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

* Added comments on System. 

* Files needed for Game are now only loaded once, except from LEVEL1.PLT.
* Added DevMenu to get debug info.
* ISR_LoadMenuVBlank() does not stop when accessing SIO.
* On fopen() and SERIAL_INTERFACE defined, "#" is prepended and "@" is appended to filename string.
This commit is contained in:
XaviDCR92 2017-07-27 07:41:25 +02:00
parent cb1c0345c7
commit 153f078ec2
15 changed files with 416 additions and 83 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

27
Levels/LEVEL1.PLT
View File

@ -6,25 +6,16 @@
#For example:
14:55
#Aircraft arrival (or departure) must be set relative to initial time, in HH:MM format.
ARRIVAL;PHX1802;100;01:00;0;180
ARRIVAL;PHX2015;180;00:10;0;180
ARRIVAL;PHX2016;140;00:30;0;180
ARRIVAL;PHX2017;140;00:40;0;180
ARRIVAL;PHX2018;140;00:55;0;180
ARRIVAL;PHX2018;160;01:20;0;180
ARRIVAL;PHX2020;160;01:45;0;180
ARRIVAL;PHX2019;140;01:30;0;180
ARRIVAL;PHX2021;140;02:00;0;180
ARRIVAL;PHX2022;140;02:30;0;180
ARRIVAL;PHX2023;140;02:15;0;180
ARRIVAL;PHX1802;100;01:00;0;360
ARRIVAL;PHX2015;100;00:10;0;360
ARRIVAL;PHX2016;100;00:40;0;360
ARRIVAL;PHX2017;100;00:50;0;360
ARRIVAL;PHX2018;100;01:40;0;360
ARRIVAL;PHX2018;100;01:20;0;360
ARRIVAL;PHX2018;100;02:00;0;360
DEPARTURE;PHX1000;100;00:05;19;180
DEPARTURE;PHX1280;100;00:30;19;180
DEPARTURE;PHX1332;100;00:45;21;180
DEPARTURE;PHX1280;100;01:30;19;180
DEPARTURE;PHX1332;100;00:50;21;180
DEPARTURE;PHX1333;100;01:00;19;180
DEPARTURE;PHX1334;100;01:15;21;180
DEPARTURE;PHX1336;100;01:20;21;180
DEPARTURE;PHX1335;100;01:30;19;180
DEPARTURE;PHX1335;100;01:40;19;180
DEPARTURE;PHX1335;100;02:00;19;180
DEPARTURE;PHX1335;100;02:15;19;180
DEPARTURE;PHX1335;100;02:30;19;180

35
Source/Game.c
View File

@ -207,18 +207,19 @@ static uint8_t GameAircraftTilemap[GAME_MAX_MAP_SIZE][GAME_MAX_AIRCRAFT_PER_TILE
TYPE_PLAYER PlayerData[MAX_PLAYERS];
static char* GameFileList[] = { "cdrom:\\DATA\\SPRITES\\TILESET1.TIM;1" ,
"cdrom:\\DATA\\LEVELS\\LEVEL1.PLT;1" ,
"cdrom:\\DATA\\SPRITES\\GAMEPLN.TIM;1" ,
"cdrom:\\DATA\\SPRITES\\PLNBLUE.CLT;1" ,
"cdrom:\\DATA\\SPRITES\\MOUSE.TIM;1" ,
"cdrom:\\DATA\\SPRITES\\BLDNGS1.TIM;1" };
static void * GameFileDest[] = {(GsSprite*)&GameTilesetSpr ,
(TYPE_FLIGHT_DATA*)&FlightData ,
static void* GameFileDest[] = { (GsSprite*)&GameTilesetSpr ,
(GsSprite*)&GamePlaneSpr ,
NULL ,
NULL,
(GsSprite*)&GameMouseSpr ,
(GsSprite*)&GameBuildingSpr };
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];
@ -327,13 +328,24 @@ void GameInit(void)
{
uint8_t i;
uint32_t track;
static bool firstLoad = true;
GameStartupFlag = true;
LoadMenu( GameFileList,
GameFileDest,
sizeof(GameFileList) / sizeof(char*),
sizeof(GameFileDest) /sizeof(void*) );
if(firstLoad == true)
{
firstLoad = false;
LoadMenu( GameFileList,
GameFileDest,
sizeof(GameFileList) / sizeof(char*),
sizeof(GameFileDest) /sizeof(void*) );
}
LoadMenu( GamePlt,
GamePltDest,
sizeof(GamePlt) / sizeof(GamePlt[0]),
sizeof(GamePltDest) / sizeof(GamePltDest[0]) );
GameLoadLevel();
@ -808,11 +820,10 @@ void GameGraphics(void)
if(split_screen == true)
{
GfxSwapBuffers();
GfxDrawScene_NoSwap();
}
GfxDrawScene();
GfxDrawScene();
}
void GameRenderBuildingAircraft(TYPE_PLAYER* ptrPlayer)

17
Source/GameGui.c
View File

@ -206,7 +206,7 @@ static char* GameFileList[] = { "cdrom:\\DATA\\SPRITES\\BUBBLE.TIM;1" ,
"cdrom:\\DATA\\SPRITES\\DEPARR.TIM;1" ,
"cdrom:\\DATA\\SPRITES\\PAGEUPDN.TIM;1" };
static void * GameFileDest[] = {(GsSprite*)&BubbleSpr ,
static void* GameFileDest[] = {(GsSprite*)&BubbleSpr ,
(TYPE_FONT*)&RadioFont ,
(GsSprite*)&DepArrSpr ,
(GsSprite*)&PageUpDownSpr };
@ -243,10 +243,17 @@ void GameGuiInit(void)
RADIO_FONT_SPACING = 12
};
LoadMenu( GameFileList,
GameFileDest,
sizeof(GameFileList) / sizeof(char*),
sizeof(GameFileDest) /sizeof(void*) );
static bool firstLoad = true;
if(firstLoad == true)
{
firstLoad = false;
LoadMenu( GameFileList,
GameFileDest,
sizeof(GameFileList) / sizeof(char*),
sizeof(GameFileDest) /sizeof(void*) );
}
PauseRect.x[0] = PAUSE_DIALOG_X;
PauseRect.x[1] = PAUSE_DIALOG_X + PAUSE_DIALOG_W;

10
Source/Gfx.c
View File

@ -95,9 +95,6 @@ static unsigned int prim_list[PRIMITIVE_LIST_SIZE];
static volatile bool gfx_busy;
// Dictates (R,G,B) brigthness to all sprites silently
static uint8_t global_lum;
// When true, it draws a rectangle on top of all primitives with
// information for development purposes.
static bool GfxDevMenuEnableFlag;
static bool five_hundred_ms_show;
static bool one_second_show;
@ -151,11 +148,6 @@ void GfxSwapBuffers(void)
}
}
void GfxDevMenuEnable(void)
{
GfxDevMenuEnableFlag = true;
}
void GfxInitDrawEnv(void)
{
@ -183,6 +175,8 @@ void GfxSetPrimitiveList(void)
void GfxDrawScene_Fast(void)
{
SystemDevMenu();
if(System1SecondTick() == true)
{
one_second_show = one_second_show? false:true;

15
Source/LoadMenu.c
View File

@ -73,7 +73,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);
/* *************************************
@ -90,7 +90,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 };
@ -233,6 +233,8 @@ void LoadMenuInit(void)
SmallFont.spr.b = 0;
GfxSetGlobalLuminance(0);
Serial_printf("I_MASK = 0x%08X\n", (*(unsigned int*)0x1F801074));
SetVBlankHandler(&ISR_LoadMenuVBlank);
}
@ -253,10 +255,9 @@ void ISR_LoadMenuVBlank(void)
{
uint8_t i;
Serial_printf("SystemIsBusy() = %d\n", SystemIsBusy() );
Serial_printf("GfxIsGPUBusy() = %d\n", GfxIsGPUBusy() );
SystemIncreaseGlobalTimer();
if( (SystemIsBusy() == true) || (GfxIsGPUBusy() == true) )
if( (SystemIsBusy() == true) || (GfxIsGPUBusy() == true) || (SerialIsBusy() == true) )
{
return;
}
@ -418,7 +419,7 @@ bool LoadMenuISRHasStarted(void)
}
void LoadMenu( char* fileList[],
void * dest[],
void* dest[],
uint8_t szFileList , uint8_t szDestList)
{
@ -433,7 +434,7 @@ void LoadMenu( char* fileList[],
}
void LoadMenuLoadFileList( char* fileList[], void * dest[],
void LoadMenuLoadFileList( char* fileList[], void* dest[],
uint8_t szFileList, uint8_t szDestList)
{
char aux_file_name[100];

2
Source/LoadMenu.h
View File

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

6
Source/Menu.c
View File

@ -131,7 +131,7 @@ static char* MainMenuFiles[] = { "cdrom:\\DATA\\SPRITES\\MAINMENU.TIM;1" ,
#endif // NO_INTRO
};
static void * MainMenuDest[] = { (GsSprite*)&MenuSpr ,
static void* MainMenuDest[] = { (GsSprite*)&MenuSpr ,
(SsVag*)&BellSnd ,
(SsVag*)&AcceptSnd ,
(GsSprite*)&PsxDisk ,
@ -250,7 +250,7 @@ void MainMenuInit(void)
PadAddCheat(&StackCheckCheat);
DevMenuCheat.Callback = &GfxDevMenuEnable;
DevMenuCheat.Callback = &SystemDevMenuToggle;
memset(DevMenuCheat.Combination, 0 , CHEAT_ARRAY_SIZE);
memcpy( DevMenuCheat.Combination,
@ -263,7 +263,7 @@ void MainMenuInit(void)
PadAddCheat(&DevMenuCheat);
SerialCheat.Callback = (void*)0x801A0000;
SerialCheat.Callback = &SystemReturnToLoader;
memset(SerialCheat.Combination, 0 , CHEAT_ARRAY_SIZE);
memcpy( SerialCheat.Combination,

43
Source/Pad.c
View File

@ -100,11 +100,30 @@ psx_pad_state PadOneGetState(void)
{
psx_pad_state PadOne;
PSX_PollPad_Fast(PAD_ONE,&PadOne);
PSX_PollPad_Fast(PAD_ONE, &PadOne);
return PadOne;
}
unsigned char PadOneGetType(void)
{
return PadOneGetState().type;
}
psx_pad_state PadTwoGetState(void)
{
psx_pad_state PadTwo;
PSX_PollPad_Fast(PAD_TWO, &PadTwo);
return PadTwo;
}
unsigned char PadTwoGetType(void)
{
return PadTwoGetState().type;
}
bool PadOneConnected(void)
{
psx_pad_state PadOne = PadOneGetState();
@ -117,6 +136,28 @@ bool PadOneConnected(void)
return true;
}
bool PadTwoConnected(void)
{
psx_pad_state PadTwo = PadTwoGetState();
if(PadTwo.status != PAD_STATUS_OK)
{
return false;
}
return true;
}
unsigned char PadOneGetID(void)
{
return PadOneGetState().id;
}
unsigned char PadTwoGetID(void)
{
return PadTwoGetState().id;
}
bool PadOneAnyKeyPressed(void)
{
return (bool)pad1;

7
Source/Pad.h
View File

@ -23,6 +23,13 @@ void PadInit(void);
void PadClearData(void);
bool PadOneConnected(void);
bool PadTwoConnected(void);
unsigned char PadOneGetType(void);
unsigned char PadTwoGetType(void);
unsigned char PadOneGetID(void);
unsigned char PadTwoGetID(void);
bool PadOneAnyKeyPressed(void);
bool PadTwoAnyKeyPressed(void);

2
Source/PltParser.c
View File

@ -61,6 +61,8 @@ bool PltParserLoadFile(char* strPath, TYPE_FLIGHT_DATA* ptrFlightData)
}
strPltBuffer = SystemGetBufferAddress();
dprintf("%s\n", strPltBuffer);
PltParserResetBuffers(ptrFlightData);

9
Source/Serial.c
View File

@ -30,6 +30,7 @@ typedef enum
* *************************************/
static volatile SERIAL_STATE SerialState;
static volatile bool serial_busy;
/* *************************************
* Local Prototypes
@ -62,6 +63,7 @@ bool SerialRead(uint8_t* ptrArray, size_t nBytes)
bool SerialWrite(void* ptrArray, size_t nBytes)
{
serial_busy = true;
if(nBytes == 0)
{
@ -79,9 +81,16 @@ bool SerialWrite(void* ptrArray, size_t nBytes)
}while(--nBytes);
serial_busy = false;
return true;
}
volatile bool SerialIsBusy(void)
{
return serial_busy;
}
#ifdef SERIAL_INTERFACE
void Serial_printf(const char* str, ...)
{

1
Source/Serial.h
View File

@ -24,6 +24,7 @@
void SerialInit(void);
bool SerialRead(uint8_t* ptrArray, size_t nBytes);
bool SerialWrite(void* ptrArray, size_t nBytes);
volatile bool SerialIsBusy(void);
#ifdef SERIAL_INTERFACE
void Serial_printf(const char* str, ...);

292
Source/System.c
View File

@ -45,6 +45,9 @@ static bool emergency_mode;
static volatile bool system_busy;
//Timer array.
static TYPE_TIMER timer_array[SYSTEM_MAX_TIMERS];
// When true, it draws a rectangle on top of all primitives with
// information for development purposes.
static bool devmenu_flag;
/* *******************************************************************
*
@ -65,7 +68,8 @@ void SystemInit(void)
//Reset 1 second timer
one_second_timer = 0;
//PSXSDK init
PSX_InitEx(PSX_INIT_SAVESTATE | PSX_INIT_CD);
//PSX_InitEx(PSX_INIT_SAVESTATE | PSX_INIT_CD);
PSX_InitEx(0);
//Graphics init
GsInit();
//Clear VRAM
@ -94,6 +98,8 @@ void SystemInit(void)
MemCardInit();
//Initial value for system_busy
system_busy = false;
//Development menu flag
devmenu_flag = false;
GfxSetGlobalLuminance(NORMAL_LUMINANCE);
@ -189,7 +195,6 @@ bool SystemRefreshNeeded(void)
void ISR_SystemDefaultVBlank(void)
{
refresh_needed = true;
SystemIncreaseGlobalTimer();
}
/* *******************************************************************
@ -360,7 +365,7 @@ bool SystemLoadFileToBuffer(char* fname, uint8_t* buffer, uint32_t szBuffer)
#ifdef SERIAL_INTERFACE
uint8_t fileSizeBuffer[sizeof(uint32_t)] = {0};
uint32_t i;
#else
#else // SERIAL_INTERFACE
FILE *f;
#endif // SERIAL_INTERFACE
int32_t size = 0;
@ -375,11 +380,9 @@ bool SystemLoadFileToBuffer(char* fname, uint8_t* buffer, uint32_t szBuffer)
}
memset(buffer,0,szBuffer);
system_busy = true;
#ifdef SERIAL_INTERFACE
Serial_printf("%s", fname);
Serial_printf("#%s@", fname);
SerialRead(fileSizeBuffer, sizeof(uint32_t) );
@ -409,7 +412,9 @@ bool SystemLoadFileToBuffer(char* fname, uint8_t* buffer, uint32_t szBuffer)
SerialWrite(ACK_BYTE_STRING, sizeof(uint8_t)); // Write ACK
}
#else
#else // SERIAL_INTERFACE
system_busy = true;
SystemDisableVBlankInterrupt();
@ -441,10 +446,10 @@ bool SystemLoadFileToBuffer(char* fname, uint8_t* buffer, uint32_t szBuffer)
SystemEnableVBlankInterrupt();
system_busy = false;
#endif // SERIAL_INTERFACE
system_busy = false;
Serial_printf("File \"%s\" loaded successfully!\n",fname);
return true;
@ -784,6 +789,18 @@ void SystemTimerRemove(TYPE_TIMER* timer)
timer->repeat_flag = 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;
@ -799,10 +816,20 @@ bool SystemArrayCompare(unsigned short* arr1, unsigned short* arr2, size_t sz)
return true;
}
/* ****************************************************************************************
*
* @name void SystemPrintStackPointerAddress(void)
*
* @author: Xavier Del Campo
*
* @brief: Prints stack usage in percentage via dprintf calls.
*
* ****************************************************************************************/
void SystemPrintStackPointerAddress(void)
{
#ifdef PSXSDK_DEBUG // Used to avoid unused variable warning
void * ptr = NULL;
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));
@ -822,6 +849,17 @@ 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;
@ -838,6 +876,18 @@ void SystemCheckStack(void)
}
}
/* ****************************************************************************************
*
* @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;
@ -847,6 +897,18 @@ void SystemSetStackPattern(void)
*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;
@ -865,6 +927,18 @@ int32_t SystemIndexOfStringArray(char* str, char** array)
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;
@ -880,6 +954,20 @@ int32_t SystemIndexOf_U16(uint16_t value, uint16_t* array, uint32_t sz)
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;
@ -895,6 +983,17 @@ int32_t SystemIndexOf_U8(uint8_t value, uint8_t* array, uint32_t from, uint32_t
return -1;
}
/* ****************************************************************************************
*
* @name void SystemCyclicHandler(void)
*
* @author: Xavier Del Campo
*
* @brief: It calls system handlers once an execution cycle has finished.
*
*
* ****************************************************************************************/
void SystemCyclicHandler(void)
{
if(UpdatePads() == false)
@ -905,6 +1004,8 @@ void SystemCyclicHandler(void)
{
SystemSetEmergencyMode(false);
}
SystemIncreaseGlobalTimer();
SystemRunTimers();
@ -917,12 +1018,183 @@ void SystemCyclicHandler(void)
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.
*
* ****************************************************************************************/
void SystemDisableVBlankInterrupt(void)
{
I_MASK &= ~(0x0001);
}
/* ****************************************************************************************
*
* @name void SystemEnableVBlankInterrupt(void)
*
* @author: Xavier Del Campo
*
* @brief: Reportedly, this routine enables VBLANK interrupt flag.
*
*
* ****************************************************************************************/
void SystemEnableVBlankInterrupt(void)
{
I_MASK |= (0x0001);
}
/* ****************************************************************************************
*
* @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)
{
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;
DEBUG_PRINT_VAR(devmenu_flag);
}
/* ****************************************************************************************
*
* @name void SystemDevMenu(void)
*
* @author: Xavier Del Campo
*
* @brief: Shows information on top of all drawn primitives for debugging/development purposes.
*
* ****************************************************************************************/
void SystemDevMenu(void)
{
enum
{
DEVMENU_BG_W = 256,
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,
};
enum
{
DEVMENU_TEXT_GAP = 8,
DEVMENU_PAD1_STATUS_TEXT_X = DEVMENU_BG_X + DEVMENU_TEXT_GAP,
DEVMENU_PAD1_STATUS_TEXT_Y = DEVMENU_BG_Y + DEVMENU_TEXT_GAP,
DEVMENU_PAD1_TYPE_TEXT_X = DEVMENU_PAD1_STATUS_TEXT_X,
DEVMENU_PAD1_TYPE_TEXT_Y = DEVMENU_PAD1_STATUS_TEXT_Y + DEVMENU_TEXT_GAP,
DEVMENU_PAD1_ID_TEXT_X = DEVMENU_PAD1_STATUS_TEXT_X,
DEVMENU_PAD1_ID_TEXT_Y = DEVMENU_PAD1_TYPE_TEXT_Y + DEVMENU_TEXT_GAP,
DEVMENU_PAD2_STATUS_TEXT_X = DEVMENU_PAD1_ID_TEXT_X,
DEVMENU_PAD2_STATUS_TEXT_Y = DEVMENU_PAD1_ID_TEXT_Y + (DEVMENU_TEXT_GAP << 1), // Leave a bigger gap here
DEVMENU_PAD2_TYPE_TEXT_X = DEVMENU_PAD2_STATUS_TEXT_X,
DEVMENU_PAD2_TYPE_TEXT_Y = DEVMENU_PAD2_STATUS_TEXT_Y + DEVMENU_TEXT_GAP,
DEVMENU_PAD2_ID_TEXT_X = DEVMENU_PAD2_TYPE_TEXT_X,
DEVMENU_PAD2_ID_TEXT_Y = DEVMENU_PAD2_TYPE_TEXT_Y + DEVMENU_TEXT_GAP,
DEVMENU_ROOTCNT0_TEXT_X = DEVMENU_PAD2_ID_TEXT_X,
DEVMENU_ROOTCNT0_TEXT_Y = DEVMENU_PAD2_ID_TEXT_Y + DEVMENU_TEXT_GAP,
};
if(devmenu_flag == true)
{
GsRectangle devMenuBg = { .x = DEVMENU_BG_X,
.y = DEVMENU_BG_Y,
.w = DEVMENU_BG_W,
.h = DEVMENU_BG_H,
.r = DEVMENU_BG_R,
.g = DEVMENU_BG_G,
.b = DEVMENU_BG_B,
.attribute = ENABLE_TRANS | TRANS_MODE(0) };
GsSortRectangle(&devMenuBg);
FontPrintText( &SmallFont,
DEVMENU_PAD1_STATUS_TEXT_X,
DEVMENU_PAD1_STATUS_TEXT_Y,
"Pad1 connected = %d",
PadOneConnected() );
FontPrintText( &SmallFont,
DEVMENU_PAD1_TYPE_TEXT_X,
DEVMENU_PAD1_TYPE_TEXT_Y,
"Pad1 type = 0x%02X",
PadOneGetType() );
FontPrintText( &SmallFont,
DEVMENU_PAD1_ID_TEXT_X,
DEVMENU_PAD1_ID_TEXT_Y,
"Pad1 ID = 0x%02X",
PadOneGetID() );
FontPrintText( &SmallFont,
DEVMENU_PAD2_STATUS_TEXT_X,
DEVMENU_PAD2_STATUS_TEXT_Y,
"Pad2 connected = %d",
PadTwoConnected() );
FontPrintText( &SmallFont,
DEVMENU_PAD2_TYPE_TEXT_X,
DEVMENU_PAD2_TYPE_TEXT_Y,
"Pad2 type = 0x%02X",
PadTwoGetType() );
FontPrintText( &SmallFont,
DEVMENU_PAD2_ID_TEXT_X,
DEVMENU_PAD2_ID_TEXT_Y,
"Pad2 ID = 0x%02X",
PadTwoGetID() );
FontPrintText( &SmallFont,
DEVMENU_ROOTCNT0_TEXT_X,
DEVMENU_ROOTCNT0_TEXT_Y,
"Timer0 = 0x%04X",
(uint16_t)((*(uint32_t*)0x1F801100) & 0x00FF) );
}
}

6
Source/System.h
View File

@ -132,6 +132,12 @@ void SystemEnableVBlankInterrupt();
void SystemDisableVBlankInterrupt();
void SystemReturnToLoader(void);
void SystemDevMenuToggle(void);
void SystemDevMenu(void);
/* **************************************
* Global Variables *
* **************************************/

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

@ -6,25 +6,16 @@
#For example:
14:55
#Aircraft arrival (or departure) must be set relative to initial time, in HH:MM format.
ARRIVAL;PHX1802;100;01:00;0;180
ARRIVAL;PHX2015;180;00:10;0;180
ARRIVAL;PHX2016;140;00:30;0;180
ARRIVAL;PHX2017;140;00:40;0;180
ARRIVAL;PHX2018;140;00:55;0;180
ARRIVAL;PHX2018;160;01:20;0;180
ARRIVAL;PHX2020;160;01:45;0;180
ARRIVAL;PHX2019;140;01:30;0;180
ARRIVAL;PHX2021;140;02:00;0;180
ARRIVAL;PHX2022;140;02:30;0;180
ARRIVAL;PHX2023;140;02:15;0;180
ARRIVAL;PHX1802;100;01:00;0;360
ARRIVAL;PHX2015;100;00:10;0;360
ARRIVAL;PHX2016;100;00:40;0;360
ARRIVAL;PHX2017;100;00:50;0;360
ARRIVAL;PHX2018;100;01:40;0;360
ARRIVAL;PHX2018;100;01:20;0;360
ARRIVAL;PHX2018;100;02:00;0;360
DEPARTURE;PHX1000;100;00:05;19;180
DEPARTURE;PHX1280;100;00:30;19;180
DEPARTURE;PHX1332;100;00:45;21;180
DEPARTURE;PHX1280;100;01:30;19;180
DEPARTURE;PHX1332;100;00:50;21;180
DEPARTURE;PHX1333;100;01:00;19;180
DEPARTURE;PHX1334;100;01:15;21;180
DEPARTURE;PHX1336;100;01:20;21;180
DEPARTURE;PHX1335;100;01:30;19;180
DEPARTURE;PHX1335;100;01:40;19;180
DEPARTURE;PHX1335;100;02:00;19;180
DEPARTURE;PHX1335;100;02:15;19;180
DEPARTURE;PHX1335;100;02:30;19;180