xavi
/
Airport
1
0
Fork 0
Code Issues Pull Requests Projects Releases 1 Wiki Activity

* 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.
This commit is contained in:
XaviDCR92 2017-05-24 07:15:38 +02:00
parent aefe5f8c1c
commit 8d2e08d744
13 changed files with 488 additions and 315 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

226
Source/Aircraft.c
View File

@ -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);
}

6
Source/Aircraft.h
View File

@ -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__

59
Source/Camera.c
View File

@ -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 );*/

3
Source/Camera.h
View File

@ -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__

161
Source/Game.c
View File

@ -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];
}

3
Source/Game.h
View File

@ -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__

304
Source/GameGui.c
View File

@ -123,6 +123,14 @@ enum
AIRCRAFT_DATA_GSGPOLY4_Y3_2PLAYER = AIRCRAFT_DATA_GSGPOLY4_Y2_2PLAYER,
};
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,
@ -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.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;
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;
ArrowsSpr.attribute |= GFX_1HZ_FLASH;
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;
ArrowsSpr.u = AIRCRAFT_DATA_FLIGHT_RIGHT_ARROW_U;
ArrowsSpr.v = AIRCRAFT_DATA_FLIGHT_RIGHT_ARROW_V;
SelectedAircraftGPoly4.attribute |= ENABLE_TRANS | TRANS_MODE(0);
ArrowsSpr.w = AIRCRAFT_DATA_FLIGHT_ARROWS_SIZE;
ArrowsSpr.h = AIRCRAFT_DATA_FLIGHT_ARROWS_SIZE;
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;
}
GfxSortSprite(&ArrowsSpr);
}
if(ptrPlayer->FlightDataPage != 0)
{
ArrowsSpr.x = AIRCRAFT_DATA_FLIGHT_LEFT_ARROW_X;
ArrowsSpr.y = AIRCRAFT_DATA_FLIGHT_LEFT_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_LEFT_ARROW_U;
ArrowsSpr.v = AIRCRAFT_DATA_FLIGHT_LEFT_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;
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;
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);
}
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);
}
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;
}

1
Source/GameGui.h
View File

@ -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);

12
Source/GameStructures.h
View File

@ -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);

2
Source/MemCard.h
View File

@ -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;

2
Source/Menu.c
View File

@ -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)

12
Source/System.c
View File

@ -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;

12
Source/System.h
View File

@ -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);