newgrf.cpp

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>.
 */

 
#include "stdafx.h"
#include "core/backup_type.hpp"
#include "core/container_func.hpp"
#include "company_manager_face.h"
#include "debug.h"
#include "fileio_func.h"
#include "engine_func.h"
#include "engine_base.h"
#include "bridge.h"
#include "town.h"
#include "newgrf_engine.h"
#include "newgrf_text.h"
#include "spritecache.h"
#include "currency_func.h"
#include "landscape.h"
#include "newgrf_badge.h"
#include "newgrf_badge_config.h"
#include "newgrf_cargo.h"
#include "newgrf_sound.h"
#include "newgrf_station.h"
#include "industrytype.h"
#include "newgrf_canal.h"
#include "newgrf_townname.h"
#include "newgrf_industries.h"
#include "newgrf_airporttiles.h"
#include "newgrf_airport.h"
#include "newgrf_object.h"
#include "network/core/config.h"
#include "smallmap_gui.h"
#include "genworld.h"
#include "error_func.h"
#include "vehicle_base.h"
#include "road.h"
#include "newgrf_roadstop.h"
#include "newgrf/newgrf_bytereader.h"
#include "newgrf/newgrf_internal_vehicle.h"
#include "newgrf/newgrf_internal.h"
#include "newgrf/newgrf_stringmapping.h"
 
#include "table/strings.h"
#include "table/pricebase.h"
 
#include "safeguards.h"
 
/* TTDPatch extended GRF format codec
 * (c) Petr Baudis 2004 (GPL'd)
 * Changes by Florian octo Forster are (c) by the OpenTTD development team.
 *
 * Contains portions of documentation by TTDPatch team.
 * Thanks especially to Josef Drexler for the documentation as well as a lot
 * of help at #tycoon. Also thanks to Michael Blunck for his GRF files which
 * served as subject to the initial testing of this codec. */

static std::vector<GRFFile> _grf_files;
 
std::span<const GRFFile> GetAllGRFFiles()
{
  return _grf_files;
}

GrfMiscBits _misc_grf_features{};

GRFLoadedFeatures _loaded_newgrf_features;
 
GrfProcessingState _cur_gps;
 
TypedIndexContainer<std::vector<GRFTempEngineData>, EngineID> _gted;  

void GrfMsgI(int severity, const std::string &msg)
{
  if (_cur_gps.grfconfig == nullptr) {
    Debug(grf, severity, "{}", msg);
  } else {
    Debug(grf, severity, "[{}:{}] {}", _cur_gps.grfconfig->filename, _cur_gps.nfo_line, msg);
  }
}

GRFFile *GetFileByGRFID(GrfID grfid)
{
  auto it = std::ranges::find(_grf_files, grfid, &GRFFile::grfid);
  if (it != std::end(_grf_files)) return &*it;
  return nullptr;
}

static GRFFile *GetFileByFilename(const std::string &filename)
{
  auto it = std::ranges::find(_grf_files, filename, &GRFFile::filename);
  if (it != std::end(_grf_files)) return &*it;
  return nullptr;
}

static void ClearTemporaryNewGRFData(GRFFile *gf)
{
  gf->labels.clear();
}

GRFError *DisableGrf(StringID message, GRFConfig *config)
{
  GRFFile *file;
  if (config != nullptr) {
    file = GetFileByGRFID(config->ident.grfid);
  } else {
    config = _cur_gps.grfconfig;
    file = _cur_gps.grffile;
  }
 
  config->status = GRFStatus::Disabled;
  if (file != nullptr) ClearTemporaryNewGRFData(file);
  if (config == _cur_gps.grfconfig) _cur_gps.skip_sprites = -1;
 
  if (message == STR_NULL) return nullptr;
 
  auto it = std::ranges::find(config->errors, _cur_gps.nfo_line, &GRFError::nfo_line);
  if (it == std::end(config->errors)) {
    it = config->errors.emplace(it, STR_NEWGRF_ERROR_MSG_FATAL, _cur_gps.nfo_line, message);
  }
  if (config == _cur_gps.grfconfig) it->param_value[0] = _cur_gps.nfo_line;
  return &*it;
}

void DisableStaticNewGRFInfluencingNonStaticNewGRFs(GRFConfig &c)
{
  GRFError *error = DisableGrf(STR_NEWGRF_ERROR_STATIC_GRF_CAUSES_DESYNC, &c);
  error->data = _cur_gps.grfconfig->GetName();
}
 
static std::map<GrfID, GrfID> _grf_id_overrides;

void SetNewGRFOverride(GrfID source_grfid, GrfID target_grfid)
{
  if (target_grfid == 0) {
    _grf_id_overrides.erase(source_grfid);
    GrfMsg(5, "SetNewGRFOverride: Removed override of {:X}", std::byteswap(source_grfid));
  } else {
    _grf_id_overrides[source_grfid] = target_grfid;
    GrfMsg(5, "SetNewGRFOverride: Added override of {:X} to {:X}", std::byteswap(source_grfid), std::byteswap(target_grfid));
  }
}

GRFFile *GetCurrentGRFOverride()
{
  auto found = _grf_id_overrides.find(_cur_gps.grffile->grfid);
  if (found != std::end(_grf_id_overrides)) {
    GRFFile *grffile = GetFileByGRFID(found->second);
    if (grffile != nullptr) return grffile;
  }
  return nullptr;
}

Engine *GetNewEngine(const GRFFile *file, VehicleType type, uint16_t internal_id, bool static_access)
{
  /* Hack for add-on GRFs that need to modify another GRF's engines. This lets
   * them use the same engine slots. */
  GrfID scope_grfid = INVALID_GRFID; // If not using dynamic_engines, all newgrfs share their ID range
  if (_settings_game.vehicle.dynamic_engines) {
    /* If dynamic_engies is enabled, there can be multiple independent ID ranges. */
    scope_grfid = file->grfid;
    if (auto it = _grf_id_overrides.find(file->grfid); it != std::end(_grf_id_overrides)) {
      scope_grfid = it->second;
      const GRFFile *grf_match = GetFileByGRFID(scope_grfid);
      if (grf_match == nullptr) {
        GrfMsg(5, "Tried mapping from GRFID {:x} to {:x} but target is not loaded", std::byteswap(file->grfid), std::byteswap(scope_grfid));
      } else {
        GrfMsg(5, "Mapping from GRFID {:x} to {:x}", std::byteswap(file->grfid), std::byteswap(scope_grfid));
      }
    }
 
    /* Check if the engine is registered in the override manager */
    EngineID engine = _engine_mngr.GetID(type, internal_id, scope_grfid);
    if (engine != EngineID::Invalid()) {
      Engine *e = Engine::Get(engine);
      if (!e->grf_prop.HasGrfFile()) {
        e->grf_prop.SetGRFFile(file);
      }
      return e;
    }
  }
 
  /* Check if there is an unreserved slot */
  EngineID engine = _engine_mngr.UseUnreservedID(type, internal_id, scope_grfid, static_access);
  if (engine != EngineID::Invalid()) {
    Engine *e = Engine::Get(engine);
 
    if (!e->grf_prop.HasGrfFile()) {
      e->grf_prop.SetGRFFile(file);
      GrfMsg(5, "Replaced engine at index {} for GRFID {:x}, type {}, index {}", e->index, std::byteswap(file->grfid), type, internal_id);
    }
 
    return e;
  }
 
  if (static_access) return nullptr;
 
  if (!Engine::CanAllocateItem()) {
    GrfMsg(0, "Can't allocate any more engines");
    return nullptr;
  }
 
  size_t engine_pool_size = Engine::GetPoolSize();
 
  /* ... it's not, so create a new one based off an existing engine */
  Engine *e = Engine::Create(type, internal_id);
  e->grf_prop.SetGRFFile(file);
 
  /* Reserve the engine slot */
  _engine_mngr.SetID(type, internal_id, scope_grfid, std::min<uint8_t>(internal_id, GetOriginalEngineCount(type)), e->index);
 
  if (engine_pool_size != Engine::GetPoolSize()) {
    /* Resize temporary engine data ... */
    _gted.resize(Engine::GetPoolSize());
  }
  if (type == VehicleType::Train) {
    _gted[e->index].railtypelabels.clear();
    for (RailType rt : e->VehInfo<RailVehicleInfo>().railtypes) _gted[e->index].railtypelabels.push_back(GetRailTypeInfo(rt)->label);
  }
 
  GrfMsg(5, "Created new engine at index {} for GRFID {:x}, type {}, index {}", e->index, std::byteswap(file->grfid), type, internal_id);
 
  return e;
}

EngineID GetNewEngineID(const GRFFile *file, VehicleType type, uint16_t internal_id)
{
  GrfID scope_grfid = INVALID_GRFID; // If not using dynamic_engines, all newgrfs share their ID range
  if (_settings_game.vehicle.dynamic_engines) {
    scope_grfid = file->grfid;
    if (auto it = _grf_id_overrides.find(file->grfid); it != std::end(_grf_id_overrides)) {
      scope_grfid = it->second;
    }
  }
 
  return _engine_mngr.GetID(type, internal_id, scope_grfid);
}
 
 
 

CargoTypes TranslateRefitMask(uint32_t refit_mask)
{
  CargoTypes result{};
  for (uint8_t bit : SetBitIterator(refit_mask)) {
    CargoType cargo = GetCargoTranslation(bit, _cur_gps.grffile, true);
    if (IsValidCargoType(cargo)) result.Set(cargo);
  }
  return result;
}

void ConvertTTDBasePrice(uint32_t base_pointer, std::string_view error_location, Price *index)
{
  /* Special value for 'none' */
  if (base_pointer == 0) {
    *index = Price::Invalid;
    return;
  }
 
  static const uint32_t start = 0x4B34; 
  static const uint32_t size  = 6;      
 
  if (base_pointer < start || (base_pointer - start) % size != 0 || (base_pointer - start) / size >= to_underlying(Price::End)) {
    GrfMsg(1, "{}: Unsupported running cost base 0x{:04X}, ignoring", error_location, base_pointer);
    return;
  }
 
  *index = (Price)((base_pointer - start) / size);
}

/* static */ const LanguageMap *LanguageMap::GetLanguageMap(GrfID grfid, GRFLanguage language_id)
{
  const GRFFile *grffile = GetFileByGRFID(grfid);
  if (grffile == nullptr) return nullptr;
 
  auto it = grffile->language_map.find(language_id);
  if (it == std::end(grffile->language_map)) return nullptr;
 
  return &it->second;
}

void GRFUnsafe(ByteReader &)
{
  _cur_gps.grfconfig->flags.Set(GRFConfigFlag::Unsafe);
 
  /* Skip remainder of GRF */
  _cur_gps.skip_sprites = -1;
}

static void ResetNewGRF()
{
  _cur_gps.grfconfig = nullptr;
  _cur_gps.grffile = nullptr;
  _grf_files.clear();
 
  /* We store pointers to GRFFiles in many places, so need to ensure that the pointers do not become invalid
   * due to vector reallocation. Should not happen due to loading taking place in multiple stages, but
   * reserving when the size is known is good practice anyway. */
  _grf_files.reserve(_grfconfig.size());
}

static void ResetNewGRFErrors()
{
  for (const auto &c : _grfconfig) {
    c->errors.clear();
  }
}
 
extern void ResetCallbacks(bool final);
extern void ResetGRM();

void ResetNewGRFData()
{
  CleanUpStrings();
  CleanUpGRFTownNames();
 
  ResetBadges();
 
  /* Copy/reset original engine info data */
  SetupEngines();
 
  /* Copy/reset original bridge info data */
  ResetBridges();
 
  /* Reset rail type information */
  ResetRailTypes();
 
  /* Copy/reset original road type info data */
  ResetRoadTypes();
 
  /* Allocate temporary refit/cargo class data */
  _gted.resize(Engine::GetPoolSize());
 
  /* Fill rail type label temporary data for default trains */
  for (const Engine *e : Engine::IterateType(VehicleType::Train)) {
    _gted[e->index].railtypelabels.clear();
    for (RailType rt : e->VehInfo<RailVehicleInfo>().railtypes) _gted[e->index].railtypelabels.push_back(GetRailTypeInfo(rt)->label);
  }
 
  /* Reset GRM reservations */
  ResetGRM();
 
  /* Reset generic feature callback lists */
  ResetGenericCallbacks();
 
  /* Reset price base data */
  ResetPriceBaseMultipliers();
 
  /* Reset the currencies array */
  ResetCurrencies();
 
  /* Reset the house array */
  ResetHouses();
 
  /* Reset the industries structures*/
  ResetIndustries();
 
  /* Reset the objects. */
  ObjectClass::Reset();
  ResetObjects();
 
  /* Reset station classes */
  StationClass::Reset();
 
  /* Reset airport-related structures */
  AirportClass::Reset();
  AirportSpec::ResetAirports();
  AirportTileSpec::ResetAirportTiles();
 
  /* Reset road stop classes */
  RoadStopClass::Reset();
 
  /* Reset canal sprite groups and flags */
  _water_feature.fill({});
 
  ResetFaces();
 
  /* Reset the snowline table. */
  ClearSnowLine();
 
  /* Reset NewGRF files */
  ResetNewGRF();
 
  /* Reset NewGRF errors. */
  ResetNewGRFErrors();
 
  /* Set up the default cargo types */
  SetupCargoForClimate(_settings_game.game_creation.landscape);
 
  /* Reset misc GRF features and train list display variables */
  _misc_grf_features = {};
 
  _loaded_newgrf_features.has_2CC = false;
  _loaded_newgrf_features.used_liveries = LiveryScheme::Default;
  _loaded_newgrf_features.shore = ShoreReplacement::None;
  _loaded_newgrf_features.tram = TramDepotReplacement::None;
 
  /* Clear all GRF overrides */
  _grf_id_overrides.clear();
 
  InitializeSoundPool();
  _spritegroup_pool.CleanPool();
  ResetCallbacks(false);
}

void ResetPersistentNewGRFData()
{
  /* Reset override managers */
  _engine_mngr.ResetToDefaultMapping();
  _house_mngr.ResetMapping();
  _industry_mngr.ResetMapping();
  _industile_mngr.ResetMapping();
  _airport_mngr.ResetMapping();
  _airporttile_mngr.ResetMapping();
}

std::span<const CargoLabel> GetCargoTranslationTable(const GRFFile &grffile)
{
  /* Always use the translation table if it's installed. */
  if (!grffile.cargo_list.empty()) return grffile.cargo_list;
 
  /* Pre-v7 use climate-dependent "slot" table. */
  if (grffile.grf_version < 7) return GetClimateDependentCargoTranslationTable();
 
  /* Otherwise use climate-independent "bitnum" table. */
  return GetClimateIndependentCargoTranslationTable();
}

static void BuildCargoTranslationMap()
{
  _cur_gps.grffile->cargo_map.fill(UINT8_MAX);
 
  auto cargo_list = GetCargoTranslationTable(*_cur_gps.grffile);
 
  for (const CargoSpec *cs : CargoSpec::Iterate()) {
    /* Check the translation table for this cargo's label */
    int idx = find_index(cargo_list, cs->label);
    if (idx >= 0) _cur_gps.grffile->cargo_map[cs->Index()] = idx;
  }
}

static void InitNewGRFFile(const GRFConfig &config)
{
  GRFFile *newfile = GetFileByFilename(config.filename);
  if (newfile != nullptr) {
    /* We already loaded it once. */
    _cur_gps.grffile = newfile;
    return;
  }
 
  assert(_grf_files.size() < _grf_files.capacity()); // We must not invalidate pointers.
  _cur_gps.grffile = &_grf_files.emplace_back(config);
}

GRFFile::GRFFile(const GRFConfig &config)
{
  this->filename = config.filename;
  this->grfid = config.ident.grfid;
 
  /* Initialise local settings to defaults */
  this->traininfo_vehicle_pitch = 0;
  this->traininfo_vehicle_width = TRAININFO_DEFAULT_VEHICLE_WIDTH;
 
  /* Mark price_base_multipliers as 'not set' */
  this->price_base_multipliers.fill(INVALID_PRICE_MODIFIER);
 
  /* Initialise rail type map with default rail types */
  this->railtype_map.fill(INVALID_RAILTYPE);
  this->railtype_map[0] = RAILTYPE_RAIL;
  this->railtype_map[1] = RAILTYPE_ELECTRIC;
  this->railtype_map[2] = RAILTYPE_MONO;
  this->railtype_map[3] = RAILTYPE_MAGLEV;
 
  /* Initialise road type map with default road types */
  this->roadtype_map.fill(INVALID_ROADTYPE);
  this->roadtype_map[0] = ROADTYPE_ROAD;
 
  /* Initialise tram type map with default tram types */
  this->tramtype_map.fill(INVALID_ROADTYPE);
  this->tramtype_map[0] = ROADTYPE_TRAM;
 
  /* Copy the initial parameter list */
  this->param = config.param;
}
 
/* Some compilers get confused about vectors of unique_ptrs. */
GRFFile::GRFFile() = default;
GRFFile::GRFFile(GRFFile &&other) = default;
GRFFile::~GRFFile() = default;

static CargoLabel GetActiveCargoLabel(const std::initializer_list<CargoLabel> &labels)
{
  for (const CargoLabel &label : labels) {
    CargoType cargo_type = GetCargoTypeByLabel(label);
    if (cargo_type != INVALID_CARGO) return label;
  }
  return CT_INVALID;
}

static CargoLabel GetActiveCargoLabel(const std::variant<CargoLabel, MixedCargoType> &label)
{
  struct visitor {
    CargoLabel operator()(const CargoLabel &label) { return label; }
    CargoLabel operator()(const MixedCargoType &mixed)
    {
      switch (mixed) {
        case MCT_LIVESTOCK_FRUIT: return GetActiveCargoLabel({CT_LIVESTOCK, CT_FRUIT});
        case MCT_GRAIN_WHEAT_MAIZE: return GetActiveCargoLabel({CT_GRAIN, CT_WHEAT, CT_MAIZE});
        case MCT_VALUABLES_GOLD_DIAMONDS: return GetActiveCargoLabel({CT_VALUABLES, CT_GOLD, CT_DIAMONDS});
        default: NOT_REACHED();
      }
    }
  };
 
  return std::visit(visitor{}, label);
}

static void CalculateRefitMasks()
{
  CargoTypes original_known_cargoes{};
  for (CargoType cargo_type : EnumRange(NUM_CARGO)) {
    if (IsDefaultCargo(cargo_type)) original_known_cargoes.Set(cargo_type);
  }
 
  for (Engine *e : Engine::Iterate()) {
    EngineID engine = e->index;
    EngineInfo *ei = &e->info;
    bool only_defaultcargo; 
 
    /* Apply default cargo translation map if cargo type hasn't been set, either explicitly or by aircraft cargo handling. */
    if (!IsValidCargoType(e->info.cargo_type)) {
      e->info.cargo_type = GetCargoTypeByLabel(GetActiveCargoLabel(e->info.cargo_label));
    }
 
    /* If the NewGRF did not set any cargo properties, we apply default values. */
    if (_gted[engine].defaultcargo_grf == nullptr) {
      /* If the vehicle has any capacity, apply the default refit masks */
      if (e->type != VehicleType::Train || e->VehInfo<RailVehicleInfo>().capacity != 0) {
        static constexpr LandscapeType T = LandscapeType::Temperate;
        static constexpr LandscapeType A = LandscapeType::Arctic;
        static constexpr LandscapeType S = LandscapeType::Tropic;
        static constexpr LandscapeType Y = LandscapeType::Toyland;
        static const struct DefaultRefitMasks {
          LandscapeTypes climate;
          CargoLabel cargo_label;
          CargoClasses cargo_allowed;
          CargoClasses cargo_disallowed;
        } _default_refit_masks[] = {
          {{T, A, S, Y}, CT_PASSENGERS, {CargoClass::Passengers},                      {}},
          {{T, A, S   }, CT_MAIL,       {CargoClass::Mail},                            {}},
          {{T, A, S   }, CT_VALUABLES,  {CargoClass::Armoured},                        {CargoClass::Liquid}},
          {{         Y}, CT_MAIL,       {CargoClass::Mail, CargoClass::Armoured},      {CargoClass::Liquid}},
          {{T, A      }, CT_COAL,       {CargoClass::Bulk},                            {}},
          {{      S   }, CT_COPPER_ORE, {CargoClass::Bulk},                            {}},
          {{         Y}, CT_SUGAR,      {CargoClass::Bulk},                            {}},
          {{T, A, S   }, CT_OIL,        {CargoClass::Liquid},                          {}},
          {{         Y}, CT_COLA,       {CargoClass::Liquid},                          {}},
          {{T         }, CT_GOODS,      {CargoClass::PieceGoods, CargoClass::Express}, {CargoClass::Liquid, CargoClass::Passengers}},
          {{   A, S   }, CT_GOODS,      {CargoClass::PieceGoods, CargoClass::Express}, {CargoClass::Liquid, CargoClass::Passengers, CargoClass::Refrigerated}},
          {{   A, S   }, CT_FOOD,       {CargoClass::Refrigerated},                    {}},
          {{         Y}, CT_CANDY,      {CargoClass::PieceGoods, CargoClass::Express}, {CargoClass::Liquid, CargoClass::Passengers}},
        };
 
        if (e->type == VehicleType::Aircraft) {
          /* Aircraft default to "light" cargoes */
          _gted[engine].cargo_allowed = {CargoClass::Passengers, CargoClass::Mail, CargoClass::Armoured, CargoClass::Express};
          _gted[engine].cargo_disallowed = {CargoClass::Liquid};
        } else if (e->type == VehicleType::Ship) {
          CargoLabel label = GetActiveCargoLabel(ei->cargo_label);
          switch (label.base()) {
            case CT_PASSENGERS.base():
              /* Ferries */
              _gted[engine].cargo_allowed = {CargoClass::Passengers};
              _gted[engine].cargo_disallowed = {};
              break;
            case CT_OIL.base():
              /* Tankers */
              _gted[engine].cargo_allowed = {CargoClass::Liquid};
              _gted[engine].cargo_disallowed = {};
              break;
            default:
              /* Cargo ships */
              if (_settings_game.game_creation.landscape == LandscapeType::Toyland) {
                /* No tanker in toyland :( */
                _gted[engine].cargo_allowed = {CargoClass::Mail, CargoClass::Armoured, CargoClass::Express, CargoClass::Bulk, CargoClass::PieceGoods, CargoClass::Liquid};
                _gted[engine].cargo_disallowed = {CargoClass::Passengers};
              } else {
                _gted[engine].cargo_allowed = {CargoClass::Mail, CargoClass::Armoured, CargoClass::Express, CargoClass::Bulk, CargoClass::PieceGoods};
                _gted[engine].cargo_disallowed = {CargoClass::Liquid, CargoClass::Passengers};
              }
              break;
          }
          e->VehInfo<ShipVehicleInfo>().old_refittable = true;
        } else if (e->type == VehicleType::Train && e->VehInfo<RailVehicleInfo>().railveh_type != RailVehicleType::Wagon) {
          /* Train engines default to all cargoes, so you can build single-cargo consists with fast engines.
           * Trains loading multiple cargoes may start stations accepting unwanted cargoes. */
          _gted[engine].cargo_allowed = {CargoClass::Passengers, CargoClass::Mail, CargoClass::Armoured, CargoClass::Express, CargoClass::Bulk, CargoClass::PieceGoods, CargoClass::Liquid};
          _gted[engine].cargo_disallowed = {};
        } else {
          /* Train wagons and road vehicles are classified by their default cargo type */
          CargoLabel label = GetActiveCargoLabel(ei->cargo_label);
          for (const auto &drm : _default_refit_masks) {
            if (!drm.climate.Test(_settings_game.game_creation.landscape)) continue;
            if (drm.cargo_label != label) continue;
 
            _gted[engine].cargo_allowed = drm.cargo_allowed;
            _gted[engine].cargo_disallowed = drm.cargo_disallowed;
            break;
          }
 
          /* All original cargoes have specialised vehicles, so exclude them */
          _gted[engine].ctt_exclude_mask = original_known_cargoes;
        }
      }
      _gted[engine].UpdateRefittability(_gted[engine].cargo_allowed.Any());
 
      if (IsValidCargoType(ei->cargo_type)) _gted[engine].ctt_exclude_mask.Reset(ei->cargo_type);
    }
 
    /* Compute refittability */
    {
      CargoTypes mask{};
      CargoTypes not_mask{};
      CargoTypes xor_mask = ei->refit_mask;
 
      /* If the original masks set by the grf are zero, the vehicle shall only carry the default cargo.
       * Note: After applying the translations, the vehicle may end up carrying no defined cargo. It becomes unavailable in that case. */
      only_defaultcargo = _gted[engine].refittability != GRFTempEngineData::Refittability::NonEmpty;
 
      if (_gted[engine].cargo_allowed.Any()) {
        /* Build up the list of cargo types from the set cargo classes. */
        for (const CargoSpec *cs : CargoSpec::Iterate()) {
          if (cs->classes.Any(_gted[engine].cargo_allowed) && cs->classes.All(_gted[engine].cargo_allowed_required)) mask.Set(cs->Index());
          if (cs->classes.Any(_gted[engine].cargo_disallowed)) not_mask.Set(cs->Index());
        }
      }
 
      CargoTypes invalid_mask = CargoTypes{_cargo_mask}.Flip();
      ei->refit_mask = mask.Reset(not_mask).Flip(xor_mask).Reset(invalid_mask);
 
      /* Apply explicit refit includes/excludes. */
      ei->refit_mask.Set(_gted[engine].ctt_include_mask);
      ei->refit_mask.Reset(_gted[engine].ctt_exclude_mask);
 
      /* Custom refit mask callback. */
      const GRFFile *file = _gted[e->index].defaultcargo_grf;
      if (file == nullptr) file = e->GetGRF();
      if (file != nullptr && e->info.callback_mask.Test(VehicleCallbackMask::CustomRefit)) {
        for (const CargoSpec *cs : CargoSpec::Iterate()) {
          uint8_t local_slot = file->cargo_map[cs->Index()];
          uint16_t callback = GetVehicleCallback(CBID_VEHICLE_CUSTOM_REFIT, cs->classes.base(), local_slot, engine, nullptr);
          switch (callback) {
            case CALLBACK_FAILED:
            case 0:
              break; // Do nothing.
            case 1: ei->refit_mask.Set(cs->Index()); break;
            case 2: ei->refit_mask.Reset(cs->Index()); break;
 
            default: ErrorUnknownCallbackResult(file->grfid, CBID_VEHICLE_CUSTOM_REFIT, callback);
          }
        }
      }
    }
 
    /* Clear invalid cargoslots (from default vehicles or pre-NewCargo GRFs) */
    if (IsValidCargoType(ei->cargo_type) && !_cargo_mask.Test(ei->cargo_type)) ei->cargo_type = INVALID_CARGO;
 
    /* Ensure that the vehicle is either not refittable, or that the default cargo is one of the refittable cargoes.
     * Note: Vehicles refittable to no cargo are handle differently to vehicle refittable to a single cargo. The latter might have subtypes. */
    if (!only_defaultcargo && (e->type != VehicleType::Ship || e->VehInfo<ShipVehicleInfo>().old_refittable) && IsValidCargoType(ei->cargo_type) && !ei->refit_mask.Test(ei->cargo_type)) {
      ei->cargo_type = INVALID_CARGO;
    }
 
    /* Check if this engine's cargo type is valid. If not, set to the first refittable
     * cargo type. Finally disable the vehicle, if there is still no cargo. */
    if (!IsValidCargoType(ei->cargo_type) && ei->refit_mask.Any()) {
      /* Figure out which CTT to use for the default cargo, if it is 'first refittable'. */
      const GRFFile *file = _gted[engine].defaultcargo_grf;
      if (file == nullptr) file = e->GetGRF();
      if (file != nullptr && file->grf_version >= 8 && !file->cargo_list.empty()) {
        /* Use first refittable cargo from cargo translation table */
        uint8_t best_local_slot = UINT8_MAX;
        for (CargoType cargo_type : ei->refit_mask) {
          uint8_t local_slot = file->cargo_map[cargo_type];
          if (local_slot < best_local_slot) {
            best_local_slot = local_slot;
            ei->cargo_type = cargo_type;
          }
        }
      }
 
      if (!IsValidCargoType(ei->cargo_type)) {
        /* Use first refittable cargo slot */
        ei->cargo_type = *ei->refit_mask.begin();
      }
    }
    if (!IsValidCargoType(ei->cargo_type) && e->type == VehicleType::Train && e->VehInfo<RailVehicleInfo>().railveh_type != RailVehicleType::Wagon && e->VehInfo<RailVehicleInfo>().capacity == 0) {
      /* For train engines which do not carry cargo it does not matter if their cargo type is invalid.
       * Fallback to the first available instead, if the cargo type has not been changed (as indicated by
       * cargo_label not being CT_INVALID). */
      if (GetActiveCargoLabel(ei->cargo_label) != CT_INVALID) {
        ei->cargo_type = *_standard_cargo_mask.begin();
      }
    }
    if (!IsValidCargoType(ei->cargo_type)) ei->climates = {};
 
    /* Clear refit_mask for not refittable ships */
    if (e->type == VehicleType::Ship && !e->VehInfo<ShipVehicleInfo>().old_refittable) {
      ei->refit_mask.Reset();
    }
  }
}

static void FinaliseCanals()
{
  for (CanalFeature i : EnumRange(CanalFeature::End)) {
    if (_water_feature[i].grffile != nullptr) {
      _water_feature[i].callback_mask = _water_feature[i].grffile->canal_local_properties[i].callback_mask;
      _water_feature[i].flags = _water_feature[i].grffile->canal_local_properties[i].flags;
    }
  }
}

static void FinaliseEngineArray()
{
  for (Engine *e : Engine::Iterate()) {
    if (e->GetGRF() == nullptr) {
      auto found = std::ranges::find(_engine_mngr.mappings[e->type], e->index, &EngineIDMapping::engine);
      if (found == std::end(_engine_mngr.mappings[e->type]) || found->grfid != INVALID_GRFID || found->internal_id != found->substitute_id) {
        e->info.string_id = STR_NEWGRF_INVALID_ENGINE;
      }
    }
 
    /* Do final mapping on variant engine ID. */
    if (e->info.variant_id != EngineID::Invalid()) {
      e->info.variant_id = GetNewEngineID(e->grf_prop.grffile, e->type, e->info.variant_id.base());
    }
 
    if (!e->info.climates.Test(_settings_game.game_creation.landscape)) continue;
 
    switch (e->type) {
      case VehicleType::Train:
        for (RailType rt : e->VehInfo<RailVehicleInfo>().railtypes) {
          AppendCopyableBadgeList(e->badges, GetRailTypeInfo(rt)->badges, GrfSpecFeature::Trains);
        }
        break;
      case VehicleType::Road: AppendCopyableBadgeList(e->badges, GetRoadTypeInfo(e->VehInfo<RoadVehicleInfo>().roadtype)->badges, GrfSpecFeature::RoadVehicles); break;
      default: break;
    }
 
    /* Skip wagons, there livery is defined via the engine */
    if (e->type != VehicleType::Train || e->VehInfo<RailVehicleInfo>().railveh_type != RailVehicleType::Wagon) {
      LiveryScheme ls = GetEngineLiveryScheme(e->index, EngineID::Invalid(), nullptr);
      _loaded_newgrf_features.used_liveries.Set(ls);
      /* Note: For ships and roadvehicles we assume that they cannot be refitted between passenger and freight */
 
      if (e->type == VehicleType::Train) {
        _loaded_newgrf_features.used_liveries.Set(LiveryScheme::FreightWagon);
        switch (ls) {
          case LiveryScheme::Steam:
          case LiveryScheme::Diesel:
          case LiveryScheme::Electric:
          case LiveryScheme::Monorail:
          case LiveryScheme::Maglev:
            _loaded_newgrf_features.used_liveries.Set(LiveryScheme::PassengerWagonSteam + ls - LiveryScheme::Steam);
            break;
 
          case LiveryScheme::DMU:
          case LiveryScheme::EMU:
            _loaded_newgrf_features.used_liveries.Set(LiveryScheme::PassengerWagonDiesel + ls - LiveryScheme::DMU);
            break;
 
          default: NOT_REACHED();
        }
      }
    }
  }
 
  /* Check engine variants don't point back on themselves (either directly or via a loop) then set appropriate flags
   * on variant engine. This is performed separately as all variant engines need to have been resolved.
   * Use Floyd's cycle-detection algorithm to handle the case where a cycle is present but does
   * not include the starting engine ID. */
  for (Engine *e : Engine::Iterate()) {
    EngineID parent = e->info.variant_id;
    EngineID parent_slow = parent;
    bool update_slow = false;
    while (parent != EngineID::Invalid()) {
      parent = Engine::Get(parent)->info.variant_id;
      if (update_slow) parent_slow = Engine::Get(parent_slow)->info.variant_id;
      update_slow = !update_slow;
      if (parent != e->index && parent != parent_slow) continue;
 
      /* Engine looped back on itself, so clear the variant. */
      e->info.variant_id = EngineID::Invalid();
 
      GrfMsg(1, "FinaliseEngineArray: Variant of engine {:x} in '{}' loops back on itself", e->grf_prop.local_id, e->GetGRF()->filename);
      break;
    }
 
    if (e->info.variant_id != EngineID::Invalid()) {
      Engine::Get(e->info.variant_id)->display_flags.Set({EngineDisplayFlag::HasVariants, EngineDisplayFlag::IsFolded});
    }
  }
}

void FinaliseCargoArray()
{
  for (CargoSpec &cs : CargoSpec::array) {
    if (cs.town_production_effect == TownProductionEffect::Invalid) {
      /* Set default town production effect by cargo label. */
      switch (cs.label.base()) {
        case CT_PASSENGERS.base(): cs.town_production_effect = TownProductionEffect::Passengers; break;
        case CT_MAIL.base():       cs.town_production_effect = TownProductionEffect::Mail; break;
        default:                   cs.town_production_effect = TownProductionEffect::None; break;
      }
    }
    if (!cs.IsValid()) {
      cs.name = cs.name_single = cs.units_volume = STR_NEWGRF_INVALID_CARGO;
      cs.quantifier = STR_NEWGRF_INVALID_CARGO_QUANTITY;
      cs.abbrev = STR_NEWGRF_INVALID_CARGO_ABBREV;
    }
  }
}

static bool IsHouseSpecValid(HouseSpec &hs, const HouseSpec *next1, const HouseSpec *next2, const HouseSpec *next3, const std::string &filename)
{
  if ((hs.building_flags.Any(BUILDING_HAS_2_TILES) &&
        (next1 == nullptr || !next1->enabled || next1->building_flags.Any(BUILDING_HAS_1_TILE))) ||
      (hs.building_flags.Any(BUILDING_HAS_4_TILES) &&
        (next2 == nullptr || !next2->enabled || next2->building_flags.Any(BUILDING_HAS_1_TILE) ||
        next3 == nullptr || !next3->enabled || next3->building_flags.Any(BUILDING_HAS_1_TILE)))) {
    hs.enabled = false;
    if (!filename.empty()) Debug(grf, 1, "FinaliseHouseArray: {} defines house {} as multitile, but no suitable tiles follow. Disabling house.", filename, hs.grf_prop.local_id);
    return false;
  }
 
  /* Some places sum population by only counting north tiles. Other places use all tiles causing desyncs.
   * As the newgrf specs define population to be zero for non-north tiles, we just disable the offending house.
   * If you want to allow non-zero populations somewhen, make sure to sum the population of all tiles in all places. */
  if ((hs.building_flags.Any(BUILDING_HAS_2_TILES) && next1->population != 0) ||
      (hs.building_flags.Any(BUILDING_HAS_4_TILES) && (next2->population != 0 || next3->population != 0))) {
    hs.enabled = false;
    if (!filename.empty()) Debug(grf, 1, "FinaliseHouseArray: {} defines multitile house {} with non-zero population on additional tiles. Disabling house.", filename, hs.grf_prop.local_id);
    return false;
  }
 
  /* Substitute type is also used for override, and having an override with a different size causes crashes.
   * This check should only be done for NewGRF houses because grf_prop.subst_id is not set for original houses.*/
  if (!filename.empty() && (hs.building_flags & BUILDING_HAS_1_TILE) != (HouseSpec::Get(hs.grf_prop.subst_id)->building_flags & BUILDING_HAS_1_TILE)) {
    hs.enabled = false;
    Debug(grf, 1, "FinaliseHouseArray: {} defines house {} with different house size then it's substitute type. Disabling house.", filename, hs.grf_prop.local_id);
    return false;
  }
 
  /* Make sure that additional parts of multitile houses are not available. */
  if (!hs.building_flags.Any(BUILDING_HAS_1_TILE) && hs.building_availability.Any(HZ_ZONE_ALL) && hs.building_availability.Any(HZ_CLIMATE_ALL)) {
    hs.enabled = false;
    if (!filename.empty()) Debug(grf, 1, "FinaliseHouseArray: {} defines house {} without a size but marked it as available. Disabling house.", filename, hs.grf_prop.local_id);
    return false;
  }
 
  return true;
}

static void EnsureEarlyHouse(HouseZones bitmask)
{
  TimerGameCalendar::Year min_year = CalendarTime::MAX_YEAR;
 
  for (const auto &hs : HouseSpec::Specs()) {
    if (!hs.enabled) continue;
    if (!hs.building_availability.All(bitmask)) continue;
    if (hs.min_year < min_year) min_year = hs.min_year;
  }
 
  if (min_year == 0) return;
 
  for (auto &hs : HouseSpec::Specs()) {
    if (!hs.enabled) continue;
    if (!hs.building_availability.All(bitmask)) continue;
    if (hs.min_year == min_year) hs.min_year = CalendarTime::MIN_YEAR;
  }
}

static void FinaliseHouseArray()
{
  /* If there are no houses with start dates before 1930, then all houses
   * with start dates of 1930 have them reset to 0. This is in order to be
   * compatible with TTDPatch, where if no houses have start dates before
   * 1930 and the date is before 1930, the game pretends that this is 1930.
   * If there have been any houses defined with start dates before 1930 then
   * the dates are left alone.
   * On the other hand, why 1930? Just 'fix' the houses with the lowest
   * minimum introduction date to 0.
   */
  for (auto &file : _grf_files) {
    if (file.housespec.empty()) continue;
 
    size_t num_houses = file.housespec.size();
    for (size_t i = 0; i < num_houses; i++) {
      auto &hs = file.housespec[i];
 
      if (hs == nullptr) continue;
 
      const HouseSpec *next1 = (i + 1 < num_houses ? file.housespec[i + 1].get() : nullptr);
      const HouseSpec *next2 = (i + 2 < num_houses ? file.housespec[i + 2].get() : nullptr);
      const HouseSpec *next3 = (i + 3 < num_houses ? file.housespec[i + 3].get() : nullptr);
 
      if (!IsHouseSpecValid(*hs, next1, next2, next3, file.filename)) continue;
 
      _house_mngr.SetEntitySpec(std::move(*hs));
    }
 
    /* Won't be used again */
    file.housespec.clear();
    file.housespec.shrink_to_fit();
  }
 
  for (size_t i = 0; i < HouseSpec::Specs().size(); i++) {
    HouseSpec *hs = HouseSpec::Get(i);
    const HouseSpec *next1 = (i + 1 < NUM_HOUSES ? HouseSpec::Get(i + 1) : nullptr);
    const HouseSpec *next2 = (i + 2 < NUM_HOUSES ? HouseSpec::Get(i + 2) : nullptr);
    const HouseSpec *next3 = (i + 3 < NUM_HOUSES ? HouseSpec::Get(i + 3) : nullptr);
 
    /* We need to check all houses again to we are sure that multitile houses
     * did get consecutive IDs and none of the parts are missing. */
    if (!IsHouseSpecValid(*hs, next1, next2, next3, std::string{})) {
      /* GetHouseNorthPart checks 3 houses that are directly before
       * it in the house pool. If any of those houses have multi-tile
       * flags set it assumes it's part of a multitile house. Since
       * we can have invalid houses in the pool marked as disabled, we
       * don't want to have them influencing valid tiles. As such set
       * building_flags to zero here to make sure any house following
       * this one in the pool is properly handled as 1x1 house. */
      hs->building_flags = {};
    }
 
    /* Apply default cargo translation map for unset cargo slots */
    for (uint i = 0; i < lengthof(hs->accepts_cargo_label); ++i) {
      if (!IsValidCargoType(hs->accepts_cargo[i])) hs->accepts_cargo[i] = GetCargoTypeByLabel(hs->accepts_cargo_label[i]);
      /* Disable acceptance if cargo type is invalid. */
      if (!IsValidCargoType(hs->accepts_cargo[i])) hs->cargo_acceptance[i] = 0;
    }
  }
 
  HouseZones climate_mask = GetClimateMaskForLandscape();
  for (HouseZone climate : climate_mask) {
    for (HouseZone zone : HZ_ZONE_ALL) {
      EnsureEarlyHouse({climate, zone});
    }
  }
}

static void FinaliseIndustriesArray()
{
  for (auto &file : _grf_files) {
    for (auto &indsp : file.industryspec) {
      if (indsp == nullptr || !indsp->enabled) continue;
 
      _industry_mngr.SetEntitySpec(std::move(*indsp));
    }
 
    for (auto &indtsp : file.indtspec) {
      if (indtsp != nullptr) {
        _industile_mngr.SetEntitySpec(std::move(*indtsp));
      }
    }
 
    /* Won't be used again */
    file.industryspec.clear();
    file.industryspec.shrink_to_fit();
    file.indtspec.clear();
    file.indtspec.shrink_to_fit();
  }
 
  for (auto &indsp : _industry_specs) {
    if (indsp.enabled && indsp.grf_prop.HasGrfFile()) {
      for (auto &conflicting : indsp.conflicting) {
        conflicting = MapNewGRFIndustryType(conflicting, indsp.grf_prop.grfid);
      }
    }
    if (!indsp.enabled) {
      indsp.name = STR_NEWGRF_INVALID_INDUSTRYTYPE;
    }
 
    /* Apply default cargo translation map for unset cargo slots */
    for (size_t i = 0; i < std::size(indsp.produced_cargo_label); ++i) {
      if (!IsValidCargoType(indsp.produced_cargo[i])) indsp.produced_cargo[i] = GetCargoTypeByLabel(GetActiveCargoLabel(indsp.produced_cargo_label[i]));
    }
    for (size_t i = 0; i < std::size(indsp.accepts_cargo_label); ++i) {
      if (!IsValidCargoType(indsp.accepts_cargo[i])) indsp.accepts_cargo[i] = GetCargoTypeByLabel(GetActiveCargoLabel(indsp.accepts_cargo_label[i]));
    }
  }
 
  for (auto &indtsp : _industry_tile_specs) {
    /* Apply default cargo translation map for unset cargo slots */
    for (size_t i = 0; i < std::size(indtsp.accepts_cargo_label); ++i) {
      if (!IsValidCargoType(indtsp.accepts_cargo[i])) indtsp.accepts_cargo[i] = GetCargoTypeByLabel(GetActiveCargoLabel(indtsp.accepts_cargo_label[i]));
    }
  }
}

static void FinaliseObjectsArray()
{
  for (auto &file : _grf_files) {
    for (auto &objectspec : file.objectspec) {
      if (objectspec != nullptr && objectspec->grf_prop.HasGrfFile() && objectspec->IsEnabled()) {
        _object_mngr.SetEntitySpec(std::move(*objectspec));
      }
    }
 
    /* Won't be used again */
    file.objectspec.clear();
    file.objectspec.shrink_to_fit();
  }
 
  ObjectSpec::BindToClasses();
}

static void FinaliseAirportsArray()
{
  for (auto &file : _grf_files) {
    for (auto &as : file.airportspec) {
      if (as != nullptr && as->enabled) {
        _airport_mngr.SetEntitySpec(std::move(*as));
      }
    }
 
    for (auto &ats : file.airtspec) {
      if (ats != nullptr && ats->enabled) {
        _airporttile_mngr.SetEntitySpec(std::move(*ats));
      }
    }
 
    /* Won't be used again */
    file.airportspec.clear();
    file.airportspec.shrink_to_fit();
    file.airtspec.clear();
    file.airtspec.shrink_to_fit();
  }
}

struct InvokeGrfActionHandler {
  template <uint8_t TAction>
  static void Invoke(ByteReader &buf, GrfLoadingStage stage)
  {
    switch (stage) {
      case GrfLoadingStage::FileScan: GrfActionHandler<TAction>::FileScan(buf); break;
      case GrfLoadingStage::SafetyScan: GrfActionHandler<TAction>::SafetyScan(buf); break;
      case GrfLoadingStage::LabelScan: GrfActionHandler<TAction>::LabelScan(buf); break;
      case GrfLoadingStage::Init: GrfActionHandler<TAction>::Init(buf); break;
      case GrfLoadingStage::Reserve: GrfActionHandler<TAction>::Reserve(buf); break;
      case GrfLoadingStage::Activation: GrfActionHandler<TAction>::Activation(buf); break;
      default: NOT_REACHED();
    }
  }
 
  using Invoker = void(*)(ByteReader &buf, GrfLoadingStage stage);
  static constexpr Invoker funcs[] = { // Must be listed in action order.
    Invoke<0x00>, Invoke<0x01>, Invoke<0x02>, Invoke<0x03>, Invoke<0x04>, Invoke<0x05>, Invoke<0x06>, Invoke<0x07>,
    Invoke<0x08>, Invoke<0x09>, Invoke<0x0A>, Invoke<0x0B>, Invoke<0x0C>, Invoke<0x0D>, Invoke<0x0E>, Invoke<0x0F>,
    Invoke<0x10>, Invoke<0x11>, Invoke<0x12>, Invoke<0x13>, Invoke<0x14>,
  };
 
  static void Invoke(uint8_t action, GrfLoadingStage stage, ByteReader &buf)
  {
    Invoker func = action < std::size(funcs) ? funcs[action] : nullptr;
    if (func == nullptr) {
      GrfMsg(7, "DecodeSpecialSprite: Skipping unknown action 0x{:02X}", action);
    } else {
      GrfMsg(7, "DecodeSpecialSprite: Handling action 0x{:02X} in stage {}", action, stage);
      func(buf, stage);
    }
  }
};
 
/* Here we perform initial decoding of some special sprites (as are they
 * described at http://www.ttdpatch.net/src/newgrf.txt, but this is only a very
 * partial implementation yet).
 * XXX: We consider GRF files trusted. It would be trivial to exploit OTTD by
 * a crafted invalid GRF file. We should tell that to the user somehow, or
 * better make this more robust in the future. */
static void DecodeSpecialSprite(ReusableBuffer<uint8_t> &allocator, uint num, GrfLoadingStage stage)
{
  uint8_t *buf;
  auto it = _grf_line_to_action6_sprite_override.find({_cur_gps.grfconfig->ident.grfid, _cur_gps.nfo_line});
  if (it == _grf_line_to_action6_sprite_override.end()) {
    /* No preloaded sprite to work with; read the
     * pseudo sprite content. */
    buf = allocator.Allocate(num);
    _cur_gps.file->ReadBlock(buf, num);
  } else {
    /* Use the preloaded sprite data. */
    buf = it->second.data();
    assert(it->second.size() == num);
    GrfMsg(7, "DecodeSpecialSprite: Using preloaded pseudo sprite data");
 
    /* Skip the real (original) content of this action. */
    _cur_gps.file->SeekTo(num, SEEK_CUR);
  }
 
  ByteReader br(buf, num);
 
  try {
    uint8_t action = br.ReadByte();
 
    if (action == 0xFF) {
      GrfMsg(2, "DecodeSpecialSprite: Unexpected data block, skipping");
    } else if (action == 0xFE) {
      GrfMsg(2, "DecodeSpecialSprite: Unexpected import block, skipping");
    } else {
      InvokeGrfActionHandler::Invoke(action, stage, br);
    }
  } catch (...) {
    GrfMsg(1, "DecodeSpecialSprite: Tried to read past end of pseudo-sprite data");
    DisableGrf(STR_NEWGRF_ERROR_READ_BOUNDS);
  }
}

static void LoadNewGRFFileFromFile(GRFConfig &config, GrfLoadingStage stage, SpriteFile &file)
{
  AutoRestoreBackup cur_file(_cur_gps.file, &file);
  AutoRestoreBackup cur_config(_cur_gps.grfconfig, &config);
 
  Debug(grf, 2, "LoadNewGRFFile: Reading NewGRF-file '{}'", config.filename);
 
  uint8_t grf_container_version = file.GetContainerVersion();
  if (grf_container_version == 0) {
    Debug(grf, 7, "LoadNewGRFFile: Custom .grf has invalid format");
    return;
  }
 
  if (stage == GrfLoadingStage::Init || stage == GrfLoadingStage::Activation) {
    /* We need the sprite offsets in the init stage for NewGRF sounds
     * and in the activation stage for real sprites. */
    ReadGRFSpriteOffsets(file);
  } else {
    /* Skip sprite section offset if present. */
    if (grf_container_version >= 2) file.ReadDword();
  }
 
  if (grf_container_version >= 2) {
    /* Read compression value. */
    uint8_t compression = file.ReadByte();
    if (compression != 0) {
      Debug(grf, 7, "LoadNewGRFFile: Unsupported compression format");
      return;
    }
  }
 
  /* Skip the first sprite; we don't care about how many sprites this
   * does contain; newest TTDPatches and George's longvehicles don't
   * neither, apparently. */
  uint32_t num = grf_container_version >= 2 ? file.ReadDword() : file.ReadWord();
  if (num == 4 && file.ReadByte() == 0xFF) {
    file.ReadDword();
  } else {
    Debug(grf, 7, "LoadNewGRFFile: Custom .grf has invalid format");
    return;
  }
 
  _cur_gps.ClearDataForNextFile();
 
  ReusableBuffer<uint8_t> allocator;
 
  while ((num = (grf_container_version >= 2 ? file.ReadDword() : file.ReadWord())) != 0) {
    uint8_t type = file.ReadByte();
    _cur_gps.nfo_line++;
 
    if (type == 0xFF) {
      if (_cur_gps.skip_sprites == 0) {
        /* Limit the special sprites to 1 MiB. */
        if (num > 1024 * 1024) {
          GrfMsg(0, "LoadNewGRFFile: Unexpectedly large sprite, disabling");
          DisableGrf(STR_NEWGRF_ERROR_UNEXPECTED_SPRITE);
          break;
        }
 
        DecodeSpecialSprite(allocator, num, stage);
 
        /* Stop all processing if we are to skip the remaining sprites */
        if (_cur_gps.skip_sprites == -1) break;
 
        continue;
      } else {
        file.SkipBytes(num);
      }
    } else {
      if (_cur_gps.skip_sprites == 0) {
        GrfMsg(0, "LoadNewGRFFile: Unexpected sprite, disabling");
        DisableGrf(STR_NEWGRF_ERROR_UNEXPECTED_SPRITE);
        break;
      }
 
      if (grf_container_version >= 2 && type == 0xFD) {
        /* Reference to data section. Container version >= 2 only. */
        file.SkipBytes(num);
      } else {
        file.SkipBytes(7);
        SkipSpriteData(file, type, num - 8);
      }
    }
 
    if (_cur_gps.skip_sprites > 0) _cur_gps.skip_sprites--;
  }
}

void LoadNewGRFFile(GRFConfig &config, GrfLoadingStage stage, Subdirectory subdir, bool temporary)
{
  const std::string &filename = config.filename;
 
  /* A .grf file is activated only if it was active when the game was
   * started.  If a game is loaded, only its active .grfs will be
   * reactivated, unless "loadallgraphics on" is used.  A .grf file is
   * considered active if its action 8 has been processed, i.e. its
   * action 8 hasn't been skipped using an action 7.
   *
   * During activation, only actions 0, 1, 2, 3, 4, 5, 7, 8, 9, 0A and 0B are
   * carried out.  All others are ignored, because they only need to be
   * processed once at initialization.  */
  if (stage != GrfLoadingStage::FileScan && stage != GrfLoadingStage::SafetyScan && stage != GrfLoadingStage::LabelScan) {
    _cur_gps.grffile = GetFileByFilename(filename);
    if (_cur_gps.grffile == nullptr) UserError("File '{}' lost in cache.\n", filename);
    if (stage == GrfLoadingStage::Reserve && config.status != GRFStatus::Initialised) return;
    if (stage == GrfLoadingStage::Activation && !config.flags.Test(GRFConfigFlag::Reserved)) return;
  }
 
  bool needs_palette_remap = config.palette & GRFP_USE_MASK;
  if (temporary) {
    SpriteFile temporarySpriteFile(filename, subdir, needs_palette_remap);
    LoadNewGRFFileFromFile(config, stage, temporarySpriteFile);
  } else {
    LoadNewGRFFileFromFile(config, stage, OpenCachedSpriteFile(filename, subdir, needs_palette_remap));
  }
}

static void ActivateOldShore()
{
  /* Use default graphics, if no shore sprites were loaded.
   * Should not happen, as the base set's extra grf should include some. */
  if (_loaded_newgrf_features.shore == ShoreReplacement::None) _loaded_newgrf_features.shore = ShoreReplacement::ActionA;
 
  if (_loaded_newgrf_features.shore != ShoreReplacement::Action5) {
    DupSprite(SPR_ORIGINALSHORE_START +  1, SPR_SHORE_BASE +  1); // SLOPE_W
    DupSprite(SPR_ORIGINALSHORE_START +  2, SPR_SHORE_BASE +  2); // SLOPE_S
    DupSprite(SPR_ORIGINALSHORE_START +  6, SPR_SHORE_BASE +  3); // SLOPE_SW
    DupSprite(SPR_ORIGINALSHORE_START +  0, SPR_SHORE_BASE +  4); // SLOPE_E
    DupSprite(SPR_ORIGINALSHORE_START +  4, SPR_SHORE_BASE +  6); // SLOPE_SE
    DupSprite(SPR_ORIGINALSHORE_START +  3, SPR_SHORE_BASE +  8); // SLOPE_N
    DupSprite(SPR_ORIGINALSHORE_START +  7, SPR_SHORE_BASE +  9); // SLOPE_NW
    DupSprite(SPR_ORIGINALSHORE_START +  5, SPR_SHORE_BASE + 12); // SLOPE_NE
  }
 
  if (_loaded_newgrf_features.shore == ShoreReplacement::ActionA) {
    DupSprite(SPR_FLAT_GRASS_TILE + 16, SPR_SHORE_BASE +  0); // SLOPE_STEEP_S
    DupSprite(SPR_FLAT_GRASS_TILE + 17, SPR_SHORE_BASE +  5); // SLOPE_STEEP_W
    DupSprite(SPR_FLAT_GRASS_TILE +  7, SPR_SHORE_BASE +  7); // SLOPE_WSE
    DupSprite(SPR_FLAT_GRASS_TILE + 15, SPR_SHORE_BASE + 10); // SLOPE_STEEP_N
    DupSprite(SPR_FLAT_GRASS_TILE + 11, SPR_SHORE_BASE + 11); // SLOPE_NWS
    DupSprite(SPR_FLAT_GRASS_TILE + 13, SPR_SHORE_BASE + 13); // SLOPE_ENW
    DupSprite(SPR_FLAT_GRASS_TILE + 14, SPR_SHORE_BASE + 14); // SLOPE_SEN
    DupSprite(SPR_FLAT_GRASS_TILE + 18, SPR_SHORE_BASE + 15); // SLOPE_STEEP_E
 
    /* XXX - SLOPE_EW, SLOPE_NS are currently not used.
     *       If they would be used somewhen, then these grass tiles will most like not look as needed */
    DupSprite(SPR_FLAT_GRASS_TILE +  5, SPR_SHORE_BASE + 16); // SLOPE_EW
    DupSprite(SPR_FLAT_GRASS_TILE + 10, SPR_SHORE_BASE + 17); // SLOPE_NS
  }
}

static void ActivateOldTramDepot()
{
  if (_loaded_newgrf_features.tram == TramDepotReplacement::WithTrack) {
    DupSprite(SPR_ROAD_DEPOT               + 0, SPR_TRAMWAY_DEPOT_NO_TRACK + 0); // use road depot graphics for "no tracks"
    DupSprite(SPR_TRAMWAY_DEPOT_WITH_TRACK + 1, SPR_TRAMWAY_DEPOT_NO_TRACK + 1);
    DupSprite(SPR_ROAD_DEPOT               + 2, SPR_TRAMWAY_DEPOT_NO_TRACK + 2); // use road depot graphics for "no tracks"
    DupSprite(SPR_TRAMWAY_DEPOT_WITH_TRACK + 3, SPR_TRAMWAY_DEPOT_NO_TRACK + 3);
    DupSprite(SPR_TRAMWAY_DEPOT_WITH_TRACK + 4, SPR_TRAMWAY_DEPOT_NO_TRACK + 4);
    DupSprite(SPR_TRAMWAY_DEPOT_WITH_TRACK + 5, SPR_TRAMWAY_DEPOT_NO_TRACK + 5);
  }
}

static void FinalisePriceBaseMultipliers()
{
  static constexpr GrfSpecFeatures override_features{GrfSpecFeature::Trains, GrfSpecFeature::RoadVehicles, GrfSpecFeature::Ships, GrfSpecFeature::Aircraft};
 
  /* Evaluate grf overrides */
  int num_grfs = (uint)_grf_files.size();
  std::vector<int> grf_overrides(num_grfs, -1);
  for (int i = 0; i < num_grfs; i++) {
    GRFFile &source = _grf_files[i];
    auto it = _grf_id_overrides.find(source.grfid);
    if (it == std::end(_grf_id_overrides)) continue;
    GrfID override_grfid = it->second;
 
    auto dest = std::ranges::find(_grf_files, override_grfid, &GRFFile::grfid);
    if (dest == std::end(_grf_files)) continue;
 
    grf_overrides[i] = static_cast<int>(std::ranges::distance(std::begin(_grf_files), dest));
    assert(grf_overrides[i] >= 0);
  }
 
  /* Override features and price base multipliers of earlier loaded grfs */
  for (int i = 0; i < num_grfs; i++) {
    if (grf_overrides[i] < 0 || grf_overrides[i] >= i) continue;
    GRFFile &source = _grf_files[i];
    GRFFile &dest = _grf_files[grf_overrides[i]];
 
    GrfSpecFeatures features = (source.grf_features | dest.grf_features) & override_features;
    source.grf_features.Set(features);
    dest.grf_features.Set(features);
 
    for (Price p : EnumRange(Price::End)) {
      /* No price defined -> nothing to do */
      if (!features.Test(_price_base_specs[p].grf_feature) || source.price_base_multipliers[p] == INVALID_PRICE_MODIFIER) continue;
      Debug(grf, 3, "'{}' overrides price base multiplier {} of '{}'", source.filename, p, dest.filename);
      dest.price_base_multipliers[p] = source.price_base_multipliers[p];
    }
  }
 
  /* Propagate features and price base multipliers of afterwards loaded grfs, if none is present yet */
  for (int i = num_grfs - 1; i >= 0; i--) {
    if (grf_overrides[i] < 0 || grf_overrides[i] <= i) continue;
    GRFFile &source = _grf_files[i];
    GRFFile &dest = _grf_files[grf_overrides[i]];
 
    GrfSpecFeatures features = (source.grf_features | dest.grf_features) & override_features;
    source.grf_features.Set(features);
    dest.grf_features.Set(features);
 
    for (Price p : EnumRange(Price::End)) {
      /* Already a price defined -> nothing to do */
      if (!features.Test(_price_base_specs[p].grf_feature) || dest.price_base_multipliers[p] != INVALID_PRICE_MODIFIER) continue;
      Debug(grf, 3, "Price base multiplier {} from '{}' propagated to '{}'", p, source.filename, dest.filename);
      dest.price_base_multipliers[p] = source.price_base_multipliers[p];
    }
  }
 
  /* The 'master grf' now have the correct multipliers. Assign them to the 'addon grfs' to make everything consistent. */
  for (int i = 0; i < num_grfs; i++) {
    if (grf_overrides[i] < 0) continue;
    GRFFile &source = _grf_files[i];
    GRFFile &dest = _grf_files[grf_overrides[i]];
 
    GrfSpecFeatures features = (source.grf_features | dest.grf_features) & override_features;
    source.grf_features.Set(features);
    dest.grf_features.Set(features);
 
    for (Price p : EnumRange(Price::End)) {
      if (!features.Test(_price_base_specs[p].grf_feature)) continue;
      if (source.price_base_multipliers[p] != dest.price_base_multipliers[p]) {
        Debug(grf, 3, "Price base multiplier {} from '{}' propagated to '{}'", p, dest.filename, source.filename);
      }
      source.price_base_multipliers[p] = dest.price_base_multipliers[p];
    }
  }
 
  /* Apply fallback prices for grf version < 8 */
  for (auto &file : _grf_files) {
    if (file.grf_version >= 8) continue;
    PriceMultipliers &price_base_multipliers = file.price_base_multipliers;
    for (Price p : EnumRange(Price::End)) {
      Price fallback_price = _price_base_specs[p].fallback_price;
      if (fallback_price != Price::Invalid && price_base_multipliers[p] == INVALID_PRICE_MODIFIER) {
        /* No price multiplier has been set.
         * So copy the multiplier from the fallback price, maybe a multiplier was set there. */
        price_base_multipliers[p] = price_base_multipliers[fallback_price];
      }
    }
  }
 
  /* Decide local/global scope of price base multipliers */
  for (auto &file : _grf_files) {
    PriceMultipliers &price_base_multipliers = file.price_base_multipliers;
    for (Price p : EnumRange(Price::End)) {
      if (price_base_multipliers[p] == INVALID_PRICE_MODIFIER) {
        /* No multiplier was set; set it to a neutral value */
        price_base_multipliers[p] = 0;
      } else {
        if (!file.grf_features.Test(_price_base_specs[p].grf_feature)) {
          /* The grf does not define any objects of the feature,
           * so it must be a difficulty setting. Apply it globally */
          Debug(grf, 3, "'{}' sets global price base multiplier {}", file.filename, p);
          SetPriceBaseMultiplier(p, price_base_multipliers[p]);
          price_base_multipliers[p] = 0;
        } else {
          Debug(grf, 3, "'{}' sets local price base multiplier {}", file.filename, p);
        }
      }
    }
  }
}
 
template <typename T>
void AddBadgeToSpecs(T &specs, GrfSpecFeature feature, Badge &badge)
{
  for (auto &spec : specs) {
    if (spec == nullptr) continue;
    spec->badges.push_back(badge.index);
    badge.features.Set(feature);
  }
}

static void FinaliseBadges()
{
  for (const auto &file : _grf_files) {
    Badge *badge = GetBadgeByLabel(fmt::format("newgrf/{:08x}", std::byteswap(file.grfid)));
    if (badge == nullptr) continue;
 
    for (Engine *e : Engine::Iterate()) {
      if (e->grf_prop.grffile != &file) continue;
      e->badges.push_back(badge->index);
      badge->features.Set(GetGrfSpecFeature(e->type));
    }
 
    AddBadgeToSpecs(file.stations, GrfSpecFeature::Stations, *badge);
    AddBadgeToSpecs(file.housespec, GrfSpecFeature::Houses, *badge);
    AddBadgeToSpecs(file.industryspec, GrfSpecFeature::Industries, *badge);
    AddBadgeToSpecs(file.indtspec, GrfSpecFeature::IndustryTiles, *badge);
    AddBadgeToSpecs(file.objectspec, GrfSpecFeature::Objects, *badge);
    AddBadgeToSpecs(file.airportspec, GrfSpecFeature::Airports, *badge);
    AddBadgeToSpecs(file.airtspec, GrfSpecFeature::AirportTiles, *badge);
    AddBadgeToSpecs(file.roadstops, GrfSpecFeature::RoadStops, *badge);
  }
 
  ApplyBadgeFeaturesToClassBadges();
  AddBadgeClassesToConfiguration();
}
 
extern void InitGRFTownGeneratorNames();

static void AfterLoadGRFs()
{
  /* Cached callback groups are no longer needed. */
  ResetCallbacks(true);
 
  FinaliseStringMapping();
 
  /* Clear the action 6 override sprites. */
  _grf_line_to_action6_sprite_override.clear();
 
  FinaliseBadges();
 
  /* Polish cargoes */
  FinaliseCargoArray();
 
  /* Pre-calculate all refit masks after loading GRF files. */
  CalculateRefitMasks();
 
  /* Polish engines */
  FinaliseEngineArray();
 
  /* Set the actually used Canal properties */
  FinaliseCanals();
 
  /* Add all new houses to the house array. */
  FinaliseHouseArray();
 
  /* Add all new industries to the industry array. */
  FinaliseIndustriesArray();
 
  /* Add all new objects to the object array. */
  FinaliseObjectsArray();
 
  InitializeSortedCargoSpecs();
 
  /* Sort the list of industry types. */
  SortIndustryTypes();
 
  /* Create dynamic list of industry legends for smallmap_gui.cpp */
  BuildIndustriesLegend();
 
  /* Build the routemap legend, based on the available cargos */
  BuildLinkStatsLegend();
 
  /* Add all new airports to the airports array. */
  FinaliseAirportsArray();
  BindAirportSpecs();
 
  /* Update the townname generators list */
  InitGRFTownGeneratorNames();
 
  /* Run all queued vehicle list order changes */
  CommitVehicleListOrderChanges();
 
  /* Load old shore sprites in new position, if they were replaced by ActionA */
  ActivateOldShore();
 
  /* Load old tram depot sprites in new position, if no new ones are present */
  ActivateOldTramDepot();
 
  /* Set up custom rail types */
  InitRailTypes();
  InitRoadTypes();
 
  for (Engine *e : Engine::IterateType(VehicleType::Road)) {
    if (_gted[e->index].rv_max_speed != 0) {
      /* Set RV maximum speed from the mph/0.8 unit value */
      e->VehInfo<RoadVehicleInfo>().max_speed = _gted[e->index].rv_max_speed * 4;
    }
 
    RoadTramType rtt = e->info.misc_flags.Test(EngineMiscFlag::RoadIsTram) ? RoadTramType::Tram : RoadTramType::Road;
 
    const GRFFile *file = e->GetGRF();
    if (file == nullptr || _gted[e->index].roadtramtype == 0) {
      e->VehInfo<RoadVehicleInfo>().roadtype = (rtt == RoadTramType::Tram) ? ROADTYPE_TRAM : ROADTYPE_ROAD;
      continue;
    }
 
    /* Remove +1 offset. */
    _gted[e->index].roadtramtype--;
 
    const std::vector<RoadTypeLabel> *list = (rtt == RoadTramType::Tram) ? &file->tramtype_list : &file->roadtype_list;
    if (_gted[e->index].roadtramtype < list->size())
    {
      RoadTypeLabel rtl = (*list)[_gted[e->index].roadtramtype];
      RoadType rt = GetRoadTypeByLabel(rtl);
      if (rt != INVALID_ROADTYPE && GetRoadTramType(rt) == rtt) {
        e->VehInfo<RoadVehicleInfo>().roadtype = rt;
        continue;
      }
    }
 
    /* Road type is not available, so disable this engine */
    e->info.climates = {};
  }
 
  for (Engine *e : Engine::IterateType(VehicleType::Train)) {
    RailTypes railtypes{};
    for (RailTypeLabel label : _gted[e->index].railtypelabels) {
      auto rt = GetRailTypeByLabel(label);
      if (rt != INVALID_RAILTYPE) railtypes.Set(rt);
    }
 
    if (railtypes.Any()) {
      e->VehInfo<RailVehicleInfo>().railtypes = railtypes;
      e->VehInfo<RailVehicleInfo>().intended_railtypes = railtypes;
    } else {
      /* Rail type is not available, so disable this engine */
      e->info.climates = {};
    }
  }
 
  SetYearEngineAgingStops();
 
  FinalisePriceBaseMultipliers();
 
  /* Deallocate temporary loading data */
  _gted.clear();
  _grm_sprites.clear();
}

void LoadNewGRF(SpriteID load_index, uint num_baseset)
{
  /* In case of networking we need to "sync" the start values
   * so all NewGRFs are loaded equally. For this we use the
   * start date of the game and we set the counters, etc. to
   * 0 so they're the same too. */
  AutoRestoreBackup backup_date{TimerGameCalendar::date};
  AutoRestoreBackup backup_year{TimerGameCalendar::year};
  AutoRestoreBackup backup_date_fract{TimerGameCalendar::date_fract};
 
  AutoRestoreBackup backup_economy_date{TimerGameEconomy::date};
  AutoRestoreBackup backup_economy_year{TimerGameEconomy::year};
  AutoRestoreBackup backup_economy_date_fract{TimerGameEconomy::date_fract};
 
  AutoRestoreBackup backup_tick_counter{TimerGameTick::counter};
  AutoRestoreBackup backup_display_opt{_display_opt};
 
  if (_networking) {
    TimerGameCalendar::year = _settings_game.game_creation.starting_year;
    TimerGameCalendar::date = TimerGameCalendar::ConvertYMDToDate(TimerGameCalendar::year, 0, 1);
    TimerGameCalendar::date_fract = 0;
 
    TimerGameEconomy::year = TimerGameEconomy::Year{_settings_game.game_creation.starting_year.base()};
    TimerGameEconomy::date = TimerGameEconomy::ConvertYMDToDate(TimerGameEconomy::year, 0, 1);
    TimerGameEconomy::date_fract = 0;
 
    TimerGameTick::counter = 0;
    _display_opt.Reset();
  }
 
  InitializePatchFlags();
 
  ResetNewGRFData();
 
  /*
   * Reset the status of all files, so we can 'retry' to load them.
   * This is needed when one for example rearranges the NewGRFs in-game
   * and a previously disabled NewGRF becomes usable. If it would not
   * be reset, the NewGRF would remain disabled even though it should
   * have been enabled.
   */
  for (const auto &c : _grfconfig) {
    if (c->status != GRFStatus::NotFound) c->status = GRFStatus::Unknown;
  }
 
  _cur_gps.spriteid = load_index;
 
  /* Load newgrf sprites
   * in each loading stage, (try to) open each file specified in the config
   * and load information from it. */
  for (GrfLoadingStage stage : EnumRange(GrfLoadingStage::LabelScan, GrfLoadingStage::End)) {
    /* Set activated grfs back to will-be-activated between reservation- and activation-stage.
     * This ensures that action7/9 conditions 0x06 - 0x0A work correctly. */
    for (const auto &c : _grfconfig) {
      if (c->status == GRFStatus::Activated) c->status = GRFStatus::Initialised;
    }
 
    if (stage == GrfLoadingStage::Reserve) {
      static const std::pair<uint32_t, uint32_t> default_grf_overrides[] = {
        { std::byteswap(0x44442202), std::byteswap(0x44440111) }, // UKRS addons modifies UKRS
        { std::byteswap(0x6D620402), std::byteswap(0x6D620401) }, // DBSetXL ECS extension modifies DBSetXL
        { std::byteswap(0x4D656f20), std::byteswap(0x4D656F17) }, // LV4cut modifies LV4
      };
      for (const auto &grf_override : default_grf_overrides) {
        SetNewGRFOverride(grf_override.first, grf_override.second);
      }
    }
 
    uint num_grfs = 0;
    uint num_non_static = 0;
 
    _cur_gps.stage = stage;
    for (const auto &c : _grfconfig) {
      if (c->status == GRFStatus::Disabled || c->status == GRFStatus::NotFound) continue;
      if (stage > GrfLoadingStage::Init && c->flags.Test(GRFConfigFlag::InitOnly)) continue;
 
      Subdirectory subdir = num_grfs < num_baseset ? Subdirectory::Baseset : Subdirectory::NewGrf;
      if (!FioCheckFileExists(c->filename, subdir)) {
        Debug(grf, 0, "NewGRF file is missing '{}'; disabling", c->filename);
        c->status = GRFStatus::NotFound;
        continue;
      }
 
      if (stage == GrfLoadingStage::LabelScan) InitNewGRFFile(*c);
 
      if (!c->flags.Test(GRFConfigFlag::Static) && !c->flags.Test(GRFConfigFlag::System)) {
        if (num_non_static == NETWORK_MAX_GRF_COUNT) {
          Debug(grf, 0, "'{}' is not loaded as the maximum number of non-static GRFs has been reached", c->filename);
          c->status = GRFStatus::Disabled;
          c->errors.emplace_back(STR_NEWGRF_ERROR_MSG_FATAL, 0, STR_NEWGRF_ERROR_TOO_MANY_NEWGRFS_LOADED);
          continue;
        }
        num_non_static++;
      }
 
      num_grfs++;
 
      LoadNewGRFFile(*c, stage, subdir, false);
      if (stage == GrfLoadingStage::Reserve) {
        c->flags.Set(GRFConfigFlag::Reserved);
      } else if (stage == GrfLoadingStage::Activation) {
        c->flags.Reset(GRFConfigFlag::Reserved);
        assert(GetFileByGRFID(c->ident.grfid) == _cur_gps.grffile);
        ClearTemporaryNewGRFData(_cur_gps.grffile);
        BuildCargoTranslationMap();
        Debug(sprite, 2, "LoadNewGRF: Currently {} sprites are loaded", _cur_gps.spriteid);
      } else if (stage == GrfLoadingStage::Init && c->flags.Test(GRFConfigFlag::InitOnly)) {
        /* We're not going to activate this, so free whatever data we allocated */
        ClearTemporaryNewGRFData(_cur_gps.grffile);
      }
    }
  }
 
  /* We've finished reading files. */
  _cur_gps.grfconfig = nullptr;
  _cur_gps.grffile = nullptr;
 
  /* Pseudo sprite processing is finished; free temporary stuff */
  _cur_gps.ClearDataForNextFile();
 
  /* Call any functions that should be run after GRFs have been loaded. */
  AfterLoadGRFs();
}

GrfSpecFeature GetGrfSpecFeature(VehicleType type)
{
  switch (type) {
    case VehicleType::Train: return GrfSpecFeature::Trains;
    case VehicleType::Road: return GrfSpecFeature::RoadVehicles;
    case VehicleType::Ship: return GrfSpecFeature::Ships;
    case VehicleType::Aircraft: return GrfSpecFeature::Aircraft;
    default: return GrfSpecFeature::Invalid;
  }
}

VehicleType GetVehicleType(GrfSpecFeature feature)
{
  switch (feature) {
    case GrfSpecFeature::Trains: return VehicleType::Train;
    case GrfSpecFeature::RoadVehicles: return VehicleType::Road;
    case GrfSpecFeature::Ships: return VehicleType::Ship;
    case GrfSpecFeature::Aircraft: return VehicleType::Aircraft;
    default: return VehicleType::Invalid;
  }
}