aboutsummaryrefslogtreecommitdiff
path: root/Source
diff options
context:
space:
mode:
authorXaviDCR92 <xavi.dcr@gmail.com>2017-09-16 01:44:42 +0200
committerXaviDCR92 <xavi.dcr@gmail.com>2017-09-16 01:44:42 +0200
commit0d7af34486f15d8f31f8474f17cad698923cadcb (patch)
treea8489b916733589bbf90f25f3d654ade9353e4a1 /Source
parentf2a6798f1da7231facec93305f8c157f1a56f072 (diff)
downloadairport-0d7af34486f15d8f31f8474f17cad698923cadcb.tar.gz
* Trimmed ending whitespaces.
* Makefile now generates output TIM files automatically, using 'cat whatever.flags' files as flags for bmp2tim.
Diffstat (limited to 'Source')
-rw-r--r--Source/Aircraft.c22
-rw-r--r--Source/Aircraft.h2
-rw-r--r--Source/EndAnimation.c84
-rw-r--r--Source/EndAnimation.h4
-rw-r--r--Source/Exe/AIRPORT.elfbin488544 -> 487972 bytes
-rw-r--r--Source/Font.c46
-rw-r--r--Source/Game.c992
-rw-r--r--Source/GameGui.c226
-rw-r--r--Source/GameStructures.h6
-rw-r--r--Source/Gfx.c148
-rw-r--r--Source/LoadMenu.c186
-rw-r--r--Source/LoadMenu.h4
-rw-r--r--Source/Makefile105
-rw-r--r--Source/MemCard.c462
-rw-r--r--Source/MemCard.h24
-rw-r--r--Source/Menu.c200
-rw-r--r--Source/PSXSDKIntro.c154
-rw-r--r--Source/Pad.c124
-rw-r--r--Source/Pad.h2
-rw-r--r--Source/PltParser.c68
-rw-r--r--Source/Serial.c2
-rw-r--r--Source/Sfx.c18
-rw-r--r--Source/Sfx.h2
-rw-r--r--Source/System.c458
-rw-r--r--Source/System.h4
-rw-r--r--Source/Timer.c52
-rw-r--r--Source/Timer.h2
-rw-r--r--Source/main.c4
28 files changed, 1697 insertions, 1704 deletions
diff --git a/Source/Aircraft.c b/Source/Aircraft.c
index bc61403..cb99c09 100644
--- a/Source/Aircraft.c
+++ b/Source/Aircraft.c
@@ -58,7 +58,7 @@ static char* AircraftLiveryNamesTable[] = {"PHX", NULL};
static AIRCRAFT_LIVERY AircraftLiveryTable[] = {AIRCRAFT_LIVERY_0, AIRCRAFT_LIVERY_UNKNOWN};
static char* GameFileList[] = { "cdrom:\\DATA\\SPRITES\\ARROW.TIM;1" };
-
+
static void* GameFileDest[] = { (GsSprite*)&ArrowSpr };
// Used to quickly link FlightData indexes against AircraftData indexes.
@@ -239,7 +239,7 @@ void AircraftHandler(void)
{
continue;
}
-
+
AircraftDirection(ptrAircraft);
AircraftAttitude(ptrAircraft);
AircraftSpeed(ptrAircraft);
@@ -249,7 +249,7 @@ void AircraftHandler(void)
for (j = 0; j < GAME_MAX_AIRCRAFT; j++)
{
TYPE_AIRCRAFT_DATA* ptrOtherAircraft = &AircraftData[j];
-
+
if (i == j)
{
continue;
@@ -331,7 +331,7 @@ void AircraftRender(TYPE_PLAYER* ptrPlayer, uint8_t aircraftIdx)
shadowIsoPos.x = ptrAircraft->IsoPos.x;
shadowIsoPos.y = ptrAircraft->IsoPos.y;
shadowIsoPos.z = 0;
-
+
if (ptrAircraft->State == STATE_IDLE)
{
return;
@@ -376,7 +376,7 @@ void AircraftRender(TYPE_PLAYER* ptrPlayer, uint8_t aircraftIdx)
{
static uint8_t aircraft_sine;
static bool aircraft_sine_decrease;
-
+
if (aircraft_sine_decrease == false)
{
if (aircraft_sine < 240)
@@ -434,10 +434,10 @@ void AircraftRender(TYPE_PLAYER* ptrPlayer, uint8_t aircraftIdx)
{
ArrowSpr.y = AircraftSpr.y;
}
-
+
GfxSortSprite(&ArrowSpr);
}
-
+
}
else
{
@@ -533,7 +533,7 @@ void AircraftDirection(TYPE_AIRCRAFT_DATA* ptrAircraft)
{
ptrAircraft->IsoPos.x = targetPos.x;
ptrAircraft->IsoPos.y = targetPos.y;
-
+
if (ptrAircraft->Target[++ptrAircraft->TargetIdx] == 0)
{
Serial_printf("All targets reached!\n");
@@ -718,21 +718,21 @@ AIRCRAFT_DIRECTION AircraftGetDirection(TYPE_AIRCRAFT_DATA* ptrAircraft)
uint16_t* AircraftGetTargets(uint8_t index)
{
TYPE_AIRCRAFT_DATA* ptrAircraft = AircraftFromFlightDataIndex(index);
-
+
return ptrAircraft->Target;
}
uint8_t AircraftGetTargetIdx(uint8_t index)
{
TYPE_AIRCRAFT_DATA* ptrAircraft = AircraftFromFlightDataIndex(index);
-
+
return ptrAircraft->TargetIdx;
}
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 aef7d52..0fb141c 100644
--- a/Source/Aircraft.h
+++ b/Source/Aircraft.h
@@ -11,7 +11,7 @@
/* *************************************
* Global prototypes
* *************************************/
-
+
void AircraftInit(void);
void AircraftHandler(void);
void AircraftRender(TYPE_PLAYER* ptrPlayer, uint8_t aircraftIdx);
diff --git a/Source/EndAnimation.c b/Source/EndAnimation.c
index 3907d6e..c60bf30 100644
--- a/Source/EndAnimation.c
+++ b/Source/EndAnimation.c
@@ -18,18 +18,18 @@
enum
{
END_ANIMATION_FADEOUT_STEP = 8,
-
+
END_ANIMATION_LINE_STEP = 2,
-
+
END_ANIMATION_SQUARES_SIZE_BITSHIFT = 5,
END_ANIMATION_SQUARES_SIZE = 32,
END_ANIMATION_SQUARES_PER_COLUMN = 8,
END_ANIMATION_SQUARES_PER_ROW = 12,
END_ANIMATION_SQUARES_TOTAL = END_ANIMATION_SQUARES_PER_COLUMN *
END_ANIMATION_SQUARES_PER_ROW,
-
+
END_ANIMATION_SQUARES_TOTAL_MAX_INDEX = END_ANIMATION_SQUARES_TOTAL - 1,
-
+
END_ANIMATION_SQUARES = 0,
END_ANIMATION_FADEOUT,
END_ANIMATION_LINE,
@@ -54,11 +54,11 @@ static GsSprite EndAnimationDisplay;
void EndAnimation(void)
{
uint8_t randIndex = 0;
-
+
GfxSaveDisplayData(&EndAnimationDisplay);
-
+
GfxSetGlobalLuminance(NORMAL_LUMINANCE);
-
+
if (SystemIsRandSeedSet() == false)
{
// Set default end animation
@@ -67,25 +67,25 @@ void EndAnimation(void)
else
{
randIndex = rand() % (END_ANIMATION_MAX_RAND_VALUE + 1);
-
+
switch(randIndex)
{
case END_ANIMATION_SQUARES:
EndAnimationSquares();
break;
-
+
case END_ANIMATION_FADEOUT:
EndAnimationFadeOut();
break;
-
+
case END_ANIMATION_LINE:
EndAnimationLine();
break;
-
+
default:
break;
}
-
+
SfxStopMusic();
}
}
@@ -93,26 +93,26 @@ void EndAnimation(void)
void EndAnimationFadeOut(void)
{
uint8_t i;
-
+
while (1)
{
if ( GfxGetGlobalLuminance() > 0)
{
GfxSetGlobalLuminance(GfxGetGlobalLuminance() - END_ANIMATION_FADEOUT_STEP);
-
+
GfxSortSprite(&EndAnimationDisplay);;
GfxDrawScene_Slow();
}
else
{
GsSortCls(0,0,0);
-
+
for (i = 0 ; i < 2 ; i++)
{
// Draw two frames to ensure black display
GfxDrawScene_Slow();
}
-
+
break;
}
}
@@ -121,35 +121,35 @@ void EndAnimationFadeOut(void)
void EndAnimationLine(void)
{
short rectIndex = 0;
-
+
do
{
GfxSortSprite(&EndAnimationDisplay);
-
+
// Draw upper half rectangle
-
+
EndAnimationRect.x = 0;
EndAnimationRect.y = 0;
-
+
EndAnimationRect.w = X_SCREEN_RESOLUTION;
EndAnimationRect.h = rectIndex;
-
+
GsSortRectangle(&EndAnimationRect);
-
+
EndAnimationRect.x = 0;
EndAnimationRect.y = Y_SCREEN_RESOLUTION - rectIndex;
-
+
EndAnimationRect.w = X_SCREEN_RESOLUTION;
EndAnimationRect.h = rectIndex;
-
+
GsSortRectangle(&EndAnimationRect);
-
+
GfxDrawScene_Slow();
-
+
rectIndex += END_ANIMATION_LINE_STEP;
-
+
}while (rectIndex <= (X_SCREEN_RESOLUTION >> 1) );
-
+
}
void EndAnimationSquares(void)
@@ -159,38 +159,38 @@ void EndAnimationSquares(void)
bool sqPos[END_ANIMATION_SQUARES_TOTAL];
uint16_t sqCounter = END_ANIMATION_SQUARES_TOTAL;
uint16_t maxIndex = END_ANIMATION_SQUARES_TOTAL_MAX_INDEX;
-
+
EndAnimationRect.w = END_ANIMATION_SQUARES_SIZE;
EndAnimationRect.h = END_ANIMATION_SQUARES_SIZE;
-
+
EndAnimationRect.r = 0;
EndAnimationRect.g = 0;
EndAnimationRect.b = 0;
-
+
memset(sqPos, false , END_ANIMATION_SQUARES_TOTAL);
-
+
for (i = 0; i < END_ANIMATION_SQUARES_TOTAL ; i++)
{
-
+
do
{
randInd = SystemRand(0,maxIndex);
-
+
/*Serial_printf("randInd = %d\t",randInd);
Serial_printf("sqPos[randInd] = %d\n", sqPos[randInd]);*/
-
+
if (sqPos[randInd] == false)
{
sqPos[randInd] = true;
sqCounter--;
-
+
while (sqPos[maxIndex] == true)
{
// Lower maximum value for rand() so that it's
// easier to spot new empty index on next iteration.
maxIndex--;
}
-
+
break;
}
else
@@ -200,11 +200,11 @@ void EndAnimationSquares(void)
break;
}
}
-
+
}while (1);
-
+
GfxSortSprite(&EndAnimationDisplay);
-
+
if (sqCounter != 0)
{
for (j = 0; j < END_ANIMATION_SQUARES_TOTAL ; j++)
@@ -214,10 +214,10 @@ void EndAnimationSquares(void)
EndAnimationRect.x = ((j) << END_ANIMATION_SQUARES_SIZE_BITSHIFT) -
(short)( (j / END_ANIMATION_SQUARES_PER_ROW) *
X_SCREEN_RESOLUTION);
-
+
EndAnimationRect.y = (short) (j/ END_ANIMATION_SQUARES_PER_ROW) <<
END_ANIMATION_SQUARES_SIZE_BITSHIFT;
-
+
GsSortRectangle(&EndAnimationRect);
}
}
diff --git a/Source/EndAnimation.h b/Source/EndAnimation.h
index 9ba13a0..3ac015b 100644
--- a/Source/EndAnimation.h
+++ b/Source/EndAnimation.h
@@ -2,7 +2,7 @@
#define __END_SCREEN_HEADER__
/* **************************************
- * Includes *
+ * Includes *
* **************************************/
/* **************************************
@@ -16,7 +16,7 @@
void EndAnimation(void);
/* **************************************
- * Global Variables *
+ * Global Variables *
* **************************************/
#endif // __END_SCREEN_HEADER__
diff --git a/Source/Exe/AIRPORT.elf b/Source/Exe/AIRPORT.elf
index a09afcd..b4f52e1 100644
--- a/Source/Exe/AIRPORT.elf
+++ b/Source/Exe/AIRPORT.elf
Binary files differ
diff --git a/Source/Font.c b/Source/Font.c
index 52a8cca..5907594 100644
--- a/Source/Font.c
+++ b/Source/Font.c
@@ -32,36 +32,36 @@ bool FontLoadImage(char* strPath, TYPE_FONT * ptrFont)
{
return false;
}
-
+
ptrFont->spr_w = ptrFont->spr.w;
ptrFont->spr_h = ptrFont->spr.h;
ptrFont->spr_u = ptrFont->spr.u;
ptrFont->spr_v = ptrFont->spr.v;
-
+
//Now set default values to font
-
+
ptrFont->char_w = FONT_DEFAULT_CHAR_SIZE;
ptrFont->char_h = FONT_DEFAULT_CHAR_SIZE;
-
+
ptrFont->spr.attribute |= COLORMODE(COLORMODE_4BPP);
ptrFont->spr.attribute &= COLORMODE(~(COLORMODE_8BPP | COLORMODE_16BPP | COLORMODE_24BPP));
ptrFont->spr.r = NORMAL_LUMINANCE;
ptrFont->spr.g = NORMAL_LUMINANCE;
ptrFont->spr.b = NORMAL_LUMINANCE;
-
+
//At this point, spr.w and spr.h = real w/h
ptrFont->char_per_row = (uint8_t)(ptrFont->spr_w / ptrFont->char_w);
ptrFont->max_ch_wrap = 0;
-
+
ptrFont->spr.w = ptrFont->char_w;
ptrFont->spr.h = ptrFont->char_h;
-
+
ptrFont->flags = FONT_NOFLAGS;
-
+
ptrFont->init_ch = FONT_DEFAULT_INIT_CHAR;
-
+
Serial_printf("Sprite CX = %d, sprite CY = %d\n",ptrFont->spr.cx, ptrFont->spr.cy);
-
+
return true;
}
@@ -79,11 +79,11 @@ void FontSetSize(TYPE_FONT * ptrFont, short size)
{
ptrFont->char_w = size;
ptrFont->char_h = size;
-
+
//At this point, spr.w and spr.h = real w/h
ptrFont->char_per_row = (uint8_t)(ptrFont->spr_w / ptrFont->char_w);
ptrFont->max_ch_wrap = 0;
-
+
ptrFont->spr.w = ptrFont->char_w;
ptrFont->spr.h = ptrFont->char_h;
}
@@ -104,9 +104,9 @@ void FontPrintText(TYPE_FONT * ptrFont, short x, short y, char* str, ...)
uint16_t line_count = 0;
int result;
short orig_x = x;
-
+
va_list ap;
-
+
if (ptrFont->flags & FONT_1HZ_FLASH)
{
if (Gfx1HzFlash() == false)
@@ -121,24 +121,24 @@ void FontPrintText(TYPE_FONT * ptrFont, short x, short y, char* str, ...)
return;
}
}
-
+
va_start(ap, str);
-
+
result = vsnprintf( _internal_text,
FONT_INTERNAL_TEXT_BUFFER_MAX_SIZE,
str,
ap );
-
+
for (i = 0; i < result ; i++)
{
char _ch = _internal_text[i];
-
+
if (_ch == '\0')
{
// End of string
break;
}
-
+
switch(_ch)
{
case ' ':
@@ -158,7 +158,7 @@ void FontPrintText(TYPE_FONT * ptrFont, short x, short y, char* str, ...)
y += ptrFont->char_h;
}
}
-
+
ptrFont->spr.x = x;
ptrFont->spr.y = y;
ptrFont->spr.w = ptrFont->char_w;
@@ -167,7 +167,7 @@ void FontPrintText(TYPE_FONT * ptrFont, short x, short y, char* str, ...)
ptrFont->spr.u += ptrFont->spr_u; // Add original offset for image
ptrFont->spr.v = (short)( (_ch - ptrFont->init_ch) / ptrFont->char_per_row) * ptrFont->char_h;
ptrFont->spr.v += ptrFont->spr_v; // Add original offset for image
-
+
if (ptrFont->flags & FONT_BLEND_EFFECT)
{
ptrFont->spr.r += 8;
@@ -188,13 +188,13 @@ void FontPrintText(TYPE_FONT * ptrFont, short x, short y, char* str, ...)
Serial_printf("Char: %c, spr.u = %d, spr.v = %d\n",str[i],ptrFont->spr.u, ptrFont->spr.v);
Serial_printf("Sprite CX = %d, sprite CY = %d\n",ptrFont->spr.cx, ptrFont->spr.cy);*/
//Serial_printf("Sprite rgb={%d,%d,%d}\n",ptrFont->spr.r, ptrFont->spr.g, ptrFont->spr.b);
-
+
GfxSortSprite(&ptrFont->spr);
x += ptrFont->char_spacing;
break;
}
}
-
+
if (ptrFont->flags & FONT_BLEND_EFFECT)
{
ptrFont->spr.r = _blend_effect_lum;
diff --git a/Source/Game.c b/Source/Game.c
index 102b9f3..2fc14ad 100644
--- a/Source/Game.c
+++ b/Source/Game.c
@@ -102,7 +102,7 @@ enum
LAST_BUILDING = BUILDING_GATE,
MAX_BUILDING_ID
};
-
+
enum
{
TILE_GRASS = 0,
@@ -127,12 +127,12 @@ enum
TILE_RWY_EXIT,
TILE_TAXIWAY_CORNER_GRASS_2,
-
+
LAST_TILE_TILESET1 = TILE_TAXIWAY_CORNER_GRASS_2
};
enum
-{
+{
LAST_TILE_TILESET2 = LAST_TILE_TILESET1
};
@@ -243,7 +243,7 @@ static char* GameFileList[] = { "cdrom:\\DATA\\SPRITES\\TILESET1.TIM;1" ,
"cdrom:\\DATA\\SOUNDS\\RCTM1F1.VAG;1" ,
"cdrom:\\DATA\\SOUNDS\\TAKEOFF1.VAG;1" ,
"cdrom:\\DATA\\SOUNDS\\BEEP.VAG;1" };
-
+
static void* GameFileDest[] = { (GsSprite*)&GameTilesetSpr ,
(GsSprite*)&GamePlaneSpr ,
NULL , // CLT files must use NULL pointers
@@ -257,10 +257,10 @@ static void* GameFileDest[] = { (GsSprite*)&GameTilesetSpr ,
static char* GamePlt[] = { "cdrom:\\DATA\\LEVELS\\LEVEL1.PLT;1" };
static void* GamePltDest[] = {(TYPE_FLIGHT_DATA*)&FlightData };
-
+
static char* GameLevelList[] = {"cdrom:\\DATA\\LEVELS\\LEVEL1.LVL;1"};
static uint16_t GameLevelBuffer[GAME_MAX_MAP_SIZE];
-
+
static uint8_t GameLevelColumns;
static uint8_t GameLevelSize;
@@ -277,59 +277,59 @@ static bool TwoPlayersActive;
bool GameFinishedFlag;
/* ***************************************************************************************
- *
+ *
* @name: void Game(bool two_players)
- *
+ *
* @author: Xavier Del Campo
*
* @brief:
* Game main loop. Called by "Menu" module.
- *
+ *
* @remarks:
- *
+ *
* ***************************************************************************************/
void Game(bool two_players)
-{
+{
TwoPlayersActive = two_players;
GameInit();
-
+
while (1)
{
if (GameExit() == true)
{
break;
}
-
+
GameEmergencyMode();
-
+
GameCalculations();
-
+
GameGraphics();
-
+
if (GameStartupFlag == true)
{
GameStartupFlag = false;
}
}
-
+
GfxDisableSplitScreen();
-
+
EndAnimation();
}
/* ***************************************************************************************
- *
+ *
* @name: bool GameExit(void)
- *
+ *
* @author: Xavier Del Campo
*
* @brief:
* Evaluates special conditions which end current game and return to main menu.
- *
+ *
* @returns:
* True if game has to be exitted, false otherwise.
- *
+ *
* ***************************************************************************************/
bool GameExit(void)
@@ -362,16 +362,16 @@ bool GameExit(void)
}
/* ***************************************************************************************
- *
+ *
* @name: bool GamePause(void)
- *
+ *
* @author: Xavier Del Campo
*
* @brief:
* When PAD_START is pressed, it draws a rectangle on top of the screen and the game halts.
- *
+ *
* @remarks:
- *
+ *
* ***************************************************************************************/
bool GamePause(void)
@@ -379,12 +379,12 @@ bool GamePause(void)
TYPE_PLAYER* ptrPlayer;
uint8_t i;
bool pause_flag = false;
-
+
if (GameStartupFlag == true)
{
return false;
}
-
+
for (i = 0 ; i < MAX_PLAYERS ; i++)
{
ptrPlayer = &PlayerData[i];
@@ -400,30 +400,30 @@ bool GamePause(void)
}
}
}
-
+
if (pause_flag == true)
- {
+ {
// Blocking function:
// * Returns true if player pointed to by ptrPlayer wants to exit game
// * Returns false if player pointed to by ptrPlayer wants to resume game
return GameGuiPauseDialog(ptrPlayer);
}
-
+
return false;
}
/* ***************************************************************************************
- *
+ *
* @name: void GameInit(void)
- *
+ *
* @author: Xavier Del Campo
*
* @brief:
* Game basic parameters initialization.
- *
+ *
* @remarks:
* Tilesets and buildings are only loaded on first game. Then, only PLT is loaded.
- *
+ *
* ***************************************************************************************/
void GameInit(void)
@@ -431,7 +431,7 @@ void GameInit(void)
uint8_t i;
uint32_t track;
static bool firstLoad = true;
-
+
GameStartupFlag = true;
if (firstLoad == true)
@@ -448,17 +448,17 @@ void GameInit(void)
GamePltDest,
sizeof(GamePlt) / sizeof(GamePlt[0]),
sizeof(GamePltDest) / sizeof(GamePltDest[0]) );
-
+
GameLoadLevel();
-
+
GameGuiInit();
GameBuildingsInit();
-
+
memset(GameRwy,0,GAME_MAX_RUNWAYS * sizeof(uint16_t) );
-
+
memset(GameUsedRwy,0,GAME_MAX_RUNWAYS * sizeof(uint16_t) );
-
+
PlayerData[PLAYER_ONE].Active = true;
PlayerData[PLAYER_ONE].PadKeyPressed_Callback = &PadOneKeyPressed;
PlayerData[PLAYER_ONE].PadKeyReleased_Callback = &PadOneKeyReleased;
@@ -467,11 +467,11 @@ void GameInit(void)
PlayerData[PLAYER_ONE].PadLastKeySinglePressed_Callback = &PadOneGetLastKeySinglePressed;
PlayerData[PLAYER_ONE].FlightDataPage = 0;
PlayerData[PLAYER_ONE].UnboardingSequenceIdx = 0;
-
+
memset(PlayerData[PLAYER_ONE].UnboardingSequence, 0, GAME_MAX_SEQUENCE_KEYS * sizeof(unsigned short) );
-
+
PlayerData[PLAYER_TWO].Active = TwoPlayersActive? true : false;
-
+
if (PlayerData[PLAYER_TWO].Active == true)
{
PlayerData[PLAYER_TWO].PadKeyPressed_Callback = &PadTwoKeyPressed;
@@ -481,9 +481,9 @@ void GameInit(void)
PlayerData[PLAYER_TWO].PadKeySinglePress_Callback = &PadTwoKeySinglePress;
PlayerData[PLAYER_TWO].PadLastKeySinglePressed_Callback = &PadTwoGetLastKeySinglePressed;
PlayerData[PLAYER_TWO].UnboardingSequenceIdx = 0;
-
+
memset(PlayerData[PLAYER_TWO].UnboardingSequence, 0, GAME_MAX_SEQUENCE_KEYS * sizeof(unsigned short) );
-
+
// On 2-player mode, one player controls departure flights and
// other player controls arrival flights.
PlayerData[PLAYER_ONE].FlightDirection = DEPARTURE;
@@ -493,7 +493,7 @@ void GameInit(void)
{
PlayerData[PLAYER_ONE].FlightDirection = DEPARTURE | ARRIVAL;
}
-
+
for (i = 0; i < MAX_PLAYERS ; i++)
{
CameraInit(&PlayerData[i]);
@@ -507,11 +507,11 @@ void GameInit(void)
PlayerData[i].WaypointIdx = 0;
PlayerData[i].LastWaypointIdx = 0;
}
-
+
GameAircraftCreatedFlag = false;
GameAircraftCollisionFlag = false;
GameAircraftCollisionIdx = 0;
-
+
if (GameTwoPlayersActive() == true)
{
GameMouseSpr.x = MOUSE_X_2PLAYER;
@@ -522,7 +522,7 @@ void GameInit(void)
GameMouseSpr.x = MOUSE_X;
GameMouseSpr.y = MOUSE_Y;
}
-
+
GameMouseSpr.w = MOUSE_W;
GameMouseSpr.h = MOUSE_H;
GameMouseSpr.attribute = COLORMODE(COLORMODE_16BPP);
@@ -535,37 +535,37 @@ void GameInit(void)
spawnMinTimeFlag = false;
GameScore = 0;
-
+
GameGetRunwayArray();
-
+
GameSelectedTile = 0;
GameFinishedFlag = false;
-
+
AircraftInit();
-
+
LoadMenuEnd();
-
+
//GfxSetGlobalLuminance(0);
-
+
track = SystemRand(GAMEPLAY_FIRST_TRACK, GAMEPLAY_LAST_TRACK);
-
- SfxPlayTrack(track);
+
+ SfxPlayTrack(track);
}
/* ***************************************************************************************
- *
+ *
* @name: void GameBuildingsInit(void)
- *
+ *
* @author: Xavier Del Campo
*
- *
+ *
* @brief:
* Reportedly, it initializes coordinate/size data for each building instance.
- *
+ *
* @remarks:
*
- *
+ *
* ***************************************************************************************/
void GameBuildingsInit(void)
@@ -621,7 +621,7 @@ void GameBuildingsInit(void)
BUILDING_HANGAR_ORIGIN_X = 20,
BUILDING_HANGAR_ORIGIN_Y = 11,
-
+
BUILDING_ATC_TOWER_ORIGIN_X = 12,
BUILDING_ATC_TOWER_ORIGIN_Y = 20,
};
@@ -680,7 +680,7 @@ void GameBuildingsInit(void)
GameBuildingData[BUILDING_GATE].IsoPos.x = BUILDING_GATE_OFFSET_X;
GameBuildingData[BUILDING_GATE].IsoPos.y = BUILDING_GATE_OFFSET_Y;
// z coordinate set to 0 by default.
-
+
/*BUILDING_ILS,
BUILDING_ATC_TOWER,
BUILDING_ATC_LOC,
@@ -690,19 +690,19 @@ void GameBuildingsInit(void)
}
/* ***************************************************************************************
- *
+ *
* @name: void GameEmergencyMode(void)
- *
+ *
* @author: Xavier Del Campo
*
- *
+ *
* @brief:
* Draws a blue rectangle on top of the screen whenever one of the two active controllers
* (e.g.: pad1 on single player mode, pad1 || pad2 on two player mode) is disconnected.
- *
+ *
* @remarks:
* See PSX_PollPad(), defined on psx.h, and Pad module for further information.
- *
+ *
* ***************************************************************************************/
void GameEmergencyMode(void)
@@ -716,10 +716,10 @@ void GameEmergencyMode(void)
{
ERROR_RECT_X = 32,
ERROR_RECT_W = X_SCREEN_RESOLUTION - (ERROR_RECT_X << 1),
-
+
ERROR_RECT_Y = 16,
ERROR_RECT_H = Y_SCREEN_RESOLUTION - (ERROR_RECT_Y << 1),
-
+
ERROR_RECT_R = 0,
ERROR_RECT_G = 32,
ERROR_RECT_B = NORMAL_LUMINANCE
@@ -731,7 +731,7 @@ void GameEmergencyMode(void)
PAD_DISCONNECTED_TEXT_Y = 48,
PAD_DISCONNECTED_TEXT_Y_OFFSET_BITSHIFT = 5
};
-
+
do
{
bool enabled = false;
@@ -748,10 +748,10 @@ void GameEmergencyMode(void)
{
// One of the pads has been disconnected during gameplay
// Show an error screen until it is disconnected again.
-
+
GsSortCls(0,0,0);
GsSortRectangle(&errorRct);
-
+
for (i = 0; i < MAX_PLAYERS; i++)
{
if (disconnected_players & (1<<i) )
@@ -762,7 +762,7 @@ void GameEmergencyMode(void)
"Pad %s disconnected", i? "right" : "left" );
}
}
-
+
GfxDrawScene_Slow();
}
@@ -790,21 +790,21 @@ void GameEmergencyMode(void)
}
/* ***************************************************************************************
- *
+ *
* @name: void GameGetAircraftTilemap(uint8_t i)
- *
+ *
* @author: Xavier Del Campo
*
* @param:
* uint8_t i:
* Index for FlightData table.
- *
+ *
* @brief:
* On each cycle, it creates a 2-dimensional array relating aircraft indexes against
* tile numbers.
- *
+ *
* @remarks:
- *
+ *
* ***************************************************************************************/
void GameGetAircraftTilemap(uint8_t i)
@@ -816,7 +816,7 @@ void GameGetAircraftTilemap(uint8_t i)
{
memset(GameAircraftTilemap, FLIGHT_DATA_INVALID_IDX, sizeof(GameAircraftTilemap) );
}
-
+
if (FlightData.State[i] == STATE_IDLE)
{
return;
@@ -832,26 +832,26 @@ void GameGetAircraftTilemap(uint8_t i)
break;
}
}
-
+
GameAircraftTilemap[tileNr][j] = i;
//Serial_printf("GameAircraftTileMap[%d][%d] = %d\n", tileNr, j, GameAircraftTilemap[tileNr][j]);
}
/* ***************************************************************************************
- *
+ *
* @name: void GameCalculations(void)
- *
+ *
* @author: Xavier Del Campo
- *
+ *
* @brief:
* First half of game execution. Executed when GPU is still drawing previous frame.
* Calculates all new states and values.
- *
+ *
* @remarks:
* Since the GPU takes a long time to draw a frame, GameCalculations() should be used
* for all CPU-intensive tasks.
- *
+ *
* ***************************************************************************************/
void GameCalculations(void)
@@ -871,10 +871,10 @@ void GameCalculations(void)
GameRemainingAircraft(i);
GameGetAircraftTilemap(i);
}
-
+
AircraftHandler();
GameGuiCalculateSlowScore();
-
+
for (i = 0 ; i < MAX_PLAYERS ; i++)
{
// Run player-specific functions for each player
@@ -886,9 +886,9 @@ void GameCalculations(void)
}
/* ***************************************************************************************
- *
+ *
* @name: void GamePlayerHandler(TYPE_PLAYER* ptrPlayer, TYPE_FLIGHT_DATA* ptrFlightData)
- *
+ *
* @author: Xavier Del Campo
*
* @param:
@@ -898,12 +898,12 @@ void GameCalculations(void)
* TYPE_FLIGHT_DATA* ptrFlightData:
* In the end, pointer to FlightData data table, which contains
* information about all available flights.
- *
+ *
* @brief:
* Calls all routines attached to a player.
- *
+ *
* @remarks:
- *
+ *
* ***************************************************************************************/
void GamePlayerHandler(TYPE_PLAYER* ptrPlayer, TYPE_FLIGHT_DATA* ptrFlightData)
@@ -921,7 +921,7 @@ void GamePlayerHandler(TYPE_PLAYER* ptrPlayer, TYPE_FLIGHT_DATA* ptrFlightData)
TYPE_ISOMETRIC_POS IsoPos = AircraftGetIsoPos(GameAircraftCollisionIdx);
CameraMoveToIsoPos(ptrPlayer, IsoPos);
}
-
+
GameStateUnboarding(ptrPlayer, ptrFlightData);
GameStateLockTarget(ptrPlayer, ptrFlightData);
GameStateSelectRunway(ptrPlayer, ptrFlightData);
@@ -934,16 +934,16 @@ void GamePlayerHandler(TYPE_PLAYER* ptrPlayer, TYPE_FLIGHT_DATA* ptrFlightData)
}
/* *******************************************************************
- *
+ *
* @name: void GameClock(void)
- *
+ *
* @author: Xavier Del Campo
- *
+ *
* @brief:
* Handles game clock later rendered on GameGui.
- *
+ *
* @remarks:
- *
+ *
* *******************************************************************/
void GameClock(void)
@@ -951,13 +951,13 @@ void GameClock(void)
if (System1SecondTick() == true)
{
GameMinutes++;
-
+
if (GameMinutes >= 60)
{
GameHour++;
GameMinutes = 0;
}
-
+
if (GameHour >= 24)
{
GameHour = 0;
@@ -966,24 +966,24 @@ void GameClock(void)
}
/* *******************************************************************
- *
+ *
* @name: void GameClockFlights(uint8_t i)
- *
+ *
* @author: Xavier Del Campo
- *
+ *
* @param:
* uint8_t i:
* Index for FlightData table.
- *
+ *
* @brief:
* Handles hours/minutes values for all active aircraft.
- *
+ *
* @remarks:
- *
+ *
* *******************************************************************/
void GameClockFlights(uint8_t i)
-{
+{
if (System1SecondTick() == true)
{
if ( (FlightData.Minutes[i] == 0)
@@ -993,7 +993,7 @@ void GameClockFlights(uint8_t i)
FlightData.Minutes[i] = 60;
FlightData.Hours[i]--;
}
-
+
if (FlightData.Minutes[i] > 0)
{
FlightData.Minutes[i]--;
@@ -1009,21 +1009,21 @@ void GameClockFlights(uint8_t i)
}
/* *******************************************************************
- *
+ *
* @name: void GameGraphics(void)
- *
+ *
* @author: Xavier Del Campo
- *
+ *
* @brief:
* Second half of game execution. Once GameCalculations() has ended,
* states and new values have been calculated and all primitives are
* rendered depending on the obtained results.
- *
+ *
* @remarks:
* It is advisable to keep CPU usage here, as once this function is
* entered, GPU is waiting for primitive data. Always try to move
* CPU-intensive operations to GameCalculations().
- *
+ *
* *******************************************************************/
void GameGraphics(void)
@@ -1032,14 +1032,14 @@ void GameGraphics(void)
bool split_screen = false;
SystemAcknowledgeFrame();
-
+
while ( (SystemRefreshNeeded() == false) || (GfxIsGPUBusy() == true) );
if (TwoPlayersActive == true)
{
split_screen = true;
}
-
+
if (GfxGetGlobalLuminance() < NORMAL_LUMINANCE)
{
// Fading from black effect on startup.
@@ -1049,7 +1049,7 @@ void GameGraphics(void)
GsSortCls(0,0,GfxGetGlobalLuminance() >> 1);
while (GsIsDrawing());
-
+
for (i = 0; i < MAX_PLAYERS ; i++)
{
TYPE_PLAYER* ptrPlayer = &PlayerData[i];
@@ -1060,7 +1060,7 @@ 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.
@@ -1075,7 +1075,7 @@ void GameGraphics(void)
GameRenderBuildingAircraft(ptrPlayer);
GameGuiAircraftList(ptrPlayer, &FlightData);
-
+
GameDrawMouse(ptrPlayer);
GameGuiDrawUnboardingSequence(ptrPlayer);
@@ -1087,18 +1087,18 @@ void GameGraphics(void)
}
}
}
-
+
// 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...)
-
+
GameGuiBubble(&FlightData);
-
+
GameGuiClock(GameHour,GameMinutes);
GameGuiShowScore();
@@ -1112,17 +1112,17 @@ void GameGraphics(void)
}
/* *******************************************************************
- *
+ *
* @name: void GameGraphics(void)
- *
+ *
* @author: Xavier Del Campo
- *
+ *
* @brief:
* Determines rendering order depending on building/aircraft
* isometric position data.
- *
+ *
* @remarks:
- *
+ *
* *******************************************************************/
void GameRenderBuildingAircraft(TYPE_PLAYER* ptrPlayer)
@@ -1153,7 +1153,7 @@ void GameRenderBuildingAircraft(TYPE_PLAYER* ptrPlayer)
for (j = 0; j < GAME_MAX_AIRCRAFT_PER_TILE; j++)
{
uint8_t AircraftIdx = GameAircraftTilemap[tileNr][j];
-
+
TYPE_ISOMETRIC_POS aircraftIsoPos = AircraftGetIsoPos(AircraftIdx);
if (AircraftIdx == FLIGHT_DATA_INVALID_IDX)
@@ -1220,7 +1220,7 @@ void GameRenderBuildingAircraft(TYPE_PLAYER* ptrPlayer)
bool buildingDrawn = false;
// Define new coordinates for building.
-
+
GameBuildingSpr.x = buildingCartPos.x - GameBuildingData[CurrentBuilding].orig_x;
GameBuildingSpr.y = buildingCartPos.y - GameBuildingData[CurrentBuilding].orig_y;
@@ -1241,13 +1241,13 @@ void GameRenderBuildingAircraft(TYPE_PLAYER* ptrPlayer)
GameBuildingSpr.u = orig_u;
GameBuildingSpr.v = orig_v;
-
+
buildingDrawn = true;
}
break;
}
-
+
if (Aircraft_Y_Data[k] < buildingIsoPos.y)
{
AircraftRender(ptrPlayer, AircraftRenderOrder[k]);
@@ -1260,10 +1260,10 @@ void GameRenderBuildingAircraft(TYPE_PLAYER* ptrPlayer)
GameBuildingSpr.u = orig_u;
GameBuildingSpr.v = orig_v;
-
+
buildingDrawn = true;
}
-
+
AircraftRender(ptrPlayer, AircraftRenderOrder[k]);
}
}
@@ -1282,104 +1282,104 @@ void GameRenderBuildingAircraft(TYPE_PLAYER* ptrPlayer)
}
/* *******************************************************************
- *
+ *
* @name: void GameLoadLevel(void)
- *
+ *
* @author: Xavier Del Campo
- *
+ *
* @brief:
* Loads and parses *.LVL data.
- *
- *
+ *
+ *
* @remarks:
* Filepath for *.LVL is given by GameLevelList[0]. Do NOT ever move
* it from there to avoid problems!
- *
+ *
* *******************************************************************/
void GameLoadLevel(void)
-{
+{
uint8_t i = 0;
uint8_t* ptrBuffer;
char LevelHeader[LEVEL_MAGIC_NUMBER_SIZE + 1];
-
+
/* TODO - Very important */
// Map contents (that means, without header) should be copied to GameLevelBuffer
// Header treatment (magic number, map size, map title...) should be done
// using System's file buffer.
-
+
if (SystemLoadFile(GameLevelList[0]) == false)
{
return;
}
-
+
ptrBuffer = SystemGetBufferAddress();
-
+
//SystemLoadFileToBuffer(GameLevelList[0],GameLevelBuffer,GAME_MAX_MAP_SIZE);
-
+
memset(LevelHeader,0, LEVEL_MAGIC_NUMBER_SIZE + 1);
-
+
memcpy(LevelHeader,ptrBuffer,LEVEL_MAGIC_NUMBER_SIZE);
-
+
LevelHeader[LEVEL_MAGIC_NUMBER_SIZE] = '\0';
-
+
Serial_printf("Level header: %s\n",LevelHeader);
-
+
if (strncmp(LevelHeader,LEVEL_MAGIC_NUMBER_STRING,LEVEL_MAGIC_NUMBER_SIZE) != 0)
{
Serial_printf("Invalid level header! Read \"%s\" instead of \"ATC\"\n",LevelHeader);
return;
}
-
+
i += LEVEL_MAGIC_NUMBER_SIZE;
-
+
GameLevelColumns = ptrBuffer[i++];
-
+
Serial_printf("Level size: %d\n",GameLevelColumns);
-
+
if ( (GameLevelColumns < MIN_MAP_COLUMNS)
||
(GameLevelColumns > MAX_MAP_COLUMNS) )
{
- Serial_printf("Invalid map size! Value: %d\n",GameLevelColumns);
+ Serial_printf("Invalid map size! Value: %d\n",GameLevelColumns);
return;
}
-
+
GameLevelSize = GameLevelColumns * GameLevelColumns;
-
+
memset(GameLevelTitle,0,LEVEL_TITLE_SIZE);
-
+
memcpy(GameLevelTitle,&ptrBuffer[i],LEVEL_TITLE_SIZE);
-
+
Serial_printf("Game level title: %s\n",GameLevelTitle);
-
+
i += LEVEL_TITLE_SIZE;
-
+
memset(GameLevelBuffer,0,GAME_MAX_MAP_SIZE);
-
+
i = LEVEL_HEADER_SIZE;
-
+
memcpy(GameLevelBuffer, &ptrBuffer[i], GameLevelSize * sizeof(uint16_t)); // 2 bytes per tile
}
/* ******************************************************************************************
- *
+ *
* @name: void GameAircraftState(uint8_t i)
- *
+ *
* @author: Xavier Del Campo
*
* @param:
* uint8_t i:
* Index for FlightData table.
- *
+ *
* @brief:
* It determines what state should be applied to aircraft when spawn timer expires.
- *
+ *
* @remarks:
* This is where TYPE_FLIGHT_DATA is transferred to TYPE_AIRCRAFT on departure.
- *
+ *
* ******************************************************************************************/
-
+
void GameAircraftState(uint8_t i)
{
uint16_t target[2] = {0};
@@ -1387,7 +1387,7 @@ void GameAircraftState(uint8_t i)
// target which is the parking tile itself, and the second element
// is just the NULL character.
// Not an ideal solution, but the best one currently available.
-
+
if (FlightData.Finished[i] == false)
{
if ( (FlightData.Hours[i] == 0)
@@ -1434,11 +1434,11 @@ void GameAircraftState(uint8_t i)
// Create notification request for incoming aircraft
GameGuiBubbleShow();
-
+
target[0] = FlightData.Parking[i];
-
+
Serial_printf("Target assigned = %d\n", target[0]);
-
+
if (AircraftAddNew(&FlightData, i, target) == false)
{
Serial_printf("Exceeded maximum aircraft number!\n");
@@ -1470,23 +1470,23 @@ void GameAircraftState(uint8_t i)
}
/* ******************************************************************************************
- *
+ *
* @name: void GameRenderLevel(TYPE_PLAYER* ptrPlayer)
- *
+ *
* @author: Xavier Del Campo
*
* @param:
* TYPE_PLAYER* ptrPlayer:
* Pointer to a player structure
*
- *
+ *
* @brief:
* Draws all tiles depending on GameLevelBuffer configuration.
- *
+ *
* @remarks:
* Tiles are usually rendered with normal RGB values unless parking/runway is busy
* or ptrPlayer->InvalidPath == true.
- *
+ *
* ******************************************************************************************/
void GameRenderLevel(TYPE_PLAYER* ptrPlayer)
@@ -1504,21 +1504,21 @@ void GameRenderLevel(TYPE_PLAYER* ptrPlayer)
//uint16_t init_timer_value = 0;
//uint16_t end_timer_value = 0;
-
+
// Prepare runway to be painted in blue if player is on runway selection mode
if (ptrPlayer->SelectRunway == true)
{
-
+
/*Serial_printf("Runway array:\n");
-
+
for (j = 0; j < GAME_MAX_RWY_LENGTH; j++)
{
Serial_printf("%d ",ptrPlayer->RwyArray[j]);
}
-
+
Serial_printf("\n");*/
}
-
+
for (i = 0 ; i < GameLevelSize; i++)
{
// GameLevelBuffer bits explanation:
@@ -1533,16 +1533,16 @@ void GameRenderLevel(TYPE_PLAYER* ptrPlayer)
// | | | | V Tile, bit 5
// | | V Tile, bit 6
// | Tile mirror flag
-
+
uint8_t CurrentTile = (uint8_t)(GameLevelBuffer[i] & 0x00FF);
// Isometric -> Cartesian conversion
tileIsoPos.x = columns << (TILE_SIZE_BIT_SHIFT);
tileIsoPos.y = rows << (TILE_SIZE_BIT_SHIFT);
tileIsoPos.z = 0;
-
+
tileCartPos = GfxIsometricToCartesian(&tileIsoPos);
-
+
// Flipped tiles have bit 7 set.
if (CurrentTile & TILE_MIRROR_FLAG)
{
@@ -1554,7 +1554,7 @@ void GameRenderLevel(TYPE_PLAYER* ptrPlayer)
{
flip_id = false;
}
-
+
if (CurrentTile <= LAST_TILE_TILESET1)
{
// Draw using GameTilesetSpr
@@ -1572,19 +1572,19 @@ void GameRenderLevel(TYPE_PLAYER* ptrPlayer)
ptrTileset = NULL;
continue;
-
+
// if (flip_id == false)
// {
// continue;
// }
}
-
+
ptrTileset->w = TILE_SIZE;
ptrTileset->h = TILE_SIZE_H;
ptrTileset->x = tileCartPos.x;
ptrTileset->y = tileCartPos.y;
-
+
// Set coordinate origin to left upper corner
ptrTileset->x -= TILE_SIZE >> 1;
//ptrTileset->y -= TILE_SIZE_H >> 2;
@@ -1609,14 +1609,14 @@ void GameRenderLevel(TYPE_PLAYER* ptrPlayer)
ptrTileset->r = NORMAL_LUMINANCE;
ptrTileset->g = NORMAL_LUMINANCE;
ptrTileset->b = NORMAL_LUMINANCE;
-
+
if ( (ptrPlayer->SelectRunway == true)
&&
(i != 0)
&&
(SystemContains_u16(i, ptrPlayer->RwyArray, GAME_MAX_RWY_LENGTH) == true) )
{
-
+
if (used_rwy == true)
{
ptrTileset->r = rwy_sine;
@@ -1674,13 +1674,13 @@ void GameRenderLevel(TYPE_PLAYER* ptrPlayer)
//init_timer_value = GetRCnt(2);
//end_timer_value = GetRCnt(2);
-
+
ptrTileset->r = NORMAL_LUMINANCE >> 2;
ptrTileset->g = rwy_sine;
ptrTileset->b = NORMAL_LUMINANCE >> 2;
}
}
-
+
if (ptrTileset != NULL)
{
if (flip_id == true)
@@ -1688,13 +1688,13 @@ void GameRenderLevel(TYPE_PLAYER* ptrPlayer)
ptrTileset->attribute |= H_FLIP;
}
}
-
+
ptrTileset->u = (short)(CurrentTile % COLUMNS_PER_TILESET) << TILE_SIZE_BIT_SHIFT;
ptrTileset->v = (short)(CurrentTile / COLUMNS_PER_TILESET) * TILE_SIZE_H;
ptrTileset->mx = ptrTileset->u + (TILE_SIZE >> 1);
ptrTileset->my = ptrTileset->v + (TILE_SIZE_H >> 1);
-
+
if (flip_id == true)
{
flip_id = false;
@@ -1704,7 +1704,7 @@ void GameRenderLevel(TYPE_PLAYER* ptrPlayer)
// Serial_printf("Tile %d, attribute 0x%X\n",i,ptrTileset->attribute);
GfxSortSprite(ptrTileset);
-
+
if (ptrTileset->attribute & H_FLIP)
{
ptrTileset->attribute &= ~(H_FLIP);
@@ -1719,18 +1719,18 @@ void GameRenderLevel(TYPE_PLAYER* ptrPlayer)
}
/* *******************************************************************
- *
+ *
* @name: void GameSetTime(uint8_t hour, uint8_t minutes)
- *
+ *
* @author: Xavier Del Campo
- *
+ *
* @brief:
* Reportedly, it sets game time to specified hour and minutes.
- *
- *
+ *
+ *
* @remarks:
* To be used on GameInit() after PLT file parsing.
- *
+ *
* *******************************************************************/
void GameSetTime(uint8_t hour, uint8_t minutes)
@@ -1740,23 +1740,23 @@ void GameSetTime(uint8_t hour, uint8_t minutes)
}
/* *******************************************************************
- *
+ *
* @name: void GameActiveAircraft(uint8_t i)
- *
+ *
* @author: Xavier Del Campo
*
* @param:
* uint8_t i:
* Index from FlightData array.
- *
+ *
* @brief:
* On each game cycle, FlightData.ActiveAircraft is set to 0 and
* number of active aircraft is recalculated.
- *
+ *
* @remarks:
* Called ciclically from GameCalculations(). This function is
* executed GAME_MAX_AIRCRAFT times on each cycle.
- *
+ *
* *******************************************************************/
void GameActiveAircraft(uint8_t i)
@@ -1767,7 +1767,7 @@ void GameActiveAircraft(uint8_t i)
{
FlightData.ActiveAircraft = 0;
}
-
+
if (FlightData.State[i] != STATE_IDLE)
{
FlightData.ActiveAircraft++;
@@ -1775,9 +1775,9 @@ void GameActiveAircraft(uint8_t i)
}
/* ******************************************************************************************
- *
+ *
* @name: void GameStateShowAircraft(TYPE_PLAYER* ptrPlayer, TYPE_FLIGHT_DATA* ptrFlightData)
- *
+ *
* @author: Xavier Del Campo
*
* @param:
@@ -1787,14 +1787,14 @@ void GameActiveAircraft(uint8_t i)
* TYPE_FLIGHT_DATA* ptrFlightData:
* In the end, pointer to FlightData data table, which contains
* information about all available flights.
- *
+ *
* @brief:
* Handles ptrPlayer->ShowAircraftData state.
- *
- *
+ *
+ *
* @remarks:
* Called ciclically from GamePlayerHandler().
- *
+ *
* ******************************************************************************************/
void GameStateShowAircraft(TYPE_PLAYER* ptrPlayer, TYPE_FLIGHT_DATA* ptrFlightData)
@@ -1806,7 +1806,7 @@ void GameStateShowAircraft(TYPE_PLAYER* ptrPlayer, TYPE_FLIGHT_DATA* ptrFlightDa
ptrPlayer->ShowAircraftData = false;
}
}
-
+
if (ptrPlayer->PadKeySinglePress_Callback(PAD_CIRCLE) == true)
{
if (GameGuiShowAircraftDataSpecialConditions(ptrPlayer) == false)
@@ -1818,9 +1818,9 @@ void GameStateShowAircraft(TYPE_PLAYER* ptrPlayer, TYPE_FLIGHT_DATA* ptrFlightDa
}
/* ******************************************************************************************
- *
+ *
* @name: void GameStateLockTarget(TYPE_PLAYER* ptrPlayer, TYPE_FLIGHT_DATA* ptrFlightData)
- *
+ *
* @author: Xavier Del Campo
*
* @param:
@@ -1830,20 +1830,20 @@ void GameStateShowAircraft(TYPE_PLAYER* ptrPlayer, TYPE_FLIGHT_DATA* ptrFlightDa
* TYPE_FLIGHT_DATA* ptrFlightData:
* In the end, pointer to FlightData data table, which contains
* information about all available flights.
- *
+ *
* @brief:
* Handles ptrPlayer->LockTarget state.
- *
- *
+ *
+ *
* @remarks:
* Called ciclically from GamePlayerHandler().
- *
+ *
******************************************************************************************/
void GameStateLockTarget(TYPE_PLAYER* ptrPlayer, TYPE_FLIGHT_DATA* ptrFlightData)
{
uint8_t AircraftIdx = ptrPlayer->FlightDataSelectedAircraft;
-
+
if (ptrPlayer->LockTarget == true)
{
if (ptrPlayer->LockedAircraft != FLIGHT_DATA_INVALID_IDX)
@@ -1851,7 +1851,7 @@ void GameStateLockTarget(TYPE_PLAYER* ptrPlayer, TYPE_FLIGHT_DATA* ptrFlightData
CameraMoveToIsoPos(ptrPlayer, AircraftGetIsoPos(ptrPlayer->LockedAircraft) );
}
}
-
+
if (ptrPlayer->PadKeySinglePress_Callback(PAD_SQUARE) == true)
{
if (ptrPlayer->LockTarget == false)
@@ -1886,9 +1886,9 @@ void GameStateLockTarget(TYPE_PLAYER* ptrPlayer, TYPE_FLIGHT_DATA* ptrFlightData
}
/* ******************************************************************************************
- *
+ *
* @name: void GameStateSelectTaxiwayRunway(TYPE_PLAYER* ptrPlayer, TYPE_FLIGHT_DATA* ptrFlightData)
- *
+ *
* @author: Xavier Del Campo
*
* @param:
@@ -1898,14 +1898,14 @@ void GameStateLockTarget(TYPE_PLAYER* ptrPlayer, TYPE_FLIGHT_DATA* ptrFlightData
* TYPE_FLIGHT_DATA* ptrFlightData:
* In the end, pointer to FlightData data table, which contains
* information about all available flights.
- *
+ *
* @brief:
* Handler for ptrPlayer->SelectTaxiwayRunway.
- *
- *
+ *
+ *
* @remarks:
* Called ciclically from GamePlayerHandler().
- *
+ *
* ******************************************************************************************/
void GameStateSelectTaxiwayRunway(TYPE_PLAYER* ptrPlayer, TYPE_FLIGHT_DATA* ptrFlightData)
@@ -1913,22 +1913,22 @@ void GameStateSelectTaxiwayRunway(TYPE_PLAYER* ptrPlayer, TYPE_FLIGHT_DATA* ptrF
TYPE_ISOMETRIC_POS IsoPos = CameraGetIsoPos(ptrPlayer);
uint8_t i;
uint16_t target_tile;
-
+
/*Serial_printf("Camera is pointing to {%d,%d}\n",IsoPos.x, IsoPos.y);*/
-
+
if (ptrPlayer->SelectTaxiwayRunway == true)
{
// Under this mode, always reset locking target.
ptrPlayer->LockTarget = false;
ptrPlayer->LockedAircraft = FLIGHT_DATA_INVALID_IDX;
-
+
ptrPlayer->SelectedTile = GameGetTileFromIsoPosition(&IsoPos);
-
+
if (GamePathToTile(ptrPlayer, ptrFlightData) == false)
{
ptrPlayer->InvalidPath = true;
}
-
+
if (ptrPlayer->PadKeySinglePress_Callback(PAD_TRIANGLE) == true)
{
// State exit.
@@ -1948,14 +1948,14 @@ void GameStateSelectTaxiwayRunway(TYPE_PLAYER* ptrPlayer, TYPE_FLIGHT_DATA* ptrF
{
break;
}
-
+
ptrPlayer->LastWaypointIdx = i;
}
-
+
target_tile = GameLevelBuffer[ptrPlayer->Waypoints[ptrPlayer->LastWaypointIdx]];
SfxPlaySound(&BeepSnd);
-
+
switch(target_tile)
{
case TILE_RWY_HOLDING_POINT:
@@ -1967,14 +1967,14 @@ void GameStateSelectTaxiwayRunway(TYPE_PLAYER* ptrPlayer, TYPE_FLIGHT_DATA* ptrF
case TILE_RWY_HOLDING_POINT_2 | TILE_MIRROR_FLAG:
AircraftFromFlightDataIndexAddTargets(ptrPlayer->FlightDataSelectedAircraft, ptrPlayer->Waypoints);
Serial_printf("Added these targets to aircraft %d:\n", ptrPlayer->FlightDataSelectedAircraft);
-
+
for (i = 0; i < PLAYER_MAX_WAYPOINTS; i++)
{
Serial_printf("%d ",ptrPlayer->Waypoints[i]);
}
-
+
Serial_printf("\n");
-
+
// Clear waypoints array.
memset(ptrPlayer->Waypoints, 0, sizeof(uint16_t) * PLAYER_MAX_WAYPOINTS);
@@ -1984,11 +1984,11 @@ void GameStateSelectTaxiwayRunway(TYPE_PLAYER* ptrPlayer, TYPE_FLIGHT_DATA* ptrF
ptrPlayer->LockedAircraft = FLIGHT_DATA_INVALID_IDX;
ptrPlayer->LockTarget = false;
ptrPlayer->SelectTaxiwayRunway = false;
-
+
ptrFlightData->State[ptrPlayer->FlightDataSelectedAircraft] = STATE_TAXIING;
GameScore += SCORE_REWARD_TAXIING;
break;
-
+
default:
break;
}
@@ -1998,9 +1998,9 @@ void GameStateSelectTaxiwayRunway(TYPE_PLAYER* ptrPlayer, TYPE_FLIGHT_DATA* ptrF
}
/* **************************************************************************************************
- *
+ *
* @name: void GameStateSelectTaxiwayParking(TYPE_PLAYER* ptrPlayer, TYPE_FLIGHT_DATA* ptrFlightData)
- *
+ *
* @author: Xavier Del Campo
*
* @param:
@@ -2010,12 +2010,12 @@ void GameStateSelectTaxiwayRunway(TYPE_PLAYER* ptrPlayer, TYPE_FLIGHT_DATA* ptrF
* TYPE_FLIGHT_DATA* ptrFlightData:
* In the end, pointer to FlightData data table, which contains
* information about all available flights.
- *
+ *
* @brief:
* Handler for ptrPlayer->SelectTaxiwayParking.
- *
+ *
* @remarks:
- *
+ *
* **************************************************************************************************/
void GameStateSelectTaxiwayParking(TYPE_PLAYER* ptrPlayer, TYPE_FLIGHT_DATA* ptrFlightData)
@@ -2023,20 +2023,20 @@ void GameStateSelectTaxiwayParking(TYPE_PLAYER* ptrPlayer, TYPE_FLIGHT_DATA* ptr
TYPE_ISOMETRIC_POS IsoPos = CameraGetIsoPos(ptrPlayer);
uint8_t i;
uint16_t target_tile;
-
+
if (ptrPlayer->SelectTaxiwayParking == true)
{
// Under this mode, always reset locking target.
ptrPlayer->LockTarget = false;
ptrPlayer->LockedAircraft = FLIGHT_DATA_INVALID_IDX;
-
+
ptrPlayer->SelectedTile = GameGetTileFromIsoPosition(&IsoPos);
-
+
if (GamePathToTile(ptrPlayer, ptrFlightData) == false)
{
ptrPlayer->InvalidPath = true;
}
-
+
if (ptrPlayer->PadKeySinglePress_Callback(PAD_TRIANGLE) == true)
{
// State exit.
@@ -2056,21 +2056,21 @@ void GameStateSelectTaxiwayParking(TYPE_PLAYER* ptrPlayer, TYPE_FLIGHT_DATA* ptr
{
break;
}
-
+
ptrPlayer->LastWaypointIdx = i;
}
-
+
target_tile = GameLevelBuffer[ptrPlayer->Waypoints[ptrPlayer->LastWaypointIdx]];
-
+
Serial_printf("ptrPlayer->LastWaypointIdx = %d\n",
ptrPlayer->LastWaypointIdx);
-
+
Serial_printf("target_tile = %d, TILE_PARKING = %d\n",
target_tile,
TILE_PARKING);
SfxPlaySound(&BeepSnd);
-
+
if ( (target_tile == TILE_PARKING)
||
(target_tile == (TILE_PARKING | TILE_MIRROR_FLAG))
@@ -2081,22 +2081,22 @@ void GameStateSelectTaxiwayParking(TYPE_PLAYER* ptrPlayer, TYPE_FLIGHT_DATA* ptr
{
// TODO: Assign path to aircraft
AircraftFromFlightDataIndexAddTargets(ptrPlayer->FlightDataSelectedAircraft, ptrPlayer->Waypoints);
-
+
Serial_printf("Added these targets to aircraft %d:\n", ptrPlayer->FlightDataSelectedAircraft);
-
+
for (i = 0; i < PLAYER_MAX_WAYPOINTS; i++)
{
Serial_printf("%d ",ptrPlayer->Waypoints[i]);
}
-
+
Serial_printf("\n");
-
+
ptrPlayer->SelectTaxiwayParking = false;
// Clear waypoints array.
memset(ptrPlayer->Waypoints, 0, sizeof(uint16_t) * PLAYER_MAX_WAYPOINTS);
ptrPlayer->WaypointIdx = 0;
ptrPlayer->LastWaypointIdx = 0;
-
+
ptrFlightData->State[ptrPlayer->FlightDataSelectedAircraft] = STATE_TAXIING;
GameScore += SCORE_REWARD_TAXIING;
}
@@ -2106,9 +2106,9 @@ void GameStateSelectTaxiwayParking(TYPE_PLAYER* ptrPlayer, TYPE_FLIGHT_DATA* ptr
}
/* **************************************************************************************************
- *
+ *
* @name: void GameStateSelectRunway(TYPE_PLAYER* ptrPlayer, TYPE_FLIGHT_DATA* ptrFlightData)
- *
+ *
* @author: Xavier Del Campo
*
* @param:
@@ -2118,32 +2118,32 @@ void GameStateSelectTaxiwayParking(TYPE_PLAYER* ptrPlayer, TYPE_FLIGHT_DATA* ptr
* TYPE_FLIGHT_DATA* ptrFlightData:
* In the end, pointer to FlightData data table, which contains
* information about all available flights.
- *
+ *
* @brief:
* Handler for ptrPlayer->SelectRunway.
- *
+ *
* @remarks:
- *
+ *
* **************************************************************************************************/
void GameStateSelectRunway(TYPE_PLAYER* ptrPlayer, TYPE_FLIGHT_DATA* ptrFlightData)
-{
+{
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 = FLIGHT_DATA_INVALID_IDX;
GameGetSelectedRunwayArray(GameRwy[ptrPlayer->SelectedRunway], ptrPlayer->RwyArray, sizeof(ptrPlayer->RwyArray));
-
+
CameraMoveToIsoPos(ptrPlayer, IsoPos);
-
+
if (ptrPlayer->PadKeySinglePress_Callback(PAD_TRIANGLE) == true)
{
ptrPlayer->SelectRunway = false;
@@ -2156,9 +2156,9 @@ void GameStateSelectRunway(TYPE_PLAYER* ptrPlayer, TYPE_FLIGHT_DATA* ptrFlightDa
{
ptrPlayer->SelectRunway = false;
Serial_printf("Player selected runway %d!\n",GameRwy[ptrPlayer->SelectedRunway]);
-
+
success = false;
-
+
for (i = 0; i < GAME_MAX_RUNWAYS; i++)
{
if (GameUsedRwy[i] == 0)
@@ -2169,7 +2169,7 @@ void GameStateSelectRunway(TYPE_PLAYER* ptrPlayer, TYPE_FLIGHT_DATA* ptrFlightDa
break;
}
}
-
+
if (success == false)
{
Serial_printf("No available runways!\n");
@@ -2203,25 +2203,25 @@ void GameStateSelectRunway(TYPE_PLAYER* ptrPlayer, TYPE_FLIGHT_DATA* ptrFlightDa
}
/* **************************************************************************************************
- *
+ *
* @name: void GameGetRunwayArray(void)
- *
+ *
* @author: Xavier Del Campo
*
- *
+ *
* @brief:
* On startup, an array of runway headers is created from GameLevelBuffer once *.LVL is parsed.
- *
+ *
* @remarks:
* Do not confuse GameRwy with GameRwyArray, which are used for completely different purposes.
- *
+ *
* **************************************************************************************************/
void GameGetRunwayArray(void)
{
uint8_t i;
uint8_t j = 0;
-
+
for (i = 0; i < GameLevelSize; i++)
{
if (GameLevelBuffer[i] == TILE_RWY_START_1)
@@ -2232,26 +2232,26 @@ void GameGetRunwayArray(void)
}
}
}
-
+
Serial_printf("GameRwy = ");
-
+
for (i = 0; i < GAME_MAX_RUNWAYS; i++)
{
if (GameRwy[i] == 0)
{
break;
}
-
+
Serial_printf("%d ", GameRwy[i]);
}
-
+
Serial_printf("\n");
}
/* **************************************************************************************************
- *
+ *
* @name: void GameSelectAircraftFromList(TYPE_PLAYER* ptrPlayer, TYPE_FLIGHT_DATA* ptrFlightData)
- *
+ *
* @author: Xavier Del Campo
*
* @param:
@@ -2261,19 +2261,19 @@ void GameGetRunwayArray(void)
* TYPE_FLIGHT_DATA* ptrFlightData:
* In the end, pointer to FlightData data table, which contains
* information about all available flights.
- *
+ *
* @brief:
* Determines actions for aircraft on PAD_CROSS pressed.
- *
+ *
* @remarks:
- *
+ *
* **************************************************************************************************/
void GameSelectAircraftFromList(TYPE_PLAYER* ptrPlayer, TYPE_FLIGHT_DATA* ptrFlightData)
{
uint8_t AircraftIdx = ptrPlayer->FlightDataSelectedAircraft;
FL_STATE aircraftState = ptrFlightData->State[AircraftIdx];
-
+
if (ptrPlayer->ShowAircraftData == true)
{
if (ptrPlayer->PadKeySinglePress_Callback(PAD_CROSS) == true)
@@ -2281,7 +2281,7 @@ void GameSelectAircraftFromList(TYPE_PLAYER* ptrPlayer, TYPE_FLIGHT_DATA* ptrFli
if (ptrPlayer->ActiveAircraft != 0)
{
ptrPlayer->ShowAircraftData = false;
-
+
switch(aircraftState)
{
case STATE_APPROACH:
@@ -2333,7 +2333,7 @@ void GameSelectAircraftFromList(TYPE_PLAYER* ptrPlayer, TYPE_FLIGHT_DATA* ptrFli
ptrPlayer->SelectedRunway = i;
}
break;
-
+
default:
Serial_printf("Incompatible state %d!\n",aircraftState);
// States remain unchanged
@@ -2344,7 +2344,7 @@ void GameSelectAircraftFromList(TYPE_PLAYER* ptrPlayer, TYPE_FLIGHT_DATA* ptrFli
break;
}
}
-
+
Serial_printf("aircraftState = %d\n", aircraftState);
Serial_printf("AircraftIdx = %d\n", AircraftIdx);
}
@@ -2365,9 +2365,9 @@ void GameSelectAircraftFromList(TYPE_PLAYER* ptrPlayer, TYPE_FLIGHT_DATA* ptrFli
}
/* **************************************************************************************************
- *
+ *
* @name: void GameGetSelectedRunwayArray(uint16_t rwyHeader, uint16_t* rwyArray, size_t sz)
- *
+ *
* @author: Xavier Del Campo
*
* @param:
@@ -2382,13 +2382,13 @@ void GameSelectAircraftFromList(TYPE_PLAYER* ptrPlayer, TYPE_FLIGHT_DATA* ptrFli
*
* size_t sz:
* Maximum size of the array.
- *
+ *
* @brief:
* Fills rwyArray with all the tile numbers (included in GameLevelBuffer) belonging to a
* runway with header pointed to by rwyHeader.
- *
+ *
* @remarks:
- *
+ *
* **************************************************************************************************/
void GameGetSelectedRunwayArray(uint16_t rwyHeader, uint16_t* rwyArray, size_t sz)
@@ -2400,7 +2400,7 @@ void GameGetSelectedRunwayArray(uint16_t rwyHeader, uint16_t* rwyArray, size_t s
RWY_DIR_NORTH,
RWY_DIR_SOUTH,
}RWY_DIR;
-
+
static uint16_t last_tile = 0;
static uint8_t i = 0;
static RWY_DIR dir;
@@ -2413,7 +2413,7 @@ void GameGetSelectedRunwayArray(uint16_t rwyHeader, uint16_t* rwyArray, size_t s
(GAME_MAX_RWY_LENGTH * sizeof(uint16_t) ) );
return;
}
-
+
if (rwyHeader != 0)
{
// This function is called recursively.
@@ -2422,18 +2422,18 @@ void GameGetSelectedRunwayArray(uint16_t rwyHeader, uint16_t* rwyArray, size_t s
// when to start creating the array.
// Part one: determine runway direction and call the function again with rwyHeader == 0.
-
+
memset(rwyArray, 0, sz);
last_tile = rwyHeader;
i = 0;
-
+
switch(GameLevelBuffer[rwyHeader])
{
case TILE_RWY_START_1:
- dir = RWY_DIR_EAST;
+ dir = RWY_DIR_EAST;
break;
case TILE_RWY_START_2:
- dir = RWY_DIR_WEST;
+ dir = RWY_DIR_WEST;
break;
case TILE_RWY_START_1 | TILE_MIRROR_FLAG:
dir = RWY_DIR_SOUTH;
@@ -2464,7 +2464,7 @@ void GameGetSelectedRunwayArray(uint16_t rwyHeader, uint16_t* rwyArray, size_t s
}
//DEBUG_PRINT_VAR(i);
-
+
rwyArray[i++] = last_tile;
//DEBUG_PRINT_VAR(rwyArray[i -1]);
@@ -2481,14 +2481,14 @@ void GameGetSelectedRunwayArray(uint16_t rwyHeader, uint16_t* rwyArray, size_t s
case RWY_DIR_SOUTH:
last_tile += GameLevelColumns;
}
-
+
GameGetSelectedRunwayArray(0, rwyArray, sz);
}
/* **************************************************************************************************
- *
+ *
* @name: void GameAssignRunwaytoAircraft(TYPE_PLAYER* ptrPlayer, TYPE_FLIGHT_DATA* ptrFlightData)
- *
+ *
* @author: Xavier Del Campo
*
* @param:
@@ -2498,13 +2498,13 @@ void GameGetSelectedRunwayArray(uint16_t rwyHeader, uint16_t* rwyArray, size_t s
* TYPE_FLIGHT_DATA* ptrFlightData:
* In the end, pointer to FlightData data table, which contains
* information about all available flights.
- *
+ *
* @brief:
* Assigns a runway to an incoming aircraft (FlightDirection == ARRIVAL) depending on
* player selection.
- *
+ *
* @remarks:
- *
+ *
* **************************************************************************************************/
void GameAssignRunwaytoAircraft(TYPE_PLAYER* ptrPlayer, TYPE_FLIGHT_DATA* ptrFlightData)
@@ -2515,47 +2515,47 @@ void GameAssignRunwaytoAircraft(TYPE_PLAYER* ptrPlayer, TYPE_FLIGHT_DATA* ptrFli
uint32_t i;
uint16_t targets[AIRCRAFT_MAX_TARGETS] = {0};
uint8_t rwyTiles[GAME_MAX_RWY_LENGTH] = {0};
-
+
// Remember that ptrPlayer->SelectedAircraft contains an index to
// be used with ptrFlightData.
-
+
Serial_printf("aircraftIndex = %d\n",aircraftIndex);
-
+
if (ptrFlightData->State[aircraftIndex] == STATE_APPROACH)
{
uint16_t rwyArray[GAME_MAX_RWY_LENGTH];
ptrFlightData->State[aircraftIndex] = STATE_FINAL;
GameScore += SCORE_REWARD_FINAL;
-
+
GameGetSelectedRunwayArray(assignedRwy, rwyArray, sizeof(rwyArray));
-
+
for (i = 0; i < GAME_MAX_RWY_LENGTH; i++)
{
rwyTiles[i] = GameLevelBuffer[rwyArray[i]];
}
-
+
i = SystemIndexOf_U8((uint8_t)TILE_RWY_EXIT, rwyTiles, 0, GAME_MAX_RWY_LENGTH);
-
+
if (i == -1)
{
Serial_printf("ERROR: Could not find TILE_RWY_EXIT for runway header %d.\n", assignedRwy);
return;
}
-
+
i = SystemIndexOf_U8((uint8_t)TILE_RWY_EXIT, rwyTiles, i + 1, GAME_MAX_RWY_LENGTH);
-
+
if (i == -1)
{
Serial_printf("ERROR: Could not find second TILE_RWY_EXIT for runway header %d.\n", assignedRwy);
return;
- }
-
+ }
+
rwyExit = rwyArray[i];
-
+
targets[0] = assignedRwy;
targets[1] = rwyExit;
-
+
if ( AircraftAddNew(ptrFlightData,
aircraftIndex,
targets ) == false)
@@ -2572,7 +2572,7 @@ void GameAssignRunwaytoAircraft(TYPE_PLAYER* ptrPlayer, TYPE_FLIGHT_DATA* ptrFli
uint8_t i;
GameGetRunwayEntryTile(aircraftIndex, &rwyEntryData);
-
+
targets[0] = rwyEntryData.rwyEntryTile;
targets[1] = targets[0] + rwyEntryData.rwyStep;
@@ -2588,9 +2588,9 @@ void GameAssignRunwaytoAircraft(TYPE_PLAYER* ptrPlayer, TYPE_FLIGHT_DATA* ptrFli
AircraftAddTargets(AircraftFromFlightDataIndex(aircraftIndex), targets);
ptrFlightData->State[aircraftIndex] = STATE_ENTERING_RWY;
-
+
/*uint16_t i;
-
+
i = rwyEntryData.rwyEntryTile;
@@ -2610,9 +2610,9 @@ void GameAssignRunwaytoAircraft(TYPE_PLAYER* ptrPlayer, TYPE_FLIGHT_DATA* ptrFli
}
/* *******************************************************************
- *
+ *
* @name: short GameGetXFromTile_short(uint16_t tile)
- *
+ *
* @author: Xavier Del Campo
*
* @param:
@@ -2622,29 +2622,29 @@ void GameAssignRunwaytoAircraft(TYPE_PLAYER* ptrPlayer, TYPE_FLIGHT_DATA* ptrFli
* @return:
* Returns relative X position (no fixed-point arithmetic) given
* a tile number from GameLevelBuffer.
- *
+ *
* @remarks:
- *
+ *
* *******************************************************************/
short GameGetXFromTile_short(uint16_t tile)
{
short retVal;
-
+
tile %= GameLevelColumns;
-
+
retVal = (tile << TILE_SIZE_BIT_SHIFT);
-
+
// Always point to tile center
retVal += TILE_SIZE >> 1;
-
+
return retVal;
}
/* *******************************************************************
- *
+ *
* @name: short GameGetYFromTile_short(uint16_t tile)
- *
+ *
* @author: Xavier Del Campo
*
* @param:
@@ -2654,31 +2654,31 @@ short GameGetXFromTile_short(uint16_t tile)
* @return:
* Returns relative Y position (no fixed-point arithmetic) given
* a tile number from GameLevelBuffer.
- *
+ *
* @remarks:
- *
+ *
* *******************************************************************/
short GameGetYFromTile_short(uint16_t tile)
{
short retVal;
-
+
tile /= GameLevelColumns;
-
+
//retVal = (fix16_t)(tile << TILE_SIZE_BIT_SHIFT);
retVal = (tile << TILE_SIZE_BIT_SHIFT);
-
+
// Always point to tile center
//retVal += TILE_SIZE >> 1;
retVal += TILE_SIZE >> 1;
-
+
return retVal;
}
/* *******************************************************************
- *
+ *
* @name: fix16_t GameGetXFromTile(uint16_t tile)
- *
+ *
* @author: Xavier Del Campo
*
* @param:
@@ -2688,9 +2688,9 @@ short GameGetYFromTile_short(uint16_t tile)
* @return:
* Returns relative X position in 16.16 (fix16_t) fixed-point format
* given a tile number from GameLevelBuffer.
- *
+ *
* @remarks:
- *
+ *
* *******************************************************************/
fix16_t GameGetXFromTile(uint16_t tile)
@@ -2699,9 +2699,9 @@ fix16_t GameGetXFromTile(uint16_t tile)
}
/* *******************************************************************
- *
+ *
* @name: fix16_t GameGetYFromTile(uint16_t tile)
- *
+ *
* @author: Xavier Del Campo
*
* @param:
@@ -2711,9 +2711,9 @@ fix16_t GameGetXFromTile(uint16_t tile)
* @return:
* Returns relative Y position in 16.16 (fix16_t) fixed-point format
* given a tile number from GameLevelBuffer.
- *
+ *
* @remarks:
- *
+ *
* *******************************************************************/
fix16_t GameGetYFromTile(uint16_t tile)
@@ -2722,9 +2722,9 @@ fix16_t GameGetYFromTile(uint16_t tile)
}
/* ****************************************************************************
- *
+ *
* @name: FL_STATE GameTargetsReached(uint16_t firstTarget, uint8_t index)
- *
+ *
* @author: Xavier Del Campo
*
* @param:
@@ -2739,16 +2739,16 @@ fix16_t GameGetYFromTile(uint16_t tile)
*
* @return:
* New state for aircraft once waypoints have been reached.
- *
+ *
* @remarks:
- *
+ *
* ****************************************************************************/
FL_STATE GameTargetsReached(uint16_t firstTarget, uint8_t index)
{
FL_STATE retState = STATE_IDLE;
uint8_t i;
-
+
switch(FlightData.State[index])
{
case STATE_FINAL:
@@ -2762,7 +2762,7 @@ FL_STATE GameTargetsReached(uint16_t firstTarget, uint8_t index)
}
}
break;
-
+
case STATE_TAXIING:
if (FlightData.FlightDirection[index] == DEPARTURE)
{
@@ -2781,18 +2781,18 @@ FL_STATE GameTargetsReached(uint16_t firstTarget, uint8_t index)
case STATE_ENTERING_RWY:
FlightData.State[index] = STATE_READY_FOR_TAKEOFF;
break;
-
+
default:
break;
}
-
+
return retState;
}
/* ****************************************************************************
- *
+ *
* @name: uint16_t GameGetTileFromIsoPosition(TYPE_ISOMETRIC_POS* IsoPos)
- *
+ *
* @author: Xavier Del Campo
*
* @param:
@@ -2804,48 +2804,48 @@ FL_STATE GameTargetsReached(uint16_t firstTarget, uint8_t index)
*
* @return:
* Tile number to be used against GameLevelBuffer.
- *
+ *
* @remarks:
* GameLevelColumns is used to determine tile number.
- *
+ *
* ****************************************************************************/
uint16_t GameGetTileFromIsoPosition(TYPE_ISOMETRIC_POS* IsoPos)
{
uint16_t tile;
-
+
if (IsoPos == NULL)
{
return 0;
}
-
+
if ( (IsoPos->x < 0) || (IsoPos->y < 0) )
{
return GAME_INVALID_TILE_SELECTION; // Invalid XYZ position
}
-
+
tile = IsoPos->x >> TILE_SIZE_BIT_SHIFT;
tile += (IsoPos->y >> TILE_SIZE_BIT_SHIFT) * GameLevelColumns;
-
+
/*Serial_printf("Returning tile %d from position {%d, %d, %d}\n",
tile,
IsoPos->x,
IsoPos->y,
IsoPos->z );*/
-
+
return tile;
}
/* ****************************************************************************
- *
+ *
* @name: uint8_t GameGetLevelColumns(void)
- *
+ *
* @author: Xavier Del Campo
*
* @return:
* GameLevelColumns. Used for other modules without declaring GameLevelColumns
* as a global variable.
- *
+ *
* ****************************************************************************/
uint8_t GameGetLevelColumns(void)
@@ -2854,9 +2854,9 @@ uint8_t GameGetLevelColumns(void)
}
/* ****************************************************************************
- *
+ *
* @name: void GamePlayerAddWaypoint(TYPE_PLAYER* ptrPlayer)
- *
+ *
* @author: Xavier Del Campo
*
* @param:
@@ -2865,7 +2865,7 @@ uint8_t GameGetLevelColumns(void)
*
* @brief:
* Wrapper for GamePlayerAddWaypoint_Ex().
- *
+ *
* ****************************************************************************/
void GamePlayerAddWaypoint(TYPE_PLAYER* ptrPlayer)
@@ -2874,15 +2874,15 @@ void GamePlayerAddWaypoint(TYPE_PLAYER* ptrPlayer)
}
/* ****************************************************************************
- *
+ *
* @name: void GamePlayerAddWaypoint(TYPE_PLAYER* ptrPlayer)
- *
+ *
* @author: Xavier Del Campo
*
* @param:
* TYPE_PLAYER* ptrPlayer:
* Pointer to a player structure.
- *
+ *
* uint16_t tile:
* Tile number from GameLevelBuffer.
*
@@ -2891,37 +2891,37 @@ void GamePlayerAddWaypoint(TYPE_PLAYER* ptrPlayer)
*
* @remark:
* To be used together with GamePathToTile().
- *
+ *
* ****************************************************************************/
void GamePlayerAddWaypoint_Ex(TYPE_PLAYER* ptrPlayer, uint16_t tile)
{
// "_Ex" function allow selecting a certain tile, whereas the other one
// is a particulare case of "_Ex" for tile = ptrPlayer->SelectedTIle.
-
+
if (ptrPlayer->WaypointIdx >= PLAYER_MAX_WAYPOINTS)
{
Serial_printf("No available waypoints for this player!\n");
return;
}
-
+
/*Serial_printf("Added tile %d to ptrPlayer->Waypoints[%d]\n",
tile,
ptrPlayer->WaypointIdx);*/
-
+
ptrPlayer->Waypoints[ptrPlayer->WaypointIdx++] = tile;
}
/* **************************************************************************************
- *
+ *
* @name: bool GameWaypointCheckExisting(TYPE_PLAYER* ptrPlayer, uint16_t temp_tile)
- *
+ *
* @author: Xavier Del Campo
*
* @param:
* TYPE_PLAYER* ptrPlayer:
* Pointer to a player structure.
- *
+ *
* uint16_t tile:
* Tile number from GameLevelBuffer.
*
@@ -2930,7 +2930,7 @@ void GamePlayerAddWaypoint_Ex(TYPE_PLAYER* ptrPlayer, uint16_t tile)
*
* @return:
* True if waypoint is already included on waypoint list, false otherwise.
- *
+ *
* **************************************************************************************/
bool GameWaypointCheckExisting(TYPE_PLAYER* ptrPlayer, uint16_t temp_tile)
@@ -2949,7 +2949,7 @@ bool GameWaypointCheckExisting(TYPE_PLAYER* ptrPlayer, uint16_t temp_tile)
}
}
}*/
-
+
GamePlayerAddWaypoint_Ex(ptrPlayer, temp_tile);
return false;
@@ -2960,9 +2960,9 @@ bool GameWaypointCheckExisting(TYPE_PLAYER* ptrPlayer, uint16_t temp_tile)
}
/* ****************************************************************************************
- *
+ *
* @name: bool GamePathToTile(TYPE_PLAYER* ptrPlayer, TYPE_FLIGHT_DATA* ptrFlightData)
- *
+ *
* @author: Xavier Del Campo
*
* @param:
@@ -2978,46 +2978,46 @@ bool GameWaypointCheckExisting(TYPE_PLAYER* ptrPlayer, uint16_t temp_tile)
* it updates current Waypoints array with all tiles between two points.
* If one of these tiles do not belong to desired tiles (i.e.: grass,
* water, buildings...), then false is returned.
- *
+ *
* @return:
* Returns false on invalid path or invalid tile number selected. True otherwise.
- *
+ *
* ****************************************************************************************/
bool GamePathToTile(TYPE_PLAYER* ptrPlayer, TYPE_FLIGHT_DATA* ptrFlightData)
-{
+{
uint8_t AcceptedTiles[] = { TILE_ASPHALT_WITH_BORDERS,
TILE_PARKING, TILE_RWY_MID,
TILE_RWY_EXIT, TILE_TAXIWAY_CORNER_GRASS,
TILE_TAXIWAY_CORNER_GRASS_2, TILE_TAXIWAY_GRASS,
TILE_TAXIWAY_INTERSECT_GRASS,
TILE_RWY_HOLDING_POINT, TILE_RWY_HOLDING_POINT_2 };
-
+
uint8_t i;
uint8_t j;
-
+
uint16_t x_diff;
uint16_t y_diff;
uint16_t temp_tile;
-
+
if (ptrPlayer->SelectedTile == GAME_INVALID_TILE_SELECTION)
{
return false;
}
-
+
for (i = (ptrPlayer->LastWaypointIdx + 1); i < PLAYER_MAX_WAYPOINTS; i++)
{
ptrPlayer->Waypoints[i] = 0;
}
-
+
ptrPlayer->WaypointIdx = ptrPlayer->LastWaypointIdx + 1;
-
+
x_diff = (uint16_t)abs( (ptrPlayer->SelectedTile % GameLevelColumns) -
(ptrPlayer->Waypoints[ptrPlayer->LastWaypointIdx] % GameLevelColumns) );
-
+
y_diff = (uint16_t)abs( (ptrPlayer->SelectedTile / GameLevelColumns) -
(ptrPlayer->Waypoints[ptrPlayer->LastWaypointIdx] / GameLevelColumns) );
-
+
/*Serial_printf("SelectedTile = %d, ptrPlayer->Waypoints[%d] = %d\n",
ptrPlayer->SelectedTile,
0,
@@ -3026,24 +3026,24 @@ bool GamePathToTile(TYPE_PLAYER* ptrPlayer, TYPE_FLIGHT_DATA* ptrFlightData)
Serial_printf("X = abs(%d - %d)\n",
ptrPlayer->SelectedTile % GameLevelColumns,
(ptrPlayer->Waypoints[0] % GameLevelColumns) );
-
+
Serial_printf("Y = abs(%d - %d)\n",
ptrPlayer->SelectedTile / GameLevelColumns,
(ptrPlayer->Waypoints[0] / GameLevelColumns) );
-
+
Serial_printf("Diff = {%d, %d}\n", x_diff, y_diff);*/
-
+
// At this point, we have to update current waypoints list.
// ptrPlayer->Waypoints[ptrPlayer->WaypointIdx - 1] points to the last inserted point,
// so now we have to determine how many points need to be created.
-
+
temp_tile = ptrPlayer->Waypoints[ptrPlayer->LastWaypointIdx];
-
+
if (x_diff >= y_diff)
{
while ( (x_diff--) > 0)
{
- if ( (ptrPlayer->SelectedTile % GameLevelColumns) >
+ if ( (ptrPlayer->SelectedTile % GameLevelColumns) >
(ptrPlayer->Waypoints[ptrPlayer->LastWaypointIdx] % GameLevelColumns) )
{
temp_tile++;
@@ -3052,16 +3052,16 @@ bool GamePathToTile(TYPE_PLAYER* ptrPlayer, TYPE_FLIGHT_DATA* ptrFlightData)
{
temp_tile--;
}
-
+
if (GameWaypointCheckExisting(ptrPlayer, temp_tile) == true)
{
return false; // Tile is already included in the list of temporary tiles?
}
}
-
+
while ( (y_diff--) > 0)
{
- if ( (ptrPlayer->SelectedTile / GameLevelColumns) >
+ if ( (ptrPlayer->SelectedTile / GameLevelColumns) >
(ptrPlayer->Waypoints[ptrPlayer->LastWaypointIdx] / GameLevelColumns) )
{
temp_tile += GameLevelColumns;
@@ -3070,7 +3070,7 @@ bool GamePathToTile(TYPE_PLAYER* ptrPlayer, TYPE_FLIGHT_DATA* ptrFlightData)
{
temp_tile -= GameLevelColumns;
}
-
+
if (GameWaypointCheckExisting(ptrPlayer, temp_tile) == true)
{
return false; // Tile is already included in the list of temporary tiles?
@@ -3078,10 +3078,10 @@ bool GamePathToTile(TYPE_PLAYER* ptrPlayer, TYPE_FLIGHT_DATA* ptrFlightData)
}
}
else
- {
+ {
while ( (y_diff--) > 0)
{
- if ( (ptrPlayer->SelectedTile / GameLevelColumns) >
+ if ( (ptrPlayer->SelectedTile / GameLevelColumns) >
(ptrPlayer->Waypoints[ptrPlayer->LastWaypointIdx] / GameLevelColumns) )
{
temp_tile += GameLevelColumns;
@@ -3096,10 +3096,10 @@ bool GamePathToTile(TYPE_PLAYER* ptrPlayer, TYPE_FLIGHT_DATA* ptrFlightData)
return false; // Tile is already included in the list of temporary tiles?
}
}
-
+
while ( (x_diff--) > 0)
{
- if ( (ptrPlayer->SelectedTile % GameLevelColumns) >
+ if ( (ptrPlayer->SelectedTile % GameLevelColumns) >
(ptrPlayer->Waypoints[ptrPlayer->LastWaypointIdx] % GameLevelColumns) )
{
temp_tile++;
@@ -3108,16 +3108,16 @@ bool GamePathToTile(TYPE_PLAYER* ptrPlayer, TYPE_FLIGHT_DATA* ptrFlightData)
{
temp_tile--;
}
-
+
if (GameWaypointCheckExisting(ptrPlayer, temp_tile) == true)
{
return false; // Tile is already included in the list of temporary tiles?
}
}
}
-
+
// Now at this point, we have prepared our array.
-
+
for (i = 0; i < PLAYER_MAX_WAYPOINTS; i++)
{
if (ptrPlayer->Waypoints[i] == 0)
@@ -3125,18 +3125,18 @@ bool GamePathToTile(TYPE_PLAYER* ptrPlayer, TYPE_FLIGHT_DATA* ptrFlightData)
// We have found empty waypoints. Exit loop
break;
}
-
+
if (SystemContains_u8( GameLevelBuffer[ptrPlayer->Waypoints[i]],
AcceptedTiles,
sizeof(AcceptedTiles) ) == false)
{
// Now try again with mirrored tiles, just in case!
-
+
for (j = 0; j < (sizeof(AcceptedTiles) * sizeof(uint8_t) ); j++)
{
AcceptedTiles[j] |= TILE_MIRROR_FLAG;
}
-
+
if (SystemContains_u8( GameLevelBuffer[ptrPlayer->Waypoints[i]],
AcceptedTiles,
sizeof(AcceptedTiles) ) == false)
@@ -3144,23 +3144,23 @@ bool GamePathToTile(TYPE_PLAYER* ptrPlayer, TYPE_FLIGHT_DATA* ptrFlightData)
// Both cases have failed. Return from function.
return false;
}
-
+
// Reverse mirror flag.
-
+
for (j = 0; j < (sizeof(AcceptedTiles) * sizeof(uint8_t) ); j++)
{
AcceptedTiles[j] &= ~(TILE_MIRROR_FLAG);
}
}
}
-
+
return true;
}
/* ****************************************************************************************
- *
+ *
* @name: TYPE_ISOMETRIC_POS GameSelectAircraft(TYPE_PLAYER* ptrPlayer)
- *
+ *
* @author: Xavier Del Campo
*
* @param:
@@ -3169,26 +3169,26 @@ bool GamePathToTile(TYPE_PLAYER* ptrPlayer, TYPE_FLIGHT_DATA* ptrFlightData)
*
* @brief:
* Moves player camera position to selected aircraft.
- *
+ *
* @return:
* Isometric position of selected aircraft.
- *
+ *
* ****************************************************************************************/
TYPE_ISOMETRIC_POS GameSelectAircraft(TYPE_PLAYER* ptrPlayer)
{
uint8_t AircraftIdx = ptrPlayer->FlightDataSelectedAircraft;
TYPE_ISOMETRIC_POS IsoPos = AircraftGetIsoPos(AircraftIdx);
-
+
CameraMoveToIsoPos(ptrPlayer, IsoPos);
-
+
return IsoPos;
}
/* ********************************************************************************
- *
+ *
* @name: void GameSelectAircraftWaypoint(TYPE_PLAYER* ptrPlayer)
- *
+ *
* @author: Xavier Del Campo
*
* @param:
@@ -3197,28 +3197,28 @@ TYPE_ISOMETRIC_POS GameSelectAircraft(TYPE_PLAYER* ptrPlayer)
*
* @brief:
* Moves player camera to selected aircraft and adds first waypoint.
- *
+ *
* ********************************************************************************/
void GameSelectAircraftWaypoint(TYPE_PLAYER* ptrPlayer)
{
TYPE_ISOMETRIC_POS IsoPos = GameSelectAircraft(ptrPlayer);
-
+
ptrPlayer->SelectedTile = GameGetTileFromIsoPosition(&IsoPos);
-
+
GamePlayerAddWaypoint(ptrPlayer);
}
/* ********************************************************************************
- *
+ *
* @name: bool GameTwoPlayersActive(void)
- *
+ *
* @author: Xavier Del Campo
*
* @return:
* Returns if a second player is active. To be used with other modules without
* declaring TwoPlayersActive as a global variable.
- *
+ *
* ********************************************************************************/
bool GameTwoPlayersActive(void)
@@ -3227,18 +3227,18 @@ bool GameTwoPlayersActive(void)
}
/* *****************************************************************
- *
+ *
* @name: void GameDrawMouse(TYPE_PLAYER* ptrPlayer)
- *
+ *
* @author: Xavier Del Campo
*
* @param:
* TYPE_PLAYER* ptrPlayer:
* Pointer to a player structure
- *
+ *
* @brief:
* Draws GameMouseSpr under determined player states.
- *
+ *
* *****************************************************************/
void GameDrawMouse(TYPE_PLAYER* ptrPlayer)
@@ -3252,9 +3252,9 @@ void GameDrawMouse(TYPE_PLAYER* ptrPlayer)
}
/* ********************************************************************************
- *
+ *
* @name: FL_STATE GameGetFlightDataStateFromIdx(uint8_t FlightDataIdx)
- *
+ *
* @author: Xavier Del Campo
*
* @param:
@@ -3263,7 +3263,7 @@ void GameDrawMouse(TYPE_PLAYER* ptrPlayer)
*
* @return:
* Returns .State variable given offset from FlightData.
- *
+ *
* ********************************************************************************/
FL_STATE GameGetFlightDataStateFromIdx(uint8_t FlightDataIdx)
@@ -3277,14 +3277,14 @@ FL_STATE GameGetFlightDataStateFromIdx(uint8_t FlightDataIdx)
}
/* ********************************************************************************
- *
+ *
* @name: uint32_t GameGetScore(void)
- *
+ *
* @author: Xavier Del Campo
*
* @return:
* Returns game score to other modules.
- *
+ *
* ********************************************************************************/
uint32_t GameGetScore(void)
@@ -3293,9 +3293,9 @@ uint32_t GameGetScore(void)
}
/* *******************************************************************************************
- *
+ *
* @name: void GameStateUnboarding(TYPE_PLAYER* ptrPlayer, TYPE_FLIGHT_DATA* ptrFlightData)
- *
+ *
* @author: Xavier Del Campo
*
* @param:
@@ -3308,7 +3308,7 @@ uint32_t GameGetScore(void)
*
* @brief:
* Handler for StateUnboarding.
- *
+ *
* *******************************************************************************************/
void GameStateUnboarding(TYPE_PLAYER* ptrPlayer, TYPE_FLIGHT_DATA* ptrFlightData)
@@ -3346,7 +3346,7 @@ void GameStateUnboarding(TYPE_PLAYER* ptrPlayer, TYPE_FLIGHT_DATA* ptrFlightData
ptrPlayer->Unboarding = false;
GameRemoveFlight(ptrPlayer->FlightDataSelectedAircraft, true);
}
-
+
ptrPlayer->UnboardingSequenceIdx = 0;
}
@@ -3362,9 +3362,9 @@ void GameStateUnboarding(TYPE_PLAYER* ptrPlayer, TYPE_FLIGHT_DATA* ptrFlightData
}
/* *******************************************************************************************
- *
+ *
* @name: void GameStateUnboarding(TYPE_PLAYER* ptrPlayer, TYPE_FLIGHT_DATA* ptrFlightData)
- *
+ *
* @author: Xavier Del Campo
*
* @param:
@@ -3377,7 +3377,7 @@ void GameStateUnboarding(TYPE_PLAYER* ptrPlayer, TYPE_FLIGHT_DATA* ptrFlightData
*
* @todo:
* Maximum number of sequence keys should be adjusted according to difficulty.
- *
+ *
* *******************************************************************************************/
void GameGenerateUnboardingSequence(TYPE_PLAYER* ptrPlayer)
@@ -3390,12 +3390,12 @@ void GameGenerateUnboardingSequence(TYPE_PLAYER* ptrPlayer)
ptrPlayer->UnboardingSequenceIdx = 0;
Serial_printf("Key sequence generated: ");
-
+
// Only medium level implemented. TODO: Implement other levels
for (i = 0; i < UNBOARDING_KEY_SEQUENCE_MEDIUM; i++)
{
uint8_t randIdx = SystemRand(0, (sizeof(keyTable) / sizeof(keyTable[0])) - 1);
-
+
ptrPlayer->UnboardingSequence[i] = keyTable[randIdx];
Serial_printf("idx = %d, 0x%04X ", randIdx, ptrPlayer->UnboardingSequence[i]);
@@ -3405,9 +3405,9 @@ void GameGenerateUnboardingSequence(TYPE_PLAYER* ptrPlayer)
}
/* *********************************************************************************************************************
- *
+ *
* @name: void GameCreateTakeoffWaypoints(TYPE_PLAYER* ptrPlayer, TYPE_FLIGHT_DATA* ptrFlightData, uint8_t aircraftIdx)
- *
+ *
* @author: Xavier Del Campo
*
* @param:
@@ -3424,7 +3424,7 @@ void GameGenerateUnboardingSequence(TYPE_PLAYER* ptrPlayer)
* @brief:
* Given input aircraft from FlightData, it automatically looks for selected runway and creates an array
* of waypoints to be then executed by corresponding TYPE_AIRCRAFT_DATA instance.
- *
+ *
* *********************************************************************************************************************/
void GameCreateTakeoffWaypoints(TYPE_PLAYER* ptrPlayer, TYPE_FLIGHT_DATA* ptrFlightData, uint8_t aircraftIdx)
@@ -3470,7 +3470,7 @@ void GameCreateTakeoffWaypoints(TYPE_PLAYER* ptrPlayer, TYPE_FLIGHT_DATA* ptrFli
(GameLevelBuffer[currentTile] != TILE_RWY_START_2);
currentTile -= rwyStep )
{
-
+
}
for (i = 0; i < GAME_MAX_RUNWAYS; i++)
@@ -3486,7 +3486,7 @@ void GameCreateTakeoffWaypoints(TYPE_PLAYER* ptrPlayer, TYPE_FLIGHT_DATA* ptrFli
GameLevelBuffer[currentTile] != TILE_RWY_EXIT;
currentTile += rwyStep )
{
-
+
}
targets[0] = currentTile;
@@ -3495,22 +3495,22 @@ void GameCreateTakeoffWaypoints(TYPE_PLAYER* ptrPlayer, TYPE_FLIGHT_DATA* ptrFli
}
/* *******************************************************************************************
- *
+ *
* @name: void GameGetRunwayEntryTile(uint8_t aircraftIdx, TYPE_RWY_ENTRY_DATA* ptrRwyEntry)
- *
+ *
* @author: Xavier Del Campo
*
* @param:
- *
+ *
* uint8_t aircraftIdx:
* Index from FlightData. Used to determine target tile.
- *
+ *
* TYPE_RWY_ENTRY_DATA* ptrRwyEntry:
* Instance to be filled with runway data.
*
* @brief:
* Fills a TYPE_RWY_ENTRY_DATA instance with information about runway.
- *
+ *
* *******************************************************************************************/
void GameGetRunwayEntryTile(uint8_t aircraftIdx, TYPE_RWY_ENTRY_DATA* ptrRwyEntry)
@@ -3583,19 +3583,19 @@ void GameGetRunwayEntryTile(uint8_t aircraftIdx, TYPE_RWY_ENTRY_DATA* ptrRwyEntr
}
/* *******************************************************************************************
- *
+ *
* @name: bool GameInsideLevelFromIsoPos(TYPE_ISOMETRIC_FIX16_POS* ptrIsoPos)
- *
+ *
* @author: Xavier Del Campo
*
* @param:
- *
+ *
* TYPE_ISOMETRIC_FIX16_POS* ptrIsoPos:
* (x, y, z) coordinate data in an isometric system.
*
* @return:
* Returns true if a (x, y, z) coordinate is inside level coordinates. False otherwise.
- *
+ *
* *******************************************************************************************/
bool GameInsideLevelFromIsoPos(TYPE_ISOMETRIC_FIX16_POS* ptrIsoPos)
@@ -3627,13 +3627,13 @@ bool GameInsideLevelFromIsoPos(TYPE_ISOMETRIC_FIX16_POS* ptrIsoPos)
}
/* *******************************************************************************************
- *
+ *
* @name: void GameRemoveFlight(uint8_t idx, bool successful)
- *
+ *
* @author: Xavier Del Campo
*
* @param:
- *
+ *
* uint8_t idx:
* Index from FlightData.
*
@@ -3645,7 +3645,7 @@ bool GameInsideLevelFromIsoPos(TYPE_ISOMETRIC_FIX16_POS* ptrIsoPos)
*
* @remarks:
* GameScore is updated here depending on player actions.
- *
+ *
* *******************************************************************************************/
void GameRemoveFlight(uint8_t idx, bool successful)
@@ -3760,13 +3760,13 @@ void GameRemoveFlight(uint8_t idx, bool successful)
}
/* *******************************************************************************************
- *
+ *
* @name: void GameActiveAircraftList(TYPE_PLAYER* ptrPlayer, TYPE_FLIGHT_DATA* ptrFlightData)
- *
+ *
* @author: Xavier Del Campo
*
* @param:
- *
+ *
* TYPE_PLAYER* ptrPlayer:
* Pointer to a player structure
*
@@ -3786,15 +3786,15 @@ void GameActiveAircraftList(TYPE_PLAYER* ptrPlayer, TYPE_FLIGHT_DATA* ptrFlightD
uint8_t currentFlightDataIdx;
uint8_t lastFlightDataIdx;
-
+
// Clear all pointers for aircraft data first.
// Then, rebuild aircraft list for player.
-
+
lastFlightDataIdx = ptrPlayer->ActiveAircraftList[ptrPlayer->SelectedAircraft];
memset(ptrPlayer->ActiveAircraftList, 0, GAME_MAX_AIRCRAFT);
ptrPlayer->ActiveAircraft = 0;
-
+
for (i = 0; i < FlightData.nAircraft; i++)
{
if ( (ptrFlightData->State[i] != STATE_IDLE)
@@ -3818,7 +3818,7 @@ void GameActiveAircraftList(TYPE_PLAYER* ptrPlayer, TYPE_FLIGHT_DATA* ptrFlightD
currentFlightDataIdx,
lastFlightDataIdx );
if (currentFlightDataIdx != lastFlightDataIdx)
- {
+ {
for (ptrPlayer->SelectedAircraft = 0; ptrPlayer->SelectedAircraft < FlightData.nAircraft; ptrPlayer->SelectedAircraft++)
{
if (ptrPlayer->ActiveAircraftList[ptrPlayer->SelectedAircraft] == lastFlightDataIdx)
@@ -3837,13 +3837,13 @@ void GameActiveAircraftList(TYPE_PLAYER* ptrPlayer, TYPE_FLIGHT_DATA* ptrFlightD
}
/* *******************************************************************************************
- *
+ *
* @name: void GameRemainingAircraft(uint8_t i)
- *
+ *
* @author: Xavier Del Campo
*
* @param:
- *
+ *
* uint8_t i:
* Index from FlightData.
*
@@ -3864,7 +3864,7 @@ void GameRemainingAircraft(uint8_t i)
{
FlightData.nRemainingAircraft = FlightData.nAircraft;
}
-
+
if (FlightData.Finished[i] == true)
{
FlightData.nRemainingAircraft--;
@@ -3872,13 +3872,13 @@ void GameRemainingAircraft(uint8_t i)
}
/* *******************************************************************************************
- *
+ *
* @name: void GameFinished(uint8_t i)
- *
+ *
* @author: Xavier Del Campo
*
* @param:
- *
+ *
* uint8_t i:
* Index from FlightData.
*
@@ -3905,13 +3905,13 @@ void GameFinished(uint8_t i)
}
/* *******************************************************************************************
- *
+ *
* @name: void GameMinimumSpawnTimeout(void)
- *
+ *
* @author: Xavier Del Campo
*
* @param:
- *
+ *
* uint8_t i:
* Index from FlightData.
*
@@ -3927,13 +3927,13 @@ void GameMinimumSpawnTimeout(void)
}
/* *******************************************************************************************
- *
+ *
* @name: void GameAircraftCollision(uint8_t AircraftIdx)
- *
+ *
* @author: Xavier Del Campo
*
* @param:
- *
+ *
* uint8_t AircraftIdx:
* Index from FlightData.
*
diff --git a/Source/GameGui.c b/Source/GameGui.c
index a4355a2..6ec89f2 100644
--- a/Source/GameGui.c
+++ b/Source/GameGui.c
@@ -12,7 +12,7 @@
/* *************************************
* Defines
* *************************************/
-
+
#define GAME_GUI_AIRCRAFT_DATA_MAX_PAGE 4
#define SLOW_SCORE_LOW_SPEED_MARGIN 100
@@ -29,7 +29,7 @@ enum
BUBBLE_SPRITE_Y = 32,
BUBBLE_SPRITE_RAND_MIN = -3,
BUBBLE_SPRITE_RAND_MAX = 3,
-
+
NOTIFICATION_BUTTON_X = BUBBLE_SPRITE_X + 24,
NOTIFICATION_BUTTON_Y = BUBBLE_SPRITE_Y + 16
};
@@ -40,32 +40,32 @@ enum
AIRCRAFT_DATA_GSGPOLY4_R1 = AIRCRAFT_DATA_GSGPOLY4_R0,
AIRCRAFT_DATA_GSGPOLY4_R2 = 0,
AIRCRAFT_DATA_GSGPOLY4_R3 = AIRCRAFT_DATA_GSGPOLY4_R2,
-
+
AIRCRAFT_DATA_GSGPOLY4_G0 = NORMAL_LUMINANCE,
AIRCRAFT_DATA_GSGPOLY4_G1 = AIRCRAFT_DATA_GSGPOLY4_G0,
AIRCRAFT_DATA_GSGPOLY4_G2 = 0,
AIRCRAFT_DATA_GSGPOLY4_G3 = AIRCRAFT_DATA_GSGPOLY4_G2,
-
+
AIRCRAFT_DATA_GSGPOLY4_B0 = 40,
AIRCRAFT_DATA_GSGPOLY4_B1 = AIRCRAFT_DATA_GSGPOLY4_B0,
AIRCRAFT_DATA_GSGPOLY4_B2 = 0,
AIRCRAFT_DATA_GSGPOLY4_B3 = AIRCRAFT_DATA_GSGPOLY4_B2,
-
+
AIRCRAFT_DATA_GSGPOLY4_X0 = (X_SCREEN_RESOLUTION >> 1) - 88,
AIRCRAFT_DATA_GSGPOLY4_X1 = (X_SCREEN_RESOLUTION >> 1) + 88,
AIRCRAFT_DATA_GSGPOLY4_X2 = AIRCRAFT_DATA_GSGPOLY4_X0,
AIRCRAFT_DATA_GSGPOLY4_X3 = AIRCRAFT_DATA_GSGPOLY4_X1,
-
+
AIRCRAFT_DATA_GSGPOLY4_Y0 = (Y_SCREEN_RESOLUTION >> 1) - 96,
AIRCRAFT_DATA_GSGPOLY4_Y1 = AIRCRAFT_DATA_GSGPOLY4_Y0,
AIRCRAFT_DATA_GSGPOLY4_Y2 = (Y_SCREEN_RESOLUTION >> 1) + 96,
AIRCRAFT_DATA_GSGPOLY4_Y3 = AIRCRAFT_DATA_GSGPOLY4_Y2,
-
+
AIRCRAFT_DATA_GSGPOLY4_X0_2PLAYER = 24,
AIRCRAFT_DATA_GSGPOLY4_X1_2PLAYER = 168,
AIRCRAFT_DATA_GSGPOLY4_X2_2PLAYER = AIRCRAFT_DATA_GSGPOLY4_X0_2PLAYER,
AIRCRAFT_DATA_GSGPOLY4_X3_2PLAYER = AIRCRAFT_DATA_GSGPOLY4_X1_2PLAYER,
-
+
AIRCRAFT_DATA_GSGPOLY4_Y0_2PLAYER = 24,
AIRCRAFT_DATA_GSGPOLY4_Y1_2PLAYER = AIRCRAFT_DATA_GSGPOLY4_Y0_2PLAYER,
AIRCRAFT_DATA_GSGPOLY4_Y2_2PLAYER = 208,
@@ -86,34 +86,34 @@ enum
AIRCRAFT_DATA_FLIGHT_GSGPOLY4_R1 = AIRCRAFT_DATA_FLIGHT_GSGPOLY4_R0,
AIRCRAFT_DATA_FLIGHT_GSGPOLY4_R2 = 0,
AIRCRAFT_DATA_FLIGHT_GSGPOLY4_R3 = AIRCRAFT_DATA_FLIGHT_GSGPOLY4_R2,
-
+
AIRCRAFT_DATA_FLIGHT_GSGPOLY4_G0 = NORMAL_LUMINANCE,
AIRCRAFT_DATA_FLIGHT_GSGPOLY4_G1 = AIRCRAFT_DATA_FLIGHT_GSGPOLY4_G0,
AIRCRAFT_DATA_FLIGHT_GSGPOLY4_G2 = 0,
AIRCRAFT_DATA_FLIGHT_GSGPOLY4_G3 = AIRCRAFT_DATA_FLIGHT_GSGPOLY4_G2,
-
+
AIRCRAFT_DATA_FLIGHT_GSGPOLY4_B0 = NORMAL_LUMINANCE,
AIRCRAFT_DATA_FLIGHT_GSGPOLY4_B1 = AIRCRAFT_DATA_FLIGHT_GSGPOLY4_B0,
AIRCRAFT_DATA_FLIGHT_GSGPOLY4_B2 = 0,
AIRCRAFT_DATA_FLIGHT_GSGPOLY4_B3 = AIRCRAFT_DATA_FLIGHT_GSGPOLY4_B2,
-
+
AIRCRAFT_DATA_FLIGHT_GSGPOLY4_GAP = 8,
AIRCRAFT_DATA_FLIGHT_GSGPOLY4_X0 = AIRCRAFT_DATA_GSGPOLY4_X0 + 24,
AIRCRAFT_DATA_FLIGHT_GSGPOLY4_X1 = AIRCRAFT_DATA_GSGPOLY4_X1 - 24,
AIRCRAFT_DATA_FLIGHT_GSGPOLY4_X2 = AIRCRAFT_DATA_FLIGHT_GSGPOLY4_X0,
AIRCRAFT_DATA_FLIGHT_GSGPOLY4_X3 = AIRCRAFT_DATA_FLIGHT_GSGPOLY4_X1,
-
+
AIRCRAFT_DATA_FLIGHT_GSGPOLY4_H = 42,
AIRCRAFT_DATA_FLIGHT_GSGPOLY4_Y0 = AIRCRAFT_DATA_GSGPOLY4_Y0 + AIRCRAFT_DATA_FLIGHT_GSGPOLY4_GAP,
AIRCRAFT_DATA_FLIGHT_GSGPOLY4_Y1 = AIRCRAFT_DATA_FLIGHT_GSGPOLY4_Y0,
AIRCRAFT_DATA_FLIGHT_GSGPOLY4_Y2 = AIRCRAFT_DATA_FLIGHT_GSGPOLY4_Y0 + AIRCRAFT_DATA_FLIGHT_GSGPOLY4_H,
AIRCRAFT_DATA_FLIGHT_GSGPOLY4_Y3 = AIRCRAFT_DATA_FLIGHT_GSGPOLY4_Y2,
-
+
AIRCRAFT_DATA_FLIGHT_GSGPOLY4_X0_2PLAYER = AIRCRAFT_DATA_GSGPOLY4_X0_2PLAYER + AIRCRAFT_DATA_FLIGHT_GSGPOLY4_GAP,
AIRCRAFT_DATA_FLIGHT_GSGPOLY4_X1_2PLAYER = AIRCRAFT_DATA_GSGPOLY4_X1_2PLAYER - AIRCRAFT_DATA_FLIGHT_GSGPOLY4_GAP,
AIRCRAFT_DATA_FLIGHT_GSGPOLY4_X2_2PLAYER = AIRCRAFT_DATA_FLIGHT_GSGPOLY4_X0_2PLAYER,
AIRCRAFT_DATA_FLIGHT_GSGPOLY4_X3_2PLAYER = AIRCRAFT_DATA_FLIGHT_GSGPOLY4_X1_2PLAYER,
-
+
AIRCRAFT_DATA_FLIGHT_GSGPOLY4_Y0_2PLAYER = AIRCRAFT_DATA_GSGPOLY4_Y0_2PLAYER + AIRCRAFT_DATA_FLIGHT_GSGPOLY4_GAP,
AIRCRAFT_DATA_FLIGHT_GSGPOLY4_Y1_2PLAYER = AIRCRAFT_DATA_FLIGHT_GSGPOLY4_Y0_2PLAYER,
AIRCRAFT_DATA_FLIGHT_GSGPOLY4_Y2_2PLAYER = AIRCRAFT_DATA_FLIGHT_GSGPOLY4_Y0_2PLAYER + AIRCRAFT_DATA_FLIGHT_GSGPOLY4_H,
@@ -124,19 +124,19 @@ enum
{
AIRCRAFT_DATA_FLIGHT_NUMBER_TEXT_X = AIRCRAFT_DATA_FLIGHT_GSGPOLY4_X0 + AIRCRAFT_DATA_FLIGHT_GSGPOLY4_GAP,
AIRCRAFT_DATA_FLIGHT_NUMBER_TEXT_Y = AIRCRAFT_DATA_FLIGHT_GSGPOLY4_Y0 + AIRCRAFT_DATA_FLIGHT_GSGPOLY4_GAP,
-
+
AIRCRAFT_DATA_FLIGHT_NUMBER_TEXT_X_2PLAYER = AIRCRAFT_DATA_FLIGHT_GSGPOLY4_X0_2PLAYER + AIRCRAFT_DATA_FLIGHT_GSGPOLY4_GAP,
AIRCRAFT_DATA_FLIGHT_NUMBER_TEXT_Y_2PLAYER = AIRCRAFT_DATA_FLIGHT_GSGPOLY4_Y0_2PLAYER + AIRCRAFT_DATA_FLIGHT_GSGPOLY4_GAP,
-
+
AIRCRAFT_DATA_DIRECTION_X = AIRCRAFT_DATA_FLIGHT_NUMBER_TEXT_X,
AIRCRAFT_DATA_DIRECTION_Y = AIRCRAFT_DATA_FLIGHT_NUMBER_TEXT_Y + AIRCRAFT_DATA_FLIGHT_GSGPOLY4_GAP,
-
+
AIRCRAFT_DATA_DIRECTION_X_2PLAYER = AIRCRAFT_DATA_FLIGHT_NUMBER_TEXT_X_2PLAYER,
AIRCRAFT_DATA_DIRECTION_Y_2PLAYER = AIRCRAFT_DATA_FLIGHT_NUMBER_TEXT_Y_2PLAYER + AIRCRAFT_DATA_FLIGHT_GSGPOLY4_GAP,
-
+
AIRCRAFT_DATA_PASSENGERS_X = AIRCRAFT_DATA_FLIGHT_NUMBER_TEXT_X + 64,
AIRCRAFT_DATA_PASSENGERS_Y = AIRCRAFT_DATA_FLIGHT_NUMBER_TEXT_Y,
-
+
AIRCRAFT_DATA_PASSENGERS_X_2PLAYER = AIRCRAFT_DATA_FLIGHT_NUMBER_TEXT_X_2PLAYER + 64,
AIRCRAFT_DATA_PASSENGERS_Y_2PLAYER = AIRCRAFT_DATA_FLIGHT_NUMBER_TEXT_Y_2PLAYER,
@@ -161,7 +161,7 @@ enum
AIRCRAFT_DATA_FLIGHT_PAGE_DOWN_X_2PLAYER = 48,
AIRCRAFT_DATA_FLIGHT_PAGE_DOWN_Y_2PLAYER = 112,
-
+
AIRCRAFT_DATA_FLIGHT_PAGE_UP_X = 260,
AIRCRAFT_DATA_FLIGHT_PAGE_UP_Y = AIRCRAFT_DATA_FLIGHT_PAGE_DOWN_Y,
@@ -210,7 +210,7 @@ static char* GameFileList[] = { "cdrom:\\DATA\\SPRITES\\BUBBLE.TIM;1" ,
"cdrom:\\DATA\\FONTS\\FONT_1.FNT;1" ,
"cdrom:\\DATA\\SPRITES\\DEPARR.TIM;1" ,
"cdrom:\\DATA\\SPRITES\\PAGEUPDN.TIM;1" };
-
+
static void* GameFileDest[] = {(GsSprite*)&BubbleSpr ,
(TYPE_FONT*)&RadioFont ,
(GsSprite*)&DepArrSpr ,
@@ -226,17 +226,17 @@ void GameGuiInit(void)
PAUSE_DIALOG_Y = 28,
PAUSE_DIALOG_W = 200,
PAUSE_DIALOG_H = 184,
-
+
PAUSE_DIALOG_R0 = 0,
PAUSE_DIALOG_R1 = PAUSE_DIALOG_R0,
PAUSE_DIALOG_R2 = 0,
PAUSE_DIALOG_R3 = PAUSE_DIALOG_R2,
-
+
PAUSE_DIALOG_G0 = NORMAL_LUMINANCE,
PAUSE_DIALOG_G1 = PAUSE_DIALOG_G0,
PAUSE_DIALOG_G2 = 0,
PAUSE_DIALOG_G3 = PAUSE_DIALOG_G2,
-
+
PAUSE_DIALOG_B0 = 40,
PAUSE_DIALOG_B1 = PAUSE_DIALOG_B0,
PAUSE_DIALOG_B2 = 0,
@@ -259,32 +259,32 @@ void GameGuiInit(void)
sizeof(GameFileList) / sizeof(char*),
sizeof(GameFileDest) /sizeof(void*) );
}
-
+
PauseRect.x[0] = PAUSE_DIALOG_X;
PauseRect.x[1] = PAUSE_DIALOG_X + PAUSE_DIALOG_W;
PauseRect.x[2] = PAUSE_DIALOG_X;
PauseRect.x[3] = PAUSE_DIALOG_X + PAUSE_DIALOG_W;
-
+
PauseRect.y[0] = PAUSE_DIALOG_Y;
PauseRect.y[1] = PAUSE_DIALOG_Y;
PauseRect.y[2] = PAUSE_DIALOG_Y + PAUSE_DIALOG_H;
PauseRect.y[3] = PAUSE_DIALOG_Y + PAUSE_DIALOG_H;
-
+
PauseRect.r[0] = PAUSE_DIALOG_R0;
PauseRect.r[1] = PAUSE_DIALOG_R1;
PauseRect.r[2] = PAUSE_DIALOG_R2;
PauseRect.r[3] = PAUSE_DIALOG_R3;
-
+
PauseRect.b[0] = PAUSE_DIALOG_B0;
PauseRect.b[1] = PAUSE_DIALOG_B1;
PauseRect.b[2] = PAUSE_DIALOG_B2;
PauseRect.b[3] = PAUSE_DIALOG_B3;
-
+
PauseRect.g[0] = PAUSE_DIALOG_G0;
PauseRect.g[1] = PAUSE_DIALOG_G1;
PauseRect.g[2] = PAUSE_DIALOG_G2;
PauseRect.g[3] = PAUSE_DIALOG_G3;
-
+
PauseRect.attribute |= ENABLE_TRANS | TRANS_MODE(0);
PageUpDownSpr.w = AIRCRAFT_DATA_FLIGHT_PAGEUPDN_SIZE;
@@ -299,30 +299,30 @@ void GameGuiInit(void)
}
bool GameGuiPauseDialog(TYPE_PLAYER* ptrPlayer)
-{
+{
GfxSaveDisplayData(&SecondDisplay);
-
+
GfxSetGlobalLuminance(NORMAL_LUMINANCE);
-
+
//DrawFBRect(0, 0, X_SCREEN_RESOLUTION, VRAM_H, 0, 0, 0);
-
+
while (GfxIsGPUBusy() == true);
-
+
do
{
if (ptrPlayer->PadKeySinglePress_Callback(PAD_CROSS) == true)
{
return true;
}
-
+
GfxSortSprite(&SecondDisplay);
-
+
GsSortGPoly4(&PauseRect);
-
+
GfxDrawScene_Slow();
-
+
}while (ptrPlayer->PadKeySinglePress_Callback(PAD_START) == false);
-
+
return false;
}
@@ -348,7 +348,7 @@ void GameGuiActiveAircraftPage(TYPE_PLAYER* ptrPlayer, TYPE_FLIGHT_DATA* ptrFlig
{
ptrPlayer->FlightDataPage++;
}
-
+
if (ptrPlayer->ShowAircraftData == true)
{
if (ptrPlayer->PadKeySinglePress_Callback(PAD_DOWN) == true)
@@ -360,7 +360,7 @@ void GameGuiActiveAircraftPage(TYPE_PLAYER* ptrPlayer, TYPE_FLIGHT_DATA* ptrFlig
ptrPlayer->SelectedAircraft++;
}
}
-
+
if (ptrPlayer->PadKeySinglePress_Callback(PAD_UP) == true)
{
if (ptrPlayer->SelectedAircraft > ( (ptrPlayer->FlightDataPage) * GAME_GUI_AIRCRAFT_DATA_MAX_PAGE) )
@@ -368,7 +368,7 @@ void GameGuiActiveAircraftPage(TYPE_PLAYER* ptrPlayer, TYPE_FLIGHT_DATA* ptrFlig
ptrPlayer->SelectedAircraft--;
}
}
-
+
if (ptrPlayer->PadKeySinglePress_Callback(PAD_RIGHT) == true)
{
if (ptrPlayer->ActiveAircraft > (GAME_GUI_AIRCRAFT_DATA_MAX_PAGE * (ptrPlayer->FlightDataPage + 1) ) )
@@ -378,7 +378,7 @@ void GameGuiActiveAircraftPage(TYPE_PLAYER* ptrPlayer, TYPE_FLIGHT_DATA* ptrFlig
Serial_printf("Selected Aircraft = %d\n",ptrPlayer->SelectedAircraft);
}
}
-
+
if (ptrPlayer->PadKeySinglePress_Callback(PAD_LEFT) == true)
{
if (ptrPlayer->FlightDataPage != 0)
@@ -412,7 +412,7 @@ void GameGuiAircraftList(TYPE_PLAYER* ptrPlayer, TYPE_FLIGHT_DATA* ptrFlightData
AIRCRAFT_STOP_Y = AIRCRAFT_LOCK_TARGET_Y,
AIRCRAFT_STOP_TEXT_Y = AIRCRAFT_STOP_Y + 4
};
-
+
if (ptrPlayer->ShowAircraftData == true)
{
// Prepare RGB data and (X,Y) coordinates for aircraft
@@ -421,26 +421,26 @@ void GameGuiAircraftList(TYPE_PLAYER* ptrPlayer, TYPE_FLIGHT_DATA* ptrFlightData
AircraftDataGPoly4.r[1] = AIRCRAFT_DATA_GSGPOLY4_R1;
AircraftDataGPoly4.r[2] = AIRCRAFT_DATA_GSGPOLY4_R2;
AircraftDataGPoly4.r[3] = AIRCRAFT_DATA_GSGPOLY4_R3;
-
+
AircraftDataGPoly4.g[0] = AIRCRAFT_DATA_GSGPOLY4_G0;
AircraftDataGPoly4.g[1] = AIRCRAFT_DATA_GSGPOLY4_G1;
AircraftDataGPoly4.g[2] = AIRCRAFT_DATA_GSGPOLY4_G2;
AircraftDataGPoly4.g[3] = AIRCRAFT_DATA_GSGPOLY4_G3;
-
+
AircraftDataGPoly4.b[0] = AIRCRAFT_DATA_GSGPOLY4_B0;
AircraftDataGPoly4.b[1] = AIRCRAFT_DATA_GSGPOLY4_B1;
AircraftDataGPoly4.b[2] = AIRCRAFT_DATA_GSGPOLY4_B2;
AircraftDataGPoly4.b[3] = AIRCRAFT_DATA_GSGPOLY4_B3;
-
+
AircraftDataGPoly4.attribute |= ENABLE_TRANS | TRANS_MODE(0);
-
+
if (GameTwoPlayersActive() == true)
{
AircraftDataGPoly4.x[0] = AIRCRAFT_DATA_GSGPOLY4_X0_2PLAYER;
AircraftDataGPoly4.x[1] = AIRCRAFT_DATA_GSGPOLY4_X1_2PLAYER;
AircraftDataGPoly4.x[2] = AIRCRAFT_DATA_GSGPOLY4_X2_2PLAYER;
AircraftDataGPoly4.x[3] = AIRCRAFT_DATA_GSGPOLY4_X3_2PLAYER;
-
+
AircraftDataGPoly4.y[0] = AIRCRAFT_DATA_GSGPOLY4_Y0_2PLAYER;
AircraftDataGPoly4.y[1] = AIRCRAFT_DATA_GSGPOLY4_Y1_2PLAYER;
AircraftDataGPoly4.y[2] = AIRCRAFT_DATA_GSGPOLY4_Y2_2PLAYER;
@@ -452,13 +452,13 @@ void GameGuiAircraftList(TYPE_PLAYER* ptrPlayer, TYPE_FLIGHT_DATA* ptrFlightData
AircraftDataGPoly4.x[1] = AIRCRAFT_DATA_GSGPOLY4_X1;
AircraftDataGPoly4.x[2] = AIRCRAFT_DATA_GSGPOLY4_X2;
AircraftDataGPoly4.x[3] = AIRCRAFT_DATA_GSGPOLY4_X3;
-
+
AircraftDataGPoly4.y[0] = AIRCRAFT_DATA_GSGPOLY4_Y0;
AircraftDataGPoly4.y[1] = AIRCRAFT_DATA_GSGPOLY4_Y1;
AircraftDataGPoly4.y[2] = AIRCRAFT_DATA_GSGPOLY4_Y2;
AircraftDataGPoly4.y[3] = AIRCRAFT_DATA_GSGPOLY4_Y3;
}
-
+
GsSortGPoly4(&AircraftDataGPoly4);
if (GameTwoPlayersActive() == true)
@@ -477,26 +477,26 @@ void GameGuiAircraftList(TYPE_PLAYER* ptrPlayer, TYPE_FLIGHT_DATA* ptrFlightData
"Remaining aircraft: %d",
ptrFlightData->nRemainingAircraft );
}
-
+
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.x[0] = AIRCRAFT_DATA_FLIGHT_GSGPOLY4_X0_2PLAYER;
@@ -505,22 +505,22 @@ void GameGuiAircraftList(TYPE_PLAYER* ptrPlayer, TYPE_FLIGHT_DATA* ptrFlightData
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);
-
+
/*Serial_printf("ptrPlayer->ActiveAircraft = %d\n",ptrPlayer->ActiveAircraft);
Serial_printf("ptrPlayer->SelectedAircraft = %d\n",ptrPlayer->SelectedAircraft);
Serial_printf("ptrPlayer->FlightDataPage = %d\n",ptrPlayer->FlightDataPage);
Serial_printf("y_offset = %d\n",y_offset);*/
-
+
if (GameTwoPlayersActive() == true)
{
SelectedAircraftGPoly4.y[0] = AIRCRAFT_DATA_FLIGHT_GSGPOLY4_Y0_2PLAYER;
@@ -535,22 +535,22 @@ void GameGuiAircraftList(TYPE_PLAYER* ptrPlayer, TYPE_FLIGHT_DATA* ptrFlightData
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[1] += y_offset;
SelectedAircraftGPoly4.y[2] += y_offset;
SelectedAircraftGPoly4.y[3] += y_offset;
-
+
GsSortGPoly4(&SelectedAircraftGPoly4);
PageUpDownSpr.attribute |= GFX_2HZ_FLASH;
-
+
if (ptrPlayer->ActiveAircraft > (GAME_GUI_AIRCRAFT_DATA_MAX_PAGE * (ptrPlayer->FlightDataPage + 1) ) )
{
orig_pageupdn_u = PageUpDownSpr.u;
-
+
PageUpDownSpr.u = orig_pageupdn_u + AIRCRAFT_DATA_FLIGHT_PAGE_UP_U;
-
+
if (GameTwoPlayersActive() == true)
{
PageUpDownSpr.x = AIRCRAFT_DATA_FLIGHT_PAGE_UP_X_2PLAYER;
@@ -566,13 +566,13 @@ void GameGuiAircraftList(TYPE_PLAYER* ptrPlayer, TYPE_FLIGHT_DATA* ptrFlightData
PageUpDownSpr.u = orig_pageupdn_u;
}
-
+
if (ptrPlayer->FlightDataPage != 0)
{
orig_pageupdn_u = PageUpDownSpr.u;
-
+
PageUpDownSpr.u = orig_pageupdn_u + AIRCRAFT_DATA_FLIGHT_PAGE_DOWN_U;
-
+
if (GameTwoPlayersActive() == true)
{
PageUpDownSpr.x = AIRCRAFT_DATA_FLIGHT_PAGE_DOWN_X_2PLAYER;
@@ -583,16 +583,16 @@ void GameGuiAircraftList(TYPE_PLAYER* ptrPlayer, TYPE_FLIGHT_DATA* ptrFlightData
PageUpDownSpr.x = AIRCRAFT_DATA_FLIGHT_PAGE_DOWN_X;
PageUpDownSpr.y = AIRCRAFT_DATA_FLIGHT_PAGE_DOWN_Y;
}
-
+
GfxSortSprite(&PageUpDownSpr);
PageUpDownSpr.u = orig_pageupdn_u;
}
-
+
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");
@@ -618,7 +618,7 @@ void GameGuiAircraftList(TYPE_PLAYER* ptrPlayer, TYPE_FLIGHT_DATA* ptrFlightData
if (GameTwoPlayersActive() == true)
{
FontPrintText( &SmallFont,
- AIRCRAFT_DATA_GSGPOLY4_X0_2PLAYER +
+ 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),
@@ -627,7 +627,7 @@ void GameGuiAircraftList(TYPE_PLAYER* ptrPlayer, TYPE_FLIGHT_DATA* ptrFlightData
else
{
FontPrintText( &SmallFont,
- AIRCRAFT_DATA_GSGPOLY4_X0 +
+ AIRCRAFT_DATA_GSGPOLY4_X0 +
( (AIRCRAFT_DATA_GSGPOLY4_X1 - AIRCRAFT_DATA_GSGPOLY4_X0) >> 2),
AIRCRAFT_DATA_GSGPOLY4_Y0 +
( (AIRCRAFT_DATA_GSGPOLY4_Y2 - AIRCRAFT_DATA_GSGPOLY4_Y0) >> 1),
@@ -676,10 +676,10 @@ void GameGuiBubble(TYPE_FLIGHT_DATA* ptrFlightData)
TimerRestart(GameGuiBubbleVibrationTimer);
}
}
-
+
BubbleSpr.x = BUBBLE_SPRITE_X;
BubbleSpr.y = BUBBLE_SPRITE_Y;
-
+
if (GameGuiBubbleVibrationFlag == true)
{
BubbleSpr.x += SystemRand(BUBBLE_SPRITE_RAND_MIN,BUBBLE_SPRITE_RAND_MAX);
@@ -689,7 +689,7 @@ void GameGuiBubble(TYPE_FLIGHT_DATA* ptrFlightData)
GfxSortSprite(&BubbleSpr);
FontSetFlags(&SmallFont, FONT_CENTERED);
FontPrintText(&SmallFont,BubbleSpr.x + 8 , BubbleSpr.y + 2, "%d", ptrFlightData->ActiveAircraft);
-
+
GfxDrawButton(NOTIFICATION_BUTTON_X, NOTIFICATION_BUTTON_Y, PAD_CIRCLE);
}
@@ -705,13 +705,13 @@ void GameGuiClock(uint8_t hour, uint8_t min)
};
static char strClock[6]; // HH:MM + \0 (6 characters needed)
-
+
if (GameStartupFlag || System1SecondTick() == true)
{
memset(strClock, 0, 6);
snprintf(strClock,6,"%02d:%02d",hour, min);
}
-
+
RadioFont.max_ch_wrap = 0;
FontSetFlags(&RadioFont, FONT_NOFLAGS);
FontPrintText(&RadioFont,CLOCK_X,CLOCK_Y,strClock);
@@ -754,7 +754,7 @@ void GameGuiShowAircraftData(TYPE_PLAYER* ptrPlayer, TYPE_FLIGHT_DATA* ptrFlight
short AircraftDataRemainingTime_X;
short AircraftDataRemainingTime_Y;
short orig_DepArr_u = DepArrSpr.u;
-
+
if (GameTwoPlayersActive() == true)
{
AircraftDataDirection_X = AIRCRAFT_DATA_DIRECTION_X_2PLAYER;
@@ -779,18 +779,18 @@ void GameGuiShowAircraftData(TYPE_PLAYER* ptrPlayer, TYPE_FLIGHT_DATA* ptrFlight
AircraftDataRemainingTime_X = AIRCRAFT_DATA_REMAINING_TIME_X;
AircraftDataRemainingTime_Y = AIRCRAFT_DATA_REMAINING_TIME_Y;
}
-
+
FontSetFlags(&SmallFont,FONT_NOFLAGS);
-
+
for (i = init_flight ; i < ptrPlayer->ActiveAircraft ; i++)
{
j = i - init_flight;
-
+
if (j >= GAME_GUI_AIRCRAFT_DATA_MAX_PAGE)
{
break;
}
-
+
FontPrintText( &SmallFont,
AircraftDataFlightNumber_X,
AircraftDataFlightNumber_Y + (AIRCRAFT_DATA_FLIGHT_GSGPOLY4_H * j),
@@ -799,7 +799,7 @@ void GameGuiShowAircraftData(TYPE_PLAYER* ptrPlayer, TYPE_FLIGHT_DATA* ptrFlight
DepArrSpr.x = AircraftDataDirection_X;
DepArrSpr.y = AircraftDataDirection_Y + (AIRCRAFT_DATA_FLIGHT_GSGPOLY4_H * j);
DepArrSpr.w = AIRCRAFT_DEPARTURE_ARRIVAL_ICON_SIZE;
-
+
switch(ptrFlightData->FlightDirection[ptrPlayer->ActiveAircraftList[i]])
{
case ARRIVAL:
@@ -816,9 +816,9 @@ void GameGuiShowAircraftData(TYPE_PLAYER* ptrPlayer, TYPE_FLIGHT_DATA* ptrFlight
GfxSortSprite(&DepArrSpr);
DepArrSpr.u = orig_DepArr_u;
-
+
FontSetFlags(&SmallFont, FONT_2HZ_FLASH);
-
+
switch(ptrFlightData->State[ptrPlayer->ActiveAircraftList[i]])
{
case STATE_APPROACH:
@@ -827,28 +827,28 @@ void GameGuiShowAircraftData(TYPE_PLAYER* ptrPlayer, TYPE_FLIGHT_DATA* ptrFlight
AircraftDataDirection_Y + (AIRCRAFT_DATA_FLIGHT_GSGPOLY4_H * j),
"Approach" );
break;
-
+
case STATE_READY_FOR_TAKEOFF:
FontPrintText( &SmallFont,
AircraftDataDirection_X + AircraftDataState_X_Offset,
AircraftDataDirection_Y + (AIRCRAFT_DATA_FLIGHT_GSGPOLY4_H * j),
"Takeoff" );
break;
-
+
case STATE_LANDED:
FontPrintText( &SmallFont,
AircraftDataDirection_X + AircraftDataState_X_Offset,
AircraftDataDirection_Y + (AIRCRAFT_DATA_FLIGHT_GSGPOLY4_H * j),
"Landed" );
break;
-
+
case STATE_PARKED:
FontPrintText( &SmallFont,
AircraftDataDirection_X + AircraftDataState_X_Offset,
AircraftDataDirection_Y + (AIRCRAFT_DATA_FLIGHT_GSGPOLY4_H * j),
"Parked" );
break;
-
+
case STATE_UNBOARDING:
FontPrintText( &SmallFont,
AircraftDataDirection_X + AircraftDataState_X_Offset,
@@ -869,13 +869,13 @@ void GameGuiShowAircraftData(TYPE_PLAYER* ptrPlayer, TYPE_FLIGHT_DATA* ptrFlight
AircraftDataDirection_Y + (AIRCRAFT_DATA_FLIGHT_GSGPOLY4_H * j),
"Stopped" );
break;
-
+
default:
break;
}
-
+
FontSetFlags(&SmallFont, FONT_NOFLAGS);
-
+
/*FontPrintText( &SmallFont,
AircraftDataPassengers_X,
AircraftDataPassengers_Y + (AIRCRAFT_DATA_FLIGHT_GSGPOLY4_H * j),
@@ -893,7 +893,7 @@ void GameGuiShowAircraftData(TYPE_PLAYER* ptrPlayer, TYPE_FLIGHT_DATA* ptrFlight
bool GameGuiShowAircraftDataSpecialConditions(TYPE_PLAYER* ptrPlayer)
{
// Aircraft list data cannot be shown under these conditions.
-
+
if ( (ptrPlayer->SelectRunway == true)
||
(ptrPlayer->SelectTaxiwayParking == true)
@@ -902,7 +902,7 @@ bool GameGuiShowAircraftDataSpecialConditions(TYPE_PLAYER* ptrPlayer)
{
return true;
}
-
+
return false;
}
@@ -977,44 +977,44 @@ void GameGuiClearPassengersLeft(void)
bool GameGuiFinishedDialog(TYPE_PLAYER* ptrPlayer)
{
GfxSaveDisplayData(&SecondDisplay);
-
+
GfxSetGlobalLuminance(NORMAL_LUMINANCE);
-
+
do
{
if (ptrPlayer->PadKeySinglePress_Callback(PAD_CROSS) == true)
{
return true;
}
-
+
GfxSortSprite(&SecondDisplay);
-
+
GsSortGPoly4(&PauseRect);
FontPrintText( &SmallFont,
- AIRCRAFT_DATA_GSGPOLY4_X0 +
+ AIRCRAFT_DATA_GSGPOLY4_X0 +
( (AIRCRAFT_DATA_GSGPOLY4_X1 - AIRCRAFT_DATA_GSGPOLY4_X0) >> 2),
AIRCRAFT_DATA_GSGPOLY4_Y0 +
( (AIRCRAFT_DATA_GSGPOLY4_Y2 - AIRCRAFT_DATA_GSGPOLY4_Y0) >> 1),
"Level finished!" );
-
+
GfxDrawScene_Slow();
-
+
}while (ptrPlayer->PadKeySinglePress_Callback(PAD_START) == false);
-
+
return false;
}
void GameGuiAircraftCollision(TYPE_PLAYER* ptrPlayer)
{
GfxSaveDisplayData(&SecondDisplay);
-
+
GfxSetGlobalLuminance(NORMAL_LUMINANCE);
-
+
do
- {
+ {
GfxSortSprite(&SecondDisplay);
-
+
GsSortGPoly4(&PauseRect);
FontPrintText( &SmallFont,
@@ -1022,9 +1022,9 @@ void GameGuiAircraftCollision(TYPE_PLAYER* ptrPlayer)
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);
}
diff --git a/Source/GameStructures.h b/Source/GameStructures.h
index c7082d8..0b5358f 100644
--- a/Source/GameStructures.h
+++ b/Source/GameStructures.h
@@ -157,7 +157,7 @@ typedef struct
bool LockTarget;
// Player is unboarding passengers
bool Unboarding;
-
+
// Stores indexes for player-specific active aircraft
// Used to relate SelectedAircraft agains FlightData index
uint8_t ActiveAircraftList[GAME_MAX_AIRCRAFT];
@@ -171,7 +171,7 @@ typedef struct
uint8_t SelectedAircraft;
// Aircraft being followed by camera
uint8_t LockedAircraft;
- // Index for GameRwy buffer on "Select runway" mode
+ // Index for GameRwy buffer on "Select runway" mode
uint16_t SelectedRunway;
// Tile pointed to by cursor
uint16_t SelectedTile;
@@ -191,7 +191,7 @@ typedef struct
uint8_t UnboardingSequenceIdx;
// Show passengers left
uint8_t PassengersLeftSelectedAircraft;
-
+
bool (*PadKeyPressed_Callback)(unsigned short);
bool (*PadKeyReleased_Callback)(unsigned short);
bool (*PadKeySinglePress_Callback)(unsigned short);
diff --git a/Source/Gfx.c b/Source/Gfx.c
index a7f8aa6..5110442 100644
--- a/Source/Gfx.c
+++ b/Source/Gfx.c
@@ -27,22 +27,22 @@
enum
{
BUTTON_SIZE = 16,
-
+
BUTTON_CROSS_U = 48,
BUTTON_CROSS_V = 0,
-
+
BUTTON_SQUARE_U = 0,
BUTTON_SQUARE_V = 0,
-
+
BUTTON_TRIANGLE_U = 32,
BUTTON_TRIANGLE_V = 0,
-
+
BUTTON_CIRCLE_U = 16,
BUTTON_CIRCLE_V = 0,
BUTTON_DIRECTION_U = 64,
BUTTON_DIRECTION_V = 0,
-
+
BUTTON_LR_U = 80,
BUTTON_LR_V = 0,
BUTTON_LR_SIZE = 24,
@@ -63,7 +63,7 @@ enum
LETTER_OFFSET_INSIDE_BUTTON_LR_X = 8,
LETTER_OFFSET_INSIDE_BUTTON_LR_Y = 6
-
+
};
enum
@@ -113,7 +113,7 @@ void GfxSwapBuffers(void)
Serial_printf("Linked list iterator overflow!\n");
while (1);
}
-
+
if ( (DrawEnv.h != Y_SCREEN_RESOLUTION)
||
( (DrawEnv.w != X_SCREEN_RESOLUTION)
@@ -146,7 +146,7 @@ void GfxSwapBuffers(void)
DispEnv.y = 0;
DrawEnv.y = DOUBLE_BUFFERING_SWAP_Y;
}
-
+
GsSetDispEnv(&DispEnv);
GsSetDrawEnv(&DrawEnv);
}
@@ -160,7 +160,7 @@ void GfxInitDrawEnv(void)
DrawEnv.draw_on_display = false;
DrawEnv.w = X_SCREEN_RESOLUTION;
DrawEnv.h = Y_SCREEN_RESOLUTION;
-
+
GsSetDrawEnv(&DrawEnv);
}
@@ -168,7 +168,7 @@ void GfxInitDispEnv(void)
{
DispEnv.x = 0;
DispEnv.y = 0;
-
+
GsSetDispEnv(&DispEnv);
}
@@ -200,7 +200,7 @@ void GfxDrawScene_Fast(void)
{
five_hundred_ms_show = five_hundred_ms_show? false:true;
}
-
+
GfxSwapBuffers();
FontCyclic();
GsDrawList();
@@ -213,12 +213,12 @@ bool GfxReadyForDMATransfer(void)
void GfxDrawScene(void)
{
- while ( (SystemRefreshNeeded() == false)
+ while ( (SystemRefreshNeeded() == false)
||
(GfxIsGPUBusy() == true) );
-
+
GfxDrawScene_Fast();
-
+
SystemCyclicHandler();
}
@@ -238,13 +238,13 @@ void GfxSortSprite(GsSprite * spr)
short aux_x = spr->x;
bool has_1hz_flash = spr->attribute & GFX_1HZ_FLASH;
bool has_2hz_flash = spr->attribute & GFX_2HZ_FLASH;
-
+
if ( (spr->w <= 0) || (spr->h <= 0) )
{
// Invalid width or heigth
return;
}
-
+
if (GfxIsSpriteInsideScreenArea(spr) == false)
{
return;
@@ -257,7 +257,7 @@ void GfxSortSprite(GsSprite * spr)
{
return;
}
-
+
if (global_lum != NORMAL_LUMINANCE)
{
if (spr->r < NORMAL_LUMINANCE - global_lum)
@@ -268,7 +268,7 @@ void GfxSortSprite(GsSprite * spr)
{
spr->r -= NORMAL_LUMINANCE - global_lum;
}
-
+
if (spr->g < NORMAL_LUMINANCE - global_lum)
{
spr->g = 0;
@@ -277,7 +277,7 @@ void GfxSortSprite(GsSprite * spr)
{
spr->g -= NORMAL_LUMINANCE - global_lum;
}
-
+
if (spr->b < NORMAL_LUMINANCE - global_lum)
{
spr->b = 0;
@@ -287,17 +287,17 @@ void GfxSortSprite(GsSprite * spr)
spr->b -= NORMAL_LUMINANCE - global_lum;
}
}
-
+
if (has_1hz_flash == true)
{
spr->attribute &= ~(GFX_1HZ_FLASH);
}
-
+
if (spr->w > MAX_SIZE_FOR_GSSPRITE)
{
// GsSprites can't be bigger than 256x256, so since display
// resolution is 384x240, it must be split into two primitives.
-
+
spr->w = MAX_SIZE_FOR_GSSPRITE;
GsSortSprite(spr);
@@ -305,22 +305,22 @@ void GfxSortSprite(GsSprite * spr)
spr->w = X_SCREEN_RESOLUTION - MAX_SIZE_FOR_GSSPRITE;
spr->tpage += MAX_SIZE_FOR_GSSPRITE / GFX_TPAGE_WIDTH;
GsSortSprite(spr);
-
+
// Restore original values after sorting
spr->w = aux_w;
spr->tpage = aux_tpage;
spr->x = aux_x;
}
else
- {
+ {
GsSortSprite(spr);
}
-
+
if (has_1hz_flash == true)
{
spr->attribute |= GFX_1HZ_FLASH;
}
-
+
spr->r = aux_r;
spr->g = aux_g;
spr->b = aux_b;
@@ -337,7 +337,7 @@ void GfxSetGlobalLuminance(uint8_t value)
}
void GfxIncreaseGlobalLuminance(int8_t step)
-{
+{
if ( ( (global_lum + step) < MAX_LUMINANCE )
&&
( (global_lum + step) > 0 ) )
@@ -363,18 +363,18 @@ bool GfxIsGPUBusy(void)
bool GfxSpriteFromFile(char* fname, GsSprite * spr)
{
GsImage gsi;
-
+
if (SystemLoadFile(fname) == false)
{
return false;
}
-
+
while (GfxIsGPUBusy() == true);
-
+
gfx_busy = true;
-
+
GsImageFromTim(&gsi, SystemGetBufferAddress() );
-
+
GsSpriteFromImage(spr, &gsi, UPLOAD_IMAGE_FLAG);
gfx_busy = false;
@@ -384,7 +384,7 @@ bool GfxSpriteFromFile(char* fname, GsSprite * spr)
DEBUG_PRINT_VAR(spr->v);
DEBUG_PRINT_VAR(spr->w);
DEBUG_PRINT_VAR(spr->h);
-
+
return true;
}
@@ -396,23 +396,23 @@ bool GfxCLUTFromFile(char* fname)
{
return false;
}
-
+
while (GfxIsGPUBusy() == true);
-
+
gfx_busy = true;
-
+
GsImageFromTim(&gsi,SystemGetBufferAddress() );
-
+
GsUploadCLUT(&gsi);
-
+
gfx_busy = false;
-
+
return true;
}
bool GfxIsInsideScreenArea(short x, short y, short w, short h)
{
- if ( ( (x + w) >= 0)
+ if ( ( (x + w) >= 0)
&&
(x < DrawEnv.w)
&&
@@ -422,7 +422,7 @@ bool GfxIsInsideScreenArea(short x, short y, short w, short h)
{
return true;
}
-
+
return false;
}
@@ -452,43 +452,43 @@ void GfxDrawButton(short x, short y, unsigned short btn)
static bool first_entered = true;
static short orig_u;
static short orig_v;
-
+
if (first_entered == true)
{
first_entered = false;
orig_u = PSXButtons.u;
orig_v = PSXButtons.v;
}
-
+
PSXButtons.w = BUTTON_SIZE;
PSXButtons.h = BUTTON_SIZE;
-
+
PSXButtons.r = NORMAL_LUMINANCE;
PSXButtons.g = NORMAL_LUMINANCE;
PSXButtons.b = NORMAL_LUMINANCE;
-
+
PSXButtons.x = x;
PSXButtons.y = y;
PSXButtons.mx = PSXButtons.w >> 1;
PSXButtons.my = PSXButtons.h >> 1;
-
+
switch(btn)
{
case PAD_CROSS:
PSXButtons.u = BUTTON_CROSS_U;
PSXButtons.v = BUTTON_CROSS_V;
break;
-
+
case PAD_SQUARE:
PSXButtons.u = BUTTON_SQUARE_U;
PSXButtons.v = BUTTON_SQUARE_V;
break;
-
+
case PAD_TRIANGLE:
PSXButtons.u = BUTTON_TRIANGLE_U;
PSXButtons.v = BUTTON_TRIANGLE_V;
break;
-
+
case PAD_CIRCLE:
PSXButtons.u = BUTTON_CIRCLE_U;
PSXButtons.v = BUTTON_CIRCLE_V;
@@ -498,13 +498,13 @@ void GfxDrawButton(short x, short y, unsigned short btn)
PSXButtons.u = BUTTON_DIRECTION_U;
PSXButtons.v = BUTTON_DIRECTION_V;
break;
-
+
case PAD_UP:
PSXButtons.u = BUTTON_DIRECTION_U;
PSXButtons.v = BUTTON_DIRECTION_V;
PSXButtons.rotate = 90 << ROTATE_BIT_SHIFT;
break;
-
+
case PAD_DOWN:
PSXButtons.u = BUTTON_DIRECTION_U;
PSXButtons.v = BUTTON_DIRECTION_V;
@@ -516,7 +516,7 @@ void GfxDrawButton(short x, short y, unsigned short btn)
PSXButtons.v = BUTTON_DIRECTION_V;
PSXButtons.attribute |= H_FLIP;
break;
-
+
case PAD_L1:
// Fall through
case PAD_L2:
@@ -539,10 +539,10 @@ void GfxDrawButton(short x, short y, unsigned short btn)
PSXButtons.h = 0;
break;
}
-
+
PSXButtons.u += orig_u;
PSXButtons.v += orig_v;
-
+
GfxSortSprite(&PSXButtons);
switch(btn)
@@ -583,14 +583,14 @@ void GfxDrawButton(short x, short y, unsigned short btn)
void GfxSaveDisplayData(GsSprite *spr)
{
while (GfxIsGPUBusy() == true);
-
+
MoveImage( DispEnv.x,
DispEnv.y,
GFX_SECOND_DISPLAY_X,
GFX_SECOND_DISPLAY_Y,
X_SCREEN_RESOLUTION,
Y_SCREEN_RESOLUTION);
-
+
spr->x = 0;
spr->y = 0;
spr->tpage = GFX_SECOND_DISPLAY_TPAGE;
@@ -622,36 +622,36 @@ bool GfxTPageOffsetFromVRAMPosition(GsSprite * spr, short x, short y)
{
return false;
}
-
+
spr->tpage = x / GFX_TPAGE_WIDTH;
spr->tpage += (short)(VRAM_W / GFX_TPAGE_WIDTH) * (short)(y / GFX_TPAGE_HEIGHT);
-
+
spr->u = (x % GFX_TPAGE_WIDTH);
-
+
if (spr->attribute & COLORMODE(COLORMODE_8BPP))
{
// On 8bpp images, it looks like U offset needs to be multiplied by 2.
spr->u <<= 1;
}
-
+
spr->v = (y % GFX_TPAGE_HEIGHT);
-
+
//Serial_printf("Sprite:\n\tTPAGE: %d\n\tU=%d\n\tV=%d\n",spr->tpage,spr->u, spr->v);
-
+
return false;
}
TYPE_CARTESIAN_POS GfxIsometricToCartesian(TYPE_ISOMETRIC_POS* ptrIsoPos)
{
TYPE_CARTESIAN_POS retCartPos;
-
+
retCartPos.x = ptrIsoPos->x - (ptrIsoPos->x >> 1);
retCartPos.x -= ptrIsoPos->y >> 1;
-
+
retCartPos.y = ptrIsoPos->y >> 2;
retCartPos.y += ptrIsoPos->x >> 2;
retCartPos.y -= ptrIsoPos->z;
-
+
return retCartPos;
}
@@ -663,26 +663,26 @@ void GfxDrawScene_NoSwap(void)
TYPE_CARTESIAN_POS GfxIsometricFix16ToCartesian(TYPE_ISOMETRIC_FIX16_POS * ptrIso16Pos)
{
TYPE_ISOMETRIC_POS IsoPos;
-
+
IsoPos.x = (short)fix16_to_int(ptrIso16Pos->x);
IsoPos.y = (short)fix16_to_int(ptrIso16Pos->y);
IsoPos.z = (short)fix16_to_int(ptrIso16Pos->z);
-
+
return GfxIsometricToCartesian(&IsoPos);
}
TYPE_ISOMETRIC_POS GfxCartesianToIsometric(TYPE_CARTESIAN_POS * ptrCartPos)
{
TYPE_ISOMETRIC_POS IsoPos;
-
+
/*isoX = cartX - cartY;
isoY = (cartX + cartY) / 2;*/
IsoPos.x = ptrCartPos->x + (ptrCartPos->y << 1);
IsoPos.y = (ptrCartPos->y << 1) - ptrCartPos->x;
-
+
// Explicitly suppose z = 0
IsoPos.z = 0;
-
+
return IsoPos;
}
@@ -694,16 +694,16 @@ void GfxSetSplitScreen(uint8_t playerIndex)
DrawEnv.x = 0;
DrawEnv.w = X_SCREEN_RESOLUTION >> 1;
break;
-
+
case PLAYER_TWO:
DrawEnv.x = X_SCREEN_RESOLUTION >> 1;
DrawEnv.w = X_SCREEN_RESOLUTION >> 1;
break;
-
+
default:
break;
}
-
+
GsSetDrawEnv_DMA(&DrawEnv);
}
@@ -711,6 +711,6 @@ void GfxDisableSplitScreen(void)
{
DrawEnv.x = 0;
DrawEnv.w = X_SCREEN_RESOLUTION;
-
+
GsSetDrawEnv_DMA(&DrawEnv);
}
diff --git a/Source/LoadMenu.c b/Source/LoadMenu.c
index ef139dc..4aa6221 100644
--- a/Source/LoadMenu.c
+++ b/Source/LoadMenu.c
@@ -1,5 +1,5 @@
/* **************************************
- * Includes *
+ * Includes *
* *************************************/
#include "LoadMenu.h"
@@ -10,7 +10,7 @@
#include "Sfx.h"
/* **************************************
- * Defines *
+ * Defines *
* *************************************/
/* **************************************
@@ -35,10 +35,10 @@ enum
LOADING_BAR_X = 64,
LOADING_BAR_Y = 200,
LOADING_BAR_N_LINES = 4,
-
+
LOADING_BAR_WIDTH = 256,
LOADING_BAR_HEIGHT = 16,
-
+
LOADING_BAR_LUMINANCE_TARGET = NORMAL_LUMINANCE,
LOADING_BAR_LUMINANCE_STEP = 10
};
@@ -49,23 +49,23 @@ enum
LOADING_TITLE_CLUT_Y = 496,
LOADING_TITLE_X = 128,
LOADING_TITLE_Y = 32,
-
+
LOADING_TITLE_U = 0,
LOADING_TITLE_V = 0,
-
+
LOADING_TITLE_LUMINANCE_STEP = 10,
LOADING_TITLE_LUMINANCE_TARGET = NORMAL_LUMINANCE
};
enum
-{
+{
PLANE_START_X = 56,
PLANE_START_Y = 200,
-
+
PLANE_U = 0,
PLANE_V = 32,
PLANE_SIZE = 16,
-
+
PLANE_LUMINANCE_STEP = 0x10,
PLANE_LUMINANCE_TARGET_VALUE = NORMAL_LUMINANCE
};
@@ -78,7 +78,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);
/* *************************************
@@ -95,7 +95,7 @@ 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,
+static void* LoadMenuDest[] = { (GsSprite*)&LoadMenuPlaneSpr,
(GsSprite*)&LoadMenuTitleSpr,
(TYPE_FONT*)&SmallFont };
@@ -120,7 +120,7 @@ void LoadMenuInit(void)
{
int i;
static bool first_load = false;
-
+
if (first_load == false)
{
first_load = true;
@@ -129,48 +129,48 @@ void LoadMenuInit(void)
sizeof(LoadMenuFiles) / sizeof(char*),
sizeof(LoadMenuDest) / sizeof(void*));
}
-
+
FontSetSize(&SmallFont, SMALL_FONT_SIZE);
FontSetSpacing(&SmallFont, SMALL_FONT_SPACING);
LoadMenuPlaneSpr.r = 0;
LoadMenuPlaneSpr.g = 0;
LoadMenuPlaneSpr.b = 0;
-
+
LoadMenuPlaneSpr.x = PLANE_START_X;
LoadMenuPlaneSpr.y = PLANE_START_Y;
-
+
// "Loading..." title init
-
+
LoadMenuTitleSpr.r = 0;
LoadMenuTitleSpr.g = 0;
LoadMenuTitleSpr.b = 0;
-
+
LoadMenuTitleSpr.x = LOADING_TITLE_X;
LoadMenuTitleSpr.y = LOADING_TITLE_Y;
-
+
LoadMenuTitleSpr.cx = LOADING_TITLE_CLUT_X;
LoadMenuTitleSpr.cy = LOADING_TITLE_CLUT_Y;
LoadMenuTitleSpr.u = LOADING_TITLE_U;
LoadMenuTitleSpr.v = LOADING_TITLE_V;
-
+
startup_flag = true;
isr_started = false;
end_flag = false;
isr_ended = false;
-
+
// Background init
-
+
loadMenuBg.x[0] = 0;
loadMenuBg.x[1] = X_SCREEN_RESOLUTION;
loadMenuBg.x[2] = 0;
loadMenuBg.x[3] = X_SCREEN_RESOLUTION;
-
+
loadMenuBg.y[0] = 0;
loadMenuBg.y[1] = 0;
loadMenuBg.y[2] = Y_SCREEN_RESOLUTION;
loadMenuBg.y[3] = Y_SCREEN_RESOLUTION;
-
+
// Colour components adjustment (default to zero)
for (i = 0; i < 4 ; i++)
{
@@ -178,69 +178,69 @@ void LoadMenuInit(void)
loadMenuBg.g[i] = 0;
loadMenuBg.b[i] = 0;
}
-
+
// "Loading" bar line 0 (up left - up right)
-
+
LoadMenuBarLines[0].x[0] = LOADING_BAR_X;
LoadMenuBarLines[0].x[1] = LOADING_BAR_X + LOADING_BAR_WIDTH;
-
+
LoadMenuBarLines[0].y[0] = LOADING_BAR_Y;
LoadMenuBarLines[0].y[1] = LOADING_BAR_Y;
-
+
// "Loading" bar line 1 (up left - down left)
-
+
LoadMenuBarLines[1].x[0] = LOADING_BAR_X;
LoadMenuBarLines[1].x[1] = LOADING_BAR_X;
-
+
LoadMenuBarLines[1].y[0] = LOADING_BAR_Y;
LoadMenuBarLines[1].y[1] = LOADING_BAR_Y + LOADING_BAR_HEIGHT;
-
+
// "Loading" bar line 2 (down left - down right)
-
+
LoadMenuBarLines[2].x[0] = LOADING_BAR_X;
LoadMenuBarLines[2].x[1] = LOADING_BAR_X + LOADING_BAR_WIDTH;
-
+
LoadMenuBarLines[2].y[0] = LOADING_BAR_Y + LOADING_BAR_HEIGHT;
LoadMenuBarLines[2].y[1] = LOADING_BAR_Y + LOADING_BAR_HEIGHT;
-
+
// "Loading" bar line 3 (up right - down right)
-
+
LoadMenuBarLines[3].x[0] = LOADING_BAR_X + LOADING_BAR_WIDTH;
LoadMenuBarLines[3].x[1] = LOADING_BAR_X + LOADING_BAR_WIDTH;
-
+
LoadMenuBarLines[3].y[0] = LOADING_BAR_Y;
LoadMenuBarLines[3].y[1] = LOADING_BAR_Y + LOADING_BAR_HEIGHT;
-
+
for (i = 0; i < LOADING_BAR_N_LINES ; i++)
{
LoadMenuBarLines[i].r = 0;
LoadMenuBarLines[i].g = 0;
LoadMenuBarLines[i].b = 0;
}
-
+
LoadMenuBarRect.r = 0;
LoadMenuBarRect.g = 0;
LoadMenuBarRect.b = 0;
-
+
// LoadMenuBarRect.attribute |= ENABLE_TRANS | TRANS_MODE(0);
-
+
LoadMenuBarRect.x = LOADING_BAR_X;
LoadMenuBarRect.y = LOADING_BAR_Y;
LoadMenuBarRect.w = 0;
LoadMenuBarRect.h = LOADING_BAR_HEIGHT;
-
+
LoadMenuBarRect.attribute |= ENABLE_TRANS | TRANS_MODE(0);
-
+
load_menu_running = true;
-
+
SmallFont.spr.r = 0;
SmallFont.spr.g = 0;
SmallFont.spr.b = 0;
-
+
GfxSetGlobalLuminance(0);
Serial_printf("I_MASK = 0x%08X\n", (*(unsigned int*)0x1F801074));
-
+
SetVBlankHandler(&ISR_LoadMenuVBlank);
}
@@ -248,11 +248,11 @@ void LoadMenuEnd(void)
{
end_flag = true;
load_menu_running = false;
-
+
while (LoadMenuISRHasEnded() == false);
Serial_printf("Set default VBlank handler.\n");
SetVBlankHandler(&ISR_SystemDefaultVBlank);
-
+
GfxSetGlobalLuminance(NORMAL_LUMINANCE);
}
@@ -279,12 +279,12 @@ void ISR_LoadMenuVBlank(void)
dprintf("Serialisbusy\n");
return;
}
-
+
/*if ( (SystemIsBusy() == true) || (GfxIsGPUBusy() == true) || (SerialIsBusy() == true) )
{
return;
}*/
-
+
if (startup_flag == true)
{
// "Loading..." text
@@ -294,15 +294,15 @@ void ISR_LoadMenuVBlank(void)
LoadMenuTitleSpr.g += LOADING_TITLE_LUMINANCE_STEP;
LoadMenuTitleSpr.b += LOADING_TITLE_LUMINANCE_STEP;
}
-
+
if (loadMenuBg.g[0] < BG_WHITE_TARGET_VALUE)
{
loadMenuBg.r[0] += BG_INCREASE_STEP;
loadMenuBg.r[1] += BG_INCREASE_STEP;
-
+
loadMenuBg.g[0] += BG_INCREASE_STEP;
loadMenuBg.g[1] += BG_INCREASE_STEP;
-
+
loadMenuBg.b[0] += BG_INCREASE_STEP;
loadMenuBg.b[1] += BG_INCREASE_STEP;
}
@@ -312,7 +312,7 @@ void ISR_LoadMenuVBlank(void)
loadMenuBg.b[2] += BG_INCREASE_STEP;
loadMenuBg.b[3] += BG_INCREASE_STEP;
}
-
+
if (LoadMenuBarRect.r < LOADING_BAR_LUMINANCE_TARGET)
{
LoadMenuBarRect.r += LOADING_BAR_LUMINANCE_STEP;
@@ -324,7 +324,7 @@ void ISR_LoadMenuVBlank(void)
startup_flag = false;
isr_started = true;
}
-
+
for (i = 0;i < LOADING_BAR_N_LINES ; i++)
{
if (LoadMenuBarLines[i].r < LOADING_BAR_LUMINANCE_TARGET)
@@ -334,64 +334,64 @@ void ISR_LoadMenuVBlank(void)
LoadMenuBarLines[i].b += LOADING_BAR_LUMINANCE_STEP;
}
}
-
+
if (LoadMenuPlaneSpr.r < PLANE_LUMINANCE_TARGET_VALUE)
{
LoadMenuPlaneSpr.r += PLANE_LUMINANCE_STEP;
LoadMenuPlaneSpr.g += PLANE_LUMINANCE_STEP;
LoadMenuPlaneSpr.b += PLANE_LUMINANCE_STEP;
}
-
+
}
else if (end_flag == true)
{
LoadMenuTitleSpr.r -= LOADING_TITLE_LUMINANCE_STEP;
LoadMenuTitleSpr.g -= LOADING_TITLE_LUMINANCE_STEP;
LoadMenuTitleSpr.b -= LOADING_TITLE_LUMINANCE_STEP;
-
+
if (loadMenuBg.g[0] > 0)
{
loadMenuBg.r[0] -= BG_INCREASE_STEP;
loadMenuBg.r[1] -= BG_INCREASE_STEP;
-
+
loadMenuBg.g[0] -= BG_INCREASE_STEP;
loadMenuBg.g[1] -= BG_INCREASE_STEP;
-
+
loadMenuBg.b[0] -= BG_INCREASE_STEP;
loadMenuBg.b[1] -= BG_INCREASE_STEP;
}
-
+
if (loadMenuBg.b[2] > 0)
{
loadMenuBg.b[2] -= BG_INCREASE_STEP;
loadMenuBg.b[3] -= BG_INCREASE_STEP;
}
-
+
if (loadMenuBg.b[2] == 0)
{
end_flag = false;
isr_ended = true;
}
-
+
if (LoadMenuPlaneSpr.r > 0)
{
LoadMenuPlaneSpr.r -= PLANE_LUMINANCE_STEP;
LoadMenuPlaneSpr.g -= PLANE_LUMINANCE_STEP;
LoadMenuPlaneSpr.b -= PLANE_LUMINANCE_STEP;
}
-
+
LoadMenuPlaneSpr.x = (PLANE_START_X + LOADING_BAR_WIDTH);
LoadMenuPlaneSpr.y = PLANE_START_Y;
-
+
LoadMenuBarRect.w = LOADING_BAR_WIDTH;
-
+
if (LoadMenuBarRect.r > 0)
{
LoadMenuBarRect.r -= LOADING_BAR_LUMINANCE_STEP;
LoadMenuBarRect.g -= LOADING_BAR_LUMINANCE_STEP;
LoadMenuBarRect.b -= LOADING_BAR_LUMINANCE_STEP;
}
-
+
for (i = 0;i < LOADING_BAR_N_LINES ; i++)
{
if (LoadMenuBarLines[i].r > 0)
@@ -402,32 +402,32 @@ void ISR_LoadMenuVBlank(void)
}
}
}
-
+
GsSortGPoly4(&loadMenuBg);
-
+
GsSortRectangle(&LoadMenuBarRect);
-
+
for (i = 0 ; i < LOADING_BAR_N_LINES ; i++)
{
GsSortLine(&LoadMenuBarLines[i]);
}
-
+
GsSortSprite(&LoadMenuTitleSpr);
-
+
LoadMenuPlaneSpr.w = PLANE_SIZE;
LoadMenuPlaneSpr.h = PLANE_SIZE;
-
+
GsSortSprite(&LoadMenuPlaneSpr);
-
+
FontSetFlags(&SmallFont, FONT_BLEND_EFFECT);
-
+
FontPrintText( &SmallFont,
LOADING_BAR_X,
LOADING_BAR_Y + LOADING_BAR_HEIGHT + 8,
strCurrentFile );
-
+
//FontSetFlags(&SmallFont, FONT_NOFLAGS);
-
+
GfxDrawScene_Fast();
}
@@ -441,67 +441,67 @@ bool LoadMenuISRHasStarted(void)
return isr_started;
}
-void LoadMenu( char* fileList[],
+void LoadMenu( char* fileList[],
void* dest[],
uint8_t szFileList , uint8_t szDestList)
{
-
+
if (load_menu_running == false)
{
LoadMenuInit();
-
+
while (LoadMenuISRHasStarted() == false);
}
-
+
LoadMenuLoadFileList(fileList,dest,szFileList,szDestList);
-
+
}
-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;
short x_increment;
uint8_t fileLoadedCount;
-
+
if (szFileList != szDestList)
{
Serial_printf("File list size different from dest list size! %d vs %d\n",
szFileList, szDestList);
return;
}
-
+
for (fileLoadedCount = 0; fileLoadedCount < szFileList ; fileLoadedCount++)
{
strCurrentFile = fileList[fileLoadedCount];
-
+
if (strCurrentFile == NULL)
{
continue;
}
-
+
x_increment = (short)(LOADING_BAR_WIDTH / szFileList);
-
+
// Calculate new X position for loading menu plane sprite.
// This is not calculated on ISR as to avoid longer ISR time.
LoadMenuPlaneSpr.x = (PLANE_START_X + (fileLoadedCount* x_increment) );
-
+
LoadMenuBarRect.w = fileLoadedCount* x_increment;
-
+
//Serial_printf("Files %d / %d loaded. New plane X = %d.\n",fileLoadedCount,szFileList,LoadMenuPlaneSpr.x);
-
+
// Backup original file path
strncpy(aux_file_name, strCurrentFile, 100);
-
+
//We want to get file extension, so split into tokens
strtok(strCurrentFile, ".;");
extension = strtok(NULL, ".;");
-
+
Serial_printf("File extension: .%s\n", extension);
//Restore original file path in order to load file
strncpy(strCurrentFile, aux_file_name, 100);
-
+
if (strncmp(extension,"TIM",3) == 0)
{
if (GfxSpriteFromFile(strCurrentFile, dest[fileLoadedCount]) == false)
@@ -515,7 +515,7 @@ void LoadMenuLoadFileList( char* fileList[], void* dest[],
{
Serial_printf("WARNING: File %s linked to non-NULL destination pointer!\n", dest[fileLoadedCount]);
}
-
+
if (GfxCLUTFromFile(strCurrentFile) == false)
{
Serial_printf("Could not load CLUT file \"%s\"!\n", strCurrentFile);
diff --git a/Source/LoadMenu.h b/Source/LoadMenu.h
index 307c7ae..3407dd1 100644
--- a/Source/LoadMenu.h
+++ b/Source/LoadMenu.h
@@ -15,10 +15,10 @@
* Global prototypes
* *************************************/
-void LoadMenu( char* fileList[],
+void LoadMenu( char* fileList[],
void* dest[],
uint8_t szFileList , uint8_t szDestList);
-
+
void LoadMenuEnd(void);
#endif //__LOAD_MENU_HEADER__
diff --git a/Source/Makefile b/Source/Makefile
index ac29758..c6c98a0 100644
--- a/Source/Makefile
+++ b/Source/Makefile
@@ -47,11 +47,11 @@ EMULATOR_FLAGS = -nogui -psxout
# Compiled objects list
OBJ_DIR = Obj
SRC_DIR = .
-OBJECTS = $(addprefix $(OBJ_DIR)/,main.o System.o Menu.o Gfx.o Pad.o MainMenuBtnAni.o \
- LoadMenu.o GameGui.o Sfx.o Camera.o EndAnimation.o \
- PSXSDKIntro.o PltParser.o Game.o Font.o MemCard.o \
- Aircraft.o Serial.o Timer.o)
-
+OBJECTS = $(addprefix $(OBJ_DIR)/, main.o System.o Menu.o Gfx.o Pad.o MainMenuBtnAni.o \
+ LoadMenu.o GameGui.o Sfx.o Camera.o EndAnimation.o \
+ PSXSDKIntro.o PltParser.o Game.o Font.o MemCard.o \
+ Aircraft.o Serial.o Timer.o)
+
# Source dependencies:
DEPS = $(OBJECTS:.o=.d)
@@ -63,8 +63,8 @@ FFMPEG_FLAGS = -f s16le -acodec pcm_s16le
# VAG objects:
SOURCE_SOUNDS_FOLDER = ../Sounds
-SOUNDS_FOLDER = ../cdimg/DATA/SOUNDS
-SOUND_OBJECTS = $(addprefix $(SOUNDS_FOLDER)/, BELL.VAG \
+OBJ_SOUNDS_DIR = ../cdimg/DATA/SOUNDS
+SOUND_OBJECTS = $(addprefix $(OBJ_SOUNDS_DIR)/, BELL.VAG \
ACCEPT.VAG \
TRAYCL.VAG \
SPINDISK.VAG \
@@ -78,7 +78,35 @@ SRC_LEVELS_DIR = $(PROJECT_DIR)/Levels
OBJ_LEVELS_DIR = $(CDROM_ROOT)/DATA/LEVELS
LEVEL_OBJECTS = $(addprefix $(OBJ_LEVELS_DIR)/, LEVEL1.LVL LEVEL1.PLT)
-# ------------------------------------
+# Sprite objects:
+BMP2TIM = bmp2tim
+SRC_SPRITES_PATH = $(PROJECT_DIR)/Sprites
+OBJ_SPRITES_PATH = $(CDROM_ROOT)/DATA/SPRITES
+# NOTE: Fonts, despite still being .TIM files, are separated into another folder,
+# so SPRITE_OBJECTS are splitted in two parts.
+OBJ_FONTS_PATH = $(CDROM_ROOT)/DATA/FONTS
+SPRITE_OBJECTS = $(addprefix $(OBJ_SPRITES_PATH)/, PSXDISK.TIM \
+ TILESET1.TIM \
+ TILESET2.TIM \
+ MAINMENU.TIM \
+ LOADING.TIM \
+ PLANE.TIM \
+ BUTTONS.TIM \
+ GAMEPLN.TIM \
+ PLNBLUE.CLT \
+ BUBBLE.TIM \
+ GPL.TIM \
+ OPENSRC.TIM \
+ MOUSE.TIM \
+ DEPARR.TIM \
+ PAGEUPDN.TIM \
+ BLDNGS1.TIM \
+ ARROW.TIM \
+ MENUSTAR.TIM )
+
+SPRITE_OBJECTS += $(addprefix $(OBJ_FONTS_PATH)/, INTROFNT.TIM \
+ FONT_1.TIM \
+ FONT_2.TIM )
# Instructions
# ------------------------------------
@@ -89,62 +117,49 @@ rebuild:
make build
-include $(DEPS)
-
+
music_objects: $(addprefix ../Music/, TRACK01.bin TRACK02.bin TRACK03.bin)
-
+
clean:
- rm -f Obj/*.o
- rm -f $(CDROM_ROOT)/DATA/SOUNDS/*.VAG
- rm -f $(CDROM_ROOT)/DATA/LEVELS/*.LVL
- rm -f $(CDROM_ROOT)/DATA/LEVELS/*.PLT
-
+ rm -f $(OBJ_DIR)/*.o
+ rm -f $(OBJ_SOUNDS_DIR)/*.VAG
+ rm -f $(OBJ_LEVELS_DIR)/*.LVL
+ rm -f $(OBJ_LEVELS_DIR)/*.PLT
+ rm -f $(OBJ_SPRITES_PATH)/*.TIM
+ rm -f $(OBJ_FONTS_PATH)/*.TIM
+
$(OBJ_DIR)/%.o: $(SRC_DIR)/%.c $(OBJ_DIR)/%.d
$(CC) $< -o $@ $(DEFINE) $(CC_FLAGS) -MMD
-
+
$(EXE_PATH)/$(PROJECT).elf: $(OBJECTS)
$(LINKER) $^ -o $@ $(LIBS) -Wl,--gc-sections
+ $(GNU_SIZE) $@
-$(EXE_PATH)/$(PROJECT).iso: $(EXE_PATH)/$(PROJECT).exe $(SOUND_OBJECTS) $(LEVEL_OBJECTS)
+$(EXE_PATH)/$(PROJECT).iso: $(EXE_PATH)/$(PROJECT).exe $(SOUND_OBJECTS) $(LEVEL_OBJECTS) $(SPRITE_OBJECTS)
mkisofs -o $@ -V $(PROJECT) -sysid PLAYSTATION $(CDROM_ROOT)
$(BIN_TARGET_PATH)/$(PROJECT).bin: $(EXE_PATH)/$(PROJECT).iso
mkpsxiso $< $@ $(LICENSE_FILE) $(MUSIC_TRACKS)
# $(PROJECT).cue is automatically generated by mkpsxiso
-
+
$(EXE_PATH)/$(PROJECT).exe: $(EXE_PATH)/$(PROJECT).elf
$(ELF2EXE) $< $@ $(ELF2EXE_FLAGS)
cp $@ $(CDROM_ROOT)
-
+
#~ emulator:
#~ export PATH=$$PATH:$(EMULATOR_DIR)
#~ $(EMULATOR) -cdfile $(PROJECT_DIR)/Bin/$(PROJECT).bin $(EMULATOR_FLAGS)
-tiles:
- rm -f ../cdimg/DATA/SPRITES/*.TIM
- rm -f ../cdimg/DATA/FONTS/*.FNT
- bmp2tim ../Sprites/PSXDisk.bmp ../cdimg/DATA/SPRITES/PSXDISK.TIM 16 -org=384,0 -mpink
- bmp2tim ../Sprites/IntroFnt.bmp ../cdimg/DATA/SPRITES/INTROFNT.TIM 16 -org=384,76 -mpink
- bmp2tim ../Sprites/Tileset1.bmp ../cdimg/DATA/SPRITES/TILESET1.TIM 16 -org=384,0 -mpink
- bmp2tim ../Sprites/Tileset2.bmp ../cdimg/DATA/SPRITES/TILESET2.TIM 16 -org=640,0 -mpink
- bmp2tim ../Sprites/MainMenu.bmp ../cdimg/DATA/SPRITES/MAINMENU.TIM 16 -org=768,384 -mpink
- bmp2tim ../Sprites/Loading.bmp ../cdimg/DATA/SPRITES/LOADING.TIM 4 -mpink -org=768,256 -clut=384,496
- bmp2tim ../Sprites/Plane.bmp ../cdimg/DATA/SPRITES/PLANE.TIM 16 -org=536,240 -mpink
- bmp2tim ../Sprites/Buttons.bmp ../cdimg/DATA/SPRITES/BUTTONS.TIM 16 -org=384,240 -mpink
- bmp2tim ../Sprites/GamePln.bmp ../cdimg/DATA/SPRITES/GAMEPLN.TIM 8 -mpink -org=800,256 -clut=384,497
- bmp2tim ../Sprites/GamePln_Blue.bmp ../cdimg/DATA/SPRITES/PLNBLUE.CLT 8 -mpink -clut=384,501
- bmp2tim ../Sprites/Bubble.bmp ../cdimg/DATA/SPRITES/BUBBLE.TIM 8 -org=584,240 -mpink -clut=384,498
- bmp2tim ../Sprites/Font_1_4bit.bmp ../cdimg/DATA/FONTS/FONT_1.FNT 4 -org=960,256 -mpink -clut=384,500
- bmp2tim ../Sprites/Font_2_4bit.bmp ../cdimg/DATA/FONTS/FONT_2.FNT 4 -org=768,288 -mpink -clut=384,499
- bmp2tim ../Sprites/GPL_4bit.bmp ../cdimg/DATA/SPRITES/GPL.TIM 4 -org=384,174 -mpink -clut=384,502
- bmp2tim ../Sprites/OpSrc_8bit.bmp ../cdimg/DATA/SPRITES/OPENSRC.TIM 8 -org=464,0 -mpink -clut=384,503
- bmp2tim ../Sprites/Mouse.bmp ../cdimg/DATA/SPRITES/MOUSE.TIM 16 -org=596,240 -mpink
- bmp2tim ../Sprites/DepArr.bmp ../cdimg/DATA/SPRITES/DEPARR.TIM 16 -org=552,240 -mpink
- bmp2tim ../Sprites/PageUpDn.bmp ../cdimg/DATA/SPRITES/PAGEUPDN.TIM 16 -org=504,240 -mpink
- bmp2tim ../Sprites/Bldngs1.bmp ../cdimg/DATA/SPRITES/BLDNGS1.TIM 16 -org=640,128 -mpink
- bmp2tim ../Sprites/Arrow.bmp ../cdimg/DATA/SPRITES/ARROW.TIM 16 -org=604,240 -mpink
- bmp2tim ../Sprites/MenuStar_4_bit.bmp ../cdimg/DATA/SPRITES/MENUSTAR.TIM 4 -org=
-
-$(SOUNDS_FOLDER)/%.VAG: $(SOURCE_SOUNDS_FOLDER)/%.wav
+$(OBJ_SPRITES_PATH)/%.TIM: $(SRC_SPRITES_PATH)/%.bmp $(SRC_SPRITES_PATH)/%.flags
+ $(BMP2TIM) $< $@ `cat $(word 2,$^)`
+
+$(OBJ_FONTS_PATH)/%.TIM: $(SRC_SPRITES_PATH)/%.bmp $(SRC_SPRITES_PATH)/%.flags
+ $(BMP2TIM) $< $@ `cat $(word 2,$^)`
+
+$(OBJ_SPRITES_PATH)/%.CLT: $(SRC_SPRITES_PATH)/%.bmp $(SRC_SPRITES_PATH)/%.flags
+ $(BMP2TIM) $< $@ `cat $(word 2,$^)`
+
+$(OBJ_SOUNDS_DIR)/%.VAG: $(SOURCE_SOUNDS_FOLDER)/%.wav
wav2vag $^ $@
$(OBJ_LEVELS_DIR)/%.LVL: $(SRC_LEVELS_DIR)/%.LVL
diff --git a/Source/MemCard.c b/Source/MemCard.c
index 09a7de3..cd8add0 100644
--- a/Source/MemCard.c
+++ b/Source/MemCard.c
@@ -10,7 +10,7 @@
/* *************************************
* Defines
* *************************************/
-
+
#define MEMCARD_SECTOR_SIZE 128
#define MEMCARD_SECTORS_PER_BLOCK 64
#define MEMCARD_SECTORS_PER_BLOCK_BITSHIFT 6
@@ -26,14 +26,14 @@
/* *************************************
* Structs and enums
* *************************************/
-
+
typedef enum t_Sectors
{
TITLE_FRAME = 0,
ICON_FRAME_1,
ICON_FRAME_2,
ICON_FRAME_3,
- DATA_FRAME,
+ DATA_FRAME,
}MEMCARD_FILE_SECTORS;
enum
@@ -57,11 +57,11 @@ enum
MEMCARD_DIALOG_Y = 28,
MEMCARD_DIALOG_W = 256,
MEMCARD_DIALOG_H = 184,
-
+
MEMCARD_DIALOG_R = 0,
MEMCARD_DIALOG_G = 128,
MEMCARD_DIALOG_B = 64,
-
+
MEMCARD_DIALOG_GAP_X = 24,
MEMCARD_DIALOG_GAP_SLOT = 128
};
@@ -72,17 +72,17 @@ enum
MEMCARD_BG_Y = 28,
MEMCARD_BG_W = 256,
MEMCARD_BG_H = 184,
-
+
MEMCARD_BG_R0 = 0,
MEMCARD_BG_R1 = MEMCARD_BG_R0,
MEMCARD_BG_R2 = MEMCARD_BG_R0,
MEMCARD_BG_R3 = MEMCARD_BG_R0,
-
+
MEMCARD_BG_G0 = 0,
MEMCARD_BG_G1 = MEMCARD_BG_G0,
MEMCARD_BG_G2 = NORMAL_LUMINANCE,
MEMCARD_BG_G3 = MEMCARD_BG_G2,
-
+
MEMCARD_BG_B0 = 0,
MEMCARD_BG_B1 = MEMCARD_BG_B0,
MEMCARD_BG_B2 = NORMAL_LUMINANCE >> 1,
@@ -95,9 +95,9 @@ enum
MEMCARD_PROGRESS_BAR_Y = 148,
MEMCARD_PROGRESS_BAR_W = 226,
MEMCARD_PROGRESS_BAR_H = 16,
-
+
MEMCARD_PROGRESS_BAR_N_LINES = 4,
-
+
MEMCARD_PROGRESS_BAR_R = NORMAL_LUMINANCE,
MEMCARD_PROGRESS_BAR_G = NORMAL_LUMINANCE,
MEMCARD_PROGRESS_BAR_B = NORMAL_LUMINANCE
@@ -118,11 +118,11 @@ typedef struct t_MemCardErrors
MEMCARD_BLOCKS Block;
MEMCARD_PROCESS Process;
}TYPE_MEMCARD_ERRORS;
-
+
/* *************************************
* Local Prototypes
* *************************************/
-
+
static bool MemCardGetInitialFrameInfo(TYPE_BLOCK_DATA * ptrBlockData);
static bool MemCardGetIconFrameInfo(TYPE_BLOCK_DATA * ptrBlockData);
static bool MemCardGetBlockStateFileName(TYPE_BLOCK_DATA * ptrBlockData);
@@ -133,7 +133,7 @@ static void MemCardIconIndexHandler(void);
/* *************************************
* Local Variables
* *************************************/
-
+
static uint8_t DataBuffer[MEMCARD_SECTOR_SIZE];
static TYPE_MEMCARD_ERRORS MemCardErrors;
static GsSprite SecondDisplay;
@@ -160,141 +160,141 @@ void MemCardInit(void)
TYPE_BLOCK_DATA * ptrBlockData;
uint8_t i;
uint8_t j;
-
+
for (j = SLOT_ONE; j <= SLOT_TWO; j++)
- {
+ {
for (i = BLOCK_1; i <= BLOCK_15; i++)
{
ptrBlockData = &MemCardData[i - BLOCK_1][j];
-
+
ptrBlockData->IconTPoly.r = NORMAL_LUMINANCE;
ptrBlockData->IconTPoly.g = NORMAL_LUMINANCE;
ptrBlockData->IconTPoly.b = NORMAL_LUMINANCE;
}
}
-
+
bzero((TYPE_MEMCARD_ERRORS*)&MemCardErrors, sizeof(TYPE_MEMCARD_ERRORS) );
}
void ISR_MemCardDataHandling(void)
{
-
+
uint8_t i;
-
+
if ( (GfxIsGPUBusy() == true) || (SystemIsBusy() == true) )
{
return;
}
-
+
// Dim background
SecondDisplay.r = NORMAL_LUMINANCE >> 1;
SecondDisplay.g = NORMAL_LUMINANCE >> 1;
SecondDisplay.b = NORMAL_LUMINANCE >> 1;
-
+
MemCardRect.x[0] = MEMCARD_BG_X;
MemCardRect.x[1] = MEMCARD_BG_X + MEMCARD_BG_W;
MemCardRect.x[2] = MEMCARD_BG_X;
MemCardRect.x[3] = MEMCARD_BG_X + MEMCARD_BG_W;
-
+
MemCardRect.y[0] = MEMCARD_BG_Y;
MemCardRect.y[1] = MEMCARD_BG_Y;
MemCardRect.y[2] = MEMCARD_BG_Y + MEMCARD_BG_H;
MemCardRect.y[3] = MEMCARD_BG_Y + MEMCARD_BG_H;
-
+
MemCardRect.r[0] = MEMCARD_BG_R0;
MemCardRect.r[1] = MEMCARD_BG_R1;
MemCardRect.r[2] = MEMCARD_BG_R2;
MemCardRect.r[3] = MEMCARD_BG_R3;
-
+
MemCardRect.g[0] = MEMCARD_BG_G0;
MemCardRect.g[1] = MEMCARD_BG_G1;
MemCardRect.g[2] = MEMCARD_BG_G2;
MemCardRect.g[3] = MEMCARD_BG_G3;
-
+
MemCardRect.b[0] = MEMCARD_BG_B0;
MemCardRect.b[1] = MEMCARD_BG_B1;
MemCardRect.b[2] = MEMCARD_BG_B2;
MemCardRect.b[3] = MEMCARD_BG_B3;
-
+
MemCardRect.attribute |= ENABLE_TRANS | TRANS_MODE(0);
-
+
// "Loading" bar line 0 (up left - up right)
-
+
MemCardProgressBarLines[0].x[0] = MEMCARD_PROGRESS_BAR_X;
MemCardProgressBarLines[0].x[1] = MEMCARD_PROGRESS_BAR_X + MEMCARD_PROGRESS_BAR_W;
-
+
MemCardProgressBarLines[0].y[0] = MEMCARD_PROGRESS_BAR_Y;
MemCardProgressBarLines[0].y[1] = MEMCARD_PROGRESS_BAR_Y;
-
+
// "Loading" bar line 1 (up left - down left)
-
+
MemCardProgressBarLines[1].x[0] = MEMCARD_PROGRESS_BAR_X;
MemCardProgressBarLines[1].x[1] = MEMCARD_PROGRESS_BAR_X;
-
+
MemCardProgressBarLines[1].y[0] = MEMCARD_PROGRESS_BAR_Y;
MemCardProgressBarLines[1].y[1] = MEMCARD_PROGRESS_BAR_Y + MEMCARD_PROGRESS_BAR_H;
-
+
// "Loading" bar line 2 (down left - down right)
-
+
MemCardProgressBarLines[2].x[0] = MEMCARD_PROGRESS_BAR_X;
MemCardProgressBarLines[2].x[1] = MEMCARD_PROGRESS_BAR_X + MEMCARD_PROGRESS_BAR_W;
-
+
MemCardProgressBarLines[2].y[0] = MEMCARD_PROGRESS_BAR_Y + MEMCARD_PROGRESS_BAR_H;
MemCardProgressBarLines[2].y[1] = MEMCARD_PROGRESS_BAR_Y + MEMCARD_PROGRESS_BAR_H;
-
+
// "Loading" bar line 3 (up right - down right)
-
+
MemCardProgressBarLines[3].x[0] = MEMCARD_PROGRESS_BAR_X + MEMCARD_PROGRESS_BAR_W;
MemCardProgressBarLines[3].x[1] = MEMCARD_PROGRESS_BAR_X + MEMCARD_PROGRESS_BAR_W;
-
+
MemCardProgressBarLines[3].y[0] = MEMCARD_PROGRESS_BAR_Y;
MemCardProgressBarLines[3].y[1] = MEMCARD_PROGRESS_BAR_Y + MEMCARD_PROGRESS_BAR_H;
-
+
for (i = 0; i < MEMCARD_PROGRESS_BAR_N_LINES; i++)
{
MemCardProgressBarLines[i].r = NORMAL_LUMINANCE;
MemCardProgressBarLines[i].g = NORMAL_LUMINANCE;
MemCardProgressBarLines[i].b = NORMAL_LUMINANCE;
}
-
+
// Set progress bar attributes
-
+
MemCardProgressBar.x = MEMCARD_PROGRESS_BAR_X;
MemCardProgressBar.y = MEMCARD_PROGRESS_BAR_Y;
-
+
MemCardProgressBar.w = ProgressBarXOffset;
MemCardProgressBar.h = MEMCARD_PROGRESS_BAR_H;
-
+
MemCardProgressBar.r = MEMCARD_PROGRESS_BAR_R;
MemCardProgressBar.g = MEMCARD_PROGRESS_BAR_G;
MemCardProgressBar.b = MEMCARD_PROGRESS_BAR_B;
-
+
GfxSortSprite(&SecondDisplay);
GsSortGPoly4(&MemCardRect);
GsSortRectangle(&MemCardProgressBar);
-
+
for (i = 0; i < MEMCARD_PROGRESS_BAR_N_LINES; i++)
{
GsSortLine(&MemCardProgressBarLines[i]);
}
-
+
FontSetFlags(&SmallFont, FONT_BLEND_EFFECT);
-
+
FontPrintText(&SmallFont, MEMCARD_LOAD_DATA_TEXT_X, MEMCARD_LOAD_DATA_TEXT_Y, "Loading memory card data...");
-
+
FontSetFlags(&SmallFont, FONT_NOFLAGS);
-
+
GfxDrawScene_Fast();
-
+
}
-
+
void MemCardResetBlockData(TYPE_BLOCK_DATA * ptrBlockData)
-{
+{
bzero((TYPE_BLOCK_DATA*)ptrBlockData, sizeof(TYPE_BLOCK_DATA));
-
+
ptrBlockData->BlockCount = FIRST_OR_ONLY_BLOCK;
-
- IconIndex = 0;
+
+ IconIndex = 0;
}
bool MemCardGetBlockInfo( TYPE_BLOCK_DATA * ptrBlockData,
@@ -302,92 +302,92 @@ bool MemCardGetBlockInfo( TYPE_BLOCK_DATA * ptrBlockData,
MEMCARD_BLOCKS blockNumber )
{
MemCardResetBlockData(ptrBlockData);
-
+
ptrBlockData->Slot = slot;
ptrBlockData->Block = blockNumber;
-
+
Serial_printf("MemCardGetBlockStateFileName...\n");
-
+
if (MemCardGetBlockStateFileName(ptrBlockData) == false)
{
return false;
}
-
+
if (ptrBlockData->BlockCount == EMPTY_BLOCK)
{
// Stop looking for any other data.
return true;
}
-
+
Serial_printf("MemCardGetInitialFrameInfo...\n");
-
+
if (MemCardGetInitialFrameInfo(ptrBlockData) == false)
{
return false;
}
-
+
Serial_printf("MemCardGetIconFrameInfo...\n");
-
+
if (MemCardGetIconFrameInfo(ptrBlockData) == false)
{
return false;
}
-
+
// We will not get any block data information, we are only interested
// in basic info.
-
+
Serial_printf("MemCardUploadToGPU...\n");
-
+
if (MemCardUploadToGPU(ptrBlockData) == false)
{
return false;
}
-
+
return true;
}
bool MemCardGetBlockStateFileName(TYPE_BLOCK_DATA * ptrBlockData)
{
int sector = ptrBlockData->Block;
-
+
MemCardErrors.Block = ptrBlockData->Block;
MemCardErrors.Slot = ptrBlockData->Slot;
MemCardErrors.Process = MEMCARD_PROCESS_GET_FILENAME;
-
+
memset(DataBuffer, 0, MEMCARD_SECTOR_SIZE);
-
+
if (MemCardReadSector(ptrBlockData, sector) == false)
{
return false;
}
-
+
// 00h-03h Block Allocation State
Serial_printf("Block %d, slot %d, allocation state: 0x%02X.\n",
ptrBlockData->Block,
ptrBlockData->Slot,
DataBuffer[0] );
-
+
/* 00000051h - In use ;first-or-only block of a file
* 00000052h - In use ;middle block of a file (if 3 or more blocks)
- * 00000053h - In use ;last block of a file (if 2 or more blocks)
+ * 00000053h - In use ;last block of a file (if 2 or more blocks)
* 000000A0h - Free ;freshly formatted
* 000000A1h - Free ;deleted (first-or-only block of file)
* 000000A2h - Free ;deleted (middle block of file)
* 000000A3h - Free ;deleted (last block of file) */
-
+
// Always take into account memory card data is little-endian,
// so if using a hex editor, you will read 51000000h.
-
+
switch(DataBuffer[0])
{
case 0x51:
ptrBlockData->BlockCount = FIRST_OR_ONLY_BLOCK;
break;
-
+
case 0x52:
ptrBlockData->BlockCount = INTERMEDIATE_BLOCK;
break;
-
+
case 0x53:
ptrBlockData->BlockCount = LAST_BLOCK;
break;
@@ -401,19 +401,19 @@ bool MemCardGetBlockStateFileName(TYPE_BLOCK_DATA * ptrBlockData)
printf("Invalid block allocation state!\n");
return false;
}
-
+
// 0Ah-1Eh Filename in ASCII, terminated by 00h (max 20 chars, plus ending 00h)
// File name is only defined on first block of group (allocation state == 0x51)
-
+
if (ptrBlockData->BlockCount == FIRST_OR_ONLY_BLOCK)
{
memset(ptrBlockData->FileName, 0 , MEMCARD_FILENAME_SIZE);
-
+
memcpy(ptrBlockData->FileName, &DataBuffer[0x0A], MEMCARD_FILENAME_SIZE);
-
+
Serial_printf("File name: %s\n", ptrBlockData->FileName);
}
-
+
return true;
}
@@ -421,35 +421,35 @@ bool MemCardGetInitialFrameInfo(TYPE_BLOCK_DATA * ptrBlockData)
{
unsigned int i;
int sector = ptrBlockData->Block << MEMCARD_SECTORS_PER_BLOCK_BITSHIFT;
-
+
MemCardErrors.Block = ptrBlockData->Block;
MemCardErrors.Slot = ptrBlockData->Slot;
MemCardErrors.Process = MEMCARD_PROCESS_GET_FILENAME;
-
+
if (ptrBlockData->BlockCount != FIRST_OR_ONLY_BLOCK)
{
// Icon data is only stored on first block (if game takes more
// than one block. Skip this step otherwise.
-
+
// When dealing with intermediate or last blocks of a file,
// we use a static pointer which points to first block of a file,
// and then image data is copied into other blocks.
return true;
}
-
+
// Pretty silly operation (TITLE_FRAME = 0), but used for
// conceptual purposes and better understanding.
sector += TITLE_FRAME;
-
+
memset(DataBuffer, 0, MEMCARD_SECTOR_SIZE);
-
+
if (MemCardReadSector(ptrBlockData, sector) == false)
{
return false;
}
-
+
Serial_printf("Magic number: '%c' '%c'\n",DataBuffer[0], DataBuffer[1]);
-
+
if (DataBuffer[0] != 'S' || DataBuffer[1] != 'C')
{
// Invalid magic number.
@@ -459,42 +459,42 @@ bool MemCardGetInitialFrameInfo(TYPE_BLOCK_DATA * ptrBlockData)
return false;
}
-
+
/* 02h Icon Display Flag
11h...Icon has 1 frame (static) (same image shown forever)
12h...Icon has 2 frames (animated) (changes every 16 PAL frames)
13h...Icon has 3 frames (animated) (changes every 11 PAL frames)
* */
-
+
switch(DataBuffer[2])
{
case 0x11:
ptrBlockData->IconNumber = 1;
break;
-
+
case 0x12:
ptrBlockData->IconNumber = 2;
break;
-
+
case 0x13:
ptrBlockData->IconNumber = 3;
break;
-
+
default:
// Invalid icon display flag! We can't know how many icons
// are used.
return false;
}
-
+
Serial_printf("Number of icons: %d\n", ptrBlockData->IconNumber);
-
+
// 60h-7Fh Icon 16 Color Palette Data (each entry is 16bit CLUT)
-
+
for (i = 0; i < ptrBlockData->IconNumber; i++)
{
memcpy(ptrBlockData->CLUT[i],&DataBuffer[0x60], MEMCARD_CLUT_SIZE);
}
-
+
return true;
}
@@ -506,39 +506,39 @@ bool MemCardGetIconFrameInfo(TYPE_BLOCK_DATA * ptrBlockData)
unsigned int j;
uint8_t buffer_contents;
static TYPE_BLOCK_DATA * ptrReferenceBlock = NULL;
-
+
switch(ptrBlockData->BlockCount)
{
case EMPTY_BLOCK:
// Empty blocks are not of interest. Skip.
return true;
-
+
case INTERMEDIATE_BLOCK:
case LAST_BLOCK:
-
+
if (ptrReferenceBlock == NULL)
{
Serial_printf("No reference memory card block found yet!\n");
return false;
}
-
+
ptrBlockData->IconNumber = ptrReferenceBlock->IconNumber;
-
+
for (i = 0; i < MEMCARD_NUMBER_OF_ICONS; i++)
{
memcpy(ptrBlockData->CLUT[i], ptrReferenceBlock->CLUT[i], MEMCARD_CLUT_SIZE);
memcpy(ptrBlockData->Icons[i], ptrReferenceBlock->Icons[i], MEMCARD_ICON_SIZE);
}
-
+
if (ptrBlockData->BlockCount == LAST_BLOCK)
{
// Dereference pointer
ptrReferenceBlock = NULL;
}
-
+
return true;
case FIRST_OR_ONLY_BLOCK:
-
+
// Icon Frame(s) (Block 1..15, Frame 1..3) (in first block of file only)
for (i = ICON_FRAME_1; i <= ptrBlockData->IconNumber; i++)
{
@@ -546,20 +546,20 @@ bool MemCardGetIconFrameInfo(TYPE_BLOCK_DATA * ptrBlockData)
buffer_contents = 0;
sector = initial_sector + i;
memset(DataBuffer, 0, MEMCARD_SECTOR_SIZE * sizeof(uint8_t) );
-
+
if (MemCardReadSector(ptrBlockData, sector) == false)
{
Serial_printf("Could not read memory sector!\n");
return false;
}
-
+
memcpy(ptrBlockData->Icons[i - 1 /* ICON_FRAME_# - 1 */], DataBuffer, MEMCARD_SECTOR_SIZE);
-
+
for (j = 0; j < MEMCARD_SECTOR_SIZE; j++)
{
buffer_contents |= ptrBlockData->Icons[i - 1][j];
}
-
+
if (buffer_contents == 0)
{
// Icon buffer is empty!
@@ -570,15 +570,15 @@ bool MemCardGetIconFrameInfo(TYPE_BLOCK_DATA * ptrBlockData)
return false;
}
}
-
+
// Use current block as reference if file contains more than one block.
ptrReferenceBlock = ptrBlockData;
-
+
return true;
}
-
+
Serial_printf("Unknown error from MemCardGetIconFrameInfo()!\n");
-
+
return false;
}
@@ -589,7 +589,7 @@ bool MemCardUploadToGPU(TYPE_BLOCK_DATA * ptrBlockData)
short y_clut_offset;
short x_block_offset;
GsImage gs;
-
+
if ( (ptrBlockData->IconNumber < 1)
||
(ptrBlockData->IconNumber > MEMCARD_NUMBER_OF_ICONS) )
@@ -597,128 +597,128 @@ bool MemCardUploadToGPU(TYPE_BLOCK_DATA * ptrBlockData)
Serial_printf("Invalid number of icons.\n");
return false;
}
-
+
for (i = 0; i < ptrBlockData->IconNumber; i++)
{
gs.pmode = COLORMODE_4BPP;
gs.has_clut = 1;
-
+
x_clut_offset = i << 4;
y_clut_offset = ptrBlockData->Block - 1;
-
+
gs.clut_x = MEMCARD_BLOCK_CLUT_X + x_clut_offset;
gs.clut_y = MEMCARD_BLOCK_CLUT_Y + y_clut_offset + (ptrBlockData->Slot << 4);
gs.clut_w = MEMCARD_BLOCK_CLUT_W;
gs.clut_h = MEMCARD_BLOCK_CLUT_H;
-
+
Serial_printf("Gs Clut = {%d,%d,%d,%d}\n",
gs.clut_x,
gs.clut_y,
gs.clut_w,
gs.clut_h );
-
+
x_block_offset = MEMCARD_BLOCK_IMAGE_W * (ptrBlockData->Block - 1);
x_block_offset *= MEMCARD_BLOCK_MAX_ICONS;
x_block_offset >>= MEMCARD_BLOCK_IMAGE_W_BITSHIFT;
x_block_offset += i<<MEMCARD_BLOCK_IMAGE_W_BITSHIFT;
-
- gs.x = MEMCARD_BLOCK_IMAGE_X + x_block_offset;
+
+ gs.x = MEMCARD_BLOCK_IMAGE_X + x_block_offset;
gs.y = MEMCARD_BLOCK_IMAGE_Y + (MEMCARD_BLOCK_IMAGE_H * ptrBlockData->Slot);
-
+
// Dimensions are 16x16 px, but since 4bpp is used, it actually
// takes 4x16 px on the framebuffer.
gs.w = MEMCARD_BLOCK_IMAGE_W >> MEMCARD_BLOCK_IMAGE_W_BITSHIFT;
gs.h = MEMCARD_BLOCK_IMAGE_H;
-
+
gs.clut_data = (uint8_t*)ptrBlockData->CLUT[i];
gs.data = (uint8_t*)ptrBlockData->Icons[i];
-
+
GsUploadImage(&gs);
-
+
if (i == 0)
{
ptrBlockData->IconTPoly.attribute = COLORMODE(COLORMODE_4BPP);
ptrBlockData->IconTPoly.tpage = (gs.x / 64) + ((gs.y/256)*16);
-
+
Serial_printf("\tTPAGE = %d\n", ptrBlockData->IconTPoly.tpage);
-
+
x_block_offset = MEMCARD_BLOCK_IMAGE_W * (ptrBlockData->Block - 1);
x_block_offset *= MEMCARD_BLOCK_MAX_ICONS;
-
+
ptrBlockData->IconTPoly.u[0] = MEMCARD_BLOCK_IMAGE_X + x_block_offset;
ptrBlockData->IconTPoly.u[1] = ptrBlockData->IconTPoly.u[0] + (gs.w << 2);
ptrBlockData->IconTPoly.u[2] = ptrBlockData->IconTPoly.u[0];
ptrBlockData->IconTPoly.u[3] = ptrBlockData->IconTPoly.u[1];
-
+
Serial_printf("\tu = {%d, %d, %d, %d}\n",
ptrBlockData->IconTPoly.u[0],
ptrBlockData->IconTPoly.u[1],
ptrBlockData->IconTPoly.u[2],
ptrBlockData->IconTPoly.u[3]);
-
+
ptrBlockData->IconTPoly.v[0] = gs.y % 256;
ptrBlockData->IconTPoly.v[1] = ptrBlockData->IconTPoly.v[0];
ptrBlockData->IconTPoly.v[2] = (gs.y % 256) + (gs.h);
ptrBlockData->IconTPoly.v[3] = ptrBlockData->IconTPoly.v[2];
-
+
Serial_printf("\tu = {%d, %d, %d, %d}\n",
ptrBlockData->IconTPoly.v[0],
ptrBlockData->IconTPoly.v[1],
ptrBlockData->IconTPoly.v[2],
ptrBlockData->IconTPoly.v[3]);
-
+
ptrBlockData->IconTPoly.r = NORMAL_LUMINANCE;
ptrBlockData->IconTPoly.g = NORMAL_LUMINANCE;
ptrBlockData->IconTPoly.b = NORMAL_LUMINANCE;
-
+
ptrBlockData->IconTPoly.cx = gs.clut_x;
ptrBlockData->IconTPoly.cy = gs.clut_y;
-
+
Serial_printf("\tclut = {%d, %d}\n",
ptrBlockData->IconTPoly.cx,
ptrBlockData->IconTPoly.cy);
}
}
-
+
return true;
}
bool MemCardReadSector(TYPE_BLOCK_DATA * ptrBlockData, int sector)
{
uint8_t result;
-
+
MemCardErrors.Block = ptrBlockData->Block;
MemCardErrors.Slot = ptrBlockData->Slot;
-
+
if ( (ptrBlockData->Slot != 0)
&&
(ptrBlockData->Slot != 1) )
{
MemCardErrors.ErrorByte = 'S';
-
+
Serial_printf("Incorrect slot %d! Block %d?\n",
ptrBlockData->Slot,
ptrBlockData->Block);
-
+
return false;
}
-
+
if ((sector < 0) || (sector > MEMCARD_MAXIMUM_SECTOR))
{
MemCardErrors.ErrorByte = 'T';
-
+
Serial_printf("Invalid memory card sector %d. Only values between"
" 0 and %d are allowed!\n", sector, MEMCARD_MAXIMUM_SECTOR);
return false;
}
while (GfxIsGPUBusy() == true);
-
+
result = McReadSector(ptrBlockData->Slot, sector, DataBuffer);
-
+
// Fill char "MemCardErrors" for further error description.
MemCardErrors.ErrorByte = result;
-
+
switch(result)
{
case '1':
@@ -734,19 +734,19 @@ bool MemCardReadSector(TYPE_BLOCK_DATA * ptrBlockData, int sector)
ptrBlockData->Block,
ptrBlockData->Slot );
return false;
-
+
case MEMCARD_BAD_SECTOR:
Serial_printf("Invalid memory card sector %d. Only values between"
" 0 and 511 are allowed!\n", sector);
return false;
-
+
case MEMCARD_CORRECT_RW:
return true;
-
+
default:
return false;
}
-
+
return true;
}
@@ -754,57 +754,57 @@ bool MemCardGetAllData(void)
{
uint8_t i;
uint8_t j;
-
+
PadClearData();
-
+
CurrentReadBlock = 0;
-
+
TotalBlocks = MEMCARD_BLOCKS_PER_CARD * MEMCARD_NUMBER_OF_SLOTS;
-
+
SmallFont.spr.r = 0;
SmallFont.spr.g = 0;
SmallFont.spr.b = 0;
-
+
GfxSaveDisplayData(&SecondDisplay);
-
+
GfxSetGlobalLuminance(NORMAL_LUMINANCE);
-
+
// ISR_MemCardDataHandling draws a rectangle on top to show
// memory card loading progress.
-
+
SetVBlankHandler(&ISR_MemCardDataHandling);
-
+
for (j = SLOT_ONE; j <= SLOT_TWO; j++)
{
MemCardStatus[j] = McGetStatus(j);
-
+
if (MemCardStatus[j] == MEMCARD_STATUS_UNKNOWN)
{
// Memcard not connected and/or formatted.
continue;
}
-
+
for (i = BLOCK_1; i <= BLOCK_15; i++)
{
- ProgressBarXOffset = (short)(CurrentReadBlock *
+ ProgressBarXOffset = (short)(CurrentReadBlock *
(MEMCARD_PROGRESS_BAR_W /
(MEMCARD_BLOCKS_PER_CARD * MEMCARD_NUMBER_OF_SLOTS) ) );
-
+
if (MemCardGetBlockInfo(&MemCardData[i - BLOCK_1][j], j, i) == false)
{
// Return to normal behaviour if anything fails
SetVBlankHandler(&ISR_SystemDefaultVBlank);
return false;
}
-
+
CurrentReadBlock++;
}
}
-
+
SetVBlankHandler(&ISR_SystemDefaultVBlank);
-
+
CurrentReadBlock = 0;
-
+
return true;
}
@@ -816,13 +816,13 @@ void MemCardHandler(void)
void MemCardIconIndexHandler(void)
{
static uint8_t iconTimer = 0;
-
+
if (System100msTick() == true)
{
if (++iconTimer >= MEMCARD_ICON_INDEX_TIME)
{
iconTimer = 0;
-
+
if (++IconIndex >= MEMCARD_NUMBER_OF_ICONS)
{
IconIndex = 0;
@@ -838,12 +838,12 @@ void MemCardDrawIcon(TYPE_BLOCK_DATA * ptrBlockData, short x, short y)
short orig_u[4];
short orig_clut_x;
static bool first_access = true;
-
+
if (ptrBlockData->BlockCount == EMPTY_BLOCK)
{
return;
}
-
+
ptrBlockData->IconTPoly.x[0] = x;
ptrBlockData->IconTPoly.x[1] = x + MEMCARD_BLOCK_IMAGE_W;
ptrBlockData->IconTPoly.x[2] = x;
@@ -858,71 +858,71 @@ void MemCardDrawIcon(TYPE_BLOCK_DATA * ptrBlockData, short x, short y)
{
orig_u[i] = ptrBlockData->IconTPoly.u[i];
}
-
+
orig_clut_x = ptrBlockData->IconTPoly.cx;
-
+
if (ptrBlockData->IconNumber > IconIndex)
{
ptrBlockData->IconTPoly.u[0] += MEMCARD_BLOCK_IMAGE_W * IconIndex;
ptrBlockData->IconTPoly.u[1] = ptrBlockData->IconTPoly.u[0] + MEMCARD_BLOCK_IMAGE_W;
ptrBlockData->IconTPoly.u[2] = ptrBlockData->IconTPoly.u[0];
ptrBlockData->IconTPoly.u[3] = ptrBlockData->IconTPoly.u[1];
-
+
ptrBlockData->IconTPoly.cx += IconIndex * MEMCARD_BLOCK_CLUT_W;
}
-
+
if (first_access == true)
{
if (IconIndex == 0)
{
first_access = false;
-
+
Serial_printf("Icon index: %d\n",IconIndex);
-
+
Serial_printf("\tU = {%d,%d,%d,%d}\n",
ptrBlockData->IconTPoly.u[0],
ptrBlockData->IconTPoly.u[1],
ptrBlockData->IconTPoly.u[2],
ptrBlockData->IconTPoly.u[3]);
-
-
+
+
Serial_printf("\tV = {%d,%d,%d,%d}\n",
ptrBlockData->IconTPoly.v[0],
ptrBlockData->IconTPoly.v[1],
ptrBlockData->IconTPoly.v[2],
ptrBlockData->IconTPoly.v[3]);
-
+
Serial_printf("\tBlock number: %d\n",ptrBlockData->Block);
-
+
Serial_printf("\tBlock count: %d\n",ptrBlockData->BlockCount);
-
+
Serial_printf("\tX = {%d,%d,%d,%d}\n",
ptrBlockData->IconTPoly.x[0],
ptrBlockData->IconTPoly.x[1],
ptrBlockData->IconTPoly.x[2],
ptrBlockData->IconTPoly.x[3]);
-
+
Serial_printf("\tY = {%d,%d,%d,%d}\n",
ptrBlockData->IconTPoly.y[0],
ptrBlockData->IconTPoly.y[1],
ptrBlockData->IconTPoly.y[2],
ptrBlockData->IconTPoly.y[3]);
-
+
Serial_printf("\tTPAGE = %d\n", ptrBlockData->IconTPoly.tpage);
Serial_printf("\tCLUT = {%d, %d}\n",
ptrBlockData->IconTPoly.cx,
ptrBlockData->IconTPoly.cy);
}
}
-
+
GsSortTPoly4(&ptrBlockData->IconTPoly);
-
+
for (i = 0; i < 4; i++)
{
ptrBlockData->IconTPoly.u[i] = orig_u[i]; // Restore data
}
-
+
ptrBlockData->IconTPoly.cx = orig_clut_x;
}
@@ -940,32 +940,32 @@ TYPE_BLOCK_DATA * MemCardShowMap(void)
unsigned char orig_g;
unsigned char orig_b;
GsRectangle MemCardMapDialog;
-
+
if (MemCardGetAllData() == false)
{
return false;
}
-
+
bzero((GsRectangle*)&MemCardMapDialog, sizeof(GsRectangle));
bzero((GsRectangle*)&emptyBlockRect, sizeof(GsRectangle));
-
+
emptyBlockRect.attribute |= ENABLE_TRANS | TRANS_MODE(1);
-
+
MemCardMapDialog.x = MEMCARD_DIALOG_X;
MemCardMapDialog.y = MEMCARD_DIALOG_Y;
MemCardMapDialog.w = MEMCARD_DIALOG_W;
MemCardMapDialog.h = MEMCARD_DIALOG_H;
-
+
MemCardMapDialog.r = MEMCARD_DIALOG_R;
MemCardMapDialog.g = MEMCARD_DIALOG_G;
MemCardMapDialog.b = MEMCARD_DIALOG_B;
-
+
MemCardMapDialog.attribute |= ENABLE_TRANS | TRANS_MODE(0);
-
+
GfxSetGlobalLuminance(NORMAL_LUMINANCE);
-
+
while (1)
- {
+ {
if (PadOneKeyReleased(PAD_TRIANGLE) == true)
{
break;
@@ -1002,70 +1002,70 @@ TYPE_BLOCK_DATA * MemCardShowMap(void)
selectedBlock++;
}
}
-
+
// Dim background
SecondDisplay.r = NORMAL_LUMINANCE >> 1;
SecondDisplay.g = NORMAL_LUMINANCE >> 1;
SecondDisplay.b = NORMAL_LUMINANCE >> 1;
-
+
GfxSortSprite(&SecondDisplay);
-
+
GsSortRectangle(&MemCardMapDialog);
-
+
for (j = SLOT_ONE; j <= SLOT_TWO; j++)
{
if (MemCardStatus[j] == MEMCARD_STATUS_UNKNOWN)
{
FontSetFlags(&SmallFont, FONT_NOFLAGS);
-
+
x = MEMCARD_DIALOG_X;
x += MEMCARD_DIALOG_GAP_SLOT * j;
-
+
y = MEMCARD_DIALOG_Y;
y += (short)(MEMCARD_DIALOG_GAP_X << 1);
y += MEMCARD_DIALOG_GAP_X;
-
+
x += MEMCARD_DIALOG_GAP_X;
-
+
FontPrintText( &SmallFont,
x,
y,
"Disconnected" );
continue;
}
-
+
for (i = BLOCK_1; i <= BLOCK_15; i++)
- {
+ {
ptrBlockData = &MemCardData[i - BLOCK_1][j];
-
+
x = MEMCARD_DIALOG_X;
x += MEMCARD_DIALOG_GAP_SLOT * j;
x += ( (i - BLOCK_1) % 3) * MEMCARD_DIALOG_GAP_X;
x += MEMCARD_DIALOG_GAP_X;
-
+
y = MEMCARD_DIALOG_Y;
y += (short)(MEMCARD_DIALOG_GAP_X * ((i - BLOCK_1) / 3));
y += MEMCARD_DIALOG_GAP_X;
-
+
if (ptrBlockData->BlockCount == EMPTY_BLOCK)
{
emptyBlockRect.x = x;
emptyBlockRect.y = y;
emptyBlockRect.w = MEMCARD_BLOCK_IMAGE_W;
emptyBlockRect.h = MEMCARD_BLOCK_IMAGE_H;
-
+
if ( (i == selectedBlock) && (j == selectedSlot) )
{
emptyBlockRect.r = FULL_LUMINANCE;
emptyBlockRect.g = FULL_LUMINANCE;
emptyBlockRect.b = FULL_LUMINANCE;
-
+
FontSetFlags(&SmallFont, FONT_NOFLAGS);
-
+
FontPrintText( &SmallFont,
MEMCARD_LOAD_DATA_TEXT_X,
MEMCARD_LOAD_DATA_TEXT_Y,
- "Empty block" );
+ "Empty block" );
}
else
{
@@ -1073,42 +1073,42 @@ TYPE_BLOCK_DATA * MemCardShowMap(void)
emptyBlockRect.g = NORMAL_LUMINANCE >> 1;
emptyBlockRect.b = NORMAL_LUMINANCE >> 1;
}
-
+
GsSortRectangle(&emptyBlockRect);
-
+
continue;
}
-
+
orig_r = ptrBlockData->IconTPoly.r;
orig_g = ptrBlockData->IconTPoly.g;
orig_b = ptrBlockData->IconTPoly.b;
-
+
if ( (i == selectedBlock) && (j == selectedSlot) )
{
ptrBlockData->IconTPoly.r = FULL_LUMINANCE;
ptrBlockData->IconTPoly.g = FULL_LUMINANCE;
ptrBlockData->IconTPoly.b = FULL_LUMINANCE;
-
+
if (ptrBlockData->BlockCount == FIRST_OR_ONLY_BLOCK)
{
FontPrintText( &SmallFont,
MEMCARD_LOAD_DATA_TEXT_X,
MEMCARD_LOAD_DATA_TEXT_Y,
- (char*)ptrBlockData->FileName );
+ (char*)ptrBlockData->FileName );
}
else if (ptrBlockData->BlockCount == INTERMEDIATE_BLOCK)
{
FontPrintText( &SmallFont,
MEMCARD_LOAD_DATA_TEXT_X,
MEMCARD_LOAD_DATA_TEXT_Y,
- "Intermediate block" );
+ "Intermediate block" );
}
else if (ptrBlockData->BlockCount == LAST_BLOCK)
{
FontPrintText( &SmallFont,
MEMCARD_LOAD_DATA_TEXT_X,
MEMCARD_LOAD_DATA_TEXT_Y,
- "Last block" );
+ "Last block" );
}
}
else
@@ -1117,18 +1117,18 @@ TYPE_BLOCK_DATA * MemCardShowMap(void)
ptrBlockData->IconTPoly.g = NORMAL_LUMINANCE >> 1;
ptrBlockData->IconTPoly.b = NORMAL_LUMINANCE >> 1;
}
-
+
MemCardDrawIcon(ptrBlockData, x, y);
-
+
ptrBlockData->IconTPoly.r = orig_r;
ptrBlockData->IconTPoly.g = orig_g;
ptrBlockData->IconTPoly.b = orig_b;
}
}
-
+
GfxDrawScene_Slow();
}
-
+
return NULL;
}
@@ -1137,9 +1137,9 @@ bool MemCardSaveData(TYPE_BLOCK_DATA * ptrBlockData)
uint32_t i;
uint32_t sz;
int sector = (ptrBlockData->Block << MEMCARD_SECTORS_PER_BLOCK_BITSHIFT) + DATA_FRAME;
-
+
// Always check whether current block is empty or not
-
+
if (ptrBlockData->BlockCount != EMPTY_BLOCK)
{
if (strncmp((char*)ptrBlockData->FileName, MEMCARD_GAME_FILENAME, MEMCARD_FILENAME_SIZE) != 0)
@@ -1164,15 +1164,15 @@ bool MemCardSaveData(TYPE_BLOCK_DATA * ptrBlockData)
Serial_printf("Invalid block selected!\n");
return false;
}
-
+
// After all these checks, now we can save data!
-
+
sz = MEMCARD_FIRST_OR_LAST_DATA_SIZE;
-
+
for (i = 0; i < sz; i++)
{
McWriteSector(ptrBlockData->Slot, sector + i, &ptrBlockData->Data[i << 7 /* 128 */]);
}
-
+
return true;
}
diff --git a/Source/MemCard.h b/Source/MemCard.h
index 723e74d..77c3f33 100644
--- a/Source/MemCard.h
+++ b/Source/MemCard.h
@@ -10,10 +10,10 @@
/* *************************************
* Defines
* *************************************/
-
-/* The memory is split into 16 blocks (of 8 Kbytes each), and each block
+
+/* The memory is split into 16 blocks (of 8 Kbytes each), and each block
* is split into 64 sectors (of 128 bytes each). The first block is used
- * as Directory, the remaining 15 blocks are containing Files, each
+ * as Directory, the remaining 15 blocks are containing Files, each
* file can occupy one or more blocks. */
#define MEMCARD_BLOCKS_PER_CARD 15
@@ -30,7 +30,7 @@
/* *************************************
* Structs and enums
* *************************************/
-
+
typedef enum t_CardBlock
{
SLOT_ONE = 0,
@@ -72,25 +72,25 @@ typedef struct t_MemCard
uint8_t IconNumber; // Possible values : 1 ... 3
uint8_t FileName[MEMCARD_FILENAME_SIZE];
MEMCARD_BLOCK_COUNT BlockCount; // Look at MEMCARD_BLOCK_COUNT enum
-
+
/*
* The first some letters of the filename should indicate the game
* to which the file belongs, in case of commercial games this is
* conventionally done like so: Two character region code:
- * "BI"=Japan, "BE"=Europe, "BA"=America
+ * "BI"=Japan, "BE"=Europe, "BA"=America
* followed by 10 character game code,
* in "AAAA-NNNNN" form
- *
+ *
* Where the "AAAA" part does imply the region too;
* (SLPS/SCPS=Japan, SLUS/SCUS=America, SLES/SCES=Europe)
* (SCxS=Made by Sony, SLxS=Licensed by Sony),
* followed by up to 8 characters, "abcdefgh"
- *
+ *
* (which may identify the file if the game uses multiple files;
* this part often contains a random string which seems to be
* allowed to contain any chars in range of 20h..7Fh, of course it
* shouldn't contain "?" and "*" wildcards).*/
-
+
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!
@@ -101,9 +101,9 @@ typedef struct t_MemCard
* Global prototypes
* *************************************/
-// Inits default values for memory card blocks
+// Inits default values for memory card blocks
void MemCardInit(void);
-
+
// Sets null values to structure pointed to by ptrBlockData.
void MemCardResetBlockData(TYPE_BLOCK_DATA * ptrBlockData);
@@ -141,7 +141,7 @@ bool MemCardSaveData(TYPE_BLOCK_DATA * ptrBlockData);
/* *************************************
* Global variables
* *************************************/
-
+
extern TYPE_BLOCK_DATA MemCardData[MEMCARD_BLOCKS_PER_CARD][MEMCARD_NUMBER_OF_SLOTS];
#endif //__MEMCARD_HEADER__
diff --git a/Source/Menu.c b/Source/Menu.c
index c3a2f13..f17991e 100644
--- a/Source/Menu.c
+++ b/Source/Menu.c
@@ -1,5 +1,5 @@
/* **************************************
- * Includes *
+ * Includes *
* *************************************/
#include "Menu.h"
@@ -17,7 +17,7 @@
#include "Pad.h"
/* **************************************
- * Defines *
+ * Defines *
* *************************************/
#define BUTTON_SIZE 64
@@ -48,7 +48,7 @@ typedef enum
OPTIONS_BUTTON_INDEX,
ONE_PLAYER_BUTTON_INDEX,
TWO_PLAYER_BUTTON_INDEX,
-
+
MAIN_MENU_BUTTONS_MAX
}MMBtn_Index;
@@ -56,52 +56,52 @@ enum
{
MAIN_MENU_PLAY_BUTTON_X = 92,
MAIN_MENU_PLAY_BUTTON_Y = 92,
-
+
MAIN_MENU_OPTIONS_BUTTON_X = 225,
MAIN_MENU_OPTIONS_BUTTON_Y = 92,
-
+
MAIN_MENU_ONE_PLAYER_BUTTON_X = 92,
MAIN_MENU_ONE_PLAYER_BUTTON_Y = 92,
-
+
MAIN_MENU_TWO_PLAYER_BUTTON_X = 225,
- MAIN_MENU_TWO_PLAYER_BUTTON_Y = 92
+ MAIN_MENU_TWO_PLAYER_BUTTON_Y = 92
};
typedef enum
{
PLAY_BUTTON_U_OFFSET = 0,
PLAY_BUTTON_Y_OFFSET = 64,
-
+
ONE_PLAYER_BUTTON_U_OFFSET = 128,
ONE_PLAYER_BUTTON_Y_OFFSET = 64,
-
+
OPTIONS_BUTTON_U_OFFSET = 64,
OPTIONS_BUTTON_Y_OFFSET = 64,
-
+
TWO_PLAYER_BUTTON_U_OFFSET = 192,
TWO_PLAYER_BUTTON_Y_OFFSET = 64,
-
+
DEFAULT_BUTTON_U_OFFSET = 0,
DEFAULT_BUTTON_V_OFFSET = 128
-
+
}MMBtn_Offset;
typedef struct
{
MMBtn_Offset offset_u;
MMBtn_Offset offset_v;
-
+
// Timer for absolute, sine-like animation
short timer;
// Pointer to function executed by pressing the button
void (*f)();
-
+
MMBtn_Index i;
-
+
bool selected;
bool was_selected;
-
+
}TYPE_MMBtn;
/* **************************************
@@ -135,14 +135,14 @@ static char* MainMenuFiles[] = { "cdrom:\\DATA\\SPRITES\\MAINMENU.TIM;1" ,
"cdrom:\\DATA\\SPRITES\\BUTTONS.TIM;1" ,
#ifndef NO_INTRO
"cdrom:\\DATA\\SPRITES\\PSXDISK.TIM;1" ,
- "cdrom:\\DATA\\SPRITES\\INTROFNT.TIM;1" ,
+ "cdrom:\\DATA\\FONTS\\INTROFNT.TIM;1" ,
"cdrom:\\DATA\\SPRITES\\GPL.TIM;1" ,
"cdrom:\\DATA\\SPRITES\\OPENSRC.TIM;1" ,
"cdrom:\\DATA\\SOUNDS\\TRAYCL.VAG;1" ,
- "cdrom:\\DATA\\SOUNDS\\SPINDISK.VAG;1"
+ "cdrom:\\DATA\\SOUNDS\\SPINDISK.VAG;1"
#endif // NO_INTRO
};
-
+
static void* MainMenuDest[] = { (GsSprite*)&MenuSpr ,
(SsVag*)&BellSnd ,
(SsVag*)&AcceptSnd ,
@@ -153,7 +153,7 @@ static void* MainMenuDest[] = { (GsSprite*)&MenuSpr ,
(GsSprite*)&GPL_Logo ,
(GsSprite*)&OpenSource_Logo ,
(SsVag*)&TrayClSnd ,
- (SsVag*)&SpinDiskSnd
+ (SsVag*)&SpinDiskSnd
#endif // NO_INTRO
};
@@ -165,19 +165,19 @@ void PlayMenu(void)
{
menuLevel = ONE_TWO_PLAYERS_LEVEL;
MainMenuMinimumBtn = ONE_PLAYER_BUTTON_INDEX;
-
+
MainMenuBtn[PLAY_BUTTON_INDEX].selected = false;
MainMenuBtn[PLAY_BUTTON_INDEX].was_selected = false;
MainMenuBtn[PLAY_BUTTON_INDEX].timer = 0;
-
+
MainMenuBtn[OPTIONS_BUTTON_INDEX].selected = false;
MainMenuBtn[OPTIONS_BUTTON_INDEX].was_selected = false;
MainMenuBtn[OPTIONS_BUTTON_INDEX].timer = 0;
-
+
MainMenuBtn[ONE_PLAYER_BUTTON_INDEX].selected = true;
MainMenuBtn[ONE_PLAYER_BUTTON_INDEX].was_selected = false;
MainMenuBtn[ONE_PLAYER_BUTTON_INDEX].timer = 0;
-
+
MainMenuBtn[TWO_PLAYER_BUTTON_INDEX].selected = false;
MainMenuBtn[TWO_PLAYER_BUTTON_INDEX].was_selected = false;
MainMenuBtn[TWO_PLAYER_BUTTON_INDEX].timer = 0;
@@ -206,39 +206,39 @@ void MainMenuInit(void)
LoadMenu( MainMenuFiles,MainMenuDest,
sizeof(MainMenuFiles) / sizeof(char*) ,
sizeof(MainMenuDest) / sizeof(void*) );
-
+
MainMenuBtn[PLAY_BUTTON_INDEX].offset_u = PLAY_BUTTON_U_OFFSET;
MainMenuBtn[PLAY_BUTTON_INDEX].offset_v = PLAY_BUTTON_Y_OFFSET;
MainMenuBtn[PLAY_BUTTON_INDEX].timer = 0;
MainMenuBtn[PLAY_BUTTON_INDEX].f = &PlayMenu;
MainMenuBtn[PLAY_BUTTON_INDEX].i = PLAY_BUTTON_INDEX;
-
+
MainMenuBtn[OPTIONS_BUTTON_INDEX].offset_u = OPTIONS_BUTTON_U_OFFSET;
MainMenuBtn[OPTIONS_BUTTON_INDEX].offset_v = OPTIONS_BUTTON_Y_OFFSET;
MainMenuBtn[OPTIONS_BUTTON_INDEX].timer = 0;
MainMenuBtn[OPTIONS_BUTTON_INDEX].f = &OptionsMenu;
MainMenuBtn[OPTIONS_BUTTON_INDEX].i = OPTIONS_BUTTON_INDEX;
-
+
MainMenuBtn[ONE_PLAYER_BUTTON_INDEX].offset_u = ONE_PLAYER_BUTTON_U_OFFSET;
MainMenuBtn[ONE_PLAYER_BUTTON_INDEX].offset_v = ONE_PLAYER_BUTTON_Y_OFFSET;
MainMenuBtn[ONE_PLAYER_BUTTON_INDEX].timer = 0;
MainMenuBtn[ONE_PLAYER_BUTTON_INDEX].f = &OnePlayerMenu;
MainMenuBtn[ONE_PLAYER_BUTTON_INDEX].i = ONE_PLAYER_BUTTON_INDEX;
-
+
MainMenuBtn[TWO_PLAYER_BUTTON_INDEX].offset_u = TWO_PLAYER_BUTTON_U_OFFSET;
MainMenuBtn[TWO_PLAYER_BUTTON_INDEX].offset_v = TWO_PLAYER_BUTTON_Y_OFFSET;
MainMenuBtn[TWO_PLAYER_BUTTON_INDEX].timer = 0;
MainMenuBtn[TWO_PLAYER_BUTTON_INDEX].f = &TwoPlayerMenu;
MainMenuBtn[TWO_PLAYER_BUTTON_INDEX].i = TWO_PLAYER_BUTTON_INDEX;
-
+
menuLevel = PLAY_OPTIONS_LEVEL;
-
+
MainMenuMinimumBtn = PLAY_BUTTON_INDEX;
-
+
TestCheat.Callback = &MenuTestCheat;
memset(TestCheat.Combination,0,CHEAT_ARRAY_SIZE);
//memcpy(myarray, (int [5]){a,b,c,d,e}, 5*sizeof(int));
-
+
memcpy( TestCheat.Combination,
(unsigned short[CHEAT_ARRAY_SIZE])
{ PAD_CIRCLE, PAD_CIRCLE, PAD_CROSS, PAD_TRIANGLE,
@@ -246,12 +246,12 @@ void MainMenuInit(void)
0, 0, 0, 0,
0, 0, 0, 0 } ,
sizeof(unsigned short) * CHEAT_ARRAY_SIZE);
-
+
PadAddCheat(&TestCheat);
-
+
StackCheckCheat.Callback = &SystemPrintStackPointerAddress;
memset(StackCheckCheat.Combination, 0, CHEAT_ARRAY_SIZE);
-
+
memcpy( StackCheckCheat.Combination,
(unsigned short[CHEAT_ARRAY_SIZE])
{ PAD_TRIANGLE, PAD_TRIANGLE, PAD_CROSS, PAD_TRIANGLE,
@@ -259,7 +259,7 @@ void MainMenuInit(void)
0, 0, 0, 0,
0, 0, 0, 0 } ,
sizeof(unsigned short) * CHEAT_ARRAY_SIZE);
-
+
PadAddCheat(&StackCheckCheat);
DevMenuCheat.Callback = &SystemDevMenuToggle;
@@ -293,55 +293,39 @@ void MainMenuInit(void)
void MainMenu(void)
{
- unsigned short* cheat_array;
- uint8_t i;
MainMenuInit();
-
- #ifndef NO_INTRO
+
+#ifndef NO_INTRO
PSXSDKIntro();
- #endif //PSXSDK_DEBUG
+#endif //PSXSDK_DEBUG
GfxSetGlobalLuminance(NORMAL_LUMINANCE);
-
+
while (1)
- {
+ {
MainMenuButtonHandler();
- while (GfxIsGPUBusy() == true);
-
+ GsSortCls(0,0,40);
+
switch(menuLevel)
{
case PLAY_OPTIONS_LEVEL:
-
- GsSortCls(0,0,40);
MainMenuDrawButton(&MainMenuBtn[PLAY_BUTTON_INDEX]);
MainMenuDrawButton(&MainMenuBtn[OPTIONS_BUTTON_INDEX]);
-
- for (cheat_array = PadGetPlayerOneCheatArray(), i = 0; *cheat_array != 0; cheat_array++, i += 16)
- {
- GfxDrawButton(i, 220, *cheat_array);
- }
-
- GfxDrawScene();
break;
-
+
case ONE_TWO_PLAYERS_LEVEL:
-
+
GsSortCls(0,0,40);
MainMenuDrawButton(&MainMenuBtn[ONE_PLAYER_BUTTON_INDEX]);
MainMenuDrawButton(&MainMenuBtn[TWO_PLAYER_BUTTON_INDEX]);
-
- for (cheat_array = PadGetPlayerOneCheatArray(), i = 0; *cheat_array != 0; cheat_array++, i += 16)
- {
- GfxDrawButton(i, 220, *cheat_array);
- }
-
- GfxDrawScene();
break;
-
+
default:
break;
}
+
+ GfxDrawScene_Slow();
}
}
@@ -350,23 +334,23 @@ void MainMenuRestoreInitValues(void)
{
menuLevel = PLAY_OPTIONS_LEVEL;
MainMenuMinimumBtn = PLAY_BUTTON_INDEX;
-
+
MainMenuBtn[PLAY_BUTTON_INDEX].selected = true;
MainMenuBtn[PLAY_BUTTON_INDEX].was_selected = false;
MainMenuBtn[PLAY_BUTTON_INDEX].timer = 0;
-
+
MainMenuBtn[OPTIONS_BUTTON_INDEX].selected = false;
MainMenuBtn[OPTIONS_BUTTON_INDEX].was_selected = false;
MainMenuBtn[OPTIONS_BUTTON_INDEX].timer = 0;
-
+
MainMenuBtn[ONE_PLAYER_BUTTON_INDEX].selected = false;
MainMenuBtn[ONE_PLAYER_BUTTON_INDEX].was_selected = false;
MainMenuBtn[ONE_PLAYER_BUTTON_INDEX].timer = 0;
-
+
MainMenuBtn[TWO_PLAYER_BUTTON_INDEX].selected = false;
MainMenuBtn[TWO_PLAYER_BUTTON_INDEX].was_selected = false;
- MainMenuBtn[TWO_PLAYER_BUTTON_INDEX].timer = 0;
-
+ MainMenuBtn[TWO_PLAYER_BUTTON_INDEX].timer = 0;
+
GfxSetGlobalLuminance(NORMAL_LUMINANCE);
SfxPlayTrack(INTRO_TRACK);
@@ -377,7 +361,7 @@ void MainMenuButtonHandler(void)
static uint8_t btn_selected = PLAY_BUTTON_INDEX;
static uint8_t previous_btn_selected = 0;
uint8_t max_buttons;
-
+
if (PadOneAnyKeyPressed() == true)
{
if (SystemIsRandSeedSet() == false)
@@ -385,20 +369,20 @@ void MainMenuButtonHandler(void)
SystemSetRandSeed();
}
}
-
+
if ( (PadOneKeySinglePress(PAD_CROSS) == true)
||
(PadOneKeySinglePress(PAD_TRIANGLE) == true) )
{
SfxPlaySound(&AcceptSnd);
}
-
+
switch(menuLevel)
{
case PLAY_OPTIONS_LEVEL:
max_buttons = MAIN_MENU_PLAY_OPTIONS_LEVEL_BUTTONS;
break;
-
+
case ONE_TWO_PLAYERS_LEVEL:
if ( (btn_selected == TWO_PLAYER_BUTTON_INDEX)
@@ -420,17 +404,17 @@ void MainMenuButtonHandler(void)
}
break;
-
+
default:
max_buttons = 0;
break;
}
//DEBUG_PRINT_VAR(btn_selected);
-
+
MainMenuBtn[previous_btn_selected].was_selected = MainMenuBtn[previous_btn_selected].selected;
MainMenuBtn[btn_selected].was_selected = MainMenuBtn[btn_selected].selected;
-
+
if (PadOneKeySinglePress(PAD_LEFT) && (btn_selected > 0) )
{
MainMenuBtn[btn_selected].selected = false;
@@ -438,27 +422,27 @@ void MainMenuButtonHandler(void)
btn_selected--;
SfxPlaySound(&BellSnd);
}
- else if (PadOneKeySinglePress(PAD_RIGHT)
+ else if (PadOneKeySinglePress(PAD_RIGHT)
&&
(btn_selected < (max_buttons - 1 + MainMenuMinimumBtn) ) )
{
MainMenuBtn[btn_selected].selected = false;
previous_btn_selected = btn_selected;
- btn_selected++;
+ btn_selected++;
SfxPlaySound(&BellSnd);
}
-
+
if (btn_selected < MainMenuMinimumBtn)
{
btn_selected = MainMenuMinimumBtn;
}
-
+
if (btn_selected > (max_buttons - 1 + MainMenuMinimumBtn) )
{
// Avoid overflow when going back in menu navigation
btn_selected = (max_buttons - 1 + MainMenuMinimumBtn);
}
-
+
if (PadOneKeySinglePress(PAD_CROSS) )
{
if (menuLevel == ONE_TWO_PLAYERS_LEVEL)
@@ -473,38 +457,38 @@ void MainMenuButtonHandler(void)
{
MainMenuBtn[btn_selected].f();
}
-
-
-
+
+
+
if (menuLevel == ONE_TWO_PLAYERS_LEVEL)
{
btn_selected = PLAY_BUTTON_INDEX;
}
-
+
}
-
+
MainMenuBtn[btn_selected].selected = true;
-
+
}
void MainMenuDrawButton(TYPE_MMBtn * btn)
-{
+{
MenuSpr.w = BUTTON_SIZE;
MenuSpr.h = BUTTON_SIZE;
-
- if (btn->timer < MainMenuBtnAni_sz)
+
+ if ( (btn->timer) < (MainMenuBtnAni_sz - 1) )
{
btn->timer++;
}
-
+
if (btn->selected == true)
{
if (btn->was_selected == false)
{
btn->timer = 0;
}
-
+
MenuSpr.r = SELECTED_BUTTON_LUMINANCE;
MenuSpr.g = SELECTED_BUTTON_LUMINANCE;
MenuSpr.b = SELECTED_BUTTON_LUMINANCE;
@@ -515,42 +499,36 @@ void MainMenuDrawButton(TYPE_MMBtn * btn)
MenuSpr.g = NORMAL_LUMINANCE;
MenuSpr.b = NORMAL_LUMINANCE;
}
-
+
MenuSpr.u = DEFAULT_BUTTON_U_OFFSET;
MenuSpr.v = DEFAULT_BUTTON_V_OFFSET;
-
+
switch(btn->i)
{
case PLAY_BUTTON_INDEX:
MenuSpr.x = MAIN_MENU_PLAY_BUTTON_X;
- MenuSpr.y = MAIN_MENU_PLAY_BUTTON_Y - MainMenuBtnAni[btn->timer];
+ MenuSpr.y = MAIN_MENU_PLAY_BUTTON_Y;
MenuSpr.u += btn->offset_u;
MenuSpr.v += btn->offset_v;
-
- GsSortSprite(&MenuSpr);
break;
-
+
case OPTIONS_BUTTON_INDEX:
MenuSpr.x = MAIN_MENU_OPTIONS_BUTTON_X;
- MenuSpr.y = MAIN_MENU_OPTIONS_BUTTON_Y - MainMenuBtnAni[btn->timer];
+ MenuSpr.y = MAIN_MENU_OPTIONS_BUTTON_Y;
MenuSpr.u += btn->offset_u;
MenuSpr.v += btn->offset_v;
-
- GsSortSprite(&MenuSpr);
break;
-
+
case ONE_PLAYER_BUTTON_INDEX:
MenuSpr.x = MAIN_MENU_ONE_PLAYER_BUTTON_X;
- MenuSpr.y = MAIN_MENU_ONE_PLAYER_BUTTON_Y - MainMenuBtnAni[btn->timer];
+ MenuSpr.y = MAIN_MENU_ONE_PLAYER_BUTTON_Y;
MenuSpr.u += btn->offset_u;
MenuSpr.v += btn->offset_v;
-
- GsSortSprite(&MenuSpr);
break;
-
+
case TWO_PLAYER_BUTTON_INDEX:
MenuSpr.x = MAIN_MENU_TWO_PLAYER_BUTTON_X;
- MenuSpr.y = MAIN_MENU_TWO_PLAYER_BUTTON_Y - MainMenuBtnAni[btn->timer];
+ MenuSpr.y = MAIN_MENU_TWO_PLAYER_BUTTON_Y;
MenuSpr.u += btn->offset_u;
MenuSpr.v += btn->offset_v;
@@ -562,14 +540,14 @@ void MainMenuDrawButton(TYPE_MMBtn * btn)
MenuSpr.g = NORMAL_LUMINANCE >> 1;
MenuSpr.b = NORMAL_LUMINANCE >> 1;
}
-
- GsSortSprite(&MenuSpr);
break;
-
+
default:
break;
}
+ MenuSpr.y -= MainMenuBtnAni[btn->timer];
+ GsSortSprite(&MenuSpr);
}
void MenuTestCheat(void)
diff --git a/Source/PSXSDKIntro.c b/Source/PSXSDKIntro.c
index d73367e..941cea4 100644
--- a/Source/PSXSDKIntro.c
+++ b/Source/PSXSDKIntro.c
@@ -23,7 +23,7 @@ enum
PSX_V = 0,
PSX_X = (X_SCREEN_RESOLUTION >> 1) - (PSX_W >> 1),
PSX_Y = (Y_SCREEN_RESOLUTION >> 1) - (PSX_H >> 1),
-
+
DISK_X = PSX_X + 11,
DISK_Y = PSX_Y + 2,
DISK_W = 27,
@@ -31,29 +31,29 @@ enum
DISK_U = 2,
DISK_V = 2,
MAX_DISK_SPIN = 5,
-
+
READER_X = PSX_X + 9,
READER_Y = PSX_Y + 1,
-
+
CLOSED_READER_W = 30,
CLOSED_READER_H = 30,
CLOSED_READER_U = 0,
CLOSED_READER_V = 30,
-
+
OPEN_READER_W = CLOSED_READER_W,
OPEN_READER_H = 15,
OPEN_READER_U = 0,
OPEN_READER_V = (CLOSED_READER_H << 1) + 1,
-
+
TRANSPARENT_CLOSED_READER_W = CLOSED_READER_W,
TRANSPARENT_CLOSED_READER_H = CLOSED_READER_H,
TRANSPARENT_CLOSED_READER_U = CLOSED_READER_W,
TRANSPARENT_CLOSED_READER_V = PSX_H,
-
+
TRANSPARENT_OPEN_READER_W = OPEN_READER_W,
TRANSPARENT_OPEN_READER_H = OPEN_READER_H,
TRANSPARENT_OPEN_READER_U = OPEN_READER_W,
- TRANSPARENT_OPEN_READER_V = TRANSPARENT_CLOSED_READER_V +
+ TRANSPARENT_OPEN_READER_V = TRANSPARENT_CLOSED_READER_V +
TRANSPARENT_CLOSED_READER_H
};
@@ -146,20 +146,20 @@ void PSXSDKIntroDrawChar(short x, short y, char ch)
PSXSDKIntroFont.w = FONT_SIZE;
PSXSDKIntroFont.h = FONT_SIZE;
PSXSDKIntroFont.tpage = FONT_TPAGE;
-
+
if ( (ch >= 'A') && (ch <= 'Z') )
{
ch -= 'A'; // Reset offset
-
+
PSXSDKIntroFont.x = x;
PSXSDKIntroFont.y = y;
-
+
PSXSDKIntroFont.u = FONT_U + ( (ch % FONT_COLUMNS) << FONT_SIZE_BITSHIFT);
PSXSDKIntroFont.v = FONT_V + ((short)(ch / FONT_COLUMNS) << FONT_SIZE_BITSHIFT);
-
+
GfxSortSprite(&PSXSDKIntroFont);
}
-
+
if (ch == ' ')
{
return;
@@ -169,7 +169,7 @@ void PSXSDKIntroDrawChar(short x, short y, char ch)
void PSXSDKIntro(void)
{
int i;
-
+
PSXSDKIntroCloseShellEvent = false;
PSXSDKIntroCloseShellEventReminder = false;
PSXSDKIntroSpinDiskEvent = false;
@@ -178,29 +178,29 @@ void PSXSDKIntro(void)
PSXSDKIntroRandTextEventReminder = false;
PSXSDKIntroStringEvent = false;
PSXSDKIntroClose = false;
-
+
GfxSetGlobalLuminance(NORMAL_LUMINANCE);
-
+
while (1)
{
while (GfxIsGPUBusy() == true);
-
+
if ( ( (GfxGetGlobalLuminance() - BG_LUMINANCE_STEP) > 0)
&&
(PSXSDKIntroClose == true) )
{
GfxIncreaseGlobalLuminance(-BG_LUMINANCE_STEP);
}
-
+
if ( (GfxGetGlobalLuminance() <= BG_LUMINANCE_STEP)
&&
(PSXSDKIntroClose == true) )
{
break;
}
-
+
GsSortCls(0,0,0);
-
+
for (i = 0; i < strlen(strPSXSDKIntro) ; i++)
{
if ( (PSXSDKIntroRandTextEvent == true)
@@ -212,13 +212,13 @@ void PSXSDKIntro(void)
PSXSDKIntroRandTextEventReminder = true;
SfxPlaySound(&SpinDiskSnd);
}
-
+
PSXSDKIntroDrawChar(FONT_X + (i << FONT_SIZE_BITSHIFT),FONT_Y,SystemRand('A','Z'));
-
+
GPL_Logo.r = 0;
GPL_Logo.g = 0;
GPL_Logo.b = 0;
-
+
OpenSource_Logo.r = 0;
OpenSource_Logo.g = 0;
OpenSource_Logo.b = 0;
@@ -226,9 +226,9 @@ void PSXSDKIntro(void)
else if ( (PSXSDKIntroRandTextEvent == true)
&&
(PSXSDKIntroStringEvent == true) )
- {
+ {
PSXSDKIntroDrawChar(FONT_X + (i << FONT_SIZE_BITSHIFT),FONT_Y,strPSXSDKIntro[i]);
-
+
if (System100msTick() == true)
{
if (GPL_Logo.r < GPL_LOGO_LUMINANCE_TARGET)
@@ -237,32 +237,32 @@ void PSXSDKIntro(void)
GPL_Logo.g += GPL_LOGO_LUMINANCE_STEP;
GPL_Logo.b += GPL_LOGO_LUMINANCE_STEP;
}
-
+
GPL_Logo.x = GPL_LOGO_X;
GPL_Logo.y = GPL_LOGO_Y;
-
+
if (OpenSource_Logo.r < OPEN_SOURCE_LOGO_LUMINANCE_TARGET)
{
OpenSource_Logo.r += OPEN_SOURCE_LOGO_LUMINANCE_STEP;
OpenSource_Logo.g += OPEN_SOURCE_LOGO_LUMINANCE_STEP;
OpenSource_Logo.b += OPEN_SOURCE_LOGO_LUMINANCE_STEP;
}
-
+
OpenSource_Logo.x = OPEN_SOURCE_LOGO_X;
OpenSource_Logo.y = OPEN_SOURCE_LOGO_Y;
}
-
+
GfxSortSprite(&GPL_Logo);
GfxSortSprite(&OpenSource_Logo);
}
}
-
+
for (i = 0; i < strlen(strPSXSDKIntroAuthor) ; i++)
{
if ( (PSXSDKIntroRandTextEvent == true)
&&
(PSXSDKIntroStringEvent == false) )
- {
+ {
PSXSDKIntroDrawChar(FONT_X2 + (i << FONT_SIZE_BITSHIFT),FONT_Y2,SystemRand('A','Z'));
}
else if ( (PSXSDKIntroRandTextEvent == true)
@@ -272,49 +272,49 @@ void PSXSDKIntro(void)
PSXSDKIntroDrawChar(FONT_X2 + (i << FONT_SIZE_BITSHIFT),FONT_Y2,strPSXSDKIntroAuthor[i]);
}
}
-
+
PSXSDKIntroDrawConsole();
-
+
PSXSDKIntroDrawDisk();
-
+
if (PSXSDKIntroCloseShellEvent == true)
{
if (PSXSDKIntroCloseShellEventReminder == false)
{
PSXSDKIntroCloseShellEventReminder = true;
-
+
SfxPlaySound(&TrayClSnd);
}
-
+
PsxDisk.x = READER_X;
PsxDisk.y = READER_Y;
-
+
PsxDisk.w = CLOSED_READER_W;
PsxDisk.h = CLOSED_READER_H;
-
+
PsxDisk.u = CLOSED_READER_U;
PsxDisk.v = CLOSED_READER_V;
-
+
GfxSortSprite(&PsxDisk);
}
else
{
PsxDisk.x = READER_X;
PsxDisk.y = READER_Y;
-
+
PsxDisk.w = OPEN_READER_W;
PsxDisk.h = OPEN_READER_H;
-
+
PsxDisk.u = OPEN_READER_U;
PsxDisk.v = OPEN_READER_V;
-
+
GfxSortSprite(&PsxDisk);
}
-
+
PSXSDKIntroDrawTransCase();
-
+
GfxDrawScene();
-
+
PSXSDKIntroRunTimers();
}
}
@@ -322,9 +322,9 @@ void PSXSDKIntro(void)
void PSXSDKIntroRunTimers(void)
{
static uint16_t intro_timer = 0;
-
+
intro_timer++;
-
+
if ( (intro_timer >= CLOSE_SHELL_EV_TIM)
&&
(PSXSDKIntroCloseShellEvent == false) )
@@ -332,7 +332,7 @@ void PSXSDKIntroRunTimers(void)
PSXSDKIntroCloseShellEvent = true;
intro_timer = 0;
}
-
+
if ( (intro_timer >= DISK_SPIN_EV_TIM)
&&
(PSXSDKIntroCloseShellEvent == true)
@@ -342,7 +342,7 @@ void PSXSDKIntroRunTimers(void)
PSXSDKIntroSpinDiskEvent = true;
intro_timer = 0;
}
-
+
if ( (intro_timer >= TEXT_APPEAR_RANDOM_TIM)
&&
(PSXSDKIntroCloseShellEvent == true)
@@ -354,7 +354,7 @@ void PSXSDKIntroRunTimers(void)
PSXSDKIntroRandTextEvent = true;
intro_timer = 0;
}
-
+
if ( (intro_timer >= TEXT_APPEAR_STRING_TIM)
&&
(PSXSDKIntroCloseShellEvent == true)
@@ -369,7 +369,7 @@ void PSXSDKIntroRunTimers(void)
SfxPlayTrack(INTRO_TRACK);
intro_timer = 0;
}
-
+
if ( (intro_timer >= INTRO_CLOSE_TIM)
&&
(PSXSDKIntroCloseShellEvent == true)
@@ -383,39 +383,39 @@ void PSXSDKIntroRunTimers(void)
PSXSDKIntroClose = true;
intro_timer = 0;
}
-
-
-
+
+
+
}
void PSXSDKIntroDrawDisk(void)
{
static int spin_rotate = 0;
static int spin_speed = 0;
-
+
PsxDisk.x = DISK_X;
PsxDisk.y = DISK_Y;
-
+
PsxDisk.w = DISK_W;
PsxDisk.h = DISK_H;
-
+
PsxDisk.u = DISK_U;
PsxDisk.v = DISK_V;
-
+
if (PSXSDKIntroSpinDiskEvent == true)
{
if (PSXSDKIntroSpinDiskEventReminder == false)
{
PSXSDKIntroSpinDiskEventReminder = true;
-
+
//SfxPlaySound(&SpinDiskSnd);
}
-
+
if (spin_speed < MAX_DISK_SPIN)
{
spin_speed++;
}
-
+
if (spin_rotate < GfxRotateFromDegrees(360) )
{
spin_rotate += GfxRotateFromDegrees(spin_speed++);
@@ -424,14 +424,14 @@ void PSXSDKIntroDrawDisk(void)
{
spin_rotate = SystemRand(0,GfxRotateFromDegrees(360));
}
-
+
PsxDisk.rotate = spin_rotate;
PsxDisk.mx = DISK_W >> 1;
PsxDisk.my = DISK_H >> 1;
}
-
+
GfxSortSprite(&PsxDisk);
-
+
PsxDisk.rotate = 0;
}
@@ -441,49 +441,49 @@ void PSXSDKIntroDrawTransCase(void)
{
PsxDisk.x = READER_X;
PsxDisk.y = READER_Y;
-
+
PsxDisk.w = TRANSPARENT_OPEN_READER_W;
PsxDisk.h = TRANSPARENT_OPEN_READER_H;
-
+
PsxDisk.u = TRANSPARENT_OPEN_READER_U;
PsxDisk.v = TRANSPARENT_OPEN_READER_V;
-
+
PsxDisk.attribute |= ENABLE_TRANS | TRANS_MODE(0);
-
+
GfxSortSprite(&PsxDisk);
-
+
PsxDisk.attribute &= ~(ENABLE_TRANS | TRANS_MODE(0) );
}
else
{
PsxDisk.x = READER_X;
PsxDisk.y = READER_Y;
-
+
PsxDisk.w = TRANSPARENT_CLOSED_READER_W;
PsxDisk.h = TRANSPARENT_CLOSED_READER_H;
-
+
PsxDisk.u = TRANSPARENT_CLOSED_READER_U;
PsxDisk.v = TRANSPARENT_CLOSED_READER_V;
-
+
PsxDisk.attribute |= ENABLE_TRANS | TRANS_MODE(0);
-
+
GfxSortSprite(&PsxDisk);
-
+
PsxDisk.attribute &= ~(ENABLE_TRANS | TRANS_MODE(0) );
}*/
-
+
}
void PSXSDKIntroDrawConsole(void)
{
PsxDisk.x = PSX_X;
PsxDisk.y = PSX_Y;
-
+
PsxDisk.w = PSX_W;
PsxDisk.h = PSX_H;
-
+
PsxDisk.u = PSX_U;
PsxDisk.v = PSX_V;
-
+
GfxSortSprite(&PsxDisk);
}
diff --git a/Source/Pad.c b/Source/Pad.c
index 71b1fdc..0f7fe82 100644
--- a/Source/Pad.c
+++ b/Source/Pad.c
@@ -22,27 +22,27 @@
enum
{
-
+
PAD_CROSS_INDEX = 0,
PAD_SQUARE_INDEX,
PAD_TRIANGLE_INDEX,
PAD_CIRCLE_INDEX,
-
+
PAD_DOWN_INDEX,
PAD_LEFT_INDEX,
PAD_UP_INDEX,
PAD_RIGHT_INDEX,
-
+
PAD_L1_INDEX,
PAD_L2_INDEX,
-
+
PAD_R1_INDEX,
PAD_R2_INDEX,
-
+
NUMBER_OF_KEYS
-
+
};
-
+
/* *************************************
* Local Prototypes
@@ -102,9 +102,9 @@ static TYPE_CHEAT * cheatsArray[PAD_MAX_CHEATS];
psx_pad_state PadOneGetState(void)
{
psx_pad_state PadOne;
-
+
PSX_PollPad_Fast(PAD_ONE, &PadOne);
-
+
return PadOne;
}
@@ -116,9 +116,9 @@ unsigned char PadOneGetType(void)
psx_pad_state PadTwoGetState(void)
{
psx_pad_state PadTwo;
-
+
PSX_PollPad_Fast(PAD_TWO, &PadTwo);
-
+
return PadTwo;
}
@@ -137,21 +137,21 @@ bool PadOneConnected(void)
{
return false;
}
-
+
return true;
}
bool PadTwoConnected(void)
{
psx_pad_state PadTwo = PadTwoGetState();
-
+
if ( (PadTwo.status != PAD_STATUS_OK)
&&
(PadTwoGetID() == PAD_FLOATING_ID) )
{
return false;
}
-
+
return true;
}
@@ -230,26 +230,26 @@ bool PadTwoKeyPressed(unsigned short key)
}
bool PadOneKeySinglePress(unsigned short key)
-{
+{
return (bool)( !(previous_pad1 & key) && (pad1 & key) );
}
bool PadTwoKeySinglePress(unsigned short key)
-{
+{
return (bool)( !(previous_pad2 & key) && (pad2 & key) );
}
bool PadOneKeyRepeat(unsigned short key, uint8_t time)
{
uint8_t key_index = PadGetKeyIndex(key);
-
+
if (key_index == NUMBER_OF_KEYS)
{
return false;
}
-
+
pad1_keys_repeat[key_index]++;
-
+
if (pad1_keys_repeat[key_index] >= time)
{
pad1_keys_repeat[key_index] = 0;
@@ -262,20 +262,20 @@ bool PadOneKeyRepeat(unsigned short key, uint8_t time)
bool PadTwoKeyRepeat(unsigned short key, uint8_t time)
{
uint8_t key_index = PadGetKeyIndex(key);
-
+
if (key_index == NUMBER_OF_KEYS)
{
return false;
}
-
+
pad2_keys_repeat[key_index]++;
-
+
if (pad2_keys_repeat[key_index] >= time)
{
pad2_keys_repeat[key_index] = 0;
return true;
}
-
+
return false;
}
@@ -296,7 +296,7 @@ void PadTwoVibrationHandler(void)
pad_enable_vibration(PAD_TWO);
pad_set_vibration(PAD_TWO,pad2_small_vibration_force,pad2_big_vibration_force);
pad2_vibration_timer--;
- }
+ }
}
bool PadOneIsVibrationEnabled(void)
@@ -314,15 +314,15 @@ bool UpdatePads(void)
unsigned short adc_mouse;
static unsigned short old_adc_mouse;
bool both_pads_connected = true;
-
+
PadOneVibrationHandler();
-
+
PadTwoVibrationHandler();
-
+
PadCheatHandler(PAD_ONE);
-
+
PadCheatHandler(PAD_TWO);
-
+
// Get now-old pad data
previous_pad1 = pad1;
previous_pad2 = pad2;
@@ -342,7 +342,7 @@ bool UpdatePads(void)
{
PSX_ReadPad(&pad1,&pad2);
}
-
+
if (PadOneConnected() == false)
{
both_pads_connected = false;
@@ -370,7 +370,7 @@ bool UpdatePads(void)
{
pad2_last_key_single_pressed = 0;
}
-
+
return both_pads_connected;
}
@@ -391,51 +391,51 @@ uint8_t PadGetKeyIndex(unsigned short key)
case PAD_CROSS:
return PAD_CROSS_INDEX;
break;
-
+
case PAD_SQUARE:
return PAD_SQUARE_INDEX;
break;
-
+
case PAD_TRIANGLE:
return PAD_TRIANGLE_INDEX;
break;
-
+
case PAD_CIRCLE:
return PAD_CIRCLE_INDEX;
break;
-
+
case PAD_DOWN:
return PAD_DOWN_INDEX;
break;
-
+
case PAD_LEFT:
return PAD_LEFT_INDEX;
break;
-
+
case PAD_UP:
return PAD_UP_INDEX;
break;
-
+
case PAD_RIGHT:
return PAD_RIGHT_INDEX;
break;
-
+
case PAD_L1:
return PAD_L1_INDEX;
break;
-
+
case PAD_R1:
return PAD_R1_INDEX;
break;
-
+
case PAD_L2:
return PAD_L2_INDEX;
break;
-
+
case PAD_R2:
return PAD_R2_INDEX;
break;
-
+
default:
return NUMBER_OF_KEYS;
break;
@@ -451,7 +451,7 @@ void PadClearData(void)
{
pad1 = 0;
pad2 = 0;
-
+
previous_pad1 = 0;
previous_pad2 = 0;
}
@@ -460,16 +460,16 @@ void PadInit(void)
{
pad1_cheat_timer = TimerCreate(PAD_CHEAT_TIMEOUT,true /* Repeat flag */,&PadOneCleanCheatArray);
pad2_cheat_timer = TimerCreate(PAD_CHEAT_TIMEOUT,true /* Repeat flag */,&PadTwoCleanCheatArray);
-
+
memset(cheatsArray,0, sizeof(cheatsArray));
}
void PadCheatHandler(uint8_t n_pad)
{
- unsigned short available_keys[12] = { PAD_LEFT, PAD_RIGHT, PAD_UP, PAD_DOWN,
+ unsigned short available_keys[12] = { PAD_LEFT, PAD_RIGHT, PAD_UP, PAD_DOWN,
PAD_L2, PAD_R2, PAD_L1, PAD_R1,
PAD_TRIANGLE, PAD_CIRCLE, PAD_CROSS, PAD_SQUARE };
-
+
uint8_t i;
uint8_t keys_released = 0;
unsigned short key;
@@ -479,7 +479,7 @@ void PadCheatHandler(uint8_t n_pad)
bool success = false;
unsigned short* cheat_array;
TYPE_TIMER* timer;
-
+
switch(n_pad)
{
case PAD_ONE:
@@ -488,19 +488,19 @@ void PadCheatHandler(uint8_t n_pad)
clean_callback = &PadOneCleanCheatArray;
timer = pad1_cheat_timer;
break;
-
+
case PAD_TWO:
pressed_callback = &PadTwoKeySinglePress;
cheat_array = pad2_cheat_array;
clean_callback = &PadTwoCleanCheatArray;
timer = pad2_cheat_timer;
break;
-
+
default:
Serial_printf("Invalid pad called for PadCheatHandler()!\n");
return;
}
-
+
for (i = 0; i < PAD_MAX_CHEATS; i++)
{
if (cheatsArray[i] != NULL)
@@ -513,15 +513,15 @@ void PadCheatHandler(uint8_t n_pad)
{
clean_callback();
}
-
+
cheatsArray[i]->Callback();
-
+
return;
}
}
}
}
-
+
for (i = 0; i < sizeof(available_keys) / sizeof(unsigned short); i++)
{
if (pressed_callback(available_keys[i]) == true)
@@ -531,12 +531,12 @@ void PadCheatHandler(uint8_t n_pad)
keys_released++;
}
}
-
+
if (keys_released != 1)
{
return;
}
-
+
// Check for full array (return success = true if an empty array
// element was found.
for (j = 0; j < CHEAT_ARRAY_SIZE; j++)
@@ -547,7 +547,7 @@ void PadCheatHandler(uint8_t n_pad)
break;
}
}
-
+
if (success == false)
{
if (clean_callback != NULL)
@@ -556,22 +556,22 @@ void PadCheatHandler(uint8_t n_pad)
clean_callback();
}
}
-
+
cheat_array[j] = key;
}
bool PadAddCheat(TYPE_CHEAT * cheat)
{
static uint8_t idx = 0;
-
+
if (idx >= PAD_MAX_CHEATS)
{
Serial_printf("Maximum number of cheats exceeded!\n");
return false;
}
-
+
cheatsArray[idx++] = cheat;
-
+
return true;
}
@@ -581,7 +581,7 @@ void PadOneCleanCheatArray(void)
}
void PadTwoCleanCheatArray(void)
-{
+{
memset(pad2_cheat_array,0,sizeof(unsigned short) * CHEAT_ARRAY_SIZE);
}
diff --git a/Source/Pad.h b/Source/Pad.h
index 458260c..c09ec9d 100644
--- a/Source/Pad.h
+++ b/Source/Pad.h
@@ -17,7 +17,7 @@
/* *************************************
* Global prototypes
* *************************************/
-
+
void PadInit(void);
void PadClearData(void);
diff --git a/Source/PltParser.c b/Source/PltParser.c
index 5a07c7b..ad7cf76 100644
--- a/Source/PltParser.c
+++ b/Source/PltParser.c
@@ -9,7 +9,7 @@
/* *************************************
* Defines
* *************************************/
-
+
#define LINE_MAX_CHARACTERS 100
/* **************************************
@@ -63,15 +63,15 @@ bool PltParserLoadFile(char* strPath, TYPE_FLIGHT_DATA* ptrFlightData)
}
strPltBuffer = SystemGetBufferAddress();
-
+
PltParserResetBuffers(ptrFlightData);
-
+
// Now, buffer shall be read from line to line
-
+
buffer = strtok_r((char*)strPltBuffer,"\n",&pltBufferSavePtr);
-
+
aircraftIndex = 0;
-
+
while (buffer != NULL)
{
if (buffer[0] == '#')
@@ -80,28 +80,28 @@ bool PltParserLoadFile(char* strPath, TYPE_FLIGHT_DATA* ptrFlightData)
buffer = strtok_r(NULL,"\n",&pltBufferSavePtr);
continue;
}
-
+
if (first_line_read == false)
{
// First (non-comment) line should indicate level time
// i.e.: 10:30, or 22:45
first_line_read = true;
-
+
if (strlen(buffer) != PLT_FIRST_LINE_CHARACTERS)
{
// Format should always be HH:MM (5 characters)
// Treat any other combination as possible error
return false;
}
-
+
if (buffer[PLT_COLON_POSITION] != ':')
{
// Check whether time format is HH:MM
return false;
}
-
+
j = 0;
-
+
for (i = 0; i < PLT_FIRST_LINE_CHARACTERS ; i++)
{
if (i == PLT_COLON_POSITION)
@@ -127,19 +127,19 @@ bool PltParserLoadFile(char* strPath, TYPE_FLIGHT_DATA* ptrFlightData)
{
// File header (initial game time) has already been read
strncpy(lineBuffer, buffer, LINE_MAX_CHARACTERS);
-
+
lineBufferPtr = strtok(lineBuffer,";");
-
+
i = 0;
-
+
Serial_printf("New line read: %s\n",buffer);
-
+
while (lineBufferPtr != NULL)
{
switch(i)
{
case DEPARTURE_ARRIVAL_INDEX:
-
+
if (strncmp(lineBufferPtr,"DEPARTURE",strlen("DEPARTURE") ) == 0)
{
ptrFlightData->FlightDirection[aircraftIndex] = DEPARTURE;
@@ -155,18 +155,18 @@ bool PltParserLoadFile(char* strPath, TYPE_FLIGHT_DATA* ptrFlightData)
Serial_printf("Flight direction is not correct!\n");
}
break;
-
+
case FLIGHT_NUMBER_INDEX:
strncpy(ptrFlightData->strFlightNumber[aircraftIndex],lineBufferPtr,GAME_MAX_CHARACTERS);
ptrFlightData->strFlightNumber[aircraftIndex][GAME_MAX_CHARACTERS - 1] = '\0';
Serial_printf("Aircraft %d flight number set to %s.\n",aircraftIndex,ptrFlightData->strFlightNumber[aircraftIndex]);
break;
-
+
case PASSENGERS_INDEX:
ptrFlightData->Passengers[aircraftIndex] = atoi(lineBufferPtr);
Serial_printf("Aircraft %d passengers set to %d.\n",aircraftIndex,ptrFlightData->Passengers[aircraftIndex]);
break;
-
+
case PARKING_INDEX:
if (ptrFlightData->FlightDirection[aircraftIndex] == DEPARTURE)
{
@@ -178,24 +178,24 @@ bool PltParserLoadFile(char* strPath, TYPE_FLIGHT_DATA* ptrFlightData)
}
Serial_printf("Aircraft %d parking set to %d.\n",aircraftIndex,ptrFlightData->Parking[aircraftIndex]);
break;
-
+
case HOURS_MINUTES_INDEX:
if ( strlen(lineBufferPtr) != strlen("HH:MM") )
{
Serial_printf("Hour minute format is not correct!\n");
break;
}
-
+
// Copy hour
strHour[0] = lineBufferPtr[0];
strHour[1] = lineBufferPtr[1];
// Copy minutes
strMinutes[0] = lineBufferPtr[3];
strMinutes[1] = lineBufferPtr[4];
-
+
ptrFlightData->Hours[aircraftIndex] = (uint8_t)atoi(strHour);
ptrFlightData->Minutes[aircraftIndex] = (uint8_t)atoi(strMinutes);
-
+
Serial_printf("Aircraft %d time set to %.2d:%.2d.\n", aircraftIndex,
ptrFlightData->Hours[aircraftIndex],
ptrFlightData->Minutes[aircraftIndex] );
@@ -205,40 +205,40 @@ bool PltParserLoadFile(char* strPath, TYPE_FLIGHT_DATA* ptrFlightData)
ptrFlightData->RemainingTime[aircraftIndex] = (uint16_t)atoi(lineBufferPtr);
Serial_printf("ptrFlightData->RemainingTime[%d] = %d\n", aircraftIndex, ptrFlightData->RemainingTime[aircraftIndex]);
break;
-
-
+
+
default:
break;
}
-
+
lineBufferPtr = strtok(NULL,";");
i++;
}
-
+
ptrFlightData->State[aircraftIndex] = STATE_IDLE;
aircraftIndex++;
}
-
+
buffer = strtok_r(NULL,"\n",&pltBufferSavePtr);
}
-
+
ptrFlightData->nAircraft = aircraftIndex; //Set total number of aircraft used
ptrFlightData->ActiveAircraft = 0;
-
+
Serial_printf("Number of aircraft parsed: %d\n",ptrFlightData->nAircraft);
-
+
return true;
}
void PltParserResetBuffers(TYPE_FLIGHT_DATA* ptrFlightData)
{
uint8_t i;
-
+
for (i = 0; i < GAME_MAX_AIRCRAFT ; i++)
{
memset(ptrFlightData->strFlightNumber[i],'\0',GAME_MAX_CHARACTERS);
}
-
+
memset(ptrFlightData->FlightDirection,DEPARTURE,GAME_MAX_AIRCRAFT);
memset(ptrFlightData->Passengers,0,GAME_MAX_AIRCRAFT);
memset(ptrFlightData->Hours,0,GAME_MAX_AIRCRAFT);
@@ -342,7 +342,7 @@ uint8_t* PltParserGenerateFile(TYPE_PLT_CONFIG* ptrPltConfig)
for (j = 0; j < nAircraft; j++)
{
uint8_t dep_arr_rand = SystemRand(0,100);
-
+
if (dep_arr_rand < 50)
{
// Set departure flight
diff --git a/Source/Serial.c b/Source/Serial.c
index 8711245..528e97b 100644
--- a/Source/Serial.c
+++ b/Source/Serial.c
@@ -52,7 +52,7 @@ bool SerialRead(uint8_t* ptrArray, size_t nBytes)
do
{
//uint16_t timeout = SERIAL_TX_RX_TIMEOUT;
-
+
while ( (SIOCheckInBuffer() == SERIAL_RX_FIFO_EMPTY)); // Wait for RX FIFO not empty
*(ptrArray++) = SIOReadByte();
diff --git a/Source/Sfx.c b/Source/Sfx.c
index 905cefb..a79a308 100644
--- a/Source/Sfx.c
+++ b/Source/Sfx.c
@@ -44,15 +44,15 @@ bool SfxUploadSound(char* file_path, SsVag * vag)
{
return false;
}
-
+
if (voiceIndex < NUMBER_OF_VOICES)
{
SsReadVag(vag,SystemGetBufferAddress());
-
+
SsUploadVag(vag);
-
+
vag->cur_voice = voiceIndex;
-
+
voiceIndex++;
Serial_printf("SPU voices used = %d\n", voiceIndex);
@@ -76,7 +76,7 @@ bool SfxUploadSound(char* file_path, SsVag * vag)
Serial_printf("Maximum number of SPU voices exceeded!\n");
return false; //Maximum voices exceeded
}
-
+
return true;
}
@@ -96,17 +96,17 @@ void SfxStopMusic(void)
uint64_t timer = SystemGetGlobalTimer();
uint16_t CDVol = 0x7FFF;
uint8_t time_step = 5;
-
+
while (CDVol > 0x3F)
{
CDVol>>=1;
SsCdVol(CDVol,CDVol);
-
+
while (SystemGetGlobalTimer() < (timer + time_step) );
-
+
timer = SystemGetGlobalTimer();
}
-
+
CdSendCommand(CdlMute,0);
#endif
}
diff --git a/Source/Sfx.h b/Source/Sfx.h
index f687353..1d4e8c0 100644
--- a/Source/Sfx.h
+++ b/Source/Sfx.h
@@ -11,7 +11,7 @@
/* *************************************
* Defines
* *************************************/
-
+
/* *************************************
* Structs and enums
* *************************************/
diff --git a/Source/System.c b/Source/System.c
index 001a01d..675b0aa 100644
--- a/Source/System.c
+++ b/Source/System.c
@@ -14,7 +14,7 @@
* Defines
* *************************************/
-#define FILE_BUFFER_SIZE 0x20014
+#define FILE_BUFFER_SIZE (128 << 10) // 128 KB
#define END_STACK_PATTERN (uint32_t) 0x18022015
#define BEGIN_STACK_ADDRESS (uint32_t*) 0x801FFF00
@@ -24,7 +24,7 @@
/* *************************************
* Local Prototypes
* *************************************/
-
+
static void SystemCheckTimer(bool* timer, uint64_t* last_timer, uint8_t step);
static void SystemSetStackPattern(void);
static void ISR_RootCounter2(void);
@@ -59,15 +59,15 @@ static bool devmenu_flag;
static unsigned char sine_counter;
/* *******************************************************************
- *
+ *
* @name: void SystemInit(void)
- *
+ *
* @author: Xavier Del Campo
- *
+ *
* @brief: Calls main intialization routines.
- *
+ *
* @remarks: To be called before main loop.
- *
+ *
* *******************************************************************/
void SystemInit(void)
@@ -76,7 +76,7 @@ void SystemInit(void)
global_timer = 0;
//Reset 1 second timer
one_second_timer = 0;
-
+
//PSXSDK init
#ifdef SERIAL_INTERFACE
// PSX_INIT_SAVESTATE | PSX_INIT_CD flags are not needed
@@ -118,11 +118,11 @@ void SystemInit(void)
devmenu_flag = false;
//Emergency mode flag
emergency_mode = false;
-
+
GfxSetGlobalLuminance(NORMAL_LUMINANCE);
-
+
SystemSetStackPattern();
-
+
//SetRCntHandler(&ISR_RootCounter2, 2, 0xA560);
Serial_printf("Begin SetRCntHandler\n");
@@ -141,19 +141,19 @@ void ISR_RootCounter2(void)
}
/* *******************************************************************
- *
+ *
* @name: void SystemSetRandSeed(void)
- *
+ *
* @author: Xavier Del Campo
- *
+ *
* @brief:
* Calls srand() while avoiding multiple calls by setting internal
* variable rand_seed to true. Internal variable "global_timer" is
* used to generate the new seed.
- *
+ *
* @remarks:
* It is recommended to call it once user has pressed any key.
- *
+ *
* *******************************************************************/
void SystemSetRandSeed(void)
@@ -163,25 +163,25 @@ void SystemSetRandSeed(void)
rand_seed = true;
//Set random seed using global timer as reference
srand((unsigned int)global_timer);
-
+
Serial_printf("Seed used: %d\n",(unsigned int)global_timer);
}
}
/* *******************************************************************
- *
+ *
* @name: bool SystemIsRandSeedSet(void)
- *
+ *
* @author: Xavier Del Campo
- *
+ *
* @brief:
* Reportedly, returns whether rand seed has already been set.
- *
+ *
* @remarks:
*
* @return:
* Reportedly, returns whether rand seed has already been set.
- *
+ *
* *******************************************************************/
bool SystemIsRandSeedSet(void)
@@ -190,18 +190,18 @@ bool SystemIsRandSeedSet(void)
}
/* *******************************************************************
- *
+ *
* @name: bool SystemRefreshNeeded(void)
- *
+ *
* @author: Xavier Del Campo
- *
+ *
* @brief:
- *
+ *
* @remarks:
*
* @return:
* Returns whether VSync flag has been enabled.
- *
+ *
* *******************************************************************/
bool SystemRefreshNeeded(void)
@@ -210,17 +210,17 @@ bool SystemRefreshNeeded(void)
}
/* *******************************************************************
- *
+ *
* @name: void ISR_SystemDefaultVBlank(void)
- *
+ *
* @author: Xavier Del Campo
- *
+ *
* @brief:
- *
+ *
* @remarks:
* Called from VSync interrupt. Called 50 times a second in PAL mode,
* 60 times a second in NTSC mode.
- *
+ *
* *******************************************************************/
void ISR_SystemDefaultVBlank(void)
@@ -230,21 +230,21 @@ void ISR_SystemDefaultVBlank(void)
fps = temp_fps;
temp_fps = 0;
}
-
+
refresh_needed = true;
}
/* *******************************************************************
- *
+ *
* @name: void SystemAcknowledgeFrame(void)
- *
+ *
* @author: Xavier Del Campo
- *
+ *
* @brief:
- *
+ *
* @remarks:
* Called by Game module in order to calculate frames per second.
- *
+ *
* *******************************************************************/
void SystemAcknowledgeFrame(void)
@@ -253,18 +253,18 @@ void SystemAcknowledgeFrame(void)
}
/* *******************************************************************
- *
+ *
* @name: void SystemAcknowledgeFrame(void)
- *
+ *
* @author: Xavier Del Campo
- *
+ *
* @brief:
* Creates a sine-line (more exactly, a parabola-like) effect and
* stores its value into a variable.
- *
+ *
* @remarks:
* To be called only once, preferibly on SystemCyclic().
- *
+ *
* *******************************************************************/
void SystemCalculateSine(void)
@@ -275,7 +275,7 @@ void SystemCalculateSine(void)
SINE_EFFECT_MAX = 240
};
- static bool sine_decrease = false;
+ static bool sine_decrease = false;
if (sine_decrease == false)
{
@@ -302,15 +302,15 @@ void SystemCalculateSine(void)
}
/* *******************************************************************
- *
+ *
* @name: unsigned char SystemGetSineValue(void)
- *
+ *
* @author: Xavier Del Campo
*
* @return:
* Returns a value which oscillates like a sine (more exactly, like
* a parabola) function to be used wherever you want.
- *
+ *
* *******************************************************************/
unsigned char SystemGetSineValue(void)
@@ -319,17 +319,17 @@ unsigned char SystemGetSineValue(void)
}
/* *******************************************************************
- *
+ *
* @name: void SystemIncreaseGlobalTimer(void)
- *
+ *
* @author: Xavier Del Campo
- *
+ *
* @brief:
* Increases internal variable responsible for time handling.
- *
+ *
* @remarks:
* Usually called from ISR_SystemDefaultVBlank().
- *
+ *
* *******************************************************************/
void SystemIncreaseGlobalTimer(void)
@@ -338,13 +338,13 @@ void SystemIncreaseGlobalTimer(void)
}
/* *******************************************************************
- *
+ *
* @name: uint64_t SystemGetGlobalTimer(void)
- *
+ *
* @author: Xavier Del Campo
- *
+ *
* @brief: Returns internal global timer value.
- *
+ *
* *******************************************************************/
uint64_t SystemGetGlobalTimer(void)
@@ -353,13 +353,13 @@ uint64_t SystemGetGlobalTimer(void)
}
/* *******************************************************************
- *
+ *
* @name: void SystemDisableScreenRefresh(void)
- *
+ *
* @author: Xavier Del Campo
- *
+ *
* @brief: Resets VBlank IRQ flag.
- *
+ *
* *******************************************************************/
void SystemDisableScreenRefresh(void)
@@ -368,14 +368,14 @@ void SystemDisableScreenRefresh(void)
}
/* *******************************************************************
- *
+ *
* @name: bool System1SecondTick(void)
- *
+ *
* @author: Xavier Del Campo
- *
+ *
* @return: bool variable with a 1-cycle-length pulse that gets
* set each second.
- *
+ *
* *******************************************************************/
bool System1SecondTick(void)
@@ -384,14 +384,14 @@ bool System1SecondTick(void)
}
/* *******************************************************************
- *
+ *
* @name: bool System100msTick(void)
- *
+ *
* @author: Xavier Del Campo
- *
+ *
* @return: bool variable with a 1-cycle-length pulse that gets
* set every 100 milliseconds.
- *
+ *
* *******************************************************************/
bool System100msTick(void)
@@ -400,14 +400,14 @@ bool System100msTick(void)
}
/* *******************************************************************
- *
+ *
* @name bool System500msTick(void)
- *
+ *
* @author: Xavier Del Campo
- *
+ *
* @return: bool variable with a 1-cycle-length pulse that gets
* set every 500 milliseconds.
- *
+ *
* *******************************************************************/
bool System500msTick(void)
@@ -416,15 +416,15 @@ bool System500msTick(void)
}
/* *******************************************************************
- *
- * @name void SystemRunTimers(void)
- *
+ *
+ * @name void SystemRunTimers(void)
+ *
* @author: Xavier Del Campo
- *
+ *
* @brief: general timer handler
*
* @remarks: 1 second, 500 ms and 100 ms ticks get updated here.
- *
+ *
* *******************************************************************/
void SystemRunTimers(void)
@@ -434,26 +434,26 @@ void SystemRunTimers(void)
static uint64_t last_500_ms_tick;
SystemCheckTimer(&one_second_timer, &last_one_second_tick, REFRESH_FREQUENCY);
-
+
#ifdef _PAL_MODE_
SystemCheckTimer(&hundred_ms_timer, &last_100_ms_tick, 2 /* 2 * 50 ms = 100 ms */);
SystemCheckTimer(&five_hundred_ms_timer, &last_500_ms_tick, 10 /* 10 * 50 ms = 500 ms */);
#else // _PAL_MODE_
SystemCheckTimer(&hundred_ms_timer, &last_100_ms_tick, 3);
#endif // _PAL_MODE_
-
+
}
/* ********************************************************************************
- *
+ *
* @name void SystemCheckTimer(bool* timer, uint64_t* last_timer, uint8_t step)
- *
+ *
* @author: Xavier Del Campo
- *
+ *
* @brief: Checks if needed time step has been elapsed. If true, flag gets set.
- *
+ *
* *******************************************************************************/
-
+
void SystemCheckTimer(bool* timer, uint64_t* last_timer, uint8_t step)
{
if (*timer == true)
@@ -469,16 +469,16 @@ void SystemCheckTimer(bool* timer, uint64_t* last_timer, uint8_t step)
}
/* ****************************************************************************************
- *
+ *
* @name bool SystemLoadFileToBuffer(char* fname, uint8_t* buffer, uint32_t szBuffer)
- *
+ *
* @author: Xavier Del Campo
- *
+ *
* @brief: Given an input path, it fills a buffer pointed to by "buffer" with
* maximum size "szBuffer" with data from CD-ROM.
*
* @return: true if file has been loaded successfully, false otherwise.
- *
+ *
* ****************************************************************************************/
bool SystemLoadFileToBuffer(char* fname, uint8_t* buffer, uint32_t szBuffer)
@@ -490,16 +490,16 @@ bool SystemLoadFileToBuffer(char* fname, uint8_t* buffer, uint32_t szBuffer)
FILE *f;
#endif // SERIAL_INTERFACE
int32_t size = 0;
-
+
// Wait for possible previous operation from the GPU before entering this section.
while ( (SystemIsBusy() == true) || (GfxIsGPUBusy() == true) );
-
+
if (fname == NULL)
{
Serial_printf("SystemLoadFile: NULL fname!\n");
return false;
}
-
+
memset(buffer,0,szBuffer);
#ifdef SERIAL_INTERFACE
@@ -540,7 +540,7 @@ bool SystemLoadFileToBuffer(char* fname, uint8_t* buffer, uint32_t szBuffer)
SystemDisableVBlankInterrupt();
f = fopen(fname, "r");
-
+
if (f == NULL)
{
Serial_printf("SystemLoadFile: file could not be found!\n");
@@ -551,18 +551,18 @@ bool SystemLoadFileToBuffer(char* fname, uint8_t* buffer, uint32_t szBuffer)
fseek(f, 0, SEEK_END);
size = ftell(f);
-
+
if (size > szBuffer)
{
Serial_printf("SystemLoadFile: Exceeds file buffer size (%d bytes)\n",size);
//Bigger than 128 kB (buffer's max size)
return false;
}
-
+
fseek(f, 0, SEEK_SET); //f->pos = 0;
-
+
fread(buffer, sizeof(char), size, f);
-
+
fclose(f);
SystemEnableVBlankInterrupt();
@@ -570,22 +570,22 @@ bool SystemLoadFileToBuffer(char* fname, uint8_t* buffer, uint32_t szBuffer)
system_busy = false;
#endif // SERIAL_INTERFACE
-
+
Serial_printf("File \"%s\" loaded successfully!\n",fname);
-
+
return true;
}
/* ****************************************************************************************
- *
+ *
* @name bool SystemLoadFile(char*fname)
- *
+ *
* @author: Xavier Del Campo
- *
+ *
* @brief: Given an input file name, it loads its conents into internal buffer.
*
* @return: true if file has been loaded successfully, false otherwise.
- *
+ *
* ****************************************************************************************/
bool SystemLoadFile(char*fname)
@@ -594,13 +594,13 @@ bool SystemLoadFile(char*fname)
}
/* ******************************************************************
- *
+ *
* @name uint8_t* SystemGetBufferAddress(void)
- *
+ *
* @author: Xavier Del Campo
*
* @return: Reportedly, returns internal buffer initial address.
- *
+ *
* *****************************************************************/
uint8_t* SystemGetBufferAddress(void)
@@ -609,13 +609,13 @@ uint8_t* SystemGetBufferAddress(void)
}
/* ******************************************************************
- *
+ *
* @name void SystemClearBuffer(void)
- *
+ *
* @author: Xavier Del Campo
*
* @return: Fills internal buffer with zeros
- *
+ *
* *****************************************************************/
void SystemClearBuffer(void)
@@ -624,33 +624,33 @@ void SystemClearBuffer(void)
}
/* ******************************************************************
- *
+ *
* @name void SystemWaitCycles(uint32_t cycles)
- *
+ *
* @author: Xavier Del Campo
*
* @return: halts program execution for n-"cycles"
- *
+ *
* *****************************************************************/
void SystemWaitCycles(uint32_t cycles)
{
uint64_t currentTime = global_timer;
-
+
while (global_timer < (currentTime + cycles) );
}
/* ******************************************************************
- *
+ *
* @name uint32_t SystemRand(uint32_t min, uint32_t max)
- *
+ *
* @author: Xavier Del Campo
*
* @return: random number between "min" and "max".
*
* @remarks: rand seed must be set before using this function, or
* you will predictable values otherwise!
- *
+ *
* *****************************************************************/
uint32_t SystemRand(uint32_t min, uint32_t max)
@@ -659,20 +659,20 @@ uint32_t SystemRand(uint32_t min, uint32_t max)
{
Serial_printf("Warning: calling rand() before srand()\n");
}
-
+
return rand() % (max - min + 1) + min;
}
/* ***********************************************************************
- *
+ *
* @name void SystemSetEmergencyMode(bool value)
- *
+ *
* @author: Xavier Del Campo
*
* @brief: Sets emergency mode flag.
*
* @remarks: emergency mode is set once that a controller is unplugged.
- *
+ *
* ***********************************************************************/
void SystemSetEmergencyMode(bool value)
@@ -681,13 +681,13 @@ void SystemSetEmergencyMode(bool value)
}
/* ***********************************************************************
- *
+ *
* @name bool SystemGetEmergencyMode(void)
- *
+ *
* @author: Xavier Del Campo
*
* @return: returns emergency mode flag.
- *
+ *
* ***********************************************************************/
bool SystemGetEmergencyMode(void)
@@ -696,13 +696,13 @@ bool SystemGetEmergencyMode(void)
}
/* ***********************************************************************
- *
+ *
* @name volatile bool SystemIsBusy(void)
- *
+ *
* @author: Xavier Del Campo
*
* @return: returns system busy flag.
- *
+ *
* ***********************************************************************/
volatile bool SystemIsBusy(void)
@@ -711,21 +711,21 @@ volatile bool SystemIsBusy(void)
}
/* ****************************************************************************
- *
+ *
* @name bool SystemContains_u8(uint8_t value, uint8_t* buffer, size_t sz)
- *
+ *
* @author: Xavier Del Campo
*
* @brief: checks if a certain value is contained in a buffer with size "sz".
- *
+ *
* @return: true if value is contained inside buffer, false otherwise.
- *
+ *
* ****************************************************************************/
bool SystemContains_u8(uint8_t value, uint8_t* buffer, size_t sz)
{
size_t i = 0;
-
+
for (i = 0; i < sz; i++)
{
if (buffer[i] == value)
@@ -733,27 +733,27 @@ bool SystemContains_u8(uint8_t value, uint8_t* buffer, size_t sz)
return true;
}
}
-
+
return false;
}
/* ****************************************************************************
- *
+ *
* @name bool SystemContains_u16(uint16_t value, uint16_t* buffer, size_t sz)
- *
+ *
* @author: Xavier Del Campo
*
* @brief: checks if a certain value is contained in a buffer with size "sz".
* Variant for u16 variables.
- *
+ *
* @return: true if value is contained inside buffer, false otherwise.
- *
+ *
* ****************************************************************************/
bool SystemContains_u16(uint16_t value, uint16_t* buffer, size_t sz)
{
size_t i = 0;
-
+
for (i = 0; i < sz; i++)
{
if (buffer[i] == value)
@@ -761,26 +761,26 @@ bool SystemContains_u16(uint16_t value, uint16_t* buffer, size_t sz)
return true;
}
}
-
+
return false;
}
/* ****************************************************************************************
- *
+ *
* @name bool SystemArrayCompare(unsigned short* arr1, unsigned short* arr2, size_t sz)
- *
+ *
* @author: Xavier Del Campo
- *
+ *
* @brief: Reportedly, it compares two arrays "arr1" and "arr2", with size "sz".
*
* @return: true if they are equal, false otherwise.
- *
+ *
* ****************************************************************************************/
bool SystemArrayCompare(unsigned short* arr1, unsigned short* arr2, size_t sz)
{
size_t i;
-
+
for (i = 0; i < sz; i++)
{
if (arr1[i] != arr2[i])
@@ -788,18 +788,18 @@ bool SystemArrayCompare(unsigned short* arr1, unsigned short* arr2, size_t sz)
return false;
}
}
-
+
return true;
}
/* ****************************************************************************************
- *
+ *
* @name void SystemPrintStackPointerAddress(void)
- *
+ *
* @author: Xavier Del Campo
- *
+ *
* @brief: Prints stack usage in percentage via dprintf calls.
- *
+ *
* ****************************************************************************************/
void SystemPrintStackPointerAddress(void)
@@ -808,11 +808,11 @@ void SystemPrintStackPointerAddress(void)
void* ptr = NULL;
fix16_t used_bytes = fix16_from_int((int)((void*)BEGIN_STACK_ADDRESS - (void*)&ptr));
fix16_t stackPercent = fix16_sdiv(used_bytes,fix16_from_int((int)STACK_SIZE));
-
+
stackPercent = fix16_smul(stackPercent, fix16_from_int((int)100));
-
+
Serial_printf("stackPercent: %d\n", stackPercent);
-
+
Serial_printf("Stack begin pointer: 0x%08X\n"
"Stack pointer address: 0x%08X\n"
"Used %d%% of stack size.\n"
@@ -826,99 +826,99 @@ void SystemPrintStackPointerAddress(void)
}
/* ****************************************************************************************
- *
+ *
* @name void SystemCheckStack(void)
- *
+ *
* @author: Xavier Del Campo
- *
+ *
* @brief: Compares stack top with expected byte pattern. If does not match, a stack
* overflow has been caused, and application returns to a safe state.
- *
+ *
* ****************************************************************************************/
void SystemCheckStack(void)
{
uint32_t * ptrStack = BEGIN_STACK_ADDRESS;
uint32_t data;
-
+
ptrStack -= STACK_SIZE;
data = (*ptrStack);
-
+
if (data != END_STACK_PATTERN)
{
Serial_printf("Stack overflow?\n");
-
+
while (1);
}
}
/* ****************************************************************************************
- *
+ *
* @name void SystemSetStackPattern(void)
- *
+ *
* @author: Xavier Del Campo
- *
+ *
* @brief: Sets a determined byte pattern on stack top to detect possible stack
* overflow during execution.
- *
+ *
* ****************************************************************************************/
void SystemSetStackPattern(void)
{
uint32_t * ptrStack = BEGIN_STACK_ADDRESS;
-
+
ptrStack -= STACK_SIZE;
-
+
*ptrStack = END_STACK_PATTERN;
}
/* ****************************************************************************************
- *
+ *
* @name int32_t SystemIndexOfStringArray(char* str, char** array)
- *
+ *
* @author: Xavier Del Campo
- *
+ *
* @brief: Finds string "str" inside an array of strings "array".
*
* @return Index for a string "str" inside "array". -1 if it could not be found.
- *
+ *
* ****************************************************************************************/
int32_t SystemIndexOfStringArray(char* str, char** array)
{
int32_t i;
-
+
for (i = 0; array[i] != NULL; i++)
{
Serial_printf("String to find: %s\nEntry: %s\n", str, array[i]);
-
+
if (strcmp(str, array[i]) == 0)
{
Serial_printf("Match! Returning index %d...\n", i);
return i;
}
}
-
+
return -1;
}
/* ****************************************************************************************
- *
+ *
* @name int32_t SystemIndexOf_U16(uint16_t value, uint16_t* array, uint32_t sz)
- *
+ *
* @author: Xavier Del Campo
- *
+ *
* @brief: For a uint16_t array, it returns index of a variable "value" inside an array.
*
* @return Index for a variable "value" inside "array". -1 if it could not be found.
- *
+ *
* ****************************************************************************************/
int32_t SystemIndexOf_U16(uint16_t value, uint16_t* array, uint32_t sz)
{
int32_t i;
-
+
for (i = 0; i < sz; i++)
{
if (value == array[i])
@@ -926,28 +926,28 @@ int32_t SystemIndexOf_U16(uint16_t value, uint16_t* array, uint32_t sz)
return i;
}
}
-
+
return -1;
}
/* ****************************************************************************************
- *
+ *
* @name int32_t SystemIndexOf_U8(uint8_t value, uint8_t* array, uint32_t from, uint32_t sz)
- *
+ *
* @author: Xavier Del Campo
- *
+ *
* @brief: For a uint8_t array, it returns index of a variable "value" inside an array.
* "from" and "size_t" can be used to determine initial/ending positions.
*
* @return Index for a variable "value" inside "array". -1 if it could not be found.
- *
+ *
* ****************************************************************************************/
int32_t SystemIndexOf_U8(uint8_t value, uint8_t* array, uint32_t from, uint32_t sz)
{
int32_t i;
-
+
for (i = from; i < sz; i++)
{
if (value == array[i])
@@ -955,18 +955,18 @@ int32_t SystemIndexOf_U8(uint8_t value, uint8_t* array, uint32_t from, uint32_t
return i;
}
}
-
+
return -1;
}
/* ****************************************************************************************
- *
+ *
* @name volatile uint8_t SystemGetFPS(void)
- *
+ *
* @author: Xavier Del Campo
- *
+ *
* @return: Frames per second
- *
+ *
* ****************************************************************************************/
volatile uint8_t SystemGetFPS(void)
@@ -975,14 +975,14 @@ volatile uint8_t SystemGetFPS(void)
}
/* ****************************************************************************************
- *
+ *
* @name void SystemCyclicHandler(void)
- *
+ *
* @author: Xavier Del Campo
- *
+ *
* @brief: It calls system handlers once an execution cycle has finished.
- *
- *
+ *
+ *
* ****************************************************************************************/
void SystemCyclicHandler(void)
@@ -990,31 +990,31 @@ void SystemCyclicHandler(void)
UpdatePads();
SystemIncreaseGlobalTimer();
-
+
SystemRunTimers();
-
+
TimerHandler();
-
+
SystemDisableScreenRefresh();
-
+
MemCardHandler();
SystemCalculateSine();
-
+
SystemCheckStack();
}
/* ****************************************************************************************
- *
+ *
* @name void SystemDisableVBlankInterrupt(void)
- *
+ *
* @author: Xavier Del Campo
- *
+ *
* @brief: Reportedly, this routine enables VBLANK interrupt flag.
*
* @remark: Used when critical timing is needed or GPU activity is not desired
- * e.g.: when reading files from CD-ROM.
- *
+ * e.g.: when reading files from CD-ROM.
+ *
* ****************************************************************************************/
void SystemDisableVBlankInterrupt(void)
@@ -1023,14 +1023,14 @@ void SystemDisableVBlankInterrupt(void)
}
/* ****************************************************************************************
- *
+ *
* @name void SystemEnableVBlankInterrupt(void)
- *
+ *
* @author: Xavier Del Campo
- *
+ *
* @brief: Reportedly, this routine enables VBLANK interrupt flag.
- *
- *
+ *
+ *
* ****************************************************************************************/
void SystemEnableVBlankInterrupt(void)
@@ -1039,14 +1039,14 @@ void SystemEnableVBlankInterrupt(void)
}
/* ****************************************************************************************
- *
+ *
* @name void SystemReturnToLoader(void)
- *
+ *
* @author: Xavier Del Campo
- *
+ *
* @brief: Deinitializes PSXSDK library and returns to OpenSend loader,
* located at memory address 0x801A0000
- *
+ *
* ****************************************************************************************/
void SystemReturnToLoader(void)
@@ -1054,36 +1054,36 @@ void SystemReturnToLoader(void)
Serial_printf("Returning to loader...\n");
EndAnimation();
-
+
PSX_DeInit();
__asm__("j 0x801A0000");
}
/* ****************************************************************************************
- *
+ *
* @name void SystemDevMenuToggle(void)
- *
+ *
* @author: Xavier Del Campo
- *
+ *
* @brief: It toggles a flag called "devmenu_flag" which, if true, shows information on
* top of all drawn primitives for debugging/development purposes.
- *
+ *
* ****************************************************************************************/
-
+
void SystemDevMenuToggle(void)
{
devmenu_flag = devmenu_flag? false: true;
}
/* ****************************************************************************************
- *
+ *
* @name void SystemEnableRCnt2Interrupt(void)
- *
+ *
* @author: Xavier Del Campo
- *
+ *
* @brief: Enables bit 6 from I_MASK (0x1F801074)/IRQ6 RCNT2 (System clock / 8)
- *
+ *
* ****************************************************************************************/
void SystemEnableRCnt2Interrupt(void)
@@ -1093,13 +1093,13 @@ void SystemEnableRCnt2Interrupt(void)
/* ****************************************************************************************
- *
+ *
* @name void SystemDisableRCnt2Interrupt(void)
- *
+ *
* @author: Xavier Del Campo
- *
+ *
* @brief: Disables bit 6 from I_MASK (0x1F801074)/IRQ6 RCNT2 (System clock / 8)
- *
+ *
* ****************************************************************************************/
void SystemDisableRCnt2Interrupt(void)
@@ -1108,13 +1108,13 @@ void SystemDisableRCnt2Interrupt(void)
}
/* ****************************************************************************************
- *
+ *
* @name void SystemDevMenu(void)
- *
+ *
* @author: Xavier Del Campo
- *
+ *
* @brief: Shows information on top of all drawn primitives for debugging/development purposes.
- *
+ *
* ****************************************************************************************/
void SystemDevMenu(void)
@@ -1125,7 +1125,7 @@ void SystemDevMenu(void)
DEVMENU_BG_X = (X_SCREEN_RESOLUTION >> 1) - (DEVMENU_BG_W >> 1),
DEVMENU_BG_Y = 32,
DEVMENU_BG_H = 128,
-
+
DEVMENU_BG_R = 0,
DEVMENU_BG_G = 128,
DEVMENU_BG_B = 32,
diff --git a/Source/System.h b/Source/System.h
index 3bce5e4..306bd5f 100644
--- a/Source/System.h
+++ b/Source/System.h
@@ -2,7 +2,7 @@
#define __SYSTEM_HEADER__
/* **************************************
- * Includes *
+ * Includes *
* **************************************/
#include "Global_Inc.h"
@@ -134,7 +134,7 @@ void SystemCalculateSine(void);
unsigned char SystemGetSineValue(void);
/* **************************************
- * Global Variables *
+ * Global Variables *
* **************************************/
#endif //__SYSTEM_HEADER__
diff --git a/Source/Timer.c b/Source/Timer.c
index d49e698..85ae267 100644
--- a/Source/Timer.c
+++ b/Source/Timer.c
@@ -23,9 +23,9 @@ static TYPE_TIMER timer_array[MAX_TIMERS];
* *************************************/
/* ********************************************************************************************
- *
+ *
* @name TYPE_TIMER* TimerCreate(uint32_t t, bool rf, void (*timer_callback)(void) )
- *
+ *
* @author: Xavier Del Campo
*
* @brief: fills a TYPE_TIMER structure with input parameters
@@ -35,23 +35,23 @@ static TYPE_TIMER timer_array[MAX_TIMERS];
* bool rf:
* Repeat flag
* void (*timer_callback)(void)
- * Function to be called on timeout
- *
+ * Function to be called on timeout
+ *
* @return: pointer to TYPE_TIMER structure if filled correctly, NULL pointer otherwise.
- *
+ *
* ********************************************************************************************/
TYPE_TIMER* TimerCreate(uint32_t t, bool rf, void (*timer_callback)(void) )
{
bool success = false;
uint8_t i;
-
+
if (t == 0)
{
Serial_printf("Cannot create timer with time == 0!\n");
return NULL;
}
-
+
for (i = 0; i < MAX_TIMERS; i++)
{
if (timer_array[i].busy == false)
@@ -65,30 +65,30 @@ TYPE_TIMER* TimerCreate(uint32_t t, bool rf, void (*timer_callback)(void) )
break;
}
}
-
+
if (success == false)
{
Serial_printf("Could not find any free timer!\n");
return NULL;
}
-
+
return &timer_array[i];
}
/* *******************************************
- *
+ *
* @name void TimerReset(void)
- *
+ *
* @author: Xavier Del Campo
*
* @brief: reportedly, removes all timers.
- *
+ *
* *******************************************/
void TimerReset(void)
{
uint8_t i;
-
+
for (i = 0; i < MAX_TIMERS; i++)
{
TimerRemove(&timer_array[i]);
@@ -96,21 +96,21 @@ void TimerReset(void)
}
/* *****************************************************
- *
+ *
* @name void TimerHandler(void)
- *
+ *
* @author: Xavier Del Campo
*
* @brief: reportedly, handles all available timers.
*
* @remarks: calls callback on timeout.
- *
+ *
* *****************************************************/
void TimerHandler(void)
{
uint8_t i;
-
+
for (i = 0; i < MAX_TIMERS; i++)
{
if (timer_array[i].busy == true)
@@ -118,11 +118,11 @@ void TimerHandler(void)
if (System100msTick() == true)
{
timer_array[i].time--;
-
+
if (timer_array[i].time == 0)
{
timer_array[i].Timeout_Callback();
-
+
if (timer_array[i].repeat_flag == true)
{
timer_array[i].time = timer_array[i].orig_time;
@@ -134,15 +134,15 @@ void TimerHandler(void)
}
/* *********************************************************************
- *
+ *
* @name void TimerRestart(TYPE_TIMER* timer)
- *
+ *
* @author: Xavier Del Campo
*
* @brief: sets time left for TYPE_TIMER instance to initial value.
*
* @remarks: specially used when TYPE_TIMER.rf is enabled.
- *
+ *
* *********************************************************************/
void TimerRestart(TYPE_TIMER* timer)
@@ -151,16 +151,16 @@ void TimerRestart(TYPE_TIMER* timer)
}
/* *********************************************************************
- *
+ *
* @name void TimerRemove(TYPE_TIMER* timer)
- *
+ *
* @author: Xavier Del Campo
*
* @brief: Resets timer parameters to default values so timer instance
- * can be recycled.
+ * can be recycled.
*
* @remarks:
- *
+ *
* *********************************************************************/
void TimerRemove(TYPE_TIMER* timer)
diff --git a/Source/Timer.h b/Source/Timer.h
index 6f4a3a4..6b11d9a 100644
--- a/Source/Timer.h
+++ b/Source/Timer.h
@@ -2,7 +2,7 @@
#define __TIMER_HEADER__
/* **************************************
- * Includes *
+ * Includes *
* **************************************/
#include "Global_Inc.h"
diff --git a/Source/main.c b/Source/main.c
index 80e74be..e025f22 100644
--- a/Source/main.c
+++ b/Source/main.c
@@ -18,8 +18,8 @@ int main(void)
{
//System initialization
SystemInit();
-
+
MainMenu();
-
+
return 0;
}
generated by cgit v1.2.3 (git 2.39.1) at 2026-07-18 22:54:28 +0000