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

    10

enum {MAX_TERMINALS =  12};

    11

enum {MAX_HELIPADS  =   4};

    12

enum {MAX_ELEMENTS  = 255};

    13

enum {MAX_HEADINGS  =  30};

    14

    15

// Airport types

    16

enum {

    17

	AT_SMALL         =  0,

    18

	AT_LARGE         =  1,

    19

	AT_HELIPORT      =  2,

    20

	AT_METROPOLITAN  =  3,

    21

	AT_INTERNATIONAL =  4,

    22

	AT_COMMUTER      =  5,

    23

	AT_HELIDEPOT     =  6,

    24

	AT_INTERCON      =  7,

    25

	AT_HELISTATION   =  8,

    26

	AT_LGA           =  9,

    27

	AT_MUC           = 10,

    28

	AT_SFO           = 11,

    29

	AT_AMS           = 12,

    30

	AT_OILRIG        = 15,

    31

	AT_DUMMY         = 255

    32

};

    33

    34

    35

struct AirportMovingData {

    36

	int16 x;

    37

	int16 y;

    38

	uint16 flag;

    39

	DirectionByte direction;

    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

		};

    53

    54

		AirportFTAClass(

    55

			AirportMovingData *moving_data,

    56

			byte *terminals,

    57

			byte *helipads,

    58

			byte *entry_points,

    59

			Flags flags,

    60

			AirportFTAbuildup *apFA,

    61

			TileIndexDiffC *depots,

    62

			byte nof_depots,

    63

			uint size_x,

    64

			uint size_y,

    65

			byte delta_z,

    66

			byte catchment

    67

		);

    68

    69

		~AirportFTAClass();

    70

    72

		{

    73

			assert(position < nofelements);

    74

			return &moving_data[position];

    75

		}

    76

    77

	AirportMovingData *moving_data;

    78

	struct AirportFTA *layout;            // state machine for airport

    79

	byte *terminals;

    80

	byte *helipads;

    81

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

    82

	Flags flags;

    83

	byte nof_depots;                      // number of depots this airport has

    84

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

    85

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

    86

	byte size_x;

    87

	byte size_y;

    88

	byte delta_z;                         // Z adjustment for helicopter pads

    89

	byte catchment;

    90

};

    91

    92

DECLARE_ENUM_AS_BIT_SET(AirportFTAClass::Flags)

    93

    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

	uint64 block;            // 64 bit blocks (st->airport_flags), should be enough for the most complex airports

    99

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

   100

	byte next_position;      // next position from this position

   101

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

   102

};

   103

   104

void InitializeAirports();

   105

void UnInitializeAirports();

   107

   108

/** Get buildable airport bitmask.

   109

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

   110

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

   111

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

   112

 */

   113

uint32 GetValidAirports();

   114

   115

#endif /* AIRPORT_H */