aircraft.h

Go to the documentation of this file.

/*
 * This file is part of OpenTTD.
 * OpenTTD is free software; you can redistribute it and/or modify it under the terms of the GNU General Public License as published by the Free Software Foundation, version 2.
 * OpenTTD is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
 * See the GNU General Public License for more details. You should have received a copy of the GNU General Public License along with OpenTTD. If not, see <http://www.gnu.org/licenses/>.
 */
 
#ifndef AIRCRAFT_H
#define AIRCRAFT_H
 
#include "station_map.h"
#include "vehicle_base.h"
 
enum AircraftFlyingAltitude {
  AIRCRAFT_MIN_FLYING_ALTITUDE        = 120, 
  AIRCRAFT_MAX_FLYING_ALTITUDE        = 360, 
  PLANE_HOLD_MAX_FLYING_ALTITUDE      = 150, 
  HELICOPTER_HOLD_MAX_FLYING_ALTITUDE = 184  
};
 
struct Aircraft;
 
enum AircraftSubType {
  AIR_HELICOPTER = 0, 
  AIR_AIRCRAFT   = 2, 
  AIR_SHADOW     = 4, 
  AIR_ROTOR      = 6, 
};
 
enum AirVehicleFlags {
  VAF_DEST_TOO_FAR             = 0, 
 
  /* The next two flags are to prevent stair climbing of the aircraft. The idea is that the aircraft
   * will ascend or descend multiple flight levels at a time instead of following the contours of the
   * landscape at a fixed altitude. This only has effect when there are more than 15 height levels. */
  VAF_IN_MAX_HEIGHT_CORRECTION = 1, 
  VAF_IN_MIN_HEIGHT_CORRECTION = 2, 
 
  VAF_HELI_DIRECT_DESCENT      = 3, 
};
 
static const int ROTOR_Z_OFFSET         = 5;    
 
void HandleAircraftEnterHangar(Aircraft *v);
void GetAircraftSpriteSize(EngineID engine, uint &width, uint &height, int &xoffs, int &yoffs, EngineImageType image_type);
void UpdateAirplanesOnNewStation(const Station *st);
void UpdateAircraftCache(Aircraft *v, bool update_range = false);
 
void AircraftLeaveHangar(Aircraft *v, Direction exit_dir);
void AircraftNextAirportPos_and_Order(Aircraft *v);
void SetAircraftPosition(Aircraft *v, int x, int y, int z);
 
void GetAircraftFlightLevelBounds(const Vehicle *v, int *min, int *max);
template <class T>
int GetAircraftFlightLevel(T *v, bool takeoff = false);
 
struct AircraftCache {
  uint32_t cached_max_range_sqr;   
  uint16_t cached_max_range;       
};
 
struct Aircraft final : public SpecializedVehicle<Aircraft, VEH_AIRCRAFT> {
  uint16_t crashed_counter;        
  byte pos;                      
  byte previous_pos;             
  StationID targetairport;       
  byte state;                    
  Direction last_direction;
  byte number_consecutive_turns; 
  byte turn_counter;             
  byte flags;                    
 
  AircraftCache acache;
 
  Aircraft() : SpecializedVehicleBase() {}
  virtual ~Aircraft() { this->PreDestructor(); }
 
  void MarkDirty() override;
  void UpdateDeltaXY() override;
  ExpensesType GetExpenseType(bool income) const override { return income ? EXPENSES_AIRCRAFT_REVENUE : EXPENSES_AIRCRAFT_RUN; }
  bool IsPrimaryVehicle() const override                  { return this->IsNormalAircraft(); }
  void GetImage(Direction direction, EngineImageType image_type, VehicleSpriteSeq *result) const override;
  int GetDisplaySpeed() const override    { return this->cur_speed; }
  int GetDisplayMaxSpeed() const override { return this->vcache.cached_max_speed; }
  int GetSpeedOldUnits() const            { return this->vcache.cached_max_speed * 10 / 128; }
  int GetCurrentMaxSpeed() const override { return this->GetSpeedOldUnits(); }
  Money GetRunningCost() const override;
 
  bool IsInDepot() const override
  {
    assert(this->IsPrimaryVehicle());
    return (this->vehstatus & VS_HIDDEN) != 0 && IsHangarTile(this->tile);
  }
 
  bool Tick() override;
  void OnNewCalendarDay() override;
  void OnNewEconomyDay() override;
  uint Crash(bool flooded = false) override;
  TileIndex GetOrderStationLocation(StationID station) override;
  ClosestDepot FindClosestDepot() override;
 
  inline bool IsNormalAircraft() const
  {
    /* To be fully correct the commented out functionality is the proper one,
     * but since value can only be 0 or 2, it is sufficient to only check <= 2
     * return (this->subtype == AIR_HELICOPTER) || (this->subtype == AIR_AIRCRAFT); */
    return this->subtype <= AIR_AIRCRAFT;
  }
 
  uint16_t GetRange() const
  {
    return this->acache.cached_max_range;
  }
};
 
void GetRotorImage(const Aircraft *v, EngineImageType image_type, VehicleSpriteSeq *result);
 
Station *GetTargetAirportIfValid(const Aircraft *v);
void HandleMissingAircraftOrders(Aircraft *v);
 
#endif /* AIRCRAFT_H */