Initial commit

1 files changed, 1727 insertions, 0 deletions

diff --git a/Source/Game.c b/Source/Game.c
new file mode 100755
index 0000000..88d2b75
--- /dev/null
+++ b/Source/Game.c
@@ -0,0 +1,1727 @@
+/* *************************************
+ * 	Includes
+ * *************************************/
+
+#include "Game.h"
+
+/* *************************************
+ * 	Defines
+ * *************************************/
+
+#define GAME_MAX_MAP_SIZE 0x400
+#define GAME_MAX_RUNWAYS 16
+#define GAME_MAX_RWY_LENGTH 16
+
+#define MIN_MAP_COLUMNS 8
+#define MAX_MAP_COLUMNS 32
+
+#define LEVEL_HEADER_SIZE 64
+#define COLUMNS_PER_TILESET 4
+#define ROWS_PER_TILESET COLUMNS_PER_TILESET
+#define LEVEL_MAGIC_NUMBER_SIZE 3
+#define LEVEL_MAGIC_NUMBER_STRING "ATC"
+#define LEVEL_TITLE_SIZE 24
+#define TILE_MIRROR_FLAG ( (uint8_t)0x80 )
+
+#define GAME_INVALID_TILE_SELECTION ( (uint16_t)0xFFFF )
+
+/* **************************************
+ * 	Structs and enums					*
+ * *************************************/
+
+enum
+{
+	TILE_GRASS = 0,
+	TILE_ASPHALT_WITH_BORDERS,
+	TILE_WATER,
+	TILE_ASPHALT,
+	TILE_HANGAR,
+	TILE_ILS,
+	TILE_ATC_TOWER,
+	TILE_ATC_LOC,
+	TILE_RWY_MID,
+	TILE_RWY_START_1,
+	TILE_RWY_START_2,
+	TILE_PARKING,
+	TILE_RESERVED_1,
+	TILE_TAXIWAY_INTERSECT_GRASS,
+	TILE_TAXIWAY_GRASS,
+	TILE_TAXIWAY_CORNER_GRASS,
+	
+	LAST_TILE_TILESET1 = TILE_TAXIWAY_CORNER_GRASS
+};
+
+enum
+{
+	TILE_HALF_WATER_1 = LAST_TILE_TILESET1 + 1,
+	TILE_HALF_WATER_2,
+	TILE_RESERVED_2,
+	TILE_RESERVED_3,
+	TILE_AIRPORT_BUILDING,
+	TILE_PLANE,
+	TILE_RESERVED_4,
+	TILE_RESERVED_5,
+	TILE_RWY_EXIT,
+	TILE_GATE,
+	TILE_RESERVED_6,
+	TILE_RESERVED_7,
+	TILE_TAXIWAY_CORNER_GRASS_2,
+	
+	LAST_TILE_TILESET2 = TILE_TAXIWAY_CORNER_GRASS_2,
+	
+	TILE_NOTHING = 0xFF
+};
+
+enum
+{
+	MOUSE_W = 8,
+	MOUSE_H = 8,
+	MOUSE_X = X_SCREEN_RESOLUTION - (X_SCREEN_RESOLUTION >> 1),
+	MOUSE_Y = Y_SCREEN_RESOLUTION - (Y_SCREEN_RESOLUTION >> 1),
+};
+
+/* *************************************
+ * 	Local Prototypes
+ * *************************************/
+
+static void GameInit(void);
+static void GameLoadLevel(void);
+static bool GamePause(void);
+static void GameEmergencyMode(void);
+static void GameCalculations(void);
+static void GamePlayerHandler(TYPE_PLAYER * ptrPlayer, TYPE_FLIGHT_DATA * ptrFlightData);
+static void GamePlayerAddWaypoint(TYPE_PLAYER * ptrPlayer);
+static void GamePlayerAddWaypoint_Ex(TYPE_PLAYER * ptrPlayer, uint16_t tile);
+static void GameGraphics(void);
+static void GameRenderLevel(TYPE_PLAYER * ptrPlayer);
+//static void GameLoadPilots(char * strPath);
+static void GameClock(void);
+static void GameClockFlights(void);
+static void GameAircraftState(void);
+static void GameActiveAircraft(void);
+static void GameStateShowAircraft(TYPE_PLAYER * ptrPlayer, TYPE_FLIGHT_DATA * ptrFlightData);
+static void GameFirstLastAircraftIndex(void);
+static void GameSelectAircraftFromList(TYPE_PLAYER * ptrPlayer, TYPE_FLIGHT_DATA * ptrFlightData);
+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 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 uint16_t GameGetTileFromIsoPosition(TYPE_ISOMETRIC_POS * IsoPos);
+static bool GamePathToTile(TYPE_PLAYER * ptrPlayer);
+
+/* *************************************
+ * 	Global Variables
+ * *************************************/
+
+bool GameStartupFlag;
+
+/* *************************************
+ * 	Local Variables
+ * *************************************/
+
+static GsSprite GameTilesetSpr;
+static GsSprite GameTileset2Spr;
+static GsSprite GamePlaneSpr;
+static GsSprite GameMouseSpr;
+static uint16_t GameRwy[GAME_MAX_RUNWAYS];
+static TYPE_FLIGHT_DATA FlightData;
+static uint16_t GameRwyArray[GAME_MAX_RWY_LENGTH];
+static uint16_t GameUsedRwy[GAME_MAX_RUNWAYS];
+static uint16_t GameSelectedTile;
+
+// Instances for player-specific data
+TYPE_PLAYER PlayerData[MAX_PLAYERS];
+
+static char * GameFileList[] = {	"cdrom:\\DATA\\SPRITES\\TILESET1.TIM;1"	,
+									"cdrom:\\DATA\\SPRITES\\TILESET2.TIM;1"	,
+									"cdrom:\\DATA\\LEVELS\\LEVEL1.PLT;1"	,
+									"cdrom:\\DATA\\SPRITES\\GAMEPLN.TIM;1"	,
+									"cdrom:\\DATA\\SPRITES\\PLNBLUE.CLT;1"	,
+									"cdrom:\\DATA\\SPRITES\\MOUSE.TIM;1"	};
+									
+static void * GameFileDest[] = {	(GsSprite*)&GameTilesetSpr		,
+									(GsSprite*)&GameTileset2Spr		,
+									(TYPE_FLIGHT_DATA*)&FlightData	,
+									(GsSprite*)&GamePlaneSpr		,
+									NULL							,
+									(GsSprite*)&GameMouseSpr		};
+									
+static char * GameLevelList[] = {	"cdrom:\\DATA\\LEVELS\\LEVEL1.LVL;1"};
+static uint8_t GameLevelBuffer[GAME_MAX_MAP_SIZE];
+									
+static uint8_t GameLevelColumns;
+static uint8_t GameLevelSize;
+
+static char GameLevelTitle[LEVEL_TITLE_SIZE];
+
+//Game local time
+static uint8_t GameHour;
+static uint8_t GameMinutes;
+
+//Local flag for two-player game mode. Obtained from Menu
+static bool TwoPlayersActive;
+//Index for first non-idle aircraft on list
+static uint8_t firstActiveAircraft;
+//Index for last non-idle aircraft on list
+static uint8_t lastActiveAircraft;
+
+void Game(bool two_players)
+{	
+	TwoPlayersActive = two_players;
+	GameInit();
+	
+	while(1)
+	{
+		if(GamePause() == true)
+		{
+			// Exit game
+			break;
+		}
+		
+		GameEmergencyMode();
+		
+		GameCalculations();
+		
+		GameGraphics();
+		
+		if(GameStartupFlag == true)
+		{
+			GameStartupFlag = false;
+		}
+	}
+	
+	EndAnimation();
+	
+	SfxPlayTrack(INTRO_TRACK);
+}
+
+bool GamePause(void)
+{
+	TYPE_PLAYER * ptrPlayer;
+	uint8_t i;
+	bool pause_flag = false;
+	
+	if(GameStartupFlag == true)
+	{
+		return false;
+	}
+	
+	for(i = 0 ; i < MAX_PLAYERS ; i++)
+	{
+		ptrPlayer = &PlayerData[i];
+		// Run player-specific functions for each player
+		if(ptrPlayer->Active == true)
+		{
+			//dprintf("Released callback = 0x%08X\n", ptrPlayer->PadKeyReleased_Callback);
+			if(ptrPlayer->PadKeyReleased_Callback(PAD_START) == true)
+			{
+				dprintf("Player %d set pause_flag to true!\n",i);
+				pause_flag = true;
+				break;
+			}
+		}
+	}
+	
+	if(pause_flag == true)
+	{	
+		// Blocking function:
+		// 	* Returns true if player pointed to by ptrPlayer wants to exit game
+		//	* Returns false if player pointed to by ptrPlayer wants to resume game
+		return GameGuiPauseDialog(ptrPlayer);
+	}
+	
+	return false;
+}
+
+void GameInit(void)
+{
+	uint8_t i;
+	uint32_t track;
+	
+	GameStartupFlag = true;
+	
+	LoadMenu(	GameFileList,
+				GameFileDest,
+				sizeof(GameFileList) / sizeof(char*),
+				sizeof(GameFileDest) /sizeof(void*)	);	
+	
+	GameLoadLevel();
+	
+	GameGuiInit();
+	
+	memset(GameRwy,0,GAME_MAX_RUNWAYS * sizeof(uint16_t) );
+	
+	memset(GameUsedRwy,0,GAME_MAX_RUNWAYS * sizeof(uint16_t) );
+	
+	PlayerData[PLAYER_ONE].Active = true;
+	PlayerData[PLAYER_ONE].PadKeyPressed_Callback = &PadOneKeyPressed;
+	PlayerData[PLAYER_ONE].PadKeyReleased_Callback = &PadOneKeyReleased;
+	PlayerData[PLAYER_ONE].PadDirectionKeyPressed_Callback = &PadOneDirectionKeyPressed;
+	PlayerData[PLAYER_ONE].FlightDataPage = 0;
+	
+	PlayerData[PLAYER_TWO].Active = TwoPlayersActive? true : false;
+	
+	if(PlayerData[PLAYER_TWO].Active == true)
+	{
+		PlayerData[PLAYER_TWO].PadKeyPressed_Callback = &PadTwoKeyPressed;
+		PlayerData[PLAYER_TWO].PadKeyReleased_Callback = &PadTwoKeyReleased;
+		PlayerData[PLAYER_TWO].PadDirectionKeyPressed_Callback = &PadTwoDirectionKeyPressed;
+		PlayerData[PLAYER_TWO].FlightDataPage = 0;
+		
+		// On 2-player mode, one player controls departure flights and
+		// other player controls arrival flights.
+		PlayerData[PLAYER_ONE].FlightDirection = DEPARTURE;
+		PlayerData[PLAYER_TWO].FlightDirection = ARRIVAL;
+	}
+	else
+	{
+		PlayerData[PLAYER_ONE].FlightDirection = DEPARTURE | ARRIVAL;
+	}
+	
+	for(i = 0; i < MAX_PLAYERS ; i++)
+	{
+		CameraInit(&PlayerData[i]);
+		PlayerData[i].ShowAircraftData = false;
+		PlayerData[i].SelectRunway = false;
+		PlayerData[i].SelectTaxiwayRunway = false;
+		PlayerData[i].LockTarget = false;
+		PlayerData[i].SelectedAircraft = 0;
+		PlayerData[i].FlightDataPage = 0;
+		memset(&PlayerData[i].Waypoints, 0, sizeof(uint16_t) * PLAYER_MAX_WAYPOINTS);
+		PlayerData[i].WaypointIdx = 0;
+		PlayerData[i].LastWaypointIdx = 0;
+	}
+	
+	firstActiveAircraft = 0;
+	lastActiveAircraft = 0;
+	
+	GameMouseSpr.x = MOUSE_X;
+	GameMouseSpr.y = MOUSE_Y;
+	GameMouseSpr.w = MOUSE_W;
+	GameMouseSpr.h = MOUSE_H;
+	GameMouseSpr.attribute = COLORMODE(COLORMODE_16BPP);
+	GameMouseSpr.r = NORMAL_LUMINANCE;
+	GameMouseSpr.g = NORMAL_LUMINANCE;
+	GameMouseSpr.b = NORMAL_LUMINANCE;
+	
+	GameGetRunwayArray();
+	
+	GameSelectedTile = 0;
+	
+	AircraftInit();
+				
+	LoadMenuEnd();
+	
+	GfxSetGlobalLuminance(0);
+	
+	track = SystemRand(GAMEPLAY_FIRST_TRACK,GAMEPLAY_LAST_TRACK);
+	
+	SfxPlayTrack(track);	
+}
+
+void GameEmergencyMode(void)
+{
+	enum
+	{
+		ERROR_RECT_X = 32,
+		ERROR_RECT_W = X_SCREEN_RESOLUTION - (ERROR_RECT_X << 1),
+		
+		ERROR_RECT_Y = 16,
+		ERROR_RECT_H = Y_SCREEN_RESOLUTION - (ERROR_RECT_Y << 1),
+		
+		ERROR_RECT_R = 0,
+		ERROR_RECT_G = 32,
+		ERROR_RECT_B = NORMAL_LUMINANCE
+	};
+	
+	GsRectangle errorRct;
+	
+	bzero((GsRectangle*)&errorRct, sizeof(GsRectangle));
+	
+	while(SystemGetEmergencyMode() == true)
+	{
+		// Pad one has been disconnected during gameplay
+		// Show an error screen until it is disconnected again.
+		
+		GsSortCls(0,0,0);
+		
+		errorRct.x = ERROR_RECT_X;
+		errorRct.w = ERROR_RECT_W;
+		errorRct.y = ERROR_RECT_Y;
+		errorRct.h = ERROR_RECT_H;
+		
+		errorRct.r = ERROR_RECT_R;
+		errorRct.g = ERROR_RECT_G;
+		errorRct.b = ERROR_RECT_B;
+		
+		GsSortRectangle(&errorRct);
+		GfxDrawScene();
+	}
+}
+
+void GameCalculations(void)
+{
+	uint8_t i;
+	
+	GameClock();
+	GameAircraftState();
+	GameActiveAircraft();
+	GameFirstLastAircraftIndex();
+	AircraftHandler();
+	
+	for(i = 0 ; i < MAX_PLAYERS ; i++)
+	{
+		// Run player-specific functions for each player
+		if(PlayerData[i].Active == true)
+		{
+			GamePlayerHandler(&PlayerData[i], &FlightData);
+		}
+	}
+	
+	if(PadOneKeyReleased(PAD_CIRCLE) == true)
+	{
+		for(i = 0; i < FlightData.nAircraft ; i++)
+		{
+			/*typedef struct
+			{
+				FL_DIR FlightDirection[GAME_MAX_AIRCRAFT];
+				char strFlightNumber[GAME_MAX_AIRCRAFT][GAME_MAX_CHARACTERS];
+				uint8_t Passengers[GAME_MAX_AIRCRAFT];
+				uint8_t Hours[GAME_MAX_AIRCRAFT];
+				uint8_t Minutes[GAME_MAX_AIRCRAFT];
+				uint8_t Parking[GAME_MAX_AIRCRAFT];
+			}TYPE_FLIGHT_DATA;*/
+			
+			dprintf("\n*****************\n");
+			dprintf("\tAIRCRAFT %d\n",i);
+			dprintf("*****************\n");
+			
+			if(FlightData.FlightDirection[i] == ARRIVAL)
+			{
+				dprintf("Direction: %s\n","Arrival");
+			}
+			else if(FlightData.FlightDirection[i] == DEPARTURE)
+			{
+				dprintf("Direction: %s\n","Arrival");
+			}
+			
+			dprintf("Time: %d:%d\n",FlightData.Hours[i],FlightData.Minutes[i]);
+			
+			dprintf("State: ");
+			
+			switch(FlightData.State[i])
+			{
+				case STATE_APPROACH:
+					dprintf("Approach");
+				break;
+				
+				case STATE_TAXIING:
+					dprintf("Taxiing");
+				break;
+				
+				case STATE_FINAL:
+					dprintf("Final");
+				break;
+				
+				case STATE_IDLE:
+					dprintf("Idle");
+				break;
+				
+				case STATE_PARKED:
+					dprintf("Parked");
+				break;
+				
+				case STATE_LANDED:
+					dprintf("Landed");
+				break;
+				
+				case STATE_TAKEOFF:
+					dprintf("Takeoff");
+				break;
+				
+				default:
+				break;
+			}
+			dprintf("\n");
+		}
+		
+		dprintf("Active aircraft: %d\n",FlightData.ActiveAircraft);
+	}
+	
+}
+
+void GameFirstLastAircraftIndex(void)
+{
+	bool first_set = false;
+	uint8_t i;
+	
+	for(i = 0; i < GAME_MAX_AIRCRAFT ; i++)
+	{
+		if(FlightData.State[i] != STATE_IDLE)
+		{
+			if(first_set == false)
+			{
+				firstActiveAircraft = i;
+				first_set = true;
+			}
+			lastActiveAircraft = i;
+		}
+	}
+}
+
+uint8_t GameGetFirstActiveAircraft(void)
+{
+	return firstActiveAircraft;
+}
+
+uint8_t GameGetLastActiveAircraft(void)
+{
+	return lastActiveAircraft;
+}
+
+void GamePlayerHandler(TYPE_PLAYER * ptrPlayer, TYPE_FLIGHT_DATA * ptrFlightData)
+{
+	ptrPlayer->SelectedTile = 0;	// Reset selected tile if no states
+									// which use this are currently active.
+	ptrPlayer->InvalidPath = false; // Do the same thing for "InvalidPath".
+
+	GameStateLockTarget(ptrPlayer);
+	GameStateSelectRunway(ptrPlayer, ptrFlightData);
+	GameStateSelectTaxiwayRunway(ptrPlayer, ptrFlightData);
+	GameStateSelectTaxiwayParking(ptrPlayer, ptrFlightData);
+	GameStateShowAircraft(ptrPlayer, ptrFlightData);
+	CameraHandler(ptrPlayer);
+	GameGuiActiveAircraftList(ptrPlayer, ptrFlightData);
+	GameGuiActiveAircraftPage(ptrPlayer, ptrFlightData);
+	GameSelectAircraftFromList(ptrPlayer, ptrFlightData);
+}
+
+void GameClock(void)
+{
+	if(System1SecondTick() == true)
+	{
+		GameMinutes++;
+		
+		if(GameMinutes >= 60)
+		{
+			GameHour++;
+			GameMinutes = 0;
+		}
+		
+		if(GameHour >= 24)
+		{
+			GameHour = 0;
+		}
+	}
+	
+	GameClockFlights();
+}
+
+void GameClockFlights(void)
+{
+	uint8_t i;
+	
+	for(i = 0; i < FlightData.nAircraft ; i++)
+	{
+		if(System1SecondTick() == true)
+		{
+			if(	(FlightData.Minutes[i] == 0)
+						&&
+				(FlightData.Hours[i] > 0)	)
+			{
+				FlightData.Minutes[i] = 60;
+				FlightData.Hours[i]--;
+			}
+			
+			if(FlightData.Minutes[i] > 0)
+			{
+				FlightData.Minutes[i]--;
+			}
+		}
+	}
+}
+
+void GameGraphics(void)
+{
+	int i;
+	
+	while(	(GfxIsGPUBusy() == true)
+					||
+			(SystemRefreshNeeded() == false)	);
+
+	GsSortCls(0,0,NORMAL_LUMINANCE >> 1);
+	
+	if(GfxGetGlobalLuminance() < NORMAL_LUMINANCE)
+	{
+		GfxIncreaseGlobalLuminance(1);
+	}
+	
+	for(i = 0; i < MAX_PLAYERS ; i++)
+	{
+		if(PlayerData[i].Active == true)
+		{
+			GameRenderLevel(&PlayerData[i]);
+			AircraftRender(&PlayerData[i]);
+		}
+	}
+	
+	GameGuiAircraftNotificationRequest(&FlightData);
+	
+	GameGuiBubble(&FlightData);
+	
+	GameGuiClock(GameHour,GameMinutes);
+	
+	for(i = 0; i < MAX_PLAYERS ; i++)
+	{
+		GameGuiAircraftList(&PlayerData[i], &FlightData);
+	}
+	
+	GfxDrawScene();	
+}
+
+void GameLoadLevel(void)
+{	
+	uint8_t i = 0;
+	uint8_t * ptrBuffer;
+	char LevelHeader[LEVEL_MAGIC_NUMBER_SIZE + 1];
+	
+	/* TODO - Very important */
+	// Map contents (that means, without header) should be copied to GameLevelBuffer
+	// Header treatment (magic number, map size, map title...) should be done
+	// using System's file buffer.
+	
+	if(SystemLoadFile(GameLevelList[0]) == false)
+	{
+		return;
+	}
+	
+	ptrBuffer = SystemGetBufferAddress();
+	
+	//SystemLoadFileToBuffer(GameLevelList[0],GameLevelBuffer,GAME_MAX_MAP_SIZE);
+	
+	memset(LevelHeader,0, LEVEL_MAGIC_NUMBER_SIZE + 1);
+	
+	memcpy(LevelHeader,ptrBuffer,LEVEL_MAGIC_NUMBER_SIZE);
+	
+	LevelHeader[LEVEL_MAGIC_NUMBER_SIZE] = '\0';
+	
+	dprintf("Level header: %s\n",LevelHeader);
+	
+	if(strncmp(LevelHeader,LEVEL_MAGIC_NUMBER_STRING,LEVEL_MAGIC_NUMBER_SIZE) != 0)
+	{
+		dprintf("Invalid level header! Read \"%s\" instead of \"ATC\"\n",LevelHeader);
+		return;
+	}
+	
+	i += LEVEL_MAGIC_NUMBER_SIZE;
+	
+	GameLevelColumns = ptrBuffer[i++];
+	
+	dprintf("Level size: %d\n",GameLevelColumns);
+	
+	if(	(GameLevelColumns < MIN_MAP_COLUMNS)
+			||
+		(GameLevelColumns > MAX_MAP_COLUMNS)	)
+	{
+		dprintf("Invalid map size! Value: %d\n",GameLevelColumns);	
+		return;
+	}
+	
+	GameLevelSize = GameLevelColumns * GameLevelColumns;
+	
+	memset(GameLevelTitle,0,LEVEL_TITLE_SIZE);
+	
+	memcpy(GameLevelTitle,&ptrBuffer[i],LEVEL_TITLE_SIZE);
+	
+	dprintf("Game level title: %s\n",GameLevelTitle);
+	
+	i += LEVEL_TITLE_SIZE;
+	
+	memset(GameLevelBuffer,0,GAME_MAX_MAP_SIZE);
+	
+	i = LEVEL_HEADER_SIZE;
+	
+	memcpy(GameLevelBuffer,&ptrBuffer[i],GameLevelSize);
+	
+}
+
+char* GetGameLevelTitle(void)
+{
+	return GameLevelTitle;
+}
+
+void GameAircraftState(void)
+{
+	uint8_t i;
+	
+	for(i = 0; i < FlightData.nAircraft ; i++)
+	{
+		if(	(FlightData.Hours[i] == 0)
+					&&
+			(FlightData.Minutes[i] == 0)
+					&&
+			(FlightData.State[i] == STATE_IDLE)	)
+		{
+			if(FlightData.FlightDirection[i] == DEPARTURE)
+			{
+				FlightData.State[i] = STATE_PARKED;
+			}
+			else if(FlightData.FlightDirection[i] == ARRIVAL)
+			{
+				FlightData.State[i] = STATE_APPROACH;
+			}
+			
+			// Create notification request for incoming aircraft
+			FlightData.NotificationRequest[i] = true;
+		}
+	}
+}
+
+
+void GameRenderLevel(TYPE_PLAYER * ptrPlayer)
+{
+	uint16_t i;
+	uint16_t j;
+	uint8_t columns = 0;
+	uint8_t rows = 0;
+	bool flip_id;
+	bool used_rwy;
+	uint8_t aux_id;
+	GsSprite * ptrTileset;
+	static unsigned char rwy_sine = 0;
+	static bool rwy_sine_decrease = false;
+	TYPE_ISOMETRIC_POS tileIsoPos;
+	TYPE_CARTESIAN_POS tileCartPos;
+	
+	// Prepare runway to be painted in blue if player is on runway selection mode
+	if(ptrPlayer->SelectRunway == true)
+	{
+		GameGetSelectedRunwayArray(GameRwy[ptrPlayer->SelectedRunway]);
+		/*dprintf("Runway array:\n");
+		
+		for(j = 0; j < GAME_MAX_RWY_LENGTH; j++)
+		{
+			dprintf("%d ",GameRwyArray[j]);
+		}
+		
+		dprintf("\n");*/
+	}
+	
+	for(i = 0 ; i < GameLevelSize; i++)
+	{
+		// Flipped tiles have bit 7 enabled
+		if(GameLevelBuffer[i] & TILE_MIRROR_FLAG)
+		{
+			flip_id = true;
+			aux_id = GameLevelBuffer[i];
+			GameLevelBuffer[i] &= ~(TILE_MIRROR_FLAG);
+		}
+		else
+		{
+			flip_id = false;
+		}
+		
+		if(GameLevelBuffer[i] == TILE_NOTHING)
+		{
+			// Skip empty tiles
+			continue;
+		}
+		
+		if(GameLevelBuffer[i] <= LAST_TILE_TILESET1)
+		{
+			// Draw using GameTilesetSpr
+			ptrTileset = &GameTilesetSpr;
+		}
+		else if(	(GameLevelBuffer[i] > LAST_TILE_TILESET1)
+						&&
+					(GameLevelBuffer[i] <= LAST_TILE_TILESET2)	)
+		{
+			// Draw using GameTileset2Spr
+			ptrTileset = &GameTileset2Spr;
+		}
+		else
+		{
+			ptrTileset = NULL;
+			
+			if(flip_id == false)
+			{
+				continue;
+			}
+		}
+		
+		ptrTileset->w = TILE_SIZE;
+		ptrTileset->h = TILE_SIZE;
+		
+		used_rwy = false;
+		
+		if(	(ptrPlayer->SelectRunway == true)
+						&&
+			(i != 0)
+						&&
+			(SystemContains_u16(i, GameRwyArray, GAME_MAX_RWY_LENGTH) == true)	)
+		{
+			for(j = 0; j < GAME_MAX_RUNWAYS; j++)
+			{
+				if(GameUsedRwy[j] != 0)
+				{
+					if(SystemContains_u16(GameUsedRwy[j], GameRwyArray, GAME_MAX_RWY_LENGTH) == true)
+					{
+						used_rwy = true;
+						break;
+					}
+				}
+			}
+			
+			if(used_rwy == true)
+			{
+				ptrTileset->r = rwy_sine;
+				ptrTileset->b = NORMAL_LUMINANCE >> 2;
+				ptrTileset->g = NORMAL_LUMINANCE >> 2;
+			}
+			else
+			{
+				ptrTileset->r = NORMAL_LUMINANCE >> 2;
+				ptrTileset->g = NORMAL_LUMINANCE >> 2;
+				ptrTileset->b = rwy_sine;
+			}
+		}
+		else if( (	(ptrPlayer->SelectTaxiwayParking == true)
+										||
+					(ptrPlayer->SelectTaxiwayRunway == true)	)
+								&&
+				 (i != 0)
+								&&
+				 (	(SystemContains_u16(i, ptrPlayer->Waypoints, PLAYER_MAX_WAYPOINTS) == true)
+								||
+					(i == ptrPlayer->SelectedTile)	)	
+								&&
+				 (ptrPlayer->SelectedTile != GAME_INVALID_TILE_SELECTION)	)
+		{
+			if(ptrPlayer->InvalidPath == true)
+			{
+				ptrTileset->r = rwy_sine;
+				ptrTileset->b = NORMAL_LUMINANCE >> 2;
+				ptrTileset->g = NORMAL_LUMINANCE >> 2;
+			}
+			else
+			{
+				ptrTileset->r = NORMAL_LUMINANCE >> 2;
+				ptrTileset->g = NORMAL_LUMINANCE >> 2;
+				ptrTileset->b = rwy_sine;
+			}
+		}
+		else
+		{
+			ptrTileset->r = NORMAL_LUMINANCE;
+			ptrTileset->g = NORMAL_LUMINANCE;
+			ptrTileset->b = NORMAL_LUMINANCE;
+		}
+		
+		if(System100msTick() == true)
+		{
+			if(rwy_sine_decrease == false)
+			{
+				if(rwy_sine < 255)
+				{
+					rwy_sine++;
+				}
+				else
+				{
+					rwy_sine_decrease = true;
+				}
+			}
+			else
+			{
+				if(rwy_sine > (NORMAL_LUMINANCE >> 2))
+				{
+					rwy_sine--;
+				}
+				else
+				{
+					rwy_sine_decrease = false;
+				}
+			}
+		}
+		
+		// TODO: Isometric -> Cartesian conversion
+		tileIsoPos.x = columns << (TILE_SIZE_BIT_SHIFT);
+		tileIsoPos.y = rows << (TILE_SIZE_BIT_SHIFT);
+		tileIsoPos.z = 0;
+		
+		tileCartPos = GfxIsometricToCartesian(&tileIsoPos);
+		
+		ptrTileset->x = tileCartPos.x;
+		ptrTileset->y = tileCartPos.y;
+		
+		// Set coordinate origin to left upper corner
+		ptrTileset->x -= TILE_SIZE >> 1;
+		ptrTileset->y -= TILE_SIZE >> 2;
+		
+		/*ptrTileset->x = columns << (TILE_SIZE_BIT_SHIFT - 1);
+		ptrTileset->x -= rows << (TILE_SIZE_BIT_SHIFT - 1);
+		
+		ptrTileset->y = rows << (TILE_SIZE_BIT_SHIFT - 2);
+		ptrTileset->y += columns << (TILE_SIZE_BIT_SHIFT - 2);*/
+		
+		if(columns < GameLevelColumns -1 )
+		{
+			columns++;
+		}
+		else
+		{
+			rows++;
+			columns = 0;
+		}
+		
+		if(ptrTileset != NULL)
+		{
+			if(flip_id == true)
+			{
+				ptrTileset->attribute |= H_FLIP;
+			}
+		}
+		
+		ptrTileset->u = (short)(GameLevelBuffer[i] % COLUMNS_PER_TILESET)<<TILE_SIZE_BIT_SHIFT;
+		ptrTileset->v = (short)(GameLevelBuffer[i] / COLUMNS_PER_TILESET)<<TILE_SIZE_BIT_SHIFT;
+			
+		if(flip_id == true)
+		{
+			flip_id = false;
+			GameLevelBuffer[i] = aux_id;
+		}
+		
+	//	dprintf("Tile %d, attribute 0x%X\n",i,ptrTileset->attribute);
+		
+		CameraApplyCoordinatesToSprite(ptrPlayer, ptrTileset);
+		GfxSortSprite(ptrTileset);
+				
+		if(ptrTileset->attribute & H_FLIP)
+		{
+			ptrTileset->attribute &= ~(H_FLIP);
+		}
+	}
+	
+	if(	(ptrPlayer->SelectTaxiwayParking == true)
+						||
+		(ptrPlayer->SelectTaxiwayRunway == true) 	)
+	{
+		GfxSortSprite(&GameMouseSpr);
+	}
+	
+	/*if(PadOneKeyReleased(PAD_CROSS) == true)
+	{
+		for(i = 0; i < GameLevelSize; i++)
+		{
+			dprintf("Tile number %d, ID: %d\n",i,GameLevelBuffer[i]);
+		}
+	}*/
+}
+
+void GameSetTime(uint8_t hour, uint8_t minutes)
+{
+	GameHour = hour;
+	GameMinutes = minutes;
+}
+
+void GameActiveAircraft(void)
+{
+	uint8_t i;
+	
+	FlightData.ActiveAircraft = 0;
+	
+	for(i = 0 ; i < FlightData.nAircraft ; i++)
+	{
+		if(FlightData.State[i] != STATE_IDLE)
+		{
+			FlightData.ActiveAircraft++;
+		}
+	}
+}
+
+void GameStateShowAircraft(TYPE_PLAYER * ptrPlayer, TYPE_FLIGHT_DATA * ptrFlightData)
+{
+	if(ptrPlayer->ShowAircraftData == true)
+	{
+		if(ptrPlayer->PadKeyReleased_Callback(PAD_TRIANGLE) == true)
+		{
+			ptrPlayer->ShowAircraftData = false;
+		}
+		else if(ptrPlayer->PadKeyReleased_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->PadKeyReleased_Callback(PAD_CIRCLE) == true)
+	{
+		if(GameGuiShowAircraftDataSpecialConditions(ptrPlayer) == false)
+		{
+			//Invert ptrPlayer->ShowAircraftData value
+			ptrPlayer->ShowAircraftData = ptrPlayer->ShowAircraftData ? false : true;
+		}
+	}
+}
+
+void GameStateLockTarget(TYPE_PLAYER * ptrPlayer)
+{
+	if(ptrPlayer->LockTarget == true)
+	{
+		CameraMoveToIsoPos(ptrPlayer, AircraftGetIsoPos(ptrPlayer->LockedAircraft) );
+		
+		if(ptrPlayer->PadKeyReleased_Callback(PAD_SQUARE) == true)
+		{
+			ptrPlayer->LockTarget = false;
+			ptrPlayer->LockedAircraft = 0;
+		}
+	}
+}
+
+void GameStateSelectTaxiwayRunway(TYPE_PLAYER * ptrPlayer, TYPE_FLIGHT_DATA * ptrFlightData)
+{
+	TYPE_ISOMETRIC_POS IsoPos = CameraGetIsoPos(ptrPlayer);
+	uint8_t i;
+	uint16_t target_tile;
+	
+	/*dprintf("Camera is pointing to {%d,%d}\n",IsoPos.x, IsoPos.y);*/
+	
+	if(ptrPlayer->SelectTaxiwayRunway == true)
+	{
+		// Under this mode, always reset locking target.
+		ptrPlayer->LockTarget = false;
+		ptrPlayer->LockedAircraft = 0;
+		
+		ptrPlayer->SelectedTile = GameGetTileFromIsoPosition(&IsoPos);
+		
+		if(GamePathToTile(ptrPlayer) == false)
+		{
+			ptrPlayer->InvalidPath = true;
+		}
+		
+		if(ptrPlayer->PadKeyReleased_Callback(PAD_TRIANGLE) == true)
+		{
+			// State exit.
+			ptrPlayer->SelectTaxiwayRunway = false;
+			// Clear waypoints array.
+			memset(ptrPlayer->Waypoints, 0, sizeof(uint16_t) * PLAYER_MAX_WAYPOINTS);
+			ptrPlayer->WaypointIdx = 0;
+			ptrPlayer->LastWaypointIdx = 0;
+		}
+		else if(ptrPlayer->PadKeyReleased_Callback(PAD_CROSS) == true)
+		{
+			if(ptrPlayer->InvalidPath == false)
+			{
+				for(i = 0; i < PLAYER_MAX_WAYPOINTS; i++)
+				{
+					if(ptrPlayer->Waypoints[i] == 0)
+					{
+						break;
+					}
+					
+					ptrPlayer->LastWaypointIdx = i;
+				}
+				
+				target_tile = GameLevelBuffer[ptrPlayer->Waypoints[ptrPlayer->LastWaypointIdx]];
+				
+				if(	(target_tile == TILE_RWY_START_1)
+										||
+					(target_tile == (TILE_RWY_START_1 | TILE_MIRROR_FLAG) )
+										||
+					(target_tile == TILE_RWY_START_2)
+										||
+					(target_tile == (TILE_RWY_START_2 | TILE_MIRROR_FLAG) ) )
+				{
+					// TODO: Assign path to aircraft
+					AircraftFromFlightDataIndexAddTargets(ptrPlayer->LockedAircraft, ptrPlayer->Waypoints);
+					dprintf("Added these targets to aircraft %d:\n", ptrPlayer->LockedAircraft);
+					
+					for(i = 0; i < PLAYER_MAX_WAYPOINTS; i++)
+					{
+						dprintf("%d ",ptrPlayer->Waypoints[i]);
+					}
+					
+					dprintf("\n");
+					
+					ptrPlayer->SelectTaxiwayParking = false;
+					// Clear waypoints array.
+					memset(ptrPlayer->Waypoints, 0, sizeof(uint16_t) * PLAYER_MAX_WAYPOINTS);
+					ptrPlayer->WaypointIdx = 0;
+					ptrPlayer->LastWaypointIdx = 0;
+					
+					ptrFlightData->State[ptrPlayer->LockedAircraft] = STATE_TAXIING;
+				}
+			}
+		}
+	}
+}
+
+void GameStateSelectTaxiwayParking(TYPE_PLAYER * ptrPlayer, TYPE_FLIGHT_DATA * ptrFlightData)
+{
+	TYPE_ISOMETRIC_POS IsoPos = CameraGetIsoPos(ptrPlayer);
+	uint8_t i;
+	uint16_t target_tile;
+	
+	if(ptrPlayer->SelectTaxiwayParking == true)
+	{
+		// Under this mode, always reset locking target.
+		ptrPlayer->LockTarget = false;
+		ptrPlayer->LockedAircraft = 0;
+		
+		ptrPlayer->SelectedTile = GameGetTileFromIsoPosition(&IsoPos);
+		
+		if(GamePathToTile(ptrPlayer) == false)
+		{
+			ptrPlayer->InvalidPath = true;
+		}
+		
+		if(ptrPlayer->PadKeyReleased_Callback(PAD_TRIANGLE) == true)
+		{
+			// State exit.
+			ptrPlayer->SelectTaxiwayParking = false;
+			// Clear waypoints array.
+			memset(ptrPlayer->Waypoints, 0, sizeof(uint16_t) * PLAYER_MAX_WAYPOINTS);
+			ptrPlayer->WaypointIdx = 0;
+			ptrPlayer->LastWaypointIdx = 0;
+		}
+		else if(ptrPlayer->PadKeyReleased_Callback(PAD_CROSS) == true)
+		{
+			if(ptrPlayer->InvalidPath == false)
+			{
+				for(i = 0; i < PLAYER_MAX_WAYPOINTS; i++)
+				{
+					if(ptrPlayer->Waypoints[i] == 0)
+					{
+						break;
+					}
+					
+					ptrPlayer->LastWaypointIdx = i;
+				}
+				
+				target_tile = GameLevelBuffer[ptrPlayer->Waypoints[ptrPlayer->LastWaypointIdx]];
+				
+				dprintf("ptrPlayer->LastWaypointIdx = %d\n",
+						ptrPlayer->LastWaypointIdx);
+				
+				dprintf("target_tile = %d, TILE_PARKING = %d\n",
+						target_tile,
+						TILE_PARKING);
+				
+				if(	(target_tile == TILE_PARKING)
+								||
+					(target_tile == (TILE_PARKING | TILE_MIRROR_FLAG) ) )
+				{
+					// TODO: Assign path to aircraft
+					AircraftFromFlightDataIndexAddTargets(ptrPlayer->LockedAircraft, ptrPlayer->Waypoints);
+					
+					dprintf("Added these targets to aircraft %d:\n", ptrPlayer->LockedAircraft);
+					
+					for(i = 0; i < PLAYER_MAX_WAYPOINTS; i++)
+					{
+						dprintf("%d ",ptrPlayer->Waypoints[i]);
+					}
+					
+					dprintf("\n");
+					
+					ptrPlayer->SelectTaxiwayParking = false;
+					// Clear waypoints array.
+					memset(ptrPlayer->Waypoints, 0, sizeof(uint16_t) * PLAYER_MAX_WAYPOINTS);
+					ptrPlayer->WaypointIdx = 0;
+					ptrPlayer->LastWaypointIdx = 0;
+					
+					ptrFlightData->State[ptrPlayer->LockedAircraft] = STATE_TAXIING;
+				}
+			}
+		}
+	}
+}
+
+void GameStateSelectRunway(TYPE_PLAYER * ptrPlayer, TYPE_FLIGHT_DATA * ptrFlightData)
+{	
+	uint8_t i;
+	bool success;
+	
+	if(ptrPlayer->SelectRunway == true)
+	{
+		// Under this mode, always reset locking target.
+		ptrPlayer->LockTarget = false;
+		ptrPlayer->LockedAircraft = 0;
+		
+		if(ptrPlayer->PadKeyReleased_Callback(PAD_TRIANGLE) == true)
+		{
+			ptrPlayer->SelectRunway = false;
+		}
+		else if(ptrPlayer->PadKeyReleased_Callback(PAD_CROSS) == true)
+		{
+			ptrPlayer->SelectRunway = false;
+			
+			dprintf("ptrPlayer->SelectedRunway = %d\n", GameRwy[ptrPlayer->SelectedRunway]);
+			if(SystemContains_u16(GameRwy[ptrPlayer->SelectedRunway], GameUsedRwy, GAME_MAX_RUNWAYS) == false)
+			{
+				ptrPlayer->SelectRunway = false;
+				dprintf("Player selected runway %d!\n",GameRwy[ptrPlayer->SelectedRunway]);
+				
+				success = false;
+				
+				for(i = 0; i < GAME_MAX_RUNWAYS; i++)
+				{
+					if(GameUsedRwy[i] == 0)
+					{
+						GameAssignRunwaytoAircraft(ptrPlayer, ptrFlightData);
+						success = true;
+						GameUsedRwy[i] = GameRwy[ptrPlayer->SelectedRunway];					
+						break;
+					}
+				}
+				
+				if(success == false)
+				{
+					dprintf("No available runways!\n");
+				}
+			}
+		}
+		else if(ptrPlayer->PadKeyReleased_Callback(PAD_LEFT) == true)
+		{
+			if(ptrPlayer->SelectedRunway != 0)
+			{
+				ptrPlayer->SelectedRunway--;
+			}
+		}
+		else if(ptrPlayer->PadKeyReleased_Callback(PAD_RIGHT) == true)
+		{
+			if(ptrPlayer->SelectedRunway < GAME_MAX_RUNWAYS)
+			{
+				if(GameRwy[ptrPlayer->SelectedRunway + 1] != 0)
+				{
+					ptrPlayer->SelectedRunway++;
+				}
+			}
+		}
+	}
+}
+
+void GameGetRunwayArray(void)
+{
+	uint8_t i;
+	uint8_t j = 0;
+	
+	for(i = 0; i < GameLevelSize; i++)
+	{
+		if(GameLevelBuffer[i] == TILE_RWY_START_1)
+		{
+			if(SystemContains_u8(i, GameLevelBuffer, GAME_MAX_RUNWAYS) == false)
+			{
+				GameRwy[j++] = i;
+			}
+		}
+	}
+	
+	dprintf("GameRwy = ");
+	
+	for(i = 0; i < GAME_MAX_RUNWAYS; i++)
+	{
+		if(GameRwy[i] == 0)
+		{
+			break;
+		}
+		
+		dprintf("%d ", GameRwy[i]);
+	}
+	
+	dprintf("\n");
+}
+
+void GameSelectAircraftFromList(TYPE_PLAYER * ptrPlayer, TYPE_FLIGHT_DATA * ptrFlightData)
+{
+	FL_STATE aircraftState = ptrFlightData->State[ptrPlayer->SelectedAircraft];
+	
+	if(ptrPlayer->ShowAircraftData == true)
+	{
+		if(ptrPlayer->PadKeyReleased_Callback(PAD_CROSS) == true)
+		{
+			if(ptrPlayer->ActiveAircraft != 0)
+			{
+				ptrPlayer->ShowAircraftData = false;
+				
+				switch(aircraftState)
+				{
+					case STATE_APPROACH:
+						ptrPlayer->SelectRunway = true;
+					break;
+					
+					case STATE_PARKED:
+						ptrPlayer->SelectTaxiwayRunway = true;
+						GameSelectAircraft(ptrPlayer);
+					break;
+					
+					case STATE_LANDED:
+						ptrPlayer->SelectTaxiwayParking = true;
+						// Move camera to selected aircraft and add first waypoint.
+						GameSelectAircraft(ptrPlayer);
+					break;
+					
+					default:
+						dprintf("Incompatible state %d!\n",aircraftState);
+						// States remain unchanged
+						ptrPlayer->SelectRunway = false;
+						ptrPlayer->SelectTaxiwayRunway = false;
+						ptrPlayer->ShowAircraftData = true;
+					break;
+				}
+			}
+		}
+	}
+}
+
+void GameGetSelectedRunwayArray(uint16_t rwyHeader)
+{
+	typedef enum t_rwydir
+	{
+		RWY_DIR_EAST	= 0,
+		RWY_DIR_WEST,
+		RWY_DIR_NORTH,
+		RWY_DIR_SOUTH,
+	}RWY_DIR;
+	
+	static uint16_t last_tile = 0;
+	static uint8_t i = 0;
+	static RWY_DIR dir;
+	
+	if(rwyHeader != 0)
+	{
+		// This function is called recursively.
+		// Since 0 is not a valid value (it's not allowed to place
+		// a runway header on first tile), it is used to determine
+		// when to start creating the array.
+		memset(GameRwyArray, 0, GAME_MAX_RWY_LENGTH * sizeof(uint16_t));
+		last_tile = rwyHeader;
+		i = 0;
+		
+		switch(GameLevelBuffer[rwyHeader])
+		{
+			case TILE_RWY_START_1:
+				dir = RWY_DIR_EAST; 
+				break;
+			case TILE_RWY_START_2:
+				dir = RWY_DIR_WEST; 
+				break;
+			case TILE_RWY_START_1 | TILE_MIRROR_FLAG:
+				dir = RWY_DIR_SOUTH;
+			case TILE_RWY_START_2 | TILE_MIRROR_FLAG:
+				dir = RWY_DIR_NORTH;
+			default:
+				dprintf("Unknown direction for tile %d\n",rwyHeader);
+				return;
+			break;
+		}
+	}
+	else
+	{
+		if(	(GameLevelBuffer[last_tile] == TILE_RWY_START_1)
+						||
+			(GameLevelBuffer[last_tile] == TILE_RWY_START_2)
+						||
+			(GameLevelBuffer[last_tile] == (TILE_RWY_START_1 | TILE_MIRROR_FLAG) )
+						||
+			(GameLevelBuffer[last_tile] == (TILE_RWY_START_2 | TILE_MIRROR_FLAG) )	)
+		{
+			// Runway end found
+			GameRwyArray[i++] = last_tile;
+			return;
+		}
+	}
+	
+	GameRwyArray[i++] = last_tile;
+	
+	switch(dir)
+	{
+		case RWY_DIR_EAST:
+			last_tile++;
+			break;
+		case RWY_DIR_WEST:
+			last_tile--;
+		case RWY_DIR_NORTH:
+			last_tile -= GameLevelColumns;
+		case RWY_DIR_SOUTH:
+			last_tile += GameLevelColumns;
+	}
+	
+	GameGetSelectedRunwayArray(0);
+}
+
+void GameAssignRunwaytoAircraft(TYPE_PLAYER * ptrPlayer, TYPE_FLIGHT_DATA * ptrFlightData)
+{
+	uint16_t assignedRwy = GameRwy[ptrPlayer->SelectedRunway];
+	uint8_t aircraftIndex = ptrPlayer->SelectedAircraft;
+	uint16_t rwyExit;
+	uint32_t i;
+	uint16_t targets[AIRCRAFT_MAX_TARGETS];
+	uint8_t rwyTiles[GAME_MAX_RWY_LENGTH];
+	
+	memset(targets, 0, sizeof(uint16_t) * AIRCRAFT_MAX_TARGETS);
+	
+	// Remember that ptrPlayer->SelectedAircraft contains an index to
+	// be used with ptrFlightData.
+	
+	/*typedef enum t_flstate
+{
+	STATE_IDLE = 0,
+	STATE_PARKED,
+	STATE_TAXIING,
+	STATE_APPROACH,
+	STATE_FINAL
+	}FL_STATE;*/
+	
+	dprintf("aircraftIndex = %d\n",aircraftIndex);
+	
+	if(ptrFlightData->State[aircraftIndex] == STATE_APPROACH)
+	{		
+		ptrFlightData->State[aircraftIndex] = STATE_FINAL;
+		
+		GameGetSelectedRunwayArray(assignedRwy);
+		
+		for(i = 0; i < GAME_MAX_RWY_LENGTH; i++)
+		{
+			rwyTiles[i] = GameLevelBuffer[GameRwyArray[i]];
+		}
+		
+		i = SystemIndexOf_U8((uint8_t)TILE_RWY_EXIT, rwyTiles, 0, GAME_MAX_RWY_LENGTH);
+		
+		if(i == -1)
+		{
+			dprintf("ERROR: Could not find TILE_RWY_EXIT for runway header %d.\n", assignedRwy);
+			return;
+		}
+		
+		i = SystemIndexOf_U8((uint8_t)TILE_RWY_EXIT, rwyTiles, i + 1, GAME_MAX_RWY_LENGTH);
+		
+		if(i == -1)
+		{
+			dprintf("ERROR: Could not find second TILE_RWY_EXIT for runway header %d.\n", assignedRwy);
+			return;
+		} 
+		
+		rwyExit = GameRwyArray[i];
+		
+		targets[0] = assignedRwy;
+		targets[1] = rwyExit;
+		
+		if( AircraftAddNew(ptrFlightData,
+							aircraftIndex,
+							targets	) == false)
+		{
+			dprintf("Exceeded maximum aircraft number!\n");
+			return;
+		}
+	}
+}
+
+fix16_t GameGetXFromTile(uint16_t tile)
+{
+	fix16_t retVal;
+	
+	tile %= GameLevelColumns;
+	
+	retVal = (fix16_t)(tile << TILE_SIZE_BIT_SHIFT);
+	
+	// Always point to tile center
+	retVal += TILE_SIZE >> 1;
+	
+	retVal = fix16_from_int(retVal);
+	
+	return retVal;
+}
+
+fix16_t GameGetYFromTile(uint16_t tile)
+{
+	fix16_t retVal;
+	
+	tile /= GameLevelColumns;
+	
+	retVal = (fix16_t)(tile << TILE_SIZE_BIT_SHIFT);
+	
+	// Always point to tile center
+	retVal += TILE_SIZE >> 1;
+	
+	retVal = fix16_from_int(retVal);
+	
+	return retVal;
+}
+
+void GameTargetsReached(uint8_t index)
+{
+	switch(FlightData.State[index])
+	{
+		case STATE_FINAL:
+			FlightData.State[index] = STATE_LANDED;
+		break;
+		
+		default:
+		break;
+	}
+}
+
+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;
+	
+	if(	(IsoPos->x < 0) || (IsoPos->y < 0) )
+	{
+		return GAME_INVALID_TILE_SELECTION; // Invalid XYZ position
+	}
+	
+	tile = IsoPos->x >> TILE_SIZE_BIT_SHIFT;
+	tile += (IsoPos->y >> TILE_SIZE_BIT_SHIFT) * GameLevelColumns;
+	
+	/*dprintf("Returning tile %d from position {%d, %d, %d}\n",
+			tile,
+			IsoPos->x,
+			IsoPos->y,
+			IsoPos->z	);*/
+	
+	return tile;
+}
+
+uint8_t GameGetLevelColumns(void)
+{
+	return GameLevelColumns;
+}
+
+void GamePlayerAddWaypoint(TYPE_PLAYER * ptrPlayer)
+{
+	GamePlayerAddWaypoint_Ex(ptrPlayer, ptrPlayer->SelectedTile);
+}
+
+void GamePlayerAddWaypoint_Ex(TYPE_PLAYER * ptrPlayer, uint16_t tile)
+{
+	// "_Ex" function allow selecting a certain tile, whereas the other one
+	// is a particulare case of "_Ex" for tile = ptrPlayer->SelectedTIle.
+	
+	if(ptrPlayer->WaypointIdx >= PLAYER_MAX_WAYPOINTS)
+	{
+		dprintf("No available waypoints for this player!\n");
+		return;
+	}
+	
+	/*dprintf("Added tile %d to ptrPlayer->Waypoints[%d]\n",
+			tile,
+			ptrPlayer->WaypointIdx);*/
+	
+	ptrPlayer->Waypoints[ptrPlayer->WaypointIdx++] = tile;
+}
+
+bool GamePathToTile(TYPE_PLAYER * ptrPlayer)
+{
+	// Given an input TYPE_PLAYER structure and a selected tile,
+	// it updates current Waypoints array with all tiles between two points.
+	// If one of these tiles do not belong to desired tiles (i.e.: grass,
+	// water, buildings...), then false is returned.
+	
+	uint8_t AcceptedTiles[] = {	TILE_ASPHALT, TILE_ASPHALT_WITH_BORDERS,
+								TILE_PARKING, TILE_RWY_START_1,
+								TILE_RWY_START_2, TILE_RWY_MID,
+								TILE_RWY_EXIT, TILE_TAXIWAY_CORNER_GRASS,
+								TILE_TAXIWAY_CORNER_GRASS_2, TILE_TAXIWAY_GRASS,
+								TILE_TAXIWAY_INTERSECT_GRASS};
+								
+	uint8_t i;
+	uint8_t j;
+	
+	uint16_t x_diff;
+	uint16_t y_diff;
+	uint16_t temp_tile;
+	
+	if(ptrPlayer->SelectedTile == GAME_INVALID_TILE_SELECTION)
+	{
+		return false;
+	}
+	
+	for(i = (ptrPlayer->LastWaypointIdx + 1); i < PLAYER_MAX_WAYPOINTS; i++)
+	{
+		ptrPlayer->Waypoints[i] = 0;
+	}
+	
+	ptrPlayer->WaypointIdx = ptrPlayer->LastWaypointIdx + 1;
+	
+	x_diff = (uint16_t)abs(	(ptrPlayer->SelectedTile % GameLevelColumns) -
+							(ptrPlayer->Waypoints[ptrPlayer->LastWaypointIdx] % GameLevelColumns) );
+	
+	y_diff = (uint16_t)abs(	(ptrPlayer->SelectedTile / GameLevelColumns) -
+							(ptrPlayer->Waypoints[ptrPlayer->LastWaypointIdx] / GameLevelColumns) );
+							
+	/*dprintf("SelectedTile = %d, ptrPlayer->Waypoints[%d] = %d\n",
+			ptrPlayer->SelectedTile,
+			0,
+			ptrPlayer->Waypoints[0] );
+
+	dprintf("X = abs(%d - %d)\n",
+			ptrPlayer->SelectedTile % GameLevelColumns,
+			(ptrPlayer->Waypoints[0] % GameLevelColumns) );
+			
+	dprintf("Y = abs(%d - %d)\n",
+			ptrPlayer->SelectedTile / GameLevelColumns,
+			(ptrPlayer->Waypoints[0] / GameLevelColumns) );
+			
+	dprintf("Diff = {%d, %d}\n", x_diff, y_diff);*/
+	
+	// At this point, we have to update current waypoints list.
+	// ptrPlayer->Waypoints[ptrPlayer->WaypointIdx - 1] points to the last inserted point,
+	// so now we have to determine how many points need to be created.
+	
+	temp_tile = ptrPlayer->Waypoints[ptrPlayer->LastWaypointIdx];
+	
+	if(x_diff >= y_diff)
+	{
+		while( (x_diff--) > 0)
+		{
+			if( (ptrPlayer->SelectedTile % GameLevelColumns) > 
+				(ptrPlayer->Waypoints[ptrPlayer->LastWaypointIdx] % GameLevelColumns)	)
+			{
+				temp_tile++;
+			}
+			else
+			{
+				temp_tile--;
+			}
+			
+			if(SystemContains_u16(temp_tile, ptrPlayer->Waypoints, PLAYER_MAX_WAYPOINTS) == false)
+			{
+				GamePlayerAddWaypoint_Ex(ptrPlayer, temp_tile);
+			}
+		}
+		
+		while( (y_diff--) > 0)
+		{
+			if( (ptrPlayer->SelectedTile / GameLevelColumns) > 
+				(ptrPlayer->Waypoints[ptrPlayer->LastWaypointIdx] / GameLevelColumns)	)
+			{
+				temp_tile += GameLevelColumns;
+			}
+			else
+			{
+				temp_tile -= GameLevelColumns;
+			}
+			
+			if(SystemContains_u16(temp_tile, ptrPlayer->Waypoints, PLAYER_MAX_WAYPOINTS) == false)
+			{
+				GamePlayerAddWaypoint_Ex(ptrPlayer, temp_tile);
+			}
+		}
+	}
+	else
+	{		
+		while( (y_diff--) > 0)
+		{
+			if( (ptrPlayer->SelectedTile / GameLevelColumns) > 
+				(ptrPlayer->Waypoints[ptrPlayer->LastWaypointIdx] / GameLevelColumns)	)
+			{
+				temp_tile += GameLevelColumns;
+			}
+			else
+			{
+				temp_tile -= GameLevelColumns;
+			}
+			
+			if(SystemContains_u16(temp_tile, ptrPlayer->Waypoints, PLAYER_MAX_WAYPOINTS) == false)
+			{
+				GamePlayerAddWaypoint_Ex(ptrPlayer, temp_tile);
+			}
+		}
+		
+		while( (x_diff--) > 0)
+		{
+			if( (ptrPlayer->SelectedTile % GameLevelColumns) > 
+				(ptrPlayer->Waypoints[ptrPlayer->LastWaypointIdx] % GameLevelColumns)	)
+			{
+				temp_tile++;
+			}
+			else
+			{
+				temp_tile--;
+			}
+			
+			if(SystemContains_u16(temp_tile, ptrPlayer->Waypoints, PLAYER_MAX_WAYPOINTS) == false)
+			{
+				GamePlayerAddWaypoint_Ex(ptrPlayer, temp_tile);
+			}
+		}
+	}
+	
+	// Now at this point, we have prepared our array.
+	
+	for(i = 0; i < PLAYER_MAX_WAYPOINTS; i++)
+	{
+		if(ptrPlayer->Waypoints[i] == 0)
+		{
+			// We have found empty waypoints. Exit loop
+			break;
+		}
+		
+		if(SystemContains_u8(	GameLevelBuffer[ptrPlayer->Waypoints[i]],
+								AcceptedTiles,
+								sizeof(AcceptedTiles) ) == false)
+		{
+			// Now try again with mirrored tiles, just in case!
+		
+			for(j = 0; j < (sizeof(AcceptedTiles) * sizeof(uint8_t) ); j++)
+			{
+				AcceptedTiles[j] |= TILE_MIRROR_FLAG;
+			}
+			
+			if(SystemContains_u8(	GameLevelBuffer[ptrPlayer->Waypoints[i]],
+									AcceptedTiles,
+									sizeof(AcceptedTiles) ) == false)
+			{
+				// Both cases have failed. Return from function.
+				return false;
+			}
+			
+			// Reverse mirror flag.
+			
+			for(j = 0; j < (sizeof(AcceptedTiles) * sizeof(uint8_t) ); j++)
+			{
+				AcceptedTiles[j] &= ~(TILE_MIRROR_FLAG);
+			}
+		}
+	}
+	
+	return true;
+}
+
+void GameSelectAircraft(TYPE_PLAYER * ptrPlayer)
+{
+	TYPE_ISOMETRIC_POS IsoPos = AircraftGetIsoPos(ptrPlayer->SelectedAircraft);
+	
+	CameraMoveToIsoPos(ptrPlayer, IsoPos);
+	
+	ptrPlayer->SelectedTile = GameGetTileFromIsoPosition(&IsoPos);
+	
+	GamePlayerAddWaypoint(ptrPlayer);
+}