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 <https://www.gnu.org/licenses/old-licenses/gpl-2.0>.
 */

 
#ifndef AIRCRAFT_H
#define AIRCRAFT_H
 
#include "station_map.h"
#include "vehicle_base.h"

static constexpr int AIRCRAFT_MIN_FLYING_ALTITUDE = 120; 
static constexpr int AIRCRAFT_MAX_FLYING_ALTITUDE = 360; 
static constexpr int PLANE_HOLD_MAX_FLYING_ALTITUDE = 150; 
static constexpr int HELICOPTER_HOLD_MAX_FLYING_ALTITUDE = 184; 
 
struct Aircraft;

enum AircraftSubType : uint8_t {
  AIR_HELICOPTER = 0, 
  AIR_AIRCRAFT   = 2, 
  AIR_SHADOW     = 4, 
  AIR_ROTOR      = 6, 
};

enum class VehicleAirFlag : uint8_t {
  DestinationTooFar = 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. */
  InMaximumHeightCorrection = 1, 
  InMinimumHeightCorrection = 2, 
 
  HelicopterDirectDescent = 3, 
};
using VehicleAirFlags = EnumBitSet<VehicleAirFlag, uint8_t>;
 
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 = 0; 
  uint16_t cached_max_range = 0; 
};

struct Aircraft final : public SpecializedVehicle<Aircraft, VEH_AIRCRAFT> {
  uint16_t crashed_counter = 0; 
  uint8_t pos = 0; 
  uint8_t previous_pos = 0; 
  StationID targetairport = StationID::Invalid(); 
  uint8_t state = 0; 
  Direction last_direction = INVALID_DIR;
  uint8_t number_consecutive_turns = 0; 
  uint8_t turn_counter = 0; 
  VehicleAirFlags flags{}; 
 
  AircraftCache acache{};
 
  Aircraft(VehicleID index) : SpecializedVehicleBase(index) {}
  ~Aircraft() override { 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.Test(VehState::Hidden) && IsHangarTile(this->tile);
  }
 
  bool Tick() override;
  void OnNewCalendarDay() override;
  void OnNewEconomyDay() override;
  uint Crash(bool flooded = false) override;
  TileIndex GetOrderStationLocation(StationID station) override;
  TileIndex GetCargoTile() const override { return this->First()->tile; }
  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 */