1

/* $Id$ */

     2

     3

/** @file aircraft.h */

     4

     5

#ifndef AIRCRAFT_H

     6

#define AIRCRAFT_H

     7

     8

#include "station_map.h"

     9

#include "vehicle.h"

    10

    11

/** An aircraft can be one ot those types */

    12

enum AircraftSubType {

    13

	AIR_HELICOPTER = 0, ///< an helicopter

    14

	AIR_AIRCRAFT   = 2, ///< an airplane

    15

	AIR_SHADOW     = 4, ///< shadow of the aircraft

    16

	AIR_ROTOR      = 6  ///< rotor of an helicopter

    17

};

    18

    19

    20

/** Check if the aircraft type is a normal flying device; eg

    21

 * not a rotor or a shadow

    22

 * @param v vehicle to check

    23

 * @return Returns true if the aircraft is a helicopter/airplane and

    24

 * false if it is a shadow or a rotor) */

    25

static inline bool IsNormalAircraft(const Vehicle *v)

    26

{

    27

	assert(v->type == VEH_AIRCRAFT);

    28

	/* To be fully correct the commented out functionality is the proper one,

    29

	 * but since value can only be 0 or 2, it is sufficient to only check <= 2

    30

	 * return (v->subtype == AIR_HELICOPTER) || (v->subtype == AIR_AIRCRAFT); */

    31

	return v->subtype <= AIR_AIRCRAFT;

    32

}

    33

    34

/** Check if this aircraft is in a hangar

    35

 * @param v vehicle to check

    36

 * @return true if in hangar

    37

 */

    38

static inline bool IsAircraftInHangar(const Vehicle* v)

    39

{

    40

	assert(v->type == VEH_AIRCRAFT);

    41

	return v->vehstatus & VS_HIDDEN && IsHangarTile(v->tile);

    42

}

    43

    44

/** Check if this aircraft is in a hangar and stopped

    45

 * @param v vehicle to check

    46

 * @return true if in hangar and stopped

    47

 */

    48

static inline bool IsAircraftInHangarStopped(const Vehicle* v)

    49

{

    50

	return IsAircraftInHangar(v) && v->vehstatus & VS_STOPPED;

    51

}

    52

    53

/** Checks if an aircraft is buildable at the tile in question

    54

 * @param engine The engine to test

    55

 * @param tile The tile where the hangar is

    56

 * @return true if the aircraft can be build

    57

 */

    58

static inline bool IsAircraftBuildableAtStation(EngineID engine, TileIndex tile)

    59

{

    60

	const Station *st = GetStationByTile(tile);

    61

	const AirportFTAClass *apc = st->Airport();

    62

	const AircraftVehicleInfo *avi = AircraftVehInfo(engine);

    63

    64

	return (apc->flags & (avi->subtype & AIR_CTOL ? AirportFTAClass::AIRPLANES : AirportFTAClass::HELICOPTERS)) != 0;

    65

}

    66

    67

/**

    68

 * Calculates cargo capacity based on an aircraft's passenger

    69

 * and mail capacities.

    70

 * @param cid Which cargo type to calculate a capacity for.

    71

 * @param avi Which engine to find a cargo capacity for.

    72

 * @return New cargo capacity value.

    73

 */

    74

uint16 AircraftDefaultCargoCapacity(CargoID cid, const AircraftVehicleInfo *avi);

    75

    76

/**

    77

 * This is the Callback method after the construction attempt of an aircraft

    78

 * @param success indicates completion (or not) of the operation

    79

 * @param tile of depot where aircraft is built

    80

 * @param p1 unused

    81

 * @param p2 unused

    82

 */

    83

void CcBuildAircraft(bool success, TileIndex tile, uint32 p1, uint32 p2);

    84

    85

/**

    86

 * This is the Callback method after the cloning attempt of an aircraft

    87

 * @param success indicates completion (or not) of the operation

    88

 * @param tile unused

    89

 * @param p1 unused

    90

 * @param p2 unused

    91

 */

    92

void CcCloneAircraft(bool success, TileIndex tile, uint32 p1, uint32 p2);

    93

    94

/** Handle Aircraft specific tasks when a an Aircraft enters a hangar

    95

 * @param *v Vehicle that enters the hangar

    96

 */

    97

void HandleAircraftEnterHangar(Vehicle *v);

    98

    99

/** Get the size of the sprite of an aircraft sprite heading west (used for lists)

   100

 * @param engine The engine to get the sprite from

   101

 * @param width The width of the sprite

   102

 * @param height The height of the sprite

   103

 */

   104

void GetAircraftSpriteSize(EngineID engine, uint &width, uint &height);

   105

   106

/**

   107

 * Updates the status of the Aircraft heading or in the station

   108

 * @param st Station been updated

   109

 */

   110

void UpdateAirplanesOnNewStation(const Station *st);

   111

   112

/** Update cached values of an aircraft.

   113

 * Currently caches callback 36 max speed.

   114

 * @param v Vehicle

   115

 */

   116

void UpdateAircraftCache(Vehicle *v);

   117

   118

/**

   119

 * This class 'wraps' Vehicle; you do not actually instantiate this class.

   120

 * You create a Vehicle using AllocateVehicle, so it is added to the pool

   121

 * and you reinitialize that to a Train using:

   122

 *   v = new (v) Aircraft();

   123

 *

   124

 * As side-effect the vehicle type is set correctly.

   125

 */

   126

struct Aircraft : public Vehicle {

   127

	/** Initializes the Vehicle to an aircraft */

   128

	Aircraft() { this->type = VEH_AIRCRAFT; }

   129

   130

	/** We want to 'destruct' the right class. */

   131

	virtual ~Aircraft() {}

   132

   133

	const char *GetTypeString() const { return "aircraft"; }

   134

	void MarkDirty();

   135

	void UpdateDeltaXY(Direction direction);

   136

	ExpensesType GetExpenseType(bool income) const { return income ? EXPENSES_AIRCRAFT_INC : EXPENSES_AIRCRAFT_RUN; }

   137

	WindowClass GetVehicleListWindowClass() const { return WC_AIRCRAFT_LIST; }

   138

	bool IsPrimaryVehicle() const { return IsNormalAircraft(this); }

   139

};

   140

   141

#endif /* AIRCRAFT_H */