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

* Implemented aircraft collision. But it would not detect collision in some cases. 

* Remove unneeded whitespace character on pointer variables (unary operators should not have any whitespaces).
* SelectedAircraft index now increases or decreases automatically on aircraft added/removed.
* Started writing Plt generation routines. Still a lot of work TODO.
This commit is contained in:
XaviDCR92 2017-06-06 06:52:46 +02:00
parent c43347edb7
commit 1244505327
23 changed files with 368 additions and 126 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

94
Source/Aircraft.c
View File

@ -9,6 +9,7 @@
* *************************************/
#define AIRCRAFT_SIZE 16
#define AIRCRAFT_SIZE_FIX16 fix16_from_int(AIRCRAFT_SIZE)
/* *************************************
* Structs and enums
@ -46,7 +47,7 @@ static uint8_t AircraftIndex;
static GsSprite AircraftSpr;
static TYPE_ISOMETRIC_POS AircraftCenterIsoPos;
static TYPE_CARTESIAN_POS AircraftCenterPos;
static char * AircraftLiveryNamesTable[] = {"PHX", NULL};
static char* AircraftLiveryNamesTable[] = {"PHX", NULL};
static AIRCRAFT_LIVERY AircraftLiveryTable[] = {AIRCRAFT_LIVERY_0, AIRCRAFT_LIVERY_UNKNOWN};
static const fix16_t AircraftSpeedsTable[] = { [AIRCRAFT_SPEED_IDLE] = 0,
[AIRCRAFT_SPEED_GROUND] = 0x6666,
@ -59,10 +60,11 @@ static const fix16_t AircraftSpeedsTable[] = { [AIRCRAFT_SPEED_IDLE] = 0,
* *************************************/
static void AircraftDirection(TYPE_AIRCRAFT_DATA* ptrAircraft);
static AIRCRAFT_LIVERY AircraftLiveryFromFlightNumber(char * strFlightNumber);
static AIRCRAFT_LIVERY AircraftLiveryFromFlightNumber(char* strFlightNumber);
static void AircraftAttitude(TYPE_AIRCRAFT_DATA* ptrAircraft);
static void AircraftUpdateSpriteFromData(TYPE_AIRCRAFT_DATA* ptrAircraft);
static void AircraftSpeed(TYPE_AIRCRAFT_DATA* ptrAircraft);
static bool AircraftCheckCollision(TYPE_AIRCRAFT_DATA* ptrRefAircraft, TYPE_AIRCRAFT_DATA* ptrOtherAircraft);
void AircraftInit(void)
{
@ -93,7 +95,7 @@ void AircraftInit(void)
AircraftCenterPos = GfxIsometricToCartesian(&AircraftCenterIsoPos);
}
bool AircraftAddNew( TYPE_FLIGHT_DATA * ptrFlightData,
bool AircraftAddNew( TYPE_FLIGHT_DATA* ptrFlightData,
uint8_t FlightDataIndex,
uint16_t* targets )
{
@ -165,7 +167,7 @@ bool AircraftAddNew( TYPE_FLIGHT_DATA * ptrFlightData,
return true;
}
AIRCRAFT_LIVERY AircraftLiveryFromFlightNumber(char * strFlightNumber)
AIRCRAFT_LIVERY AircraftLiveryFromFlightNumber(char* strFlightNumber)
{
int32_t liveryIndex;
char strLivery[4];
@ -215,6 +217,7 @@ void AircraftHandler(void)
for(i = 0; i < GAME_MAX_AIRCRAFT; i++)
{
TYPE_AIRCRAFT_DATA* ptrAircraft = &AircraftData[i];
uint8_t j;
if(ptrAircraft->State == STATE_IDLE)
{
@ -225,6 +228,27 @@ void AircraftHandler(void)
AircraftAttitude(ptrAircraft);
AircraftSpeed(ptrAircraft);
for(j = 0; j < GAME_MAX_AIRCRAFT; j++)
{
TYPE_AIRCRAFT_DATA* ptrOtherAircraft = &AircraftData[j];
if(i == j)
{
continue;
}
if(AircraftData[j].State == STATE_IDLE)
{
continue;
}
if(AircraftCheckCollision(ptrAircraft, ptrOtherAircraft) == true)
{
GameAircraftCollision(ptrAircraft->FlightDataIdx);
break;
}
}
ptrAircraft->State = GameGetFlightDataStateFromIdx(ptrAircraft->FlightDataIdx);
}
}
@ -267,27 +291,52 @@ void AircraftSpeed(TYPE_AIRCRAFT_DATA* ptrAircraft)
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];
TYPE_AIRCRAFT_DATA* ptrAircraft = &AircraftData[i];
TYPE_CARTESIAN_POS cartPos;
TYPE_ISOMETRIC_FIX16_POS shadowIsoPos = { .x = ptrAircraft->IsoPos.x,
.y = ptrAircraft->IsoPos.y,
.z = 0 };
TYPE_CARTESIAN_POS shadowCartPos;
if(ptrAircraft->State == STATE_IDLE)
{
continue;
}
AircraftUpdateSpriteFromData(ptrAircraft);
if(ptrAircraft->IsoPos.z > 0)
{
// Draw aircraft shadow
shadowCartPos = GfxIsometricFix16ToCartesian(&shadowIsoPos);
// Aircraft position is referred to aircraft center
AircraftSpr.x = shadowCartPos.x - (AircraftSpr.w >> 1);
AircraftSpr.y = shadowCartPos.y - (AircraftSpr.h >> 1);
CameraApplyCoordinatesToSprite(ptrPlayer, &AircraftSpr);
AircraftSpr.r = 0;
AircraftSpr.g = 0;
AircraftSpr.b = 0;
AircraftSpr.attribute |= ENABLE_TRANS | TRANS_MODE(0);
GfxSortSprite(&AircraftSpr);
}
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);
AircraftSpr.attribute &= ~(ENABLE_TRANS | TRANS_MODE(0));
CameraApplyCoordinatesToSprite(ptrPlayer, &AircraftSpr);
@ -569,3 +618,28 @@ bool AircraftMoving(uint8_t index)
return (bool)ptrAircraft->Speed;
}
bool AircraftCheckCollision(TYPE_AIRCRAFT_DATA* ptrRefAircraft, TYPE_AIRCRAFT_DATA* ptrOtherAircraft)
{
// Here I have used an old macro that I found on nextvolume's source code for "A Small Journey", IIRC.
// Totally fool-proof, so I dint' want to complicate things!
#define check_bb_collision(x1,y1,w1,h1,x2,y2,w2,h2) (!( ((x1)>=(x2)+(w2)) || ((x2)>=(x1)+(w1)) || \
((y1)>=(y2)+(h2)) || ((y2)>=(y1)+(h1)) ))
if(check_bb_collision( ptrRefAircraft->IsoPos.x,
ptrRefAircraft->IsoPos.y,
AIRCRAFT_SIZE_FIX16,
AIRCRAFT_SIZE_FIX16,
ptrOtherAircraft->IsoPos.x,
ptrOtherAircraft->IsoPos.y,
AIRCRAFT_SIZE_FIX16,
AIRCRAFT_SIZE_FIX16 ) != 0)
{
if(ptrRefAircraft->IsoPos.z == ptrOtherAircraft->IsoPos.z)
{
return true;
}
}
return false;
}

2
Source/Aircraft.h
View File

@ -27,7 +27,7 @@ uint16_t* AircraftGetTargets(uint8_t index);
bool AircraftMoving(uint8_t index);
uint8_t AircraftGetTargetIdx(uint8_t index);
AIRCRAFT_DIRECTION AircraftGetDirection(TYPE_AIRCRAFT_DATA* ptrAircraft);
bool AircraftAddNew( TYPE_FLIGHT_DATA * ptrFlightData,
bool AircraftAddNew( TYPE_FLIGHT_DATA* ptrFlightData,
uint8_t FlightDataIndex,
uint16_t* targets );

4
Source/Font.c
View File

@ -21,7 +21,7 @@
static char _internal_text[FONT_INTERNAL_TEXT_BUFFER_MAX_SIZE];
static unsigned char _blend_effect_lum;
bool FontLoadImage(char * strPath, TYPE_FONT * ptrFont)
bool FontLoadImage(char* strPath, TYPE_FONT * ptrFont)
{
if(GfxSpriteFromFile(strPath, &ptrFont->spr) == false)
{
@ -88,7 +88,7 @@ void FontCyclic(void)
_blend_effect_lum -= 8;
}
void FontPrintText(TYPE_FONT * ptrFont, short x, short y, char * str, ...)
void FontPrintText(TYPE_FONT * ptrFont, short x, short y, char* str, ...)
{
uint16_t i;
uint16_t line_count = 0;

4
Source/Font.h
View File

@ -26,9 +26,9 @@
* Global prototypes
* *************************************/
bool FontLoadImage(char * strPath, TYPE_FONT * ptrFont);
bool FontLoadImage(char* strPath, TYPE_FONT * ptrFont);
void FontSetSize(TYPE_FONT * ptrFont, short size);
void FontPrintText(TYPE_FONT *ptrFont, short x, short y, char * str, ...);
void FontPrintText(TYPE_FONT *ptrFont, short x, short y, char* str, ...);
void FontSetInitChar(TYPE_FONT * ptrFont, char c);
void FontSetFlags(TYPE_FONT * ptrFont, FONT_FLAGS flags);
void FontCyclic(void);

81
Source/Game.c
View File

@ -120,35 +120,35 @@ static bool GamePause(void);
static bool GameFinished(void);
static void GameEmergencyMode(void);
static void GameCalculations(void);
static void GamePlayerHandler(TYPE_PLAYER* ptrPlayer, TYPE_FLIGHT_DATA * ptrFlightData);
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 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 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 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, TYPE_FLIGHT_DATA* ptrFlightData);
static TYPE_ISOMETRIC_POS GameSelectAircraft(TYPE_PLAYER* ptrPlayer);
static void GameSelectAircraftWaypoint(TYPE_PLAYER* ptrPlayer);
static void GameGetRunwayArray(void);
static void GameGetSelectedRunwayArray(uint16_t rwyHeader);
static void GameAssignRunwaytoAircraft(TYPE_PLAYER* ptrPlayer, TYPE_FLIGHT_DATA * ptrFlightData);
static void GameAssignRunwaytoAircraft(TYPE_PLAYER* ptrPlayer, TYPE_FLIGHT_DATA* ptrFlightData);
static bool GamePathToTile(TYPE_PLAYER* ptrPlayer, TYPE_FLIGHT_DATA* ptrFlightData);
static void GameDrawMouse(TYPE_PLAYER* ptrPlayer);
static void GameStateUnboarding(TYPE_PLAYER* ptrPlayer, TYPE_FLIGHT_DATA* ptrFlightData);
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);
static void GameActiveAircraftList(TYPE_PLAYER* ptrPlayer, TYPE_FLIGHT_DATA* ptrFlightData);
static void GameRemainingAircraft(void);
static void GameMinimumSpawnTimeout(void);
@ -176,11 +176,13 @@ static bool firstLevelRender; // Used to avoid reentrance issues on GameRenderLe
static TYPE_TIMER* GameSpawnMinTime;
static bool spawnMinTimeFlag;
static bool GameAircraftCreatedFlag;
static bool GameAircraftCollisionFlag;
static uint8_t GameAircraftCollisionIdx;
// Instances for player-specific data
TYPE_PLAYER PlayerData[MAX_PLAYERS];
static char * GameFileList[] = { "cdrom:\\DATA\\SPRITES\\TILESET1.TIM;1" ,
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" ,
@ -194,7 +196,7 @@ static void * GameFileDest[] = { (GsSprite*)&GameTilesetSpr ,
NULL ,
(GsSprite*)&GameMouseSpr };
static char * GameLevelList[] = { "cdrom:\\DATA\\LEVELS\\LEVEL1.LVL;1"};
static char* GameLevelList[] = { "cdrom:\\DATA\\LEVELS\\LEVEL1.LVL;1"};
static uint8_t GameLevelBuffer[GAME_MAX_MAP_SIZE];
static uint8_t GameLevelColumns;
@ -222,12 +224,19 @@ void Game(bool two_players)
{
if(GameFinished() == true)
{
// Exit game on level finished.
break;
}
if(GamePause() == true)
{
// Exit game
// Exit game if player desires to exit.
break;
}
if(GameAircraftCollisionFlag == true)
{
GameGuiAircraftCollision(&PlayerData[PLAYER_ONE]);
break;
}
@ -360,6 +369,8 @@ void GameInit(void)
firstActiveAircraft = 0;
lastActiveAircraft = 0;
GameAircraftCreatedFlag = false;
GameAircraftCollisionFlag = false;
GameAircraftCollisionIdx = 0;
if(GameTwoPlayersActive() == true)
{
@ -556,7 +567,7 @@ uint8_t GameGetLastActiveAircraft(void)
return lastActiveAircraft;
}
void GamePlayerHandler(TYPE_PLAYER* ptrPlayer, TYPE_FLIGHT_DATA * ptrFlightData)
void GamePlayerHandler(TYPE_PLAYER* ptrPlayer, TYPE_FLIGHT_DATA* ptrFlightData)
{
ptrPlayer->SelectedTile = 0; // Reset selected tile if no states
// which use this are currently active.
@ -564,6 +575,12 @@ void GamePlayerHandler(TYPE_PLAYER* ptrPlayer, TYPE_FLIGHT_DATA * ptrFlightData)
ptrPlayer->FlightDataSelectedAircraft = ptrPlayer->ActiveAircraftList[ptrPlayer->SelectedAircraft];
if(GameAircraftCollisionFlag == true)
{
TYPE_ISOMETRIC_POS IsoPos = AircraftGetIsoPos(GameAircraftCollisionIdx);
CameraMoveToIsoPos(ptrPlayer, IsoPos);
}
GameActiveAircraftList(ptrPlayer, ptrFlightData);
GameStateUnboarding(ptrPlayer, ptrFlightData);
GameStateLockTarget(ptrPlayer, ptrFlightData);
@ -633,7 +650,7 @@ void GameGraphics(void)
int i;
bool split_screen = false;
while(GfxIsGPUBusy() == true);
while( (SystemRefreshNeeded() == false) || (GfxIsGPUBusy() == true) );
if(TwoPlayersActive == true)
{
@ -1103,7 +1120,7 @@ void GameRenderLevel(TYPE_PLAYER* ptrPlayer)
}
}
// TODO: Isometric -> Cartesian conversion
// Isometric -> Cartesian conversion
tileIsoPos.x = columns << (TILE_SIZE_BIT_SHIFT);
tileIsoPos.y = rows << (TILE_SIZE_BIT_SHIFT);
tileIsoPos.z = 0;
@ -1117,12 +1134,6 @@ void GameRenderLevel(TYPE_PLAYER* ptrPlayer)
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++;
@ -1163,14 +1174,6 @@ void GameRenderLevel(TYPE_PLAYER* ptrPlayer)
ptrTileset->attribute &= ~(H_FLIP);
}
}
/*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)
@ -1194,7 +1197,7 @@ void GameActiveAircraft(void)
}
}
void GameStateShowAircraft(TYPE_PLAYER* ptrPlayer, TYPE_FLIGHT_DATA * ptrFlightData)
void GameStateShowAircraft(TYPE_PLAYER* ptrPlayer, TYPE_FLIGHT_DATA* ptrFlightData)
{
if(ptrPlayer->ShowAircraftData == true)
{
@ -1256,7 +1259,7 @@ void GameStateLockTarget(TYPE_PLAYER* ptrPlayer, TYPE_FLIGHT_DATA* ptrFlightData
}
}
void GameStateSelectTaxiwayRunway(TYPE_PLAYER* ptrPlayer, TYPE_FLIGHT_DATA * ptrFlightData)
void GameStateSelectTaxiwayRunway(TYPE_PLAYER* ptrPlayer, TYPE_FLIGHT_DATA* ptrFlightData)
{
TYPE_ISOMETRIC_POS IsoPos = CameraGetIsoPos(ptrPlayer);
uint8_t i;
@ -1343,7 +1346,7 @@ void GameStateSelectTaxiwayRunway(TYPE_PLAYER* ptrPlayer, TYPE_FLIGHT_DATA * ptr
}
}
void GameStateSelectTaxiwayParking(TYPE_PLAYER* ptrPlayer, TYPE_FLIGHT_DATA * ptrFlightData)
void GameStateSelectTaxiwayParking(TYPE_PLAYER* ptrPlayer, TYPE_FLIGHT_DATA* ptrFlightData)
{
TYPE_ISOMETRIC_POS IsoPos = CameraGetIsoPos(ptrPlayer);
uint8_t i;
@ -1428,7 +1431,7 @@ void GameStateSelectTaxiwayParking(TYPE_PLAYER* ptrPlayer, TYPE_FLIGHT_DATA * pt
}
}
void GameStateSelectRunway(TYPE_PLAYER* ptrPlayer, TYPE_FLIGHT_DATA * ptrFlightData)
void GameStateSelectRunway(TYPE_PLAYER* ptrPlayer, TYPE_FLIGHT_DATA* ptrFlightData)
{
uint8_t i;
bool success;
@ -1533,7 +1536,7 @@ void GameGetRunwayArray(void)
dprintf("\n");
}
void GameSelectAircraftFromList(TYPE_PLAYER* ptrPlayer, TYPE_FLIGHT_DATA * ptrFlightData)
void GameSelectAircraftFromList(TYPE_PLAYER* ptrPlayer, TYPE_FLIGHT_DATA* ptrFlightData)
{
uint8_t AircraftIdx = ptrPlayer->FlightDataSelectedAircraft;
FL_STATE aircraftState = ptrFlightData->State[AircraftIdx];
@ -1690,7 +1693,7 @@ void GameGetSelectedRunwayArray(uint16_t rwyHeader)
GameGetSelectedRunwayArray(0);
}
void GameAssignRunwaytoAircraft(TYPE_PLAYER* ptrPlayer, TYPE_FLIGHT_DATA * ptrFlightData)
void GameAssignRunwaytoAircraft(TYPE_PLAYER* ptrPlayer, TYPE_FLIGHT_DATA* ptrFlightData)
{
uint16_t assignedRwy = GameRwy[ptrPlayer->SelectedRunway];
uint8_t aircraftIndex = ptrPlayer->FlightDataSelectedAircraft;
@ -2556,7 +2559,7 @@ void GameRemoveFlight(uint8_t idx, bool successful)
}
}
void GameActiveAircraftList(TYPE_PLAYER* ptrPlayer, TYPE_FLIGHT_DATA * ptrFlightData)
void GameActiveAircraftList(TYPE_PLAYER* ptrPlayer, TYPE_FLIGHT_DATA* ptrFlightData)
{
uint8_t i;
uint8_t j = 0;
@ -2639,3 +2642,9 @@ void GameMinimumSpawnTimeout(void)
{
spawnMinTimeFlag = true;
}
void GameAircraftCollision(uint8_t AircraftIdx)
{
GameAircraftCollisionFlag = true;
GameAircraftCollisionIdx = AircraftIdx;
}

3
Source/Game.h
View File

@ -36,7 +36,7 @@ extern TYPE_PLAYER PlayerData[];
* *************************************/
void Game(bool two_players);
char * GetGameLevelTitle(void);
char* GetGameLevelTitle(void);
void GameSetTime(uint8_t hour, uint8_t minutes);
bool GameTwoPlayersActive(void);
uint8_t GameGetFirstActiveAircraft(void);
@ -53,4 +53,5 @@ uint32_t GameGetScore(void);
bool GameInsideLevelFromIsoPos(TYPE_ISOMETRIC_FIX16_POS* ptrIsoPos);
void GameRemoveFlight(uint8_t idx, bool successful);
void GameCalculateRemainingAircraft(void);
void GameAircraftCollision(uint8_t AircraftIdx);
#endif //__GAME_HEADER__

95
Source/GameGui.c
View File

@ -148,12 +148,18 @@ enum
{
AIRCRAFT_DATA_FLIGHT_LEFT_ARROW_X = 96,
AIRCRAFT_DATA_FLIGHT_LEFT_ARROW_Y = 112,
AIRCRAFT_DATA_FLIGHT_LEFT_ARROW_X_2PLAYER = 48,
AIRCRAFT_DATA_FLIGHT_LEFT_ARROW_Y_2PLAYER = 112,
AIRCRAFT_DATA_FLIGHT_LEFT_ARROW_U = 44,
AIRCRAFT_DATA_FLIGHT_LEFT_ARROW_V = 48,
AIRCRAFT_DATA_FLIGHT_RIGHT_ARROW_X = 280,
AIRCRAFT_DATA_FLIGHT_RIGHT_ARROW_Y = AIRCRAFT_DATA_FLIGHT_LEFT_ARROW_Y,
AIRCRAFT_DATA_FLIGHT_RIGHT_ARROW_X_2PLAYER = 128,
AIRCRAFT_DATA_FLIGHT_RIGHT_ARROW_Y_2PLAYER = AIRCRAFT_DATA_FLIGHT_LEFT_ARROW_Y_2PLAYER,
AIRCRAFT_DATA_FLIGHT_RIGHT_ARROW_U = AIRCRAFT_DATA_FLIGHT_LEFT_ARROW_U + 8,
AIRCRAFT_DATA_FLIGHT_RIGHT_ARROW_V = 48,
@ -172,7 +178,7 @@ enum
* Local prototypes *
* *************************************/
static void GameGuiShowAircraftData(TYPE_PLAYER* ptrPlayer, TYPE_FLIGHT_DATA * ptrFlightData);
static void GameGuiShowAircraftData(TYPE_PLAYER* ptrPlayer, TYPE_FLIGHT_DATA* ptrFlightData);
static void GameGuiClearPassengersLeft(void);
/* **************************************
@ -188,7 +194,7 @@ static GsSprite SecondDisplay;
static TYPE_TIMER* ShowAircraftPassengersTimer;
static bool GameGuiClearPassengersLeft_Flag;
static char * GameFileList[] = {"cdrom:\\DATA\\SPRITES\\BUBBLE.TIM;1" ,
static char* GameFileList[] = {"cdrom:\\DATA\\SPRITES\\BUBBLE.TIM;1" ,
"cdrom:\\DATA\\FONTS\\FONT_1.FNT;1" ,
"cdrom:\\DATA\\SPRITES\\ARROWS.TIM;1" };
@ -256,6 +262,9 @@ void GameGuiInit(void)
PauseRect.attribute |= ENABLE_TRANS | TRANS_MODE(0);
ShowAircraftPassengersTimer = SystemCreateTimer(20, true, GameGuiClearPassengersLeft);
ArrowsSpr.w = AIRCRAFT_DATA_FLIGHT_ARROWS_SIZE;
ArrowsSpr.h = AIRCRAFT_DATA_FLIGHT_ARROWS_SIZE;
slowScore = 0;
}
@ -288,11 +297,14 @@ bool GameGuiPauseDialog(TYPE_PLAYER* ptrPlayer)
return false;
}
void GameGuiActiveAircraftPage(TYPE_PLAYER* ptrPlayer, TYPE_FLIGHT_DATA * ptrFlightData)
void GameGuiActiveAircraftPage(TYPE_PLAYER* ptrPlayer, TYPE_FLIGHT_DATA* ptrFlightData)
{
while(ptrPlayer->ActiveAircraft < ptrPlayer->SelectedAircraft)
if(ptrPlayer->ActiveAircraft != 0)
{
ptrPlayer->SelectedAircraft--;
while(ptrPlayer->ActiveAircraft <= ptrPlayer->SelectedAircraft)
{
ptrPlayer->SelectedAircraft--;
}
}
while(ptrPlayer->ActiveAircraft < (uint8_t)(GAME_GUI_AIRCRAFT_DATA_MAX_PAGE * ptrPlayer->FlightDataPage) )
@ -342,7 +354,7 @@ void GameGuiActiveAircraftPage(TYPE_PLAYER* ptrPlayer, TYPE_FLIGHT_DATA * ptrFli
}
}
void GameGuiAircraftList(TYPE_PLAYER* ptrPlayer, TYPE_FLIGHT_DATA * ptrFlightData)
void GameGuiAircraftList(TYPE_PLAYER* ptrPlayer, TYPE_FLIGHT_DATA* ptrFlightData)
{
short y_offset;
uint8_t page_aircraft;
@ -487,32 +499,42 @@ void GameGuiAircraftList(TYPE_PLAYER* ptrPlayer, TYPE_FLIGHT_DATA * ptrFlightDat
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;
if(GameTwoPlayersActive() == true)
{
ArrowsSpr.x = AIRCRAFT_DATA_FLIGHT_RIGHT_ARROW_X_2PLAYER;
ArrowsSpr.y = AIRCRAFT_DATA_FLIGHT_RIGHT_ARROW_Y_2PLAYER;
}
else
{
ArrowsSpr.x = AIRCRAFT_DATA_FLIGHT_RIGHT_ARROW_X;
ArrowsSpr.y = AIRCRAFT_DATA_FLIGHT_RIGHT_ARROW_Y;
}
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;
ArrowsSpr.attribute |= GFX_1HZ_FLASH;
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;
if(GameTwoPlayersActive() == true)
{
ArrowsSpr.x = AIRCRAFT_DATA_FLIGHT_LEFT_ARROW_X_2PLAYER;
ArrowsSpr.y = AIRCRAFT_DATA_FLIGHT_LEFT_ARROW_Y_2PLAYER;
}
else
{
ArrowsSpr.x = AIRCRAFT_DATA_FLIGHT_LEFT_ARROW_X;
ArrowsSpr.y = AIRCRAFT_DATA_FLIGHT_LEFT_ARROW_Y;
}
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;
ArrowsSpr.attribute |= GFX_1HZ_FLASH;
GfxSortSprite(&ArrowsSpr);
}
@ -555,7 +577,7 @@ void GameGuiAircraftList(TYPE_PLAYER* ptrPlayer, TYPE_FLIGHT_DATA * ptrFlightDat
}
void GameGuiBubble(TYPE_FLIGHT_DATA * ptrFlightData)
void GameGuiBubble(TYPE_FLIGHT_DATA* ptrFlightData)
{
uint8_t i;
static uint16_t BubbleVibrationTimer;
@ -658,7 +680,7 @@ void GameGuiShowPassengersLeft(TYPE_PLAYER* ptrPlayer)
}
}
void GameGuiShowAircraftData(TYPE_PLAYER* ptrPlayer, TYPE_FLIGHT_DATA * ptrFlightData)
void GameGuiShowAircraftData(TYPE_PLAYER* ptrPlayer, TYPE_FLIGHT_DATA* ptrFlightData)
{
uint8_t init_flight = ptrPlayer->FlightDataPage * GAME_GUI_AIRCRAFT_DATA_MAX_PAGE;
uint8_t i;
@ -897,10 +919,6 @@ bool GameGuiFinishedDialog(TYPE_PLAYER* ptrPlayer)
GfxSaveDisplayData(&SecondDisplay);
GfxSetGlobalLuminance(NORMAL_LUMINANCE);
//DrawFBRect(0, 0, X_SCREEN_RESOLUTION, VRAM_H, 0, 0, 0);
while(GfxIsGPUBusy() == true);
do
{
@ -926,3 +944,26 @@ bool GameGuiFinishedDialog(TYPE_PLAYER* ptrPlayer)
return false;
}
void GameGuiAircraftCollision(TYPE_PLAYER* ptrPlayer)
{
GfxSaveDisplayData(&SecondDisplay);
GfxSetGlobalLuminance(NORMAL_LUMINANCE);
do
{
GfxSortSprite(&SecondDisplay);
GsSortGPoly4(&PauseRect);
FontPrintText( &SmallFont,
AIRCRAFT_DATA_GSGPOLY4_X0 + 8,
AIRCRAFT_DATA_GSGPOLY4_Y0 +
( (AIRCRAFT_DATA_GSGPOLY4_Y2 - AIRCRAFT_DATA_GSGPOLY4_Y0) >> 1),
"Collision between aircraft!" );
GfxDrawScene_Slow();
}while(ptrPlayer->PadKeySinglePress_Callback(PAD_CROSS) == false);
}

9
Source/GameGui.h
View File

@ -30,14 +30,15 @@
void GameGuiInit(void);
bool GameGuiPauseDialog(TYPE_PLAYER* ptrPlayer);
bool GameGuiShowAircraftDataSpecialConditions(TYPE_PLAYER* ptrPlayer);
void GameGuiBubble(TYPE_FLIGHT_DATA * ptrFlightData);
void GameGuiBubble(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 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);
void GameGuiAircraftList(TYPE_PLAYER* ptrPlayer, TYPE_FLIGHT_DATA* ptrFlightData);
bool GameGuiFinishedDialog(TYPE_PLAYER* ptrPlayer);
void GameGuiAircraftCollision(TYPE_PLAYER* ptrPlayer);
#endif //__GAME_GUI_HEADER__

19
Source/GameStructures.h
View File

@ -7,6 +7,7 @@
#define GAME_MAX_AIRCRAFT 32
#define GAME_MAX_CHARACTERS 8
#define GAME_MAX_PARKING 32
#define CHEAT_ARRAY_SIZE 16
#define AIRCRAFT_MAX_TARGETS 32
#define PLAYER_MAX_WAYPOINTS AIRCRAFT_MAX_TARGETS
@ -47,6 +48,13 @@ typedef enum t_flstate
STATE_LANDED
}FL_STATE;
typedef enum t_LevelDifficulty
{
LEVEL_DIFFICULTY_EASY = 0,
LEVEL_DIFFICULTY_MEDIUM,
LEVEL_DIFFICULTY_HARD
}LEVEL_DIFFICULTY;
typedef struct t_isopos
{
short x;
@ -231,4 +239,15 @@ typedef struct t_Cheat
void (*Callback)(void);
}TYPE_CHEAT;
// TYPE_PLT_CONFIG is used for PLT file generation.
typedef struct t_PltConfig
{
uint8_t MaxTime; // Minutes
uint8_t nRunway;
uint8_t ParkingArray[GAME_MAX_PARKING];
LEVEL_DIFFICULTY Level;
bool TwoPlayers;
uint8_t maxLostFlights;
}TYPE_PLT_CONFIG;
#endif // __GAME_STRUCTURES__HEADER__

6
Source/Gfx.c
View File

@ -315,7 +315,7 @@ bool GfxIsGPUBusy(void)
return (GsIsDrawing() || gfx_busy || (GfxReadyForDMATransfer() == false) );
}
bool GfxSpriteFromFile(char * fname, GsSprite * spr)
bool GfxSpriteFromFile(char* fname, GsSprite * spr)
{
GsImage gsi;
@ -336,7 +336,7 @@ bool GfxSpriteFromFile(char * fname, GsSprite * spr)
return true;
}
bool GfxCLUTFromFile(char * fname)
bool GfxCLUTFromFile(char* fname)
{
GsImage gsi;
@ -465,6 +465,8 @@ void GfxSaveDisplayData(GsSprite *spr)
spr->r = NORMAL_LUMINANCE;
spr->g = NORMAL_LUMINANCE;
spr->b = NORMAL_LUMINANCE;
while(GfxIsGPUBusy() == true);
}
bool Gfx1HzFlash(void)

4
Source/Gfx.h
View File

@ -52,10 +52,10 @@ void GfxDrawScene_Fast(void);
bool GfxReadyForDMATransfer(void);
// Fills a GsSprite structure with information from a TIM file.
bool GfxSpriteFromFile(char * fname, GsSprite * spr);
bool GfxSpriteFromFile(char* fname, GsSprite * spr);
// Reportedly, loads CLUT data from a TIM image (image data is discarded)
bool GfxCLUTFromFile(char * fname);
bool GfxCLUTFromFile(char* fname);
// Returns true if current object is within screen limits, false otherwise.
bool GfxIsInsideScreenArea(short x, short y, short w, short h);

12
Source/LoadMenu.c
View File

@ -72,7 +72,7 @@ static void LoadMenuInit(void);
static void ISR_LoadMenuVBlank(void);
static bool LoadMenuISRHasEnded(void);
static bool LoadMenuISRHasStarted(void);
static void LoadMenuLoadFileList( char * fileList[], void * dest[],
static void LoadMenuLoadFileList( char* fileList[], void * dest[],
uint8_t szFileList, uint8_t szDestList);
/* *************************************
@ -85,14 +85,14 @@ static GsSprite LoadMenuTitleSpr;
static GsLine LoadMenuBarLines[LOADING_BAR_N_LINES];
static GsRectangle LoadMenuBarRect;
static char * LoadMenuFiles[] = { "cdrom:\\DATA\\SPRITES\\PLANE.TIM;1",
static char* LoadMenuFiles[] = { "cdrom:\\DATA\\SPRITES\\PLANE.TIM;1",
"cdrom:\\DATA\\SPRITES\\LOADING.TIM;1",
"cdrom:\\DATA\\FONTS\\FONT_2.FNT;1" };
static void * LoadMenuDest[] = {(GsSprite*)&LoadMenuPlaneSpr,
(GsSprite*)&LoadMenuTitleSpr,
(TYPE_FONT*)&SmallFont };
static char * strCurrentFile;
static char* strCurrentFile;
// Flags to communicate with ISR state
// * startup_flag: background fades in from black to blue.
@ -414,7 +414,7 @@ bool LoadMenuISRHasStarted(void)
return isr_started;
}
void LoadMenu( char * fileList[],
void LoadMenu( char* fileList[],
void * dest[],
uint8_t szFileList , uint8_t szDestList)
{
@ -430,11 +430,11 @@ void LoadMenu( char * fileList[],
}
void LoadMenuLoadFileList( char * fileList[], void * dest[],
void LoadMenuLoadFileList( char* fileList[], void * dest[],
uint8_t szFileList, uint8_t szDestList)
{
char aux_file_name[100];
char * extension;
char* extension;
short x_increment;
uint8_t fileLoadedCount;

2
Source/LoadMenu.h
View File

@ -19,7 +19,7 @@
* Global prototypes
* *************************************/
void LoadMenu( char * fileList[],
void LoadMenu( char* fileList[],
void * dest[],
uint8_t szFileList , uint8_t szDestList);

4
Source/MapEditor/MapEditor.pro.user
View File

@ -1,6 +1,6 @@
<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE QtCreatorProject>
<!-- Written by QtCreator 4.0.3, 2016-11-12T03:25:30. -->
<!-- Written by QtCreator 4.0.3, 2017-06-06T05:55:51. -->
<qtcreator>
<data>
<variable>EnvironmentId</variable>
@ -292,7 +292,7 @@
<value type="QString" key="Qt4ProjectManager.Qt4RunConfiguration.ProFile">MapEditor.pro</value>
<value type="bool" key="Qt4ProjectManager.Qt4RunConfiguration.UseDyldImageSuffix">false</value>
<value type="QString" key="Qt4ProjectManager.Qt4RunConfiguration.UserWorkingDirectory"></value>
<value type="QString" key="Qt4ProjectManager.Qt4RunConfiguration.UserWorkingDirectory.default">C:/cygwin/home/Xavier/Airport/Source/MapEditor</value>
<value type="QString" key="Qt4ProjectManager.Qt4RunConfiguration.UserWorkingDirectory.default"></value>
<value type="uint" key="RunConfiguration.QmlDebugServerPort">3768</value>
<value type="bool" key="RunConfiguration.UseCppDebugger">false</value>
<value type="bool" key="RunConfiguration.UseCppDebuggerAuto">true</value>

2
Source/Menu.c
View File

@ -113,7 +113,7 @@ static SsVag AcceptSnd;
static TYPE_CHEAT TestCheat;
static TYPE_CHEAT StackCheckCheat;
static char * MainMenuFiles[] = { "cdrom:\\DATA\\SPRITES\\MAINMENU.TIM;1" ,
static char* MainMenuFiles[] = { "cdrom:\\DATA\\SPRITES\\MAINMENU.TIM;1" ,
"cdrom:\\DATA\\SOUNDS\\BELL.VAG;1" ,
"cdrom:\\DATA\\SOUNDS\\ACCEPT.VAG;1" ,
"cdrom:\\DATA\\SPRITES\\PSXDISK.TIM;1" ,

4
Source/PSXSDKIntro.c
View File

@ -124,8 +124,8 @@ static bool PSXSDKIntroStringEvent;
static bool PSXSDKIntroClose;
// Text
static char * strPSXSDKIntro = {"MADE WITH PSXSDK"};
static char * strPSXSDKIntroAuthor = {"BY NEXTVOLUME"};
static char* strPSXSDKIntro = {"MADE WITH PSXSDK"};
static char* strPSXSDKIntroAuthor = {"BY NEXTVOLUME"};
/* *************************************
* Global variables

89
Source/PltParser.c
View File

@ -38,18 +38,18 @@ enum
/* *************************************
* Local Prototypes
* *************************************/
static void PltParserResetBuffers(TYPE_FLIGHT_DATA * ptrFlightData);
static void PltParserResetBuffers(TYPE_FLIGHT_DATA* ptrFlightData);
bool PltParserLoadFile(char * strPath, TYPE_FLIGHT_DATA * ptrFlightData)
bool PltParserLoadFile(char* strPath, TYPE_FLIGHT_DATA* ptrFlightData)
{
uint8_t i;
uint8_t j;
uint8_t aircraftIndex;
bool first_line_read = false;
char * buffer;
char* buffer;
char lineBuffer[LINE_MAX_CHARACTERS];
char * lineBufferPtr;
char * pltBufferSavePtr;
char* lineBufferPtr;
char* pltBufferSavePtr;
char strHour[PLT_HOUR_MINUTE_CHARACTERS];
char strMinutes[PLT_HOUR_MINUTE_CHARACTERS];
uint8_t* strPltBuffer;
@ -239,7 +239,7 @@ bool PltParserLoadFile(char * strPath, TYPE_FLIGHT_DATA * ptrFlightData)
return true;
}
void PltParserResetBuffers(TYPE_FLIGHT_DATA * ptrFlightData)
void PltParserResetBuffers(TYPE_FLIGHT_DATA* ptrFlightData)
{
uint8_t i;
@ -257,3 +257,80 @@ void PltParserResetBuffers(TYPE_FLIGHT_DATA * ptrFlightData)
memset(ptrFlightData->Parking,0,GAME_MAX_AIRCRAFT);
memset(ptrFlightData->Finished,0,GAME_MAX_AIRCRAFT);
}
uint8_t* PltParserGenerateFile(TYPE_PLT_CONFIG* ptrPltConfig)
{
enum
{
MIN_AIRCRAFT_TIMELAPSE_MIN_SECONDS_EASY = 30,
MIN_AIRCRAFT_TIMELAPSE_MAX_SECONDS_EASY = 45,
MIN_AIRCRAFT_TIMELAPSE_MIN_SECONDS_MEDIUM = 20,
MIN_AIRCRAFT_TIMELAPSE_MAX_SECONDS_MEDIUM = 30,
MIN_AIRCRAFT_TIMELAPSE_MIN_SECONDS_HARD = 10,
MIN_AIRCRAFT_TIMELAPSE_MAX_SECONDS_HARD = 20,
};
enum
{
MIN_AIRCRAFT_EASY = 5,
MAX_AIRCRAFT_EASY = 10,
MIN_AIRCRAFT_MEDIUM = 10,
MAX_AIRCRAFT_MEDIUM = GAME_MAX_AIRCRAFT >> 1,
MIN_AIRCRAFT_HARD = 20,
MAX_AIRCRAFT_HARD = GAME_MAX_AIRCRAFT,
};
typedef enum t_Hour
{
MIN_HOUR = 0,
MAX_HOUR = 23
}TYPE_HOUR;
typedef enum t_Minute
{
MIN_MINUTE = 0,
MAX_MINUTE = 59
}TYPE_MINUTE;
uint8_t* PltBuffer = SystemGetBufferAddress();
uint8_t minAircraftTime;
uint8_t maxAircraftTime;
uint8_t nAircraft;
uint8_t i;
TYPE_HOUR InitialHour;
TYPE_MINUTE InitialMinutes;
char auxBuffer[32] = {0};
switch(ptrPltConfig->Level)
{
case LEVEL_DIFFICULTY_EASY:
minAircraftTime = MIN_AIRCRAFT_TIMELAPSE_MIN_SECONDS_EASY;
maxAircraftTime = MIN_AIRCRAFT_TIMELAPSE_MAX_SECONDS_EASY;
nAircraft = SystemRand(MIN_AIRCRAFT_EASY, MAX_AIRCRAFT_EASY);
break;
case LEVEL_DIFFICULTY_MEDIUM:
minAircraftTime = MIN_AIRCRAFT_TIMELAPSE_MIN_SECONDS_MEDIUM;
maxAircraftTime = MIN_AIRCRAFT_TIMELAPSE_MAX_SECONDS_MEDIUM;
nAircraft = SystemRand(MIN_AIRCRAFT_MEDIUM, MAX_AIRCRAFT_MEDIUM);
break;
case LEVEL_DIFFICULTY_HARD:
minAircraftTime = MIN_AIRCRAFT_TIMELAPSE_MIN_SECONDS_HARD;
maxAircraftTime = MIN_AIRCRAFT_TIMELAPSE_MAX_SECONDS_HARD;
nAircraft = SystemRand(MIN_AIRCRAFT_HARD, MAX_AIRCRAFT_HARD);
break;
}
SystemClearBuffer();
// At this point, PltBuffer is filled with zeros. Start generating PLT file.
InitialHour = SystemRand(MIN_HOUR, MAX_HOUR);
InitialMinutes = SystemRand(MIN_MINUTE, MAX_MINUTE);
snprintf(auxBuffer, 32, "%d:%d\n", InitialHour, InitialMinutes);
return PltBuffer;
}

3
Source/PltParser.h
View File

@ -21,7 +21,8 @@
* Global prototypes
* *************************************/
bool PltParserLoadFile(char * strPath, TYPE_FLIGHT_DATA * ptrFlightData);
bool PltParserLoadFile(char* strPath, TYPE_FLIGHT_DATA* ptrFlightData);
uint8_t* PltParserGenerateFile(TYPE_PLT_CONFIG* ptrPltConfig);
/* *************************************
* Global variables

2
Source/Sfx.c
View File

@ -28,7 +28,7 @@ void SfxPlaySound(SsVag * sound)
SsPlayVag(sound, sound->cur_voice, MAX_VOLUME, MAX_VOLUME);
}
bool SfxUploadSound(char * file_path, SsVag * vag)
bool SfxUploadSound(char* file_path, SsVag * vag)
{
if(SystemLoadFile(file_path) == false)
{

2
Source/Sfx.h
View File

@ -30,7 +30,7 @@ typedef enum t_musicTracks
* *************************************/
void SfxPlaySound(SsVag * sound);
bool SfxUploadSound(char * file_path, SsVag * vag);
bool SfxUploadSound(char* file_path, SsVag * vag);
void SfxPlayTrack(MUSIC_TRACKS track);
void SfxStopMusic(void);

25
Source/System.c
View File

@ -346,7 +346,7 @@ void SystemCheckTimer(bool* timer, uint64_t* last_timer, uint8_t step)
/* ****************************************************************************************
*
* @name bool SystemLoadFileToBuffer(char * fname, uint8_t* buffer, uint32_t szBuffer)
* @name bool SystemLoadFileToBuffer(char* fname, uint8_t* buffer, uint32_t szBuffer)
*
* @author: Xavier Del Campo
*
@ -357,7 +357,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;
@ -414,7 +414,7 @@ bool SystemLoadFileToBuffer(char * fname, uint8_t* buffer, uint32_t szBuffer)
/* ****************************************************************************************
*
* @name bool SystemLoadFile(char *fname)
* @name bool SystemLoadFile(char*fname)
*
* @author: Xavier Del Campo
*
@ -424,7 +424,7 @@ bool SystemLoadFileToBuffer(char * fname, uint8_t* buffer, uint32_t szBuffer)
*
* ****************************************************************************************/
bool SystemLoadFile(char *fname)
bool SystemLoadFile(char*fname)
{
return SystemLoadFileToBuffer(fname,file_buffer,sizeof(file_buffer));
}
@ -444,6 +444,21 @@ uint8_t* SystemGetBufferAddress(void)
return file_buffer;
}
/* ******************************************************************
*
* @name void SystemClearBuffer(void)
*
* @author: Xavier Del Campo
*
* @return: Fills internal buffer with zeros
*
* *****************************************************************/
void SystemClearBuffer(void)
{
memset(file_buffer, 0, sizeof(file_buffer));
}
/* ******************************************************************
*
* @name void SystemWaitCycles(uint32_t cycles)
@ -788,7 +803,7 @@ void SystemSetStackPattern(void)
*ptrStack = END_STACK_PATTERN;
}
int32_t SystemIndexOfStringArray(char * str, char ** array)
int32_t SystemIndexOfStringArray(char* str, char** array)
{
int32_t i;

8
Source/System.h
View File

@ -34,10 +34,10 @@ void SystemSetRandSeed(void);
bool SystemRefreshNeeded(void);
// Loads a file into system's internal buffer
bool SystemLoadFile(char *fname);
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);
@ -116,7 +116,7 @@ void SystemCheckStack(void);
// Looks for string "str" inside a string array pointed to by "array".
// Returns index inside string array on success, -1 if not found.
int32_t SystemIndexOfStringArray(char * str, char ** array);
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);
@ -126,6 +126,8 @@ int32_t SystemIndexOf_U8(uint8_t value, uint8_t* array, uint32_t from, uint32_t
void SystemCyclicHandler(void);
void SystemClearBuffer(void);
/* **************************************
* Global Variables *
* **************************************/

20
cdimg/DATA/LEVELS/LEVEL1.PLT
View File

@ -18,13 +18,13 @@ ARRIVAL;PHX2021;140;02:00;0;180
ARRIVAL;PHX2022;140;02:30;0;180
ARRIVAL;PHX2023;140;02:15;0;180
DEPARTURE;PHX1000;100;00:05;19;180
DEPARTURE;PHX1280;100;00:30;19;180
DEPARTURE;PHX1332;100;00:45;21;180
DEPARTURE;PHX1333;100;01:00;19;180
DEPARTURE;PHX1334;100;01:15;21;180
DEPARTURE;PHX1336;100;01:20;21;180
DEPARTURE;PHX1335;100;01:30;19;180
DEPARTURE;PHX1335;100;01:40;19;180
DEPARTURE;PHX1335;100;02:00;19;180
DEPARTURE;PHX1335;100;02:15;19;180
DEPARTURE;PHX1335;100;02:30;19;180
DEPARTURE;PHX1000;100;00:05;19;180
DEPARTURE;PHX1000;100;00:05;19;180
DEPARTURE;PHX1000;100;00:05;19;180
DEPARTURE;PHX1000;100;00:05;19;180
DEPARTURE;PHX1000;100;00:05;19;180
DEPARTURE;PHX1000;100;00:05;19;180
DEPARTURE;PHX1000;100;00:05;19;180
DEPARTURE;PHX1000;100;00:05;19;180
DEPARTURE;PHX1000;100;00:05;19;180
DEPARTURE;PHX1000;100;00:05;19;180