279 lines
7.3 KiB
C
279 lines
7.3 KiB
C
#ifndef GAME_STRUCTURES__HEADER__
|
|
#define GAME_STRUCTURES__HEADER__
|
|
|
|
/* *************************************
|
|
* Defines
|
|
* *************************************/
|
|
|
|
#define GAME_MAX_AIRCRAFT 32
|
|
#define GAME_MAX_CHARACTERS 8
|
|
#define GAME_MAX_PARKING 32
|
|
#define GAME_MAX_RWY_LENGTH 16
|
|
#define GAME_MAX_MAP_SIZE 0x400
|
|
#define CHEAT_ARRAY_SIZE 16
|
|
#define AIRCRAFT_MAX_TARGETS 48
|
|
#define PLAYER_MAX_WAYPOINTS AIRCRAFT_MAX_TARGETS
|
|
#define GAME_MAX_SEQUENCE_KEYS 12
|
|
|
|
/* *************************************
|
|
* Structs and enums
|
|
* *************************************/
|
|
|
|
typedef struct t_Camera
|
|
{
|
|
int32_t X_Offset;
|
|
int32_t Y_Offset;
|
|
int8_t X_Speed;
|
|
int8_t Y_Speed;
|
|
uint8_t Speed_Timer;
|
|
}TYPE_CAMERA;
|
|
|
|
typedef enum t_fldir
|
|
{
|
|
DEPARTURE = 0x01,
|
|
ARRIVAL = 0x02
|
|
}FL_DIR;
|
|
|
|
typedef enum t_flstate
|
|
{
|
|
STATE_IDLE,
|
|
STATE_PARKED,
|
|
STATE_UNBOARDING,
|
|
STATE_TAXIING,
|
|
STATE_HOLDING_RWY,
|
|
STATE_ENTERING_RWY,
|
|
STATE_READY_FOR_TAKEOFF,
|
|
STATE_TAKEOFF,
|
|
STATE_CLIMBING,
|
|
STATE_APPROACH,
|
|
STATE_FINAL,
|
|
STATE_USER_STOPPED,
|
|
STATE_AUTO_STOPPED,
|
|
STATE_LANDED,
|
|
MAX_STATES
|
|
}FL_STATE;
|
|
|
|
typedef enum t_LevelDifficulty
|
|
{
|
|
LEVEL_DIFFICULTY_EASY = 0,
|
|
LEVEL_DIFFICULTY_MEDIUM,
|
|
LEVEL_DIFFICULTY_HARD
|
|
}LEVEL_DIFFICULTY;
|
|
|
|
typedef struct t_isopos
|
|
{
|
|
short x;
|
|
short y;
|
|
short z;
|
|
}TYPE_ISOMETRIC_POS;
|
|
|
|
typedef struct t_isofix16pos
|
|
{
|
|
fix16_t x;
|
|
fix16_t y;
|
|
fix16_t z;
|
|
}TYPE_ISOMETRIC_FIX16_POS;
|
|
|
|
typedef struct t_cartpos
|
|
{
|
|
short x;
|
|
short y;
|
|
}TYPE_CARTESIAN_POS;
|
|
|
|
typedef struct t_tileData
|
|
{
|
|
bool ShowTile;
|
|
TYPE_CARTESIAN_POS CartPos;
|
|
unsigned char r;
|
|
unsigned char g;
|
|
unsigned char b;
|
|
}TYPE_TILE_DATA;
|
|
|
|
typedef struct t_flightData
|
|
{
|
|
FL_DIR FlightDirection[GAME_MAX_AIRCRAFT];
|
|
char strFlightNumber[GAME_MAX_AIRCRAFT][GAME_MAX_CHARACTERS];
|
|
uint8_t Passengers[GAME_MAX_AIRCRAFT];
|
|
uint8_t Hours[GAME_MAX_AIRCRAFT];
|
|
uint8_t Minutes[GAME_MAX_AIRCRAFT];
|
|
uint8_t Parking[GAME_MAX_AIRCRAFT];
|
|
uint16_t RemainingTime[GAME_MAX_AIRCRAFT];
|
|
uint8_t nAircraft;
|
|
uint8_t nRemainingAircraft;
|
|
uint8_t ActiveAircraft;
|
|
FL_STATE State[GAME_MAX_AIRCRAFT];
|
|
bool Finished[GAME_MAX_AIRCRAFT];
|
|
}TYPE_FLIGHT_DATA;
|
|
|
|
typedef enum t_livery
|
|
{
|
|
AIRCRAFT_LIVERY_UNKNOWN = 0,
|
|
AIRCRAFT_LIVERY_0
|
|
}AIRCRAFT_LIVERY;
|
|
|
|
typedef enum t_direction
|
|
{
|
|
NO_DIRECTION,
|
|
DIR_NORTH,
|
|
DIR_SOUTH,
|
|
DIR_EAST,
|
|
DIR_WEST
|
|
}DIRECTION;
|
|
|
|
typedef enum t_aircraftAttitude
|
|
{
|
|
AIRCRAFT_STATE_NEUTRAL = 0,
|
|
AIRCRAFT_STATE_UP_5_DEGREES,
|
|
AIRCRAFT_STATE_UP_15_DEGREES,
|
|
AIRCRAFT_STATE_DOWN_5_DEGREES,
|
|
}AIRCRAFT_ATTITUDE;
|
|
|
|
typedef struct t_aircraftData
|
|
{
|
|
AIRCRAFT_LIVERY Livery;
|
|
DIRECTION Direction;
|
|
AIRCRAFT_ATTITUDE Attitude;
|
|
FL_STATE State;
|
|
// Target tile (used to calculate direction and movement)
|
|
uint16_t Target[AIRCRAFT_MAX_TARGETS];
|
|
uint8_t TargetIdx;
|
|
// Used to relate TYPE_AIRCRAFT_DATA and TYPE_FLIGHT_DATA
|
|
uint8_t FlightDataIdx;
|
|
// Position data (real pos inside map)
|
|
TYPE_ISOMETRIC_FIX16_POS IsoPos;
|
|
fix16_t Speed;
|
|
short TargetSpeed;
|
|
bool TargetReached;
|
|
// Used for target reached detection
|
|
fix16_t XPos_Old;
|
|
// Used for target reached detection
|
|
fix16_t YPos_Old;
|
|
}TYPE_AIRCRAFT_DATA;
|
|
|
|
typedef struct
|
|
{
|
|
// ## State flags ##
|
|
// Player is on the game
|
|
bool Active;
|
|
// Player requests showing aircraft data menu
|
|
bool ShowAircraftData;
|
|
// Player on runway selection mode (when FL_STATE == APPROACH)
|
|
bool SelectRunway;
|
|
// Player on taxiway + runway selection mode (when FL_STATE == PARKED)
|
|
bool SelectTaxiwayRunway;
|
|
// Player on taxiway + parking selection mode (when FL_STATE == LANDED)
|
|
bool SelectTaxiwayParking;
|
|
// Tiles selected by player are not valid for establishing a new path
|
|
bool InvalidPath;
|
|
// Player has locked the camera at a determined aircraft
|
|
bool LockTarget;
|
|
// Player is unboarding passengers
|
|
bool Unboarding;
|
|
|
|
// Stores indexes for player-specific active aircraft
|
|
// Used to relate SelectedAircraft against FlightData index
|
|
uint8_t ActiveAircraftList[GAME_MAX_AIRCRAFT];
|
|
// Flight direction to be managed by player (see 2-player mode)
|
|
FL_DIR FlightDirection;
|
|
// Number of active aircraft for current player (could be not equal to total active aircraft!)
|
|
uint8_t ActiveAircraft;
|
|
// When too many aircraft are active, they are separated into different pages
|
|
uint8_t FlightDataPage;
|
|
// Selected aircraft on aircraft data list
|
|
uint8_t SelectedAircraft;
|
|
// Aircraft being followed by camera
|
|
uint8_t LockedAircraft;
|
|
// Index for GameRwy buffer on "Select runway" mode
|
|
uint16_t SelectedRunway;
|
|
// Tile pointed to by cursor
|
|
uint16_t SelectedTile;
|
|
// Conversion between selected aircraft from data list and actual flight data index
|
|
uint8_t FlightDataSelectedAircraft;
|
|
// Waypoints added to list when player is tracing a path for an aircraft.
|
|
// For example: when determining path from runway to parking.
|
|
uint16_t Waypoints[PLAYER_MAX_WAYPOINTS];
|
|
// Internal index for waypoint management.
|
|
uint8_t WaypointIdx;
|
|
// Another internal index to keep last desired selected point by user when defining a path.
|
|
uint8_t LastWaypointIdx;
|
|
// If player is unboarding passengers, then a sequence of keys is generated to make unboarding
|
|
// process a bit more difficult and challenging.
|
|
unsigned short UnboardingSequence[GAME_MAX_SEQUENCE_KEYS];
|
|
// Index inside UnboardingSequence[]
|
|
uint8_t UnboardingSequenceIdx;
|
|
// Show passengers left
|
|
uint8_t PassengersLeftSelectedAircraft;
|
|
// Lookup tables defined on GameRenderTerrainPrecalculations() to be later used on
|
|
// GameRenderTerrain().
|
|
TYPE_TILE_DATA TileData[GAME_MAX_MAP_SIZE];
|
|
// Player camera instance.
|
|
TYPE_CAMERA Camera;
|
|
// Array of tiles which will change their RGB values when displayed under certain player states.
|
|
uint16_t RwyArray[GAME_MAX_RWY_LENGTH];
|
|
// Remaining time for next aircraft (if any).
|
|
uint16_t NextAircraftTime;
|
|
// Number of remaining aircraft in STATE_IDLE.
|
|
uint16_t RemainingAircraft;
|
|
|
|
// Pad callbacks.
|
|
bool (*const PadKeyPressed_Callback)(unsigned short);
|
|
bool (*const PadKeyReleased_Callback)(unsigned short);
|
|
bool (*const PadKeySinglePress_Callback)(unsigned short);
|
|
bool (*const PadDirectionKeyPressed_Callback)(void);
|
|
unsigned short (*const PadLastKeySinglePressed_Callback)(void);
|
|
}TYPE_PLAYER;
|
|
|
|
typedef enum t_fontflags
|
|
{
|
|
FONT_NOFLAGS = 1 << 0,
|
|
FONT_CENTERED = 1 << 1,
|
|
FONT_WRAP_LINE = 1 << 2,
|
|
FONT_BLEND_EFFECT = 1 << 3,
|
|
FONT_1HZ_FLASH = 1 << 4,
|
|
FONT_2HZ_FLASH = 1 << 5
|
|
}FONT_FLAGS;
|
|
|
|
typedef struct t_Font
|
|
{
|
|
GsSprite spr;
|
|
short char_spacing;
|
|
short char_w;
|
|
short char_h;
|
|
char init_ch;
|
|
uint8_t char_per_row;
|
|
uint8_t max_ch_wrap;
|
|
volatile FONT_FLAGS flags;
|
|
short spr_w;
|
|
short spr_h;
|
|
short spr_u;
|
|
short spr_v;
|
|
}TYPE_FONT;
|
|
|
|
typedef struct t_Timer
|
|
{
|
|
uint32_t time;
|
|
uint32_t orig_time;
|
|
bool repeat_flag;
|
|
bool busy;
|
|
void (*Timeout_Callback)(void);
|
|
}TYPE_TIMER;
|
|
|
|
typedef struct t_Cheat
|
|
{
|
|
unsigned short Combination[CHEAT_ARRAY_SIZE];
|
|
void (*Callback)(void);
|
|
}TYPE_CHEAT;
|
|
|
|
// TYPE_PLT_CONFIG is used for PLT file generation.
|
|
typedef struct t_PltConfig
|
|
{
|
|
uint8_t MaxTime; // Minutes
|
|
uint8_t nRunway;
|
|
uint8_t ParkingArray[GAME_MAX_PARKING];
|
|
LEVEL_DIFFICULTY Level;
|
|
bool TwoPlayers;
|
|
uint8_t maxLostFlights;
|
|
}TYPE_PLT_CONFIG;
|
|
|
|
#endif // GAME_STRUCTURES__HEADER__
|