1

/* $Id$ */

     2

     3

/** @file aircraft.h */

     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

    13

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

    14

enum AircraftSubType {

    15

	AIR_HELICOPTER = 0, ///< an helicopter

    16

	AIR_AIRCRAFT   = 2, ///< an airplane

    17

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

    18

	AIR_ROTOR      = 6  ///< rotor of an helicopter

    19

};

    20

    21

    22

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

    23

 * not a rotor or a shadow

    24

 * @param v vehicle to check

    25

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

    26

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

    27

static inline bool IsNormalAircraft(const Vehicle *v)

    28

{

    29

	assert(v->type == VEH_AIRCRAFT);

    30

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

    31

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

    32

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

    33

	return v->subtype <= AIR_AIRCRAFT;

    34

}

    35

    36

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

    37

 * @param engine The engine to test

    38

 * @param st The station

    39

 * @return true if the aircraft can use the station

    40

 */

    41

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

    42

{

    43

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

    44

	const AircraftVehicleInfo *avi = AircraftVehInfo(engine);

    45

    46

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

    47

}

    48

    49

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

    50

 * @param engine The engine to test

    51

 * @param tile The tile where the station is

    52

 * @return true if the aircraft can use the station

    53

 */

    54

static inline bool CanAircraftUseStation(EngineID engine, TileIndex tile)

    55

{

    56

	return CanAircraftUseStation(engine, GetStationByTile(tile));

    57

}

    58

    59

/**

    60

 * Calculates cargo capacity based on an aircraft's passenger

    61

 * and mail capacities.

    62

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

    63

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

    64

 * @return New cargo capacity value.

    65

 */

    66

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

    67

    68

/**

    69

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

    70

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

    71

 * @param tile of depot where aircraft is built

    72

 * @param p1 unused

    73

 * @param p2 unused

    74

 */

    75

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

    76

    77

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

    78

 * @param *v Vehicle that enters the hangar

    79

 */

    80

void HandleAircraftEnterHangar(Vehicle *v);

    81

    82

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

    83

 * @param engine The engine to get the sprite from

    84

 * @param width The width of the sprite

    85

 * @param height The height of the sprite

    86

 */

    87

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

    88

    89

/**

    90

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

    91

 * @param st Station been updated

    92

 */

    93

void UpdateAirplanesOnNewStation(const Station *st);

    94

    95

/** Update cached values of an aircraft.

    96

 * Currently caches callback 36 max speed.

    97

 * @param v Vehicle

    98

 */

    99

void UpdateAircraftCache(Vehicle *v);

   100

   101

/**

   102

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

   103

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

   104

 * and you reinitialize that to a Train using:

   105

 *   v = new (v) Aircraft();

   106

 *

   107

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

   108

 */

   109

struct Aircraft : public Vehicle {

   110

	/** Initializes the Vehicle to an aircraft */

   111

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

   112

   113

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

   114

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

   115

   116

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

   117

	void MarkDirty();

   118

	void UpdateDeltaXY(Direction direction);

   119

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

   120

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

   121

	SpriteID GetImage(Direction direction) const;

   122

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

   123

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

   124

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

   125

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

   126

	void Tick();

   127

	void OnNewDay();

   128

	TileIndex GetOrderStationLocation(StationID station);

   129

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

   130

};

   131

   132

#endif /* AIRCRAFT_H */