diff --git a/Laptop/BobbyRMailOrder.cpp b/Laptop/BobbyRMailOrder.cpp
index ac1a4d8a..9b7b62a1 100644
--- a/Laptop/BobbyRMailOrder.cpp
+++ b/Laptop/BobbyRMailOrder.cpp
@@ -2307,7 +2307,7 @@ BOOLEAN AddNewBobbyRShipment( BobbyRayPurchaseStruct *pPurchaseStruct, UINT8 ubD
 	else
 		gpNewBobbyrShipments[ iFoundSpot ].fDisplayedInShipmentPage = FALSE;
 
-	//get the apckage weight, if the weight is "below" the minimum, use the minimum
+	//get the package weight, if the weight is "below" the minimum, use the minimum
 	if(  uiPackageWeight < MIN_SHIPPING_WEIGHT )
 	{
 		gpNewBobbyrShipments[ iFoundSpot ].uiPackageWeight = MIN_SHIPPING_WEIGHT;
diff --git a/Standard Gaming Platform/input.cpp b/Standard Gaming Platform/input.cpp
index f6c08f68..90fc312b 100644
--- a/Standard Gaming Platform/input.cpp	
+++ b/Standard Gaming Platform/input.cpp	
@@ -1601,8 +1601,6 @@ void SimulateMouseMovement( UINT32 uiNewXPos, UINT32 uiNewYPos )
 	newmouse.y = uiNewYPos;
 	ClientToScreen( ghWindow, &newmouse);
 	SetCursorPos( newmouse.x, newmouse.y);
-
-	// Does this generate a mouse move message?  I'll first try without
 }
 
 
diff --git a/Strategic/Strategic Event Handler.cpp b/Strategic/Strategic Event Handler.cpp
index 83f4f149..6d2e99cf 100644
--- a/Strategic/Strategic Event Handler.cpp	
+++ b/Strategic/Strategic Event Handler.cpp	
@@ -342,6 +342,8 @@ void BobbyRayPurchaseEventCallback( UINT8 ubOrderID )
 		SetFactFalse( FACT_PABLOS_STOLE_FROM_LATEST_SHIPMENT );
 	}
 
+	SetFactFalse( FACT_PLAYER_FOUND_ITEMS_MISSING );
+
 	SetFactFalse( FACT_LARGE_SIZED_OLD_SHIPMENT_WAITING );
 
 	if ( CheckFact( FACT_NEXT_PACKAGE_CAN_BE_DELAYED, 0 ) )
diff --git a/Tactical/Handle UI.cpp b/Tactical/Handle UI.cpp
index 3a888502..23fc6372 100644
--- a/Tactical/Handle UI.cpp	
+++ b/Tactical/Handle UI.cpp	
@@ -1,90 +1,90 @@
 #ifdef PRECOMPILEDHEADERS
-	#include "Tactical All.h"
-	#include "BuildDefines.h"
-	
+#include "Tactical All.h"
+#include "BuildDefines.h"
+
 #else
-	#include "builddefines.h"
-	#include <stdio.h>
-	#include <string.h>
-	#include "wcheck.h"
-	#include "stdlib.h"
-	#include "debug.h"
-	#include "math.h"
-	#include "jascreens.h"
-	#include "pathai.h"
-	#include "Soldier Control.h"
-	#include "Animation Control.h"
-	#include "Animation Data.h"
-	#include "Event Pump.h"
-	#include "Timer Control.h"
-	#include "mousesystem.h"
-	#include "cursors.h"
-	#include "Handle UI.h"
-	#include "Isometric Utils.h"
-	#include "input.h"    
-	#include "overhead.h"
-	#include "Sys Globals.h"
-	#include "screenids.h"
-	#include "interface.h"
-	#include "cursor control.h"
-	#include "points.h"
-	#include "Interactive Tiles.h"
-	#include "interface cursors.h"
-	#include "opplist.h"
-	#include "worldman.h"
-	#include "weapons.h"
-	#include "Sound Control.h"
-	#include "renderworld.h"
-	#include "structure.h" 
-	#include "interface panels.h"
-	#include "weapons.h"
-	#include "Handle items.h"
-	#include "UI cursors.h"
-	#include "Handle UI plan.h"
-	#include "Message.h"
-	#include "Render fun.h"
-	#include "interface items.h"
-	#include "physics.h"
-	#include "Soldier Profile.h"
-	#include "strategicmap.h"
-	#include "soldier profile.h"
-	#include "soldier create.h"
-	#include "soldier add.h"
-	#include "interface dialogue.h"
-	#include "soldier macros.h"
-	#include "soldier functions.h"
-	#include "Assignments.h"
-	#include "squads.h"
-	#include "Strategic Pathing.h"
-	#include "strategic movement.h"
-	#include "strategic.h"
-	#include "exit grids.h"
-	#include "structure wrap.h"
-	#include "soldier add.h"
-	#include "Random.h"
-	#include "english.h"
-	#include "Random.h"
-	#include "english.h"
-	#include "vehicles.h"
-	#include "messageboxscreen.h"
-	#include "text.h"
-	#include "dialogue control.h"
-	#include "line.h"
-	#include "render dirty.h"
-	#include "GameSettings.h"
-	#include "los.h"
-	#include "Campaign Types.h"
-	#include "Queen Command.h"
-	#include "Options Screen.h"
-	#include "SaveLoadGame.h"
-	#include "Spread Burst.h"
-	#include "ai.h"
-	#include "Game Clock.h"
-	#include "civ quotes.h"
-	#include "Militia Control.h"
-	#include "qarray.h"
-	#include "environment.h"
-	#include "Map Information.h"
+#include "builddefines.h"
+#include <stdio.h>
+#include <string.h>
+#include "wcheck.h"
+#include "stdlib.h"
+#include "debug.h"
+#include "math.h"
+#include "jascreens.h"
+#include "pathai.h"
+#include "Soldier Control.h"
+#include "Animation Control.h"
+#include "Animation Data.h"
+#include "Event Pump.h"
+#include "Timer Control.h"
+#include "mousesystem.h"
+#include "cursors.h"
+#include "Handle UI.h"
+#include "Isometric Utils.h"
+#include "input.h"    
+#include "overhead.h"
+#include "Sys Globals.h"
+#include "screenids.h"
+#include "interface.h"
+#include "cursor control.h"
+#include "points.h"
+#include "Interactive Tiles.h"
+#include "interface cursors.h"
+#include "opplist.h"
+#include "worldman.h"
+#include "weapons.h"
+#include "Sound Control.h"
+#include "renderworld.h"
+#include "structure.h" 
+#include "interface panels.h"
+#include "weapons.h"
+#include "Handle items.h"
+#include "UI cursors.h"
+#include "Handle UI plan.h"
+#include "Message.h"
+#include "Render fun.h"
+#include "interface items.h"
+#include "physics.h"
+#include "Soldier Profile.h"
+#include "strategicmap.h"
+#include "soldier profile.h"
+#include "soldier create.h"
+#include "soldier add.h"
+#include "interface dialogue.h"
+#include "soldier macros.h"
+#include "soldier functions.h"
+#include "Assignments.h"
+#include "squads.h"
+#include "Strategic Pathing.h"
+#include "strategic movement.h"
+#include "strategic.h"
+#include "exit grids.h"
+#include "structure wrap.h"
+#include "soldier add.h"
+#include "Random.h"
+#include "english.h"
+#include "Random.h"
+#include "english.h"
+#include "vehicles.h"
+#include "messageboxscreen.h"
+#include "text.h"
+#include "dialogue control.h"
+#include "line.h"
+#include "render dirty.h"
+#include "GameSettings.h"
+#include "los.h"
+#include "Campaign Types.h"
+#include "Queen Command.h"
+#include "Options Screen.h"
+#include "SaveLoadGame.h"
+#include "Spread Burst.h"
+#include "ai.h"
+#include "Game Clock.h"
+#include "civ quotes.h"
+#include "Militia Control.h"
+#include "qarray.h"
+#include "environment.h"
+#include "Map Information.h"
 #endif
 
 
@@ -475,7 +475,7 @@ void PreventFromTheFreezingBug(SOLDIERTYPE* pSoldier)
 {
 	gfUIInterfaceSetBusy = FALSE;
 	UnSetUIBusy( pSoldier->ubID );
-//	gTacticalStatus.ubAttackBusyCount = 0; // 0verhaul:  I know commenting this may not be a good idea, but then neither is this kludgy routine.
+	//	gTacticalStatus.ubAttackBusyCount = 0; // 0verhaul:  I know commenting this may not be a good idea, but then neither is this kludgy routine.
 	guiPendingOverrideEvent = LU_ENDUILOCK;
 	UIHandleLUIEndLock( NULL );
 }
@@ -483,258 +483,258 @@ void PreventFromTheFreezingBug(SOLDIERTYPE* pSoldier)
 // MAIN TACTICAL UI HANDLER
 UINT32  HandleTacticalUI( void )
 {
-		UINT32 ReturnVal	= GAME_SCREEN;
-		UINT32 uiNewEvent;	
-		UINT16				usMapPos;
-		LEVELNODE					*pIntTile;
-		static LEVELNODE *pOldIntTile = NULL;
+	UINT32 ReturnVal	= GAME_SCREEN;
+	UINT32 uiNewEvent;	
+	UINT16				usMapPos;
+	LEVELNODE					*pIntTile;
+	static LEVELNODE *pOldIntTile = NULL;
 
 
-		// RESET FLAGS
-		gfUIDisplayActionPoints			= FALSE;
-		gfUIDisplayActionPointsInvalid	= FALSE;
-		gfUIDisplayActionPointsBlack  	= FALSE;
-		gfUIDisplayActionPointsCenter	= FALSE;
-		gfUIDoNotHighlightSelMerc		= FALSE;
-		gfUIHandleSelection				= NO_GUY_SELECTION;
-		gfUIHandleSelectionAboveGuy		= FALSE;
-		gfUIDisplayDamage				= FALSE;
-		guiShowUPDownArrows				= ARROWS_HIDE_UP | ARROWS_HIDE_DOWN;
-		gfUIBodyHitLocation				= FALSE;
-		gfUIIntTileLocation				= FALSE;
-		gfUIIntTileLocation2			= FALSE;
-		//gfUIForceReExamineCursorData	= FALSE;
-		gfUINewStateForIntTile			= FALSE;
-		gfUIShowExitExitGrid			= FALSE;
-		gfUIOverItemPool				= FALSE;
-		gfUIHandlePhysicsTrajectory		= FALSE;
-		gfUIMouseOnValidCatcher			= FALSE;
-		gfIgnoreOnSelectedGuy           = FALSE;
-		gTintBulletCounts				= FALSE;
-		gfUIAutofireBulletCount			= FALSE;
-		gfUICtHBar						= FALSE;
+	// RESET FLAGS
+	gfUIDisplayActionPoints			= FALSE;
+	gfUIDisplayActionPointsInvalid	= FALSE;
+	gfUIDisplayActionPointsBlack  	= FALSE;
+	gfUIDisplayActionPointsCenter	= FALSE;
+	gfUIDoNotHighlightSelMerc		= FALSE;
+	gfUIHandleSelection				= NO_GUY_SELECTION;
+	gfUIHandleSelectionAboveGuy		= FALSE;
+	gfUIDisplayDamage				= FALSE;
+	guiShowUPDownArrows				= ARROWS_HIDE_UP | ARROWS_HIDE_DOWN;
+	gfUIBodyHitLocation				= FALSE;
+	gfUIIntTileLocation				= FALSE;
+	gfUIIntTileLocation2			= FALSE;
+	//gfUIForceReExamineCursorData	= FALSE;
+	gfUINewStateForIntTile			= FALSE;
+	gfUIShowExitExitGrid			= FALSE;
+	gfUIOverItemPool				= FALSE;
+	gfUIHandlePhysicsTrajectory		= FALSE;
+	gfUIMouseOnValidCatcher			= FALSE;
+	gfIgnoreOnSelectedGuy           = FALSE;
+	gTintBulletCounts				= FALSE;
+	gfUIAutofireBulletCount			= FALSE;
+	gfUICtHBar						= FALSE;
 
-		// Set old event value
-		guiOldEvent							= uiNewEvent = guiCurrentEvent;
+	// Set old event value
+	guiOldEvent							= uiNewEvent = guiCurrentEvent;
 
-		if ( gfUIInterfaceSetBusy )
+	if ( gfUIInterfaceSetBusy )
+	{
+		if ( ( GetJA2Clock( ) - guiUIInterfaceBusyTime ) > 25000 )
 		{
-			if ( ( GetJA2Clock( ) - guiUIInterfaceBusyTime ) > 25000 )
-			{
-				gfUIInterfaceSetBusy = FALSE;
+			gfUIInterfaceSetBusy = FALSE;
 
-				//UNLOCK UI
-				UnSetUIBusy( (UINT8)gusSelectedSoldier );
+			//UNLOCK UI
+			UnSetUIBusy( (UINT8)gusSelectedSoldier );
 
-				// Decrease global busy  counter...
-				gTacticalStatus.ubAttackBusyCount = 0;
-				DebugMsg( TOPIC_JA2, DBG_LEVEL_3, String("Setting attack busy count to 0 due to ending AI lock" ) );
+			// Decrease global busy  counter...
+			gTacticalStatus.ubAttackBusyCount = 0;
+			DebugMsg( TOPIC_JA2, DBG_LEVEL_3, String("Setting attack busy count to 0 due to ending AI lock" ) );
 
-				guiPendingOverrideEvent = LU_ENDUILOCK;
-				UIHandleLUIEndLock( NULL );
-			}
+			guiPendingOverrideEvent = LU_ENDUILOCK;
+			UIHandleLUIEndLock( NULL );
 		}
+	}
 
-		if ( ( GetJA2Clock( ) - guiUIInterfaceSwapCursorsTime ) > 1000 )
+	if ( ( GetJA2Clock( ) - guiUIInterfaceSwapCursorsTime ) > 1000 )
+	{
+		gfOKForExchangeCursor = !gfOKForExchangeCursor;
+		guiUIInterfaceSwapCursorsTime = GetJA2Clock( );
+	}
+
+	// OK, do a check for on an int tile...
+	pIntTile = GetCurInteractiveTile( );
+
+	if ( pIntTile != pOldIntTile )
+	{
+		gfUINewStateForIntTile = TRUE;
+
+		pOldIntTile = pIntTile;
+	}
+
+	if ( guiPendingOverrideEvent == I_DO_NOTHING )
+	{
+		// When we are here, guiCurrentEvent is set to the last event
+		// Within the input gathering phase, it may change
+
+		// GATHER INPUT
+		// Any new event will overwrite previous events. Therefore,
+		// PRIOTITIES GO LIKE THIS:
+		//						Mouse Movement
+		//						Keyboard Polling
+		//						Mouse Buttons
+		//						Keyboard Queued Events ( will override always )
+
+		// SWITCH ON INPUT GATHERING, DEPENDING ON MODE
+		// IF WE ARE NOT IN COMBAT OR IN REALTIME COMBAT
+		if ( ( gTacticalStatus.uiFlags & REALTIME ) || !( gTacticalStatus.uiFlags & INCOMBAT ) )
 		{
-			gfOKForExchangeCursor = !gfOKForExchangeCursor;
-			guiUIInterfaceSwapCursorsTime = GetJA2Clock( );
-		}
-
-		// OK, do a check for on an int tile...
-		pIntTile = GetCurInteractiveTile( );
-
-		if ( pIntTile != pOldIntTile )
-		{
-			gfUINewStateForIntTile = TRUE;
-
-			pOldIntTile = pIntTile;
-		}
-
-		if ( guiPendingOverrideEvent == I_DO_NOTHING )
-		{
-			// When we are here, guiCurrentEvent is set to the last event
-			// Within the input gathering phase, it may change
-
-			// GATHER INPUT
-			// Any new event will overwrite previous events. Therefore,
-			// PRIOTITIES GO LIKE THIS:
-			//						Mouse Movement
-			//						Keyboard Polling
-			//						Mouse Buttons
-			//						Keyboard Queued Events ( will override always )
-
-			// SWITCH ON INPUT GATHERING, DEPENDING ON MODE
-			// IF WE ARE NOT IN COMBAT OR IN REALTIME COMBAT
-			if ( ( gTacticalStatus.uiFlags & REALTIME ) || !( gTacticalStatus.uiFlags & INCOMBAT ) )
-			{
-				// FROM MOUSE POSITION
-				GetRTMousePositionInput( &uiNewEvent );
-				// FROM KEYBOARD POLLING
-				GetPolledKeyboardInput( &uiNewEvent );
-				// FROM MOUSE CLICKS
-				GetRTMouseButtonInput( &uiNewEvent );			
-				// FROM KEYBOARD
-				GetKeyboardInput( &uiNewEvent );
-
-			}
-			else
-			{
-				// FROM MOUSE POSITION
-				GetTBMousePositionInput( &uiNewEvent );
-				// FROM KEYBOARD POLLING
-				GetPolledKeyboardInput( &uiNewEvent );
-				// FROM MOUSE CLICKS
-				GetTBMouseButtonInput( &uiNewEvent );			
-				// FROM KEYBOARD
-				GetKeyboardInput( &uiNewEvent );
-			}
-
+			// FROM MOUSE POSITION
+			GetRTMousePositionInput( &uiNewEvent );
+			// FROM KEYBOARD POLLING
+			GetPolledKeyboardInput( &uiNewEvent );
+			// FROM MOUSE CLICKS
+			GetRTMouseButtonInput( &uiNewEvent );			
+			// FROM KEYBOARD
+			GetKeyboardInput( &uiNewEvent );
 
 		}
 		else
 		{
-			uiNewEvent = 	guiPendingOverrideEvent;
-			guiPendingOverrideEvent = I_DO_NOTHING;
+			// FROM MOUSE POSITION
+			GetTBMousePositionInput( &uiNewEvent );
+			// FROM KEYBOARD POLLING
+			GetPolledKeyboardInput( &uiNewEvent );
+			// FROM MOUSE CLICKS
+			GetTBMouseButtonInput( &uiNewEvent );			
+			// FROM KEYBOARD
+			GetKeyboardInput( &uiNewEvent );
 		}
 
-		if ( HandleItemPickupMenu( ) )
+
+	}
+	else
+	{
+		uiNewEvent = 	guiPendingOverrideEvent;
+		guiPendingOverrideEvent = I_DO_NOTHING;
+	}
+
+	if ( HandleItemPickupMenu( ) )
+	{
+		uiNewEvent = A_CHANGE_TO_MOVE;
+	}
+
+	// Set Current event to new one!
+	guiCurrentEvent = uiNewEvent;
+
+	//ATE: New! Get flags for over soldier or not...
+	gfUIFullTargetFound				= FALSE;
+	gfUISelectiveTargetFound		= FALSE;
+
+	if ( GetMouseMapPos( &usMapPos ) )
+	{
+		// Look for soldier full
+		if ( FindSoldier( usMapPos, &gusUIFullTargetID, &guiUIFullTargetFlags, ( FINDSOLDIERSAMELEVEL( gsInterfaceLevel ) ) ) )
 		{
-			uiNewEvent = A_CHANGE_TO_MOVE;
+			gfUIFullTargetFound = TRUE;
 		}
 
-		// Set Current event to new one!
-		guiCurrentEvent = uiNewEvent;
- 
-		//ATE: New! Get flags for over soldier or not...
-		gfUIFullTargetFound				= FALSE;
-		gfUISelectiveTargetFound		= FALSE;
-
-		if ( GetMouseMapPos( &usMapPos ) )
+		// Look for soldier selective
+		if ( FindSoldier( usMapPos, &gusUISelectiveTargetID, &guiUISelectiveTargetFlags, FINDSOLDIERSELECTIVESAMELEVEL( gsInterfaceLevel ) ) )
 		{
-			// Look for soldier full
-			if ( FindSoldier( usMapPos, &gusUIFullTargetID, &guiUIFullTargetFlags, ( FINDSOLDIERSAMELEVEL( gsInterfaceLevel ) ) ) )
-			{
-				gfUIFullTargetFound = TRUE;
-			}
-
-			// Look for soldier selective
-			if ( FindSoldier( usMapPos, &gusUISelectiveTargetID, &guiUISelectiveTargetFlags, FINDSOLDIERSELECTIVESAMELEVEL( gsInterfaceLevel ) ) )
-			{
-				gfUISelectiveTargetFound = TRUE;
-			}
-
+			gfUISelectiveTargetFound = TRUE;
 		}
 
+	}
 
-		// Check if current event has changed and clear event if so, to prepare it for execution
-		// Clearing it does things like set first time flag, param variavles, etc
-		if ( uiNewEvent != guiOldEvent )
+
+	// Check if current event has changed and clear event if so, to prepare it for execution
+	// Clearing it does things like set first time flag, param variables, etc
+	if ( uiNewEvent != guiOldEvent )
+	{
+		// Snap mouse back if it's that type
+		if ( gEvents[ guiOldEvent ].uiFlags & UIEVENT_SNAPMOUSE )
 		{
-			// Snap mouse back if it's that type
-			if ( gEvents[ guiOldEvent ].uiFlags & UIEVENT_SNAPMOUSE )
-			{
-				SimulateMouseMovement( (UINT32)gusSavedMouseX, (UINT32)gusSavedMouseY );
-			}
-
-			ClearEvent( &gEvents[ uiNewEvent ] );
+			SimulateMouseMovement( (UINT32)gusSavedMouseX, (UINT32)gusSavedMouseY );
 		}
 
-		// Restore not scrolling from stance adjust....
-		if ( gOldUIMode == ADJUST_STANCE_MODE )
-		{
-			gfIgnoreScrolling = FALSE;
-		}
+		ClearEvent( &gEvents[ uiNewEvent ] );
+	}
 
-		// IF this event is of type snap mouse, save position
-		if ( gEvents[ uiNewEvent ].uiFlags & UIEVENT_SNAPMOUSE && gEvents[ uiNewEvent ].fFirstTime )
-		{
-			 // Save mouse position
-			 gusSavedMouseX = gusMouseXPos;
-			 gusSavedMouseY = gusMouseYPos;
-		}
+	// Restore not scrolling from stance adjust....
+	if ( gOldUIMode == ADJUST_STANCE_MODE )
+	{
+		gfIgnoreScrolling = FALSE;
+	}
 
-		// HANDLE UI EVENT
-		ReturnVal = gEvents[ uiNewEvent ].HandleEvent( &( gEvents[ uiNewEvent ] ) );
-
-  	if ( gfInOpenDoorMenu )
-    {
-      return( ReturnVal );
-    }
-
-		// Set first time flag to false, now that it has been executed
-		gEvents[ uiNewEvent ].fFirstTime = FALSE;
-
-		// Check if UI mode has changed from previous event
-		if ( gEvents[ uiNewEvent ].ChangeToUIMode != gCurrentUIMode && ( gEvents[ uiNewEvent ].ChangeToUIMode != DONT_CHANGEMODE ) )
-		{			
-		  gEvents[ uiNewEvent ].uiMenuPreviousMode = gCurrentUIMode;
-
-			gOldUIMode = gCurrentUIMode;
-
-			gCurrentUIMode = gEvents[ uiNewEvent ].ChangeToUIMode;
-
-			// CHANGE MODE - DO SPECIAL THINGS IF WE ENTER THIS MODE
-			switch( gCurrentUIMode )
-			{
-				case ACTION_MODE:
-					ErasePath( TRUE );
-					break;
-			}
-
-		}
-
-		// Check if menu event is done and if so set to privious mode
-		// This is needed to hook into the interface stuff which sets the fDoneMenu flag
-		if ( gEvents[ uiNewEvent ].fDoneMenu == TRUE  )
-		{
-			if ( gCurrentUIMode == MENU_MODE || gCurrentUIMode == POPUP_MODE || gCurrentUIMode == LOOKCURSOR_MODE )
-			{
-				gCurrentUIMode = (UI_MODE) gEvents[ uiNewEvent ].uiMenuPreviousMode;
-			}
-		}
-		// Check to return to privious mode
-		// If the event is a single event, return to previous
-		if ( gEvents[ uiNewEvent ].uiFlags & UIEVENT_SINGLEEVENT )
-		{
-			// ATE: OK - don't revert to single event if our mouse is not
-			// in viewport - rather use m_on_t event
-			if ( ( gViewportRegion.uiFlags & MSYS_MOUSE_IN_AREA )  )
-			{
-				guiCurrentEvent = guiOldEvent;
-			}
-			else
-			{
-				// ATE: Check first that some modes are met....
-				if ( gCurrentUIMode != HANDCURSOR_MODE && gCurrentUIMode != LOOKCURSOR_MODE && gCurrentUIMode != TALKCURSOR_MODE )
-				{
-					guiCurrentEvent = M_ON_TERRAIN;
-				}
-			}
-		}
-
-		// Donot display APs if not in combat
-		if ( !(gTacticalStatus.uiFlags & INCOMBAT ) || (gTacticalStatus.uiFlags & REALTIME ) )
-		{
-			gfUIDisplayActionPoints = FALSE;
-		}
-
-
-		// Will set the cursor but only if different
-		SetUIMouseCursor( );
-	
-		// ATE: Check to reset selected guys....
-		if ( gTacticalStatus.fAtLeastOneGuyOnMultiSelect )
-		{
-			// If not in MOVE_MODE, CONFIRM_MOVE_MODE, RUBBERBAND_MODE, stop....
-			if ( gCurrentUIMode != MOVE_MODE && gCurrentUIMode != CONFIRM_MOVE_MODE && gCurrentUIMode != RUBBERBAND_MODE && gCurrentUIMode != ADJUST_STANCE_MODE && gCurrentUIMode != TALKCURSOR_MODE && gCurrentUIMode != LOOKCURSOR_MODE )
-			{
-				ResetMultiSelection( );
-			}
-		}
+	// IF this event is of type snap mouse, save position
+	if ( gEvents[ uiNewEvent ].uiFlags & UIEVENT_SNAPMOUSE && gEvents[ uiNewEvent ].fFirstTime )
+	{
+		// Save mouse position
+		gusSavedMouseX = gusMouseXPos;
+		gusSavedMouseY = gusMouseYPos;
+	}
 
+	// HANDLE UI EVENT
+	ReturnVal = gEvents[ uiNewEvent ].HandleEvent( &( gEvents[ uiNewEvent ] ) );
 
+	if ( gfInOpenDoorMenu )
+	{
 		return( ReturnVal );
+	}
+
+	// Set first time flag to false, now that it has been executed
+	gEvents[ uiNewEvent ].fFirstTime = FALSE;
+
+	// Check if UI mode has changed from previous event
+	if ( gEvents[ uiNewEvent ].ChangeToUIMode != gCurrentUIMode && ( gEvents[ uiNewEvent ].ChangeToUIMode != DONT_CHANGEMODE ) )
+	{			
+		gEvents[ uiNewEvent ].uiMenuPreviousMode = gCurrentUIMode;
+
+		gOldUIMode = gCurrentUIMode;
+
+		gCurrentUIMode = gEvents[ uiNewEvent ].ChangeToUIMode;
+
+		// CHANGE MODE - DO SPECIAL THINGS IF WE ENTER THIS MODE
+		switch( gCurrentUIMode )
+		{
+		case ACTION_MODE:
+			ErasePath( TRUE );
+			break;
+		}
+
+	}
+
+	// Check if menu event is done and if so set to privious mode
+	// This is needed to hook into the interface stuff which sets the fDoneMenu flag
+	if ( gEvents[ uiNewEvent ].fDoneMenu == TRUE  )
+	{
+		if ( gCurrentUIMode == MENU_MODE || gCurrentUIMode == POPUP_MODE || gCurrentUIMode == LOOKCURSOR_MODE )
+		{
+			gCurrentUIMode = (UI_MODE) gEvents[ uiNewEvent ].uiMenuPreviousMode;
+		}
+	}
+	// Check to return to privious mode
+	// If the event is a single event, return to previous
+	if ( gEvents[ uiNewEvent ].uiFlags & UIEVENT_SINGLEEVENT )
+	{
+		// ATE: OK - don't revert to single event if our mouse is not
+		// in viewport - rather use m_on_t event
+		if ( ( gViewportRegion.uiFlags & MSYS_MOUSE_IN_AREA )  )
+		{
+			guiCurrentEvent = guiOldEvent;
+		}
+		else
+		{
+			// ATE: Check first that some modes are met....
+			if ( gCurrentUIMode != HANDCURSOR_MODE && gCurrentUIMode != LOOKCURSOR_MODE && gCurrentUIMode != TALKCURSOR_MODE )
+			{
+				guiCurrentEvent = M_ON_TERRAIN;
+			}
+		}
+	}
+
+	// Donot display APs if not in combat
+	if ( !(gTacticalStatus.uiFlags & INCOMBAT ) || (gTacticalStatus.uiFlags & REALTIME ) )
+	{
+		gfUIDisplayActionPoints = FALSE;
+	}
+
+
+	// Will set the cursor but only if different
+	SetUIMouseCursor( );
+
+	// ATE: Check to reset selected guys....
+	if ( gTacticalStatus.fAtLeastOneGuyOnMultiSelect )
+	{
+		// If not in MOVE_MODE, CONFIRM_MOVE_MODE, RUBBERBAND_MODE, stop....
+		if ( gCurrentUIMode != MOVE_MODE && gCurrentUIMode != CONFIRM_MOVE_MODE && gCurrentUIMode != RUBBERBAND_MODE && gCurrentUIMode != ADJUST_STANCE_MODE && gCurrentUIMode != TALKCURSOR_MODE && gCurrentUIMode != LOOKCURSOR_MODE )
+		{
+			ResetMultiSelection( );
+		}
+	}
+
+
+	return( ReturnVal );
 }
 
 void SetUIMouseCursor( )
@@ -873,7 +873,7 @@ void SetUIMouseCursor( )
 				MSYS_RemoveRegion( &gViewportRegion );
 
 				MSYS_DefineRegion( &gViewportRegion, 0, 0 ,gsVIEWPORT_END_X, gsVIEWPORT_WINDOW_END_Y, MSYS_PRIORITY_NORMAL,
-									 VIDEO_NO_CURSOR, MSYS_NO_CALLBACK, MSYS_NO_CALLBACK );
+					VIDEO_NO_CURSOR, MSYS_NO_CALLBACK, MSYS_NO_CALLBACK );
 
 
 				// Adjust where we blit our cursor!
@@ -892,34 +892,34 @@ void SetUIMouseCursor( )
 					// Define region for viewport
 					MSYS_RemoveRegion( &gViewportRegion );
 					MSYS_DefineRegion( &gViewportRegion, 0, 0 ,gsVIEWPORT_END_X, SCREEN_HEIGHT, MSYS_PRIORITY_NORMAL,
-										 VIDEO_NO_CURSOR, MSYS_NO_CALLBACK, MSYS_NO_CALLBACK );
+						VIDEO_NO_CURSOR, MSYS_NO_CALLBACK, MSYS_NO_CALLBACK );
 
 					gsGlobalCursorYOffset = ( SCREEN_HEIGHT - gsVIEWPORT_WINDOW_END_Y );
 					SetCurrentCursorFromDatabase( gUICursors[ guiNewUICursor ].usFreeCursorName );
 
-          gfViewPortAdjustedForSouth = TRUE;
+					gfViewPortAdjustedForSouth = TRUE;
 
 				}
 			}
 		}
-    else
-    {
-      if ( gfViewPortAdjustedForSouth )
-      {
+		else
+		{
+			if ( gfViewPortAdjustedForSouth )
+			{
 				// Define region for viewport
 				MSYS_RemoveRegion( &gViewportRegion );
 
 				MSYS_DefineRegion( &gViewportRegion, 0, 0 ,gsVIEWPORT_END_X, gsVIEWPORT_WINDOW_END_Y, MSYS_PRIORITY_NORMAL,
-									 VIDEO_NO_CURSOR, MSYS_NO_CALLBACK, MSYS_NO_CALLBACK );
+					VIDEO_NO_CURSOR, MSYS_NO_CALLBACK, MSYS_NO_CALLBACK );
+
 
-	
 				// Adjust where we blit our cursor!
 				gsGlobalCursorYOffset = 0;
 				SetCurrentCursorFromDatabase( CURSOR_NORMAL );
 
-        gfViewPortAdjustedForSouth = FALSE;
-      }
-    }
+				gfViewPortAdjustedForSouth = FALSE;
+			}
+		}
 
 		if ( gfUIShowExitExitGrid )
 		{
@@ -929,7 +929,7 @@ void SetUIMouseCursor( )
 			gfUIDisplayActionPoints = FALSE;
 			ErasePath( TRUE );
 
- 		  if( GetMouseMapPos( &usMapPos) )
+			if( GetMouseMapPos( &usMapPos) )
 			{	
 				if ( gusSelectedSoldier != NOBODY && MercPtrs[ gusSelectedSoldier ]->bLevel == 0 )
 				{
@@ -1010,10 +1010,10 @@ void SetUIKeyboardHook( UIKEYBOARD_HOOK KeyboardHookFnc )
 
 void ClearEvent( UI_EVENT *pUIEvent )
 {
-	 memset( pUIEvent->uiParams, 0, sizeof( pUIEvent->uiParams ) );
-	 pUIEvent->fDoneMenu					= FALSE;
-	 pUIEvent->fFirstTime					= TRUE;
-	 pUIEvent->uiMenuPreviousMode = 0;
+	memset( pUIEvent->uiParams, 0, sizeof( pUIEvent->uiParams ) );
+	pUIEvent->fDoneMenu					= FALSE;
+	pUIEvent->fFirstTime					= TRUE;
+	pUIEvent->uiMenuPreviousMode = 0;
 
 }
 
@@ -1034,63 +1034,63 @@ UINT32 UIHandleIDoNothing( UI_EVENT *pUIEvent )
 
 UINT32 UIHandleExit( UI_EVENT *pUIEvent )
 {
-  gfProgramIsRunning = FALSE;
+	gfProgramIsRunning = FALSE;
 	return( GAME_SCREEN );
 }
 
 UINT32 UIHandleNewMerc( UI_EVENT *pUIEvent )
 {
-	 static UINT8				ubTemp = 3;
-	 UINT16							usMapPos;
-   static INT32       iSoldierCount=0;     
-	 MERC_HIRE_STRUCT HireMercStruct;
-	 INT8		bReturnCode;
-	 SOLDIERTYPE *pSoldier;
+	static UINT8				ubTemp = 3;
+	UINT16							usMapPos;
+	static INT32       iSoldierCount=0;     
+	MERC_HIRE_STRUCT HireMercStruct;
+	INT8		bReturnCode;
+	SOLDIERTYPE *pSoldier;
 
 
-	 // Get Grid Corrdinates of mouse
- 	 if( GetMouseMapPos( &usMapPos) )
-	 {		 
-		 ubTemp+= 2;
+	// Get Grid Corrdinates of mouse
+	if( GetMouseMapPos( &usMapPos) )
+	{		 
+		ubTemp+= 2;
 
-			memset( &HireMercStruct, 0, sizeof(MERC_HIRE_STRUCT));
+		memset( &HireMercStruct, 0, sizeof(MERC_HIRE_STRUCT));
 
-			HireMercStruct.ubProfileID = ubTemp;
+		HireMercStruct.ubProfileID = ubTemp;
 
-			//DEF: temp
-			HireMercStruct.sSectorX = gWorldSectorX;
-			HireMercStruct.sSectorY = gWorldSectorY;
-			HireMercStruct.bSectorZ = gbWorldSectorZ;
-			HireMercStruct.ubInsertionCode	= INSERTION_CODE_GRIDNO;
-			HireMercStruct.usInsertionData	= usMapPos;
-			HireMercStruct.fCopyProfileItemsOver = TRUE;
-			HireMercStruct.iTotalContractLength = 7;
+		//DEF: temp
+		HireMercStruct.sSectorX = gWorldSectorX;
+		HireMercStruct.sSectorY = gWorldSectorY;
+		HireMercStruct.bSectorZ = gbWorldSectorZ;
+		HireMercStruct.ubInsertionCode	= INSERTION_CODE_GRIDNO;
+		HireMercStruct.usInsertionData	= usMapPos;
+		HireMercStruct.fCopyProfileItemsOver = TRUE;
+		HireMercStruct.iTotalContractLength = 7;
 
-			//specify when the merc should arrive
-			HireMercStruct.uiTimeTillMercArrives = 0;
+		//specify when the merc should arrive
+		HireMercStruct.uiTimeTillMercArrives = 0;
 
-			//if we succesfully hired the merc
-			bReturnCode = HireMerc( &HireMercStruct );
+		//if we succesfully hired the merc
+		bReturnCode = HireMerc( &HireMercStruct );
 
-			if( bReturnCode == MERC_HIRE_FAILED )
-			{
-				ScreenMsg( FONT_ORANGE, MSG_BETAVERSION, L"Merc hire failed:  Either already hired or dislikes you." );
-			}
-			else if( bReturnCode == MERC_HIRE_OVER_18_MERCS_HIRED )
-			{
-				ScreenMsg( FONT_ORANGE, MSG_BETAVERSION, L"Can't hire more than 18 mercs." );
-			}
-			else
-			{
-				// Get soldier from profile
-				pSoldier = FindSoldierByProfileID( ubTemp, FALSE );
+		if( bReturnCode == MERC_HIRE_FAILED )
+		{
+			ScreenMsg( FONT_ORANGE, MSG_BETAVERSION, L"Merc hire failed:  Either already hired or dislikes you." );
+		}
+		else if( bReturnCode == MERC_HIRE_OVER_18_MERCS_HIRED )
+		{
+			ScreenMsg( FONT_ORANGE, MSG_BETAVERSION, L"Can't hire more than 18 mercs." );
+		}
+		else
+		{
+			// Get soldier from profile
+			pSoldier = FindSoldierByProfileID( ubTemp, FALSE );
 
-				MercArrivesCallback( pSoldier->ubID );
-				SelectSoldier( pSoldier->ubID, FALSE, TRUE );
-			}
+			MercArrivesCallback( pSoldier->ubID );
+			SelectSoldier( pSoldier->ubID, FALSE, TRUE );
+		}
 
-	 }
-	 return( GAME_SCREEN );
+	}
+	return( GAME_SCREEN );
 }
 
 UINT32 UIHandleNewBadMerc( UI_EVENT *pUIEvent )
@@ -1124,9 +1124,9 @@ UINT32 UIHandleNewBadMerc( UI_EVENT *pUIEvent )
 				SECTORINFO *pSector = &SectorInfo[ SECTOR( gWorldSectorX, gWorldSectorY ) ];
 				switch( pSoldier->ubSoldierClass )
 				{
-					case SOLDIER_CLASS_ADMINISTRATOR:	pSector->ubNumAdmins++; pSector->ubAdminsInBattle++; break;
-					case SOLDIER_CLASS_ARMY:					pSector->ubNumTroops++; pSector->ubTroopsInBattle++; break;
-					case SOLDIER_CLASS_ELITE:					pSector->ubNumElites++; pSector->ubElitesInBattle++; break;
+				case SOLDIER_CLASS_ADMINISTRATOR:	pSector->ubNumAdmins++; pSector->ubAdminsInBattle++; break;
+				case SOLDIER_CLASS_ARMY:					pSector->ubNumTroops++; pSector->ubTroopsInBattle++; break;
+				case SOLDIER_CLASS_ELITE:					pSector->ubNumElites++; pSector->ubElitesInBattle++; break;
 				}
 			}
 			else
@@ -1136,13 +1136,13 @@ UINT32 UIHandleNewBadMerc( UI_EVENT *pUIEvent )
 				{
 					switch( pSoldier->ubSoldierClass )
 					{
-						case SOLDIER_CLASS_ADMINISTRATOR:	pSector->ubNumAdmins++; pSector->ubAdminsInBattle++; break;
-						case SOLDIER_CLASS_ARMY:					pSector->ubNumTroops++; pSector->ubTroopsInBattle++; break;
-						case SOLDIER_CLASS_ELITE:					pSector->ubNumElites++; pSector->ubElitesInBattle++; break;
+					case SOLDIER_CLASS_ADMINISTRATOR:	pSector->ubNumAdmins++; pSector->ubAdminsInBattle++; break;
+					case SOLDIER_CLASS_ARMY:					pSector->ubNumTroops++; pSector->ubTroopsInBattle++; break;
+					case SOLDIER_CLASS_ELITE:					pSector->ubNumElites++; pSector->ubElitesInBattle++; break;
 					}
 				}
 			}
-			
+
 			pSoldier->ubStrategicInsertionCode = INSERTION_CODE_GRIDNO;
 			pSoldier->usStrategicInsertionData = usMapPos;
 			UpdateMercInSector( pSoldier, gWorldSectorX, gWorldSectorY, gbWorldSectorZ );
@@ -1155,12 +1155,12 @@ UINT32 UIHandleNewBadMerc( UI_EVENT *pUIEvent )
 
 UINT32 UIHandleEnterEditMode( UI_EVENT *pUIEvent )
 {
-		return( EDIT_SCREEN );
+	return( EDIT_SCREEN );
 }
 
 UINT32 UIHandleEnterPalEditMode( UI_EVENT *pUIEvent )
 {
-		return( PALEDIT_SCREEN );
+	return( PALEDIT_SCREEN );
 }
 
 
@@ -1238,7 +1238,7 @@ UINT32 UIHandleTestHit( UI_EVENT *pUIEvent )
 
 		// gTacticalStatus.ubAttackBusyCount++;
 		DebugAttackBusy( "Testing a hit.\n" );
-		 EVENT_SoldierGotHit( pSoldier, 1, bDamage, 10, pSoldier->bDirection, 320, NOBODY , FIRE_WEAPON_NO_SPECIAL, pSoldier->bAimShotLocation, 0, NOWHERE );
+		EVENT_SoldierGotHit( pSoldier, 1, bDamage, 10, pSoldier->bDirection, 320, NOBODY , FIRE_WEAPON_NO_SPECIAL, pSoldier->bAimShotLocation, 0, NOWHERE );
 		// callahan update end - put everything as it was
 	}
 	return( GAME_SCREEN );
@@ -1271,7 +1271,7 @@ void ChangeInterfaceLevel( INT16 sLevel )
 	// Remove any interactive tiles we could be over!
 	BeginCurInteractiveTileCheck( INTILE_CHECK_SELECTIVE );
 	gfPlotNewMovement = TRUE;
-  ErasePath(FALSE);
+	ErasePath(FALSE);
 }
 
 
@@ -1299,15 +1299,15 @@ UINT32 UIHandleSelectMerc( UI_EVENT *pUIEvent )
 	// Get merc index at mouse and set current selection
 	if ( gfUIFullTargetFound )
 	{
-		 iCurrentSquad = CurrentSquad( );
+		iCurrentSquad = CurrentSquad( );
 
-		 InternalSelectSoldier( gusUIFullTargetID, TRUE, FALSE, TRUE );
+		InternalSelectSoldier( gusUIFullTargetID, TRUE, FALSE, TRUE );
 
-		 // If different, display message
-		 if ( CurrentSquad( ) != iCurrentSquad )
-		 {
-				ScreenMsg( FONT_MCOLOR_LTYELLOW, MSG_INTERFACE, pMessageStrings[ MSG_SQUAD_ACTIVE ], ( CurrentSquad( ) + 1 ) );
-		 }
+		// If different, display message
+		if ( CurrentSquad( ) != iCurrentSquad )
+		{
+			ScreenMsg( FONT_MCOLOR_LTYELLOW, MSG_INTERFACE, pMessageStrings[ MSG_SQUAD_ACTIVE ], ( CurrentSquad( ) + 1 ) );
+		}
 	}
 
 	return( GAME_SCREEN );
@@ -1355,77 +1355,77 @@ UINT32 UIHandleMOnTerrain( UI_EVENT *pUIEvent )
 	// CHECK IF WE'RE ON A GUY ( EITHER SELECTED, OURS, OR THEIRS
 	if ( !UIHandleOnMerc( TRUE ) )
 	{
-		 // Are we over items...
-		 if ( GetItemPool( usMapPos, &pItemPool, (UINT8)gsInterfaceLevel ) && ITEMPOOL_VISIBLE( pItemPool ) )
-		 {
-				// Are we already in...
-			  if ( fOverItems )
+		// Are we over items...
+		if ( GetItemPool( usMapPos, &pItemPool, (UINT8)gsInterfaceLevel ) && ITEMPOOL_VISIBLE( pItemPool ) )
+		{
+			// Are we already in...
+			if ( fOverItems )
+			{
+				// Is this the same level & gridno...
+				if ( gsInterfaceLevel == (INT16)bLevelForItemsOver && usMapPos == sGridNoForItemsOver )
 				{
-					// Is this the same level & gridno...
-					if ( gsInterfaceLevel == (INT16)bLevelForItemsOver && usMapPos == sGridNoForItemsOver )
+					// Check timer...
+					if ( ( GetJA2Clock( ) - uiItemsOverTimer ) > 1500 )
 					{
-						// Check timer...
-						if ( ( GetJA2Clock( ) - uiItemsOverTimer ) > 1500 )
-						{
-							// Change to hand curso mode
-							guiPendingOverrideEvent = M_CHANGE_TO_HANDMODE;
-							gsOverItemsGridNo				= usMapPos;
-							gsOverItemsLevel				= gsInterfaceLevel;
-							fOverItems = FALSE;
-						}
-					}
-					else
-					{
-						uiItemsOverTimer = GetJA2Clock( );
-						bLevelForItemsOver = (INT8)gsInterfaceLevel;
-						sGridNoForItemsOver = usMapPos;
+						// Change to hand curso mode
+						guiPendingOverrideEvent = M_CHANGE_TO_HANDMODE;
+						gsOverItemsGridNo				= usMapPos;
+						gsOverItemsLevel				= gsInterfaceLevel;
+						fOverItems = FALSE;
 					}
 				}
 				else
 				{
-					fOverItems = TRUE;
-
 					uiItemsOverTimer = GetJA2Clock( );
 					bLevelForItemsOver = (INT8)gsInterfaceLevel;
 					sGridNoForItemsOver = usMapPos;
 				}
-		 }
-		 else
-		 {
+			}
+			else
+			{
+				fOverItems = TRUE;
+
+				uiItemsOverTimer = GetJA2Clock( );
+				bLevelForItemsOver = (INT8)gsInterfaceLevel;
+				sGridNoForItemsOver = usMapPos;
+			}
+		}
+		else
+		{
 			fOverItems = FALSE;
-		 }
+		}
 
 
-		 if ( GetSoldier( &pSoldier, gusSelectedSoldier ) )
-		 {
-   
-       if ( pSoldier->sGridNo == NOWHERE )
-       {
-          int i = 0;
-       }
+		if ( GetSoldier( &pSoldier, gusSelectedSoldier ) )
+		{
 
-			 if ( GetExitGrid( usMapPos, &ExitGrid ) && pSoldier->bLevel == 0 )
-			 {
-				 gfUIShowExitExitGrid = TRUE;
-			 }
+			if ( pSoldier->sGridNo == NOWHERE )
+			{
+				int i = 0;
+			}
 
-			 // ATE: Draw invalidc cursor if heights different
-			 if ( gpWorldLevelData[ usMapPos ].sHeight != gpWorldLevelData[ pSoldier->sGridNo ].sHeight )
-			 {
-					// ERASE PATH
-					ErasePath( TRUE );
+			if ( GetExitGrid( usMapPos, &ExitGrid ) && pSoldier->bLevel == 0 )
+			{
+				gfUIShowExitExitGrid = TRUE;
+			}
 
-					guiNewUICursor = FLOATING_X_UICURSOR;				
+			// ATE: Draw invalidc cursor if heights different
+			if ( gpWorldLevelData[ usMapPos ].sHeight != gpWorldLevelData[ pSoldier->sGridNo ].sHeight )
+			{
+				// ERASE PATH
+				ErasePath( TRUE );
 
-					return( GAME_SCREEN );
-			 }
-		 }
+				guiNewUICursor = FLOATING_X_UICURSOR;				
 
-		 // DO SOME CURSOR POSITION FLAGS SETTING
-		 GetCursorMovementFlags( &uiCursorFlags );
+				return( GAME_SCREEN );
+			}
+		}
 
-		 if ( gusSelectedSoldier != NO_SOLDIER )
-		 {
+		// DO SOME CURSOR POSITION FLAGS SETTING
+		GetCursorMovementFlags( &uiCursorFlags );
+
+		if ( gusSelectedSoldier != NO_SOLDIER )
+		{
 			// Get Soldier Pointer
 			GetSoldier( &pSoldier, gusSelectedSoldier );
 
@@ -1437,23 +1437,23 @@ UINT32 UIHandleMOnTerrain( UI_EVENT *pUIEvent )
 			// THIS IS JUST A CRUDE TEST FOR NOW
 			if ( pSoldier->bLife < OKLIFE )
 			{
-        UINT8 ubID;
+				UINT8 ubID;
 				// Show reg. cursor
 				// GO INTO IDLE MODE
 				// guiPendingOverrideEvent = I_CHANGE_TO_IDLE;
 				// gusSelectedSoldier = NO_SOLDIER;	
-      	ubID = FindNextActiveAndAliveMerc( pSoldier, FALSE, FALSE ); 
+				ubID = FindNextActiveAndAliveMerc( pSoldier, FALSE, FALSE ); 
 
-        if ( ubID != NOBODY )
-        {
-        	SelectSoldier( (INT16)ubID, FALSE, FALSE );
-        }
-        else
-        {
-		      gusSelectedSoldier = NO_SOLDIER;
-		      // Change UI mode to reflact that we are selected
-		      guiPendingOverrideEvent = I_ON_TERRAIN;
-        }
+				if ( ubID != NOBODY )
+				{
+					SelectSoldier( (INT16)ubID, FALSE, FALSE );
+				}
+				else
+				{
+					gusSelectedSoldier = NO_SOLDIER;
+					// Change UI mode to reflact that we are selected
+					guiPendingOverrideEvent = I_ON_TERRAIN;
+				}
 			}
 			else if ( ( UIOKMoveDestination( pSoldier, usMapPos ) != 1 ) && pIntNode == NULL )
 			{
@@ -1508,7 +1508,7 @@ UINT32 UIHandleMOnTerrain( UI_EVENT *pUIEvent )
 
 
 	{
-								
+
 		//if ( fSetCursor && guiNewUICursor != ENTER_VEHICLE_UICURSOR )
 		if ( fSetCursor && !gfBeginVehicleCursor )
 		{
@@ -1533,81 +1533,81 @@ UINT32 UIHandleMovementMenu( UI_EVENT *pUIEvent )
 	// Popup Menu
 	if ( pUIEvent->fFirstTime )
 	{
-		 //Pop-up menu
-		 PopupMovementMenu( pUIEvent );
+		//Pop-up menu
+		PopupMovementMenu( pUIEvent );
 
-		 // Change cusror to normal
-		 guiNewUICursor = NORMAL_FREEUICURSOR;
+		// Change cusror to normal
+		guiNewUICursor = NORMAL_FREEUICURSOR;
 
 	}
 
 	// Check for done flag
 	if ( pUIEvent->fDoneMenu )
 	{
-			PopDownMovementMenu( );
-			
-			// Excecute command, if user hit a button
-			if ( pUIEvent->uiParams[1] == TRUE )
+		PopDownMovementMenu( );
+
+		// Excecute command, if user hit a button
+		if ( pUIEvent->uiParams[1] == TRUE )
+		{
+			if ( pUIEvent->uiParams[ 2 ] == MOVEMENT_MENU_LOOK )
 			{
-				if ( pUIEvent->uiParams[ 2 ] == MOVEMENT_MENU_LOOK )
-				{
-					guiPendingOverrideEvent = LC_CHANGE_TO_LOOK;
-				}
-				else if ( pUIEvent->uiParams[ 2 ] == MOVEMENT_MENU_HAND )
-				{
-					guiPendingOverrideEvent = HC_ON_TERRAIN;
-				}
-				else if ( pUIEvent->uiParams[ 2 ] == MOVEMENT_MENU_ACTIONC )
-				{
-					guiPendingOverrideEvent = M_CHANGE_TO_ACTION;
-				}
-				else if ( pUIEvent->uiParams[ 2 ] == MOVEMENT_MENU_TALK )
-				{
-					guiPendingOverrideEvent = T_CHANGE_TO_TALKING;
-				}
-				else
-				{
-					// Change stance based on params!
-					switch( pUIEvent->uiParams[ 0 ] )
-					{
-						case MOVEMENT_MENU_RUN:
-
-							if ( pSoldier->usUIMovementMode != WALKING && pSoldier->usUIMovementMode != RUNNING )
-							{
-								UIHandleSoldierStanceChange( pSoldier->ubID, ANIM_STAND );
-								pSoldier->fUIMovementFast = 1;
-							}
-							else
-							{
-								 pSoldier->fUIMovementFast = 1;
-								 pSoldier->usUIMovementMode = RUNNING;
-								 gfPlotNewMovement = TRUE;
-							}
-							break;
-
-						case MOVEMENT_MENU_WALK:
-
-							UIHandleSoldierStanceChange( pSoldier->ubID, ANIM_STAND );
-							break;
-
-						case MOVEMENT_MENU_SWAT:
-
-							UIHandleSoldierStanceChange( pSoldier->ubID, ANIM_CROUCH );
-							break;
-
-						case MOVEMENT_MENU_PRONE:
-
-							UIHandleSoldierStanceChange( pSoldier->ubID, ANIM_PRONE );
-							break;
-							
-					}
-				
-					guiPendingOverrideEvent = A_CHANGE_TO_MOVE;
-
-					//pSoldier->usUIMovementMode = (INT8)pUIEvent->uiParams[ 0 ];
-				}
-
+				guiPendingOverrideEvent = LC_CHANGE_TO_LOOK;
 			}
+			else if ( pUIEvent->uiParams[ 2 ] == MOVEMENT_MENU_HAND )
+			{
+				guiPendingOverrideEvent = HC_ON_TERRAIN;
+			}
+			else if ( pUIEvent->uiParams[ 2 ] == MOVEMENT_MENU_ACTIONC )
+			{
+				guiPendingOverrideEvent = M_CHANGE_TO_ACTION;
+			}
+			else if ( pUIEvent->uiParams[ 2 ] == MOVEMENT_MENU_TALK )
+			{
+				guiPendingOverrideEvent = T_CHANGE_TO_TALKING;
+			}
+			else
+			{
+				// Change stance based on params!
+				switch( pUIEvent->uiParams[ 0 ] )
+				{
+				case MOVEMENT_MENU_RUN:
+
+					if ( pSoldier->usUIMovementMode != WALKING && pSoldier->usUIMovementMode != RUNNING )
+					{
+						UIHandleSoldierStanceChange( pSoldier->ubID, ANIM_STAND );
+						pSoldier->fUIMovementFast = 1;
+					}
+					else
+					{
+						pSoldier->fUIMovementFast = 1;
+						pSoldier->usUIMovementMode = RUNNING;
+						gfPlotNewMovement = TRUE;
+					}
+					break;
+
+				case MOVEMENT_MENU_WALK:
+
+					UIHandleSoldierStanceChange( pSoldier->ubID, ANIM_STAND );
+					break;
+
+				case MOVEMENT_MENU_SWAT:
+
+					UIHandleSoldierStanceChange( pSoldier->ubID, ANIM_CROUCH );
+					break;
+
+				case MOVEMENT_MENU_PRONE:
+
+					UIHandleSoldierStanceChange( pSoldier->ubID, ANIM_PRONE );
+					break;
+
+				}
+
+				guiPendingOverrideEvent = A_CHANGE_TO_MOVE;
+
+				//pSoldier->usUIMovementMode = (INT8)pUIEvent->uiParams[ 0 ];
+			}
+
+		}
 	}
 
 	return( GAME_SCREEN );
@@ -1625,8 +1625,8 @@ UINT32 UIHandleAOnTerrain( UI_EVENT *pUIEvent )
 {
 	UINT16						usMapPos;
 	SOLDIERTYPE				*pSoldier;
-//	INT16							sTargetXPos, sTargetYPos;
-	 DebugMsg(TOPIC_JA2,DBG_LEVEL_3,String("UIHandleAOnTerrain"));
+	//	INT16							sTargetXPos, sTargetYPos;
+	DebugMsg(TOPIC_JA2,DBG_LEVEL_3,String("UIHandleAOnTerrain"));
 
 	if( !GetMouseMapPos( &usMapPos) )
 	{
@@ -1641,78 +1641,78 @@ UINT32 UIHandleAOnTerrain( UI_EVENT *pUIEvent )
 	// Get soldier to determine range
 	if ( GetSoldier( &pSoldier, gusSelectedSoldier ) )
 	{
-		 // ATE: Add stuff here to display a system message if we are targeting smeothing and
-		 //  are out of range.
-		 // Are we using a gun?
-		 if ( GetActionModeCursor( pSoldier ) == TARGETCURS )
-		 {
-			 SetActionModeDoorCursorText( );
+		// ATE: Add stuff here to display a system message if we are targeting smeothing and
+		//  are out of range.
+		// Are we using a gun?
+		if ( GetActionModeCursor( pSoldier ) == TARGETCURS )
+		{
+			SetActionModeDoorCursorText( );
 
-			 // Yep, she's a gun.
-			 // Are we in range?
-			 if ( !InRange( pSoldier, usMapPos ) )
-			 {
-				 // Are we over a guy?
-				 if ( gfUIFullTargetFound )
-				 {
-						// No, ok display message IF this is the first time at this gridno
-						if ( gsOutOfRangeGridNo != MercPtrs[ gusUIFullTargetID ]->sGridNo || gubOutOfRangeMerc != gusSelectedSoldier )
-						{
-							// Display
-							ScreenMsg( FONT_MCOLOR_LTYELLOW, MSG_INTERFACE, TacticalStr[ OUT_OF_RANGE_STRING ] );
-
-             //PlayJA2Sample( TARGET_OUT_OF_RANGE, RATE_11025, MIDVOLUME, 1, MIDDLEPAN );			              
-
-							// Set
-							gsOutOfRangeGridNo = MercPtrs[ gusUIFullTargetID ]->sGridNo;
-							gubOutOfRangeMerc  = (UINT8)gusSelectedSoldier;
-						}
-				 }
-			 }
-
-		 }
-
-	   guiNewUICursor = GetProperItemCursor( (UINT8)gusSelectedSoldier, pSoldier->inv[ HANDPOS ].usItem, usMapPos, FALSE );
-
-		  // Show UI ON GUY
-		  UIHandleOnMerc( FALSE );
-
-			// If we are in realtime, and in a stationary animation, follow!
-			if ( ( gTacticalStatus.uiFlags & REALTIME ) || !( gTacticalStatus.uiFlags & INCOMBAT ) )
+			// Yep, she's a gun.
+			// Are we in range?
+			if ( !InRange( pSoldier, usMapPos ) )
 			{
-				if ( gAnimControl[ pSoldier->usAnimState ].uiFlags & ANIM_STATIONARY && pSoldier->ubPendingAction == NO_PENDING_ACTION )
-				{				
-					 // Check if we have a shot waiting!
-					 if ( gUITargetShotWaiting )
-					 {
-							guiPendingOverrideEvent = CA_MERC_SHOOT;
-					 }
-
-					 if ( !gUITargetReady )
-					 {				
-							// Move to proper stance + direction!
-							// Convert our grid-not into an XY
-						//	ConvertGridNoToXY( usMapPos, &sTargetXPos, &sTargetYPos );
-
-							// Ready weapon
-					//		SoldierReadyWeapon( pSoldier, sTargetXPos, sTargetYPos, FALSE );
-
-							gUITargetReady = TRUE;
-					 }
-
-		
-
-				}
-				else
+				// Are we over a guy?
+				if ( gfUIFullTargetFound )
 				{
-					gUITargetReady = FALSE;
+					// No, ok display message IF this is the first time at this gridno
+					if ( gsOutOfRangeGridNo != MercPtrs[ gusUIFullTargetID ]->sGridNo || gubOutOfRangeMerc != gusSelectedSoldier )
+					{
+						// Display
+						ScreenMsg( FONT_MCOLOR_LTYELLOW, MSG_INTERFACE, TacticalStr[ OUT_OF_RANGE_STRING ] );
+
+						//PlayJA2Sample( TARGET_OUT_OF_RANGE, RATE_11025, MIDVOLUME, 1, MIDDLEPAN );			              
+
+						// Set
+						gsOutOfRangeGridNo = MercPtrs[ gusUIFullTargetID ]->sGridNo;
+						gubOutOfRangeMerc  = (UINT8)gusSelectedSoldier;
+					}
 				}
 			}
 
+		}
+
+		guiNewUICursor = GetProperItemCursor( (UINT8)gusSelectedSoldier, pSoldier->inv[ HANDPOS ].usItem, usMapPos, FALSE );
+
+		// Show UI ON GUY
+		UIHandleOnMerc( FALSE );
+
+		// If we are in realtime, and in a stationary animation, follow!
+		if ( ( gTacticalStatus.uiFlags & REALTIME ) || !( gTacticalStatus.uiFlags & INCOMBAT ) )
+		{
+			if ( gAnimControl[ pSoldier->usAnimState ].uiFlags & ANIM_STATIONARY && pSoldier->ubPendingAction == NO_PENDING_ACTION )
+			{				
+				// Check if we have a shot waiting!
+				if ( gUITargetShotWaiting )
+				{
+					guiPendingOverrideEvent = CA_MERC_SHOOT;
+				}
+
+				if ( !gUITargetReady )
+				{				
+					// Move to proper stance + direction!
+					// Convert our grid-not into an XY
+					//	ConvertGridNoToXY( usMapPos, &sTargetXPos, &sTargetYPos );
+
+					// Ready weapon
+					//		SoldierReadyWeapon( pSoldier, sTargetXPos, sTargetYPos, FALSE );
+
+					gUITargetReady = TRUE;
+				}
+
+
+
+			}
+			else
+			{
+				gUITargetReady = FALSE;
+			}
+		}
+
 
 	}
 
-	
+
 	return( GAME_SCREEN );
 
 }
@@ -1724,7 +1724,7 @@ UINT32 UIHandleMChangeToAction( UI_EVENT *pUIEvent )
 	EndPhysicsTrajectoryUI( );
 
 	//guiNewUICursor = CONFIRM_MOVE_UICURSOR;
- 
+
 	return( GAME_SCREEN );
 }
 
@@ -1737,15 +1737,15 @@ UINT32 UIHandleMChangeToHandMode( UI_EVENT *pUIEvent )
 
 UINT32 UIHandleAChangeToMove( UI_EVENT *pUIEvent )
 {
-	 // Set merc glow back to normal
-	 // ( could have been set when in target cursor )
-	 SetMercGlowNormal( );
+	// Set merc glow back to normal
+	// ( could have been set when in target cursor )
+	SetMercGlowNormal( );
 
-	 // gsOutOfRangeGridNo = NOWHERE;
+	// gsOutOfRangeGridNo = NOWHERE;
 
-	 gfPlotNewMovement = TRUE;
+	gfPlotNewMovement = TRUE;
 
-	 return( GAME_SCREEN );
+	return( GAME_SCREEN );
 }
 
 UINT32 UIHandleCWait( UI_EVENT *pUIEvent )
@@ -1763,52 +1763,52 @@ UINT32 UIHandleCWait( UI_EVENT *pUIEvent )
 
 	if ( GetSoldier( &pSoldier, gusSelectedSoldier )  )
 	{
-			pInvTile = GetCurInteractiveTile( );
+		pInvTile = GetCurInteractiveTile( );
 
-			if ( pInvTile && gpInvTileThatCausedMoveConfirm != pInvTile )
+		if ( pInvTile && gpInvTileThatCausedMoveConfirm != pInvTile )
+		{
+			// Get out og this mode...
+			guiPendingOverrideEvent = A_CHANGE_TO_MOVE;
+			return( GAME_SCREEN );
+		}
+
+		GetCursorMovementFlags( &uiCursorFlags );
+
+		if ( pInvTile != NULL )
+		{
+
+			fSetCursor =  HandleUIMovementCursor( pSoldier, uiCursorFlags, usMapPos, MOVEUI_TARGET_INTTILES );
+
+			//Set UI CURSOR
+			guiNewUICursor = GetInteractiveTileCursor( guiNewUICursor, TRUE  );
+
+			// Make red tile under spot... if we've previously found one...
+			if ( gfUIHandleShowMoveGrid )
 			{
-				// Get out og this mode...
-				guiPendingOverrideEvent = A_CHANGE_TO_MOVE;
-				return( GAME_SCREEN );
+				gfUIHandleShowMoveGrid = 2;
 			}
 
-			GetCursorMovementFlags( &uiCursorFlags );
 
-			if ( pInvTile != NULL )
-			{
+			return( GAME_SCREEN );
+		}
 
-				fSetCursor =  HandleUIMovementCursor( pSoldier, uiCursorFlags, usMapPos, MOVEUI_TARGET_INTTILES );
+		// Display action points
+		gfUIDisplayActionPoints = TRUE;
 
-				//Set UI CURSOR
-				guiNewUICursor = GetInteractiveTileCursor( guiNewUICursor, TRUE  );
+		// Determine if we can afford!
+		if ( !EnoughPoints( pSoldier, gsCurrentActionPoints, 0, FALSE ) )
+		{  
+			gfUIDisplayActionPointsInvalid = TRUE;
+		}
 
-				// Make red tile under spot... if we've previously found one...
-				if ( gfUIHandleShowMoveGrid )
-				{
-					gfUIHandleShowMoveGrid = 2;
-				}
+		SetConfirmMovementModeCursor( pSoldier, FALSE );
 
-
-				return( GAME_SCREEN );
-			}
-
-		  // Display action points
-		  gfUIDisplayActionPoints = TRUE;
-
-		  // Determine if we can afford!
-		  if ( !EnoughPoints( pSoldier, gsCurrentActionPoints, 0, FALSE ) )
-			{  
-			  gfUIDisplayActionPointsInvalid = TRUE;
-			}
-
-		  SetConfirmMovementModeCursor( pSoldier, FALSE );
-
-			// If we are not in combat, draw path here!
-			if ( (gTacticalStatus.uiFlags & REALTIME ) || !(gTacticalStatus.uiFlags & INCOMBAT ) )
-			{
-				//DrawUIMovementPath( pSoldier, usMapPos,  0 );
-				fSetCursor =  HandleUIMovementCursor( pSoldier, uiCursorFlags, usMapPos, 0 );
-			}
+		// If we are not in combat, draw path here!
+		if ( (gTacticalStatus.uiFlags & REALTIME ) || !(gTacticalStatus.uiFlags & INCOMBAT ) )
+		{
+			//DrawUIMovementPath( pSoldier, usMapPos,  0 );
+			fSetCursor =  HandleUIMovementCursor( pSoldier, uiCursorFlags, usMapPos, 0 );
+		}
 
 	}
 
@@ -1825,18 +1825,18 @@ UINT32 UIHandleCMoveMerc( UI_EVENT *pUIEvent )
 	INT16							sDestGridNo;
 	INT16							sActionGridNo;
 	STRUCTURE					*pStructure;
-	UINT8							ubDirection;
+	UINT8							ubDirection = 0xff;
 	BOOLEAN						fAllMove;
 	INT8							bLoop;
 	LEVELNODE					*pIntTile;
 	INT16							sIntTileGridNo;
 	BOOLEAN						fOldFastMove;
-						
+
 	if ( gusSelectedSoldier != NO_SOLDIER )
 	{
 		fAllMove = gfUIAllMoveOn;
 		gfUIAllMoveOn = FALSE;
-					
+
 		if( !GetMouseMapPos( &usMapPos) )
 		{
 			return( GAME_SCREEN );
@@ -1855,14 +1855,14 @@ UINT32 UIHandleCMoveMerc( UI_EVENT *pUIEvent )
 			{
 				if ( OK_CONTROLLABLE_MERC( pSoldier ) && pSoldier->bAssignment == CurrentSquad( ) && !pSoldier->fMercAsleep )
 				{	
-	        // If we can't be controlled, returninvalid...
-	        if ( pSoldier->uiStatusFlags & SOLDIER_ROBOT )
-	        {
-		        if ( !CanRobotBeControlled( pSoldier ) )
-            {
-              continue;
-            }
-          }
+					// If we can't be controlled, returninvalid...
+					if ( pSoldier->uiStatusFlags & SOLDIER_ROBOT )
+					{
+						if ( !CanRobotBeControlled( pSoldier ) )
+						{
+							continue;
+						}
+					}
 
 					AdjustNoAPToFinishMove( pSoldier, FALSE );
 
@@ -1942,9 +1942,9 @@ UINT32 UIHandleCMoveMerc( UI_EVENT *pUIEvent )
 						// check if we are at this location
 						if ( pSoldier->sGridNo == sDestGridNo )
 						{
-				 			 StartInteractiveObject( sIntTileGridNo, pStructure->usStructureID, pSoldier, ubDirection );
-							 InteractWithInteractiveObject( pSoldier, pStructure, ubDirection );
-							 return( GAME_SCREEN );
+							StartInteractiveObject( sIntTileGridNo, pStructure->usStructureID, pSoldier, ubDirection );
+							InteractWithInteractiveObject( pSoldier, pStructure, ubDirection );
+							return( GAME_SCREEN );
 						}
 					}
 					else
@@ -2000,7 +2000,7 @@ UINT32 UIHandleCMoveMerc( UI_EVENT *pUIEvent )
 					// HANDLE ANY INTERACTIVE OBJECTS HERE!
 					if ( pIntTile != NULL )
 					{
-				 		StartInteractiveObject( sIntTileGridNo, pStructure->usStructureID, pSoldier, ubDirection );
+						StartInteractiveObject( sIntTileGridNo, pStructure->usStructureID, pSoldier, ubDirection );
 					}
 				}
 			}
@@ -2013,17 +2013,17 @@ UINT32 UIHandleMCycleMoveAll( UI_EVENT *pUIEvent )
 {
 	SOLDIERTYPE *pSoldier;
 
-	 if ( !GetSoldier( &pSoldier, gusSelectedSoldier ) )
-	 {
-		 return( GAME_SCREEN );
-	 }
+	if ( !GetSoldier( &pSoldier, gusSelectedSoldier ) )
+	{
+		return( GAME_SCREEN );
+	}
 
-	 if ( gfUICanBeginAllMoveCycle )
-	 {
-			gfUIAllMoveOn							= TRUE;
-			gfUICanBeginAllMoveCycle	= FALSE;
-	 }
-	 return( GAME_SCREEN );
+	if ( gfUICanBeginAllMoveCycle )
+	{
+		gfUIAllMoveOn							= TRUE;
+		gfUICanBeginAllMoveCycle	= FALSE;
+	}
+	return( GAME_SCREEN );
 }
 
 
@@ -2032,63 +2032,63 @@ UINT32 UIHandleMCycleMovement( UI_EVENT *pUIEvent )
 	SOLDIERTYPE *pSoldier;
 	BOOLEAN			fGoodMode = FALSE;
 
-	 if ( !GetSoldier( &pSoldier, gusSelectedSoldier ) )
-	 {
-		 return( GAME_SCREEN );
-	 }
+	if ( !GetSoldier( &pSoldier, gusSelectedSoldier ) )
+	{
+		return( GAME_SCREEN );
+	}
 
-	 gfUIAllMoveOn							= FALSE;
+	gfUIAllMoveOn							= FALSE;
 
-   if ( pSoldier->ubBodyType == ROBOTNOWEAPON )
-   {
- 		 pSoldier->usUIMovementMode = WALKING;     
-  	 gfPlotNewMovement = TRUE;
-	   return( GAME_SCREEN );
-   }
-   
-	 do
-	 {
-		 // Cycle gmovement state
-		 if ( pSoldier->usUIMovementMode == RUNNING )
-		 {
-			 pSoldier->usUIMovementMode = WALKING;
-			 if ( IsValidMovementMode( pSoldier, WALKING ) )
-			 {
-					fGoodMode = TRUE;
-			 }
-		 }
-		 else if ( pSoldier->usUIMovementMode == WALKING )
-		 {
-			 pSoldier->usUIMovementMode = SWATTING;
-			 if ( IsValidMovementMode( pSoldier, SWATTING ) )
-			 {
-				 fGoodMode = TRUE;
-			 }
-		 }
-		 else if ( pSoldier->usUIMovementMode == SWATTING )
-		 {
-			 pSoldier->usUIMovementMode = CRAWLING;
-			 if ( IsValidMovementMode( pSoldier, CRAWLING ) )
-			 {
-				 fGoodMode = TRUE;
-			 }
-		 }
-		 else if ( pSoldier->usUIMovementMode == CRAWLING )
-		 {
-			 pSoldier->fUIMovementFast = 1;
-			 pSoldier->usUIMovementMode = RUNNING;
-			 if ( IsValidMovementMode( pSoldier, RUNNING ) )
-			 {
-				 fGoodMode = TRUE;
-			 }
-		 }
+	if ( pSoldier->ubBodyType == ROBOTNOWEAPON )
+	{
+		pSoldier->usUIMovementMode = WALKING;     
+		gfPlotNewMovement = TRUE;
+		return( GAME_SCREEN );
+	}
+
+	do
+	{
+		// Cycle gmovement state
+		if ( pSoldier->usUIMovementMode == RUNNING )
+		{
+			pSoldier->usUIMovementMode = WALKING;
+			if ( IsValidMovementMode( pSoldier, WALKING ) )
+			{
+				fGoodMode = TRUE;
+			}
+		}
+		else if ( pSoldier->usUIMovementMode == WALKING )
+		{
+			pSoldier->usUIMovementMode = SWATTING;
+			if ( IsValidMovementMode( pSoldier, SWATTING ) )
+			{
+				fGoodMode = TRUE;
+			}
+		}
+		else if ( pSoldier->usUIMovementMode == SWATTING )
+		{
+			pSoldier->usUIMovementMode = CRAWLING;
+			if ( IsValidMovementMode( pSoldier, CRAWLING ) )
+			{
+				fGoodMode = TRUE;
+			}
+		}
+		else if ( pSoldier->usUIMovementMode == CRAWLING )
+		{
+			pSoldier->fUIMovementFast = 1;
+			pSoldier->usUIMovementMode = RUNNING;
+			if ( IsValidMovementMode( pSoldier, RUNNING ) )
+			{
+				fGoodMode = TRUE;
+			}
+		}
+
+	} while( fGoodMode != TRUE );
 
-	 } while( fGoodMode != TRUE );
-	
 	gfPlotNewMovement = TRUE;
 
 
-	 return( GAME_SCREEN );
+	return( GAME_SCREEN );
 }
 
 UINT32 UIHandleCOnTerrain( UI_EVENT *pUIEvent )
@@ -2111,8 +2111,8 @@ UINT32 UIHandleMAdjustStanceMode( UI_EVENT *pUIEvent )
 	static UINT32			uiOldShowUPDownArrows;
 	INT8							bNewDirection;
 
-  // Change cusror to normal
-  guiNewUICursor = NO_UICURSOR;
+	// Change cusror to normal
+	guiNewUICursor = NO_UICURSOR;
 
 
 	if ( pUIEvent->fFirstTime )
@@ -2153,59 +2153,59 @@ UINT32 UIHandleMAdjustStanceMode( UI_EVENT *pUIEvent )
 
 			switch( gAnimControl[ pSoldier->usAnimState ].ubEndHeight )
 			{
-				case ANIM_STAND:
-					if ( ubNearHeigherLevel )
-					{
-						ubUpHeight	= 1;
-						ubDownDepth = 2;
-					}
-					else if ( ubNearLowerLevel )
-					{
-						ubUpHeight	= 0;
-						ubDownDepth = 3;
-					}
-					else
-					{
-						ubUpHeight	= 0;
-						ubDownDepth = 2;
-					}
-					break;
+			case ANIM_STAND:
+				if ( ubNearHeigherLevel )
+				{
+					ubUpHeight	= 1;
+					ubDownDepth = 2;
+				}
+				else if ( ubNearLowerLevel )
+				{
+					ubUpHeight	= 0;
+					ubDownDepth = 3;
+				}
+				else
+				{
+					ubUpHeight	= 0;
+					ubDownDepth = 2;
+				}
+				break;
 
-				case ANIM_CROUCH:
-					if ( ubNearHeigherLevel )
-					{
-						ubUpHeight	= 2;
-						ubDownDepth = 1;
-					}
-					else if ( ubNearLowerLevel )
-					{
-						ubUpHeight	= 1;
-						ubDownDepth = 2;
-					}
-					else
-					{
-						ubUpHeight	= 1;
-						ubDownDepth = 1;
-					}
-					break;
+			case ANIM_CROUCH:
+				if ( ubNearHeigherLevel )
+				{
+					ubUpHeight	= 2;
+					ubDownDepth = 1;
+				}
+				else if ( ubNearLowerLevel )
+				{
+					ubUpHeight	= 1;
+					ubDownDepth = 2;
+				}
+				else
+				{
+					ubUpHeight	= 1;
+					ubDownDepth = 1;
+				}
+				break;
 
-				case ANIM_PRONE:
-					if ( ubNearHeigherLevel )
-					{
-						ubUpHeight	= 3;
-						ubDownDepth = 0;
-					}
-					else if ( ubNearLowerLevel )
-					{
-						ubUpHeight	= 2;
-						ubDownDepth = 1;
-					}
-					else
-					{
-						ubUpHeight	= 2;
-						ubDownDepth = 0;
-					}
-					break;
+			case ANIM_PRONE:
+				if ( ubNearHeigherLevel )
+				{
+					ubUpHeight	= 3;
+					ubDownDepth = 0;
+				}
+				else if ( ubNearLowerLevel )
+				{
+					ubUpHeight	= 2;
+					ubDownDepth = 1;
+				}
+				else
+				{
+					ubUpHeight	= 2;
+					ubDownDepth = 0;
+				}
+				break;
 			}			
 
 
@@ -2225,109 +2225,109 @@ UINT32 UIHandleMAdjustStanceMode( UI_EVENT *pUIEvent )
 			// Get soldier
 			if ( GetSoldier( &pSoldier, gusSelectedSoldier )  )
 			{
-					if ( iPosDiff < GO_MOVE_ONE && ubUpHeight >= 1 )
+				if ( iPosDiff < GO_MOVE_ONE && ubUpHeight >= 1 )
+				{
+					// Change arrows to move down arrow + show
+					//guiShowUPDownArrows = ARROWS_SHOW_UP_ABOVE_Y;
+					guiShowUPDownArrows = ARROWS_SHOW_DOWN_BESIDE | ARROWS_SHOW_UP_BESIDE;
+					gbAdjustStanceDiff = 0;
+					gbClimbID					 = 0;
+				}	
+				else if ( iPosDiff > GO_MOVE_ONE && iPosDiff < GO_MOVE_TWO && ubUpHeight >= 1 )
+				{
+					//guiShowUPDownArrows = ARROWS_SHOW_UP_ABOVE_G;
+					if ( ubUpHeight == 1 && ubNearHeigherLevel )
 					{
-						// Change arrows to move down arrow + show
-						//guiShowUPDownArrows = ARROWS_SHOW_UP_ABOVE_Y;
-						guiShowUPDownArrows = ARROWS_SHOW_DOWN_BESIDE | ARROWS_SHOW_UP_BESIDE;
-						gbAdjustStanceDiff = 0;
+						guiShowUPDownArrows = ARROWS_SHOW_UP_ABOVE_CLIMB;
+						gbClimbID					  = 1;
+					}
+					else
+					{
+						guiShowUPDownArrows = ARROWS_SHOW_UP_ABOVE_Y;
+						gbClimbID					  = 0;
+					}
+					gbAdjustStanceDiff = 1;
+				}
+				else if ( iPosDiff >= GO_MOVE_TWO && iPosDiff < GO_MOVE_THREE && ubUpHeight >= 2 )
+				{
+					if ( ubUpHeight == 2 && ubNearHeigherLevel )
+					{
+						guiShowUPDownArrows = ARROWS_SHOW_UP_ABOVE_CLIMB;
+						gbClimbID					 = 1;
+					}
+					else
+					{
+						guiShowUPDownArrows = ARROWS_SHOW_UP_ABOVE_YY;
 						gbClimbID					 = 0;
-					}	
-					else if ( iPosDiff > GO_MOVE_ONE && iPosDiff < GO_MOVE_TWO && ubUpHeight >= 1 )
-					{
-						//guiShowUPDownArrows = ARROWS_SHOW_UP_ABOVE_G;
-						if ( ubUpHeight == 1 && ubNearHeigherLevel )
-						{
-							guiShowUPDownArrows = ARROWS_SHOW_UP_ABOVE_CLIMB;
-							gbClimbID					  = 1;
-						}
-						else
-						{
-							guiShowUPDownArrows = ARROWS_SHOW_UP_ABOVE_Y;
-							gbClimbID					  = 0;
-						}
-						gbAdjustStanceDiff = 1;
 					}
-					else if ( iPosDiff >= GO_MOVE_TWO && iPosDiff < GO_MOVE_THREE && ubUpHeight >= 2 )
+					gbAdjustStanceDiff = 2;
+				}
+				else if ( iPosDiff >= GO_MOVE_THREE && ubUpHeight >= 3 )
+				{
+					if ( ubUpHeight == 3 && ubNearHeigherLevel )
 					{
-						if ( ubUpHeight == 2 && ubNearHeigherLevel )
-						{
-							guiShowUPDownArrows = ARROWS_SHOW_UP_ABOVE_CLIMB;
-							gbClimbID					 = 1;
-						}
-						else
-						{
-							guiShowUPDownArrows = ARROWS_SHOW_UP_ABOVE_YY;
-							gbClimbID					 = 0;
-						}
-						gbAdjustStanceDiff = 2;
-					}
-					else if ( iPosDiff >= GO_MOVE_THREE && ubUpHeight >= 3 )
-					{
-						if ( ubUpHeight == 3 && ubNearHeigherLevel )
-						{
-							guiShowUPDownArrows = ARROWS_SHOW_UP_ABOVE_CLIMB;
-							gbClimbID					 = 1;
-						}
+						guiShowUPDownArrows = ARROWS_SHOW_UP_ABOVE_CLIMB;
+						gbClimbID					 = 1;
 					}
+				}
 			}
 
 		}
-	
+
 		if ( gusAnchorMouseY < gusMouseYPos )
 		{
 
 			// Get soldier
 			if ( GetSoldier( &pSoldier, gusSelectedSoldier )  )
 			{
-					if ( iPosDiff < GO_MOVE_ONE && ubDownDepth >= 1 )
-					{
-						// Change arrows to move down arrow + show
-						//guiShowUPDownArrows = ARROWS_SHOW_DOWN_BELOW_Y;
-						guiShowUPDownArrows = ARROWS_SHOW_DOWN_BESIDE | ARROWS_SHOW_UP_BESIDE;
-						gbAdjustStanceDiff = 0;
-						gbClimbID					 = 0;
+				if ( iPosDiff < GO_MOVE_ONE && ubDownDepth >= 1 )
+				{
+					// Change arrows to move down arrow + show
+					//guiShowUPDownArrows = ARROWS_SHOW_DOWN_BELOW_Y;
+					guiShowUPDownArrows = ARROWS_SHOW_DOWN_BESIDE | ARROWS_SHOW_UP_BESIDE;
+					gbAdjustStanceDiff = 0;
+					gbClimbID					 = 0;
 
-					}	
-					else if ( iPosDiff >= GO_MOVE_ONE && iPosDiff < GO_MOVE_TWO && ubDownDepth >= 1 )
+				}	
+				else if ( iPosDiff >= GO_MOVE_ONE && iPosDiff < GO_MOVE_TWO && ubDownDepth >= 1 )
+				{
+					//						guiShowUPDownArrows = ARROWS_SHOW_DOWN_BELOW_G;
+					if ( ubDownDepth == 1 && ubNearLowerLevel )
 					{
-//						guiShowUPDownArrows = ARROWS_SHOW_DOWN_BELOW_G;
-							if ( ubDownDepth == 1 && ubNearLowerLevel )
-							{
-								guiShowUPDownArrows = ARROWS_SHOW_DOWN_CLIMB;
-								gbClimbID					 = -1;
-							}
-							else
-							{
-								guiShowUPDownArrows = ARROWS_SHOW_DOWN_BELOW_Y;
-								gbClimbID					 = 0;
-							}
-							gbAdjustStanceDiff = -1;
+						guiShowUPDownArrows = ARROWS_SHOW_DOWN_CLIMB;
+						gbClimbID					 = -1;
 					}
-					else if ( iPosDiff > GO_MOVE_TWO && iPosDiff < GO_MOVE_THREE && ubDownDepth >= 2 )
+					else
 					{
-						//guiShowUPDownArrows = ARROWS_SHOW_DOWN_BELOW_GG;
-						if ( ubDownDepth == 2 && ubNearLowerLevel )
-						{
-							guiShowUPDownArrows = ARROWS_SHOW_DOWN_CLIMB;
-							gbClimbID					 = -1;
-						}
-						else
-						{
-							guiShowUPDownArrows = ARROWS_SHOW_DOWN_BELOW_YY;
-							gbClimbID					 = 0;
-						}
-						gbAdjustStanceDiff = -2;
+						guiShowUPDownArrows = ARROWS_SHOW_DOWN_BELOW_Y;
+						gbClimbID					 = 0;
 					}
-					else if ( iPosDiff > GO_MOVE_THREE && ubDownDepth >= 3 )
+					gbAdjustStanceDiff = -1;
+				}
+				else if ( iPosDiff > GO_MOVE_TWO && iPosDiff < GO_MOVE_THREE && ubDownDepth >= 2 )
+				{
+					//guiShowUPDownArrows = ARROWS_SHOW_DOWN_BELOW_GG;
+					if ( ubDownDepth == 2 && ubNearLowerLevel )
 					{
-						//guiShowUPDownArrows = ARROWS_SHOW_DOWN_BELOW_GG;
-						if ( ubDownDepth == 3 && ubNearLowerLevel )
-						{
-							guiShowUPDownArrows = ARROWS_SHOW_DOWN_CLIMB;
-							gbClimbID					 = -1;
-						}
+						guiShowUPDownArrows = ARROWS_SHOW_DOWN_CLIMB;
+						gbClimbID					 = -1;
 					}
+					else
+					{
+						guiShowUPDownArrows = ARROWS_SHOW_DOWN_BELOW_YY;
+						gbClimbID					 = 0;
+					}
+					gbAdjustStanceDiff = -2;
+				}
+				else if ( iPosDiff > GO_MOVE_THREE && ubDownDepth >= 3 )
+				{
+					//guiShowUPDownArrows = ARROWS_SHOW_DOWN_BELOW_GG;
+					if ( ubDownDepth == 3 && ubNearLowerLevel )
+					{
+						guiShowUPDownArrows = ARROWS_SHOW_DOWN_CLIMB;
+						gbClimbID					 = -1;
+					}
+				}
 
 			}
 
@@ -2368,9 +2368,9 @@ UINT32 UIHandleCAOnTerrain( UI_EVENT *pUIEvent )
 
 	if ( GetSoldier( &pSoldier, gusSelectedSoldier ) )
 	{
-		 guiNewUICursor = GetProperItemCursor( (UINT8)gusSelectedSoldier, pSoldier->inv[ HANDPOS ].usItem, usMapPos, TRUE );
+		guiNewUICursor = GetProperItemCursor( (UINT8)gusSelectedSoldier, pSoldier->inv[ HANDPOS ].usItem, usMapPos, TRUE );
 
-		 UIHandleOnMerc( FALSE );
+		UIHandleOnMerc( FALSE );
 
 	}
 
@@ -2388,10 +2388,10 @@ void UIHandleMercAttack( SOLDIERTYPE *pSoldier , SOLDIERTYPE *pTargetSoldier, UI
 	LEVELNODE					*pIntNode;
 	STRUCTURE					*pStructure;
 	INT16							sGridNo, sNewGridNo;
-  UINT8             ubItemCursor;
-  
-  // get cursor
-  ubItemCursor  =  GetActionModeCursor( pSoldier );
+	UINT8             ubItemCursor;
+
+	// get cursor
+	ubItemCursor  =  GetActionModeCursor( pSoldier );
 
 	if ( !(gTacticalStatus.uiFlags & INCOMBAT) && pTargetSoldier && Item[ pSoldier->inv[ HANDPOS ].usItem ].usItemClass & IC_WEAPON )
 	{
@@ -2430,46 +2430,46 @@ void UIHandleMercAttack( SOLDIERTYPE *pSoldier , SOLDIERTYPE *pTargetSoldier, UI
 		}
 	}
 
-  // here, change gridno if we're targeting ourselves....
+	// here, change gridno if we're targeting ourselves....
 	if ( pIntNode != NULL  )
 	{
-    // Are we in the same gridno?
-    if ( sGridNo == pSoldier->sGridNo && ubItemCursor != AIDCURS )
-    {
-      // Get orientation....
+		// Are we in the same gridno?
+		if ( sGridNo == pSoldier->sGridNo && ubItemCursor != AIDCURS )
+		{
+			// Get orientation....
 			switch( pStructure->ubWallOrientation )
 			{
-				case OUTSIDE_TOP_LEFT:
-				case INSIDE_TOP_LEFT:
+			case OUTSIDE_TOP_LEFT:
+			case INSIDE_TOP_LEFT:
 
-						sNewGridNo = NewGridNo( sGridNo, DirectionInc( SOUTH ) );
-						break;
+				sNewGridNo = NewGridNo( sGridNo, DirectionInc( SOUTH ) );
+				break;
 
-				case OUTSIDE_TOP_RIGHT:
-				case INSIDE_TOP_RIGHT:
+			case OUTSIDE_TOP_RIGHT:
+			case INSIDE_TOP_RIGHT:
 
-						sNewGridNo = NewGridNo( sGridNo, DirectionInc( EAST ) );
-						break;
+				sNewGridNo = NewGridNo( sGridNo, DirectionInc( EAST ) );
+				break;
 
-				default:
-            sNewGridNo = sGridNo;
-      }
+			default:
+				sNewGridNo = sGridNo;
+			}
 
-      // Set target gridno to this one...
-      sTargetGridNo = sNewGridNo;
+			// Set target gridno to this one...
+			sTargetGridNo = sNewGridNo;
 
-      // now set target cube height
-      // CJC says to hardcode this value :)
-      pSoldier->bTargetCubeLevel = 2;
-    }
-    else
-    {
-      // ATE: Refine this a bit - if we have nobody as a target...
-      if ( pTargetSoldier == NULL )
-      {
-        sTargetGridNo = sGridNo;
-      }
-    }
+			// now set target cube height
+			// CJC says to hardcode this value :)
+			pSoldier->bTargetCubeLevel = 2;
+		}
+		else
+		{
+			// ATE: Refine this a bit - if we have nobody as a target...
+			if ( pTargetSoldier == NULL )
+			{
+				sTargetGridNo = sGridNo;
+			}
+		}
 	}
 
 
@@ -2482,14 +2482,14 @@ void UIHandleMercAttack( SOLDIERTYPE *pSoldier , SOLDIERTYPE *pTargetSoldier, UI
 			return;
 		}
 	}
- 
+
 	// If in turn-based mode - return to movement
 	if ( ( gTacticalStatus.uiFlags & INCOMBAT ) )
 	{
 		// Reset some flags for cont move...
 		pSoldier->sFinalDestination = pSoldier->sGridNo;
 		pSoldier->bGoodContPath			= FALSE;
-	//  guiPendingOverrideEvent = A_CHANGE_TO_MOVE;
+		//  guiPendingOverrideEvent = A_CHANGE_TO_MOVE;
 	}	
 
 
@@ -2550,7 +2550,7 @@ UINT32 UIHandleCAMercShoot( UI_EVENT *pUIEvent )
 		{
 			return( GAME_SCREEN );
 		}
-		
+
 		// Get soldier
 		if ( GetSoldier( &pSoldier, gusSelectedSoldier )  )
 		{
@@ -2686,29 +2686,29 @@ UINT32 UIHandlePADJAdjustStance( UI_EVENT *pUIEvent )
 
 	if ( gusSelectedSoldier != NO_SOLDIER && gbAdjustStanceDiff != 0 )
 	{
-			// Get soldier
-			if ( GetSoldier( &pSoldier, gusSelectedSoldier )  )
+		// Get soldier
+		if ( GetSoldier( &pSoldier, gusSelectedSoldier )  )
+		{
+			ubNewStance = GetAdjustedAnimHeight( gAnimControl[ pSoldier->usAnimState ].ubEndHeight, gbAdjustStanceDiff );
+
+			if ( gbClimbID	== 1 )
 			{
-					ubNewStance = GetAdjustedAnimHeight( gAnimControl[ pSoldier->usAnimState ].ubEndHeight, gbAdjustStanceDiff );
-
-					if ( gbClimbID	== 1 )
-					{
-						BeginSoldierClimbUpRoof( pSoldier );
-					}
-					else if ( gbClimbID == -1 )
-					{
-						BeginSoldierClimbDownRoof( pSoldier );
-					}
-					else
-					{
-						// Set state to result
-						UIHandleSoldierStanceChange( pSoldier->ubID, ubNewStance );
-					}
-
-				  // Once we have APs, we can safely reset nomove flag!
-					// AdjustNoAPToFinishMove( pSoldier, FALSE );
-
+				BeginSoldierClimbUpRoof( pSoldier );
 			}
+			else if ( gbClimbID == -1 )
+			{
+				BeginSoldierClimbDownRoof( pSoldier );
+			}
+			else
+			{
+				// Set state to result
+				UIHandleSoldierStanceChange( pSoldier->ubID, ubNewStance );
+			}
+
+			// Once we have APs, we can safely reset nomove flag!
+			// AdjustNoAPToFinishMove( pSoldier, FALSE );
+
+		}
 
 	}
 	return( GAME_SCREEN );
@@ -2790,19 +2790,19 @@ void HandleObjectHighlighting( )
 			switch( gCurrentUIMode )
 			{
 
-				case CONFIRM_MOVE_MODE:
-				case MENU_MODE:
+			case CONFIRM_MOVE_MODE:
+			case MENU_MODE:
 
-					break;
-			
-				case MOVE_MODE:
-				case CONFIRM_ACTION_MODE:
+				break;
+
+			case MOVE_MODE:
+			case CONFIRM_ACTION_MODE:
 				//case ACTION_MODE:
-				case IDLE_MODE:
+			case IDLE_MODE:
 
-					// Set as selected
-					//pSoldier->pCurrentShade = pSoldier->pShades[ 1 ];
-					break;
+				// Set as selected
+				//pSoldier->pCurrentShade = pSoldier->pShades[ 1 ];
+				break;
 			}
 		}
 		else if ( guiUIFullTargetFlags & OWNED_MERC )
@@ -2820,7 +2820,7 @@ void AdjustSoldierCreationStartValues( )
 	INT32				cnt;
 	SOLDIERTYPE		*pSoldier;
 
-	
+
 	cnt = gTacticalStatus.Team[ gbPlayerNum ].bFirstID;
 	guiCreateGuyIndex = (INT16)cnt;
 
@@ -2865,7 +2865,7 @@ BOOLEAN SelectedMercCanAffordAttack( )
 		{
 			return( GAME_SCREEN );
 		}
-		
+
 		// Get soldier
 		if ( GetSoldier( &pSoldier, gusSelectedSoldier )  )
 		{
@@ -2883,48 +2883,48 @@ BOOLEAN SelectedMercCanAffordAttack( )
 			if ( ubItemCursor == BOMBCURS )
 			{
 				// Check as...
-			  if ( EnoughPoints( pSoldier, GetTotalAPsToDropBomb( pSoldier, usMapPos ), 0, TRUE ) )
+				if ( EnoughPoints( pSoldier, GetTotalAPsToDropBomb( pSoldier, usMapPos ), 0, TRUE ) )
 				{
-				  return( TRUE );
+					return( TRUE );
 				}
 			}
 			else if ( ubItemCursor == REMOTECURS )
 			{
 				// Check as...
-			  if ( EnoughPoints( pSoldier, GetAPsToUseRemote( pSoldier ), 0, TRUE ) )
+				if ( EnoughPoints( pSoldier, GetAPsToUseRemote( pSoldier ), 0, TRUE ) )
 				{
-				  return( TRUE );
+					return( TRUE );
 				}
 			}
 			else
 			{
-				 // Look for a soldier at this position
+				// Look for a soldier at this position
 				if ( gfUIFullTargetFound )
 				{
-						// GetSoldier
-						GetSoldier( &pTargetSoldier, gusUIFullTargetID );
-						sTargetGridNo	= pTargetSoldier->sGridNo;
-				 }
-				 else
-				 {
-						sTargetGridNo	= usMapPos;
-				 }
+					// GetSoldier
+					GetSoldier( &pTargetSoldier, gusUIFullTargetID );
+					sTargetGridNo	= pTargetSoldier->sGridNo;
+				}
+				else
+				{
+					sTargetGridNo	= usMapPos;
+				}
 
-				 sAPCost = CalcTotalAPsToAttack( pSoldier, sTargetGridNo, TRUE, (INT8)(pSoldier->bShownAimTime ) );
+				sAPCost = CalcTotalAPsToAttack( pSoldier, sTargetGridNo, TRUE, (INT8)(pSoldier->bShownAimTime ) );
 
-				 if ( EnoughPoints( pSoldier, sAPCost, 0, TRUE ) )
-				 {
-					 return( TRUE );
-				 }
-				 else
-				 {
-					 // Play curse....
-					 DoMercBattleSound( pSoldier, BATTLE_SOUND_CURSE1 );
-				 }
+				if ( EnoughPoints( pSoldier, sAPCost, 0, TRUE ) )
+				{
+					return( TRUE );
+				}
+				else
+				{
+					// Play curse....
+					DoMercBattleSound( pSoldier, BATTLE_SOUND_CURSE1 );
+				}
 			}
-		 }
+		}
 
-	 }
+	}
 
 	return( FALSE );
 }
@@ -2937,7 +2937,7 @@ BOOLEAN SelectedMercCanAffordMove(  )
 	INT16							sBPCost = 0;
 	UINT16						usMapPos;
 	LEVELNODE					*pIntTile;
-	
+
 	// Get soldier
 	if ( GetSoldier( &pSoldier, gusSelectedSoldier )  )
 	{
@@ -2966,7 +2966,7 @@ BOOLEAN SelectedMercCanAffordMove(  )
 		// Take the first direction!
 		sAPCost = PtsToMoveDirection( pSoldier, (UINT8)guiPathingData[ 0 ] );
 
-    sAPCost += GetAPsToChangeStance( pSoldier, gAnimControl[ pSoldier->usUIMovementMode ].ubHeight );
+		sAPCost += GetAPsToChangeStance( pSoldier, gAnimControl[ pSoldier->usUIMovementMode ].ubHeight );
 
 		if ( EnoughPoints( pSoldier, sAPCost, 0 , TRUE ) )
 		{
@@ -2990,7 +2990,7 @@ void GetMercClimbDirection( UINT8 ubSoldierID, BOOLEAN *pfGoDown, BOOLEAN *pfGoU
 
 	*pfGoDown = FALSE;
 	*pfGoUp   = FALSE;
-	
+
 	if ( !GetSoldier( &pSoldier, ubSoldierID ) )
 	{
 		return;
@@ -3051,20 +3051,20 @@ UINT32 UIHandleHCOnTerrain( UI_EVENT *pUIEvent )
 	{
 		guiNewUICursor = INVALID_ACTION_UICURSOR;
 	}
-  else
-  {
-	  if ( gsOverItemsGridNo != NOWHERE && ( usMapPos != gsOverItemsGridNo || gsInterfaceLevel != gsOverItemsLevel ) )
-	  {
-		  gsOverItemsGridNo = NOWHERE;
-		  guiPendingOverrideEvent = A_CHANGE_TO_MOVE;
-	  }
-	  else
-	  {
-		  guiNewUICursor = NORMALHANDCURSOR_UICURSOR;
+	else
+	{
+		if ( gsOverItemsGridNo != NOWHERE && ( usMapPos != gsOverItemsGridNo || gsInterfaceLevel != gsOverItemsLevel ) )
+		{
+			gsOverItemsGridNo = NOWHERE;
+			guiPendingOverrideEvent = A_CHANGE_TO_MOVE;
+		}
+		else
+		{
+			guiNewUICursor = NORMALHANDCURSOR_UICURSOR;
 
-		  UIHandleInteractiveTilesAndItemsOnTerrain( pSoldier, usMapPos, TRUE, FALSE );
-	  }
-  }
+			UIHandleInteractiveTilesAndItemsOnTerrain( pSoldier, usMapPos, TRUE, FALSE );
+		}
+	}
 	return( GAME_SCREEN );
 }
 
@@ -3109,7 +3109,7 @@ void ToggleHandCursorMode( UINT32 *puiNewEvent  )
 	}
 	else
 	{
-		
+
 		*puiNewEvent = M_CHANGE_TO_HANDMODE;
 	}
 }
@@ -3168,7 +3168,7 @@ BOOLEAN UIHandleOnMerc( BOOLEAN fMovementMode )
 		usSoldierIndex	= gusUIFullTargetID;
 		uiMercFlags			= guiUIFullTargetFlags;
 	}
-	
+
 	// CHECK IF WE'RE ON A GUY ( EITHER SELECTED, OURS, OR THEIRS
 	if ( fFoundMerc )
 	{
@@ -3313,26 +3313,26 @@ UINT32 UIHandleILoadLevel( UI_EVENT *pUIEvent )
 
 UINT32 UIHandleISoldierDebug( UI_EVENT *pUIEvent )
 {
-	 // Use soldier display pages
-	 SetDebugRenderHook( (RENDER_HOOK)DebugSoldierPage1, 0 );
-	 SetDebugRenderHook( (RENDER_HOOK)DebugSoldierPage2, 1 );
-	 SetDebugRenderHook( (RENDER_HOOK)DebugSoldierPage3, 2 );
-	 SetDebugRenderHook( (RENDER_HOOK)DebugSoldierPage4, 3 );
-	 gCurDebugPage = 1;
+	// Use soldier display pages
+	SetDebugRenderHook( (RENDER_HOOK)DebugSoldierPage1, 0 );
+	SetDebugRenderHook( (RENDER_HOOK)DebugSoldierPage2, 1 );
+	SetDebugRenderHook( (RENDER_HOOK)DebugSoldierPage3, 2 );
+	SetDebugRenderHook( (RENDER_HOOK)DebugSoldierPage4, 3 );
+	gCurDebugPage = 1;
 
-	 return( DEBUG_SCREEN );
+	return( DEBUG_SCREEN );
 }
 
 UINT32 UIHandleILOSDebug( UI_EVENT *pUIEvent )
 {
-	 SetDebugRenderHook( (RENDER_HOOK)DebugStructurePage1, 0 );
-	 return( DEBUG_SCREEN );
+	SetDebugRenderHook( (RENDER_HOOK)DebugStructurePage1, 0 );
+	return( DEBUG_SCREEN );
 }
 
 UINT32 UIHandleILevelNodeDebug( UI_EVENT *pUIEvent )
 {
-	 SetDebugRenderHook( (RENDER_HOOK)DebugLevelNodePage, 0 );
-	 return( DEBUG_SCREEN );
+	SetDebugRenderHook( (RENDER_HOOK)DebugLevelNodePage, 0 );
+	return( DEBUG_SCREEN );
 }
 
 UINT32 UIHandleIETOnTerrain( UI_EVENT *pUIEvent )
@@ -3355,32 +3355,32 @@ void UIHandleSoldierStanceChange( UINT8 ubSoldierID, INT8	bNewStance )
 	// Is this a valid stance for our position?
 	if ( !IsValidStance( pSoldier, bNewStance ) )
 	{
-    if ( pSoldier->bCollapsed && pSoldier->bBreath < OKBREATH )
-    {
+		if ( pSoldier->bCollapsed && pSoldier->bBreath < OKBREATH )
+		{
 			ScreenMsg( FONT_MCOLOR_LTYELLOW, MSG_UI_FEEDBACK, gzLateLocalizedString[ 4 ], pSoldier->name );
-    }
-    else
-    {
-		  if ( pSoldier->uiStatusFlags & SOLDIER_VEHICLE )
-		  {
-			  ScreenMsg( FONT_MCOLOR_LTYELLOW, MSG_UI_FEEDBACK, TacticalStr[ VEHICLES_NO_STANCE_CHANGE_STR ] );
-		  }
-		  else if ( pSoldier->uiStatusFlags & SOLDIER_ROBOT )
-		  {
-			  ScreenMsg( FONT_MCOLOR_LTYELLOW, MSG_UI_FEEDBACK, TacticalStr[ ROBOT_NO_STANCE_CHANGE_STR ] );
-		  }
-		  else
-		  {
-			  if ( pSoldier->bCollapsed )
-			  {
-				  ScreenMsg( FONT_MCOLOR_LTYELLOW, MSG_UI_FEEDBACK, pMessageStrings[ MSG_CANT_CHANGE_STANCE ], pSoldier->name );
-			  }
-			  else
-			  {
-				  ScreenMsg( FONT_MCOLOR_LTYELLOW, MSG_UI_FEEDBACK, TacticalStr[ CANNOT_STANCE_CHANGE_STR ], pSoldier->name );
-			  }
-		  }
-    }
+		}
+		else
+		{
+			if ( pSoldier->uiStatusFlags & SOLDIER_VEHICLE )
+			{
+				ScreenMsg( FONT_MCOLOR_LTYELLOW, MSG_UI_FEEDBACK, TacticalStr[ VEHICLES_NO_STANCE_CHANGE_STR ] );
+			}
+			else if ( pSoldier->uiStatusFlags & SOLDIER_ROBOT )
+			{
+				ScreenMsg( FONT_MCOLOR_LTYELLOW, MSG_UI_FEEDBACK, TacticalStr[ ROBOT_NO_STANCE_CHANGE_STR ] );
+			}
+			else
+			{
+				if ( pSoldier->bCollapsed )
+				{
+					ScreenMsg( FONT_MCOLOR_LTYELLOW, MSG_UI_FEEDBACK, pMessageStrings[ MSG_CANT_CHANGE_STANCE ], pSoldier->name );
+				}
+				else
+				{
+					ScreenMsg( FONT_MCOLOR_LTYELLOW, MSG_UI_FEEDBACK, TacticalStr[ CANNOT_STANCE_CHANGE_STR ], pSoldier->name );
+				}
+			}
+		}
 		return;
 	}
 
@@ -3403,7 +3403,7 @@ void UIHandleSoldierStanceChange( UINT8 ubSoldierID, INT8	bNewStance )
 		else
 			return;
 	}
-	
+
 	// If realtime- change walking animation!
 	if ( ( gTacticalStatus.uiFlags & REALTIME ) || !( gTacticalStatus.uiFlags & INCOMBAT ) )
 	{
@@ -3434,7 +3434,7 @@ void UIHandleSoldierStanceChange( UINT8 ubSoldierID, INT8	bNewStance )
 
 
 			ChangeSoldierState( pSoldier, pSoldier->usUIMovementMode, 0, FALSE );
-			
+
 		}
 	}
 
@@ -3502,7 +3502,7 @@ void GetCursorMovementFlags( UINT32 *puiCursorFlags )
 	static	UINT16	usOldMouseXPos  = 32000;
 	static	UINT16	usOldMouseYPos  = 32000;
 	static	UINT16  usOldMapPos		  = 32000;
-	
+
 	static	UINT32  uiSameFrameCursorFlags;
 	static  UINT32	uiOldFrameNumber = 99999;
 
@@ -3512,7 +3512,7 @@ void GetCursorMovementFlags( UINT32 *puiCursorFlags )
 		( *puiCursorFlags ) = uiSameFrameCursorFlags;
 		return;
 	}
-	
+
 	GetMouseMapPos( &usMapPos );
 	ConvertGridNoToXY( usMapPos, &sXPos, &sYPos );
 
@@ -3557,175 +3557,175 @@ BOOLEAN HandleUIMovementCursor( SOLDIERTYPE *pSoldier, UINT32 uiCursorFlags, UIN
 	BOOLEAN						fTargetFoundAndLookingForOne = FALSE;
 	BOOLEAN						fIntTileFoundAndLookingForOne = FALSE;
 
-	 // Determine if we can afford!
-	 if ( !EnoughPoints( pSoldier, gsCurrentActionPoints, 0, FALSE ) )
-	 {
-		 gfUIDisplayActionPointsInvalid = TRUE;
-	 }
+	// Determine if we can afford!
+	if ( !EnoughPoints( pSoldier, gsCurrentActionPoints, 0, FALSE ) )
+	{
+		gfUIDisplayActionPointsInvalid = TRUE;
+	}
 
-	 // Check if we're stationary
-	 if ( ( ( gTacticalStatus.uiFlags & REALTIME ) || !( gTacticalStatus.uiFlags & INCOMBAT ) ) || ( ( gAnimControl[ pSoldier->usAnimState ].uiFlags & ANIM_STATIONARY ) || pSoldier->fNoAPToFinishMove ) || pSoldier->ubID >= MAX_NUM_SOLDIERS )
-	 {
-		  // If we are targeting a merc for some reason, don't go thorugh normal channels if we are on someone now
-			if ( uiFlags == MOVEUI_TARGET_MERCS || uiFlags == MOVEUI_TARGET_MERCSFORAID )
+	// Check if we're stationary
+	if ( ( ( gTacticalStatus.uiFlags & REALTIME ) || !( gTacticalStatus.uiFlags & INCOMBAT ) ) || ( ( gAnimControl[ pSoldier->usAnimState ].uiFlags & ANIM_STATIONARY ) || pSoldier->fNoAPToFinishMove ) || pSoldier->ubID >= MAX_NUM_SOLDIERS )
+	{
+		// If we are targeting a merc for some reason, don't go thorugh normal channels if we are on someone now
+		if ( uiFlags == MOVEUI_TARGET_MERCS || uiFlags == MOVEUI_TARGET_MERCSFORAID )
+		{
+			if ( gfUIFullTargetFound != fTargetFound || usTargetID != gusUIFullTargetID || gfResetUIMovementOptimization )
 			{
-				if ( gfUIFullTargetFound != fTargetFound || usTargetID != gusUIFullTargetID || gfResetUIMovementOptimization )
-				{
-					gfResetUIMovementOptimization = FALSE;
+				gfResetUIMovementOptimization = FALSE;
 
-					// ERASE PATH
-					ErasePath( TRUE );
+				// ERASE PATH
+				ErasePath( TRUE );
 
-					// Try and get a path right away
-					DrawUIMovementPath( pSoldier, usMapPos,  uiFlags );
-				}
-
-				// Save for next time...
-				fTargetFound = gfUIFullTargetFound;
-				usTargetID	 = gusUIFullTargetID;
-
-				if ( fTargetFound )
-				{
-					fTargetFoundAndLookingForOne = TRUE;
-				}
+				// Try and get a path right away
+				DrawUIMovementPath( pSoldier, usMapPos,  uiFlags );
 			}
 
-			if ( uiFlags == MOVEUI_TARGET_ITEMS )
-			{											
-				gfUIOverItemPool = TRUE;
-				gfUIOverItemPoolGridNo = usMapPos;
-			}
-			else if ( uiFlags == MOVEUI_TARGET_MERCSFORAID )
+			// Save for next time...
+			fTargetFound = gfUIFullTargetFound;
+			usTargetID	 = gusUIFullTargetID;
+
+			if ( fTargetFound )
 			{
-				// Set values for AP display...
-				gfUIDisplayActionPointsCenter = TRUE;
+				fTargetFoundAndLookingForOne = TRUE;
+			}
+		}
+
+		if ( uiFlags == MOVEUI_TARGET_ITEMS )
+		{											
+			gfUIOverItemPool = TRUE;
+			gfUIOverItemPoolGridNo = usMapPos;
+		}
+		else if ( uiFlags == MOVEUI_TARGET_MERCSFORAID )
+		{
+			// Set values for AP display...
+			gfUIDisplayActionPointsCenter = TRUE;
+		}
+
+		// IF CURSOR IS MOVING
+		if ( ( uiCursorFlags & MOUSE_MOVING ) || gfUINewStateForIntTile )
+		{
+			// SHOW CURSOR
+			fSetCursor = TRUE;
+
+			// IF CURSOR WAS PREVIOUSLY STATIONARY, MAKE THE ADDITIONAL CHECK OF GRID POS CHANGE
+			if (  ( ( uiCursorFlags & MOUSE_MOVING_NEW_TILE ) && !fTargetFoundAndLookingForOne ) || gfUINewStateForIntTile )
+			{
+				// ERASE PATH
+				ErasePath( TRUE );
+
+				// Reset counter
+				RESETCOUNTER( PATHFINDCOUNTER );
+
+				gfPlotNewMovement = TRUE;
+
 			}
 
-			// IF CURSOR IS MOVING
-			if ( ( uiCursorFlags & MOUSE_MOVING ) || gfUINewStateForIntTile )
+			if ( uiCursorFlags & MOUSE_MOVING_IN_TILE )
 			{
-				// SHOW CURSOR
-				fSetCursor = TRUE;
-
-				// IF CURSOR WAS PREVIOUSLY STATIONARY, MAKE THE ADDITIONAL CHECK OF GRID POS CHANGE
-				if (  ( ( uiCursorFlags & MOUSE_MOVING_NEW_TILE ) && !fTargetFoundAndLookingForOne ) || gfUINewStateForIntTile )
-				{
-					// ERASE PATH
-					ErasePath( TRUE );
-					
-					// Reset counter
-					RESETCOUNTER( PATHFINDCOUNTER );
-
-					gfPlotNewMovement = TRUE;
-
-				}
-				
-				if ( uiCursorFlags & MOUSE_MOVING_IN_TILE )
-				{
-					gfUIDisplayActionPoints = TRUE;
-				}
-
-			 }
-
-			 if ( uiCursorFlags & MOUSE_STATIONARY )
-			 {
-					// CURSOR IS STATIONARY
-					if ( _KeyDown( SHIFT ) && !gfPlotNewMovementNOCOST )
-					{
-						gfPlotNewMovementNOCOST = TRUE;
-						gfPlotNewMovement = TRUE;
-					}
-					if ( !(_KeyDown( SHIFT ) ) && gfPlotNewMovementNOCOST )
-					{
-						gfPlotNewMovementNOCOST = FALSE;
-						gfPlotNewMovement = TRUE;
-					}
-
-
-					// ONLY DIPSLAY PATH AFTER A DELAY
-					if ( COUNTERDONE( PATHFINDCOUNTER ) )
-					{
-						// Reset counter
-						RESETCOUNTER( PATHFINDCOUNTER );
-
-						if ( gfPlotNewMovement  )
-						{
-							DrawUIMovementPath( pSoldier, usMapPos,  uiFlags );
-
-							gfPlotNewMovement = FALSE;
-						}
-					}
-							
-					fSetCursor = TRUE;
-
-					// DISPLAY POINTS EVEN WITHOUT DELAY
-					// ONLY IF GFPLOT NEW MOVEMENT IS FALSE!
-					if ( !gfPlotNewMovement )
-					{
-						if ( gsCurrentActionPoints < 0 || ( (gTacticalStatus.uiFlags & REALTIME) || !(gTacticalStatus.uiFlags & INCOMBAT ) ) )
-						{
-							gfUIDisplayActionPoints = FALSE;
-						}
-						else
-						{
-							gfUIDisplayActionPoints = TRUE;
-
-							if ( uiFlags == MOVEUI_TARGET_INTTILES )
-							{
-								// Set values for AP display...
-								gUIDisplayActionPointsOffX = 22;
-								gUIDisplayActionPointsOffY = 15;
-							}
-							if ( uiFlags == MOVEUI_TARGET_BOMB )
-							{
-								// Set values for AP display...
-								gUIDisplayActionPointsOffX = 22;
-								gUIDisplayActionPointsOffY = 15;
-							}
-							else if ( uiFlags == MOVEUI_TARGET_ITEMS )
-							{
-								// Set values for AP display...
-								gUIDisplayActionPointsOffX = 22;
-								gUIDisplayActionPointsOffY = 15;
-							}
-							else 
-							{
-								switch ( pSoldier->usUIMovementMode )
-								{
-									case WALKING:
-										
-										gUIDisplayActionPointsOffY = 10;
-										gUIDisplayActionPointsOffX = 10;
-										break;
-
-									case RUNNING:
-										gUIDisplayActionPointsOffY = 15;
-										gUIDisplayActionPointsOffX = 21;
-										break;
-								}
-							}
-						}
-					}
+				gfUIDisplayActionPoints = TRUE;
 			}
 
 		}
-		else
+
+		if ( uiCursorFlags & MOUSE_STATIONARY )
 		{
-			// THE MERC IS MOVING
-			// We're moving, erase path, change cursor
-			ErasePath( TRUE );
+			// CURSOR IS STATIONARY
+			if ( _KeyDown( SHIFT ) && !gfPlotNewMovementNOCOST )
+			{
+				gfPlotNewMovementNOCOST = TRUE;
+				gfPlotNewMovement = TRUE;
+			}
+			if ( !(_KeyDown( SHIFT ) ) && gfPlotNewMovementNOCOST )
+			{
+				gfPlotNewMovementNOCOST = FALSE;
+				gfPlotNewMovement = TRUE;
+			}
+
+
+			// ONLY DIPSLAY PATH AFTER A DELAY
+			if ( COUNTERDONE( PATHFINDCOUNTER ) )
+			{
+				// Reset counter
+				RESETCOUNTER( PATHFINDCOUNTER );
+
+				if ( gfPlotNewMovement  )
+				{
+					DrawUIMovementPath( pSoldier, usMapPos,  uiFlags );
+
+					gfPlotNewMovement = FALSE;
+				}
+			}
 
 			fSetCursor = TRUE;
 
+			// DISPLAY POINTS EVEN WITHOUT DELAY
+			// ONLY IF GFPLOT NEW MOVEMENT IS FALSE!
+			if ( !gfPlotNewMovement )
+			{
+				if ( gsCurrentActionPoints < 0 || ( (gTacticalStatus.uiFlags & REALTIME) || !(gTacticalStatus.uiFlags & INCOMBAT ) ) )
+				{
+					gfUIDisplayActionPoints = FALSE;
+				}
+				else
+				{
+					gfUIDisplayActionPoints = TRUE;
+
+					if ( uiFlags == MOVEUI_TARGET_INTTILES )
+					{
+						// Set values for AP display...
+						gUIDisplayActionPointsOffX = 22;
+						gUIDisplayActionPointsOffY = 15;
+					}
+					if ( uiFlags == MOVEUI_TARGET_BOMB )
+					{
+						// Set values for AP display...
+						gUIDisplayActionPointsOffX = 22;
+						gUIDisplayActionPointsOffY = 15;
+					}
+					else if ( uiFlags == MOVEUI_TARGET_ITEMS )
+					{
+						// Set values for AP display...
+						gUIDisplayActionPointsOffX = 22;
+						gUIDisplayActionPointsOffY = 15;
+					}
+					else 
+					{
+						switch ( pSoldier->usUIMovementMode )
+						{
+						case WALKING:
+
+							gUIDisplayActionPointsOffY = 10;
+							gUIDisplayActionPointsOffX = 10;
+							break;
+
+						case RUNNING:
+							gUIDisplayActionPointsOffY = 15;
+							gUIDisplayActionPointsOffX = 21;
+							break;
+						}
+					}
+				}
+			}
 		}
 
-		if(pSoldier->bDoAutofire) //reset the autofire bullet count
-		{
-			pSoldier->autofireLastStep = FALSE;
-			pSoldier->bDoAutofire = 1;  
-		}
+	}
+	else
+	{
+		// THE MERC IS MOVING
+		// We're moving, erase path, change cursor
+		ErasePath( TRUE );
 
-		return( fSetCursor );
+		fSetCursor = TRUE;
+
+	}
+
+	if(pSoldier->bDoAutofire) //reset the autofire bullet count
+	{
+		pSoldier->autofireLastStep = FALSE;
+		pSoldier->bDoAutofire = 1;  
+	}
+
+	return( fSetCursor );
 }
 
 
@@ -3737,9 +3737,9 @@ INT8 DrawUIMovementPath( SOLDIERTYPE *pSoldier, UINT16 usMapPos, UINT32 uiFlags
 	STRUCTURE					*pStructure;
 	BOOLEAN						fOnInterTile = FALSE;
 	UINT8							ubDirection;
-//	ITEM_POOL					*pItemPool;
-	INT16							sAdjustedGridNo;
-  INT16							sIntTileGridNo;
+	//	ITEM_POOL					*pItemPool;
+	INT16							sAdjustedGridNo = -1;
+	INT16							sIntTileGridNo;
 	LEVELNODE					*pIntTile;
 	INT8							bReturnCode = 0;
 	BOOLEAN						fPlot;
@@ -3762,34 +3762,34 @@ INT8 DrawUIMovementPath( SOLDIERTYPE *pSoldier, UINT16 usMapPos, UINT32 uiFlags
 	// IF WE ARE OVER AN INTERACTIVE TILE, GIVE GRIDNO OF POSITION
 	if ( uiFlags == MOVEUI_TARGET_INTTILES )
 	{
-			// Get structure info for in tile!
-			pIntTile = GetCurInteractiveTileGridNoAndStructure( &sIntTileGridNo, &pStructure );
+		// Get structure info for in tile!
+		pIntTile = GetCurInteractiveTileGridNoAndStructure( &sIntTileGridNo, &pStructure );
 
-			// We should not have null here if we are given this flag...
-			if ( pIntTile != NULL )
+		// We should not have null here if we are given this flag...
+		if ( pIntTile != NULL )
+		{
+			sActionGridNo =  FindAdjacentGridEx( pSoldier, sIntTileGridNo, &ubDirection, NULL, FALSE, TRUE );
+			if ( sActionGridNo == -1 )
 			{
-				sActionGridNo =  FindAdjacentGridEx( pSoldier, sIntTileGridNo, &ubDirection, NULL, FALSE, TRUE );
-				if ( sActionGridNo == -1 )
-				{
-					sActionGridNo = sIntTileGridNo;
-				}
-				CalcInteractiveObjectAPs( sIntTileGridNo, pStructure, &sAPCost, &sBPCost );
-				//sAPCost += UIPlotPath( pSoldier, sActionGridNo, NO_COPYROUTE, PLOT, TEMPORARY, (UINT16)pSoldier->usUIMovementMode, NOT_STEALTH, FORWARD, pSoldier->bActionPoints);
-				sAPCost += UIPlotPath( pSoldier, sActionGridNo, NO_COPYROUTE, fPlot, TEMPORARY, (UINT16)pSoldier->usUIMovementMode, NOT_STEALTH, FORWARD, pSoldier->bActionPoints);
-				
-				if ( sActionGridNo != pSoldier->sGridNo )
-				{
-					gfUIHandleShowMoveGrid = TRUE;
-					gsUIHandleShowMoveGridLocation = sActionGridNo;
-				}
+				sActionGridNo = sIntTileGridNo;
+			}
+			CalcInteractiveObjectAPs( sIntTileGridNo, pStructure, &sAPCost, &sBPCost );
+			//sAPCost += UIPlotPath( pSoldier, sActionGridNo, NO_COPYROUTE, PLOT, TEMPORARY, (UINT16)pSoldier->usUIMovementMode, NOT_STEALTH, FORWARD, pSoldier->bActionPoints);
+			sAPCost += UIPlotPath( pSoldier, sActionGridNo, NO_COPYROUTE, fPlot, TEMPORARY, (UINT16)pSoldier->usUIMovementMode, NOT_STEALTH, FORWARD, pSoldier->bActionPoints);
 
-				// Add cost for stance change....
-				sAPCost += GetAPsToChangeStance( pSoldier, ANIM_STAND );
-			}
-			else
+			if ( sActionGridNo != pSoldier->sGridNo )
 			{
-				sAPCost += UIPlotPath( pSoldier, sActionGridNo, NO_COPYROUTE, fPlot, TEMPORARY, (UINT16)pSoldier->usUIMovementMode, NOT_STEALTH, FORWARD, pSoldier->bActionPoints );
+				gfUIHandleShowMoveGrid = TRUE;
+				gsUIHandleShowMoveGridLocation = sActionGridNo;
 			}
+
+			// Add cost for stance change....
+			sAPCost += GetAPsToChangeStance( pSoldier, ANIM_STAND );
+		}
+		else
+		{
+			sAPCost += UIPlotPath( pSoldier, sActionGridNo, NO_COPYROUTE, fPlot, TEMPORARY, (UINT16)pSoldier->usUIMovementMode, NOT_STEALTH, FORWARD, pSoldier->bActionPoints );
+		}
 	}
 	else if ( uiFlags == MOVEUI_TARGET_WIREFENCE )
 	{
@@ -3798,18 +3798,18 @@ INT8 DrawUIMovementPath( SOLDIERTYPE *pSoldier, UINT16 usMapPos, UINT32 uiFlags
 		{
 			sAPCost = 0;
 		}
-    else
-    {
-		  sAPCost = GetAPsToCutFence( pSoldier );
+		else
+		{
+			sAPCost = GetAPsToCutFence( pSoldier );
 
-		  sAPCost += UIPlotPath( pSoldier, sActionGridNo, NO_COPYROUTE, fPlot, TEMPORARY, (UINT16)pSoldier->usUIMovementMode, NOT_STEALTH, FORWARD, pSoldier->bActionPoints);
-				  
-		  if ( sActionGridNo != pSoldier->sGridNo )
-		  {
-			  gfUIHandleShowMoveGrid = TRUE;
-			  gsUIHandleShowMoveGridLocation = sActionGridNo;
-		  }
-    }
+			sAPCost += UIPlotPath( pSoldier, sActionGridNo, NO_COPYROUTE, fPlot, TEMPORARY, (UINT16)pSoldier->usUIMovementMode, NOT_STEALTH, FORWARD, pSoldier->bActionPoints);
+
+			if ( sActionGridNo != pSoldier->sGridNo )
+			{
+				gfUIHandleShowMoveGrid = TRUE;
+				gsUIHandleShowMoveGridLocation = sActionGridNo;
+			}
+		}
 	}
 	else if ( uiFlags == MOVEUI_TARGET_JAR )
 	{
@@ -3822,7 +3822,7 @@ INT8 DrawUIMovementPath( SOLDIERTYPE *pSoldier, UINT16 usMapPos, UINT32 uiFlags
 		sAPCost = GetAPsToUseJar( pSoldier, sActionGridNo );
 
 		sAPCost += UIPlotPath( pSoldier, sActionGridNo, NO_COPYROUTE, fPlot, TEMPORARY, (UINT16)pSoldier->usUIMovementMode, NOT_STEALTH, FORWARD, pSoldier->bActionPoints);
-				
+
 		if ( sActionGridNo != pSoldier->sGridNo )
 		{
 			gfUIHandleShowMoveGrid = TRUE;
@@ -3842,7 +3842,7 @@ INT8 DrawUIMovementPath( SOLDIERTYPE *pSoldier, UINT16 usMapPos, UINT32 uiFlags
 			{
 				sAPCost = AP_ATTACH_CAN;
 				sAPCost += UIPlotPath( pSoldier, sActionGridNo, NO_COPYROUTE, fPlot, TEMPORARY, (UINT16)pSoldier->usUIMovementMode, NOT_STEALTH, FORWARD, pSoldier->bActionPoints);
-					
+
 				if ( sActionGridNo != pSoldier->sGridNo )
 				{
 					gfUIHandleShowMoveGrid = TRUE;
@@ -3864,7 +3864,7 @@ INT8 DrawUIMovementPath( SOLDIERTYPE *pSoldier, UINT16 usMapPos, UINT32 uiFlags
 			INT16 sNewGridNo;
 			UINT8	ubDirection;
 
-		  sNewGridNo = FindGridNoFromSweetSpotWithStructDataFromSoldier( pSoldier, pSoldier->usUIMovementMode, 5, &ubDirection, 0, MercPtrs[ ubMercID ] );
+			sNewGridNo = FindGridNoFromSweetSpotWithStructDataFromSoldier( pSoldier, pSoldier->usUIMovementMode, 5, &ubDirection, 0, MercPtrs[ ubMercID ] );
 
 			if ( sNewGridNo != NOWHERE )
 			{
@@ -3881,7 +3881,7 @@ INT8 DrawUIMovementPath( SOLDIERTYPE *pSoldier, UINT16 usMapPos, UINT32 uiFlags
 		sAPCost = GetAPsToBeginRepair( pSoldier );
 
 		sAPCost += UIPlotPath( pSoldier, sActionGridNo, NO_COPYROUTE, fPlot, TEMPORARY, (UINT16)pSoldier->usUIMovementMode, NOT_STEALTH, FORWARD, pSoldier->bActionPoints);
-				
+
 		if ( sActionGridNo != pSoldier->sGridNo )
 		{
 			gfUIHandleShowMoveGrid = TRUE;
@@ -3896,7 +3896,7 @@ INT8 DrawUIMovementPath( SOLDIERTYPE *pSoldier, UINT16 usMapPos, UINT32 uiFlags
 			INT16 sNewGridNo;
 			UINT8	ubDirection;
 
-		  sNewGridNo = FindGridNoFromSweetSpotWithStructDataFromSoldier( pSoldier, pSoldier->usUIMovementMode, 5, &ubDirection, 0, MercPtrs[ ubMercID ] );
+			sNewGridNo = FindGridNoFromSweetSpotWithStructDataFromSoldier( pSoldier, pSoldier->usUIMovementMode, 5, &ubDirection, 0, MercPtrs[ ubMercID ] );
 
 			if ( sNewGridNo != NOWHERE )
 			{
@@ -3913,7 +3913,7 @@ INT8 DrawUIMovementPath( SOLDIERTYPE *pSoldier, UINT16 usMapPos, UINT32 uiFlags
 		sAPCost = GetAPsToRefuelVehicle( pSoldier );
 
 		sAPCost += UIPlotPath( pSoldier, sActionGridNo, NO_COPYROUTE, fPlot, TEMPORARY, (UINT16)pSoldier->usUIMovementMode, NOT_STEALTH, FORWARD, pSoldier->bActionPoints);
-				
+
 		if ( sActionGridNo != pSoldier->sGridNo )
 		{
 			gfUIHandleShowMoveGrid = TRUE;
@@ -3922,103 +3922,103 @@ INT8 DrawUIMovementPath( SOLDIERTYPE *pSoldier, UINT16 usMapPos, UINT32 uiFlags
 	}
 	else if ( uiFlags == MOVEUI_TARGET_MERCS )
 	{
-		   INT16		sGotLocation = NOWHERE;
-		   BOOLEAN	fGotAdjacent = FALSE;
+		INT16		sGotLocation = NOWHERE;
+		BOOLEAN	fGotAdjacent = FALSE;
 
-			// Check if we are on a target
-			if ( gfUIFullTargetFound )
+		// Check if we are on a target
+		if ( gfUIFullTargetFound )
+		{
+			INT32		cnt;
+			INT16		sSpot;	
+			UINT8		ubGuyThere;
+
+			for ( cnt = 0; cnt < NUM_WORLD_DIRECTIONS; cnt++ )
 			{
-				 INT32		cnt;
-				 INT16		sSpot;	
-				 UINT8		ubGuyThere;
+				sSpot = (INT16)NewGridNo( pSoldier->sGridNo, DirectionInc( (INT8)cnt ) );
 
-				 for ( cnt = 0; cnt < NUM_WORLD_DIRECTIONS; cnt++ )
-				 {
-						sSpot = (INT16)NewGridNo( pSoldier->sGridNo, DirectionInc( (INT8)cnt ) );
-
-            // Make sure movement costs are OK....
-            if ( gubWorldMovementCosts[ sSpot ][ cnt ][ gsInterfaceLevel ] >= TRAVELCOST_BLOCKED )
-            {
-              continue;
-            }
+				// Make sure movement costs are OK....
+				if ( gubWorldMovementCosts[ sSpot ][ cnt ][ gsInterfaceLevel ] >= TRAVELCOST_BLOCKED )
+				{
+					continue;
+				}
 
 
-						// Check for who is there...
-						ubGuyThere = WhoIsThere2( sSpot, pSoldier->bLevel );
+				// Check for who is there...
+				ubGuyThere = WhoIsThere2( sSpot, pSoldier->bLevel );
 
-						if ( ubGuyThere == MercPtrs[ gusUIFullTargetID ]->ubID )
-						{
-							// We've got a guy here....
-							// Who is the one we want......
-							sGotLocation = sSpot;
-							sAdjustedGridNo	= MercPtrs[ gusUIFullTargetID ]->sGridNo;
-							ubDirection		= ( UINT8 )cnt;
-							break;
-						}
-				 }
+				if ( ubGuyThere == MercPtrs[ gusUIFullTargetID ]->ubID )
+				{
+					// We've got a guy here....
+					// Who is the one we want......
+					sGotLocation = sSpot;
+					sAdjustedGridNo	= MercPtrs[ gusUIFullTargetID ]->sGridNo;
+					ubDirection		= ( UINT8 )cnt;
+					break;
+				}
+			}
 
-				 if ( sGotLocation == NOWHERE )
-				 {
-						sActionGridNo =  FindAdjacentGridEx( pSoldier, MercPtrs[ gusUIFullTargetID ]->sGridNo, &ubDirection, &sAdjustedGridNo, TRUE, FALSE );
+			if ( sGotLocation == NOWHERE )
+			{
+				sActionGridNo =  FindAdjacentGridEx( pSoldier, MercPtrs[ gusUIFullTargetID ]->sGridNo, &ubDirection, &sAdjustedGridNo, TRUE, FALSE );
 
-						if ( sActionGridNo == -1 )
-						{
-							sGotLocation = NOWHERE;
-						}
-						else
-						{
-							sGotLocation = sActionGridNo;
-						}
-						fGotAdjacent = TRUE;
-				 }
-      }
-      else
-      {
-        sAdjustedGridNo = usMapPos;
-			  sGotLocation = sActionGridNo;
+				if ( sActionGridNo == -1 )
+				{
+					sGotLocation = NOWHERE;
+				}
+				else
+				{
+					sGotLocation = sActionGridNo;
+				}
 				fGotAdjacent = TRUE;
-      }
+			}
+		}
+		else
+		{
+			sAdjustedGridNo = usMapPos;
+			sGotLocation = sActionGridNo;
+			fGotAdjacent = TRUE;
+		}
 
-			 if ( sGotLocation != NOWHERE )
-			 {
-				 sAPCost += MinAPsToAttack( pSoldier, sAdjustedGridNo, TRUE );
+		if ( sGotLocation != NOWHERE )
+		{
+			sAPCost += MinAPsToAttack( pSoldier, sAdjustedGridNo, TRUE );
 
-				 // WANNE: Turn around APs were missing!
-				//sAPCost += APsToTurnAround(pSoldier, sAdjustedGridNo);
-				
-				 sAPCost += UIPlotPath( pSoldier, sGotLocation, NO_COPYROUTE, fPlot, TEMPORARY, (UINT16)pSoldier->usUIMovementMode, NOT_STEALTH, FORWARD, pSoldier->bActionPoints);
+			// WANNE: Turn around APs were missing!
+			//sAPCost += APsToTurnAround(pSoldier, sAdjustedGridNo);
 
-				 if ( sGotLocation != pSoldier->sGridNo && fGotAdjacent )
-				 {
-						gfUIHandleShowMoveGrid = TRUE;
-						gsUIHandleShowMoveGridLocation = sGotLocation;
-				 }
-			 }
+			sAPCost += UIPlotPath( pSoldier, sGotLocation, NO_COPYROUTE, fPlot, TEMPORARY, (UINT16)pSoldier->usUIMovementMode, NOT_STEALTH, FORWARD, pSoldier->bActionPoints);
+
+			if ( sGotLocation != pSoldier->sGridNo && fGotAdjacent )
+			{
+				gfUIHandleShowMoveGrid = TRUE;
+				gsUIHandleShowMoveGridLocation = sGotLocation;
+			}
+		}
 	}
 	else if ( uiFlags == MOVEUI_TARGET_STEAL )
 	{
-			// Check if we are on a target
-			if ( gfUIFullTargetFound )
+		// Check if we are on a target
+		if ( gfUIFullTargetFound )
+		{
+			sActionGridNo =  FindAdjacentGridEx( pSoldier, MercPtrs[ gusUIFullTargetID ]->sGridNo, &ubDirection, &sAdjustedGridNo, TRUE, FALSE );
+			if ( sActionGridNo == -1 )
 			{
-				sActionGridNo =  FindAdjacentGridEx( pSoldier, MercPtrs[ gusUIFullTargetID ]->sGridNo, &ubDirection, &sAdjustedGridNo, TRUE, FALSE );
-				if ( sActionGridNo == -1 )
-				{
-					sActionGridNo = sAdjustedGridNo;
-				}
-				sAPCost += AP_STEAL_ITEM;
-				// CJC August 13 2002: take into account stance in AP prediction
-				if (!(PTR_STANDING))
-				{
-					sAPCost += GetAPsToChangeStance( pSoldier, ANIM_STAND );
-				}
-				sAPCost += UIPlotPath( pSoldier, sActionGridNo, NO_COPYROUTE, fPlot, TEMPORARY, (UINT16)pSoldier->usUIMovementMode, NOT_STEALTH, FORWARD, pSoldier->bActionPoints);
-
-				if ( sActionGridNo != pSoldier->sGridNo )
-				{
-					gfUIHandleShowMoveGrid = TRUE;
-					gsUIHandleShowMoveGridLocation = sActionGridNo;
-				}
+				sActionGridNo = sAdjustedGridNo;
 			}
+			sAPCost += AP_STEAL_ITEM;
+			// CJC August 13 2002: take into account stance in AP prediction
+			if (!(PTR_STANDING))
+			{
+				sAPCost += GetAPsToChangeStance( pSoldier, ANIM_STAND );
+			}
+			sAPCost += UIPlotPath( pSoldier, sActionGridNo, NO_COPYROUTE, fPlot, TEMPORARY, (UINT16)pSoldier->usUIMovementMode, NOT_STEALTH, FORWARD, pSoldier->bActionPoints);
+
+			if ( sActionGridNo != pSoldier->sGridNo )
+			{
+				gfUIHandleShowMoveGrid = TRUE;
+				gsUIHandleShowMoveGridLocation = sActionGridNo;
+			}
+		}
 	}
 	else if ( uiFlags == MOVEUI_TARGET_BOMB )
 	{
@@ -4030,28 +4030,28 @@ INT8 DrawUIMovementPath( SOLDIERTYPE *pSoldier, UINT16 usMapPos, UINT32 uiFlags
 	}
 	else if ( uiFlags == MOVEUI_TARGET_MERCSFORAID )
 	{
-			if ( gfUIFullTargetFound )
+		if ( gfUIFullTargetFound )
+		{
+			sActionGridNo =  FindAdjacentGridEx( pSoldier, MercPtrs[ gusUIFullTargetID ]->sGridNo, &ubDirection, &sAdjustedGridNo, TRUE, FALSE );
+
+			// Try again at another gridno...
+			if ( sActionGridNo == -1 )
 			{
-				sActionGridNo =  FindAdjacentGridEx( pSoldier, MercPtrs[ gusUIFullTargetID ]->sGridNo, &ubDirection, &sAdjustedGridNo, TRUE, FALSE );
+				sActionGridNo =  FindAdjacentGridEx( pSoldier, usMapPos, &ubDirection, &sAdjustedGridNo, TRUE, FALSE );
 
-				// Try again at another gridno...
 				if ( sActionGridNo == -1 )
 				{
-					sActionGridNo =  FindAdjacentGridEx( pSoldier, usMapPos, &ubDirection, &sAdjustedGridNo, TRUE, FALSE );
-
-					if ( sActionGridNo == -1 )
-					{
-						sActionGridNo = sAdjustedGridNo;
-					}
-				}
-				sAPCost += GetAPsToBeginFirstAid( pSoldier );
-				sAPCost += UIPlotPath( pSoldier, sActionGridNo, NO_COPYROUTE, fPlot, TEMPORARY, (UINT16)pSoldier->usUIMovementMode, NOT_STEALTH, FORWARD, pSoldier->bActionPoints);
-				if ( sActionGridNo != pSoldier->sGridNo )
-				{
-					gfUIHandleShowMoveGrid = TRUE;
-					gsUIHandleShowMoveGridLocation = sActionGridNo;
+					sActionGridNo = sAdjustedGridNo;
 				}
 			}
+			sAPCost += GetAPsToBeginFirstAid( pSoldier );
+			sAPCost += UIPlotPath( pSoldier, sActionGridNo, NO_COPYROUTE, fPlot, TEMPORARY, (UINT16)pSoldier->usUIMovementMode, NOT_STEALTH, FORWARD, pSoldier->bActionPoints);
+			if ( sActionGridNo != pSoldier->sGridNo )
+			{
+				gfUIHandleShowMoveGrid = TRUE;
+				gsUIHandleShowMoveGridLocation = sActionGridNo;
+			}
+		}
 	}
 	else if ( uiFlags == MOVEUI_TARGET_ITEMS )
 	{
@@ -4071,7 +4071,7 @@ INT8 DrawUIMovementPath( SOLDIERTYPE *pSoldier, UINT16 usMapPos, UINT32 uiFlags
 				}
 				else
 				{
-						sAPCost += AP_PICKUP_ITEM;
+					sAPCost += AP_PICKUP_ITEM;
 				}
 
 				if ( sActionGridNo != pSoldier->sGridNo )
@@ -4117,15 +4117,15 @@ INT16 APsToTurnAround(SOLDIERTYPE *pSoldier, INT16 sAdjustedGridNo)
 			// Which position has the soldier?
 			switch( gAnimControl[ pSoldier->usAnimState ].ubEndHeight )
 			{
-				case ANIM_STAND:
-					sAPCost += AP_LOOK_STANDING;
-					break;
-				case ANIM_CROUCH:
-					sAPCost += AP_LOOK_CROUCHED;
-					break;
-				case ANIM_PRONE:
-					sAPCost += AP_LOOK_PRONE;
-					break;
+			case ANIM_STAND:
+				sAPCost += AP_LOOK_STANDING;
+				break;
+			case ANIM_CROUCH:
+				sAPCost += AP_LOOK_CROUCHED;
+				break;
+			case ANIM_PRONE:
+				sAPCost += AP_LOOK_PRONE;
+				break;
 			}
 		}
 	}
@@ -4136,7 +4136,7 @@ INT16 APsToTurnAround(SOLDIERTYPE *pSoldier, INT16 sAdjustedGridNo)
 
 BOOLEAN UIMouseOnValidAttackLocation( SOLDIERTYPE *pSoldier )
 {
-  UINT16 usInHand;
+	UINT16 usInHand;
 	BOOLEAN						fGuyHere = FALSE;
 	SOLDIERTYPE				*pTSoldier;
 	UINT8							ubItemCursor;
@@ -4148,7 +4148,7 @@ BOOLEAN UIMouseOnValidAttackLocation( SOLDIERTYPE *pSoldier )
 	}
 
 	// LOOK IN GUY'S HAND TO CHECK LOCATION
-  usInHand = pSoldier->inv[HANDPOS].usItem;
+	usInHand = pSoldier->inv[HANDPOS].usItem;
 
 	// Get cursor value
 	ubItemCursor  =  GetActionModeCursor( pSoldier );
@@ -4229,16 +4229,16 @@ BOOLEAN UIMouseOnValidAttackLocation( SOLDIERTYPE *pSoldier )
 		}
 	}
 
-  if ( !CanPlayerUseRocketRifle( pSoldier, TRUE ) )
-  {
-    return( FALSE );
-  }
+	if ( !CanPlayerUseRocketRifle( pSoldier, TRUE ) )
+	{
+		return( FALSE );
+	}
 
 	//if ( Item[ usInHand ].usItemClass == IC_BLADE && usInHand != THROWING_KNIFE )	
 	//{
 	//	if ( !fGuyHere )
 	//	{
-		//	return( FALSE );
+	//	return( FALSE );
 	//	}
 	//}
 
@@ -4281,11 +4281,11 @@ BOOLEAN UIMouseOnValidAttackLocation( SOLDIERTYPE *pSoldier )
 			return( FALSE );
 		}
 
-    if ( pTSoldier->bBleeding == 0 && pTSoldier->bLife != pTSoldier->bLifeMax )
-    {
+		if ( pTSoldier->bBleeding == 0 && pTSoldier->bLife != pTSoldier->bLifeMax )
+		{
 			ScreenMsg( FONT_MCOLOR_LTYELLOW, MSG_UI_FEEDBACK, gzLateLocalizedString[ 19 ], pTSoldier->name );
 			return( FALSE );
-    }
+		}
 
 		if ( pTSoldier->bBleeding == 0 && pTSoldier->bLife >= OKLIFE )
 		{
@@ -4316,7 +4316,7 @@ BOOLEAN UIOkForItemPickup( SOLDIERTYPE *pSoldier, INT16 sGridNo )
 		{
 			//if ( !ITEMPOOL_VISIBLE( pItemPool ) )
 			{
-		//		return( FALSE );
+				//		return( FALSE );
 			}
 		}
 
@@ -4341,26 +4341,26 @@ BOOLEAN SoldierCanAffordNewStance( SOLDIERTYPE *pSoldier, UINT8 ubDesiredStance
 
 	switch( bCurrentHeight )
 	{
-		case ANIM_STAND - ANIM_CROUCH:
-		case ANIM_CROUCH - ANIM_STAND:
+	case ANIM_STAND - ANIM_CROUCH:
+	case ANIM_CROUCH - ANIM_STAND:
 
-			bAP = AP_CROUCH;
-			bBP = BP_CROUCH;
-			break;
+		bAP = AP_CROUCH;
+		bBP = BP_CROUCH;
+		break;
 
-		case ANIM_STAND - ANIM_PRONE:
-		case ANIM_PRONE - ANIM_STAND:
+	case ANIM_STAND - ANIM_PRONE:
+	case ANIM_PRONE - ANIM_STAND:
 
-			bAP = AP_CROUCH + AP_PRONE;
-			bBP = BP_CROUCH + BP_PRONE;
-			break;
+		bAP = AP_CROUCH + AP_PRONE;
+		bBP = BP_CROUCH + BP_PRONE;
+		break;
 
-		case ANIM_CROUCH - ANIM_PRONE:
-		case ANIM_PRONE - ANIM_CROUCH:
+	case ANIM_CROUCH - ANIM_PRONE:
+	case ANIM_PRONE - ANIM_CROUCH:
 
-			bAP = AP_PRONE;
-			bBP = BP_PRONE;
-			break;
+		bAP = AP_PRONE;
+		bBP = BP_PRONE;
+		break;
 
 	}
 
@@ -4372,17 +4372,17 @@ void SetUIbasedOnStance( SOLDIERTYPE *pSoldier, INT8 bNewStance )
 	// Set UI based on our stance!
 	switch ( bNewStance )
 	{
-			case ANIM_STAND:
-				pSoldier->usUIMovementMode = WALKING;
-				break;
+	case ANIM_STAND:
+		pSoldier->usUIMovementMode = WALKING;
+		break;
 
-			case ANIM_CROUCH:
-				pSoldier->usUIMovementMode = SWATTING;
-				break;
+	case ANIM_CROUCH:
+		pSoldier->usUIMovementMode = SWATTING;
+		break;
 
-			case ANIM_PRONE:
-				pSoldier->usUIMovementMode = CRAWLING;
-				break;
+	case ANIM_PRONE:
+		pSoldier->usUIMovementMode = CRAWLING;
+		break;
 	}
 
 	// Set UI cursor!
@@ -4394,32 +4394,32 @@ void SetMovementModeCursor( SOLDIERTYPE *pSoldier )
 {
 	if ( gTacticalStatus.uiFlags & TURNBASED && ( gTacticalStatus.uiFlags & INCOMBAT ) )
 	{
-			if ( ( OK_ENTERABLE_VEHICLE( pSoldier ) ) )
+		if ( ( OK_ENTERABLE_VEHICLE( pSoldier ) ) )
+		{
+			guiNewUICursor = MOVE_VEHICLE_UICURSOR;
+		}
+		else
+		{
+			// Change mouse cursor based on type of movement we want to do
+			switch ( pSoldier->usUIMovementMode )
 			{
-				guiNewUICursor = MOVE_VEHICLE_UICURSOR;
-			}
-			else
-			{
-				// Change mouse cursor based on type of movement we want to do
-				switch ( pSoldier->usUIMovementMode )
-				{
-						case WALKING:
-							guiNewUICursor = MOVE_WALK_UICURSOR;
-							break;
+			case WALKING:
+				guiNewUICursor = MOVE_WALK_UICURSOR;
+				break;
 
-						case RUNNING:
-							guiNewUICursor = MOVE_RUN_UICURSOR;
-							break;
+			case RUNNING:
+				guiNewUICursor = MOVE_RUN_UICURSOR;
+				break;
 
-						case SWATTING:
-							guiNewUICursor = MOVE_SWAT_UICURSOR;
-							break;
+			case SWATTING:
+				guiNewUICursor = MOVE_SWAT_UICURSOR;
+				break;
 
-						case CRAWLING:
-							guiNewUICursor = MOVE_PRONE_UICURSOR;
-							break;
-				}
+			case CRAWLING:
+				guiNewUICursor = MOVE_PRONE_UICURSOR;
+				break;
 			}
+		}
 	}
 
 	if ( ( gTacticalStatus.uiFlags & REALTIME ) || !( gTacticalStatus.uiFlags & INCOMBAT ) )
@@ -4438,7 +4438,7 @@ void SetMovementModeCursor( SOLDIERTYPE *pSoldier )
 			guiNewUICursor = MOVE_REALTIME_UICURSOR;
 		}
 	}
-	
+
 	guiNewUICursor = GetInteractiveTileCursor( guiNewUICursor, FALSE );
 
 }
@@ -4460,21 +4460,21 @@ void SetConfirmMovementModeCursor( SOLDIERTYPE *pSoldier, BOOLEAN fFromMove )
 				// Change mouse cursor based on type of movement we want to do
 				switch ( pSoldier->usUIMovementMode )
 				{
-						case WALKING:
-							guiNewUICursor = ALL_MOVE_WALK_UICURSOR;
-							break;
+				case WALKING:
+					guiNewUICursor = ALL_MOVE_WALK_UICURSOR;
+					break;
 
-						case RUNNING:
-							guiNewUICursor = ALL_MOVE_RUN_UICURSOR;
-							break;
+				case RUNNING:
+					guiNewUICursor = ALL_MOVE_RUN_UICURSOR;
+					break;
 
-						case SWATTING:
-							guiNewUICursor = ALL_MOVE_SWAT_UICURSOR;
-							break;
+				case SWATTING:
+					guiNewUICursor = ALL_MOVE_SWAT_UICURSOR;
+					break;
 
-						case CRAWLING:
-							guiNewUICursor = ALL_MOVE_PRONE_UICURSOR;
-							break;
+				case CRAWLING:
+					guiNewUICursor = ALL_MOVE_PRONE_UICURSOR;
+					break;
 				}
 			}
 		}
@@ -4489,21 +4489,21 @@ void SetConfirmMovementModeCursor( SOLDIERTYPE *pSoldier, BOOLEAN fFromMove )
 				// Change mouse cursor based on type of movement we want to do
 				switch ( pSoldier->usUIMovementMode )
 				{
-						case WALKING:
-							guiNewUICursor = CONFIRM_MOVE_WALK_UICURSOR;
-							break;
+				case WALKING:
+					guiNewUICursor = CONFIRM_MOVE_WALK_UICURSOR;
+					break;
 
-						case RUNNING:
-							guiNewUICursor = CONFIRM_MOVE_RUN_UICURSOR;
-							break;
+				case RUNNING:
+					guiNewUICursor = CONFIRM_MOVE_RUN_UICURSOR;
+					break;
 
-						case SWATTING:
-							guiNewUICursor = CONFIRM_MOVE_SWAT_UICURSOR;
-							break;
+				case SWATTING:
+					guiNewUICursor = CONFIRM_MOVE_SWAT_UICURSOR;
+					break;
 
-						case CRAWLING:
-							guiNewUICursor = CONFIRM_MOVE_PRONE_UICURSOR;
-							break;
+				case CRAWLING:
+					guiNewUICursor = CONFIRM_MOVE_PRONE_UICURSOR;
+					break;
 				}
 			}
 		}
@@ -4811,7 +4811,7 @@ UINT32 UIHandleTOnTerrain( UI_EVENT *pUIEvent )
 			guiNewUICursor = TALK_OUT_RANGE_NA_UICURSOR;				
 		}
 	}
-	
+
 	if ( fValidTalkableGuy )
 	{
 		if ( !SoldierTo3DLocationLineOfSightTest( pSoldier, sTargetGridNo,  pSoldier->bLevel, 3, (UINT8) sDistVisible, TRUE ) )
@@ -4821,13 +4821,13 @@ UINT32 UIHandleTOnTerrain( UI_EVENT *pUIEvent )
 		}
 	}
 
-	 gfUIDisplayActionPoints = TRUE;
+	gfUIDisplayActionPoints = TRUE;
 
-	 gUIDisplayActionPointsOffX = 8;
-	 gUIDisplayActionPointsOffY = 3;
+	gUIDisplayActionPointsOffX = 8;
+	gUIDisplayActionPointsOffY = 3;
 
-	 // Set # of APs
-	 gsCurrentActionPoints = 6;
+	// Set # of APs
+	gsCurrentActionPoints = 6;
 
 	// Determine if we can afford!
 	if ( !EnoughPoints( pSoldier, gsCurrentActionPoints, 0, FALSE ) )
@@ -4863,7 +4863,7 @@ UINT32 UIHandleTChangeToTalking( UI_EVENT *pUIEvent )
 UINT32 UIHandleLUIOnTerrain( UI_EVENT *pUIEvent )
 {
 	//guiNewUICursor = NO_UICURSOR;
-//	SetCurrentCursorFromDatabase( VIDEO_NO_CURSOR );
+	//	SetCurrentCursorFromDatabase( VIDEO_NO_CURSOR );
 
 	return( GAME_SCREEN );
 }
@@ -4883,7 +4883,7 @@ UINT32 UIHandleLUIBeginLock( UI_EVENT *pUIEvent )
 		//SetCurrentCursorFromDatabase( VIDEO_NO_CURSOR );
 
 		MSYS_DefineRegion( &gDisableRegion, 0, 0 ,SCREEN_WIDTH, SCREEN_HEIGHT, MSYS_PRIORITY_HIGHEST,
-							 CURSOR_WAIT, MSYS_NO_CALLBACK, MSYS_NO_CALLBACK );
+			CURSOR_WAIT, MSYS_NO_CALLBACK, MSYS_NO_CALLBACK );
 		// Add region
 		MSYS_AddRegion( &gDisableRegion );
 
@@ -4892,9 +4892,9 @@ UINT32 UIHandleLUIBeginLock( UI_EVENT *pUIEvent )
 		// UnPause time!
 		PauseGame();
 		LockPauseState( 16 );
-		
+
 	}
-	
+
 	return( GAME_SCREEN );
 }
 
@@ -4913,7 +4913,7 @@ UINT32 UIHandleLUIEndLock( UI_EVENT *pUIEvent )
 		guiForceRefreshMousePositionCalculation = TRUE;
 		UIHandleMOnTerrain( NULL );
 
-	  if ( gViewportRegion.uiFlags & MSYS_MOUSE_IN_AREA )
+		if ( gViewportRegion.uiFlags & MSYS_MOUSE_IN_AREA )
 		{
 			SetCurrentCursorFromDatabase( gUICursors[ guiNewUICursor ].usFreeCursorName );
 		}
@@ -4942,7 +4942,7 @@ void CheckForDisabledRegionRemove( )
 
 		// Remove region
 		MSYS_RemoveRegion( &gDisableRegion );	
-    
+
 		UnLockPauseState();
 		UnPauseGame();
 
@@ -5014,9 +5014,9 @@ void EndMultiSoldierSelection( BOOLEAN fAcknowledge )
 	SOLDIERTYPE			*pFirstSoldier = NULL;
 	BOOLEAN					fSelectedSoldierInBatch = FALSE;
 
-	
+
 	gTacticalStatus.fAtLeastOneGuyOnMultiSelect = FALSE;
-	
+
 
 	// OK, loop through all guys who are 'multi-selected' and
 	// check if our currently selected guy is amoung the
@@ -5065,13 +5065,13 @@ void StopRubberBandedMercFromMoving( )
 	SOLDIERTYPE *		pSoldier;
 	INT32						cnt;
 	SOLDIERTYPE			*pFirstSoldier = NULL;
-	
+
 
 	if ( !gTacticalStatus.fAtLeastOneGuyOnMultiSelect )
 	{
 		return;
 	}
-	
+
 	// OK, loop through all guys who are 'multi-selected' and
 	// check if our currently selected guy is amoung the
 	// lucky few.. if not, change to a guy who is...
@@ -5142,14 +5142,14 @@ BOOLEAN HandleMultiSelectionMove( INT16 sDestGridNo )
 		{
 			if ( pSoldier->uiStatusFlags & SOLDIER_MULTI_SELECTED )
 			{
-	      // If we can't be controlled, returninvalid...
-	      if ( pSoldier->uiStatusFlags & SOLDIER_ROBOT )
-	      {
-		      if ( !CanRobotBeControlled( pSoldier ) )
-          {
-            continue;
-          }
-        }
+				// If we can't be controlled, returninvalid...
+				if ( pSoldier->uiStatusFlags & SOLDIER_ROBOT )
+				{
+					if ( !CanRobotBeControlled( pSoldier ) )
+					{
+						continue;
+					}
+				}
 
 				pSoldier->fUIMovementFast  = fMoveFast;
 				pSoldier->usUIMovementMode =  GetMoveStateBasedOnStance( pSoldier, gAnimControl[ pSoldier->usAnimState ].ubEndHeight );
@@ -5168,7 +5168,7 @@ BOOLEAN HandleMultiSelectionMove( INT16 sDestGridNo )
 				// Remove any previous actions
 				pSoldier->ubPendingAction		 = NO_PENDING_ACTION;
 
-				
+
 				if ( EVENT_InternalGetNewSoldierPath( pSoldier, sDestGridNo, pSoldier->usUIMovementMode , TRUE, pSoldier->fNoAPToFinishMove ) )
 				{
 					InternalDoMercBattleSound( pSoldier, BATTLE_SOUND_OK1, BATTLE_SND_LOWER_VOLUME );
@@ -5220,7 +5220,7 @@ UINT32 UIHandleRubberBandOnTerrain( UI_EVENT *pUIEvent )
 	INT16						sScreenX, sScreenY;
 	INT32						iTemp;
 	SGPRect					aRect;
-  BOOLEAN         fAtLeastOne = FALSE;
+	BOOLEAN         fAtLeastOne = FALSE;
 
 	guiNewUICursor = NO_UICURSOR;
 	//SetCurrentCursorFromDatabase( VIDEO_NO_CURSOR );
@@ -5264,15 +5264,15 @@ UINT32 UIHandleRubberBandOnTerrain( UI_EVENT *pUIEvent )
 
 			if ( IsPointInScreenRect( sScreenX, sScreenY, &aRect ) )
 			{
-        fAtLeastOne = TRUE;
+				fAtLeastOne = TRUE;
 			}
 		}
 	}
 
-  if ( !fAtLeastOne )
-  {
-    return( GAME_SCREEN );
-  }
+	if ( !fAtLeastOne )
+	{
+		return( GAME_SCREEN );
+	}
 
 	// ATE: Now loop through our guys and see if any fit!
 	cnt = gTacticalStatus.Team[ gbPlayerNum ].bFirstID;
@@ -5334,7 +5334,7 @@ UINT32 UIHandleJumpOverOnTerrain( UI_EVENT *pUIEvent )
 	// Display APs....
 	gsCurrentActionPoints = GetAPsToJumpOver( pSoldier );
 
-  gfUIDisplayActionPoints		 = TRUE;
+	gfUIDisplayActionPoints		 = TRUE;
 	gfUIDisplayActionPointsCenter = TRUE;
 
 	guiNewUICursor = JUMP_OVER_UICURSOR;
@@ -5403,7 +5403,7 @@ UINT32 UIHandleLABeginLockOurTurn( UI_EVENT *pUIEvent )
 		//SetCurrentCursorFromDatabase( VIDEO_NO_CURSOR );
 
 		MSYS_DefineRegion( &gUserTurnRegion, 0, 0 ,SCREEN_WIDTH, SCREEN_HEIGHT, MSYS_PRIORITY_HIGHEST,
-							 CURSOR_WAIT, MSYS_NO_CALLBACK, MSYS_NO_CALLBACK );
+			CURSOR_WAIT, MSYS_NO_CALLBACK, MSYS_NO_CALLBACK );
 		// Add region
 		MSYS_AddRegion( &gUserTurnRegion );
 
@@ -5437,7 +5437,7 @@ UINT32 UIHandleLAEndLockOurTurn( UI_EVENT *pUIEvent )
 		guiForceRefreshMousePositionCalculation = TRUE;
 		UIHandleMOnTerrain( NULL );
 
-	  if ( gViewportRegion.uiFlags & MSYS_MOUSE_IN_AREA )
+		if ( gViewportRegion.uiFlags & MSYS_MOUSE_IN_AREA )
 		{
 			SetCurrentCursorFromDatabase( gUICursors[ guiNewUICursor ].usFreeCursorName );
 		}
@@ -5461,8 +5461,8 @@ BOOLEAN IsValidTalkableNPCFromMouse( UINT8 *pubSoldierID , BOOLEAN fGive, BOOLEA
 	// Check if there is a guy here to talk to!
 	if ( gfUIFullTargetFound )
 	{
-			*pubSoldierID = (UINT8)gusUIFullTargetID;
-			return( IsValidTalkableNPC( (UINT8)gusUIFullTargetID, fGive, fAllowMercs, fCheckCollapsed ) );
+		*pubSoldierID = (UINT8)gusUIFullTargetID;
+		return( IsValidTalkableNPC( (UINT8)gusUIFullTargetID, fGive, fAllowMercs, fCheckCollapsed ) );
 	}
 
 	return( FALSE );
@@ -5495,10 +5495,10 @@ BOOLEAN IsValidTalkableNPC( UINT8 ubSoldierID, BOOLEAN fGive , BOOLEAN fAllowMer
 		return( FALSE );
 	}
 
-  if ( pSoldier->bCollapsed && fCheckCollapsed )
-  {
-    return( FALSE );
-  }
+	if ( pSoldier->bCollapsed && fCheckCollapsed )
+	{
+		return( FALSE );
+	}
 
 	if ( pSoldier->uiStatusFlags & SOLDIER_VEHICLE )
 	{
@@ -5603,7 +5603,7 @@ BOOLEAN HandleTalkInit(  )
 				{
 					//ATE: Check if we have good LOS
 					// is he close enough to see that gridno if he turns his head?
-				  sDistVisible = DistanceVisible( pSoldier, DIRECTION_IRRELEVANT, DIRECTION_IRRELEVANT, pTSoldier->sGridNo, pTSoldier->bLevel, pTSoldier );
+					sDistVisible = DistanceVisible( pSoldier, DIRECTION_IRRELEVANT, DIRECTION_IRRELEVANT, pTSoldier->sGridNo, pTSoldier->bLevel, pTSoldier );
 
 					// Check LOS!
 					if ( !SoldierTo3DLocationLineOfSightTest( pSoldier, pTSoldier->sGridNo,  pTSoldier->bLevel, 3, (UINT8) sDistVisible, TRUE ) )
@@ -5881,75 +5881,75 @@ INT8 UIHandleInteractiveTilesAndItemsOnTerrain( SOLDIERTYPE *pSoldier, INT16 usM
 
 	if ( gfUIFullTargetFound  )
 	{
-		 pTSoldier = MercPtrs[ gusUIFullTargetID ];
+		pTSoldier = MercPtrs[ gusUIFullTargetID ];
 
-		 if ( OK_ENTERABLE_VEHICLE( pTSoldier ) && pTSoldier->bVisible != -1 )
-		 {
-				// grab number of occupants in vehicles
-				if ( fItemsOnlyIfOnIntTiles )
+		if ( OK_ENTERABLE_VEHICLE( pTSoldier ) && pTSoldier->bVisible != -1 )
+		{
+			// grab number of occupants in vehicles
+			if ( fItemsOnlyIfOnIntTiles )
+			{
+				if ( !OKUseVehicle( pTSoldier->ubProfile ) )
 				{
-					if ( !OKUseVehicle( pTSoldier->ubProfile ) )
+					// Set UI CURSOR....
+					guiNewUICursor = CANNOT_MOVE_UICURSOR;	
+
+					gfBeginVehicleCursor = TRUE;
+					return( 1 );
+				}
+				else
+				{
+					if ( GetNumberInVehicle( pTSoldier->bVehicleID ) == 0 )
 					{
 						// Set UI CURSOR....
-						guiNewUICursor = CANNOT_MOVE_UICURSOR;	
+						guiNewUICursor = ENTER_VEHICLE_UICURSOR;	
 
 						gfBeginVehicleCursor = TRUE;
 						return( 1 );
 					}
-					else
-					{
-						if ( GetNumberInVehicle( pTSoldier->bVehicleID ) == 0 )
-						{
-							// Set UI CURSOR....
-							guiNewUICursor = ENTER_VEHICLE_UICURSOR;	
+				}
+			}
+			else
+			{
+				// Set UI CURSOR....
+				guiNewUICursor = ENTER_VEHICLE_UICURSOR;	
+				return( 1 );
+			}
+		}
 
-							gfBeginVehicleCursor = TRUE;
-							return( 1 );
-						}
-					}
+		if ( !fItemsOnlyIfOnIntTiles )
+		{
+			if ( ( guiUIFullTargetFlags & ENEMY_MERC ) && !( guiUIFullTargetFlags & UNCONSCIOUS_MERC ) )
+			{
+				if ( !fOverEnemy )
+				{
+					fOverEnemy = TRUE;
+					gfPlotNewMovement = TRUE;
+				}
+
+				//Set UI CURSOR
+				if ( fUseOKCursor || ( ( gTacticalStatus.uiFlags & INCOMBAT ) && ( gTacticalStatus.uiFlags & TURNBASED ) ) )
+				{
+					guiNewUICursor = OKHANDCURSOR_UICURSOR;	
 				}
 				else
 				{
-					// Set UI CURSOR....
-					guiNewUICursor = ENTER_VEHICLE_UICURSOR;	
-					return( 1 );
+					guiNewUICursor = NORMALHANDCURSOR_UICURSOR;	
 				}
-		 }
 
-		 if ( !fItemsOnlyIfOnIntTiles )
-		 {
-			 if ( ( guiUIFullTargetFlags & ENEMY_MERC ) && !( guiUIFullTargetFlags & UNCONSCIOUS_MERC ) )
-			 {
-					if ( !fOverEnemy )
-					{
-						fOverEnemy = TRUE;
-						gfPlotNewMovement = TRUE;
-					}
+				fSetCursor =  HandleUIMovementCursor( pSoldier, uiCursorFlags, sActionGridNo, MOVEUI_TARGET_STEAL );
 
-					//Set UI CURSOR
-					if ( fUseOKCursor || ( ( gTacticalStatus.uiFlags & INCOMBAT ) && ( gTacticalStatus.uiFlags & TURNBASED ) ) )
-					{
-						guiNewUICursor = OKHANDCURSOR_UICURSOR;	
-					}
-					else
-					{
-						guiNewUICursor = NORMALHANDCURSOR_UICURSOR;	
-					}
+				// Display action points
+				gfUIDisplayActionPoints = TRUE;
 
-					fSetCursor =  HandleUIMovementCursor( pSoldier, uiCursorFlags, sActionGridNo, MOVEUI_TARGET_STEAL );
+				// Determine if we can afford!
+				if ( !EnoughPoints( pSoldier, gsCurrentActionPoints, 0, FALSE ) )
+				{  
+					gfUIDisplayActionPointsInvalid = TRUE;
+				}
 
-					// Display action points
-					gfUIDisplayActionPoints = TRUE;
-
-					// Determine if we can afford!
-					if ( !EnoughPoints( pSoldier, gsCurrentActionPoints, 0, FALSE ) )
-					{  
-						gfUIDisplayActionPointsInvalid = TRUE;
-					}
-
-					return( 0 );
-			 }
-		 }
+				return( 0 );
+			}
+		}
 	}
 
 	if ( fOverEnemy )
@@ -6084,7 +6084,7 @@ INT8 UIHandleInteractiveTilesAndItemsOnTerrain( SOLDIERTYPE *pSoldier, INT16 usM
 		}
 
 	}
-	
+
 	if ( pIntTile == NULL )
 	{
 		return( 0 );
@@ -6121,30 +6121,30 @@ BOOLEAN SelectedGuyInBusyAnimation( )
 		pSoldier = MercPtrs[ gusSelectedSoldier ];
 
 		if ( pSoldier->usAnimState == LOB_ITEM || 
-				 pSoldier->usAnimState == THROW_ITEM ||
-				 //<SB> crouch throwing
-				 pSoldier->usAnimState == THROW_ITEM_CROUCHED ||
-				 //<SB> crouch throwing
-				 pSoldier->usAnimState == PICKUP_ITEM ||
-				 pSoldier->usAnimState == DROP_ITEM ||
-				 pSoldier->usAnimState == OPEN_DOOR ||
-				 pSoldier->usAnimState == OPEN_STRUCT ||
-				 pSoldier->usAnimState == OPEN_STRUCT ||
-				 pSoldier->usAnimState == END_OPEN_DOOR ||
-				 pSoldier->usAnimState == END_OPEN_LOCKED_DOOR ||
-				 pSoldier->usAnimState == ADJACENT_GET_ITEM ||
-         pSoldier->usAnimState == DROP_ADJACENT_OBJECT ||
+			pSoldier->usAnimState == THROW_ITEM ||
+			//<SB> crouch throwing
+			pSoldier->usAnimState == THROW_ITEM_CROUCHED ||
+			//<SB> crouch throwing
+			pSoldier->usAnimState == PICKUP_ITEM ||
+			pSoldier->usAnimState == DROP_ITEM ||
+			pSoldier->usAnimState == OPEN_DOOR ||
+			pSoldier->usAnimState == OPEN_STRUCT ||
+			pSoldier->usAnimState == OPEN_STRUCT ||
+			pSoldier->usAnimState == END_OPEN_DOOR ||
+			pSoldier->usAnimState == END_OPEN_LOCKED_DOOR ||
+			pSoldier->usAnimState == ADJACENT_GET_ITEM ||
+			pSoldier->usAnimState == DROP_ADJACENT_OBJECT ||
 
-				 pSoldier->usAnimState == OPEN_DOOR_CROUCHED ||
-				 pSoldier->usAnimState == BEGIN_OPENSTRUCT_CROUCHED ||
-				 pSoldier->usAnimState == CLOSE_DOOR_CROUCHED ||
-				 pSoldier->usAnimState == OPEN_DOOR_CROUCHED ||
-				 pSoldier->usAnimState == OPEN_STRUCT_CROUCHED ||
-				 pSoldier->usAnimState == END_OPENSTRUCT_CROUCHED ||
-				 pSoldier->usAnimState == END_OPEN_DOOR_CROUCHED ||
-				 pSoldier->usAnimState == END_OPEN_LOCKED_DOOR_CROUCHED ||
-				 pSoldier->usAnimState == END_OPENSTRUCT_LOCKED_CROUCHED ||
-				 pSoldier->usAnimState == BEGIN_OPENSTRUCT )
+			pSoldier->usAnimState == OPEN_DOOR_CROUCHED ||
+			pSoldier->usAnimState == BEGIN_OPENSTRUCT_CROUCHED ||
+			pSoldier->usAnimState == CLOSE_DOOR_CROUCHED ||
+			pSoldier->usAnimState == OPEN_DOOR_CROUCHED ||
+			pSoldier->usAnimState == OPEN_STRUCT_CROUCHED ||
+			pSoldier->usAnimState == END_OPENSTRUCT_CROUCHED ||
+			pSoldier->usAnimState == END_OPEN_DOOR_CROUCHED ||
+			pSoldier->usAnimState == END_OPEN_LOCKED_DOOR_CROUCHED ||
+			pSoldier->usAnimState == END_OPENSTRUCT_LOCKED_CROUCHED ||
+			pSoldier->usAnimState == BEGIN_OPENSTRUCT )
 		{
 			return( TRUE );
 		}
@@ -6160,27 +6160,27 @@ void GotoHeigherStance( SOLDIERTYPE *pSoldier )
 
 	switch( gAnimControl[ pSoldier->usAnimState ].ubEndHeight )
 	{
-		case ANIM_STAND:
+	case ANIM_STAND:
 
-			// Nowhere
-			// Try to climb
-			GetMercClimbDirection( pSoldier->ubID, &fNearLowerLevel, &fNearHeigherLevel );
+		// Nowhere
+		// Try to climb
+		GetMercClimbDirection( pSoldier->ubID, &fNearLowerLevel, &fNearHeigherLevel );
 
-			if ( fNearHeigherLevel )
-			{
-				BeginSoldierClimbUpRoof( pSoldier );
-			}
-			break;
+		if ( fNearHeigherLevel )
+		{
+			BeginSoldierClimbUpRoof( pSoldier );
+		}
+		break;
 
-		case ANIM_CROUCH:
+	case ANIM_CROUCH:
 
-			HandleStanceChangeFromUIKeys( ANIM_STAND );
-			break;
+		HandleStanceChangeFromUIKeys( ANIM_STAND );
+		break;
 
-		case ANIM_PRONE:
+	case ANIM_PRONE:
 
-			HandleStanceChangeFromUIKeys( ANIM_CROUCH );
-			break;
+		HandleStanceChangeFromUIKeys( ANIM_CROUCH );
+		break;
 	}
 }
 
@@ -6193,27 +6193,27 @@ void GotoLowerStance( SOLDIERTYPE *pSoldier )
 
 	switch( gAnimControl[ pSoldier->usAnimState ].ubEndHeight )
 	{
-		case ANIM_STAND:
+	case ANIM_STAND:
 
-			HandleStanceChangeFromUIKeys( ANIM_CROUCH );
-			break;
+		HandleStanceChangeFromUIKeys( ANIM_CROUCH );
+		break;
 
-		case ANIM_CROUCH:
+	case ANIM_CROUCH:
 
-			HandleStanceChangeFromUIKeys( ANIM_PRONE );
-			break;
+		HandleStanceChangeFromUIKeys( ANIM_PRONE );
+		break;
 
-		case ANIM_PRONE:
+	case ANIM_PRONE:
 
-			// Nowhere
-			// Try to climb
-			GetMercClimbDirection( pSoldier->ubID, &fNearLowerLevel, &fNearHeigherLevel );
+		// Nowhere
+		// Try to climb
+		GetMercClimbDirection( pSoldier->ubID, &fNearLowerLevel, &fNearHeigherLevel );
 
-			if ( fNearLowerLevel )
-			{
-				BeginSoldierClimbDownRoof( pSoldier );
-			}
-			break;
+		if ( fNearLowerLevel )
+		{
+			BeginSoldierClimbDownRoof( pSoldier );
+		}
+		break;
 	}
 }
 
@@ -6282,28 +6282,28 @@ BOOLEAN ValidQuickExchangePosition( )
 		//if ( ( pOverSoldier->bSide != gbPlayerNum ) && pOverSoldier->bNeutral  )
 		if ( ( pOverSoldier->bTeam != gbPlayerNum && pOverSoldier->bNeutral ) || (pOverSoldier->bTeam == MILITIA_TEAM && pOverSoldier->bSide == 0 ) )
 		{
-      // hehe - don't allow animals to exchange places
-      if ( !( pOverSoldier->uiStatusFlags & ( SOLDIER_ANIMAL ) ) )
-      {
-			  // OK, we have a civ , now check if they are near selected guy.....
-			  if ( GetSoldier( &pSoldier, gusSelectedSoldier ) )
-			  {
-				  if ( PythSpacesAway( pSoldier->sGridNo, pOverSoldier->sGridNo ) == 1 )
-				  {
-					  // Check if we have LOS to them....
-					  sDistVisible = DistanceVisible( pSoldier, DIRECTION_IRRELEVANT, DIRECTION_IRRELEVANT, pOverSoldier->sGridNo, pOverSoldier->bLevel, pOverSoldier );
+			// hehe - don't allow animals to exchange places
+			if ( !( pOverSoldier->uiStatusFlags & ( SOLDIER_ANIMAL ) ) )
+			{
+				// OK, we have a civ , now check if they are near selected guy.....
+				if ( GetSoldier( &pSoldier, gusSelectedSoldier ) )
+				{
+					if ( PythSpacesAway( pSoldier->sGridNo, pOverSoldier->sGridNo ) == 1 )
+					{
+						// Check if we have LOS to them....
+						sDistVisible = DistanceVisible( pSoldier, DIRECTION_IRRELEVANT, DIRECTION_IRRELEVANT, pOverSoldier->sGridNo, pOverSoldier->bLevel, pOverSoldier );
 
-					  if ( SoldierTo3DLocationLineOfSightTest( pSoldier, pOverSoldier->sGridNo,  pOverSoldier->bLevel, (UINT8)3, (UINT8) sDistVisible, TRUE ) )
-					  {
-						  // ATE:
-						  // Check that the path is good!
-						  if ( FindBestPath( pSoldier, pOverSoldier->sGridNo, pSoldier->bLevel, pSoldier->usUIMovementMode, NO_COPYROUTE, PATH_IGNORE_PERSON_AT_DEST ) == 1 )
-						  {
-							  fOnValidGuy = TRUE;
-						  }
-					  }
-				  }
-        }
+						if ( SoldierTo3DLocationLineOfSightTest( pSoldier, pOverSoldier->sGridNo,  pOverSoldier->bLevel, (UINT8)3, (UINT8) sDistVisible, TRUE ) )
+						{
+							// ATE:
+							// Check that the path is good!
+							if ( FindBestPath( pSoldier, pOverSoldier->sGridNo, pSoldier->bLevel, pSoldier->usUIMovementMode, NO_COPYROUTE, PATH_IGNORE_PERSON_AT_DEST ) == 1 )
+							{
+								fOnValidGuy = TRUE;
+							}
+						}
+					}
+				}
 			}
 		}
 	}
@@ -6337,8 +6337,8 @@ BOOLEAN IsValidJumpLocation( SOLDIERTYPE *pSoldier, INT16 sGridNo, BOOLEAN fChec
 	INT16 sDirs[4] = { NORTH, EAST, SOUTH, WEST };
 	INT32 cnt;
 	UINT8	ubGuyThere;
-  UINT8 ubMovementCost;
-  INT32 iDoorGridNo;
+	UINT8 ubMovementCost;
+	INT32 iDoorGridNo;
 
 	// First check that action point cost is zero so far
 	// ie: NO PATH!
@@ -6353,19 +6353,19 @@ BOOLEAN IsValidJumpLocation( SOLDIERTYPE *pSoldier, INT16 sGridNo, BOOLEAN fChec
 		// MOVE OUT TWO DIRECTIONS
 		sIntSpot = NewGridNo( sGridNo, DirectionInc( sDirs[ cnt ] ) );
 
-    // ATE: Check our movement costs for going through walls!
-    ubMovementCost = gubWorldMovementCosts[ sIntSpot ][ sDirs[ cnt ] ][ pSoldier->bLevel ];
-	  if ( IS_TRAVELCOST_DOOR( ubMovementCost ) )
-    {
-		  ubMovementCost = DoorTravelCost( pSoldier, sIntSpot, ubMovementCost, (BOOLEAN) (pSoldier->bTeam == gbPlayerNum), &iDoorGridNo );
-	  }
+		// ATE: Check our movement costs for going through walls!
+		ubMovementCost = gubWorldMovementCosts[ sIntSpot ][ sDirs[ cnt ] ][ pSoldier->bLevel ];
+		if ( IS_TRAVELCOST_DOOR( ubMovementCost ) )
+		{
+			ubMovementCost = DoorTravelCost( pSoldier, sIntSpot, ubMovementCost, (BOOLEAN) (pSoldier->bTeam == gbPlayerNum), &iDoorGridNo );
+		}
 
-	  // If we have hit an obstacle, STOP HERE
-	  if ( ubMovementCost >= TRAVELCOST_BLOCKED )
-	  {
-      // no good, continue
-      continue;
-    }
+		// If we have hit an obstacle, STOP HERE
+		if ( ubMovementCost >= TRAVELCOST_BLOCKED )
+		{
+			// no good, continue
+			continue;
+		}
 
 
 		// TWICE AS FAR!
@@ -6373,13 +6373,13 @@ BOOLEAN IsValidJumpLocation( SOLDIERTYPE *pSoldier, INT16 sGridNo, BOOLEAN fChec
 
 		// Is the soldier we're looking at here?
 		ubGuyThere = WhoIsThere2( sSpot, pSoldier->bLevel );
-		
+
 		// Alright folks, here we are!
 		if ( ubGuyThere == pSoldier->ubID )
 		{
 			// Double check OK destination......
-	    if ( NewOKDestination( pSoldier, sGridNo, TRUE, (INT8)gsInterfaceLevel ) )
-	    {
+			if ( NewOKDestination( pSoldier, sGridNo, TRUE, (INT8)gsInterfaceLevel ) )
+			{
 				// If the soldier in the middle of doing stuff?
 				if ( !pSoldier->fTurningUntilDone )
 				{
diff --git a/Tactical/Overhead.cpp b/Tactical/Overhead.cpp
index bb35436f..e292f1a5 100644
--- a/Tactical/Overhead.cpp
+++ b/Tactical/Overhead.cpp
@@ -7224,6 +7224,10 @@ BOOLEAN ProcessImplicationsOfPCAttack( SOLDIERTYPE * pSoldier, SOLDIERTYPE ** pp
 		else if (pTarget->ubProfile == PABLO && pTarget->bLife >= OKLIFE && CheckFact( FACT_PABLO_PUNISHED_BY_PLAYER, 0 ) && !CheckFact( 38, 0 ) )
 		{
 			TriggerNPCRecord( PABLO, 3 );
+			// Nailed Pablo.  So reset the fact that he stole from the last shipment since he's supposed to be returning
+			// the goods now.
+			SetFactFalse( FACT_PABLOS_STOLE_FROM_LATEST_SHIPMENT);
+			SetFactFalse( FACT_PLAYER_FOUND_ITEMS_MISSING);
 		}
 		else
 		{
diff --git a/Tactical/Soldier Control.cpp b/Tactical/Soldier Control.cpp
index 819fa8e6..ebec7617 100644
--- a/Tactical/Soldier Control.cpp	
+++ b/Tactical/Soldier Control.cpp	
@@ -279,7 +279,7 @@ Inventory& Inventory::operator=(const Inventory& src)
 	// This IF is just for setting breakpoints when trying to figure out inventory item problems.  Remove it later
 	if ((src.inv.size() != slotCnt) ||
 		(inv.size() != slotCnt)) {
-		int i = 0; // Set BP here if following asserts throw
+			int i = 0; // Set BP here if following asserts throw
 	}
 	Assert (src.inv.size() == slotCnt);
 	Assert (inv.size() == slotCnt);
@@ -295,8 +295,8 @@ Inventory& Inventory::operator=(const Inventory& src)
 				inv[idx] = src.inv[idx];
 			}
 		}
-    }
-    return *this;
+	}
+	return *this;
 }
 
 Inventory::~Inventory() {
@@ -308,7 +308,7 @@ OBJECTTYPE& Inventory::operator [] (int idx) {
 	if ((idx < 0) ||
 		(idx >= slotCnt) ||
 		(inv.size() != slotCnt)) {
-		int i = inv.size();  // Set BP here if following asserts throw
+			int i = inv.size();  // Set BP here if following asserts throw
 	}
 	Assert(idx >= 0);
 	Assert(idx < slotCnt);
@@ -357,13 +357,13 @@ SOLDIERTYPE::SOLDIERTYPE(const SOLDIERTYPE& src) {
 // Assignment operator
 SOLDIERTYPE& SOLDIERTYPE::operator=(const SOLDIERTYPE& src)
 {
-    if (this != &src) {
+	if (this != &src) {
 		memcpy(this, &src, SIZEOF_SOLDIERTYPE_POD);
 		inv = src.inv;
 		bNewItemCount = src.bNewItemCount;
 		bNewItemCycleCount = src.bNewItemCycleCount;
-    }
-    return *this;
+	}
+	return *this;
 }
 
 // Destructor
@@ -554,13 +554,13 @@ MERCPROFILESTRUCT::MERCPROFILESTRUCT(const MERCPROFILESTRUCT& src) {
 // Assignment operator
 MERCPROFILESTRUCT& MERCPROFILESTRUCT::operator=(const MERCPROFILESTRUCT& src)
 {
-    if (this != &src) {
+	if (this != &src) {
 		memcpy(this, &src, SIZEOF_MERCPROFILESTRUCT_POD);
 		inv = src.inv;
 		bInvStatus = src.bInvStatus;
 		bInvNumber = src.bInvNumber;
-    }
- 	Assert(inv.size() == NUM_INV_SLOTS);
+	}
+	Assert(inv.size() == NUM_INV_SLOTS);
 	Assert(bInvStatus.size() == NUM_INV_SLOTS);
 	Assert(bInvStatus.size() == NUM_INV_SLOTS);
 	return *this;
@@ -3978,7 +3978,7 @@ UINT16 PickSoldierReadyAnimation( SOLDIERTYPE *pSoldier, BOOLEAN fEndReady )
 void EVENT_SoldierGotHit( SOLDIERTYPE *pSoldier, UINT16 usWeaponIndex, INT16 sDamage, INT16 sBreathLoss, UINT16 bDirection, UINT16 sRange, UINT8 ubAttackerID, UINT8 ubSpecial, UINT8 ubHitLocation, INT16 sSubsequent, INT16 sLocationGrid )
 {
 	UINT8		ubCombinedLoss, ubVolume, ubReason;
-//	SOLDIERTYPE * pNewSoldier;
+	//	SOLDIERTYPE * pNewSoldier;
 
 	ubReason = 0;
 
@@ -3989,17 +3989,17 @@ void EVENT_SoldierGotHit( SOLDIERTYPE *pSoldier, UINT16 usWeaponIndex, INT16 sDa
 	// ATE: If we have gotten hit, but are still in our attack animation, reduce count!
 	switch ( pSoldier->usAnimState )
 	{
-		case SHOOT_ROCKET:
-		case SHOOT_MORTAR:
-		case THROW_ITEM:
+	case SHOOT_ROCKET:
+	case SHOOT_MORTAR:
+	case THROW_ITEM:
 		// <SB> crouch throwing
-		case THROW_ITEM_CROUCHED:
+	case THROW_ITEM_CROUCHED:
 		// <SB> crouch throwing
-		case LOB_ITEM:
-			
-			DebugMsg( TOPIC_JA2, DBG_LEVEL_3, String("@@@@@@@ Freeing up attacker - ATTACK ANIMATION %s ENDED BY HIT ANIMATION, Now %d", gAnimControl[ pSoldier->usAnimState ].zAnimStr, gTacticalStatus.ubAttackBusyCount ) );
-			ReduceAttackBusyCount( pSoldier->ubID, FALSE );
-			break;
+	case LOB_ITEM:
+
+		DebugMsg( TOPIC_JA2, DBG_LEVEL_3, String("@@@@@@@ Freeing up attacker - ATTACK ANIMATION %s ENDED BY HIT ANIMATION, Now %d", gAnimControl[ pSoldier->usAnimState ].zAnimStr, gTacticalStatus.ubAttackBusyCount ) );
+		ReduceAttackBusyCount( pSoldier->ubID, FALSE );
+		break;
 	}
 #endif
 
@@ -5072,7 +5072,9 @@ BOOLEAN EVENT_InternalGetNewSoldierPath( SOLDIERTYPE *pSoldier, UINT16 sDestGrid
 #endif
 		iDest = FindBestPath( pSoldier, sDestGridNo, pSoldier->bLevel, usMovementAnim, COPYROUTE, fFlags );
 		fContinue = (iDest != 0);
-//	}
+#if 0
+	}
+#endif
 
 	// Only if we can get a path here
 	if ( fContinue )
@@ -5253,8 +5255,8 @@ void ChangeSoldierStance( SOLDIERTYPE *pSoldier, UINT8 ubDesiredStance )
 
 		// Now change to appropriate animation
 		EVENT_InitNewSoldierAnim( pSoldier, usNewState, 0 , FALSE );
-		}
 	}
+}
 
 void EVENT_InternalSetSoldierDestination( SOLDIERTYPE *pSoldier, UINT16	usNewDirection, BOOLEAN fFromMove, UINT16 usAnimState )
 {
@@ -6115,22 +6117,24 @@ void TurnSoldier( SOLDIERTYPE *pSoldier)
 	// This is needed for prone animations as well as any multi-tiled structs
 	if ( fDoDirectionChange )
 	{
+		// If the soldier is not crawling or multi-tiled, he should be allowed to turn in place.  Even if there is some
+		// obstacle he shouldn't be standing on.
 		if ( OKToAddMercToWorld( pSoldier, (INT8)sDirection ) )
 		{
 			// Don't do this if we are walkoing off screen...
 			if ( gubWaitingForAllMercsToExitCode == WAIT_FOR_MERCS_TO_WALKOFF_SCREEN || gubWaitingForAllMercsToExitCode == WAIT_FOR_MERCS_TO_WALK_TO_GRIDNO )
-		 {
+			{
 
-		 }
+			}
 			else
-		 {
-			 // ATE: We should only do this if we are STATIONARY!
-			 if ( ( gAnimControl[ pSoldier->usAnimState ].uiFlags & ANIM_STATIONARY ) )
-			 {
-				 pSoldier->uiStatusFlags |= SOLDIER_LOOK_NEXT_TURNSOLDIER;
-			 }
-			 // otherwise, it's handled next tile...
-		 }
+			{
+				// ATE: We should only do this if we are STATIONARY!
+				if ( ( gAnimControl[ pSoldier->usAnimState ].uiFlags & ANIM_STATIONARY ) )
+				{
+					pSoldier->uiStatusFlags |= SOLDIER_LOOK_NEXT_TURNSOLDIER;
+				}
+				// otherwise, it's handled next tile...
+			}
 
 			EVENT_SetSoldierDirection( pSoldier, sDirection );
 
@@ -6139,22 +6143,19 @@ void TurnSoldier( SOLDIERTYPE *pSoldier)
 				PlaySoldierFootstepSound( pSoldier );
 			}
 		}
-		else
-		{	
 			// Are we prone crawling?
-			if ( pSoldier->usAnimState == CRAWLING )
-		 {
-			 // OK, we want to getup, turn and go prone again....
-			 SendChangeSoldierStanceEvent( pSoldier, ANIM_CROUCH );
-			 pSoldier->fTurningFromPronePosition = TURNING_FROM_PRONE_ENDING_UP_FROM_MOVE;
-		 }
-			// If we are a creature, or multi-tiled, cancel AI action.....?
-			else if ( pSoldier->uiStatusFlags & SOLDIER_MULTITILE )
-		 {
-			 pSoldier->bDesiredDirection = pSoldier->bDirection;
-		 }
-
+		else if ( pSoldier->usAnimState == CRAWLING )
+		{
+			// OK, we want to getup, turn and go prone again....
+			SendChangeSoldierStanceEvent( pSoldier, ANIM_CROUCH );
+			pSoldier->fTurningFromPronePosition = TURNING_FROM_PRONE_ENDING_UP_FROM_MOVE;
 		}
+		// If we are a creature, or multi-tiled, cancel AI action.....?
+		else if ( pSoldier->uiStatusFlags & SOLDIER_MULTITILE )
+		{
+			pSoldier->bDesiredDirection = pSoldier->bDirection;
+		}
+
 	} 
 }
 
@@ -7003,26 +7004,26 @@ void BeginSoldierClimbUpRoof( SOLDIERTYPE *pSoldier )
 			//Kaiden: Helps if we look where we are going before we try to climb on top of someone
 			ubWhoIsThere = WhoIsThere2( NewGridNo( (UINT16)pSoldier->sGridNo, (UINT16)DirectionInc(bNewDirection ) ), 1 );
 			if ( ubWhoIsThere != NOBODY && ubWhoIsThere != pSoldier->ubID )
-		 {
-			 return;
-		 }
+			{
+				return;
+			}
 			else
-		 {
+			{
 
-			 if (pSoldier->bTeam == gbPlayerNum)
-			 {
-				 // OK, SET INTERFACE FIRST
-				 SetUIBusy( pSoldier->ubID );
-			 }
+				if (pSoldier->bTeam == gbPlayerNum)
+				{
+					// OK, SET INTERFACE FIRST
+					SetUIBusy( pSoldier->ubID );
+				}
 
-			 pSoldier->sTempNewGridNo = NewGridNo( (UINT16)pSoldier->sGridNo, (UINT16)DirectionInc(bNewDirection ) );
+				pSoldier->sTempNewGridNo = NewGridNo( (UINT16)pSoldier->sGridNo, (UINT16)DirectionInc(bNewDirection ) );
 
-			 pSoldier->ubPendingDirection = bNewDirection;
-			 //pSoldier->usPendingAnimation = CLIMBUPROOF;
-			 EVENT_InitNewSoldierAnim( pSoldier, CLIMBUPROOF, 0 , FALSE );
+				pSoldier->ubPendingDirection = bNewDirection;
+				//pSoldier->usPendingAnimation = CLIMBUPROOF;
+				EVENT_InitNewSoldierAnim( pSoldier, CLIMBUPROOF, 0 , FALSE );
 
-			 InternalReceivingSoldierCancelServices( pSoldier, FALSE );				
-			 InternalGivingSoldierCancelServices( pSoldier, FALSE );				
+				InternalReceivingSoldierCancelServices( pSoldier, FALSE );				
+				InternalGivingSoldierCancelServices( pSoldier, FALSE );				
 
 			}		
 
@@ -8269,30 +8270,30 @@ void BeginSoldierClimbDownRoof( SOLDIERTYPE *pSoldier )
 			//Kaiden: Helps if we look where we are going before we try to climb on top of someone
 			ubWhoIsThere = WhoIsThere2( NewGridNo( (UINT16)pSoldier->sGridNo, (UINT16)DirectionInc(bNewDirection ) ), 0 );
 			if ( ubWhoIsThere != NOBODY && ubWhoIsThere != pSoldier->ubID )
-		 {
-			 return;
-		 }
+			{
+				return;
+			}
 			else
-		 {
+			{
 
-			 if (pSoldier->bTeam == gbPlayerNum)
-			 {
-				 // OK, SET INTERFACE FIRST
-				 SetUIBusy( pSoldier->ubID );
-			 }
+				if (pSoldier->bTeam == gbPlayerNum)
+				{
+					// OK, SET INTERFACE FIRST
+					SetUIBusy( pSoldier->ubID );
+				}
 
 
 
 
-			 pSoldier->sTempNewGridNo = NewGridNo( (UINT16)pSoldier->sGridNo, (UINT16)DirectionInc(bNewDirection ) );
+				pSoldier->sTempNewGridNo = NewGridNo( (UINT16)pSoldier->sGridNo, (UINT16)DirectionInc(bNewDirection ) );
 
-			 bNewDirection = gTwoCDirection[ bNewDirection ];
+				bNewDirection = gTwoCDirection[ bNewDirection ];
 
-			 pSoldier->ubPendingDirection = bNewDirection;
-			 EVENT_InitNewSoldierAnim( pSoldier, CLIMBDOWNROOF, 0 , FALSE );
+				pSoldier->ubPendingDirection = bNewDirection;
+				EVENT_InitNewSoldierAnim( pSoldier, CLIMBDOWNROOF, 0 , FALSE );
 
-			 InternalReceivingSoldierCancelServices( pSoldier, FALSE );				
-			 InternalGivingSoldierCancelServices( pSoldier, FALSE );				
+				InternalReceivingSoldierCancelServices( pSoldier, FALSE );				
+				InternalGivingSoldierCancelServices( pSoldier, FALSE );				
 
 			}
 		}
@@ -8940,7 +8941,7 @@ void ReleaseSoldiersAttacker( SOLDIERTYPE *pSoldier )
 			ubNumToFree = pSoldier->bBeingAttackedCount;
 			// Zero it out BEFORE, as supression may increase it again...
 			pSoldier->bBeingAttackedCount = 0;
-			
+
 			for ( cnt = 0; cnt < ubNumToFree; cnt++ )
 			{
 				DebugMsg( TOPIC_JA2, DBG_LEVEL_3, String("@@@@@@@ Freeing up attacker of %d (attacker is %d) - releasesoldierattacker num to free is %d", pSoldier->ubID, pSoldier->ubAttackerID, ubNumToFree ) );
@@ -9213,7 +9214,7 @@ void EVENT_SoldierBeginBladeAttack( SOLDIERTYPE *pSoldier, INT16 sGridNo, UINT8
 	// Increment the number of people busy doing stuff because of an attack
 	//if ( (gTacticalStatus.uiFlags & TURNBASED) && (gTacticalStatus.uiFlags & INCOMBAT) )
 	//{
-//	gTacticalStatus.ubAttackBusyCount++;
+	//	gTacticalStatus.ubAttackBusyCount++;
 	DebugMsg( TOPIC_JA2, DBG_LEVEL_3, String("Begin blade attack: ATB  %d", gTacticalStatus.ubAttackBusyCount) );
 	DebugAttackBusy( String( "Begin blade attack: ATB  %d\n", gTacticalStatus.ubAttackBusyCount) );
 
@@ -9389,7 +9390,7 @@ void EVENT_SoldierBeginPunchAttack( SOLDIERTYPE *pSoldier, INT16 sGridNo, UINT8
 	// Increment the number of people busy doing stuff because of an attack
 	//if ( (gTacticalStatus.uiFlags & TURNBASED) && (gTacticalStatus.uiFlags & INCOMBAT) )
 	//{
-//	gTacticalStatus.ubAttackBusyCount++;
+	//	gTacticalStatus.ubAttackBusyCount++;
 	DebugMsg( TOPIC_JA2, DBG_LEVEL_3, String("Begin HTH attack: ATB  %d", gTacticalStatus.ubAttackBusyCount) );
 	DebugAttackBusy( String( "Begin HTH attack: ATB  %d\n", gTacticalStatus.ubAttackBusyCount) );
 
@@ -9512,9 +9513,9 @@ void EVENT_SoldierBeginKnifeThrowAttack( SOLDIERTYPE *pSoldier, INT16 sGridNo, U
 	// Increment the number of people busy doing stuff because of an attack
 	//if ( (gTacticalStatus.uiFlags & TURNBASED) && (gTacticalStatus.uiFlags & INCOMBAT) )
 	//{
-//	gTacticalStatus.ubAttackBusyCount++;
+	//	gTacticalStatus.ubAttackBusyCount++;
 	//}
-//	pSoldier->bBulletsLeft = 1;
+	//	pSoldier->bBulletsLeft = 1;
 	DebugMsg( TOPIC_JA2, DBG_LEVEL_3, String("!!!!!!! Starting knifethrow attack, bullets left %d", pSoldier->bBulletsLeft) );
 	DebugAttackBusy( String( "Begin knife throwing attack: ATB  %d\n", gTacticalStatus.ubAttackBusyCount) );
 
@@ -10730,58 +10731,58 @@ INT32 CheckBleeding( SOLDIERTYPE *pSoldier )
 			{
 				// may drop blood whether or not any bleeding takes place this turn
 				if ( pSoldier->bTilesMoved < 1 )
-			 {
-				 iBlood = ( ( pSoldier->bBleeding - MIN_BLEEDING_THRESHOLD ) / BLOODDIVISOR ); // + pSoldier->dying;
-				 if ( iBlood > MAXBLOODQUANTITY )
-				 {
-					 iBlood = MAXBLOODQUANTITY;
-				 }
-			 }
+				{
+					iBlood = ( ( pSoldier->bBleeding - MIN_BLEEDING_THRESHOLD ) / BLOODDIVISOR ); // + pSoldier->dying;
+					if ( iBlood > MAXBLOODQUANTITY )
+					{
+						iBlood = MAXBLOODQUANTITY;
+					}
+				}
 				else
-			 {
-				 iBlood = NOBLOOD;
-			 }
+				{
+					iBlood = NOBLOOD;
+				}
 
 				// Are we in a different mode?
 				if ( !(gTacticalStatus.uiFlags & TURNBASED ) || !(gTacticalStatus.uiFlags & INCOMBAT ) )
-			 {
-				 pSoldier->dNextBleed -= (FLOAT)RT_NEXT_BLEED_MODIFIER;
-			 }
+				{
+					pSoldier->dNextBleed -= (FLOAT)RT_NEXT_BLEED_MODIFIER;
+				}
 				else
-			 {
-				 // Do a single step descrease
-				 pSoldier->dNextBleed--;
-			 }
+				{
+					// Do a single step descrease
+					pSoldier->dNextBleed--;
+				}
 
 				// if it's time to lose some blood
 				if ( pSoldier->dNextBleed <= 0)
-			 {
-				 // first, calculate if soldier is bandaged
-				 bBandaged = pSoldier->bLifeMax - pSoldier->bBleeding - pSoldier->bLife;
+				{
+					// first, calculate if soldier is bandaged
+					bBandaged = pSoldier->bLifeMax - pSoldier->bBleeding - pSoldier->bLife;
 
-				 // as long as he's bandaged and not "dying"
-				 if ( bBandaged && pSoldier->bLife >= OKLIFE )
-				 {
-					 // just bleeding through existing bandages
-					 pSoldier->bBleeding++;
+					// as long as he's bandaged and not "dying"
+					if ( bBandaged && pSoldier->bLife >= OKLIFE )
+					{
+						// just bleeding through existing bandages
+						pSoldier->bBleeding++;
 
-					 SoldierBleed( pSoldier, TRUE );
-				 }
-				 else	// soldier is either not bandaged at all or is dying
-				 {
-					 if ( pSoldier->bLife < OKLIFE )		// if he's dying
-					 {
-						 // if he's conscious, and he hasn't already, say his "dying quote"
-						 if ( ( pSoldier->bLife >= CONSCIOUSNESS ) && !pSoldier->fDyingComment )
-						 {
-							 TacticalCharacterDialogue( pSoldier, QUOTE_SERIOUSLY_WOUNDED );
+						SoldierBleed( pSoldier, TRUE );
+					}
+					else	// soldier is either not bandaged at all or is dying
+					{
+						if ( pSoldier->bLife < OKLIFE )		// if he's dying
+						{
+							// if he's conscious, and he hasn't already, say his "dying quote"
+							if ( ( pSoldier->bLife >= CONSCIOUSNESS ) && !pSoldier->fDyingComment )
+							{
+								TacticalCharacterDialogue( pSoldier, QUOTE_SERIOUSLY_WOUNDED );
 
-							 pSoldier->fDyingComment = TRUE;
-						 }
+								pSoldier->fDyingComment = TRUE;
+							}
 
-						 // can't permit lifemax to ever bleed beneath OKLIFE, or that
-						 // soldier might as well be dead!
-						 if (pSoldier->bLifeMax >= OKLIFE)
+							// can't permit lifemax to ever bleed beneath OKLIFE, or that
+							// soldier might as well be dead!
+							if (pSoldier->bLifeMax >= OKLIFE)
 							{
 								// bleeding while "dying" costs a PERMANENT point of life each time!
 								pSoldier->bLifeMax--;
@@ -10790,16 +10791,16 @@ INT32 CheckBleeding( SOLDIERTYPE *pSoldier )
 						}
 					}
 
-				 // either way, a point of life (health) is lost because of bleeding
-				 // This will also update the life bar
+					// either way, a point of life (health) is lost because of bleeding
+					// This will also update the life bar
 
-				 SoldierBleed( pSoldier, FALSE );
+					SoldierBleed( pSoldier, FALSE );
 
 
-				 // if he's not dying (which includes him saying the dying quote just
-				 // now), and he hasn't warned us that he's bleeding yet, he does so
-				 // Also, not if they are being bandaged....
-				 if ( ( pSoldier->bLife >= OKLIFE ) && !pSoldier->fDyingComment && !pSoldier->fWarnedAboutBleeding && !gTacticalStatus.fAutoBandageMode && pSoldier->ubServiceCount == 0 )
+					// if he's not dying (which includes him saying the dying quote just
+					// now), and he hasn't warned us that he's bleeding yet, he does so
+					// Also, not if they are being bandaged....
+					if ( ( pSoldier->bLife >= OKLIFE ) && !pSoldier->fDyingComment && !pSoldier->fWarnedAboutBleeding && !gTacticalStatus.fAutoBandageMode && pSoldier->ubServiceCount == 0 )
 					{
 						TacticalCharacterDialogue( pSoldier, QUOTE_STARTING_TO_BLEED );
 
@@ -10807,7 +10808,7 @@ INT32 CheckBleeding( SOLDIERTYPE *pSoldier )
 						pSoldier->fWarnedAboutBleeding = TRUE;
 					}
 
-				 pSoldier->dNextBleed = CalcSoldierNextBleed( pSoldier );
+					pSoldier->dNextBleed = CalcSoldierNextBleed( pSoldier );
 
 				}
 			}
@@ -11574,7 +11575,7 @@ void MercStealFromMerc( SOLDIERTYPE *pSoldier, SOLDIERTYPE *pTarget )
 		}
 
 		// OK, set UI
-//		gTacticalStatus.ubAttackBusyCount++;
+		//		gTacticalStatus.ubAttackBusyCount++;
 		// reset attacking item (hand)
 		pSoldier->usAttackingWeapon = 0;
 		DebugMsg( TOPIC_JA2, DBG_LEVEL_3, String("!!!!!!! Starting STEAL attack, attack count now %d", gTacticalStatus.ubAttackBusyCount) );
@@ -12277,7 +12278,7 @@ void SetSoldierPersonalLightLevel( SOLDIERTYPE *pSoldier )
 		return;
 	}
 
-	//THe light level for the soldier
+	//The light level for the soldier
 	gpWorldLevelData[pSoldier->sGridNo].pMercHead->ubShadeLevel = 3;
 	gpWorldLevelData[pSoldier->sGridNo].pMercHead->ubSumLights = 5;
 	gpWorldLevelData[pSoldier->sGridNo].pMercHead->ubMaxLights = 5;
diff --git a/TileEngine/Interactive Tiles.cpp b/TileEngine/Interactive Tiles.cpp
index d15ed2d6..3f6a66ba 100644
--- a/TileEngine/Interactive Tiles.cpp	
+++ b/TileEngine/Interactive Tiles.cpp	
@@ -252,8 +252,10 @@ void HandleStructChangeFromGridNo( SOLDIERTYPE *pSoldier, INT16 sGridNo )
 		{
 			if ( sGridNo == BOBBYR_SHIPPING_DEST_GRIDNO && gWorldSectorX == BOBBYR_SHIPPING_DEST_SECTOR_X && gWorldSectorY == BOBBYR_SHIPPING_DEST_SECTOR_Y && gbWorldSectorZ == BOBBYR_SHIPPING_DEST_SECTOR_Z && CheckFact( FACT_PABLOS_STOLE_FROM_LATEST_SHIPMENT, 0 ) && !(CheckFact( FACT_PLAYER_FOUND_ITEMS_MISSING, 0) ) )
 			{
-				SayQuoteFromNearbyMercInSector( BOBBYR_SHIPPING_DEST_GRIDNO, 3, QUOTE_STUFF_MISSING_DRASSEN );
-        fDidMissingQuote = TRUE;
+			SetFactFalse( 38); // Reset whether we punched Pablo lately
+			SetFactFalse( FACT_PABLO_RETURNED_GOODS);
+			SayQuoteFromNearbyMercInSector( BOBBYR_SHIPPING_DEST_GRIDNO, 3, QUOTE_STUFF_MISSING_DRASSEN );
+	        fDidMissingQuote = TRUE;
 			}
 		}
 		else if ( pSoldier->bTeam == CIV_TEAM )
diff --git a/TileEngine/worldman.cpp b/TileEngine/worldman.cpp
index 864dd236..10d79a73 100644
--- a/TileEngine/worldman.cpp
+++ b/TileEngine/worldman.cpp
@@ -2263,7 +2263,11 @@ BOOLEAN OKToAddMercToWorld( SOLDIERTYPE *pSoldier, INT8 bDirection )
 	STRUCTURE_FILE_REF			*pStructFileRef;
 	UINT16 usOKToAddStructID;
 
-  //if ( pSoldier->uiStatusFlags & SOLDIER_MULTITILE )
+	// 0verhaul:  Reinserting this check.  If a soldier is sitting or standing on a grid and another soldier is lying prone
+	// across that grid but has the structure, this call will not allow the current soldier to turn.  Since we are talking
+	// about the soldier whose turn it is, this is not a good thing because it will lead to deadlock.
+	if ( pSoldier->uiStatusFlags & SOLDIER_MULTITILE ||
+		pSoldier->usAnimState == CRAWLING)
 	{
 		// Get surface data
  		usAnimSurface = GetSoldierAnimationSurface( pSoldier, pSoldier->usAnimState );
diff --git a/ja2_2005Express.vcproj b/ja2_2005Express.vcproj
index bd093836..006b6534 100644
--- a/ja2_2005Express.vcproj
+++ b/ja2_2005Express.vcproj
@@ -142,7 +142,7 @@
 			<Tool
 				Name="VCLinkerTool"
 				AdditionalDependencies="Winmm.lib"
-				OutputFile="$(OutDir)\ja2_rel._1066.exe"
+				OutputFile="$(OutDir)\ja2_rel_1066.exe"
 				LinkIncremental="1"
 				GenerateDebugInformation="true"
 				SubSystem="2"