1

/* $Id$ */

     2

     3

/** @file airport.h Various declarations for airports */

     4

     5

#ifndef AIRPORT_H

     6

#define AIRPORT_H

     7

     8

#include "direction.h"

     9

#include "fsmblockmap.h"

    10

    11

enum {MAX_TERMINALS =  36};

    12

enum {MAX_HELIPADS  =  24};

    13

enum {MAX_ELEMENTS  = 255};

    14

enum {MAX_HEADINGS  =  30};

    15

    16

// Airport types

    17

enum {

    18

	AT_SMALL         =  0,

    19

	AT_LARGE         =  1,

    20

	AT_HELIPORT      =  2,

    21

	AT_METROPOLITAN  =  3,

    22

	AT_INTERNATIONAL =  4,

    23

	AT_COMMUTER      =  5,

    24

	AT_HELIDEPOT     =  6,

    25

	AT_INTERCON      =  7,

    26

	AT_HELISTATION   =  8,

    27

	AT_OILRIG        = 15,

    28

	AT_DUMMY         = 255

    29

};

    30

    31

    32

struct AirportMovingData {

    33

	int16 x;

    34

	int16 y;

    35

	int16 z;

    36

	uint16 flag;

    37

	DirectionByte direction;

    38

	byte state;

    39

	byte block;  //block number for this specific location

    40

};

    41

    42

struct AirportFTAbuildup;

    43

    44

// Finite sTate mAchine --> FTA

    45

struct AirportFTAClass {

    46

	public:

    47

		enum Flags {

    48

			AIRPLANES   = 0x1,

    49

			HELICOPTERS = 0x2,

    50

			ALL         = AIRPLANES | HELICOPTERS,

    51

			SHORT_STRIP = 0x4,

    52

			SEAPLANES   = 0x8

    53

		};

    54

    55

		AirportFTAClass(

    56

			AirportMovingData *moving_data,

    57

			byte *terminals,

    58

			byte *helipads,

    59

			byte *entry_points,

    60

			Flags flags,

    61

			AirportFTAbuildup *apFA,

    62

			TileIndexDiffC *depots,

    63

			byte nof_depots,

    64

			uint size_x,

    65

			uint size_y,

    66

			byte delta_z,

    67

			byte catchment

    68

		);

    69

    70

		~AirportFTAClass();

    71

    72

		const AirportMovingData *MovingData(byte position) const

    73

		{

    74

			assert(position < nofelements);

    75

			return &moving_data[position];

    76

		}

    77

    78

	AirportMovingData *moving_data;

    79

	struct AirportFTA *layout;            // state machine for airport

    80

	byte *terminals;

    81

	byte *helipads;

    82

	TileIndexDiffC *airport_depots; // gives the position of the depots on the airports

    83

	Flags flags;

    84

	byte nof_depots;                      // number of depots this airport has

    85

	byte nofelements;                     // number of positions the airport consists of

    86

	byte *entry_points;             ///< when an airplane arrives at this airport, enter it at position entry_point, index depends on direction

    87

	byte size_x;

    88

	byte size_y;

    89

	byte delta_z;                         // Z adjustment for helicopter pads

    90

	byte catchment;

    91

};

    92

    93

DECLARE_ENUM_AS_BIT_SET(AirportFTAClass::Flags)

    94

    95

// internal structure used in openttd - Finite sTate mAchine --> FTA

    96

struct AirportFTA {

    97

	AirportFTA *next;        // possible extra movement choices from this position

    98

	FSMblockmap reserveblock;       // 2 64 bit blocks

    99

	FSMblockmap releaseblock;       // 2 64 bit blocks

   100

	byte position;           // the position that an airplane is at

   101

	byte next_position;      // next position from this position

   102

	byte heading;            // heading (current orders), guiding an airplane to its target on an airport

   104

};

   105

   106

void InitializeAirports();

   107

void UnInitializeAirports();

   108

const AirportFTAClass *GetAirport(const byte airport_type);

   109

   110

/** Get buildable airport bitmask.

   111

 * @return get all buildable airports at this given time, bitmasked.

   112

 * Bit 0 means the small airport is buildable, etc.

   113

 * @todo set availability of airports by year, instead of airplane

   114

 */

   115

uint32 GetValidAirports();

   116

   117

#endif /* AIRPORT_H */