1

/* $Id$ */

     2

     3

/** @file aircraft.h Base for aircraft. */

     4

     5

#ifndef AIRCRAFT_H

     6

#define AIRCRAFT_H

     7

     8

#include "station_map.h"

     9

#include "station_base.h"

    10

#include "vehicle_base.h"

    11

#include "engine_func.h"

    12

#include "engine_base.h"

    13

    14

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

    15

enum AircraftSubType {

    16

	AIR_HELICOPTER = 0, ///< an helicopter

    17

	AIR_AIRCRAFT   = 2, ///< an airplane

    18

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

    19

	AIR_ROTOR      = 6  ///< rotor of an helicopter

    20

};

    21

    22

    23

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

    24

 * not a rotor or a shadow

    25

 * @param v vehicle to check

    26

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

    27

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

    28

static inline bool IsNormalAircraft(const Vehicle *v)

    29

{

    30

	assert(v->type == VEH_AIRCRAFT);

    31

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

    32

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

    33

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

    34

	return v->subtype <= AIR_AIRCRAFT;

    35

}

    36

    37

/** Checks if an aircraft can use the station in question

    38

 * @param engine The engine to test

    39

 * @param st The station

    40

 * @return true if the aircraft can use the station

    41

 */

    42

static inline bool CanAircraftUseStation(EngineID engine, const Station *st)

    43

{

    44

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

    45

	const AircraftVehicleInfo *avi = AircraftVehInfo(engine);

    46

    47

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

    48

}

    49

    50

/** Checks if an aircraft can use the station at the tile in question

    51

 * @param engine The engine to test

    52

 * @param tile The tile where the station is

    53

 * @return true if the aircraft can use the station

    54

 */

    55

static inline bool CanAircraftUseStation(EngineID engine, TileIndex tile)

    56

{

    57

	return CanAircraftUseStation(engine, GetStationByTile(tile));

    58

}

    59

    60

/**

    61

 * Calculates cargo capacity based on an aircraft's passenger

    62

 * and mail capacities.

    63

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

    64

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

    65

 * @return New cargo capacity value.

    66

 */

    67

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

    68

    69

/**

    70

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

    71

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

    72

 * @param tile of depot where aircraft is built

    73

 * @param p1 unused

    74

 * @param p2 unused

    75

 */

    76

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

    77

    78

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

    79

 * @param *v Vehicle that enters the hangar

    80

 */

    81

void HandleAircraftEnterHangar(Vehicle *v);

    82

    83

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

    84

 * @param engine The engine to get the sprite from

    85

 * @param width The width of the sprite

    86

 * @param height The height of the sprite

    87

 */

    88

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

    89

    90

/**

    91

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

    92

 * @param st Station been updated

    93

 */

    94

void UpdateAirplanesOnNewStation(const Station *st);

    95

    96

/** Update cached values of an aircraft.

    97

 * Currently caches callback 36 max speed.

    98

 * @param v Vehicle

    99

 */

   100

void UpdateAircraftCache(Vehicle *v);

   101

   102

/**

   103

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

   104

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

   105

 * and you reinitialize that to a Train using:

   106

 *   v = new (v) Aircraft();

   107

 *

   108

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

   109

 */

   110

struct Aircraft : public Vehicle {

   111

	/** Initializes the Vehicle to an aircraft */

   112

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

   113

   114

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

   115

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

   116

   117

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

   118

	void MarkDirty();

   119

	void UpdateDeltaXY(Direction direction);

   120

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

   121

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

   122

	SpriteID GetImage(Direction direction) const;

   123

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

   124

	int GetDisplayMaxSpeed() const { return this->max_speed * 10 / 16; }

   125

	Money GetRunningCost() const { return AircraftVehInfo(this->engine_type)->running_cost * _price.aircraft_running; }

   126

	bool IsInDepot() const { return (this->vehstatus & VS_HIDDEN) != 0 && IsHangarTile(this->tile); }

   127

	void Tick();

   128

	void OnNewDay();

   129

	TileIndex GetOrderStationLocation(StationID station);

   130

	bool FindClosestDepot(TileIndex *location, DestinationID *destination, bool *reverse);

   131

};

   132

   133

Station *GetTargetAirportIfValid(const Vehicle *v);

   134

   135

#endif /* AIRCRAFT_H */