saveload.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 SAVELOAD_H
#define SAVELOAD_H
 
#include "saveload_type.h"
#include "saveload_error.hpp"
#include "saveload_func.h"
#include "../core/label_type.hpp"
#include "../cargopacket.h"
#include "../fileio_type.h"
#include "../fios.h"
#include "../linkgraph/linkgraph.h"
#include "../linkgraph/linkgraphjob.h"

enum class SaveLoadVersion : uint16_t {
  MinVersion, 
 
  BigCurrency, 
  VehicleCurrencyStationChanges, 
  BiggerStationVariables, 
  TownTolerancePauseMode, 
 
  BigMap, 
  MultipleRoadStops, 
  LargerCargoSource, 
  LargerUnitNumber, 
  LargerTownCargoStatistics, 
 
  LargerTownCounter, 
  LargerTownIterator, 
  LinkWaypointToTown, 
  LargerAIStateCounter, 
  TransferOrder, 
 
  MoveSemaphoreBits, 
  EngineRenew, 
  StoreWaypointIdInMap, 
  RemoveMinorVersion, 
  EngineRenewPool, 
 
  NoMultiheadReference, 
  RemoveOldPbs, 
  SavePatches, 
  RemoveAutosaveInterval, 
  Elrail, 
 
  ImproveMultistop, 
  LastVehicleType, 
  NewGRFStations, 
  Yapf, 
  MoreUnderBridges, 
 
  Tgp, 
  BigDates, 
  LinkFarmFieldToIndustry, 
  SaveYapfSettings, 
  Liveries, 
 
  LiveryRefit, 
  RefitOrders, 
  Utf8, 
  DisableElrailSetting, 
  FreightWeight, 
 
  GradualLoading, 
  NewGRFSettings, 
  BridgeWormhole, 
  UnifyAnimationState, 
  CargoSourceTile, 
 
  CountPaidForCargo, 
  MoreAirportBlocks, 
  DriveThroughRoadStops, 
  RailTrackTypeUnification, 
  SimplifyPlayerFace, 
 
  AircraftSpeedHolding, 
  FeederShare, 
  StatueOwner, 
  NewGRFHouses, 
  TownGrowthControl, 
 
  NewGRFCargo, 
  Cities, 
  FifoLoading, 
  VeryLowTownIndustryNumber, 
  TownLayout, 
 
  VehicleGroups, 
  MultipleRoadTypes, 
  AdjacentStations, 
  TramLivery, 
  MultipleSignalTypes, 
 
  UnifyCurrency, 
  NewGRFTownNames, 
  Timetables, 
  CargoPackets, 
  MoreCargoPackets, 
 
  CargoPaymentOverflow, 
  UngroupedVehicles, 
  SplitStationTypeFromGfxid, 
  NewGRFIndustryLayout, 
  FixStationPickupAccounting, 
 
  Autoslope, 
  NewGRFPersistentStorage, 
  CleanupUnconnectedRoads, 
  StoreIndustryCargo, 
  FairPlaySettings, 
 
  NewGRFMoreAnimation, 
  FixTreeGround, 
  NewGRFIndustryRandomTriggers, 
  DepotWaterOwners, 
  ReplaceCustomNameArray, 
 
  MaglevMonorailPaxWagonLivery, 
  WaterClass, 
  SimplifyPathfinderSettings, 
  FractionProfitRunningTicks, 
  MoreWaypointsPerTown, 
 
  PlaneSpeedFactor, 
  MoreHouseAnimationFrames, 
  RemoveHouseCount, 
  ImprovedOrders, 
  FixCompanyCargoTypes, 
 
  MoreEngineTypes, 
  AirportNoise, 
  MergeOptsPats, 
  Gamelog, 
  IndustryTileWaterClass, 
 
  Yapp, 
  NewGRFPalette, 
  SpreadIndustryProductionChanges, 
  NewGRFSuppliedStationName, 
  MoreCompanies, 
 
  OrderList, 
  DistantStationJoining, 
  NoAI, 
  StoreAIVersion, 
  NextCompetitorStartOverflow, 
 
  RemoveOldAISettings, 
  FreeformEdges, 
  SplitHQ, 
  RoadLayoutPerTown, 
  SeparateRoadOwners, 
 
  CustomTownNumber, 
  GamelogEmergency, 
  PlatformStopLocation, 
  DigitGroupSeparator, 
  PauseModes, 
 
  CompanyServiceIntervals, 
  CargoPayments, 
  WaypointMoreLikeStation, 
  UnifyWaypointAndStation, 
  MultiTileWaypoints, 
 
  RemoveSubsidyStationBinding, 
  CumulatedInflation, 
  TownAcceptance, 
  FoundTown, 
  TimetableStart, 
 
  RoadStopOccupancyPenalty, 
  MaximumDepotPenalty, 
  DisallowTreeBuilding, 
  TrainSlopeSteepness, 
  VirtualFeederSharePayment, 
 
  RocksStayUnderSnow, 
  SplitLoadWaitCounters, 
  AirportAnimationFrames, 
  ReducePlaneCrashes, 
  RvRealisticAcceleration, 
 
  StoreAirportSize, 
  UniqueDepotNames, 
  NewGRFDepotBuildDate, 
  DisableTownLevelCrossing, 
  ReorderUnmovableRemoveReserved, 
 
  NewGRFAirportSmoke, 
  UnifyWaterClass, 
  UnifyAnimationFrame, 
  IndustryPlatform, 
  CustomSeaLevel, 
 
  FractionalCargoDelivery, 
  StoreNewGRFVersion, 
  IndustryManagement, 
  LeaveRoadStopSeparately, 
  PauseLevel, 
 
  NewGRFObjectView, 
  TerraformLimits, 
  UnifyGroundVehicles, 
  TrackRealAndAutoOrders, 
  MaxLengthAndReverseSignals, 
 
  DisallowRoadReconstruction, 
  PersistentStoragePool, 
  NewGRFCustomCargoAging, 
  Rivers, 
  VehicleCentreAndZPos, 
 
  ScriptTownGrowth, 
  InfrastructureMaintenanceCosts, 
  NewGRFAircraftRange, 
  ScriptTownText, 
  MoveSccEncoded, 
 
  CountIndividualCargoes, 
  ScenarioDeitySigns, 
  OrderMaxSpeed, 
  FixRoadOwnership, 
  CurrentOrderMaxSpeed, 
 
  AutoreplaceWhenOldTreeLimit, 
  BackupOrderState, 
  MonthlyBankruptcyCheck, 
  ScriptSettingsProfile, 
  RobustEnginePreview, 
 
  ServiceIntervalPercent, 
  CargoReservation, 
  GoalProgressPlaneAcceleration, 
  Cargodist, 
  SeparateLocaleUnits, 
 
  Storybooks, 
  ObjectTypeToPool, 
  LinkgraphRestrictedFlow, 
  UnifyRvTravelTime, 
  GroupHierarchy, 
 
  SeparateOrderTravelWaitTime, 
  LinkgraphLocationDisasterStore, 
  FixOrderBackup, 
  HideEnginesForCompany, 
  MaxBridgeMapHeight, 
 
  Distinguish16, 
  Distinguish17, 
  StoreMapVariety, 
  TownGrowthInGameTicks, 
  ExtendCargotypes, 
 
  ExtendRailtypes, 
  ExtendPersistentStorage, 
  ExtendIndustryCargoSlots, 
  ShipPathCache, 
  ShipRotation, 
 
  GroupLiveries, 
  ShipsStopInLocks, 
  FixCargoMonitor, 
  TownCargogen, 
  ShipCurvePenalty, 
 
  ServeNeutralIndustries, 
  RoadvehPathCache, 
  RemoveOldPathfinder, 
  TreesWaterClass, 
  RoadTypes, 
 
  ScriptMemlimit, 
  MultitileDocks, 
  TradingAge, 
  EndingYear, 
  RemoveTownCargoCache, 
 
  /* Patchpacks for a while considered it a good idea to jump a few versions
   * above our version for their savegames. But as time continued, this gap
   * has been closing, up to the point we would start to reuse versions from
   * their patchpacks. This is not a problem from our perspective: the
   * savegame will simply fail to load because they all contain chunks we
   * cannot digest. But, this gives for ugly errors. As we have plenty of
   * versions anyway, we simply skip the versions we know belong to
   * patchpacks. This way we can present the user with a clean error
   * indicate they are loading a savegame from a patchpack.
   * For future patchpack creators: please follow a system like JGRPP, where
   * the version is masked with 0x8000, and the true version is stored in
   * its own chunk with feature toggles.
   */
  StartPatchpacks, 
  EndPatchpacks = 286, 
 
  GSIndustryControl, 
  VehMotionCounter, 
  IndustryText, 
 
  MapgenSettingsRevamp, 
  GroupReplaceWagonRemoval, 
  CustomSubsidyDuration, 
  SaveloadListLength, 
  RiffToArray, 
 
  TableChunks, 
  ScriptInt64, 
  LinkgraphTravelTime, 
  DockDockingtiles, 
  RepairObjectDockingTiles, 
 
  U64TickCounter, 
  LastLoadingTick, 
  MultitrackLevelCrossings, 
  NewGRFRoadStops, 
  LinkgraphEdges, 
 
  VelocityNautical, 
  ConsistentPartialZ, 
  MoreCargoAge, 
  LinkgraphSeconds, 
  AIStartDate, 
 
  ExtendVehicleRandom, 
  ExtendEntityMapping, 
  DisasterVehState, 
  SavegameId, 
  StringGamelog, 
 
  IndustryCargoReorganise, 
  PeriodsInTransitRename, 
  NewGRFLastService, 
  RemoveLoadedAtXY, 
  CargoTravelled, 
 
  StationRatingCheat, 
  TimetableStartTicks, 
  TimetableStartTicksFix, 
  TimetableTicksType, 
  WaterRegions, 
 
  WaterRegionEvalSimplified, 
  EconomyDate, 
  EconomyModeTimekeepingUnits, 
  CalendarSubDateFract, 
  ShipAcceleration, 
 
  MaxLoanForCompany, 
  DepotUnbunching, 
  AILocalConfig, 
  ScriptRandomizer, 
  VehicleEconomyAge, 
 
  CompanyAllowList, 
  GroupNumbers, 
  IncreaseStationTypeFieldSize, 
  RoadWaypoints, 
  CompanyInauguratedPeriod, 
 
  RoadStopTileData, 
  CompanyAllowListV2, 
  WaterTileType, 
  ProductionHistory, 
  RoadTypeLabelMap, 
 
  NonfloodingWaterTiles, 
  PathCacheFormat, 
  AnimatedTileStateInMap, 
  IncreaseHouseLimit, 
  CompanyInauguratedPeriodV2, 
 
  EncodedStringFormat, 
  ProtectPlacedHouses, 
  ScriptSaveInstances, 
  FixSccEncodedNegative, 
  OrdersOwnedByOrderlist, 
 
  FaceStyles, 
  IndustryNumValidHistory, 
  IndustryAcceptedHistory, 
  TownSupplyHistory, 
  StationsUnderBridges, 
 
  DocksUnderBridges, 
  LocksUnderBridges, 
  EngineMultiRailtype, 
  SignTextColours, 
  BuoysAt0_0, 
 
  DriveBackwards, 
  DepotsUnderBridges, 
  LabelOrientationUnification, 
  DoubleEndedShips, 
 
  MaxVersion, 
};

enum SavegameType : uint8_t {
  TTD, 
  TTDP1, 
  TTDP2, 
  OTTD, 
  TTO, 
  Invalid = 0xFF, 
};
void SetSaveLoadError(StringID str);
 
typedef void AutolengthProc(int);

enum class ChunkType : uint8_t {
  Riff = 0, 
  Array = 1, 
  SparseArray = 2, 
  Table = 3, 
  SparseTable = 4, 
 
  FileTypeMask = 0xf, 
  ReadOnly, 
};

using ChunkId = Label<struct ChunkIdTag>;;

struct ChunkHandler {
  ChunkId id; 
  ChunkType type; 

  ChunkHandler(ChunkId id, ChunkType type) : id(id), type(type) {}

  virtual ~ChunkHandler() = default;

  virtual void Save() const { NOT_REACHED(); }

  virtual void Load() const = 0;

  virtual void FixPointers() const {}

  virtual void LoadCheck(size_t len = 0) const;

  std::string GetName() const
  {
    return this->id.AsString();
  }
};

using ChunkHandlerRef = std::reference_wrapper<const ChunkHandler>;

using ChunkHandlerTable = std::span<const ChunkHandlerRef>;

using SaveLoadCompatTable = std::span<const struct SaveLoadCompat>;

class SaveLoadHandler {
public:
  std::optional<std::vector<SaveLoad>> load_description; 

  virtual ~SaveLoadHandler() = default;

  virtual void Save([[maybe_unused]] void *object) const {}

  virtual void Load([[maybe_unused]] void *object) const {}

  virtual void LoadCheck([[maybe_unused]] void *object) const {}

  virtual void FixPointers([[maybe_unused]] void *object) const {}

  virtual SaveLoadTable GetDescription() const = 0;

  virtual SaveLoadCompatTable GetCompatDescription() const = 0;

  SaveLoadTable GetLoadDescription() const;
};

template <class TImpl, class TObject>
class DefaultSaveLoadHandler : public SaveLoadHandler {
public:
  SaveLoadTable GetDescription() const override { return static_cast<const TImpl *>(this)->description; }
 
  SaveLoadCompatTable GetCompatDescription() const override { return static_cast<const TImpl *>(this)->compat_description; }

  virtual void Save([[maybe_unused]] TObject *object) const {}
  void Save(void *object) const override { this->Save(static_cast<TObject *>(object)); }

  virtual void Load([[maybe_unused]] TObject *object) const {}
  void Load(void *object) const override { this->Load(static_cast<TObject *>(object)); }

  virtual void LoadCheck([[maybe_unused]] TObject *object) const {}
  void LoadCheck(void *object) const override { this->LoadCheck(static_cast<TObject *>(object)); }

  virtual void FixPointers([[maybe_unused]] TObject *object) const {}
  void FixPointers(void *object) const override { this->FixPointers(static_cast<TObject *>(object)); }
};

enum class SLRefType : uint8_t {
  Vehicle = 1, 
  Station = 2, 
  Town = 3, 
  OldVehicle = 4, 
  RoadStop = 5, 
  EngineRenew = 6, 
  CargoPacket = 7, 
  OrderList = 8, 
  Storage = 9, 
  LinkGraph = 10, 
  LinkGraphJob = 11, 
};

enum class VarFileType : uint8_t {
  /* 4 bits allocated a maximum of 16 types for NumberType.
   * NOTE: the SLE_FILE_NNN values are stored in the savegame! */
  /* Value 0 is used to mark end-of-header in tables. Do not use here! */
  I8 = 1, 
  Bool = I8, 
  U8 = 2, 
  I16 = 3, 
  U16 = 4, 
  I32 = 5, 
  U32 = 6, 
  Label = U32, 
  I64 = 7, 
  U64 = 8, 
  StringID = 9, 
  String = 10, 
  Struct = 11, 
  /* 4 more possible file-primitives */
};

enum class VarMemType : uint8_t {
  Bool = 0, 
  I8 = 1, 
  U8 = 2, 
  I16 = 3, 
  U16 = 4, 
  I32 = 5, 
  U32 = 6, 
  I64 = 7, 
  U64 = 8, 
  Null = 9, 
  Str = 12, 
  Name = 14, 
  Label = 15, 
};

struct VarType {
  VarFileType file{}; 
  VarMemType mem{}; 
  StringValidationSettings string_validation_settings{}; 
  SLRefType ref{}; 

  constexpr VarType() {}

  constexpr VarType(VarFileType file, VarMemType mem) : file(file), mem(mem) {}

  constexpr VarType(StringValidationSettings string_validation_settings) :
    file(VarFileType::String), mem(VarMemType::Str), string_validation_settings(string_validation_settings) {}

  constexpr VarType(SLRefType ref) : ref(ref) {}

  constexpr bool operator==(const VarType &other) const = default;
};

struct VarTypes {
  static constexpr VarType BOOL{ VarFileType::Bool, VarMemType::Bool }; 
  static constexpr VarType I8{ VarFileType::I8, VarMemType::I8 }; 
  static constexpr VarType U8{ VarFileType::U8, VarMemType::U8 }; 
  static constexpr VarType I16{ VarFileType::I16, VarMemType::I16 }; 
  static constexpr VarType U16{ VarFileType::U16, VarMemType::U16 }; 
  static constexpr VarType I32{ VarFileType::I32, VarMemType::I32 }; 
  static constexpr VarType U32{ VarFileType::U32, VarMemType::U32 }; 
  static constexpr VarType I64{ VarFileType::I64, VarMemType::I64 }; 
  static constexpr VarType U64{ VarFileType::U64, VarMemType::U64 }; 
  static constexpr VarType STRINGID{ VarFileType::StringID, VarMemType::U32 }; 
  static constexpr VarType STR{ VarFileType::String, VarMemType::Str }; 
  static constexpr VarType NAME{ VarFileType::StringID, VarMemType::Name }; 
  static constexpr VarType LABEL{ VarFileType::U32, VarMemType::Label }; 
};

enum class SaveLoadType : uint8_t {
  Variable = 0, 
  Reference = 1, 
  Struct = 2, 
 
  String = 4, 
 
  Array = 5, 
  Vector = 7, 
  ReferenceList = 8, 
  StructList = 9, 
 
  SaveByte = 10, 
  Null = 11, 
 
  ReferenceVector = 12, 
};

#define SLE_OBJECT_ADDRESS(base, variable) +[] (const void *b, size_t) -> const auto * { return std::addressof(static_cast<const base *>(b)->variable); }

#define SLE_GLOBAL_ADDRESS(variable) +[] (const void *, size_t) -> const auto * { return std::addressof(variable); }

struct SaveLoad {
  template <typename R = void>
  using AddressFunction = const R *(*)(const void *base, size_t extra);
 
  std::string name; 
  SaveLoadType cmd; 
  VarType conv{}; 
  uint16_t length{}; 
  SaveLoadVersion version_from; 
  SaveLoadVersion version_to; 
  AddressFunction<> address_func = nullptr; 
  size_t extra_data = 0; 
  std::shared_ptr<SaveLoadHandler> handler{}; 

  static constexpr bool IsIntegralFileType(VarFileType file_type)
  {
    switch (file_type) {
      case VarFileType::I8:
      case VarFileType::U8:
      case VarFileType::I16:
      case VarFileType::U16:
      case VarFileType::I32:
      case VarFileType::U32:
      case VarFileType::I64:
      case VarFileType::U64:
        return true;
 
      default:
        return false;
    }
  }

  template <typename T, VarFileType file_type>
  static constexpr VarMemType DetermineMemType()
  {
    if constexpr (std::is_base_of_v<BaseLabel, T>) {
      static_assert(file_type == VarFileType::Label);
      return VarMemType::Label;
    } else if constexpr (std::is_same_v<StringID, T>) {
      static_assert(file_type == VarFileType::StringID);
      static_assert(sizeof(T) == sizeof(uint32_t));
      return VarMemType::U32;
    } else if constexpr (std::is_same_v<bool, T>) {
      static_assert(file_type == VarFileType::Bool);
      return VarMemType::Bool;
    } else if constexpr (std::is_same_v<int8_t, T>) {
      static_assert(IsIntegralFileType(file_type));
      return VarMemType::I8;
    } else if constexpr (std::is_same_v<uint8_t, T> || std::is_same_v<char, T>) {
      static_assert(IsIntegralFileType(file_type));
      return VarMemType::U8;
    } else if constexpr (std::is_same_v<int16_t, T>) {
      static_assert(IsIntegralFileType(file_type));
      return VarMemType::I16;
    } else if constexpr (std::is_same_v<uint16_t, T>) {
      static_assert(IsIntegralFileType(file_type));
      return VarMemType::U16;
    } else if constexpr (std::is_same_v<int32_t, T>) {
      static_assert(IsIntegralFileType(file_type));
      return VarMemType::I32;
    } else if constexpr (std::is_same_v<uint32_t, T>) {
      static_assert(IsIntegralFileType(file_type));
      return VarMemType::U32;
    } else if constexpr (std::is_same_v<int64_t, T>) {
      static_assert(IsIntegralFileType(file_type));
      return VarMemType::I64;
    } else if constexpr (std::is_same_v<uint64_t, T>) {
      static_assert(IsIntegralFileType(file_type));
      return VarMemType::U64;
    } else if constexpr (std::is_same_v<std::string, T>) {
      if constexpr (file_type == VarFileType::StringID) {
        return VarMemType::Name; // Special transitional case for migrating from StringID to std::string.
      } else {
        static_assert(file_type == VarFileType::String);
        return VarMemType::Str;
      }
    } else if constexpr (std::is_enum_v<T>) {
      return DetermineMemType<std::underlying_type_t<T>, file_type>();
    } else if constexpr (requires { typename T::value_type; }) {
      return DetermineMemType<typename T::value_type, file_type>();
    } else {
      /* If in the following assert bare false is used the compilation fails on gcc 12.2.0. */
      static_assert(ConvertibleThroughBase<T>, "The given type is not supported");
      return DetermineMemType<typename T::BaseType, file_type>();
    }
  }

  template <typename T>
  static constexpr bool IsValidRefType(SLRefType ref_type)
  {
    switch (ref_type) {
      case SLRefType::OldVehicle: // Old vehicles we save as new ones
      case SLRefType::Vehicle: return std::is_base_of_v<Vehicle, T>;
      case SLRefType::Station: return std::is_base_of_v<BaseStation, T>;
      case SLRefType::Town: return std::is_same_v<Town, T>;
      case SLRefType::RoadStop: return std::is_same_v<RoadStop, T>;
      case SLRefType::EngineRenew: return std::is_same_v<EngineRenew, T>;
      case SLRefType::CargoPacket: return std::is_same_v<CargoPacket, T>;
      case SLRefType::OrderList: return std::is_same_v<OrderList, T>;
      case SLRefType::Storage: return std::is_same_v<PersistentStorage, T>;
      case SLRefType::LinkGraph: return std::is_same_v<LinkGraph, T>;
      case SLRefType::LinkGraphJob: return std::is_same_v<LinkGraphJob, T>;
      default: NOT_REACHED(); // Add a check for the new reference type above here.
    }
  }

  template <typename T>
  static constexpr AddressFunction<> ToAddressFunction(AddressFunction<T> address_func)
  {
    /* The reinterpret_cast is nasty, but we are only casting away the type of the return. */
    static_assert(std::is_same_v<AddressFunction<>, decltype(ToAddressFunction<void>(nullptr))>);
    return reinterpret_cast<AddressFunction<>>(address_func);
  }
 

  template <VarFileType file_type, typename T>
  static SaveLoad Variable(std::string name, AddressFunction<T> address_func,
      SaveLoadVersion from = SaveLoadVersion::MinVersion, SaveLoadVersion to = SaveLoadVersion::MaxVersion, size_t extra = 0)
  {
    return SaveLoad{
      .name = std::move(name),
      .cmd = SaveLoadType::Variable,
      .conv = {file_type, DetermineMemType<T, file_type>()},
      .version_from = from,
      .version_to = to,
      .address_func = ToAddressFunction(address_func),
      .extra_data = extra,
    };
  }

  template <SLRefType type, typename T>
  static SaveLoad Reference(std::string name, AddressFunction<T> address_func,
      SaveLoadVersion from = SaveLoadVersion::MinVersion, SaveLoadVersion to = SaveLoadVersion::MaxVersion)
  {
    static_assert(requires { typename std::remove_pointer_t<T>::Pool; });
    return SaveLoad{
      .name = std::move(name),
      .cmd = SaveLoadType::Reference,
      .conv = type,
      .version_from = from,
      .version_to = to,
      .address_func = ToAddressFunction(address_func),
    };
  }

  template <typename T>
  static SaveLoad String(std::string name, AddressFunction<T> address_func, StringValidationSettings string_validation_settings = {},
      SaveLoadVersion from = SaveLoadVersion::MinVersion, SaveLoadVersion to = SaveLoadVersion::MaxVersion, size_t extra = 0)
  {
    static_assert(std::is_same_v<std::string, T> || std::is_same_v<EncodedString, T>);
    return SaveLoad{
      .name = std::move(name),
      .cmd = SaveLoadType::String,
      .conv = string_validation_settings,
      .version_from = from,
      .version_to = to,
      .address_func = ToAddressFunction(address_func),
      .extra_data = extra,
    };
  }

  template <typename T> requires std::is_base_of_v<SaveLoadHandler, T>
  static SaveLoad Struct(std::string name,
      SaveLoadVersion from = SaveLoadVersion::MinVersion, SaveLoadVersion to = SaveLoadVersion::MaxVersion)
  {
    return SaveLoad{
      .name = std::move(name),
      .cmd = SaveLoadType::Struct,
      .version_from = from,
      .version_to = to,
      .handler = std::make_shared<T>(),
    };
  }

  template <VarFileType file_type, uint16_t length, typename T>
  static SaveLoad Array(std::string name, AddressFunction<T> address_func,
      SaveLoadVersion from = SaveLoadVersion::MinVersion, SaveLoadVersion to = SaveLoadVersion::MaxVersion, size_t extra = 0)
  {
    static_assert(SlVarSize(DetermineMemType<T, file_type>()) * length <= sizeof(T)); // Partial setting/filling of an array is permitted.
    return SaveLoad{
      .name = std::move(name),
      .cmd = SaveLoadType::Array,
      .conv = {file_type, DetermineMemType<T, file_type>()},
      .length = length,
      .version_from = from,
      .version_to = to,
      .address_func = ToAddressFunction(address_func),
      .extra_data = extra,
    };
  }

  template <VarFileType file_type, typename T>
  static SaveLoad Vector(std::string name, AddressFunction<T> address_func,
      SaveLoadVersion from = SaveLoadVersion::MinVersion, SaveLoadVersion to = SaveLoadVersion::MaxVersion)
  {
    static_assert(std::is_base_of_v<std::vector<typename T::value_type>, T>);
    return SaveLoad{
      .name = std::move(name),
      .cmd = SaveLoadType::Vector,
      .conv = {file_type, DetermineMemType<typename T::value_type, file_type>()},
      .version_from = from,
      .version_to = to,
      .address_func = ToAddressFunction(address_func),
    };
  }

  template <SLRefType type, typename T>
  static SaveLoad ReferenceList(std::string name, AddressFunction<T> address_func,
      SaveLoadVersion from = SaveLoadVersion::MinVersion, SaveLoadVersion to = SaveLoadVersion::MaxVersion)
  {
    static_assert(std::is_base_of_v<std::list<typename T::value_type>, T>);
    static_assert(requires { typename std::remove_pointer_t<typename T::value_type>::Pool; });
    static_assert(IsValidRefType<std::remove_pointer_t<typename T::value_type>>(type));
    return SaveLoad{
      .name = std::move(name),
      .cmd = SaveLoadType::ReferenceList,
      .conv = type,
      .version_from = from,
      .version_to = to,
      .address_func = ToAddressFunction(address_func),
    };
  }

  template <typename T> requires std::is_base_of_v<SaveLoadHandler, T>
  static SaveLoad StructList(std::string name,
      SaveLoadVersion from = SaveLoadVersion::MinVersion, SaveLoadVersion to = SaveLoadVersion::MaxVersion)
  {
    return SaveLoad{
      .name = std::move(name),
      .cmd = SaveLoadType::StructList,
      .version_from = from,
      .version_to = to,
      .handler = std::make_shared<T>(),
    };
  }

  template <typename T>
  static SaveLoad SaveByte(std::string name, AddressFunction<T> address_func,
      SaveLoadVersion from = SaveLoadVersion::MinVersion, SaveLoadVersion to = SaveLoadVersion::MaxVersion)
  {
    return SaveLoad{
      .name = std::move(name),
      .cmd = SaveLoadType::SaveByte,
      .conv = {VarFileType::U8, DetermineMemType<T, VarFileType::U8>()},
      .version_from = from,
      .version_to = to,
      .address_func = ToAddressFunction(address_func),
    };
  }

  template <SLRefType type, typename T>
  static SaveLoad ReferenceVector(std::string name, AddressFunction<T> address_func,
      SaveLoadVersion from = SaveLoadVersion::MinVersion, SaveLoadVersion to = SaveLoadVersion::MaxVersion)
  {
    static_assert(std::is_base_of_v<std::vector<typename T::value_type>, T>);
    static_assert(requires { typename std::remove_pointer_t<typename T::value_type>::Pool; });
    static_assert(IsValidRefType<std::remove_pointer_t<typename T::value_type>>(type));
    return SaveLoad{
      .name = std::move(name),
      .cmd = SaveLoadType::ReferenceVector,
      .conv = type,
      .version_from = from,
      .version_to = to,
      .address_func = ToAddressFunction(address_func),
    };
  }
};

struct SaveLoadCompat {
  std::string_view name; 
  uint16_t null_length; 
  SaveLoadVersion version_from; 
  SaveLoadVersion version_to; 
};

constexpr size_t SlVarSize(VarMemType type)
{
  switch (type) {
    case VarMemType::Bool: return sizeof(bool);
    case VarMemType::I8: return sizeof(int8_t);
    case VarMemType::U8: return sizeof(uint8_t);
    case VarMemType::I16: return sizeof(int16_t);
    case VarMemType::U16: return sizeof(uint16_t);
    case VarMemType::I32: return sizeof(int32_t);
    case VarMemType::U32: return sizeof(uint32_t);
    case VarMemType::I64: return sizeof(int64_t);
    case VarMemType::U64: return sizeof(uint64_t);
    case VarMemType::Null: return sizeof(void *);
    case VarMemType::Str: return sizeof(std::string);
    case VarMemType::Name: return sizeof(std::string);
    case VarMemType::Label: return sizeof(BaseLabel);
    default: NOT_REACHED();
  }
}

#define SLC_VAR(name) {name, 0, SaveLoadVersion::MinVersion, SaveLoadVersion::MaxVersion}

#define SLC_NULL(length, from, to) {{}, length, from, to}

inline bool IsSavegameVersionBefore(SaveLoadVersion major, uint8_t minor = 0)
{
  extern SaveLoadVersion _sl_version;
  extern uint8_t            _sl_minor_version;
  return _sl_version < major || (minor > 0 && _sl_version == major && _sl_minor_version < minor);
}

inline bool IsSavegameVersionBeforeOrAt(SaveLoadVersion major)
{
  extern SaveLoadVersion _sl_version;
  return _sl_version <= major;
}

inline bool SlIsObjectCurrentlyValid(SaveLoadVersion version_from, SaveLoadVersion version_to)
{
  extern const SaveLoadVersion SAVEGAME_VERSION;
  return version_from <= SAVEGAME_VERSION && SAVEGAME_VERSION < version_to;
}

inline void *GetVariableAddress(const void *object, const SaveLoad &sld)
{
  /* Entry is a null-variable, mostly used to read old savegames etc. */
  if (sld.conv.mem == VarMemType::Null) {
    assert(sld.address_func == nullptr);
    return nullptr;
  }
 
  /* Everything else should be a non-null pointer. */
  assert(sld.address_func != nullptr);
  return const_cast<void *>(sld.address_func(object, sld.extra_data));
}
 
int64_t ReadValue(const void *ptr, VarMemType conv);
void WriteValue(void *ptr, VarMemType conv, int64_t val);
 
void SlSetArrayIndex(uint index);
static void SlSetArrayIndex(const ConvertibleThroughBase auto &index) { SlSetArrayIndex(index.base()); }
int SlIterateArray();
 
void SlSetStructListLength(size_t length);
size_t SlGetStructListLength(size_t limit);
 
void SlAutolength(AutolengthProc *proc, int arg);
size_t SlGetFieldLength();
void SlSetLength(size_t length);
size_t SlCalcObjMemberLength(const void *object, const SaveLoad &sld);
size_t SlCalcObjLength(const void *object, const SaveLoadTable &slt);
 
uint8_t SlReadByte();
void SlReadString(std::string &str, size_t length);
void SlWriteByte(uint8_t b);
 
void SlGlobList(const SaveLoadTable &slt);
void SlCopy(void *object, size_t length, VarType conv);
std::vector<SaveLoad> SlTableHeader(const SaveLoadTable &slt);
std::vector<SaveLoad> SlCompatTableHeader(const SaveLoadTable &slt, const SaveLoadCompatTable &slct);
void SlObject(void *object, const SaveLoadTable &slt);

template <VarFileType file_type, typename T>
static inline void SlCopy(T &collection)
{
  std::span span{collection}; // Let std::span worry about what is passed being a contiguous container.
  SlCopy(span.data(), span.size(), {file_type, SaveLoad::DetermineMemType<std::remove_const_t<typename T::value_type>, file_type>()});
}

inline void SlSkipBytes(size_t length)
{
  for (; length != 0; length--) SlReadByte();
}

template <class TImpl, class TObject, class TElementType, size_t MAX_LENGTH = UINT32_MAX>
class VectorSaveLoadHandler : public DefaultSaveLoadHandler<TImpl, TObject> {
public:
  virtual std::vector<TElementType> &GetVector(TObject *object) const = 0;

  virtual size_t GetLength() const { return SlGetStructListLength(MAX_LENGTH); }
 
  void Save(TObject *object) const override
  {
    auto &vector = this->GetVector(object);
    SlSetStructListLength(vector.size());
 
    for (auto &item : vector) {
      SlObject(&item, this->GetDescription());
    }
  }
 
  void Load(TObject *object) const override
  {
    auto &vector = this->GetVector(object);
    size_t count = this->GetLength();
 
    vector.reserve(count);
    while (count-- > 0) {
      auto &item = vector.emplace_back();
      SlObject(&item, this->GetLoadDescription());
    }
  }
};
 
#endif /* SAVELOAD_H */