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

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

    86

 * @param *v Vehicle that enters the hangar

    87

 */

    88

void HandleAircraftEnterHangar(Vehicle *v);

    89

    90

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

    91

 * @param engine The engine to get the sprite from

    92

 * @param width The width of the sprite

    93

 * @param height The height of the sprite

    94

 */

    95

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

    96

    97

/**

    98

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

    99

 * @param st Station been updated

   100

 */

   101

void UpdateAirplanesOnNewStation(const Station *st);

   102

   103

/** Update cached values of an aircraft.

   104

 * Currently caches callback 36 max speed.

   105

 * @param v Vehicle

   106

 */

   107

void UpdateAircraftCache(Vehicle *v);

   108

   109

/**

   110

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

   111

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

   112

 * and you reinitialize that to a Train using:

   113

 *   v = new (v) Aircraft();

   114

 *

   115

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

   116

 */

   117

struct Aircraft : public Vehicle {

   118

	/** Initializes the Vehicle to an aircraft */

   119

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

   120

   121

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

   122

	virtual ~Aircraft() { this->PreDestructor(); }

   123

   124

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

   125

	void MarkDirty();

   126

	void UpdateDeltaXY(Direction direction);

   127

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

   128

	WindowClass GetVehicleListWindowClass() const { return WC_AIRCRAFT_LIST; }

   129

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

   130

	int GetImage(Direction direction) const;

   131

	int GetDisplaySpeed() const { return this->cur_speed * 10 / 16; }

   132

	void Tick();

   133

};

   134

   135

#endif /* AIRCRAFT_H */