airport.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 AIRPORT_H
#define AIRPORT_H
 
#include "direction_type.h"
#include "tile_type.h"
 
static const uint MAX_TERMINALS =   8;                       
static const uint MAX_HELIPADS  =   3;                       
static const uint MAX_ELEMENTS  = 255;                       
 
static const uint NUM_AIRPORTTILES_PER_GRF = 255;            
 
static const uint NUM_AIRPORTTILES       = 256;              
static const uint NEW_AIRPORTTILE_OFFSET = 74;               
static const uint INVALID_AIRPORTTILE    = NUM_AIRPORTTILES; 
 
enum AirportTypes : uint8_t {
  AT_SMALL           =   0, 
  AT_LARGE           =   1, 
  AT_HELIPORT        =   2, 
  AT_METROPOLITAN    =   3, 
  AT_INTERNATIONAL   =   4, 
  AT_COMMUTER        =   5, 
  AT_HELIDEPOT       =   6, 
  AT_INTERCON        =   7, 
  AT_HELISTATION     =   8, 
  AT_OILRIG          =   9, 
  NEW_AIRPORT_OFFSET =  10, 
  NUM_AIRPORTS_PER_GRF = 128, 
  NUM_AIRPORTS       = 128, 
  AT_INVALID         = 254, 
  AT_DUMMY           = 255, 
};
 
enum AirportMovingDataFlag : uint8_t {
  NoSpeedClamp, 
  Takeoff, 
  SlowTurn, 
  Land, 
  ExactPosition, 
  Brake, 
  HeliRaise, 
  HeliLower, 
  Hold, 
};
 
using AirportMovingDataFlags = EnumBitSet<AirportMovingDataFlag, uint16_t>;
 
enum AirportMovementStates : uint8_t {
  TO_ALL         =   0, 
  HANGAR         =   1, 
  TERM1          =   2, 
  TERM2          =   3, 
  TERM3          =   4, 
  TERM4          =   5, 
  TERM5          =   6, 
  TERM6          =   7, 
  HELIPAD1       =   8, 
  HELIPAD2       =   9, 
  TAKEOFF        =  10, 
  STARTTAKEOFF   =  11, 
  ENDTAKEOFF     =  12, 
  HELITAKEOFF    =  13, 
  FLYING         =  14, 
  LANDING        =  15, 
  ENDLANDING     =  16, 
  HELILANDING    =  17, 
  HELIENDLANDING =  18, 
  TERM7          =  19, 
  TERM8          =  20, 
  HELIPAD3       =  21, 
  MAX_HEADINGS   =  21, 
  TERMGROUP      = 255, 
};
 
enum class AirportBlock : uint8_t {
  Term1            =  0, 
  Term2            =  1, 
  Term3            =  2, 
  Term4            =  3, 
  Term5            =  4, 
  Term6            =  5, 
  Helipad1         =  6, 
  Helipad2         =  7, 
  RunwayInOut      =  8,
  RunwayIn         =  8,
  AirportBusy      =  8,
  RunwayOut        =  9,
  TaxiwayBusy      = 10,
  OutWay           = 11,
  InWay            = 12,
  AirportEntrance  = 13,
  TermGroup1       = 14,
  TermGroup2       = 15,
  Hangar2Area      = 16,
  TermGroup2Enter1 = 17,
  TermGroup2Enter2 = 18,
  TermGroup2Exit1  = 19,
  TermGroup2Exit2  = 20,
  PreHelipad       = 21,
 
  /* blocks for new airports */
  Term7            = 22, 
  Term8            = 23, 
  Helipad3         = 24, 
  Hangar1Area      = 26,
  OutWay2          = 27,
  InWay2           = 28,
  RunwayIn2        = 29,
  RunwayOut2       = 10, 
  HelipadGroup     = 13, 
  OutWay3          = 31,
  /* end of new blocks */
 
  Nothing          = 30,
  AirportClosed    = 63, 
};
using AirportBlocks = EnumBitSet<AirportBlock, uint64_t>;
 
struct AirportMovingData {
  int16_t x;             
  int16_t y;             
  AirportMovingDataFlags flags; 
  Direction direction; 
};
 
AirportMovingData RotateAirportMovingData(const AirportMovingData *orig, Direction rotation, uint num_tiles_x, uint num_tiles_y);
 
struct AirportFTAbuildup;
 
struct AirportFTA {
  AirportFTA(const AirportFTAbuildup&);
 
  std::unique_ptr<AirportFTA> next; 
  AirportBlocks blocks; 
  uint8_t position; 
  uint8_t next_position; 
  uint8_t heading; 
};
 
struct AirportFTAClass {
public:
  enum class Flag : uint8_t {
    Airplanes   = 0, 
    Helicopters = 1, 
    ShortStrip  = 2, 
  };
  using Flags = EnumBitSet<Flag, uint8_t>;
 
  AirportFTAClass(
    const AirportMovingData *moving_data,
    const uint8_t *terminals,
    const uint8_t num_helipads,
    const uint8_t *entry_points,
    Flags flags,
    const AirportFTAbuildup *apFA,
    uint8_t delta_z
  );
 
  const AirportMovingData *MovingData(uint8_t position) const
  {
    assert(position < nofelements);
    return &moving_data[position];
  }
 
  const AirportMovingData *moving_data; 
  std::vector<AirportFTA> layout; 
  const uint8_t *terminals;                
  const uint8_t num_helipads;              
  Flags flags;                          
  uint8_t nofelements;                     
  const uint8_t *entry_points;             
  uint8_t delta_z;                         
};
 
 
const AirportFTAClass *GetAirport(const uint8_t airport_type);
uint8_t GetVehiclePosOnBuild(TileIndex hangar_tile);
 
#endif /* AIRPORT_H */