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"

    10

    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_LGA           =  9,

    28

	AT_MUC           = 10,

    29

	AT_SFO           = 11,

    30

	AT_AMS           = 12,

    31

	AT_OILRIG        = 15,

    32

	AT_DUMMY         = 255

    33

};

    34

    35

    36

struct AirportMovingData {

    37

	int16 x;

    38

	int16 y;

    42

	uint16 flag;

    43

	DirectionByte direction;

    44

};

    45

    46

struct AirportFTAbuildup;

    47

    48

// Finite sTate mAchine --> FTA

    49

struct AirportFTAClass {

    50

	public:

    51

		enum Flags {

    52

			AIRPLANES   = 0x1,

    53

			HELICOPTERS = 0x2,

    54

			ALL         = AIRPLANES | HELICOPTERS,

    55

			SHORT_STRIP = 0x4

    56

		};

    57

    58

		AirportFTAClass(

    59

			AirportMovingData *moving_data,

    60

			byte *terminals,

    61

			byte *helipads,

    62

			byte *entry_points,

    63

			Flags flags,

    64

			AirportFTAbuildup *apFA,

    65

			TileIndexDiffC *depots,

    66

			byte nof_depots,

    67

			uint size_x,

    68

			uint size_y,

    69

			byte delta_z,

    70

			byte catchment

    71

		);

    72

    73

		~AirportFTAClass();

    74

    75

		const AirportMovingData *MovingData(byte position) const

    76

		{

    77

			assert(position < nofelements);

    78

			return &moving_data[position];

    79

		}

    80

    81

	AirportMovingData *moving_data;

    82

	struct AirportFTA *layout;            // state machine for airport

    83

	byte *terminals;

    84

	byte *helipads;

    85

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

    86

	Flags flags;

    87

	byte nof_depots;                      // number of depots this airport has

    88

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

    89

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

    90

	byte size_x;

    91

	byte size_y;

    92

	byte delta_z;                         // Z adjustment for helicopter pads

    93

	byte catchment;

    94

};

    95

    96

DECLARE_ENUM_AS_BIT_SET(AirportFTAClass::Flags)

    97

    98

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

    99

struct AirportFTA {

   100

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

   103

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

   104

	byte next_position;      // next position from this position

   105

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

   106

};

   107

   108

void InitializeAirports();

   109

void UnInitializeAirports();

   110

const AirportFTAClass *GetAirport(const byte airport_type);

   111

   112

/** Get buildable airport bitmask.

   113

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

   114

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

   115

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

   116

 */

   117

uint32 GetValidAirports();

   118

   119

#endif /* AIRPORT_H */