* More passengers by correct sequence are unboarded.

* Aircraft should not be removed on State == STATE_APPROACH.
* Initial implementation for finished game.
* Added some comments on System.c.
* GameGuiPrepareNotificationString() deprecated.
This commit is contained in:
XaviDCR92 2017-06-03 01:37:55 +02:00
parent 92c65ff3b2
commit 219d958538
11 changed files with 400 additions and 211 deletions

View File

@ -114,6 +114,8 @@ bool AircraftAddNew( TYPE_FLIGHT_DATA * ptrFlightData,
ptrAircraft->FlightDataIdx = FlightDataIndex;
dprintf("ptrAircraft->FlightDataIdx = %d, FlightDataIndex = %d\n", ptrAircraft->FlightDataIdx, FlightDataIndex);
if(ptrFlightData->FlightDirection[FlightDataIndex] == ARRIVAL)
{
ptrAircraft->IsoPos.x = 0;
@ -386,6 +388,7 @@ void AircraftDirection(TYPE_AIRCRAFT_DATA* ptrAircraft)
{
dprintf("All targets reached!\n");
ptrAircraft->State = GameTargetsReached(ptrAircraft->Target[0], ptrAircraft->FlightDataIdx);
memset(ptrAircraft->Target, 0, AIRCRAFT_MAX_TARGETS);
}
}
}

View File

@ -105,7 +105,7 @@ enum
UNBOARDING_KEY_SEQUENCE_EASY = 4,
UNBOARDING_KEY_SEQUENCE_MEDIUM = 6,
UNBOARDING_KEY_SEQUENCE_HARD = GAME_MAX_SEQUENCE_KEYS,
UNBOARDING_PASSENGERS_PER_SEQUENCE = 25
UNBOARDING_PASSENGERS_PER_SEQUENCE = 50
};
/* *************************************
@ -115,6 +115,7 @@ enum
static void GameInit(void);
static void GameLoadLevel(void);
static bool GamePause(void);
static bool GameFinished(void);
static void GameEmergencyMode(void);
static void GameCalculations(void);
static void GamePlayerHandler(TYPE_PLAYER* ptrPlayer, TYPE_FLIGHT_DATA * ptrFlightData);
@ -212,6 +213,11 @@ void Game(bool two_players)
while(1)
{
if(GameFinished() == true)
{
break;
}
if(GamePause() == true)
{
// Exit game
@ -665,8 +671,6 @@ void GameGraphics(void)
// Draw common elements for both players (messages, clock...)
GameGuiAircraftNotificationRequest(&FlightData);
GameGuiBubble(&FlightData);
GameGuiClock(GameHour,GameMinutes);
@ -804,6 +808,8 @@ void GameAircraftState(void)
target[0] = FlightData.Parking[i];
dprintf("Target assigned = %d\n", target[0]);
dprintf("2\n");
if(AircraftAddNew(&FlightData, i, target) == false)
{
@ -814,6 +820,7 @@ void GameAircraftState(void)
}
else if(FlightData.FlightDirection[i] == ARRIVAL)
{
dprintf("Flight %d set to STATE_APPROACH.\n", i);
FlightData.State[i] = STATE_APPROACH;
// Create notification request for incoming aircraft
FlightData.NotificationRequest[i] = true;
@ -825,6 +832,9 @@ void GameAircraftState(void)
(FlightData.RemainingTime[i] == 0) )
{
// Player(s) lost a flight!
DEBUG_PRINT_VAR(i);
DEBUG_PRINT_VAR(FlightData.State[i]);
DEBUG_PRINT_VAR(FlightData.RemainingTime[i]);
GameRemoveFlight(i, false);
}
}
@ -1007,11 +1017,27 @@ void GameRenderLevel(TYPE_PLAYER* ptrPlayer)
for(j = 0; j < GAME_MAX_AIRCRAFT; j++)
{
uint16_t* targets = AircraftGetTargets(j);
aircraftTile = AircraftGetTileFromFlightDataIndex(j);
uint16_t lastTarget = 0;
uint8_t k;
if(i == aircraftTile)
for(k = 0; k < AIRCRAFT_MAX_TARGETS; k++)
{
if(targets[k] == 0)
{
break;
}
lastTarget = targets[k];
}
if( (i == aircraftTile)
||
(i == lastTarget) )
{
bHoldingRwyBusy = true;
break;
}
}
@ -1704,6 +1730,8 @@ void GameAssignRunwaytoAircraft(TYPE_PLAYER* ptrPlayer, TYPE_FLIGHT_DATA * ptrFl
targets[0] = assignedRwy;
targets[1] = rwyExit;
dprintf("1\n");
if( AircraftAddNew(ptrFlightData,
aircraftIndex,
@ -2460,24 +2488,22 @@ void GameRemoveFlight(uint8_t idx, bool successful)
DEBUG_PRINT_VAR(&PlayerData[PLAYER_ONE]);
DEBUG_PRINT_VAR(&PlayerData[PLAYER_TWO]);*/
FlightData.Passengers[ptrPlayer->ActiveAircraftList[j]] = 0;
FlightData.State[ptrPlayer->ActiveAircraftList[j]] = STATE_IDLE;
FlightData.Finished[ptrPlayer->ActiveAircraftList[j]] = true;
for(k = 0; k < GAME_MAX_RUNWAYS; k++)
{
uint16_t* targets = AircraftGetTargets(ptrPlayer->ActiveAircraftList[j]);
uint8_t targetIdx = AircraftGetTargetIdx(ptrPlayer->ActiveAircraftList[j]);
if(SystemContains_u16(GameUsedRwy[k], targets, targetIdx) == true)
if(SystemContains_u16(GameUsedRwy[k], targets, AIRCRAFT_MAX_TARGETS) == true)
{
GameUsedRwy[k] = 0;
}
}
if(AircraftRemove(idx) == false)
if(FlightData.State[ptrPlayer->ActiveAircraftList[j]] != STATE_APPROACH)
{
dprintf("Something went wrong when removing aircraft!\n");
if(AircraftRemove(idx) == false)
{
dprintf("Something went wrong when removing aircraft!\n");
}
}
ptrPlayer->LockTarget = false;
@ -2492,6 +2518,10 @@ void GameRemoveFlight(uint8_t idx, bool successful)
GameScore = (GameScore < LOST_FLIGHT_PENALTY)? 0 : (GameScore - LOST_FLIGHT_PENALTY);
}
FlightData.Passengers[ptrPlayer->ActiveAircraftList[j]] = 0;
FlightData.State[ptrPlayer->ActiveAircraftList[j]] = STATE_IDLE;
FlightData.Finished[ptrPlayer->ActiveAircraftList[j]] = true;
return;
}
}
@ -2525,3 +2555,18 @@ void GameActiveAircraftList(TYPE_PLAYER* ptrPlayer, TYPE_FLIGHT_DATA * ptrFlight
}
}
bool GameFinished(void)
{
uint8_t i;
for(i = 0; i < FlightData.nAircraft; i++)
{
if(FlightData.Finished[i] == false)
{
// At least one aircraft still not finished
return false;
}
}
return GameGuiFinishedDialog(&PlayerData[PLAYER_ONE]);
}

View File

@ -10,7 +10,6 @@
#define NOTIFICATION_TIMER_LIMIT 5*TIMEBASE_1_SECOND // 5 seconds
#define BUBBLE_VIBRATION_TIMER_LIMIT TIMEBASE_1_SECOND >> 1 // Half a second
#define NOTIFICATION_BUFFER_SIZE 200
#define GAME_GUI_AIRCRAFT_DATA_MAX_PAGE 4
#define SLOW_SCORE_LOW_SPEED_MARGIN 100
@ -20,57 +19,6 @@
/* **************************************
* Structs and enums *
* *************************************/
enum
{
PAUSE_DIALOG_X = 92,
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,
PAUSE_DIALOG_B3 = PAUSE_DIALOG_B2,
};
enum
{
NOTIFICATION_GSGPOLY4_R0 = 0,
NOTIFICATION_GSGPOLY4_R1 = NOTIFICATION_GSGPOLY4_R0,
NOTIFICATION_GSGPOLY4_R2 = 0,
NOTIFICATION_GSGPOLY4_R3 = NOTIFICATION_GSGPOLY4_R2,
NOTIFICATION_GSGPOLY4_G0 = NORMAL_LUMINANCE,
NOTIFICATION_GSGPOLY4_G1 = NOTIFICATION_GSGPOLY4_G0,
NOTIFICATION_GSGPOLY4_G2 = 0,
NOTIFICATION_GSGPOLY4_G3 = NOTIFICATION_GSGPOLY4_G2,
NOTIFICATION_GSGPOLY4_B0 = 40,
NOTIFICATION_GSGPOLY4_B1 = NOTIFICATION_GSGPOLY4_B0,
NOTIFICATION_GSGPOLY4_B2 = 0,
NOTIFICATION_GSGPOLY4_B3 = NOTIFICATION_GSGPOLY4_B2,
NOTIFICATION_GSGPOLY4_X0 = 16,
NOTIFICATION_GSGPOLY4_X1 = X_SCREEN_RESOLUTION - NOTIFICATION_GSGPOLY4_X0 - 16,
NOTIFICATION_GSGPOLY4_X2 = NOTIFICATION_GSGPOLY4_X0,
NOTIFICATION_GSGPOLY4_X3 = NOTIFICATION_GSGPOLY4_X1,
NOTIFICATION_GSGPOLY4_Y0 = Y_SCREEN_RESOLUTION - (64 + 8),
NOTIFICATION_GSGPOLY4_Y1 = NOTIFICATION_GSGPOLY4_Y0,
NOTIFICATION_GSGPOLY4_Y2 = Y_SCREEN_RESOLUTION - 8,
NOTIFICATION_GSGPOLY4_Y3 = NOTIFICATION_GSGPOLY4_Y2
};
enum
{
@ -83,18 +31,6 @@ enum
NOTIFICATION_BUTTON_Y = BUBBLE_SPRITE_Y + 16
};
enum
{
CLOCK_X = 16,
CLOCK_Y = 16
};
enum
{
SCORE_X = (X_SCREEN_RESOLUTION >> 1) - 64,
SCORE_Y = 16,
};
enum
{
AIRCRAFT_DATA_GSGPOLY4_R0 = 0,
@ -236,7 +172,6 @@ enum
* Local prototypes *
* *************************************/
static void GameGuiPrepareNotificationString(TYPE_FLIGHT_DATA * ptrFlightData, uint8_t offset);
static void GameGuiShowAircraftData(TYPE_PLAYER* ptrPlayer, TYPE_FLIGHT_DATA * ptrFlightData);
static void GameGuiClearPassengersLeft(void);
@ -245,7 +180,6 @@ static void GameGuiClearPassengersLeft(void);
* *************************************/
static GsSprite BubbleSpr;
static GsGPoly4 NotificationGPoly4;
static GsGPoly4 AircraftDataGPoly4;
static GsGPoly4 SelectedAircraftGPoly4;
static GsSprite ArrowsSpr;
@ -262,11 +196,33 @@ static void * GameFileDest[] = {(GsSprite*)&BubbleSpr ,
(TYPE_FONT*)&RadioFont ,
(GsSprite*)&ArrowsSpr };
static char strNotificationRequest[NOTIFICATION_BUFFER_SIZE];
static uint32_t slowScore; // It will update slowly to actual score value
void GameGuiInit(void)
{
enum
{
PAUSE_DIALOG_X = 92,
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,
PAUSE_DIALOG_B3 = PAUSE_DIALOG_B2,
};
LoadMenu( GameFileList,
GameFileDest,
sizeof(GameFileList) / sizeof(char*),
@ -304,89 +260,6 @@ void GameGuiInit(void)
slowScore = 0;
}
void GameGuiAircraftNotificationRequest(TYPE_FLIGHT_DATA * ptrFlightData)
{
uint8_t i;
static uint16_t NotificationTimer;
static uint8_t FirstNotification;
bool first_entered = true;
if(GameStartupFlag == true)
{
// Set initial values to static variables
NotificationTimer = 0;
FirstNotification = 0;
}
for(i = FirstNotification; i < ptrFlightData->nAircraft ; i++)
{
if(ptrFlightData->NotificationRequest[i] == true)
{
// Prepare RGB data and (X,Y) coordinates for notification
// request rectangle.
NotificationGPoly4.r[0] = NOTIFICATION_GSGPOLY4_R0;
NotificationGPoly4.r[1] = NOTIFICATION_GSGPOLY4_R1;
NotificationGPoly4.r[2] = NOTIFICATION_GSGPOLY4_R2;
NotificationGPoly4.r[3] = NOTIFICATION_GSGPOLY4_R3;
NotificationGPoly4.g[0] = NOTIFICATION_GSGPOLY4_G0;
NotificationGPoly4.g[1] = NOTIFICATION_GSGPOLY4_G1;
NotificationGPoly4.g[2] = NOTIFICATION_GSGPOLY4_G2;
NotificationGPoly4.g[3] = NOTIFICATION_GSGPOLY4_G3;
NotificationGPoly4.b[0] = NOTIFICATION_GSGPOLY4_B0;
NotificationGPoly4.b[1] = NOTIFICATION_GSGPOLY4_B1;
NotificationGPoly4.b[2] = NOTIFICATION_GSGPOLY4_B2;
NotificationGPoly4.b[3] = NOTIFICATION_GSGPOLY4_B3;
NotificationGPoly4.attribute |= ENABLE_TRANS | TRANS_MODE(0);
NotificationGPoly4.x[0] = NOTIFICATION_GSGPOLY4_X0;
NotificationGPoly4.x[1] = NOTIFICATION_GSGPOLY4_X1;
NotificationGPoly4.x[2] = NOTIFICATION_GSGPOLY4_X2;
NotificationGPoly4.x[3] = NOTIFICATION_GSGPOLY4_X3;
NotificationGPoly4.y[0] = NOTIFICATION_GSGPOLY4_Y0;
NotificationGPoly4.y[1] = NOTIFICATION_GSGPOLY4_Y1;
NotificationGPoly4.y[2] = NOTIFICATION_GSGPOLY4_Y2;
NotificationGPoly4.y[3] = NOTIFICATION_GSGPOLY4_Y3;
/* dprintf("Notification timer: %d.\n",NotificationTimer); */
if(++NotificationTimer >= NOTIFICATION_TIMER_LIMIT)
{
// Reset timer and notification request for current aircraft
FirstNotification = 0;
NotificationTimer = 0;
ptrFlightData->NotificationRequest[i] = 0;
first_entered = true;
}
else
{
if(first_entered == true)
{
// Prepare string for new notification request only once
first_entered = false;
RadioFont.max_ch_wrap = 18;
RadioFont.flags |= FONT_WRAP_LINE;
GameGuiPrepareNotificationString(ptrFlightData, i);
}
// Keep information about last aircraft notified...
// so that it gets called on next cycle
FirstNotification = i;
GsSortGPoly4(&NotificationGPoly4);
FontPrintText( &RadioFont,
NotificationGPoly4.x[0] + 8,
NotificationGPoly4.y[0] + 8,
strNotificationRequest);
}
break;
}
}
}
bool GameGuiPauseDialog(TYPE_PLAYER* ptrPlayer)
{
GfxSaveDisplayData(&SecondDisplay);
@ -717,30 +590,14 @@ void GameGuiBubble(TYPE_FLIGHT_DATA * ptrFlightData)
//dprintf("Bubble timer: %d\n",BubbleVibrationTimer);
}
void GameGuiPrepareNotificationString(TYPE_FLIGHT_DATA * ptrFlightData, uint8_t offset)
{
memset(strNotificationRequest,0,NOTIFICATION_BUFFER_SIZE);
strncat( strNotificationRequest,
ptrFlightData->strFlightNumber[offset],
strlen(ptrFlightData->strFlightNumber[offset]) );
strcat(strNotificationRequest, " request for ");
switch(ptrFlightData->FlightDirection[offset])
{
case DEPARTURE:
strcat(strNotificationRequest, "departure");
break;
case ARRIVAL:
strcat(strNotificationRequest, "approach");
break;
}
strcat(strNotificationRequest, ".");
}
void GameGuiClock(uint8_t hour, uint8_t min)
{
enum
{
CLOCK_X = 16,
CLOCK_Y = 4
};
static char strClock[6]; // HH:MM + \0 (6 characters needed)
if(GameStartupFlag || System1SecondTick() == true)
@ -967,6 +824,12 @@ void GameGuiCalculateSlowScore(void)
void GameGuiShowScore(void)
{
enum
{
SCORE_X = (X_SCREEN_RESOLUTION >> 1) - 64,
SCORE_Y = 4,
};
FontPrintText( &RadioFont,
SCORE_X,
SCORE_Y,
@ -1003,3 +866,38 @@ void GameGuiClearPassengersLeft(void)
{
GameGuiClearPassengersLeft_Flag = true;
}
bool GameGuiFinishedDialog(TYPE_PLAYER* ptrPlayer)
{
GfxSaveDisplayData(&SecondDisplay);
GfxSetGlobalLuminance(NORMAL_LUMINANCE);
//DrawFBRect(0, 0, X_SCREEN_RESOLUTION, VRAM_H, 0, 0, 0);
while(GfxIsGPUBusy() == true);
do
{
if(ptrPlayer->PadKeySinglePress_Callback(PAD_CROSS) == true)
{
return true;
}
GfxSortSprite(&SecondDisplay);
GsSortGPoly4(&PauseRect);
FontPrintText( &SmallFont,
AIRCRAFT_DATA_GSGPOLY4_X0_2PLAYER +
( (AIRCRAFT_DATA_GSGPOLY4_X1_2PLAYER - AIRCRAFT_DATA_GSGPOLY4_X0_2PLAYER) >> 2),
AIRCRAFT_DATA_GSGPOLY4_Y0_2PLAYER +
( (AIRCRAFT_DATA_GSGPOLY4_Y2_2PLAYER - AIRCRAFT_DATA_GSGPOLY4_Y0_2PLAYER) >> 1),
"All flights finished!" );
GfxDrawScene_Slow();
}while(ptrPlayer->PadKeySinglePress_Callback(PAD_START) == false);
return false;
}

View File

@ -30,7 +30,6 @@
void GameGuiInit(void);
bool GameGuiPauseDialog(TYPE_PLAYER* ptrPlayer);
bool GameGuiShowAircraftDataSpecialConditions(TYPE_PLAYER* ptrPlayer);
void GameGuiAircraftNotificationRequest(TYPE_FLIGHT_DATA * ptrFlightData);
void GameGuiBubble(TYPE_FLIGHT_DATA * ptrFlightData);
void GameGuiClock(uint8_t hour, uint8_t min);
void GameGuiActiveAircraftList(TYPE_PLAYER* ptrPlayer, TYPE_FLIGHT_DATA * ptrFlightData);
@ -39,5 +38,6 @@ void GameGuiCalculateSlowScore(void);
void GameGuiShowScore(void);
void GameGuiDrawUnboardingSequence(TYPE_PLAYER* ptrPlayer);
void GameGuiAircraftList(TYPE_PLAYER* ptrPlayer, TYPE_FLIGHT_DATA * ptrFlightData);
bool GameGuiFinishedDialog(TYPE_PLAYER* ptrPlayer);
#endif //__GAME_GUI_HEADER__

View File

@ -73,3 +73,5 @@ short MainMenuBtnAni[] =
1,
0
};
size_t MainMenuBtnAni_sz = sizeof(MainMenuBtnAni) / sizeof(MainMenuBtnAni[0]);

View File

@ -12,8 +12,6 @@
* Defines
* *************************************/
#define MAIN_MENU_BTN_ANI_SIZE 53
/* *************************************
* Global prototypes
* *************************************/
@ -23,5 +21,6 @@
* *************************************/
extern short MainMenuBtnAni[];
extern size_t MainMenuBtnAni_sz;
#endif // __MAINMENUBTN_HEADER__

View File

@ -1,5 +1,6 @@
CC = psx-gcc
DEFINE= -DFIXMATH_FAST_SIN -D_PAL_MODE_ -DPSXSDK_DEBUG
DEFINE= -DFIXMATH_FAST_SIN -D_PAL_MODE_
DEFINE += -DPSXSDK_DEBUG
DEFINE += -DNO_CDDA
DEFINE += -DNO_INTRO
LIBS= -lfixmath

View File

@ -432,7 +432,7 @@ void MainMenuDrawButton(TYPE_MMBtn * btn)
MenuSpr.w = BUTTON_SIZE;
MenuSpr.h = BUTTON_SIZE;
if(btn->timer < MAIN_MENU_BTN_ANI_SIZE)
if(btn->timer < MainMenuBtnAni_sz)
{
btn->timer++;
}

View File

@ -211,6 +211,7 @@ bool PltParserLoadFile(char * strPath, TYPE_FLIGHT_DATA * ptrFlightData)
case REMAINING_TIME_INDEX:
ptrFlightData->RemainingTime[aircraftIndex] = (uint8_t)atoi(lineBufferPtr);
dprintf("ptrFlightData->RemainingTime[%d] = %d\n", aircraftIndex, ptrFlightData->RemainingTime[aircraftIndex]);
break;

View File

@ -213,38 +213,102 @@ void SystemIncreaseGlobalTimer(void)
global_timer++;
}
/* *******************************************************************
*
* @name: uint64_t SystemGetGlobalTimer(void)
*
* @author: Xavier Del Campo
*
* @brief: Returns internal global timer value.
*
* *******************************************************************/
uint64_t SystemGetGlobalTimer(void)
{
return global_timer;
}
/* *******************************************************************
*
* @name: void SystemDisableScreenRefresh(void)
*
* @author: Xavier Del Campo
*
* @brief: Resets VBlank IRQ flag.
*
* *******************************************************************/
void SystemDisableScreenRefresh(void)
{
refresh_needed = false;
}
/* *******************************************************************
*
* @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)
{
return one_second_timer;
}
/* *******************************************************************
*
* @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)
{
return hundred_ms_timer;
}
/* *******************************************************************
*
* @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)
{
return five_hundred_ms_timer;
}
static uint64_t last_one_second_tick;
static uint64_t last_100_ms_tick;
static uint64_t last_500_ms_tick;
/* *******************************************************************
*
* @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)
{
static uint64_t last_one_second_tick;
static uint64_t last_100_ms_tick;
static uint64_t last_500_ms_tick;
SystemCheckTimer(&one_second_timer, &last_one_second_tick, REFRESH_FREQUENCY);
#ifdef _PAL_MODE_
@ -256,6 +320,16 @@ void SystemRunTimers(void)
}
/* ********************************************************************************
*
* @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)
@ -270,6 +344,19 @@ 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)
{
FILE *f;
@ -325,16 +412,48 @@ bool SystemLoadFileToBuffer(char * fname, uint8_t* buffer, uint32_t szBuffer)
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)
{
return SystemLoadFileToBuffer(fname,file_buffer,sizeof(file_buffer));
}
/* ******************************************************************
*
* @name uint8_t* SystemGetBufferAddress(void)
*
* @author: Xavier Del Campo
*
* @return: Reportedly, returns internal buffer initial address.
*
* *****************************************************************/
uint8_t* SystemGetBufferAddress(void)
{
return file_buffer;
}
/* ******************************************************************
*
* @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;
@ -342,26 +461,83 @@ void SystemWaitCycles(uint32_t cycles)
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)
{
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)
{
emergency_mode = value;
}
/* ***********************************************************************
*
* @name bool SystemGetEmergencyMode(void)
*
* @author: Xavier Del Campo
*
* @return: returns emergency mode flag.
*
* ***********************************************************************/
bool SystemGetEmergencyMode(void)
{
return emergency_mode;
}
/* ***********************************************************************
*
* @name volatile bool SystemIsBusy(void)
*
* @author: Xavier Del Campo
*
* @return: returns system busy flag.
*
* ***********************************************************************/
volatile bool SystemIsBusy(void)
{
return system_busy;
}
/* ****************************************************************************
*
* @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;
@ -377,6 +553,19 @@ bool SystemContains_u8(uint8_t value, uint8_t* buffer, size_t sz)
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;
@ -392,6 +581,25 @@ bool SystemContains_u16(uint16_t value, uint16_t* buffer, size_t sz)
return false;
}
/* ********************************************************************************************
*
* @name TYPE_TIMER* SystemCreateTimer(uint32_t t, bool rf, void (*timer_callback)(void) )
*
* @author: Xavier Del Campo
*
* @brief: fills a TYPE_TIMER structure with input parameters
*
* @param: uint32_t t:
* Timeout value (1 unit = 10 ms)
* bool rf:
* Repeat flag
* void (*timer_callback)(void)
* Function to be called on timeout
*
* @return: pointer to TYPE_TIMER structure if filled correctly, NULL pointer otherwise.
*
* ********************************************************************************************/
TYPE_TIMER* SystemCreateTimer(uint32_t t, bool rf, void (*timer_callback)(void) )
{
bool success = false;
@ -426,20 +634,38 @@ TYPE_TIMER* SystemCreateTimer(uint32_t t, bool rf, void (*timer_callback)(void)
return &timer_array[i];
}
/* *******************************************
*
* @name void SystemResetTimers(void)
*
* @author: Xavier Del Campo
*
* @brief: reportedly, removes all timers.
*
* *******************************************/
void SystemResetTimers(void)
{
uint8_t i;
for(i = 0; i < SYSTEM_MAX_TIMERS; i++)
{
timer_array[i].Timeout_Callback = NULL;
timer_array[i].busy = false;
timer_array[i].repeat_flag = false;
timer_array[i].time = 0;
timer_array[i].orig_time = 0;
SystemTimerRemove(&timer_array[i]);
}
}
/* *****************************************************
*
* @name void SystemUserTimersHandler(void)
*
* @author: Xavier Del Campo
*
* @brief: reportedly, handles all available timers.
*
* @remarks: calls callback on timeout.
*
* *****************************************************/
void SystemUserTimersHandler(void)
{
uint8_t i;
@ -473,6 +699,18 @@ void SystemUserTimersHandler(void)
}
}
/* *********************************************************************
*
* @name void SystemUserTimersHandler(void)
*
* @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 SystemTimerRestart(TYPE_TIMER* timer)
{
timer->time = timer->orig_time;

View File

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