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

 
#ifndef NEWGRF_AIRPORT_H
#define NEWGRF_AIRPORT_H
 
#include "airport.h"
#include "timer/timer_game_calendar.h"
#include "newgrf_badge_type.h"
#include "newgrf_class.h"
#include "newgrf_commons.h"
#include "newgrf_spritegroup.h"
#include "newgrf_town.h"
#include "tilearea_type.h"

typedef uint8_t StationGfx;

struct AirportTileTable {
  TileIndexDiffC ti; 
  StationGfx gfx; 
};

class AirportTileTableIterator : public TileIterator {
private:
  std::span<const AirportTileTable> att; 
  TileIndex base_tile; 
  std::span<const AirportTileTable>::iterator iter;
 
public:
  AirportTileTableIterator(std::span<const AirportTileTable> att, TileIndex base_tile)
    : TileIterator(base_tile + ToTileIndexDiff(att.front().ti))
    , att(att), base_tile(base_tile), iter(att.begin())
  {
  }
 
  inline TileIterator& operator ++() override
  {
    ++this->iter;
    if (this->iter == std::end(att)) {
      this->tile = INVALID_TILE;
    } else {
      this->tile = this->base_tile + ToTileIndexDiff(this->iter->ti);
    }
    return *this;
  }

  StationGfx GetStationGfx() const
  {
    return this->iter->gfx;
  }
 
  std::unique_ptr<TileIterator> Clone() const override
  {
    return std::make_unique<AirportTileTableIterator>(*this);
  }
};

enum AirportClassID : uint8_t {
  APC_BEGIN     = 0,  
  APC_SMALL     = 0,  
  APC_LARGE,          
  APC_HUB,            
  APC_HELIPORT,       
  APC_MAX       = 16, 
};

DECLARE_INCREMENT_DECREMENT_OPERATORS(AirportClassID)
 

enum TTDPAirportType : uint8_t {
  ATP_TTDP_SMALL,    
  ATP_TTDP_LARGE,    
  ATP_TTDP_HELIPORT, 
  ATP_TTDP_OILRIG,   
};

struct HangarTileTable {
  TileIndexDiffC ti; 
  Direction dir;     
  uint8_t hangar_num;   
};
 
struct AirportTileLayout {
  std::vector<AirportTileTable> tiles; 
  Direction rotation; 
};

struct AirportSpec : NewGRFSpecBase<AirportClassID> {
  const struct AirportFTAClass *fsm;     
  std::vector<AirportTileLayout> layouts; 
  std::span<const HangarTileTable> depots; 
  uint8_t size_x;                           
  uint8_t size_y;                           
  uint8_t noise_level;                      
  uint8_t catchment;                        
  TimerGameCalendar::Year min_year;      
  TimerGameCalendar::Year max_year;      
  StringID name;                         
  TTDPAirportType ttd_airport_type;      
  SpriteID preview_sprite;               
  uint16_t maintenance_cost;               
  /* Newgrf data */
  bool enabled;                          
  SubstituteGRFFileProps grf_prop; 
  std::vector<BadgeID> badges;
 
  static const AirportSpec *Get(uint8_t type);
  static AirportSpec *GetWithoutOverride(uint8_t type);
 
  bool IsAvailable() const;
  bool IsWithinMapBounds(uint8_t table, TileIndex index) const;
 
  static void ResetAirports();

  uint8_t GetIndex() const
  {
    assert(this >= std::begin(specs) && this < std::end(specs));
    return static_cast<uint8_t>(std::distance(std::cbegin(specs), this));
  }
 
  static const AirportSpec dummy; 
 
private:
  static AirportSpec specs[NUM_AIRPORTS]; 
 
  friend void AirportOverrideManager::SetEntitySpec(AirportSpec &&as);
};

using AirportClass = NewGRFClass<AirportSpec, AirportClassID, APC_MAX>;
 
void BindAirportSpecs();

struct AirportScopeResolver : public ScopeResolver {
  struct Station *st; 
  const AirportSpec *spec; 
  uint8_t layout;        
  TileIndex tile;     

  AirportScopeResolver(ResolverObject &ro, TileIndex tile, Station *st, const AirportSpec *spec, uint8_t layout)
    : ScopeResolver(ro), st(st), spec(spec), layout(layout), tile(tile)
  {
  }
 
  uint32_t GetRandomBits() const override;
  uint32_t GetVariable(uint8_t variable, [[maybe_unused]] uint32_t parameter, bool &available) const override;
  void StorePSA(uint pos, int32_t value) override;
};
 

struct AirportResolverObject : public ResolverObject {
  AirportScopeResolver airport_scope;
  std::optional<TownScopeResolver> town_scope = std::nullopt; 
 
  AirportResolverObject(TileIndex tile, Station *st, const AirportSpec *spec, uint8_t layout,
      CallbackID callback = CBID_NO_CALLBACK, uint32_t callback_param1 = 0, uint32_t callback_param2 = 0);
 
  TownScopeResolver *GetTown();
 
  ScopeResolver *GetScope(VarSpriteGroupScope scope = VSG_SCOPE_SELF, uint8_t relative = 0) override
  {
    switch (scope) {
      case VSG_SCOPE_SELF: return &this->airport_scope;
      case VSG_SCOPE_PARENT:
      {
        TownScopeResolver *tsr = this->GetTown();
        if (tsr != nullptr) return tsr;
        [[fallthrough]];
      }
      default: return ResolverObject::GetScope(scope, relative);
    }
  }
 
  GrfSpecFeature GetFeature() const override;
  uint32_t GetDebugID() const override;
};
 
StringID GetAirportTextCallback(const AirportSpec *as, uint8_t layout, uint16_t callback);
 
#endif /* NEWGRF_AIRPORT_H */