* Aircraft state was not being transferred ciclically from Game to Aircraft module.

* Improved detection of target reaching for Aircraft.c.
* Cursor is now displayed correctly on both 1-player and 2-player mode.
* Fixed behaviour for locking/unlocking aircraft.
* Fixed menus for 2-player mode.
* Minor fixes and improvements.

13 files changed, 488 insertions, 315 deletions

diff --git a/Source/Aircraft.c b/Source/Aircraft.c
index fb2b516..3b3dab8 100644
--- a/Source/Aircraft.c
+++ b/Source/Aircraft.c
@@ -13,14 +13,14 @@
 /* *************************************

  * 	Structs and enums

  * *************************************/

- 

+

 enum

 {

 	AIRCRAFT_SPRITE_SIZE = 24,

 	AIRCRAFT_SPRITE_VRAM_X = 800,

 	AIRCRAFT_SPRITE_VRAM_Y = 304,

-}; 

- 

+};

+

 enum

 {

 	PHX_LIVERY_CLUT_X = 384,

@@ -33,7 +33,8 @@ typedef enum t_aircraftSpeeds
 	AIRCRAFT_SPEED_TAXIING,

 	AIRCRAFT_SPEED_APPROACH,

 	AIRCRAFT_SPEED_TAKEOFF,

-	AIRCRAFT_SPEED_DESCENT,

+	AIRCRAFT_SPEED_FINAL,

+	AIRCRAFT_SPEED_FINAL_Z,

 }AIRCRAFT_SPEEDS;

 

 /* *************************************

@@ -47,12 +48,12 @@ static TYPE_ISOMETRIC_POS AircraftCenterIsoPos;
 static TYPE_CARTESIAN_POS AircraftCenterPos;

 static char * AircraftLiveryNamesTable[] = {"PHX", NULL};

 static AIRCRAFT_LIVERY AircraftLiveryTable[] = {AIRCRAFT_LIVERY_0, AIRCRAFT_LIVERY_UNKNOWN};

-static const fix16_t AircraftSpeedsTable[] = {	0			/* IDLE */		,

-												0x3333		/* TAXIING */	,

-												0x00010000	/* APPROACH */	,

-												0x20000		/* TAKEOFF	*/	,

-												0x8000		/* DESCENT	*/	};

-																	 

+static const fix16_t AircraftSpeedsTable[] = {	[AIRCRAFT_SPEED_IDLE] = 0,

+												[AIRCRAFT_SPEED_TAXIING] = 0x6666,

+												[AIRCRAFT_SPEED_TAKEOFF] = 0x20000,

+												[AIRCRAFT_SPEED_FINAL] = 0x10000,

+												[AIRCRAFT_SPEED_FINAL_Z] = 0x4000	};

+

 /* *************************************

  * 	Local prototypes

  * *************************************/

@@ -67,61 +68,61 @@ void AircraftInit(void)
 {

 	bzero(AircraftData, GAME_MAX_AIRCRAFT * sizeof(TYPE_AIRCRAFT_DATA));

 	AircraftIndex = 0;

-	

+

 	AircraftSpr.x = 0;

 	AircraftSpr.y = 0;

-	

+

 	AircraftSpr.attribute = COLORMODE(COLORMODE_8BPP);

-	

+

 	AircraftSpr.cx = PHX_LIVERY_CLUT_X;

 	AircraftSpr.cy = PHX_LIVERY_CLUT_Y;

-	

+

 	AircraftSpr.w = AIRCRAFT_SPRITE_SIZE;

 	AircraftSpr.h = AIRCRAFT_SPRITE_SIZE;

-	

+

 	/*AircraftSpr.tpage = 28;

 	AircraftSpr.u = 64;

 	AircraftSpr.v = 48;*/

-	

+

 	GfxTPageOffsetFromVRAMPosition(&AircraftSpr, AIRCRAFT_SPRITE_VRAM_X, AIRCRAFT_SPRITE_VRAM_Y);

-	

+

 	AircraftCenterIsoPos.x = AIRCRAFT_SIZE >> 1;

 	AircraftCenterIsoPos.y = AIRCRAFT_SIZE >> 1;

 	AircraftCenterIsoPos.z = 0;

-	

+

 	AircraftCenterPos = GfxIsometricToCartesian(&AircraftCenterIsoPos);

 }

 

 bool AircraftAddNew(	TYPE_FLIGHT_DATA * ptrFlightData,

 						uint8_t FlightDataIndex,

-						uint16_t * targets		)

+						uint16_t* targets		)

 {

 	TYPE_AIRCRAFT_DATA* ptrAircraft = &AircraftData[AircraftIndex];

 	uint8_t level_columns = GameGetLevelColumns();

 	uint8_t i;

-	

+

 	if(AircraftIndex >= GAME_MAX_AIRCRAFT)

 	{

 		dprintf("Exceeded maximum aircraft capacity!\n");

 		return false;

 	}

-	

+

 	memcpy(ptrAircraft->Target, targets, sizeof(uint16_t) * AIRCRAFT_MAX_TARGETS);

-	

+

 	ptrAircraft->TargetIdx = 0;

 	ptrAircraft->Livery = AircraftLiveryFromFlightNumber(ptrFlightData->strFlightNumber[FlightDataIndex]);

-	

+

 	ptrAircraft->FlightDataIdx = FlightDataIndex;

-	

+

 	if(ptrFlightData->FlightDirection[FlightDataIndex] == ARRIVAL)

 	{

 		ptrAircraft->IsoPos.x = 0;

-		

+

 		ptrAircraft->IsoPos.y = targets[0] / level_columns;

 		ptrAircraft->IsoPos.y <<= TILE_SIZE_BIT_SHIFT;

 		ptrAircraft->IsoPos.y += TILE_SIZE >> 1; // Adjust to tile center

 		ptrAircraft->IsoPos.y = fix16_from_int(ptrAircraft->IsoPos.y);

-		

+

 		ptrAircraft->IsoPos.z = targets[0] % level_columns;

 		ptrAircraft->IsoPos.z <<= TILE_SIZE_BIT_SHIFT - 1;

 		ptrAircraft->IsoPos.z = fix16_from_int(ptrAircraft->IsoPos.z);

@@ -132,31 +133,33 @@ bool AircraftAddNew(	TYPE_FLIGHT_DATA * ptrFlightData,
 		ptrAircraft->IsoPos.y = GameGetYFromTile(ptrFlightData->Parking[FlightDataIndex]);

 		ptrAircraft->IsoPos.z = 0;

 	}

-	

+

 	ptrAircraft->State = ptrFlightData->State[FlightDataIndex];

-	

+

+	ptrAircraft->Direction = AIRCRAFT_DIR_NORTH; // Default to north direction

+

 	dprintf("\nAircraft Data:\n");

 	dprintf("\tTargets:");

-	

+

 	for(i = 0; i < AIRCRAFT_MAX_TARGETS; i++)

 	{

 		if(ptrAircraft->Target[i] == 0)

 		{

 			break;

 		}

-		

+

 		dprintf(" %d", ptrAircraft->Target[i]);

 	}

-	

+

 	dprintf("\nLivery: %d\n",	ptrAircraft->Livery	);

-			

+

 	dprintf("Aircraft position: {%d, %d, %d}\n",

 			fix16_to_int(ptrAircraft->IsoPos.x),

 			fix16_to_int(ptrAircraft->IsoPos.y),

 			fix16_to_int(ptrAircraft->IsoPos.z)	);

-	

+

 	AircraftIndex++;

-	

+

 	return true;

 }

 

@@ -164,18 +167,18 @@ AIRCRAFT_LIVERY AircraftLiveryFromFlightNumber(char * strFlightNumber)
 {

 	int32_t liveryIndex;

 	char strLivery[4];

-	

+

 	memset(strLivery, 0, 4 * sizeof(char) );

-	

+

 	strncpy(strLivery, strFlightNumber, 3);

-	

+

 	liveryIndex = SystemIndexOfStringArray(strLivery, AircraftLiveryNamesTable);

-	

+

 	if(liveryIndex == -1)

 	{

 		return AIRCRAFT_LIVERY_UNKNOWN;

 	}

-	

+

 	return AircraftLiveryTable[liveryIndex];

 }

 

@@ -183,19 +186,21 @@ void AircraftHandler(void)
 {

 	TYPE_AIRCRAFT_DATA* ptrAircraft;

 	uint8_t i;

-	

+

 	for(i = 0; i < GAME_MAX_AIRCRAFT; i++)

 	{

 		ptrAircraft = &AircraftData[i];

-		

+

 		if(ptrAircraft->State == STATE_IDLE)

 		{

 			continue;

 		}

-		

+

 		AircraftDirection(ptrAircraft);

 		AircraftAttitude(ptrAircraft);

 		AircraftSpeed(ptrAircraft);

+

+		ptrAircraft->State = GameGetFlightDataStateFromIdx(ptrAircraft->FlightDataIdx);

 	}

 }

 

@@ -204,20 +209,23 @@ void AircraftSpeed(TYPE_AIRCRAFT_DATA* ptrAircraft)
 	switch(ptrAircraft->State)

 	{

 		case STATE_FINAL:

-			ptrAircraft->Speed = AircraftSpeedsTable[AIRCRAFT_SPEED_DESCENT];

+			ptrAircraft->Speed = AircraftSpeedsTable[AIRCRAFT_SPEED_FINAL];

 		break;

-		

+

 		case STATE_TAKEOFF:

 			ptrAircraft->Speed = AircraftSpeedsTable[AIRCRAFT_SPEED_TAKEOFF];

 		break;

-		

+

 		case STATE_TAXIING:

 			ptrAircraft->Speed = AircraftSpeedsTable[AIRCRAFT_SPEED_TAXIING];

 		break;

-		

+

 		case STATE_UNBOARDING:

+			// Fall through

 		case STATE_IDLE:

+			// Fall through

 		case STATE_LANDED:

+			// Fall through

 		default:

 			ptrAircraft->Speed = 0;

 		break;

@@ -228,32 +236,32 @@ void AircraftRender(TYPE_PLAYER* ptrPlayer)
 {

 	TYPE_AIRCRAFT_DATA* ptrAircraft;

 	TYPE_CARTESIAN_POS cartPos;

-	

+

 	uint8_t i;

-	

+

 	for(i = 0; i < GAME_MAX_AIRCRAFT; i++)

 	{

 		ptrAircraft = &AircraftData[i];

-		

+

 		if(ptrAircraft->State == STATE_IDLE)

 		{

 			continue;

 		}

-		

+

 		cartPos = GfxIsometricFix16ToCartesian(&ptrAircraft->IsoPos);

-		

+

 		// Aircraft position is referred to aircraft center

 		AircraftSpr.x = cartPos.x - (AircraftSpr.w >> 1);

 		AircraftSpr.y = cartPos.y - (AircraftSpr.h >> 1);

-		

+

 		AircraftUpdateSpriteFromData(ptrAircraft);

-		

+

 		CameraApplyCoordinatesToSprite(ptrPlayer, &AircraftSpr);

-		

+

 		AircraftSpr.r = NORMAL_LUMINANCE;

 		AircraftSpr.g = NORMAL_LUMINANCE;

 		AircraftSpr.b = NORMAL_LUMINANCE;

-		

+

 		GfxSortSprite(&AircraftSpr);

 	}

 }

@@ -261,62 +269,90 @@ void AircraftRender(TYPE_PLAYER* ptrPlayer)
 void AircraftDirection(TYPE_AIRCRAFT_DATA* ptrAircraft)

 {

 	TYPE_ISOMETRIC_FIX16_POS targetPos;

-	

+

 	if(ptrAircraft->Target[ptrAircraft->TargetIdx] == 0)

 	{

 		return;

 	}

-	

+

 	targetPos.x = GameGetXFromTile(ptrAircraft->Target[ptrAircraft->TargetIdx]);

 	targetPos.y = GameGetYFromTile(ptrAircraft->Target[ptrAircraft->TargetIdx]);

 	targetPos.z = 0;

-	

+

 	ptrAircraft->TargetReached = false;

-	

+

 	if(targetPos.y == ptrAircraft->IsoPos.y)

 	{

 		if(targetPos.x > ptrAircraft->IsoPos.x)

 		{

-			ptrAircraft->Direction = AIRCRAFT_DIR_EAST;

-			ptrAircraft->IsoPos.x += ptrAircraft->Speed;

+			if(targetPos.x <= (ptrAircraft->IsoPos.x + ptrAircraft->Speed) )

+			{

+				ptrAircraft->TargetReached = true;

+			}

+			else

+			{

+				ptrAircraft->Direction = AIRCRAFT_DIR_EAST;

+				ptrAircraft->IsoPos.x += ptrAircraft->Speed;

+			}

 		}

 		else if(targetPos.x < ptrAircraft->IsoPos.x)

 		{

-			ptrAircraft->Direction = AIRCRAFT_DIR_WEST;

-			ptrAircraft->IsoPos.x -= ptrAircraft->Speed;

+			if(targetPos.x >= (ptrAircraft->IsoPos.x - ptrAircraft->Speed) )

+			{

+				ptrAircraft->TargetReached = true;

+			}

+			else

+			{

+				ptrAircraft->Direction = AIRCRAFT_DIR_WEST;

+				ptrAircraft->IsoPos.x -= ptrAircraft->Speed;

+			}

 		}

 		else

 		{

 			ptrAircraft->TargetReached = true;

-			

-			if(ptrAircraft->Target[++ptrAircraft->TargetIdx] == 0)

-			{

-				dprintf("All targets reached!\n");

-				GameTargetsReached(ptrAircraft->FlightDataIdx);

-			}

 		}

 	}

 	else if(targetPos.x == ptrAircraft->IsoPos.x)

 	{

 		if(targetPos.y > ptrAircraft->IsoPos.y)

 		{

-			ptrAircraft->Direction = AIRCRAFT_DIR_SOUTH;

-			ptrAircraft->IsoPos.y += ptrAircraft->Speed;

+			if(targetPos.y <= (ptrAircraft->IsoPos.y + ptrAircraft->Speed) )

+			{

+				ptrAircraft->TargetReached = true;

+			}

+			else

+			{

+				ptrAircraft->Direction = AIRCRAFT_DIR_SOUTH;

+				ptrAircraft->IsoPos.y += ptrAircraft->Speed;

+			}

 		}

 		else if(targetPos.y < ptrAircraft->IsoPos.y)

 		{

-			ptrAircraft->Direction = AIRCRAFT_DIR_NORTH;

-			ptrAircraft->IsoPos.y -= ptrAircraft->Speed;

+			if(targetPos.y >= (ptrAircraft->IsoPos.y - ptrAircraft->Speed) )

+			{

+				ptrAircraft->TargetReached = true;

+			}

+			else

+			{

+				ptrAircraft->Direction = AIRCRAFT_DIR_NORTH;

+				ptrAircraft->IsoPos.y -= ptrAircraft->Speed;

+			}

 		}

 		else

 		{

 			ptrAircraft->TargetReached = true;

-			

-			if(ptrAircraft->Target[++ptrAircraft->TargetIdx] == 0)

-			{

-				dprintf("All targets reached!\n");

-				ptrAircraft->State = GameTargetsReached(ptrAircraft->FlightDataIdx);

-			}

+		}

+	}

+

+	if(ptrAircraft->TargetReached == true)

+	{

+		ptrAircraft->IsoPos.x = targetPos.x;

+		ptrAircraft->IsoPos.y = targetPos.y;

+		

+		if(ptrAircraft->Target[++ptrAircraft->TargetIdx] == 0)

+		{

+			dprintf("All targets reached!\n");

+			ptrAircraft->State = GameTargetsReached(ptrAircraft->FlightDataIdx);

 		}

 	}

 }

@@ -329,35 +365,43 @@ void AircraftUpdateSpriteFromData(TYPE_AIRCRAFT_DATA* ptrAircraft)
 			AircraftSpr.cx = PHX_LIVERY_CLUT_X;

 			AircraftSpr.cy = PHX_LIVERY_CLUT_Y;

 		break;

-		

+

 		case AIRCRAFT_LIVERY_UNKNOWN:

 			// Fall through

 		default:

 			dprintf("Unknown livery %d!\n", ptrAircraft->Livery);

 		break;

 	}

-	

+

 	// Reset TPAGE and {U, V} offset first.

 	GfxTPageOffsetFromVRAMPosition(&AircraftSpr, AIRCRAFT_SPRITE_VRAM_X, AIRCRAFT_SPRITE_VRAM_Y);

-	

+

 	switch(ptrAircraft->Direction)

 	{

 		case AIRCRAFT_DIR_NORTH:

 			AircraftSpr.v += AircraftSpr.w;

 			AircraftSpr.attribute |= H_FLIP;

 		break;

+

 		case AIRCRAFT_DIR_SOUTH:

 			AircraftSpr.v += 0;

 			AircraftSpr.attribute |= H_FLIP;

 		break;

+

 		case AIRCRAFT_DIR_EAST:

 			AircraftSpr.v += 0;

 			AircraftSpr.attribute &= ~(H_FLIP);

 		break;

+

 		case AIRCRAFT_DIR_WEST:

 			AircraftSpr.v += AircraftSpr.w;

 			AircraftSpr.attribute &= ~(H_FLIP);

 		break;

+

+		case AIRCRAFT_DIR_NO_DIRECTION:

+			// Fall through

+		default:

+		break;

 	}

 }

 

@@ -367,7 +411,7 @@ void AircraftAttitude(TYPE_AIRCRAFT_DATA* ptrAircraft)
 	{

 		if(ptrAircraft->IsoPos.z > 0)

 		{

-			ptrAircraft->IsoPos.z -= AircraftSpeedsTable[AIRCRAFT_SPEED_DESCENT];

+			ptrAircraft->IsoPos.z -= AircraftSpeedsTable[AIRCRAFT_SPEED_FINAL_Z];

 		}

 	}

 }

@@ -378,16 +422,16 @@ TYPE_ISOMETRIC_POS AircraftGetIsoPos(uint8_t FlightDataIdx)
 	// So we must perform a conversion first for convenience.

 	TYPE_ISOMETRIC_POS retIsoPos;

 	TYPE_ISOMETRIC_FIX16_POS fix16IsoPos = AircraftFromFlightDataIndex(FlightDataIdx)->IsoPos;

-	

+

 	retIsoPos.x = (short)fix16_to_int(fix16IsoPos.x);

 	retIsoPos.y = (short)fix16_to_int(fix16IsoPos.y);

 	retIsoPos.z = (short)fix16_to_int(fix16IsoPos.z);

-	

+

 	return retIsoPos;

 }

 

-void AircraftAddTargets(TYPE_AIRCRAFT_DATA* ptrAircraft, uint16_t * targets)

-{	

+void AircraftAddTargets(TYPE_AIRCRAFT_DATA* ptrAircraft, uint16_t* targets)

+{

 	memcpy(ptrAircraft->Target, targets, sizeof(uint16_t) * AIRCRAFT_MAX_TARGETS);

 }

 

@@ -401,21 +445,21 @@ TYPE_AIRCRAFT_DATA* AircraftFromFlightDataIndex(uint8_t index)
 {

 	uint8_t i;

 	TYPE_AIRCRAFT_DATA* ptrAircraft;

-	

+

 	for(i = 0; i < GAME_MAX_AIRCRAFT; i++)

 	{

 		ptrAircraft = &AircraftData[i];

-		

+

 		if(ptrAircraft->FlightDataIdx == index)

 		{

 			return ptrAircraft;

 		}

 	}

-	

+

 	return NULL;

 }

 

-void AircraftFromFlightDataIndexAddTargets(uint8_t index, uint16_t * targets)

+void AircraftFromFlightDataIndexAddTargets(uint8_t index, uint16_t* targets)

 {

 	AircraftAddTargets(AircraftFromFlightDataIndex(index), targets);

 }

diff --git a/Source/Aircraft.h b/Source/Aircraft.h
index e32a64a..5f80960 100644
--- a/Source/Aircraft.h
+++ b/Source/Aircraft.h
@@ -18,12 +18,12 @@ void AircraftInit(void);
 void AircraftHandler(void);

 void AircraftRender(TYPE_PLAYER* ptrPlayer);

 TYPE_AIRCRAFT_DATA* AircraftFromFlightDataIndex(uint8_t index);

-void AircraftFromFlightDataIndexAddTargets(uint8_t index, uint16_t * targets);

-void AircraftAddTargets(TYPE_AIRCRAFT_DATA* ptrAircraft, uint16_t * targets);

+void AircraftFromFlightDataIndexAddTargets(uint8_t index, uint16_t* targets);

+void AircraftAddTargets(TYPE_AIRCRAFT_DATA* ptrAircraft, uint16_t* targets);

 TYPE_ISOMETRIC_POS AircraftGetIsoPos(uint8_t FlightDataIdx);

 uint16_t AircraftGetTileFromFlightDataIndex(uint8_t index);

 bool AircraftAddNew(	TYPE_FLIGHT_DATA * ptrFlightData,

 						uint8_t FlightDataIndex,

-						uint16_t * targets		);

+						uint16_t* targets		);

 

 #endif //__AIRCRAFT_HEADER__

diff --git a/Source/Camera.c b/Source/Camera.c
index f0f637f..db01dec 100644
--- a/Source/Camera.c
+++ b/Source/Camera.c
@@ -12,6 +12,7 @@
 #define MAX_CAMERA_SPEED 5
 #define MIN_CAMERA_SPEED 1
 #define CAMERA_INITIAL_X_OFFSET (X_SCREEN_RESOLUTION >> 1)
+#define CAMERA_INITIAL_X_OFFSET_2PLAYER (X_SCREEN_RESOLUTION >> 2)
 
 /* *************************************
  * 	Local Prototypes
@@ -41,7 +42,7 @@ void CameraApplyCoordinatesToRectangle(TYPE_PLAYER* ptrPlayer, GsRectangle * rec
 	dprintf("Rectangle {%d, %d}\n",
 			rect->x,
 			rect->y	);
-			
+
 	rect->x += (short)ptrPlayer->Camera.X_Offset;
 	rect->y += (short)ptrPlayer->Camera.Y_Offset;
 }
@@ -61,7 +62,7 @@ void CameraUpdateSpeed(TYPE_PLAYER* ptrPlayer)
 				ptrPlayer->Camera.X_Speed++;
 			}
 		}
-			
+
 		if(ptrPlayer->PadKeyPressed_Callback(PAD_UP) == true)
 		{
 			if(ptrPlayer->Camera.Y_Speed < 0)
@@ -73,7 +74,7 @@ void CameraUpdateSpeed(TYPE_PLAYER* ptrPlayer)
 				ptrPlayer->Camera.Y_Speed++;
 			}
 		}
-			
+
 		if(ptrPlayer->PadKeyPressed_Callback(PAD_DOWN) == true)
 		{
 			if(ptrPlayer->Camera.Y_Speed > 0)
@@ -85,7 +86,7 @@ void CameraUpdateSpeed(TYPE_PLAYER* ptrPlayer)
 				ptrPlayer->Camera.Y_Speed--;
 			}
 		}
-		
+
 		if(ptrPlayer->PadKeyPressed_Callback(PAD_RIGHT) == true)
 		{
 			if(ptrPlayer->Camera.X_Speed > 0)
@@ -112,11 +113,11 @@ void CameraUpdateSpeed(TYPE_PLAYER* ptrPlayer)
 			ptrPlayer->Camera.X_Speed++;
 		}
 	}
-	
+
 	if(	(ptrPlayer->PadKeyPressed_Callback(PAD_UP) == false)
 			&&
 		(ptrPlayer->PadKeyPressed_Callback(PAD_DOWN) == false)	)
-	{		
+	{
 		if(ptrPlayer->Camera.Y_Speed > 0)
 		{
 			ptrPlayer->Camera.Y_Speed--;
@@ -136,7 +137,7 @@ void CameraHandler(TYPE_PLAYER* ptrPlayer)
 		ptrPlayer->Camera.Y_Speed = 0;
 		return;
 	}
-	
+
 	if(ptrPlayer->Camera.Speed_Timer < SPEED_CALCULATION_TIME)
 	{
 		ptrPlayer->Camera.Speed_Timer++;
@@ -146,7 +147,7 @@ void CameraHandler(TYPE_PLAYER* ptrPlayer)
 		ptrPlayer->Camera.Speed_Timer = 0;
 		CameraUpdateSpeed(ptrPlayer);
 	}
-	
+
 	ptrPlayer->Camera.X_Offset += ptrPlayer->Camera.X_Speed;
 	ptrPlayer->Camera.Y_Offset += ptrPlayer->Camera.Y_Speed;
 }
@@ -158,10 +159,10 @@ bool CameraSpecialConditions(TYPE_PLAYER* ptrPlayer)
 		(ptrPlayer->SelectRunway == true)		)
 	{
 		// Camera cannot be handled when these states are activated
-	
+
 		return true;
 	}
-	
+
 	return false;
 }
 
@@ -169,21 +170,29 @@ TYPE_ISOMETRIC_POS CameraGetIsoPos(TYPE_PLAYER* ptrPlayer)
 {
 	TYPE_ISOMETRIC_POS IsoPos;
 	TYPE_CARTESIAN_POS CartPos;
-	
-	CartPos.x = CAMERA_INITIAL_X_OFFSET - ptrPlayer->Camera.X_Offset;
-	CartPos.y = (Y_SCREEN_RESOLUTION >> 1) - ptrPlayer->Camera.Y_Offset;
-	
+
+	if(GameTwoPlayersActive() == true)
+	{
+		CartPos.x = CAMERA_INITIAL_X_OFFSET_2PLAYER - ptrPlayer->Camera.X_Offset;
+		CartPos.y = (Y_SCREEN_RESOLUTION >> 1) - ptrPlayer->Camera.Y_Offset;
+	}
+	else
+	{
+		CartPos.x = CAMERA_INITIAL_X_OFFSET - ptrPlayer->Camera.X_Offset;
+		CartPos.y = (Y_SCREEN_RESOLUTION >> 1) - ptrPlayer->Camera.Y_Offset;
+	}
+
 	/*dprintf("CartPos = {%d, %d}\n", CartPos.x, CartPos.y);*/
-	
+
 	IsoPos = GfxCartesianToIsometric(&CartPos);
-	
+
 	return IsoPos;
 }
 
 void CameraMoveToIsoPos(TYPE_PLAYER* ptrPlayer, TYPE_ISOMETRIC_POS IsoPos)
 {
 	TYPE_CARTESIAN_POS CartPos = GfxIsometricToCartesian(&IsoPos);
-	
+
 	/*dprintf("Isometric pos = {%d, %d, %d}, "
 			"Cartesian pos = {%d, %d}\n",
 			IsoPos.x,
@@ -191,10 +200,18 @@ void CameraMoveToIsoPos(TYPE_PLAYER* ptrPlayer, TYPE_ISOMETRIC_POS IsoPos)
 			IsoPos.z,
 			CartPos.x,
 			CartPos.y	);*/
-	
-	ptrPlayer->Camera.X_Offset = CAMERA_INITIAL_X_OFFSET - CartPos.x;
-	ptrPlayer->Camera.Y_Offset = (Y_SCREEN_RESOLUTION >> 1) - CartPos.y;
-	
+
+	if(GameTwoPlayersActive() == true)
+	{
+		ptrPlayer->Camera.X_Offset = CAMERA_INITIAL_X_OFFSET_2PLAYER - CartPos.x;
+		ptrPlayer->Camera.Y_Offset = (Y_SCREEN_RESOLUTION >> 1) - CartPos.y;
+	}
+	else
+	{
+		ptrPlayer->Camera.X_Offset = CAMERA_INITIAL_X_OFFSET - CartPos.x;
+		ptrPlayer->Camera.Y_Offset = (Y_SCREEN_RESOLUTION >> 1) - CartPos.y;
+	}
+
 	/*dprintf("Moving camera to {%d, %d}\n",
 			ptrPlayer->Camera.X_Offset,
 			ptrPlayer->Camera.Y_Offset	);*/
diff --git a/Source/Camera.h b/Source/Camera.h
index 887113d..3b622d4 100644
--- a/Source/Camera.h
+++ b/Source/Camera.h
@@ -9,6 +9,7 @@
 #include "System.h"
 #include "Pad.h"
 #include "GameStructures.h"
+#include "Game.h"
 
 /* *************************************
  * 	Defines
@@ -23,6 +24,6 @@ void CameraHandler(TYPE_PLAYER* ptrPlayer);
 void CameraApplyCoordinatesToSprite(TYPE_PLAYER* ptrPlayer, GsSprite * spr);
 void CameraApplyCoordinatesToRectangle(TYPE_PLAYER* ptrPlayer, GsRectangle * rect);
 TYPE_ISOMETRIC_POS CameraGetIsoPos(TYPE_PLAYER* ptrPlayer);
-void CameraMoveToIsoPos(TYPE_PLAYER* ptrPlayer, TYPE_ISOMETRIC_POS ptrIsoPos);
+void CameraMoveToIsoPos(TYPE_PLAYER* ptrPlayer, TYPE_ISOMETRIC_POS IsoPos);
 
 #endif //__CAM_HEADER__
diff --git a/Source/Game.c b/Source/Game.c
index bdb49f1..1aa3fdc 100644
--- a/Source/Game.c
+++ b/Source/Game.c
@@ -107,13 +107,13 @@ static void GameSelectAircraftFromList(TYPE_PLAYER* ptrPlayer, TYPE_FLIGHT_DATA
 static void GameStateSelectRunway(TYPE_PLAYER* ptrPlayer, TYPE_FLIGHT_DATA * ptrFlightData);
 static void GameStateSelectTaxiwayRunway(TYPE_PLAYER* ptrPlayer, TYPE_FLIGHT_DATA * ptrFlightData);
 static void GameStateSelectTaxiwayParking(TYPE_PLAYER* ptrPlayer, TYPE_FLIGHT_DATA * ptrFlightData);
-static void GameStateLockTarget(TYPE_PLAYER* ptrPlayer);
+static void GameStateLockTarget(TYPE_PLAYER* ptrPlayer, TYPE_FLIGHT_DATA* ptrFlightData);
 static void GameSelectAircraft(TYPE_PLAYER* ptrPlayer);
 static void GameGetRunwayArray(void);
 static void GameGetSelectedRunwayArray(uint16_t rwyHeader);
 static void GameAssignRunwaytoAircraft(TYPE_PLAYER* ptrPlayer, TYPE_FLIGHT_DATA * ptrFlightData);
-static bool GameGuiShowAircraftDataSpecialConditions(TYPE_PLAYER* ptrPlayer);
 static bool GamePathToTile(TYPE_PLAYER* ptrPlayer);
+static void GameDrawMouse(TYPE_PLAYER* ptrPlayer);
 
 /* *************************************
  * 	Global Variables
@@ -267,7 +267,6 @@ void GameInit(void)
 	PlayerData[PLAYER_ONE].PadKeySinglePress_Callback = &PadOneKeySinglePress;
 	PlayerData[PLAYER_ONE].PadDirectionKeyPressed_Callback = &PadOneDirectionKeyPressed;
 	PlayerData[PLAYER_ONE].FlightDataPage = 0;
-	PlayerData[PLAYER_ONE].Id = PLAYER_ONE;
 	
 	PlayerData[PLAYER_TWO].Active = TwoPlayersActive? true : false;
 	
@@ -283,7 +282,6 @@ void GameInit(void)
 		// other player controls arrival flights.
 		PlayerData[PLAYER_ONE].FlightDirection = DEPARTURE;
 		PlayerData[PLAYER_TWO].FlightDirection = ARRIVAL;
-		PlayerData[PLAYER_TWO].Id = PLAYER_TWO;
 	}
 	else
 	{
@@ -309,13 +307,13 @@ void GameInit(void)
 	
 	if(GameTwoPlayersActive() == true)
 	{
-		GameMouseSpr.x = MOUSE_X;
-		GameMouseSpr.y = MOUSE_Y;
+		GameMouseSpr.x = MOUSE_X_2PLAYER;
+		GameMouseSpr.y = MOUSE_Y_2PLAYER;
 	}
 	else
 	{
-		GameMouseSpr.x = MOUSE_X_2PLAYER;
-		GameMouseSpr.y = MOUSE_Y_2PLAYER;
+		GameMouseSpr.x = MOUSE_X;
+		GameMouseSpr.y = MOUSE_Y;
 	}
 	
 	GameMouseSpr.w = MOUSE_W;
@@ -506,7 +504,7 @@ void GamePlayerHandler(TYPE_PLAYER* ptrPlayer, TYPE_FLIGHT_DATA * ptrFlightData)
 									// which use this are currently active.
 	ptrPlayer->InvalidPath = false; // Do the same thing for "InvalidPath".
 
-	GameStateLockTarget(ptrPlayer);
+	GameStateLockTarget(ptrPlayer, ptrFlightData);
 	GameStateSelectRunway(ptrPlayer, ptrFlightData);
 	GameStateSelectTaxiwayRunway(ptrPlayer, ptrFlightData);
 	GameStateSelectTaxiwayParking(ptrPlayer, ptrFlightData);
@@ -576,6 +574,7 @@ void GameGraphics(void)
 	
 	if(GfxGetGlobalLuminance() < NORMAL_LUMINANCE)
 	{
+		// Fading from black effect on startup.
 		GfxIncreaseGlobalLuminance(1);
 	}
 	
@@ -588,16 +587,30 @@ void GameGraphics(void)
 				GfxSetSplitScreen(i);
 			}
 			
+			// Draw half split screen for each player
+			// only if 2-player mode is active. Else, render
+			// the whole screen as usual.
+			
 			GsSortCls(0,0,GfxGetGlobalLuminance() >> 1);
 
 			GameRenderLevel(&PlayerData[i]);
+
 			AircraftRender(&PlayerData[i]);
 
 			GameGuiAircraftList(&PlayerData[i], &FlightData);
+			
+			GameDrawMouse(&PlayerData[i]);
 		}
 	}
 	
-	GfxDisableSplitScreen();
+	// Avoid changing drawing environment twice on 1-player mode
+	// as it doesn't make any sense.
+	if(split_screen == true)
+	{
+		GfxDisableSplitScreen();
+	}
+	
+	// Draw common elements for both players (messages, clock...)
 	
 	GameGuiAircraftNotificationRequest(&FlightData);
 	
@@ -611,7 +624,7 @@ void GameGraphics(void)
 void GameLoadLevel(void)
 {	
 	uint8_t i = 0;
-	uint8_t * ptrBuffer;
+	uint8_t* ptrBuffer;
 	char LevelHeader[LEVEL_MAGIC_NUMBER_SIZE + 1];
 	
 	/* TODO - Very important */
@@ -945,13 +958,6 @@ void GameRenderLevel(TYPE_PLAYER* ptrPlayer)
 		}
 	}
 	
-	if(	(ptrPlayer->SelectTaxiwayParking == true)
-						||
-		(ptrPlayer->SelectTaxiwayRunway == true) 	)
-	{
-		GfxSortSprite(&GameMouseSpr);
-	}
-	
 	/*if(PadOneKeyReleased(PAD_CROSS) == true)
 	{
 		for(i = 0; i < GameLevelSize; i++)
@@ -990,18 +996,6 @@ void GameStateShowAircraft(TYPE_PLAYER* ptrPlayer, TYPE_FLIGHT_DATA * ptrFlightD
 		{
 			ptrPlayer->ShowAircraftData = false;
 		}
-		else if(ptrPlayer->PadKeySinglePress_Callback(PAD_SQUARE) == true)
-		{
-			dprintf("Aircraft state = %d. STATE_IDLE = %d\n",
-					ptrFlightData->State[ptrPlayer->SelectedAircraft],
-					STATE_IDLE);
-					
-			if(ptrFlightData->State[ptrPlayer->SelectedAircraft] != STATE_IDLE)
-			{
-				ptrPlayer->LockTarget = true;
-				ptrPlayer->LockedAircraft = ptrPlayer->SelectedAircraft;
-			}
-		}
 	}
 	
 	if(ptrPlayer->PadKeySinglePress_Callback(PAD_CIRCLE) == true)
@@ -1014,13 +1008,38 @@ void GameStateShowAircraft(TYPE_PLAYER* ptrPlayer, TYPE_FLIGHT_DATA * ptrFlightD
 	}
 }
 
-void GameStateLockTarget(TYPE_PLAYER* ptrPlayer)
+void GameStateLockTarget(TYPE_PLAYER* ptrPlayer, TYPE_FLIGHT_DATA* ptrFlightData)
 {
+	uint8_t AircraftIdx = ptrPlayer->ActiveAircraftList[ptrPlayer->SelectedAircraft];
+	
 	if(ptrPlayer->LockTarget == true)
 	{
 		CameraMoveToIsoPos(ptrPlayer, AircraftGetIsoPos(ptrPlayer->LockedAircraft) );
-		
-		if(ptrPlayer->PadKeySinglePress_Callback(PAD_SQUARE) == true)
+	}
+	
+	if(ptrPlayer->PadKeySinglePress_Callback(PAD_SQUARE) == true)
+	{		
+		if(ptrPlayer->LockTarget == false)
+		{
+			if( (ptrFlightData->State[AircraftIdx] != STATE_IDLE)
+											&&
+				(ptrFlightData->State[AircraftIdx] != STATE_APPROACH) )
+			{
+				ptrPlayer->LockTarget = true;
+				ptrPlayer->LockedAircraft = AircraftIdx;
+			}
+		}
+		else
+		{
+			ptrPlayer->LockTarget = false;
+			ptrPlayer->LockedAircraft = 0;
+		}
+	}
+	else if(ptrPlayer->PadDirectionKeyPressed_Callback() == true)
+	{
+		if( (ptrPlayer->LockTarget == true)
+						&&
+			(ptrPlayer->ShowAircraftData == false) )
 		{
 			ptrPlayer->LockTarget = false;
 			ptrPlayer->LockedAircraft = 0;
@@ -1194,13 +1213,18 @@ void GameStateSelectRunway(TYPE_PLAYER* ptrPlayer, TYPE_FLIGHT_DATA * ptrFlightD
 {	
 	uint8_t i;
 	bool success;
+	TYPE_ISOMETRIC_POS IsoPos = {	GameGetXFromTile_short(GameRwy[ptrPlayer->SelectedRunway]),
+									GameGetYFromTile_short(GameRwy[ptrPlayer->SelectedRunway]),
+									0	};
 	
 	if(ptrPlayer->SelectRunway == true)
-	{
+	{		
 		// Under this mode, always reset locking target.
 		ptrPlayer->LockTarget = false;
 		ptrPlayer->LockedAircraft = 0;
 		
+		CameraMoveToIsoPos(ptrPlayer, IsoPos);
+		
 		if(ptrPlayer->PadKeySinglePress_Callback(PAD_TRIANGLE) == true)
 		{
 			ptrPlayer->SelectRunway = false;
@@ -1243,7 +1267,7 @@ void GameStateSelectRunway(TYPE_PLAYER* ptrPlayer, TYPE_FLIGHT_DATA * ptrFlightD
 		}
 		else if(ptrPlayer->PadKeySinglePress_Callback(PAD_RIGHT) == true)
 		{
-			if(ptrPlayer->SelectedRunway < GAME_MAX_RUNWAYS)
+			if(ptrPlayer->SelectedRunway < (GAME_MAX_RUNWAYS - 1))
 			{
 				if(GameRwy[ptrPlayer->SelectedRunway + 1] != 0)
 				{
@@ -1287,7 +1311,8 @@ void GameGetRunwayArray(void)
 
 void GameSelectAircraftFromList(TYPE_PLAYER* ptrPlayer, TYPE_FLIGHT_DATA * ptrFlightData)
 {
-	FL_STATE aircraftState = ptrFlightData->State[ptrPlayer->SelectedAircraft];
+	uint8_t AircraftIdx = ptrPlayer->ActiveAircraftList[ptrPlayer->SelectedAircraft];
+	FL_STATE aircraftState = ptrFlightData->State[AircraftIdx];
 	
 	if(ptrPlayer->ShowAircraftData == true)
 	{
@@ -1323,6 +1348,9 @@ void GameSelectAircraftFromList(TYPE_PLAYER* ptrPlayer, TYPE_FLIGHT_DATA * ptrFl
 					break;
 				}
 			}
+			
+			dprintf("aircraftState = %d\n", aircraftState);
+			dprintf("AircraftIdx = %d\n", AircraftIdx);
 		}
 	}
 }
@@ -1470,9 +1498,9 @@ void GameAssignRunwaytoAircraft(TYPE_PLAYER* ptrPlayer, TYPE_FLIGHT_DATA * ptrFl
 	}
 }
 
-fix16_t GameGetXFromTile(uint16_t tile)
+short GameGetXFromTile_short(uint16_t tile)
 {
-	fix16_t retVal;
+	short retVal;
 	
 	tile %= GameLevelColumns;
 	
@@ -1481,14 +1509,12 @@ fix16_t GameGetXFromTile(uint16_t tile)
 	// Always point to tile center
 	retVal += TILE_SIZE >> 1;
 	
-	retVal = fix16_from_int(retVal);
-	
 	return retVal;
 }
 
-fix16_t GameGetYFromTile(uint16_t tile)
+short GameGetYFromTile_short(uint16_t tile)
 {
-	fix16_t retVal;
+	short retVal;
 	
 	tile /= GameLevelColumns;
 	
@@ -1497,11 +1523,19 @@ fix16_t GameGetYFromTile(uint16_t tile)
 	// Always point to tile center
 	retVal += TILE_SIZE >> 1;
 	
-	retVal = fix16_from_int(retVal);
-	
 	return retVal;
 }
 
+fix16_t GameGetXFromTile(uint16_t tile)
+{
+	return fix16_from_int(GameGetXFromTile_short(tile));
+}
+
+fix16_t GameGetYFromTile(uint16_t tile)
+{
+	return fix16_from_int(GameGetYFromTile_short(tile));
+}
+
 FL_STATE GameTargetsReached(uint8_t index)
 {
 	FL_STATE retState = STATE_IDLE;
@@ -1523,22 +1557,6 @@ FL_STATE GameTargetsReached(uint8_t index)
 	return retState;
 }
 
-bool GameGuiShowAircraftDataSpecialConditions(TYPE_PLAYER* ptrPlayer)
-{
-	// Aircraft list data cannot be shown under these conditions.
-	
-	if(	(ptrPlayer->SelectRunway == true)
-						||
-		(ptrPlayer->SelectTaxiwayParking == true)
-						||
-		(ptrPlayer->SelectTaxiwayRunway == true)	)
-	{
-		return true;
-	}
-	
-	return false;
-}
-
 uint16_t GameGetTileFromIsoPosition(TYPE_ISOMETRIC_POS * IsoPos)
 {
 	uint16_t tile;
@@ -1824,7 +1842,8 @@ bool GamePathToTile(TYPE_PLAYER* ptrPlayer)
 
 void GameSelectAircraft(TYPE_PLAYER* ptrPlayer)
 {
-	TYPE_ISOMETRIC_POS IsoPos = AircraftGetIsoPos(ptrPlayer->SelectedAircraft);
+	uint8_t AircraftIdx = ptrPlayer->ActiveAircraftList[ptrPlayer->SelectedAircraft];
+	TYPE_ISOMETRIC_POS IsoPos = AircraftGetIsoPos(AircraftIdx);
 	
 	CameraMoveToIsoPos(ptrPlayer, IsoPos);
 	
@@ -1837,3 +1856,23 @@ bool GameTwoPlayersActive(void)
 {
 	return TwoPlayersActive;
 }
+
+void GameDrawMouse(TYPE_PLAYER* ptrPlayer)
+{
+	if(	(ptrPlayer->SelectTaxiwayParking == true)
+						||
+		(ptrPlayer->SelectTaxiwayRunway == true) 	)
+	{
+		GfxSortSprite(&GameMouseSpr);
+	}
+}
+
+FL_STATE GameGetFlightDataStateFromIdx(uint8_t FlightDataIdx)
+{
+	if(FlightDataIdx >= GAME_MAX_AIRCRAFT)
+	{
+		return STATE_IDLE; // Error: could cause buffer overrun
+	}
+
+	return FlightData.State[FlightDataIdx];
+}
diff --git a/Source/Game.h b/Source/Game.h
index 6e74aee..fb8c12c 100644
--- a/Source/Game.h
+++ b/Source/Game.h
@@ -44,7 +44,10 @@ uint8_t 	GameGetLastActiveAircraft(void);
 uint8_t 	GameGetLevelColumns(void);
 fix16_t 	GameGetXFromTile(uint16_t tile);
 fix16_t 	GameGetYFromTile(uint16_t tile);
+short		GameGetXFromTile_short(uint16_t tile);
+short		GameGetYFromTile_short(uint16_t tile);
 FL_STATE	GameTargetsReached(uint8_t index);
 uint16_t	GameGetTileFromIsoPosition(TYPE_ISOMETRIC_POS * IsoPos);
+FL_STATE	GameGetFlightDataStateFromIdx(uint8_t FlightDataIdx);
 
 #endif //__GAME_HEADER__
diff --git a/Source/GameGui.c b/Source/GameGui.c
index d3855f9..94d3dce 100644
--- a/Source/GameGui.c
+++ b/Source/GameGui.c
@@ -125,6 +125,14 @@ enum
 

 enum

 {

+	AIRCRAFT_LOCK_TARGET_X = 32,

+	AIRCRAFT_LOCK_TARGET_TEXT_X = AIRCRAFT_LOCK_TARGET_X + 16,

+	AIRCRAFT_LOCK_TARGET_Y = 224,

+	AIRCRAFT_LOCK_TARGET_TEXT_Y = AIRCRAFT_LOCK_TARGET_Y + 4,

+};

+

+enum

+{

 	AIRCRAFT_DATA_FLIGHT_GSGPOLY4_R0 = NORMAL_LUMINANCE,

 	AIRCRAFT_DATA_FLIGHT_GSGPOLY4_R1 = AIRCRAFT_DATA_FLIGHT_GSGPOLY4_R0,

 	AIRCRAFT_DATA_FLIGHT_GSGPOLY4_R2 = 0,

@@ -388,19 +396,22 @@ void GameGuiActiveAircraftList(TYPE_PLAYER* ptrPlayer, TYPE_FLIGHT_DATA * ptrFli
 	uint8_t i;

 	uint8_t j = 0;

 	

-	// Clear all pointers for aircraft data first.

-	// Then, rebuild aircraft list for player.

-	memset(ptrPlayer->ActiveAircraftList, 0, GAME_MAX_AIRCRAFT);

-	ptrPlayer->ActiveAircraft = 0;

-	

-	for(i = 0; i < GAME_MAX_AIRCRAFT; i++)

+	if(ptrPlayer->ShowAircraftData == true)

 	{

-		if(	(ptrFlightData->State[i] != STATE_IDLE)

-							&&

-			(ptrFlightData->FlightDirection[i] & ptrPlayer->FlightDirection) )

+		// Clear all pointers for aircraft data first.

+		// Then, rebuild aircraft list for player.

+		memset(ptrPlayer->ActiveAircraftList, 0, GAME_MAX_AIRCRAFT);

+		ptrPlayer->ActiveAircraft = 0;

+		

+		for(i = 0; i < GAME_MAX_AIRCRAFT; i++)

 		{

-			ptrPlayer->ActiveAircraftList[j++] = i;

-			ptrPlayer->ActiveAircraft++;

+			if(	(ptrFlightData->State[i] != STATE_IDLE)

+								&&

+				(ptrFlightData->FlightDirection[i] & ptrPlayer->FlightDirection) )

+			{

+				ptrPlayer->ActiveAircraftList[j++] = i;

+				ptrPlayer->ActiveAircraft++;

+			}

 		}

 	}

 }

@@ -496,14 +507,6 @@ void GameGuiAircraftList(TYPE_PLAYER* ptrPlayer, TYPE_FLIGHT_DATA * ptrFlightDat
 			AircraftDataGPoly4.y[1] = AIRCRAFT_DATA_GSGPOLY4_Y1_2PLAYER;

 			AircraftDataGPoly4.y[2] = AIRCRAFT_DATA_GSGPOLY4_Y2_2PLAYER;

 			AircraftDataGPoly4.y[3] = AIRCRAFT_DATA_GSGPOLY4_Y3_2PLAYER;

-			

-			if(ptrPlayer->Id == PLAYER_TWO)

-			{

-				AircraftDataGPoly4.x[0] += X_SCREEN_RESOLUTION >> 1;

-				AircraftDataGPoly4.x[1] += X_SCREEN_RESOLUTION >> 1;

-				AircraftDataGPoly4.x[2] += X_SCREEN_RESOLUTION >> 1;

-				AircraftDataGPoly4.x[3] += X_SCREEN_RESOLUTION >> 1;

-			}

 		}

 		else

 		{

@@ -520,105 +523,127 @@ void GameGuiAircraftList(TYPE_PLAYER* ptrPlayer, TYPE_FLIGHT_DATA * ptrFlightDat
 		

 		GsSortGPoly4(&AircraftDataGPoly4);

 			

-			if(ptrPlayer->ActiveAircraft != 0)

+		if(ptrPlayer->ActiveAircraft != 0)

+		{

+			SelectedAircraftGPoly4.r[0] = AIRCRAFT_DATA_FLIGHT_GSGPOLY4_R0;

+			SelectedAircraftGPoly4.r[1] = AIRCRAFT_DATA_FLIGHT_GSGPOLY4_R1;

+			SelectedAircraftGPoly4.r[2] = AIRCRAFT_DATA_FLIGHT_GSGPOLY4_R2;

+			SelectedAircraftGPoly4.r[3] = AIRCRAFT_DATA_FLIGHT_GSGPOLY4_R3;

+			

+			SelectedAircraftGPoly4.g[0] = AIRCRAFT_DATA_FLIGHT_GSGPOLY4_G0;

+			SelectedAircraftGPoly4.g[1] = AIRCRAFT_DATA_FLIGHT_GSGPOLY4_G1;

+			SelectedAircraftGPoly4.g[2] = AIRCRAFT_DATA_FLIGHT_GSGPOLY4_G2;

+			SelectedAircraftGPoly4.g[3] = AIRCRAFT_DATA_FLIGHT_GSGPOLY4_G3;

+			

+			SelectedAircraftGPoly4.b[0] = AIRCRAFT_DATA_FLIGHT_GSGPOLY4_B0;

+			SelectedAircraftGPoly4.b[1] = AIRCRAFT_DATA_FLIGHT_GSGPOLY4_B1;

+			SelectedAircraftGPoly4.b[2] = AIRCRAFT_DATA_FLIGHT_GSGPOLY4_B2;

+			SelectedAircraftGPoly4.b[3] = AIRCRAFT_DATA_FLIGHT_GSGPOLY4_B3;

+			

+			SelectedAircraftGPoly4.attribute |= ENABLE_TRANS | TRANS_MODE(0);

+			

+			if(GameTwoPlayersActive() == true)

 			{

-				SelectedAircraftGPoly4.r[0] = AIRCRAFT_DATA_FLIGHT_GSGPOLY4_R0;

-				SelectedAircraftGPoly4.r[1] = AIRCRAFT_DATA_FLIGHT_GSGPOLY4_R1;

-				SelectedAircraftGPoly4.r[2] = AIRCRAFT_DATA_FLIGHT_GSGPOLY4_R2;

-				SelectedAircraftGPoly4.r[3] = AIRCRAFT_DATA_FLIGHT_GSGPOLY4_R3;

-				

-				SelectedAircraftGPoly4.g[0] = AIRCRAFT_DATA_FLIGHT_GSGPOLY4_G0;

-				SelectedAircraftGPoly4.g[1] = AIRCRAFT_DATA_FLIGHT_GSGPOLY4_G1;

-				SelectedAircraftGPoly4.g[2] = AIRCRAFT_DATA_FLIGHT_GSGPOLY4_G2;

-				SelectedAircraftGPoly4.g[3] = AIRCRAFT_DATA_FLIGHT_GSGPOLY4_G3;

-				

-				SelectedAircraftGPoly4.b[0] = AIRCRAFT_DATA_FLIGHT_GSGPOLY4_B0;

-				SelectedAircraftGPoly4.b[1] = AIRCRAFT_DATA_FLIGHT_GSGPOLY4_B1;

-				SelectedAircraftGPoly4.b[2] = AIRCRAFT_DATA_FLIGHT_GSGPOLY4_B2;

-				SelectedAircraftGPoly4.b[3] = AIRCRAFT_DATA_FLIGHT_GSGPOLY4_B3;

-				

-				SelectedAircraftGPoly4.attribute |= ENABLE_TRANS | TRANS_MODE(0);

-				

-				if(GameTwoPlayersActive() == true)

-				{

-					SelectedAircraftGPoly4.x[0] = AIRCRAFT_DATA_FLIGHT_GSGPOLY4_X0_2PLAYER;

-					SelectedAircraftGPoly4.x[1] = AIRCRAFT_DATA_FLIGHT_GSGPOLY4_X1_2PLAYER;

-					SelectedAircraftGPoly4.x[2] = AIRCRAFT_DATA_FLIGHT_GSGPOLY4_X2_2PLAYER;

-					SelectedAircraftGPoly4.x[3] = AIRCRAFT_DATA_FLIGHT_GSGPOLY4_X3_2PLAYER;

-				}

-				else

-				{				

-					SelectedAircraftGPoly4.x[0] = AIRCRAFT_DATA_FLIGHT_GSGPOLY4_X0;

-					SelectedAircraftGPoly4.x[1] = AIRCRAFT_DATA_FLIGHT_GSGPOLY4_X1;

-					SelectedAircraftGPoly4.x[2] = AIRCRAFT_DATA_FLIGHT_GSGPOLY4_X2;

-					SelectedAircraftGPoly4.x[3] = AIRCRAFT_DATA_FLIGHT_GSGPOLY4_X3;

-				}

+				SelectedAircraftGPoly4.x[0] = AIRCRAFT_DATA_FLIGHT_GSGPOLY4_X0_2PLAYER;

+				SelectedAircraftGPoly4.x[1] = AIRCRAFT_DATA_FLIGHT_GSGPOLY4_X1_2PLAYER;

+				SelectedAircraftGPoly4.x[2] = AIRCRAFT_DATA_FLIGHT_GSGPOLY4_X2_2PLAYER;

+				SelectedAircraftGPoly4.x[3] = AIRCRAFT_DATA_FLIGHT_GSGPOLY4_X3_2PLAYER;

+			}

+			else

+			{				

+				SelectedAircraftGPoly4.x[0] = AIRCRAFT_DATA_FLIGHT_GSGPOLY4_X0;

+				SelectedAircraftGPoly4.x[1] = AIRCRAFT_DATA_FLIGHT_GSGPOLY4_X1;

+				SelectedAircraftGPoly4.x[2] = AIRCRAFT_DATA_FLIGHT_GSGPOLY4_X2;

+				SelectedAircraftGPoly4.x[3] = AIRCRAFT_DATA_FLIGHT_GSGPOLY4_X3;

+			}

+			

+			page_aircraft = (ptrPlayer->SelectedAircraft) - (ptrPlayer->FlightDataPage * GAME_GUI_AIRCRAFT_DATA_MAX_PAGE);

+			

+			y_offset = 	(short)(page_aircraft * AIRCRAFT_DATA_FLIGHT_GSGPOLY4_H);

+									

+			/*dprintf("ptrPlayer->ActiveAircraft = %d\n",ptrPlayer->ActiveAircraft);

+			dprintf("ptrPlayer->SelectedAircraft = %d\n",ptrPlayer->SelectedAircraft);

+			dprintf("ptrPlayer->FlightDataPage = %d\n",ptrPlayer->FlightDataPage);

+			dprintf("y_offset = %d\n",y_offset);*/

+			

+			if(GameTwoPlayersActive() == true)

+			{

+				SelectedAircraftGPoly4.y[0] = AIRCRAFT_DATA_FLIGHT_GSGPOLY4_Y0_2PLAYER;

+				SelectedAircraftGPoly4.y[1] = AIRCRAFT_DATA_FLIGHT_GSGPOLY4_Y1_2PLAYER;

+				SelectedAircraftGPoly4.y[2] = AIRCRAFT_DATA_FLIGHT_GSGPOLY4_Y2_2PLAYER;

+				SelectedAircraftGPoly4.y[3] = AIRCRAFT_DATA_FLIGHT_GSGPOLY4_Y3_2PLAYER;

+			}

+			else

+			{

+				SelectedAircraftGPoly4.y[0] = AIRCRAFT_DATA_FLIGHT_GSGPOLY4_Y0;

+				SelectedAircraftGPoly4.y[1] = AIRCRAFT_DATA_FLIGHT_GSGPOLY4_Y1;

+				SelectedAircraftGPoly4.y[2] = AIRCRAFT_DATA_FLIGHT_GSGPOLY4_Y2;

+				SelectedAircraftGPoly4.y[3] = AIRCRAFT_DATA_FLIGHT_GSGPOLY4_Y3;

+			}

+			

+			SelectedAircraftGPoly4.y[0] += y_offset;

+			SelectedAircraftGPoly4.y[1] += y_offset;	

+			SelectedAircraftGPoly4.y[2] += y_offset;

+			SelectedAircraftGPoly4.y[3] += y_offset;

+			

+			GsSortGPoly4(&SelectedAircraftGPoly4);

+			

+			if(ptrPlayer->ActiveAircraft > (GAME_GUI_AIRCRAFT_DATA_MAX_PAGE * (ptrPlayer->FlightDataPage + 1) ) )

+			{

+				ArrowsSpr.x = AIRCRAFT_DATA_FLIGHT_RIGHT_ARROW_X;

+				ArrowsSpr.y = AIRCRAFT_DATA_FLIGHT_RIGHT_ARROW_Y;

 				

-				page_aircraft = (ptrPlayer->SelectedAircraft) - (ptrPlayer->FlightDataPage * GAME_GUI_AIRCRAFT_DATA_MAX_PAGE);

+				ArrowsSpr.attribute |= GFX_1HZ_FLASH;

 				

-				y_offset = 	(short)(page_aircraft * AIRCRAFT_DATA_FLIGHT_GSGPOLY4_H);

-										

-				/*dprintf("ptrPlayer->ActiveAircraft = %d\n",ptrPlayer->ActiveAircraft);

-				dprintf("ptrPlayer->SelectedAircraft = %d\n",ptrPlayer->SelectedAircraft);

-				dprintf("ptrPlayer->FlightDataPage = %d\n",ptrPlayer->FlightDataPage);

-				dprintf("y_offset = %d\n",y_offset);*/

+				ArrowsSpr.u = AIRCRAFT_DATA_FLIGHT_RIGHT_ARROW_U;

+				ArrowsSpr.v = AIRCRAFT_DATA_FLIGHT_RIGHT_ARROW_V;

 				

-				if(GameTwoPlayersActive() == true)

-				{

-					SelectedAircraftGPoly4.y[0] = AIRCRAFT_DATA_FLIGHT_GSGPOLY4_Y0_2PLAYER;

-					SelectedAircraftGPoly4.y[1] = AIRCRAFT_DATA_FLIGHT_GSGPOLY4_Y1_2PLAYER;

-					SelectedAircraftGPoly4.y[2] = AIRCRAFT_DATA_FLIGHT_GSGPOLY4_Y2_2PLAYER;

-					SelectedAircraftGPoly4.y[3] = AIRCRAFT_DATA_FLIGHT_GSGPOLY4_Y3_2PLAYER;

-				}

-				else

-				{

-					SelectedAircraftGPoly4.y[0] = AIRCRAFT_DATA_FLIGHT_GSGPOLY4_Y0;

-					SelectedAircraftGPoly4.y[1] = AIRCRAFT_DATA_FLIGHT_GSGPOLY4_Y1;

-					SelectedAircraftGPoly4.y[2] = AIRCRAFT_DATA_FLIGHT_GSGPOLY4_Y2;

-					SelectedAircraftGPoly4.y[3] = AIRCRAFT_DATA_FLIGHT_GSGPOLY4_Y3;

-				}

+				ArrowsSpr.w = AIRCRAFT_DATA_FLIGHT_ARROWS_SIZE;

+				ArrowsSpr.h = AIRCRAFT_DATA_FLIGHT_ARROWS_SIZE;

 				

-				SelectedAircraftGPoly4.y[0] += y_offset;

-				SelectedAircraftGPoly4.y[1] += y_offset;	

-				SelectedAircraftGPoly4.y[2] += y_offset;

-				SelectedAircraftGPoly4.y[3] += y_offset;

+				GfxSortSprite(&ArrowsSpr);

+			}

+			

+			if(ptrPlayer->FlightDataPage != 0)

+			{

+				ArrowsSpr.x = AIRCRAFT_DATA_FLIGHT_LEFT_ARROW_X;

+				ArrowsSpr.y = AIRCRAFT_DATA_FLIGHT_LEFT_ARROW_Y;

 				

-				GsSortGPoly4(&SelectedAircraftGPoly4);

+				ArrowsSpr.attribute |= GFX_1HZ_FLASH;

 				

-				if(ptrPlayer->ActiveAircraft > (GAME_GUI_AIRCRAFT_DATA_MAX_PAGE * (ptrPlayer->FlightDataPage + 1) ) )

-				{

-					ArrowsSpr.x = AIRCRAFT_DATA_FLIGHT_RIGHT_ARROW_X;

-					ArrowsSpr.y = AIRCRAFT_DATA_FLIGHT_RIGHT_ARROW_Y;

-					

-					ArrowsSpr.attribute |= GFX_1HZ_FLASH;

-					

-					ArrowsSpr.u = AIRCRAFT_DATA_FLIGHT_RIGHT_ARROW_U;

-					ArrowsSpr.v = AIRCRAFT_DATA_FLIGHT_RIGHT_ARROW_V;

-					

-					ArrowsSpr.w = AIRCRAFT_DATA_FLIGHT_ARROWS_SIZE;

-					ArrowsSpr.h = AIRCRAFT_DATA_FLIGHT_ARROWS_SIZE;

-					

-					GfxSortSprite(&ArrowsSpr);

-				}

+				ArrowsSpr.u = AIRCRAFT_DATA_FLIGHT_LEFT_ARROW_U;

+				ArrowsSpr.v = AIRCRAFT_DATA_FLIGHT_LEFT_ARROW_V;

 				

-				if(ptrPlayer->FlightDataPage != 0)

-				{

-					ArrowsSpr.x = AIRCRAFT_DATA_FLIGHT_LEFT_ARROW_X;

-					ArrowsSpr.y = AIRCRAFT_DATA_FLIGHT_LEFT_ARROW_Y;

-					

-					ArrowsSpr.attribute |= GFX_1HZ_FLASH;

-					

-					ArrowsSpr.u = AIRCRAFT_DATA_FLIGHT_LEFT_ARROW_U;

-					ArrowsSpr.v = AIRCRAFT_DATA_FLIGHT_LEFT_ARROW_V;

-					

-					ArrowsSpr.w = AIRCRAFT_DATA_FLIGHT_ARROWS_SIZE;

-					ArrowsSpr.h = AIRCRAFT_DATA_FLIGHT_ARROWS_SIZE;

-					

-					GfxSortSprite(&ArrowsSpr);

-				}

+				ArrowsSpr.w = AIRCRAFT_DATA_FLIGHT_ARROWS_SIZE;

+				ArrowsSpr.h = AIRCRAFT_DATA_FLIGHT_ARROWS_SIZE;

 				

-				GameGuiShowAircraftData(ptrPlayer, ptrFlightData);

-			}	

+				GfxSortSprite(&ArrowsSpr);

+			}

+			

+			GameGuiShowAircraftData(ptrPlayer, ptrFlightData);

+			

+			GfxDrawButton(AIRCRAFT_LOCK_TARGET_X, AIRCRAFT_LOCK_TARGET_Y, PAD_SQUARE);

+			

+			if(ptrPlayer->LockTarget == true)

+			{

+				FontPrintText(&SmallFont, AIRCRAFT_LOCK_TARGET_TEXT_X, AIRCRAFT_LOCK_TARGET_TEXT_Y, "Unlock target");

+			}

+			else

+			{

+				FontPrintText(&SmallFont, AIRCRAFT_LOCK_TARGET_TEXT_X, AIRCRAFT_LOCK_TARGET_TEXT_Y, "Lock target");

+			}

+		}	

+		else

+		{

+			if(GameTwoPlayersActive() == true)

+			{

+				FontPrintText( 	&SmallFont,

+								AIRCRAFT_DATA_GSGPOLY4_X0_2PLAYER + 

+								( (AIRCRAFT_DATA_GSGPOLY4_X1_2PLAYER - AIRCRAFT_DATA_GSGPOLY4_X0_2PLAYER) >> 2),

+								AIRCRAFT_DATA_GSGPOLY4_Y0_2PLAYER +

+								( (AIRCRAFT_DATA_GSGPOLY4_Y2_2PLAYER - AIRCRAFT_DATA_GSGPOLY4_Y0_2PLAYER) >> 1),

+								"No flights!"	);

+			}

 			else

 			{

 				FontPrintText( 	&SmallFont,

@@ -628,6 +653,7 @@ void GameGuiAircraftList(TYPE_PLAYER* ptrPlayer, TYPE_FLIGHT_DATA * ptrFlightDat
 								( (AIRCRAFT_DATA_GSGPOLY4_Y2 - AIRCRAFT_DATA_GSGPOLY4_Y0) >> 1),

 								"No flights!"	);

 			}

+		}

 	}

 

 }

@@ -740,6 +766,7 @@ void GameGuiShowAircraftData(TYPE_PLAYER* ptrPlayer, TYPE_FLIGHT_DATA * ptrFligh
 	short AircraftDataFlightNumber_Y;

 	short AircraftDataPassengers_X;

 	short AircraftDataPassengers_Y;

+	short AircraftDataState_X_Offset;

 	

 	if(GameTwoPlayersActive() == true)

 	{

@@ -749,6 +776,7 @@ void GameGuiShowAircraftData(TYPE_PLAYER* ptrPlayer, TYPE_FLIGHT_DATA * ptrFligh
 		AircraftDataFlightNumber_Y = AIRCRAFT_DATA_FLIGHT_NUMBER_TEXT_Y_2PLAYER;

 		AircraftDataPassengers_X = AIRCRAFT_DATA_PASSENGERS_X_2PLAYER;

 		AircraftDataPassengers_Y = AIRCRAFT_DATA_PASSENGERS_Y_2PLAYER;

+		AircraftDataState_X_Offset = 54;

 	}

 	else

 	{

@@ -758,6 +786,7 @@ void GameGuiShowAircraftData(TYPE_PLAYER* ptrPlayer, TYPE_FLIGHT_DATA * ptrFligh
 		AircraftDataFlightNumber_Y = AIRCRAFT_DATA_FLIGHT_NUMBER_TEXT_Y;

 		AircraftDataPassengers_X = AIRCRAFT_DATA_PASSENGERS_X;

 		AircraftDataPassengers_Y = AIRCRAFT_DATA_PASSENGERS_Y;

+		AircraftDataState_X_Offset = 88;

 	}

 	

 	FontSetFlags(&SmallFont,FONT_NOFLAGS);

@@ -774,9 +803,9 @@ void GameGuiShowAircraftData(TYPE_PLAYER* ptrPlayer, TYPE_FLIGHT_DATA * ptrFligh
 		FontPrintText(	&SmallFont,

 						AircraftDataFlightNumber_X,

 						AircraftDataFlightNumber_Y + (AIRCRAFT_DATA_FLIGHT_GSGPOLY4_H * j),

-						ptrFlightData->strFlightNumber[i]	);

+						ptrFlightData->strFlightNumber[ptrPlayer->ActiveAircraftList[i]]	);

 					

-		switch(ptrFlightData->FlightDirection[i])

+		switch(ptrFlightData->FlightDirection[ptrPlayer->ActiveAircraftList[i]])

 		{

 			case ARRIVAL:

 				FontPrintText(	&SmallFont,

@@ -785,10 +814,20 @@ void GameGuiShowAircraftData(TYPE_PLAYER* ptrPlayer, TYPE_FLIGHT_DATA * ptrFligh
 								"Arrival"	);

 			break;

 			case DEPARTURE:

-				FontPrintText(	&SmallFont,

-								AircraftDataDirection_X,

-								AircraftDataDirection_Y + (AIRCRAFT_DATA_FLIGHT_GSGPOLY4_H * j),

-								"Departure"	);

+				if(GameTwoPlayersActive() == true)

+				{

+					FontPrintText(	&SmallFont,

+									AircraftDataDirection_X,

+									AircraftDataDirection_Y + (AIRCRAFT_DATA_FLIGHT_GSGPOLY4_H * j),

+									"Depart."	);

+				}

+				else

+				{

+					FontPrintText(	&SmallFont,

+									AircraftDataDirection_X,

+									AircraftDataDirection_Y + (AIRCRAFT_DATA_FLIGHT_GSGPOLY4_H * j),

+									"Departure"	);

+				}

 			break;

 			default:

 			break;

@@ -796,32 +835,39 @@ void GameGuiShowAircraftData(TYPE_PLAYER* ptrPlayer, TYPE_FLIGHT_DATA * ptrFligh
 		

 		FontSetFlags(&SmallFont, FONT_2HZ_FLASH);

 		

-		switch(ptrFlightData->State[i])

+		switch(ptrFlightData->State[ptrPlayer->ActiveAircraftList[i]])

 		{

+			case STATE_APPROACH:

+				FontPrintText(	&SmallFont,

+								AircraftDataDirection_X + AircraftDataState_X_Offset,

+								AircraftDataDirection_Y + (AIRCRAFT_DATA_FLIGHT_GSGPOLY4_H * j),

+								"Approach"	);

+			break;

+				

 			case STATE_FINAL:

 				FontPrintText(	&SmallFont,

-								AircraftDataDirection_X + 88,

+								AircraftDataDirection_X + AircraftDataState_X_Offset,

 								AircraftDataDirection_Y + (AIRCRAFT_DATA_FLIGHT_GSGPOLY4_H * j),

 								"Landing"	);

 			break;

 			

 			case STATE_LANDED:

 				FontPrintText(	&SmallFont,

-								AircraftDataDirection_X + 88,

+								AircraftDataDirection_X + AircraftDataState_X_Offset,

 								AircraftDataDirection_Y + (AIRCRAFT_DATA_FLIGHT_GSGPOLY4_H * j),

 								"Arrived"	);

 			break;

 			

 			case STATE_PARKED:

 				FontPrintText(	&SmallFont,

-								AircraftDataDirection_X + 88,

+								AircraftDataDirection_X + AircraftDataState_X_Offset,

 								AircraftDataDirection_Y + (AIRCRAFT_DATA_FLIGHT_GSGPOLY4_H * j),

 								"Parked"	);

 			break;

 			

 			case STATE_UNBOARDING:

 				FontPrintText(	&SmallFont,

-								AircraftDataDirection_X + 88,

+								AircraftDataDirection_X + AircraftDataState_X_Offset,

 								AircraftDataDirection_Y + (AIRCRAFT_DATA_FLIGHT_GSGPOLY4_H * j),

 								"Unboard"	);

 			break;

@@ -836,6 +882,22 @@ void GameGuiShowAircraftData(TYPE_PLAYER* ptrPlayer, TYPE_FLIGHT_DATA * ptrFligh
 						AircraftDataPassengers_X,

 						AircraftDataPassengers_Y + (AIRCRAFT_DATA_FLIGHT_GSGPOLY4_H * j),

 						"%d pax.",

-						ptrFlightData->Passengers[i]	);

+						ptrFlightData->Passengers[ptrPlayer->ActiveAircraftList[i]]	);

+	}

+}

+

+bool GameGuiShowAircraftDataSpecialConditions(TYPE_PLAYER* ptrPlayer)

+{

+	// Aircraft list data cannot be shown under these conditions.

+	

+	if(	(ptrPlayer->SelectRunway == true)

+						||

+		(ptrPlayer->SelectTaxiwayParking == true)

+						||

+		(ptrPlayer->SelectTaxiwayRunway == true)	)

+	{

+		return true;

 	}

+	

+	return false;

 }

diff --git a/Source/GameGui.h b/Source/GameGui.h
index 160b06a..319e58b 100644
--- a/Source/GameGui.h
+++ b/Source/GameGui.h
@@ -29,6 +29,7 @@
 

 void GameGuiInit(void);

 bool GameGuiPauseDialog(TYPE_PLAYER* ptrPlayer);

+bool GameGuiShowAircraftDataSpecialConditions(TYPE_PLAYER* ptrPlayer);

 void GameGuiAircraftNotificationRequest(TYPE_FLIGHT_DATA * ptrFlightData);

 void GameGuiBubble(TYPE_FLIGHT_DATA * ptrFlightData);

 void GameGuiAircraftList(TYPE_PLAYER* ptrPlayer, TYPE_FLIGHT_DATA * ptrFlightData);

diff --git a/Source/GameStructures.h b/Source/GameStructures.h
index 355ec33..4a6b563 100644
--- a/Source/GameStructures.h
+++ b/Source/GameStructures.h
@@ -84,10 +84,11 @@ typedef enum t_livery
 

 typedef enum t_direction

 {

-	AIRCRAFT_DIR_NORTH = 0,

+	AIRCRAFT_DIR_NO_DIRECTION = 0,

+	AIRCRAFT_DIR_NORTH,

 	AIRCRAFT_DIR_SOUTH,

 	AIRCRAFT_DIR_EAST,

-	AIRCRAFT_DIR_WEST

+	AIRCRAFT_DIR_WEST,

 }AIRCRAFT_DIRECTION;

 

 typedef enum t_aircraftAttitude

@@ -114,6 +115,10 @@ typedef struct t_aircraftData
 	fix16_t Speed;

 	short TargetSpeed;

 	bool TargetReached;

+	// Used for target reached detection

+	fix16_t XPos_Old;

+	// Used for target reached detection

+	fix16_t YPos_Old;

 }TYPE_AIRCRAFT_DATA;

 

 typedef struct

@@ -135,6 +140,7 @@ typedef struct
 		bool LockTarget;

 	

 	// Stores indexes for player-specific active aircraft

+	// Used to relate SelectedAircraft agains FlightData index

 	uint8_t	ActiveAircraftList[GAME_MAX_AIRCRAFT];

 	// Flight direction to be managed by player (see 2-player mode)

 	FL_DIR	FlightDirection;

@@ -157,8 +163,6 @@ typedef struct
 	uint8_t WaypointIdx;

 	// Another internal index to keep last desired selected point by user when defining a path.

 	uint8_t LastWaypointIdx;

-	// Player ID (PLAYER_ONE = 0, PLAYER_TWO = 1)

-	uint8_t Id;

 	

 	bool	(*PadKeyPressed_Callback)(unsigned short);

 	bool	(*PadKeyReleased_Callback)(unsigned short);

diff --git a/Source/MemCard.h b/Source/MemCard.h
index a7ddcf8..880886b 100644
--- a/Source/MemCard.h
+++ b/Source/MemCard.h
@@ -96,7 +96,7 @@ typedef struct t_MemCard
 	

 	uint8_t Icons[MEMCARD_NUMBER_OF_ICONS][MEMCARD_ICON_SIZE];

 	uint8_t CLUT[MEMCARD_NUMBER_OF_ICONS][MEMCARD_CLUT_SIZE];

-	uint8_t * Data; // Buffer pointed to by "Data" must be 128 KB or higher!

+	uint8_t* Data; // Buffer pointed to by "Data" must be 128 KB or higher!

 	GsTPoly4 IconTPoly;

 }TYPE_BLOCK_DATA;

 

diff --git a/Source/Menu.c b/Source/Menu.c
index 0a922c4..da69137 100644
--- a/Source/Menu.c
+++ b/Source/Menu.c
@@ -320,6 +320,8 @@ void MainMenuRestoreInitValues(void)
 	MainMenuBtn[TWO_PLAYER_BUTTON_INDEX].selected = false;
 	MainMenuBtn[TWO_PLAYER_BUTTON_INDEX].was_selected = false;
 	MainMenuBtn[TWO_PLAYER_BUTTON_INDEX].timer = 0;	
+	
+	GfxSetGlobalLuminance(NORMAL_LUMINANCE);
 }
 
 void MainMenuButtonHandler(void)
diff --git a/Source/System.c b/Source/System.c
index 6eeaf15..8005fa8 100644
--- a/Source/System.c
+++ b/Source/System.c
@@ -269,7 +269,7 @@ void SystemCheckTimer(bool * timer, uint64_t * last_timer, uint8_t step)
 	}	
 }
 
-bool SystemLoadFileToBuffer(char * fname, uint8_t * buffer, uint32_t szBuffer)
+bool SystemLoadFileToBuffer(char * fname, uint8_t* buffer, uint32_t szBuffer)
 {
 	FILE *f;
 	int32_t size;
@@ -329,7 +329,7 @@ bool SystemLoadFile(char *fname)
 	return SystemLoadFileToBuffer(fname,file_buffer,sizeof(file_buffer));
 }
 
-uint8_t * SystemGetBufferAddress(void)
+uint8_t* SystemGetBufferAddress(void)
 {
 	return file_buffer;
 }
@@ -361,7 +361,7 @@ volatile bool SystemIsBusy(void)
 	return system_busy;
 }
 
-bool SystemContains_u8(uint8_t value, uint8_t * buffer, size_t sz)
+bool SystemContains_u8(uint8_t value, uint8_t* buffer, size_t sz)
 {
 	size_t i = 0;
 	
@@ -376,7 +376,7 @@ bool SystemContains_u8(uint8_t value, uint8_t * buffer, size_t sz)
 	return false;
 }
 
-bool SystemContains_u16(uint16_t value, uint16_t * buffer, size_t sz)
+bool SystemContains_u16(uint16_t value, uint16_t* buffer, size_t sz)
 {
 	size_t i = 0;
 	
@@ -567,7 +567,7 @@ int32_t SystemIndexOfStringArray(char * str, char ** array)
 	return -1;
 }
 
-int32_t SystemIndexOf_U16(uint16_t value, uint16_t * array, uint32_t sz)
+int32_t SystemIndexOf_U16(uint16_t value, uint16_t* array, uint32_t sz)
 {
 	int32_t i;
 	
@@ -582,7 +582,7 @@ int32_t SystemIndexOf_U16(uint16_t value, uint16_t * array, uint32_t sz)
 	return -1;
 }
 
-int32_t SystemIndexOf_U8(uint8_t value, uint8_t * array, uint32_t from, uint32_t sz)
+int32_t SystemIndexOf_U8(uint8_t value, uint8_t* array, uint32_t from, uint32_t sz)
 {
 	int32_t i;
 	
diff --git a/Source/System.h b/Source/System.h
index 61ce6e2..dda7c01 100644
--- a/Source/System.h
+++ b/Source/System.h
@@ -37,13 +37,13 @@ bool SystemRefreshNeeded(void);
 bool SystemLoadFile(char *fname);
 
 // Loads a file into desired buffer
-bool SystemLoadFileToBuffer(char * fname, uint8_t * buffer, uint32_t szBuffer);
+bool SystemLoadFileToBuffer(char * fname, uint8_t* buffer, uint32_t szBuffer);
 
 // Clears VSync flag after each frame
 void SystemDisableScreenRefresh(void);
 
 // Returns file buffer address
-uint8_t * SystemGetBufferAddress(void);
+uint8_t* SystemGetBufferAddress(void);
 
 // Tells whether srand() has been called using a pseudo-random value
 bool SystemIsRandSeedSet(void);
@@ -82,10 +82,10 @@ uint64_t SystemGetGlobalTimer(void);
 volatile bool SystemIsBusy(void);
 
 // Returns whether indicated value is contained inside buffer
-bool SystemContains_u8(uint8_t value, uint8_t * buffer, size_t sz);
+bool SystemContains_u8(uint8_t value, uint8_t* buffer, size_t sz);
 
 // Overload for uint16_t
-bool SystemContains_u16(uint16_t value, uint16_t * buffer, size_t sz);
+bool SystemContains_u16(uint16_t value, uint16_t* buffer, size_t sz);
 
 // Creates a timer instance wiht a determined value and associates it to a callback
 // Once time expires, callback is automatically called right after GfxDrawScene().
@@ -119,10 +119,10 @@ void SystemCheckStack(void);
 int32_t SystemIndexOfStringArray(char * str, char ** array);
 
 // Function overload for uint16_t data type.
-int32_t SystemIndexOf_U16(uint16_t value, uint16_t * array, uint32_t sz);
+int32_t SystemIndexOf_U16(uint16_t value, uint16_t* array, uint32_t sz);
 
 // Function overload for uint8_t data type.
-int32_t SystemIndexOf_U8(uint8_t value, uint8_t * array, uint32_t from, uint32_t sz);
+int32_t SystemIndexOf_U8(uint8_t value, uint8_t* array, uint32_t from, uint32_t sz);
 
 void SystemCyclicHandler(void);