newgrf.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 NEWGRF_H
#define NEWGRF_H
 
#include "cargotype.h"
#include "rail_type.h"
#include "road_type.h"
#include "fileio_type.h"
#include "newgrf_text_type.h"
#include "core/bitmath_func.hpp"
#include "core/alloc_type.hpp"
#include "core/mem_func.hpp"
 
enum CanalFeature {
  CF_WATERSLOPE,
  CF_LOCKS,
  CF_DIKES,
  CF_ICON,
  CF_DOCKS,
  CF_RIVER_SLOPE,
  CF_RIVER_EDGE,
  CF_RIVER_GUI,
  CF_BUOY,
  CF_END,
};
 
struct CanalProperties {
  uint8_t callback_mask;  
  uint8_t flags;          
};
 
enum GrfLoadingStage {
  GLS_FILESCAN,
  GLS_SAFETYSCAN,
  GLS_LABELSCAN,
  GLS_INIT,
  GLS_RESERVE,
  GLS_ACTIVATION,
  GLS_END,
};
 
DECLARE_POSTFIX_INCREMENT(GrfLoadingStage)
 
enum GrfMiscBit {
  GMB_DESERT_TREES_FIELDS    = 0, // Unsupported.
  GMB_DESERT_PAVED_ROADS     = 1,
  GMB_FIELD_BOUNDING_BOX     = 2, // Unsupported.
  GMB_TRAIN_WIDTH_32_PIXELS  = 3, 
  GMB_AMBIENT_SOUND_CALLBACK = 4,
  GMB_CATENARY_ON_3RD_TRACK  = 5, // Unsupported.
  GMB_SECOND_ROCKY_TILE_SET  = 6,
};
 
enum GrfSpecFeature {
  GSF_TRAINS,
  GSF_ROADVEHICLES,
  GSF_SHIPS,
  GSF_AIRCRAFT,
  GSF_STATIONS,
  GSF_CANALS,
  GSF_BRIDGES,
  GSF_HOUSES,
  GSF_GLOBALVAR,
  GSF_INDUSTRYTILES,
  GSF_INDUSTRIES,
  GSF_CARGOES,
  GSF_SOUNDFX,
  GSF_AIRPORTS,
  GSF_SIGNALS,
  GSF_OBJECTS,
  GSF_RAILTYPES,
  GSF_AIRPORTTILES,
  GSF_ROADTYPES,
  GSF_TRAMTYPES,
  GSF_ROADSTOPS,
  GSF_END,
 
  GSF_FAKE_TOWNS = GSF_END, 
  GSF_FAKE_END,             
 
  GSF_INVALID = 0xFF,       
};
 
static const uint32_t INVALID_GRFID = 0xFFFFFFFF;
 
struct GRFLabel {
  uint8_t label;
  uint32_t nfo_line;
  size_t pos;
 
  GRFLabel(uint8_t label, uint32_t nfo_line, size_t pos) : label(label), nfo_line(nfo_line), pos(pos) {}
};
 
struct GRFFile : ZeroedMemoryAllocator {
  std::string filename;
  uint32_t grfid;
  uint8_t grf_version;
 
  uint sound_offset;
  uint16_t num_sounds;
 
  std::vector<std::unique_ptr<struct StationSpec>> stations;
  std::vector<std::unique_ptr<struct HouseSpec>> housespec;
  std::vector<std::unique_ptr<struct IndustrySpec>> industryspec;
  std::vector<std::unique_ptr<struct IndustryTileSpec>> indtspec;
  std::vector<std::unique_ptr<struct ObjectSpec>> objectspec;
  std::vector<std::unique_ptr<struct AirportSpec>> airportspec;
  std::vector<std::unique_ptr<struct AirportTileSpec>> airtspec;
  std::vector<std::unique_ptr<struct RoadStopSpec>> roadstops;
 
  std::vector<uint32_t> param;
 
  std::vector<GRFLabel> labels;                   
 
  std::vector<CargoLabel> cargo_list;             
  std::array<uint8_t, NUM_CARGO> cargo_map{}; 
 
  std::vector<RailTypeLabel> railtype_list;       
  std::array<RailType, RAILTYPE_END> railtype_map{};
 
  std::vector<RoadTypeLabel> roadtype_list;       
  std::array<RoadType, ROADTYPE_END> roadtype_map{};
 
  std::vector<RoadTypeLabel> tramtype_list;       
  std::array<RoadType, ROADTYPE_END> tramtype_map{};
 
  CanalProperties canal_local_properties[CF_END]; 
 
  std::unordered_map<uint8_t, LanguageMap> language_map; 
 
  int traininfo_vehicle_pitch;  
  uint traininfo_vehicle_width; 
 
  uint32_t grf_features;                     
  PriceMultipliers price_base_multipliers; 
 
  GRFFile(const struct GRFConfig *config);
 
  uint32_t GetParam(uint number) const
  {
    /* Note: We implicitly test for number < this->param.size() and return 0 for invalid parameters.
     *       In fact this is the more important test, as param is zeroed anyway. */
    return (number < std::size(this->param)) ? this->param[number] : 0;
  }
};
 
enum ShoreReplacement {
  SHORE_REPLACE_NONE,       
  SHORE_REPLACE_ACTION_5,   
  SHORE_REPLACE_ACTION_A,   
  SHORE_REPLACE_ONLY_NEW,   
};
 
enum TramReplacement {
  TRAMWAY_REPLACE_DEPOT_NONE,       
  TRAMWAY_REPLACE_DEPOT_WITH_TRACK, 
  TRAMWAY_REPLACE_DEPOT_NO_TRACK,   
};
 
struct GRFLoadedFeatures {
  bool has_2CC;             
  uint64_t used_liveries;     
  ShoreReplacement shore;   
  TramReplacement tram;     
};
 
inline bool HasGrfMiscBit(GrfMiscBit bit)
{
  extern uint8_t _misc_grf_features;
  return HasBit(_misc_grf_features, bit);
}
 
/* Indicates which are the newgrf features currently loaded ingame */
extern GRFLoadedFeatures _loaded_newgrf_features;
 
void LoadNewGRFFile(struct GRFConfig *config, GrfLoadingStage stage, Subdirectory subdir, bool temporary);
void LoadNewGRF(SpriteID load_index, uint num_baseset);
void ReloadNewGRFData(); // in saveload/afterload.cpp
void ResetNewGRFData();
void ResetPersistentNewGRFData();
 
void GrfMsgI(int severity, const std::string &msg);
#define GrfMsg(severity, format_string, ...) do { if ((severity) == 0 || _debug_grf_level >= (severity)) GrfMsgI(severity, fmt::format(FMT_STRING(format_string) __VA_OPT__(,) __VA_ARGS__)); } while (false)
 
bool GetGlobalVariable(uint8_t param, uint32_t *value, const GRFFile *grffile);
 
StringID MapGRFStringID(uint32_t grfid, StringID str);
void ShowNewGRFError();
 
#endif /* NEWGRF_H */