* Aircraft 0 was incorrectly being removed because indexes 0 to GAME_MAX_AIRCRAFT were being read instead of 0 to ptrPlayer->ActiveAircraft.

* Solved issues with linked list overflow. A detection mechanism has also been added.
* New state STATE_ENTERING_RWY.
* GameGuiActiveAircraftList has been moved from GameGui to Game module.
* Active aircraft list for each player is now updated each time that a new flight either appears or disappears.
* Other minor fixes.

9 files changed, 162 insertions, 76 deletions

diff --git a/Source/Aircraft.c b/Source/Aircraft.c
index da8e03a..14b1ea2 100644
--- a/Source/Aircraft.c
+++ b/Source/Aircraft.c
@@ -194,7 +194,10 @@ bool AircraftRemove(uint8_t aircraftIdx)
 		{

 			if(ptrAircraft->FlightDataIdx == aircraftIdx)

 			{

+				DEBUG_PRINT_VAR(ptrAircraft->FlightDataIdx);

+				DEBUG_PRINT_VAR(aircraftIdx);

 				ptrAircraft->State = STATE_IDLE;

+				dprintf("Flight %d removed\n", ptrAircraft->FlightDataIdx);

 				return true;

 			}

 		}

@@ -240,18 +243,20 @@ void AircraftSpeed(TYPE_AIRCRAFT_DATA* ptrAircraft)
 

 		case STATE_TAXIING:

 			// Fall through

-		case STATE_HOLDING_RWY:

-			// Fall through

-		case STATE_READY_FOR_TAKEOFF:

+		case STATE_ENTERING_RWY:

 			ptrAircraft->Speed = AircraftSpeedsTable[AIRCRAFT_SPEED_GROUND];

 		break;

 

+		case STATE_READY_FOR_TAKEOFF:

+			// Fall through

 		case STATE_UNBOARDING:

 			// Fall through

 		case STATE_IDLE:

 			// Fall through

 		case STATE_LANDED:

 			// Fall through

+		case STATE_HOLDING_RWY:

+			// Fall through

 		default:

 			ptrAircraft->Speed = 0;

 		break;

@@ -415,8 +420,6 @@ void AircraftDirection(TYPE_AIRCRAFT_DATA* ptrAircraft)
 

 		if(GameInsideLevelFromIsoPos(&ptrAircraft->IsoPos) == true)

 		{

-			ptrAircraft->State = STATE_IDLE;

-			dprintf("Flight %d removed\n", ptrAircraft->FlightDataIdx);

 			GameRemoveFlight(ptrAircraft->FlightDataIdx);

 		}

 	}

@@ -549,3 +552,10 @@ uint16_t* AircraftGetTargets(uint8_t index)
 	

 	return ptrAircraft->Target;

 }

+

+bool AircraftMoving(uint8_t index)

+{

+	TYPE_AIRCRAFT_DATA* ptrAircraft = AircraftFromFlightDataIndex(index);

+	

+	return (bool)ptrAircraft->Speed;

+}

diff --git a/Source/Aircraft.h b/Source/Aircraft.h
index 0c0458b..d681479 100644
--- a/Source/Aircraft.h
+++ b/Source/Aircraft.h
@@ -24,6 +24,7 @@ TYPE_ISOMETRIC_POS AircraftGetIsoPos(uint8_t FlightDataIdx);
 uint16_t AircraftGetTileFromFlightDataIndex(uint8_t index);

 bool AircraftRemove(uint8_t aircraftIdx);

 uint16_t* AircraftGetTargets(uint8_t index);

+bool AircraftMoving(uint8_t index);

 AIRCRAFT_DIRECTION AircraftGetDirection(TYPE_AIRCRAFT_DATA* ptrAircraft);

 bool AircraftAddNew(	TYPE_FLIGHT_DATA * ptrFlightData,

 						uint8_t FlightDataIndex,

diff --git a/Source/Game.c b/Source/Game.c
index ed3eeb6..6c59674 100644
--- a/Source/Game.c
+++ b/Source/Game.c
@@ -145,6 +145,7 @@ static void GameStateUnboarding(TYPE_PLAYER* ptrPlayer, TYPE_FLIGHT_DATA* ptrFli
 static void GameGenerateUnboardingSequence(TYPE_PLAYER* ptrPlayer);
 static void GameCreateTakeoffWaypoints(TYPE_PLAYER* ptrPlayer, TYPE_FLIGHT_DATA* ptrFlightData, uint8_t aircraftIdx);
 static void GameGetRunwayEntryTile(uint8_t aircraftIdx, TYPE_RWY_ENTRY_DATA* ptrRwyEntry);
+static void GameActiveAircraftList(TYPE_PLAYER* ptrPlayer, TYPE_FLIGHT_DATA * ptrFlightData);
 
 /* *************************************
  * 	Global Variables
@@ -491,6 +492,10 @@ void GameCalculations(void)
 				case STATE_TAKEOFF:
 					dprintf("Takeoff");
 				break;
+
+				case STATE_UNBOARDING:
+					dprintf("Unboarding");
+				break;
 				
 				default:
 				break;
@@ -540,6 +545,7 @@ void GamePlayerHandler(TYPE_PLAYER* ptrPlayer, TYPE_FLIGHT_DATA * ptrFlightData)
 
 	ptrPlayer->FlightDataSelectedAircraft = ptrPlayer->ActiveAircraftList[ptrPlayer->SelectedAircraft];
 
+	GameActiveAircraftList(ptrPlayer, ptrFlightData);
 	GameStateUnboarding(ptrPlayer, ptrFlightData);
 	GameStateLockTarget(ptrPlayer, ptrFlightData);
 	GameStateSelectRunway(ptrPlayer, ptrFlightData);
@@ -547,7 +553,6 @@ void GamePlayerHandler(TYPE_PLAYER* ptrPlayer, TYPE_FLIGHT_DATA * ptrFlightData)
 	GameStateSelectTaxiwayParking(ptrPlayer, ptrFlightData);
 	GameStateShowAircraft(ptrPlayer, ptrFlightData);
 	CameraHandler(ptrPlayer);
-	GameGuiActiveAircraftList(ptrPlayer, ptrFlightData);
 	GameGuiActiveAircraftPage(ptrPlayer, ptrFlightData);
 	GameSelectAircraftFromList(ptrPlayer, ptrFlightData);
 }
@@ -819,9 +824,18 @@ void GameAircraftState(void)
 								&&
 				(FlightData.RemainingTime[i] == 0)	)
 			{
+				uint8_t j;
+				
 				// Player(s) lost a flight!
 				FlightData.State[i] = STATE_IDLE;
 				GameScore = (GameScore < LOST_FLIGHT_PENALTY)? 0 : (GameScore - LOST_FLIGHT_PENALTY);
+
+				for(j = 0; j < MAX_PLAYERS; j++)
+				{
+					TYPE_PLAYER* ptrPlayer = &PlayerData[j];
+					
+					GameActiveAircraftList(ptrPlayer, &FlightData);
+				}
 			}
 		}
 	}
@@ -1536,6 +1550,7 @@ void GameSelectAircraftFromList(TYPE_PLAYER* ptrPlayer, TYPE_FLIGHT_DATA * ptrFl
 						ptrPlayer->SelectRunway = false;
 						ptrPlayer->SelectTaxiwayRunway = false;
 						ptrPlayer->ShowAircraftData = true;
+						ptrPlayer->Unboarding = false;
 					break;
 				}
 			}
@@ -1706,6 +1721,8 @@ void GameAssignRunwaytoAircraft(TYPE_PLAYER* ptrPlayer, TYPE_FLIGHT_DATA * ptrFl
 		dprintf("\n");
 
 		AircraftAddTargets(AircraftFromFlightDataIndex(aircraftIndex), targets);
+
+		ptrFlightData->State[aircraftIndex] = STATE_ENTERING_RWY;
 		
 		/*uint16_t i;
 		
@@ -1799,7 +1816,7 @@ FL_STATE GameTargetsReached(uint16_t firstTarget, uint8_t index)
 			FlightData.State[index] = STATE_CLIMBING;
 		break;
 
-		case STATE_HOLDING_RWY:
+		case STATE_ENTERING_RWY:
 			FlightData.State[index] = STATE_READY_FOR_TAKEOFF;
 		break;
 		
@@ -1942,11 +1959,12 @@ bool GamePathToTile(TYPE_PLAYER* ptrPlayer, TYPE_FLIGHT_DATA* ptrFlightData)
 			{
 				for(i = 0; i < GAME_MAX_AIRCRAFT; i++)
 				{
-					if(ptrFlightData->State[i] != STATE_IDLE)
+					if( (ptrFlightData->State[i] != STATE_IDLE)
+									&&
+						(AircraftMoving(i) == false)			)
 					{
 						if(temp_tile == AircraftGetTileFromFlightDataIndex(i))
 						{
-							dprintf("i = %d, state = %d\n", i, ptrFlightData->State[i]);
 							return false;	// Check pending!
 						}
 					}
@@ -1976,11 +1994,12 @@ bool GamePathToTile(TYPE_PLAYER* ptrPlayer, TYPE_FLIGHT_DATA* ptrFlightData)
 			{
 				for(i = 0; i < GAME_MAX_AIRCRAFT; i++)
 				{
-					if(ptrFlightData->State[i] != STATE_IDLE)
+					if( (ptrFlightData->State[i] != STATE_IDLE)
+									&&
+						(AircraftMoving(i) == false)			)
 					{
 						if(temp_tile == AircraftGetTileFromFlightDataIndex(i))
 						{
-							dprintf("i = %d, state = %d\n", i, ptrFlightData->State[i]);
 							return false;	// Check pending!
 						}
 					}
@@ -2013,11 +2032,12 @@ bool GamePathToTile(TYPE_PLAYER* ptrPlayer, TYPE_FLIGHT_DATA* ptrFlightData)
 			{
 				for(i = 0; i < GAME_MAX_AIRCRAFT; i++)
 				{
-					if(ptrFlightData->State[i] != STATE_IDLE)
+					if( (ptrFlightData->State[i] != STATE_IDLE)
+									&&
+						(AircraftMoving(i) == false)			)
 					{
 						if(temp_tile == AircraftGetTileFromFlightDataIndex(i))
 						{
-							dprintf("i = %d, state = %d\n", i, ptrFlightData->State[i]);
 							return false;	// Check pending!
 						}
 					}
@@ -2048,11 +2068,12 @@ bool GamePathToTile(TYPE_PLAYER* ptrPlayer, TYPE_FLIGHT_DATA* ptrFlightData)
 			{
 				for(i = 0; i < GAME_MAX_AIRCRAFT; i++)
 				{
-					if(ptrFlightData->State[i] != STATE_IDLE)
+					if( (ptrFlightData->State[i] != STATE_IDLE)
+									&&
+						(AircraftMoving(i) == false)			)
 					{
 						if(temp_tile == AircraftGetTileFromFlightDataIndex(i))
 						{
-							dprintf("i = %d, state = %d\n", i, ptrFlightData->State[i]);
 							return false;	// Check pending!
 						}
 					}
@@ -2303,7 +2324,9 @@ void GameGetRunwayEntryTile(uint8_t aircraftIdx, TYPE_RWY_ENTRY_DATA* ptrRwyEntr
 	int16_t step = 0;
 	uint16_t i;
 
-	if( (currentTile > GameLevelColumns) && ( (currentTile + GameLevelColumns) < (sizeof(GameLevelBuffer) / sizeof(GameLevelBuffer[0]) ) ) )
+	if( (currentTile >= GameLevelColumns)
+						&&
+		( (currentTile + GameLevelColumns) < GameLevelSize) )
 	{
 		if(GameLevelBuffer[currentTile + 1] == TILE_RWY_EXIT)
 		{
@@ -2342,18 +2365,20 @@ void GameGetRunwayEntryTile(uint8_t aircraftIdx, TYPE_RWY_ENTRY_DATA* ptrRwyEntr
 
 		i = ptrRwyEntry->rwyEntryTile;
 
-		while(	(i > ptrRwyEntry->rwyStep)
+		while(	(GameLevelBuffer[i] != TILE_RWY_START_1)
 								&&
-				(i < (GameLevelSize - ptrRwyEntry->rwyStep) )
+				(GameLevelBuffer[i] != TILE_RWY_START_2)
 								&&
-				(GameLevelBuffer[i] != TILE_RWY_START_1)
+				(i > ptrRwyEntry->rwyStep)
 								&&
-				(GameLevelBuffer[i] != TILE_RWY_START_2) )
+				((i - ptrRwyEntry->rwyStep) < GameLevelSize ) )
 		{
 			i -= ptrRwyEntry->rwyStep;
 		}
 
 		ptrRwyEntry->rwyHeader = i;
+
+		DEBUG_PRINT_VAR(ptrRwyEntry->rwyHeader);
 	}
 	else
 	{
@@ -2399,31 +2424,73 @@ void GameRemoveFlight(uint8_t idx)
 	{
 		ptrPlayer = &PlayerData[i];
 
-		for(j = 0; j < GAME_MAX_AIRCRAFT; j++)
+		for(j = 0; j < ptrPlayer->ActiveAircraft; j++)
 		{
-			if(ptrPlayer->ActiveAircraftList[j] == idx)
+			if(FlightData.State[ptrPlayer->FlightDataSelectedAircraft] != STATE_IDLE)
 			{
-				ptrPlayer->Unboarding = false;
-				/*DEBUG_PRINT_VAR(ptrPlayer);
-				DEBUG_PRINT_VAR(&PlayerData[PLAYER_ONE]);
-				DEBUG_PRINT_VAR(&PlayerData[PLAYER_TWO]);*/
-
-				FlightData.Passengers[ptrPlayer->FlightDataSelectedAircraft] = 0;
-				FlightData.State[ptrPlayer->FlightDataSelectedAircraft] = STATE_IDLE;
-				FlightData.Finished[ptrPlayer->FlightDataSelectedAircraft] = true;
-				
-				if(AircraftRemove(idx) == false)
+				if(ptrPlayer->ActiveAircraftList[j] == idx)
 				{
-					dprintf("Something went wrong when removing aircraft!\n");
-				}
+					if(ptrPlayer == &PlayerData[PLAYER_ONE])
+					{
+						dprintf("Player one\n");
+					}
+					else if(ptrPlayer == &PlayerData[PLAYER_TWO])
+					{
+						dprintf("Player two\n");
+					}
+					
+					ptrPlayer->Unboarding = false;
+					memset(ptrPlayer->UnboardingSequence, 0, GAME_MAX_SEQUENCE_KEYS);
+					ptrPlayer->UnboardingSequenceIdx = 0;
+					
+					/*DEBUG_PRINT_VAR(ptrPlayer);
+					DEBUG_PRINT_VAR(&PlayerData[PLAYER_ONE]);
+					DEBUG_PRINT_VAR(&PlayerData[PLAYER_TWO]);*/
+
+					FlightData.Passengers[ptrPlayer->FlightDataSelectedAircraft] = 0;
+					FlightData.State[ptrPlayer->FlightDataSelectedAircraft] = STATE_IDLE;
+					FlightData.Finished[ptrPlayer->FlightDataSelectedAircraft] = true;
+					
+					if(AircraftRemove(idx) == false)
+					{
+						dprintf("Something went wrong when removing aircraft!\n");
+					}
 
-				ptrPlayer->LockTarget = false;
-				ptrPlayer->LockedAircraft = 0;
+					ptrPlayer->LockTarget = false;
+					ptrPlayer->LockedAircraft = 0;
 
-				GameScore += SCORE_REWARD_FINISH_FLIGHT;
+					GameScore += SCORE_REWARD_FINISH_FLIGHT;
 
-				return;
+					return;
+				}
 			}
 		}
+
+		// Usually called in PlayerHandler(), but now
+		// force active aircraft list update.
+		GameActiveAircraftList(ptrPlayer, &FlightData);
 	}
 }
+
+void GameActiveAircraftList(TYPE_PLAYER* ptrPlayer, TYPE_FLIGHT_DATA * ptrFlightData)
+{
+	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(	(ptrFlightData->State[i] != STATE_IDLE)
+							&&
+			(ptrFlightData->FlightDirection[i] & ptrPlayer->FlightDirection) )
+		{
+			ptrPlayer->ActiveAircraftList[j++] = i;
+			ptrPlayer->ActiveAircraft++;
+		}
+	}
+}
+
diff --git a/Source/GameGui.c b/Source/GameGui.c
index 677b454..b670dfa 100644
--- a/Source/GameGui.c
+++ b/Source/GameGui.c
@@ -415,31 +415,6 @@ bool GameGuiPauseDialog(TYPE_PLAYER* ptrPlayer)
 	return false;

 }

 

-void GameGuiActiveAircraftList(TYPE_PLAYER* ptrPlayer, TYPE_FLIGHT_DATA * ptrFlightData)

-{

-	uint8_t i;

-	uint8_t j = 0;

-	

-	if(ptrPlayer->ShowAircraftData == true)

-	{

-		// 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(	(ptrFlightData->State[i] != STATE_IDLE)

-								&&

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

-			{

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

-				ptrPlayer->ActiveAircraft++;

-			}

-		}

-	}

-}

-

 void GameGuiActiveAircraftPage(TYPE_PLAYER* ptrPlayer, TYPE_FLIGHT_DATA * ptrFlightData)

 {

 	while(ptrPlayer->ActiveAircraft < ptrPlayer->SelectedAircraft)

diff --git a/Source/GameGui.h b/Source/GameGui.h
index 5b2489d..bae15ef 100644
--- a/Source/GameGui.h
+++ b/Source/GameGui.h
@@ -32,12 +32,12 @@ 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);

 void GameGuiClock(uint8_t hour, uint8_t min);

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

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

 void GameGuiCalculateSlowScore(void);

 void GameGuiShowScore(void);

 void GameGuiDrawUnboardingSequence(TYPE_PLAYER* ptrPlayer);

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

 

 #endif //__GAME_GUI_HEADER__

diff --git a/Source/GameStructures.h b/Source/GameStructures.h
index 34f5697..4d88c48 100644
--- a/Source/GameStructures.h
+++ b/Source/GameStructures.h
@@ -38,6 +38,7 @@ typedef enum t_flstate
 	STATE_UNBOARDING,

 	STATE_TAXIING,

 	STATE_HOLDING_RWY,

+	STATE_ENTERING_RWY,

 	STATE_READY_FOR_TAKEOFF,

 	STATE_TAKEOFF,

 	STATE_CLIMBING,

diff --git a/Source/Gfx.c b/Source/Gfx.c
index 1b4612a..3f9c81d 100644
--- a/Source/Gfx.c
+++ b/Source/Gfx.c
@@ -8,7 +8,7 @@
  * 	Defines
  * *************************************/
 
-#define PRIMITIVE_LIST_SIZE 0x800
+#define PRIMITIVE_LIST_SIZE 0x1000
 #define DOUBLE_BUFFERING_SWAP_Y	256
 #define UPLOAD_IMAGE_FLAG 1
 #define MAX_LUMINANCE 0xFF
@@ -76,18 +76,47 @@ static bool one_second_show;
 
 void GfxSwapBuffers(void)
 {
+	// Consistency check
+#if PSXSDK_DEBUG
+
+	if(GsListPos() >= PRIMITIVE_LIST_SIZE)
+	{
+		dprintf("Linked list iterator overflow!\n");
+		while(1);
+	}
+	
+	if( (DrawEnv.h != Y_SCREEN_RESOLUTION)
+					||
+		( (DrawEnv.w != X_SCREEN_RESOLUTION)
+						&&
+		  (DrawEnv.w != X_SCREEN_RESOLUTION >> 1) )
+					||
+		( (DispEnv.y != DOUBLE_BUFFERING_SWAP_Y)
+						&&
+		  (DispEnv.y != 0) )		)
+	{
+		dprintf("What the hell is happening?\n");
+		DEBUG_PRINT_VAR(DispEnv.x);
+		DEBUG_PRINT_VAR(DispEnv.y);
+		DEBUG_PRINT_VAR(DrawEnv.x);
+		DEBUG_PRINT_VAR(DrawEnv.y);
+
+		while(1);
+	}
+#endif // PSXSDK_DEBUG
+
 	if(DrawEnv.h == Y_SCREEN_RESOLUTION)
 	{
-			if(DispEnv.y == 0)
-			{
-				DispEnv.y = DOUBLE_BUFFERING_SWAP_Y;
-				DrawEnv.y = 0;
-			}
-			else if(DispEnv.y == DOUBLE_BUFFERING_SWAP_Y)
-			{
-				DispEnv.y = 0;
-				DrawEnv.y = DOUBLE_BUFFERING_SWAP_Y;
-			}
+		if(DispEnv.y == 0)
+		{
+			DispEnv.y = DOUBLE_BUFFERING_SWAP_Y;
+			DrawEnv.y = 0;
+		}
+		else if(DispEnv.y == DOUBLE_BUFFERING_SWAP_Y)
+		{
+			DispEnv.y = 0;
+			DrawEnv.y = DOUBLE_BUFFERING_SWAP_Y;
+		}
 			
 		GsSetDispEnv_DMA(&DispEnv);
 		GsSetDrawEnv_DMA(&DrawEnv);
diff --git a/Source/Makefile b/Source/Makefile
index a02fd8c..8d35664 100644
--- a/Source/Makefile
+++ b/Source/Makefile
@@ -1,6 +1,7 @@
 CC = psx-gcc
 DEFINE= -DFIXMATH_FAST_SIN -D_PAL_MODE_ -DPSXSDK_DEBUG
-DEFINE +=  -DNO_CDDA -DNO_INTRO
+DEFINE +=  -DNO_CDDA
+DEFINE +=  -DNO_INTRO
 LIBS= -lfixmath
 CC_FLAGS = -Wall -Werror -c -Os
 LINKER = psx-gcc
diff --git a/Source/Menu.c b/Source/Menu.c
index da69137..b2dde33 100644
--- a/Source/Menu.c
+++ b/Source/Menu.c
@@ -244,6 +244,8 @@ void MainMenuInit(void)
 				
 	PadAddCheat(&StackCheckCheat);
 
+	GfxSetGlobalLuminance(NORMAL_LUMINANCE);
+
 	LoadMenuEnd();
 }