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

 
#ifndef NEWGRF_H
#define NEWGRF_H
 
#include "cargotype.h"
#include "debug_type.h"
#include "livery.h"
#include "rail_type.h"
#include "road_type.h"
#include "fileio_type.h"
#include "newgrf_badge_type.h"
#include "newgrf_callbacks.h"
#include "newgrf_text_type.h"
#include "vehicle_type.h"

enum class CanalFeature : uint8_t {
  LockWaterSlope, 
  Locks, 
  Dikes, 
  Icon, 
  FlatDocks, 
  RiverSlope, 
  RiverEdge, 
  RiverIcon, 
  Buoy, 
  End, 
};

enum class CanalFeatureFlag : uint8_t {
  HasFlatSprite = 0, 
};

using CanalFeatureFlags = EnumBitSet<CanalFeatureFlag, uint8_t>;

struct CanalProperties {
  CanalCallbackMasks callback_mask; 
  CanalFeatureFlags flags; 
};

enum class GrfLoadingStage : uint8_t {
  FileScan, 
  SafetyScan, 
  LabelScan, 
  Init, 
  Reserve, 
  Activation, 
  End, 
};

enum class GrfMiscBit : uint8_t {
  DesertTreesFields = 0, 
  DesertPavedRoads = 1, 
  FieldBoundingBox = 2, 
  TrainWidth32Pixels = 3, 
  AmbientSoundCallback = 4, 
  CatenaryOn3rdTrack = 5, 
  SecondRockyTileSet = 6, 
};

using GrfMiscBits = EnumBitSet<GrfMiscBit, uint8_t>;
 
enum class GrfSpecFeature : uint8_t {
  Trains, 
  RoadVehicles, 
  Ships, 
  Aircraft, 
  Stations, 
  Canals, 
  Bridges, 
  Houses, 
  GlobalVar, 
  IndustryTiles, 
  Industries, 
  Cargoes, 
  SoundEffects, 
  Airports, 
  Signals, 
  Objects, 
  RailTypes, 
  AirportTiles, 
  RoadTypes, 
  TramTypes, 
  RoadStops, 
  Badges, 
  End, 
 
  Default = End, 
  FakeTowns = End, 
  FakeEnd, 
 
  OriginalStrings = 0x48, 
 
  Invalid = 0xFF, 
};

using GrfSpecFeatures = EnumBitSet<GrfSpecFeature, uint32_t, GrfSpecFeature::End>;
 
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 {
  std::string filename{};
  GrfID grfid{};
  uint8_t grf_version = 0;
 
  uint sound_offset = 0;
  uint16_t num_sounds = 0;
 
  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<BadgeID> badge_list{}; 
  std::unordered_map<uint16_t, BadgeID> badge_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{};
 
  EnumIndexArray<CanalProperties, CanalFeature, CanalFeature::End> canal_local_properties{}; 
 
  std::unordered_map<GRFLanguage, LanguageMap> language_map{}; 
 
  int traininfo_vehicle_pitch = 0; 
  uint traininfo_vehicle_width = 0; 
  bool cargo_list_is_fallback = false; 
 
  GrfSpecFeatures grf_features{}; 
  PriceMultipliers price_base_multipliers{}; 
 
  GRFFile(const GRFConfig &config);
  GRFFile();
  GRFFile(GRFFile &&other);
  ~GRFFile();

  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 class ShoreReplacement : uint8_t {
  None, 
  Action5, 
  ActionA, 
  OnlyNew, 
};

enum class TramDepotReplacement : uint8_t {
  None, 
  WithTrack, 
  WithoutTrack, 
};

struct GRFLoadedFeatures {
  bool has_2CC; 
  LiverySchemes used_liveries; 
  ShoreReplacement shore; 
  TramDepotReplacement tram; 
};

struct PriceBaseSpec {
  Money start_price; 
  PriceCategory category; 
  GrfSpecFeature grf_feature; 
  Price fallback_price; 
};

inline bool HasGrfMiscBit(GrfMiscBit bit)
{
  extern GrfMiscBits _misc_grf_features;
  return _misc_grf_features.Test(bit);
}
 
/* Indicates which are the newgrf features currently loaded ingame */
extern GRFLoadedFeatures _loaded_newgrf_features;
 
void LoadNewGRFFile(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(Severity severity, const std::string &msg);
#define GrfMsg(severity, format_string, ...) do { if ((severity) == Severity::Critical || IsVisibleSeverity(Facility::Grf, (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(GrfID grfid, GRFStringID str);
void ShowNewGRFError();
 
GrfSpecFeature GetGrfSpecFeature(VehicleType type);
VehicleType GetVehicleType(GrfSpecFeature feature);

template <typename T> requires std::is_base_of_v<BaseLabel, T>
constexpr uint32_t FlattenNewGRFLabel(T label) { return label[0] | label[1] << 8 | label[2] << 16 | label[3] << 24; }

template <typename T> requires std::is_base_of_v<BaseLabel, T>
constexpr T UnflattenNewGRFLabel(uint32_t value)
{
  uint8_t buf[]{
    static_cast<uint8_t>(GB(value, 0, 8)),
    static_cast<uint8_t>(GB(value, 8, 8)),
    static_cast<uint8_t>(GB(value, 16, 8)),
    static_cast<uint8_t>(GB(value, 24, 8))
  };
  return buf;
}
 
#endif /* NEWGRF_H */