Changeset - r25773:457e167f3c9e
src/order_backup.h
Show inline comments
 
@@ -36,7 +36,7 @@ static const uint32 MAKE_ORDER_BACKUP_FL
 
struct OrderBackup : OrderBackupPool::PoolItem<&_order_backup_pool>, BaseConsist {
 
private:
 
	friend SaveLoadTable GetOrderBackupDescription(); ///< Saving and loading of order backups.
 
	friend void Load_BKOR();   ///< Creating empty orders upon savegame loading.
 
	friend struct BKORChunkHandler; ///< Creating empty orders upon savegame loading.
 
	uint32 user;               ///< The user that requested the backup.
 
	TileIndex tile;            ///< Tile of the depot where the order was changed.
 
	GroupID group;             ///< The group the vehicle was part of.
src/order_base.h
Show inline comments
 
@@ -32,7 +32,7 @@ extern OrderListPool _orderlist_pool;
 
 */
 
struct Order : OrderPool::PoolItem<&_order_pool> {
 
private:
 
	friend void Load_VEHS();                                             ///< Loading of ancient vehicles.
 
	friend struct VEHSChunkHandler;                             ///< Loading of ancient vehicles.
 
	friend SaveLoadTable GetOrderDescription();                 ///< Saving and loading of orders.
 
	/* So we can use private/protected variables in the saveload code */
 
	friend class SlVehicleCommon;
src/saveload/ai_sl.cpp
Show inline comments
 
@@ -57,7 +57,10 @@ static void SaveReal_AIPL(int *index_ptr
 
	if (Company::IsValidAiID(index)) AI::Save(index);
 
}
 

	
 
static void Load_AIPL()
 
struct AIPLChunkHandler : ChunkHandler {
 
	AIPLChunkHandler() : ChunkHandler('AIPL', CH_TABLE) {}
 

	
 
	void Load() const override
 
{
 
	const std::vector<SaveLoad> slt = SlCompatTableHeader(_ai_company_desc, _ai_company_sl_compat);
 

	
 
@@ -117,7 +120,7 @@ static void Load_AIPL()
 
	}
 
}
 

	
 
static void Save_AIPL()
 
	void Save() const override
 
{
 
	SlTableHeader(_ai_company_desc);
 

	
 
@@ -126,8 +129,9 @@ static void Save_AIPL()
 
		SlAutolength((AutolengthProc *)SaveReal_AIPL, &i);
 
	}
 
}
 
};
 

	
 
static const ChunkHandler AIPL{ 'AIPL', Save_AIPL, Load_AIPL, nullptr, nullptr, CH_TABLE };
 
static const AIPLChunkHandler AIPL;
 
static const ChunkHandlerRef ai_chunk_handlers[] = {
 
	AIPL,
 
};
src/saveload/airport_sl.cpp
Show inline comments
 
@@ -14,28 +14,36 @@
 

	
 
#include "../safeguards.h"
 

	
 
static void Save_APID()
 
struct APIDChunkHandler : ChunkHandler {
 
	APIDChunkHandler() : ChunkHandler('APID', CH_TABLE) {}
 

	
 
	void Save() const override
 
{
 
	Save_NewGRFMapping(_airport_mngr);
 
}
 

	
 
static void Load_APID()
 
	void Load() const override
 
{
 
	Load_NewGRFMapping(_airport_mngr);
 
}
 
};
 

	
 
static void Save_ATID()
 
struct ATIDChunkHandler : ChunkHandler {
 
	ATIDChunkHandler() : ChunkHandler('ATID', CH_TABLE) {}
 

	
 
	void Save() const override
 
{
 
	Save_NewGRFMapping(_airporttile_mngr);
 
}
 

	
 
static void Load_ATID()
 
	void Load() const override
 
{
 
	Load_NewGRFMapping(_airporttile_mngr);
 
}
 
};
 

	
 
static const ChunkHandler ATID{ 'ATID', Save_ATID, Load_ATID, nullptr, nullptr, CH_TABLE };
 
static const ChunkHandler APID{ 'APID', Save_APID, Load_APID, nullptr, nullptr, CH_TABLE };
 
static const ATIDChunkHandler ATID;
 
static const APIDChunkHandler APID;
 
static const ChunkHandlerRef airport_chunk_handlers[] = {
 
	ATID,
 
	APID,
src/saveload/animated_tile_sl.cpp
Show inline comments
 
@@ -24,10 +24,10 @@ static const SaveLoad _animated_tile_des
 
	 SLEG_VECTOR("tiles", _animated_tiles, SLE_UINT32),
 
};
 

	
 
/**
 
 * Save the ANIT chunk.
 
 */
 
static void Save_ANIT()
 
struct ANITChunkHandler : ChunkHandler {
 
	ANITChunkHandler() : ChunkHandler('ANIT', CH_TABLE) {}
 

	
 
	void Save() const override
 
{
 
	SlTableHeader(_animated_tile_desc);
 

	
 
@@ -35,10 +35,7 @@ static void Save_ANIT()
 
	SlGlobList(_animated_tile_desc);
 
}
 

	
 
/**
 
 * Load the ANIT chunk; the chunk containing the animated tiles.
 
 */
 
static void Load_ANIT()
 
	void Load() const override
 
{
 
	/* Before version 80 we did NOT have a variable length animated tile table */
 
	if (IsSavegameVersionBefore(SLV_80)) {
 
@@ -67,8 +64,10 @@ static void Load_ANIT()
 
	SlGlobList(slt);
 
	if (SlIterateArray() != -1) SlErrorCorrupt("Too many ANIT entries");
 
}
 
};
 

	
 
static const ChunkHandler ANIT{ 'ANIT', Save_ANIT, Load_ANIT, nullptr, nullptr, CH_TABLE };
 

	
 
static const ANITChunkHandler ANIT;
 
static const ChunkHandlerRef animated_tile_chunk_handlers[] = {
 
	ANIT,
 
};
src/saveload/autoreplace_sl.cpp
Show inline comments
 
@@ -25,7 +25,13 @@ static const SaveLoad _engine_renew_desc
 
	SLE_CONDVAR(EngineRenew, replace_when_old, SLE_BOOL, SLV_175, SL_MAX_VERSION),
 
};
 

	
 
static void Save_ERNW()
 
struct ERNWChunkHandler : ChunkHandler {
 
	ERNWChunkHandler() : ChunkHandler('ERNW', CH_TABLE)
 
	{
 
		this->fix_pointers = true;
 
	}
 

	
 
	void Save() const override
 
{
 
	SlTableHeader(_engine_renew_desc);
 

	
 
@@ -35,7 +41,7 @@ static void Save_ERNW()
 
	}
 
}
 

	
 
static void Load_ERNW()
 
	void Load() const override
 
{
 
	const std::vector<SaveLoad> slt = SlCompatTableHeader(_engine_renew_desc, _engine_renew_sl_compat);
 

	
 
@@ -54,14 +60,15 @@ static void Load_ERNW()
 
	}
 
}
 

	
 
static void Ptrs_ERNW()
 
	void FixPointers() const override
 
{
 
	for (EngineRenew *er : EngineRenew::Iterate()) {
 
		SlObject(er, _engine_renew_desc);
 
	}
 
}
 
};
 

	
 
static const ChunkHandler ERNW{ 'ERNW', Save_ERNW, Load_ERNW, Ptrs_ERNW, nullptr, CH_TABLE };
 
static const ERNWChunkHandler ERNW;
 
static const ChunkHandlerRef autoreplace_chunk_handlers[] = {
 
	ERNW,
 
};
src/saveload/cargomonitor_sl.cpp
Show inline comments
 
@@ -43,8 +43,11 @@ static CargoMonitorID FixupCargoMonitor(
 
	return number;
 
}
 

	
 
/** Save the #_cargo_deliveries monitoring map. */
 
static void SaveDelivery()
 
/** #_cargo_deliveries monitoring map. */
 
struct CMDLChunkHandler : ChunkHandler {
 
	CMDLChunkHandler() : ChunkHandler('CMDL', CH_TABLE) {}
 

	
 
	void Save() const override
 
{
 
	SlTableHeader(_cargomonitor_pair_desc);
 

	
 
@@ -64,8 +67,7 @@ static void SaveDelivery()
 
	}
 
}
 

	
 
/** Load the #_cargo_deliveries monitoring map. */
 
static void LoadDelivery()
 
	void Load() const override
 
{
 
	const std::vector<SaveLoad> slt = SlCompatTableHeader(_cargomonitor_pair_desc, _cargomonitor_pair_sl_compat);
 

	
 
@@ -83,10 +85,13 @@ static void LoadDelivery()
 
		_cargo_deliveries.insert(p);
 
	}
 
}
 

	
 
};
 

	
 
/** Save the #_cargo_pickups monitoring map. */
 
static void SavePickup()
 
/** #_cargo_pickups monitoring map. */
 
struct CMPUChunkHandler : ChunkHandler {
 
	CMPUChunkHandler() : ChunkHandler('CMPU', CH_TABLE) {}
 

	
 
	void Save() const override
 
{
 
	SlTableHeader(_cargomonitor_pair_desc);
 

	
 
@@ -106,8 +111,7 @@ static void SavePickup()
 
	}
 
}
 

	
 
/** Load the #_cargo_pickups monitoring map. */
 
static void LoadPickup()
 
	void Load() const override
 
{
 
	const std::vector<SaveLoad> slt = SlCompatTableHeader(_cargomonitor_pair_desc, _cargomonitor_pair_sl_compat);
 

	
 
@@ -125,10 +129,11 @@ static void LoadPickup()
 
		_cargo_pickups.insert(p);
 
	}
 
}
 
};
 

	
 
/** Chunk definition of the cargomonitoring maps. */
 
static const ChunkHandler CMDL{ 'CMDL', SaveDelivery, LoadDelivery, nullptr, nullptr, CH_TABLE };
 
static const ChunkHandler CMPU{ 'CMPU', SavePickup,   LoadPickup,   nullptr, nullptr, CH_TABLE };
 
static const CMDLChunkHandler CMDL;
 
static const CMPUChunkHandler CMPU;
 
static const ChunkHandlerRef cargomonitor_chunk_handlers[] = {
 
	CMDL,
 
	CMPU,
src/saveload/cargopacket_sl.cpp
Show inline comments
 
@@ -100,10 +100,10 @@ SaveLoadTable GetCargoPacketDesc()
 
	return _cargopacket_desc;
 
}
 

	
 
/**
 
 * Save the cargo packets.
 
 */
 
static void Save_CAPA()
 
struct CAPAChunkHandler : ChunkHandler {
 
	CAPAChunkHandler() : ChunkHandler('CAPA', CH_TABLE) {}
 

	
 
	void Save() const override
 
{
 
	SlTableHeader(GetCargoPacketDesc());
 

	
 
@@ -113,10 +113,7 @@ static void Save_CAPA()
 
	}
 
}
 

	
 
/**
 
 * Load the cargo packets.
 
 */
 
static void Load_CAPA()
 
	void Load() const override
 
{
 
	const std::vector<SaveLoad> slt = SlCompatTableHeader(GetCargoPacketDesc(), _cargopacket_sl_compat);
 

	
 
@@ -127,8 +124,9 @@ static void Load_CAPA()
 
		SlObject(cp, slt);
 
	}
 
}
 
};
 

	
 
static const ChunkHandler CAPA{ 'CAPA', Save_CAPA, Load_CAPA, nullptr, nullptr, CH_TABLE };
 
static const CAPAChunkHandler CAPA;
 
static const ChunkHandlerRef cargopacket_chunk_handlers[] = {
 
	CAPA,
 
};
src/saveload/cheat_sl.cpp
Show inline comments
 
@@ -35,10 +35,11 @@ static const SaveLoad _cheats_desc[] = {
 
	SLE_VAR(Cheats, edit_max_hl.value, SLE_BOOL),
 
};
 

	
 
/**
 
 * Save the cheat values.
 
 */
 
static void Save_CHTS()
 

	
 
struct CHTSChunkHandler : ChunkHandler {
 
	CHTSChunkHandler() : ChunkHandler('CHTS', CH_TABLE) {}
 

	
 
	void Save() const override
 
{
 
	SlTableHeader(_cheats_desc);
 

	
 
@@ -46,10 +47,7 @@ static void Save_CHTS()
 
	SlObject(&_cheats, _cheats_desc);
 
}
 

	
 
/**
 
 * Load the cheat values.
 
 */
 
static void Load_CHTS()
 
	void Load() const override
 
{
 
	std::vector<SaveLoad> slt = SlCompatTableHeader(_cheats_desc, _cheats_sl_compat);
 

	
 
@@ -74,8 +72,9 @@ static void Load_CHTS()
 
	SlObject(&_cheats, slt);
 
	if (!IsSavegameVersionBefore(SLV_RIFF_TO_ARRAY) && SlIterateArray() != -1) SlErrorCorrupt("Too many CHTS entries");
 
}
 
};
 

	
 
static const ChunkHandler CHTS{ 'CHTS', Save_CHTS, Load_CHTS, nullptr, nullptr, CH_TABLE };
 
static const CHTSChunkHandler CHTS;
 
static const ChunkHandlerRef cheat_chunk_handlers[] = {
 
	CHTS,
 
};
src/saveload/company_sl.cpp
Show inline comments
 
@@ -497,7 +497,14 @@ static const SaveLoad _company_desc[] = 
 
	SLEG_CONDSTRUCTLIST("liveries", SlCompanyLiveries,                               SLV_34, SL_MAX_VERSION),
 
};
 

	
 
static void Save_PLYR()
 
struct PLYRChunkHandler : ChunkHandler {
 
	PLYRChunkHandler() : ChunkHandler('PLYR', CH_TABLE)
 
	{
 
		this->load_check = true;
 
		this->fix_pointers = true;
 
	}
 

	
 
	void Save() const override
 
{
 
	SlTableHeader(_company_desc);
 

	
 
@@ -507,7 +514,7 @@ static void Save_PLYR()
 
	}
 
}
 

	
 
static void Load_PLYR()
 
	void Load() const override
 
{
 
	const std::vector<SaveLoad> slt = SlCompatTableHeader(_company_desc, _company_sl_compat);
 

	
 
@@ -519,7 +526,8 @@ static void Load_PLYR()
 
	}
 
}
 

	
 
static void Check_PLYR()
 

	
 
	void LoadCheck(size_t) const override
 
{
 
	const std::vector<SaveLoad> slt = SlCompatTableHeader(_company_desc, _company_sl_compat);
 

	
 
@@ -550,14 +558,15 @@ static void Check_PLYR()
 
	}
 
}
 

	
 
static void Ptrs_PLYR()
 
	void FixPointers() const override
 
{
 
	for (Company *c : Company::Iterate()) {
 
		SlObject(c, _company_desc);
 
	}
 
}
 
};
 

	
 
static const ChunkHandler PLYR{ 'PLYR', Save_PLYR, Load_PLYR, Ptrs_PLYR, Check_PLYR, CH_TABLE };
 
static const PLYRChunkHandler PLYR;
 
static const ChunkHandlerRef company_chunk_handlers[] = {
 
	PLYR,
 
};
src/saveload/depot_sl.cpp
Show inline comments
 
@@ -29,7 +29,13 @@ static const SaveLoad _depot_desc[] = {
 
	 SLE_CONDVAR(Depot, build_date, SLE_INT32,                SLV_142, SL_MAX_VERSION),
 
};
 

	
 
static void Save_DEPT()
 
struct DEPTChunkHandler : ChunkHandler {
 
	DEPTChunkHandler() : ChunkHandler('DEPT', CH_TABLE)
 
	{
 
		this->fix_pointers = true;
 
	}
 

	
 
	void Save() const override
 
{
 
	SlTableHeader(_depot_desc);
 

	
 
@@ -39,7 +45,7 @@ static void Save_DEPT()
 
	}
 
}
 

	
 
static void Load_DEPT()
 
	void Load() const override
 
{
 
	const std::vector<SaveLoad> slt = SlCompatTableHeader(_depot_desc, _depot_sl_compat);
 

	
 
@@ -54,15 +60,16 @@ static void Load_DEPT()
 
	}
 
}
 

	
 
static void Ptrs_DEPT()
 
	void FixPointers() const override
 
{
 
	for (Depot *depot : Depot::Iterate()) {
 
		SlObject(depot, _depot_desc);
 
		if (IsSavegameVersionBefore(SLV_141)) depot->town = Town::Get((size_t)depot->town);
 
	}
 
}
 
};
 

	
 
static const ChunkHandler DEPT{ 'DEPT', Save_DEPT, Load_DEPT, Ptrs_DEPT, nullptr, CH_TABLE };
 
static const DEPTChunkHandler DEPT;
 
static const ChunkHandlerRef depot_chunk_handlers[] = {
 
	DEPT,
 
};
src/saveload/economy_sl.cpp
Show inline comments
 
@@ -18,22 +18,30 @@
 
#include "../safeguards.h"
 

	
 
/** Prices in pre 126 savegames */
 
static void Load_PRIC()
 
struct PRICChunkHandler : ChunkHandler {
 
	PRICChunkHandler() : ChunkHandler('PRIC', CH_READONLY) {}
 

	
 
	void Load() const override
 
{
 
	/* Old games store 49 base prices, very old games store them as int32 */
 
	int vt = IsSavegameVersionBefore(SLV_65) ? SLE_FILE_I32 : SLE_FILE_I64;
 
	SlCopy(nullptr, 49, vt | SLE_VAR_NULL);
 
	SlCopy(nullptr, 49, SLE_FILE_U16 | SLE_VAR_NULL);
 
}
 
};
 

	
 
/** Cargo payment rates in pre 126 savegames */
 
static void Load_CAPR()
 
struct CAPRChunkHandler : ChunkHandler {
 
	CAPRChunkHandler() : ChunkHandler('CAPR', CH_READONLY) {}
 

	
 
	void Load() const override
 
{
 
	uint num_cargo = IsSavegameVersionBefore(SLV_55) ? 12 : IsSavegameVersionBefore(SLV_EXTEND_CARGOTYPES) ? 32 : NUM_CARGO;
 
	int vt = IsSavegameVersionBefore(SLV_65) ? SLE_FILE_I32 : SLE_FILE_I64;
 
	SlCopy(nullptr, num_cargo, vt | SLE_VAR_NULL);
 
	SlCopy(nullptr, num_cargo, SLE_FILE_U16 | SLE_VAR_NULL);
 
}
 
};
 

	
 
static const SaveLoad _economy_desc[] = {
 
	SLE_CONDVAR(Economy, old_max_loan_unround,          SLE_FILE_I32 | SLE_VAR_I64,  SL_MIN_VERSION, SLV_65),
 
@@ -49,7 +57,10 @@ static const SaveLoad _economy_desc[] = 
 
};
 

	
 
/** Economy variables */
 
static void Save_ECMY()
 
struct ECMYChunkHandler : ChunkHandler {
 
	ECMYChunkHandler() : ChunkHandler('ECMY', CH_TABLE) {}
 

	
 
	void Save() const override
 
{
 
	SlTableHeader(_economy_desc);
 

	
 
@@ -57,8 +68,8 @@ static void Save_ECMY()
 
	SlObject(&_economy, _economy_desc);
 
}
 

	
 
/** Economy variables */
 
static void Load_ECMY()
 

	
 
	void Load() const override
 
{
 
	const std::vector<SaveLoad> slt = SlCompatTableHeader(_economy_desc, _economy_sl_compat);
 

	
 
@@ -68,6 +79,7 @@ static void Load_ECMY()
 

	
 
	StartupIndustryDailyChanges(IsSavegameVersionBefore(SLV_102));  // old savegames will need to be initialized
 
}
 
};
 

	
 
static const SaveLoad _cargopayment_desc[] = {
 
	    SLE_REF(CargoPayment, front,           REF_VEHICLE),
 
@@ -76,7 +88,13 @@ static const SaveLoad _cargopayment_desc
 
	SLE_CONDVAR(CargoPayment, visual_transfer, SLE_INT64, SLV_181, SL_MAX_VERSION),
 
};
 

	
 
static void Save_CAPY()
 
struct CAPYChunkHandler : ChunkHandler {
 
	CAPYChunkHandler() : ChunkHandler('CAPY', CH_TABLE)
 
	{
 
		this->fix_pointers = true;
 
	}
 

	
 
	void Save() const override
 
{
 
	SlTableHeader(_cargopayment_desc);
 

	
 
@@ -86,7 +104,7 @@ static void Save_CAPY()
 
	}
 
}
 

	
 
static void Load_CAPY()
 
	void Load() const override
 
{
 
	const std::vector<SaveLoad> slt = SlCompatTableHeader(_cargopayment_desc, _cargopayment_sl_compat);
 

	
 
@@ -98,17 +116,18 @@ static void Load_CAPY()
 
	}
 
}
 

	
 
static void Ptrs_CAPY()
 
	void FixPointers() const override
 
{
 
	for (CargoPayment *cp : CargoPayment::Iterate()) {
 
		SlObject(cp, _cargopayment_desc);
 
	}
 
}
 
};
 

	
 
static const ChunkHandler CAPY{ 'CAPY', Save_CAPY, Load_CAPY, Ptrs_CAPY, nullptr, CH_TABLE };
 
static const ChunkHandler PRIC{ 'PRIC', nullptr,   Load_PRIC, nullptr,   nullptr, CH_READONLY };
 
static const ChunkHandler CAPR{ 'CAPR', nullptr,   Load_CAPR, nullptr,   nullptr, CH_READONLY };
 
static const ChunkHandler ECMY{ 'ECMY', Save_ECMY, Load_ECMY, nullptr,   nullptr, CH_TABLE };
 
static const CAPYChunkHandler CAPY;
 
static const PRICChunkHandler PRIC;
 
static const CAPRChunkHandler CAPR;
 
static const ECMYChunkHandler ECMY;
 
static const ChunkHandlerRef economy_chunk_handlers[] = {
 
	CAPY,
 
	PRIC,
src/saveload/engine_sl.cpp
Show inline comments
 
@@ -80,7 +80,10 @@ Engine *GetTempDataEngine(EngineID index
 
	}
 
}
 

	
 
static void Save_ENGN()
 
struct ENGNChunkHandler : ChunkHandler {
 
	ENGNChunkHandler() : ChunkHandler('ENGN', CH_TABLE) {}
 

	
 
	void Save() const override
 
{
 
	SlTableHeader(_engine_desc);
 

	
 
@@ -90,7 +93,7 @@ static void Save_ENGN()
 
	}
 
}
 

	
 
static void Load_ENGN()
 
	void Load() const override
 
{
 
	const std::vector<SaveLoad> slt = SlCompatTableHeader(_engine_desc, _engine_sl_compat);
 

	
 
@@ -111,6 +114,7 @@ static void Load_ENGN()
 
		}
 
	}
 
}
 
};
 

	
 
/**
 
 * Copy data from temporary engine array into the real engine pool.
 
@@ -152,7 +156,10 @@ void ResetTempEngineData()
 
	_temp_engine.clear();
 
}
 

	
 
static void Load_ENGS()
 
struct ENGSChunkHandler : ChunkHandler {
 
	ENGSChunkHandler() : ChunkHandler('ENGS', CH_READONLY) {}
 

	
 
	void Load() const override
 
{
 
	/* Load old separate String ID list into a temporary array. This
 
	 * was always 256 entries. */
 
@@ -166,6 +173,7 @@ static void Load_ENGS()
 
		e->name = CopyFromOldName(names[engine]);
 
	}
 
}
 
};
 

	
 
/** Save and load the mapping between the engine id in the pool, and the grf file it came from. */
 
static const SaveLoad _engine_id_mapping_desc[] = {
 
@@ -175,7 +183,10 @@ static const SaveLoad _engine_id_mapping
 
	SLE_VAR(EngineIDMapping, substitute_id, SLE_UINT8),
 
};
 

	
 
static void Save_EIDS()
 
struct EIDSChunkHandler : ChunkHandler {
 
	EIDSChunkHandler() : ChunkHandler('EIDS', CH_TABLE) {}
 

	
 
	void Save() const override
 
{
 
	SlTableHeader(_engine_id_mapping_desc);
 

	
 
@@ -187,7 +198,7 @@ static void Save_EIDS()
 
	}
 
}
 

	
 
static void Load_EIDS()
 
	void Load() const override
 
{
 
	const std::vector<SaveLoad> slt = SlCompatTableHeader(_engine_id_mapping_desc, _engine_id_mapping_sl_compat);
 

	
 
@@ -198,10 +209,11 @@ static void Load_EIDS()
 
		SlObject(eid, slt);
 
	}
 
}
 
};
 

	
 
static const ChunkHandler EIDS{ 'EIDS', Save_EIDS, Load_EIDS, nullptr, nullptr, CH_TABLE };
 
static const ChunkHandler ENGN{ 'ENGN', Save_ENGN, Load_ENGN, nullptr, nullptr, CH_TABLE };
 
static const ChunkHandler ENGS{ 'ENGS', nullptr,   Load_ENGS, nullptr, nullptr, CH_READONLY };
 
static const EIDSChunkHandler EIDS;
 
static const ENGNChunkHandler ENGN;
 
static const ENGSChunkHandler ENGS;
 
static const ChunkHandlerRef engine_chunk_handlers[] = {
 
	EIDS,
 
	ENGN,
src/saveload/game_sl.cpp
Show inline comments
 
@@ -54,7 +54,10 @@ static void SaveReal_GSDT(int *index_ptr
 
	Game::Save();
 
}
 

	
 
static void Load_GSDT()
 
struct GSDTChunkHandler : ChunkHandler {
 
	GSDTChunkHandler() : ChunkHandler('GSDT', CH_TABLE) {}
 

	
 
	void Load() const override
 
{
 
	const std::vector<SaveLoad> slt = SlCompatTableHeader(_game_script_desc, _game_script_sl_compat);
 

	
 
@@ -106,12 +109,13 @@ static void Load_GSDT()
 
	if (SlIterateArray() != -1) SlErrorCorrupt("Too many GameScript configs");
 
}
 

	
 
static void Save_GSDT()
 
	void Save() const override
 
{
 
	SlTableHeader(_game_script_desc);
 
	SlSetArrayIndex(0);
 
	SlAutolength((AutolengthProc *)SaveReal_GSDT, nullptr);
 
}
 
};
 

	
 
extern GameStrings *_current_data;
 

	
 
@@ -152,7 +156,10 @@ static const SaveLoad _game_language_des
 
	SLEG_STRUCTLIST("strings", SlGameLanguageString),
 
};
 

	
 
static void Load_GSTR()
 
struct GSTRChunkHandler : ChunkHandler {
 
	GSTRChunkHandler() : ChunkHandler('GSTR', CH_TABLE) {}
 

	
 
	void Load() const override
 
{
 
	const std::vector<SaveLoad> slt = SlCompatTableHeader(_game_language_desc, _game_language_sl_compat);
 

	
 
@@ -176,7 +183,7 @@ static void Load_GSTR()
 
	ReconsiderGameScriptLanguage();
 
}
 

	
 
static void Save_GSTR()
 
	void Save() const override
 
{
 
	SlTableHeader(_game_language_desc);
 

	
 
@@ -187,9 +194,10 @@ static void Save_GSTR()
 
		SlObject(&_current_data->raw_strings[i], _game_language_desc);
 
	}
 
}
 
};
 

	
 
static const ChunkHandler GSTR{ 'GSTR', Save_GSTR, Load_GSTR, nullptr, nullptr, CH_TABLE };
 
static const ChunkHandler GSDT{ 'GSDT', Save_GSDT, Load_GSDT, nullptr, nullptr, CH_TABLE };
 
static const GSTRChunkHandler GSTR;
 
static const GSDTChunkHandler GSDT;
 
static const ChunkHandlerRef game_chunk_handlers[] = {
 
	GSTR,
 
	GSDT,
src/saveload/gamelog_sl.cpp
Show inline comments
 
@@ -347,7 +347,13 @@ static const SaveLoad _gamelog_desc[] = 
 
	SLEG_STRUCTLIST("action", SlGamelogAction),
 
};
 

	
 
static void Load_GLOG_common(LoggedAction *&gamelog_action, uint &gamelog_actions)
 
struct GLOGChunkHandler : ChunkHandler {
 
	GLOGChunkHandler() : ChunkHandler('GLOG', CH_TABLE)
 
	{
 
		this->load_check = true;
 
	}
 

	
 
	void LoadCommon(LoggedAction *&gamelog_action, uint &gamelog_actions) const
 
{
 
	assert(gamelog_action == nullptr);
 
	assert(gamelog_actions == 0);
 
@@ -378,7 +384,7 @@ static void Load_GLOG_common(LoggedActio
 
	}
 
}
 

	
 
static void Save_GLOG()
 
	void Save() const override
 
{
 
	SlTableHeader(_gamelog_desc);
 

	
 
@@ -391,17 +397,18 @@ static void Save_GLOG()
 
	}
 
}
 

	
 
static void Load_GLOG()
 
	void Load() const override
 
{
 
	Load_GLOG_common(_gamelog_action, _gamelog_actions);
 
		this->LoadCommon(_gamelog_action, _gamelog_actions);
 
}
 

	
 
static void Check_GLOG()
 
	void LoadCheck(size_t) const override
 
{
 
	Load_GLOG_common(_load_check_data.gamelog_action, _load_check_data.gamelog_actions);
 
		this->LoadCommon(_load_check_data.gamelog_action, _load_check_data.gamelog_actions);
 
}
 
};
 

	
 
static const ChunkHandler GLOG{ 'GLOG', Save_GLOG, Load_GLOG, nullptr, Check_GLOG, CH_TABLE };
 
static const GLOGChunkHandler GLOG;
 
static const ChunkHandlerRef gamelog_chunk_handlers[] = {
 
	GLOG,
 
};
src/saveload/goal_sl.cpp
Show inline comments
 
@@ -25,7 +25,10 @@ static const SaveLoad _goals_desc[] = {
 
	SLE_CONDVAR(Goal, completed, SLE_BOOL, SLV_182, SL_MAX_VERSION),
 
};
 

	
 
static void Save_GOAL()
 
struct GOALChunkHandler : ChunkHandler {
 
	GOALChunkHandler() : ChunkHandler('GOAL', CH_TABLE) {}
 

	
 
	void Save() const override
 
{
 
	SlTableHeader(_goals_desc);
 

	
 
@@ -35,7 +38,7 @@ static void Save_GOAL()
 
	}
 
}
 

	
 
static void Load_GOAL()
 
	void Load() const override
 
{
 
	const std::vector<SaveLoad> slt = SlCompatTableHeader(_goals_desc, _goals_sl_compat);
 

	
 
@@ -45,8 +48,9 @@ static void Load_GOAL()
 
		SlObject(s, slt);
 
	}
 
}
 
};
 

	
 
static const ChunkHandler GOAL{ 'GOAL', Save_GOAL, Load_GOAL, nullptr, nullptr, CH_TABLE };
 
static const GOALChunkHandler GOAL;
 
static const ChunkHandlerRef goal_chunk_handlers[] = {
 
	GOAL,
 
};
src/saveload/group_sl.cpp
Show inline comments
 
@@ -28,7 +28,10 @@ static const SaveLoad _group_desc[] = {
 
	 SLE_CONDVAR(Group, parent,             SLE_UINT16,                    SLV_189, SL_MAX_VERSION),
 
};
 

	
 
static void Save_GRPS()
 
struct GRPSChunkHandler : ChunkHandler {
 
	GRPSChunkHandler() : ChunkHandler('GRPS', CH_TABLE) {}
 

	
 
	void Save() const override
 
{
 
	SlTableHeader(_group_desc);
 

	
 
@@ -39,7 +42,7 @@ static void Save_GRPS()
 
}
 

	
 

	
 
static void Load_GRPS()
 
	void Load() const override
 
{
 
	const std::vector<SaveLoad> slt = SlCompatTableHeader(_group_desc, _group_sl_compat);
 

	
 
@@ -58,8 +61,9 @@ static void Load_GRPS()
 
		}
 
	}
 
}
 
};
 

	
 
static const ChunkHandler GRPS{ 'GRPS', Save_GRPS, Load_GRPS, nullptr, nullptr, CH_TABLE };
 
static const GRPSChunkHandler GRPS;
 
static const ChunkHandlerRef group_chunk_handlers[] = {
 
	GRPS,
 
};
src/saveload/industry_sl.cpp
Show inline comments
 
@@ -74,7 +74,13 @@ static const SaveLoad _industry_desc[] =
 
	SLE_CONDSSTR(Industry, text,     SLE_STR | SLF_ALLOW_CONTROL,     SLV_INDUSTRY_TEXT, SL_MAX_VERSION),
 
};
 

	
 
static void Save_INDY()
 
struct INDYChunkHandler : ChunkHandler {
 
	INDYChunkHandler() : ChunkHandler('INDY', CH_TABLE)
 
	{
 
		this->fix_pointers = true;
 
	}
 

	
 
	void Save() const override
 
{
 
	SlTableHeader(_industry_desc);
 

	
 
@@ -85,17 +91,7 @@ static void Save_INDY()
 
	}
 
}
 

	
 
static void Save_IIDS()
 
{
 
	Save_NewGRFMapping(_industry_mngr);
 
}
 

	
 
static void Save_TIDS()
 
{
 
	Save_NewGRFMapping(_industile_mngr);
 
}
 

	
 
static void Load_INDY()
 
	void Load() const override
 
{
 
	const std::vector<SaveLoad> slt = SlCompatTableHeader(_industry_desc, _industry_sl_compat);
 

	
 
@@ -118,30 +114,52 @@ static void Load_INDY()
 
	}
 
}
 

	
 
static void Load_IIDS()
 
{
 
	Load_NewGRFMapping(_industry_mngr);
 
}
 

	
 
static void Load_TIDS()
 
{
 
	Load_NewGRFMapping(_industile_mngr);
 
}
 

	
 
static void Ptrs_INDY()
 
	void FixPointers() const override
 
{
 
	for (Industry *i : Industry::Iterate()) {
 
		SlObject(i, _industry_desc);
 
	}
 
}
 
};
 

	
 
struct IIDSChunkHandler : ChunkHandler {
 
	IIDSChunkHandler() : ChunkHandler('IIDS', CH_TABLE) {}
 

	
 
	void Save() const override
 
	{
 
		Save_NewGRFMapping(_industry_mngr);
 
	}
 

	
 
	void Load() const override
 
	{
 
		Load_NewGRFMapping(_industry_mngr);
 
	}
 
};
 

	
 
struct TIDSChunkHandler : ChunkHandler {
 
	TIDSChunkHandler() : ChunkHandler('TIDS', CH_TABLE) {}
 

	
 
	void Save() const override
 
	{
 
		Save_NewGRFMapping(_industile_mngr);
 
	}
 

	
 
	void Load() const override
 
	{
 
		Load_NewGRFMapping(_industile_mngr);
 
	}
 
};
 

	
 
/** Description of the data to save and load in #IndustryBuildData. */
 
static const SaveLoad _industry_builder_desc[] = {
 
	SLEG_VAR("wanted_inds", _industry_builder.wanted_inds, SLE_UINT32),
 
};
 

	
 
/** Save industry builder. */
 
static void Save_IBLD()
 
/** Industry builder. */
 
struct IBLDChunkHandler : ChunkHandler {
 
	IBLDChunkHandler() : ChunkHandler('IBLD', CH_TABLE) {}
 

	
 
	void Save() const override
 
{
 
	SlTableHeader(_industry_builder_desc);
 

	
 
@@ -149,8 +167,7 @@ static void Save_IBLD()
 
	SlGlobList(_industry_builder_desc);
 
}
 

	
 
/** Load industry builder. */
 
static void Load_IBLD()
 
	void Load() const override
 
{
 
	const std::vector<SaveLoad> slt = SlCompatTableHeader(_industry_builder_desc, _industry_builder_sl_compat);
 

	
 
@@ -158,6 +175,7 @@ static void Load_IBLD()
 
	SlGlobList(slt);
 
	if (!IsSavegameVersionBefore(SLV_RIFF_TO_ARRAY) && SlIterateArray() != -1) SlErrorCorrupt("Too many IBLD entries");
 
}
 
};
 

	
 
/** Description of the data to save and load in #IndustryTypeBuildData. */
 
static const SaveLoad _industrytype_builder_desc[] = {
 
@@ -168,8 +186,11 @@ static const SaveLoad _industrytype_buil
 
	SLE_VAR(IndustryTypeBuildData, wait_count,   SLE_UINT16),
 
};
 

	
 
/** Save industry-type build data. */
 
static void Save_ITBL()
 
/** Industry-type build data. */
 
struct ITBLChunkHandler : ChunkHandler {
 
	ITBLChunkHandler() : ChunkHandler('ITBL', CH_TABLE) {}
 

	
 
	void Save() const override
 
{
 
	SlTableHeader(_industrytype_builder_desc);
 

	
 
@@ -179,8 +200,7 @@ static void Save_ITBL()
 
	}
 
}
 

	
 
/** Load industry-type build data. */
 
static void Load_ITBL()
 
	void Load() const override
 
{
 
	const std::vector<SaveLoad> slt = SlCompatTableHeader(_industrytype_builder_desc, _industrytype_builder_sl_compat);
 

	
 
@@ -193,12 +213,13 @@ static void Load_ITBL()
 
		SlObject(_industry_builder.builddata + index, slt);
 
	}
 
}
 
};
 

	
 
static const ChunkHandler INDY{ 'INDY', Save_INDY, Load_INDY, Ptrs_INDY, nullptr, CH_TABLE };
 
static const ChunkHandler IIDS{ 'IIDS', Save_IIDS, Load_IIDS, nullptr,   nullptr, CH_TABLE };
 
static const ChunkHandler TIDS{ 'TIDS', Save_TIDS, Load_TIDS, nullptr,   nullptr, CH_TABLE };
 
static const ChunkHandler IBLD{ 'IBLD', Save_IBLD, Load_IBLD, nullptr,   nullptr, CH_TABLE };
 
static const ChunkHandler ITBL{ 'ITBL', Save_ITBL, Load_ITBL, nullptr,   nullptr, CH_TABLE };
 
static const INDYChunkHandler INDY;
 
static const IIDSChunkHandler IIDS;
 
static const TIDSChunkHandler TIDS;
 
static const IBLDChunkHandler IBLD;
 
static const ITBLChunkHandler ITBL;
 
static const ChunkHandlerRef industry_chunk_handlers[] = {
 
	INDY,
 
	IIDS,
src/saveload/labelmaps_sl.cpp
Show inline comments
 
@@ -99,7 +99,10 @@ static const SaveLoad _label_object_desc
 
	SLE_VAR(LabelObject, label, SLE_UINT32),
 
};
 

	
 
static void Save_RAIL()
 
struct RAILChunkHandler : ChunkHandler {
 
	RAILChunkHandler() : ChunkHandler('RAIL', CH_TABLE) {}
 

	
 
	void Save() const override
 
{
 
	SlTableHeader(_label_object_desc);
 

	
 
@@ -113,7 +116,7 @@ static void Save_RAIL()
 
	}
 
}
 

	
 
static void Load_RAIL()
 
	void Load() const override
 
{
 
	const std::vector<SaveLoad> slt = SlCompatTableHeader(_label_object_desc, _label_object_sl_compat);
 

	
 
@@ -126,8 +129,9 @@ static void Load_RAIL()
 
		_railtype_list.push_back((RailTypeLabel)lo.label);
 
	}
 
}
 
};
 

	
 
static const ChunkHandler RAIL{ 'RAIL', Save_RAIL, Load_RAIL, nullptr, nullptr, CH_TABLE };
 
static const RAILChunkHandler RAIL;
 
static const ChunkHandlerRef labelmaps_chunk_handlers[] = {
 
	RAIL,
 
};
src/saveload/linkgraph_sl.cpp
Show inline comments
 
@@ -242,9 +242,12 @@ void AfterLoadLinkGraphs()
 
}
 

	
 
/**
 
 * Save all link graphs.
 
 * All link graphs.
 
 */
 
static void Save_LGRP()
 
struct LGRPChunkHandler : ChunkHandler {
 
	LGRPChunkHandler() : ChunkHandler('LGRP', CH_TABLE) {}
 

	
 
	void Save() const override
 
{
 
	SlTableHeader(GetLinkGraphDesc());
 

	
 
@@ -254,10 +257,7 @@ static void Save_LGRP()
 
	}
 
}
 

	
 
/**
 
 * Load all link graphs.
 
 */
 
static void Load_LGRP()
 
	void Load() const override
 
{
 
	const std::vector<SaveLoad> slt = SlCompatTableHeader(GetLinkGraphDesc(), _linkgraph_sl_compat);
 

	
 
@@ -267,11 +267,15 @@ static void Load_LGRP()
 
		SlObject(lg, slt);
 
	}
 
}
 
};
 

	
 
/**
 
 * Save all link graph jobs.
 
 * All link graph jobs.
 
 */
 
static void Save_LGRJ()
 
struct LGRJChunkHandler : ChunkHandler {
 
	LGRJChunkHandler() : ChunkHandler('LGRJ', CH_TABLE) {}
 

	
 
	void Save() const override
 
{
 
	SlTableHeader(GetLinkGraphJobDesc());
 

	
 
@@ -281,10 +285,7 @@ static void Save_LGRJ()
 
	}
 
}
 

	
 
/**
 
 * Load all link graph jobs.
 
 */
 
static void Load_LGRJ()
 
	void Load() const override
 
{
 
	const std::vector<SaveLoad> slt = SlCompatTableHeader(GetLinkGraphJobDesc(), _linkgraph_job_sl_compat);
 

	
 
@@ -294,11 +295,18 @@ static void Load_LGRJ()
 
		SlObject(lgj, slt);
 
	}
 
}
 
};
 

	
 
/**
 
 * Save the link graph schedule.
 
 * Link graph schedule.
 
 */
 
static void Save_LGRS()
 
struct LGRSChunkHandler : ChunkHandler {
 
	LGRSChunkHandler() : ChunkHandler('LGRS', CH_TABLE)
 
	{
 
		this->fix_pointers = true;
 
	}
 

	
 
	void Save() const override
 
{
 
	SlTableHeader(GetLinkGraphScheduleDesc());
 

	
 
@@ -306,10 +314,7 @@ static void Save_LGRS()
 
	SlObject(&LinkGraphSchedule::instance, GetLinkGraphScheduleDesc());
 
}
 

	
 
/**
 
 * Load the link graph schedule.
 
 */
 
static void Load_LGRS()
 
	void Load() const override
 
{
 
	const std::vector<SaveLoad> slt = SlCompatTableHeader(GetLinkGraphScheduleDesc(), _linkgraph_schedule_sl_compat);
 

	
 
@@ -318,17 +323,15 @@ static void Load_LGRS()
 
	if (!IsSavegameVersionBefore(SLV_RIFF_TO_ARRAY) && SlIterateArray() != -1) SlErrorCorrupt("Too many LGRS entries");
 
}
 

	
 
/**
 
 * Substitute pointers in link graph schedule.
 
 */
 
static void Ptrs_LGRS()
 
	void FixPointers() const override
 
{
 
	SlObject(&LinkGraphSchedule::instance, GetLinkGraphScheduleDesc());
 
}
 
};
 

	
 
static const ChunkHandler LGRP{ 'LGRP', Save_LGRP, Load_LGRP, nullptr,   nullptr, CH_TABLE };
 
static const ChunkHandler LGRJ{ 'LGRJ', Save_LGRJ, Load_LGRJ, nullptr,   nullptr, CH_TABLE };
 
static const ChunkHandler LGRS{ 'LGRS', Save_LGRS, Load_LGRS, Ptrs_LGRS, nullptr, CH_TABLE };
 
static const LGRPChunkHandler LGRP;
 
static const LGRJChunkHandler LGRJ;
 
static const LGRSChunkHandler LGRS;
 
static const ChunkHandlerRef linkgraph_chunk_handlers[] = {
 
	LGRP,
 
	LGRJ,
src/saveload/map_sl.cpp
Show inline comments
 
@@ -27,7 +27,13 @@ static const SaveLoad _map_desc[] = {
 
	SLEG_CONDVAR("dim_y", _map_dim_y, SLE_UINT32, SLV_6, SL_MAX_VERSION),
 
};
 

	
 
static void Save_MAPS()
 
struct MAPSChunkHandler : ChunkHandler {
 
	MAPSChunkHandler() : ChunkHandler('MAPS', CH_TABLE)
 
	{
 
		this->load_check = true;
 
	}
 

	
 
	void Save() const override
 
{
 
	SlTableHeader(_map_desc);
 

	
 
@@ -38,7 +44,7 @@ static void Save_MAPS()
 
	SlGlobList(_map_desc);
 
}
 

	
 
static void Load_MAPS()
 
	void Load() const override
 
{
 
	const std::vector<SaveLoad> slt = SlCompatTableHeader(_map_desc, _map_sl_compat);
 

	
 
@@ -49,7 +55,7 @@ static void Load_MAPS()
 
	AllocateMap(_map_dim_x, _map_dim_y);
 
}
 

	
 
static void Check_MAPS()
 
	void LoadCheck(size_t) const override
 
{
 
	const std::vector<SaveLoad> slt = SlCompatTableHeader(_map_desc, _map_sl_compat);
 

	
 
@@ -60,10 +66,14 @@ static void Check_MAPS()
 
	_load_check_data.map_size_x = _map_dim_x;
 
	_load_check_data.map_size_y = _map_dim_y;
 
}
 
};
 

	
 
static const uint MAP_SL_BUF_SIZE = 4096;
 

	
 
static void Load_MAPT()
 
struct MAPTChunkHandler : ChunkHandler {
 
	MAPTChunkHandler() : ChunkHandler('MAPT', CH_RIFF) {}
 

	
 
	void Load() const override
 
{
 
	std::array<byte, MAP_SL_BUF_SIZE> buf;
 
	TileIndex size = MapSize();
 
@@ -74,7 +84,7 @@ static void Load_MAPT()
 
	}
 
}
 

	
 
static void Save_MAPT()
 
	void Save() const override
 
{
 
	std::array<byte, MAP_SL_BUF_SIZE> buf;
 
	TileIndex size = MapSize();
 
@@ -85,8 +95,12 @@ static void Save_MAPT()
 
		SlCopy(buf.data(), MAP_SL_BUF_SIZE, SLE_UINT8);
 
	}
 
}
 
};
 

	
 
static void Load_MAPH()
 
struct MAPHChunkHandler : ChunkHandler {
 
	MAPHChunkHandler() : ChunkHandler('MAPH', CH_RIFF) {}
 

	
 
	void Load() const override
 
{
 
	std::array<byte, MAP_SL_BUF_SIZE> buf;
 
	TileIndex size = MapSize();
 
@@ -97,7 +111,7 @@ static void Load_MAPH()
 
	}
 
}
 

	
 
static void Save_MAPH()
 
	void Save() const override
 
{
 
	std::array<byte, MAP_SL_BUF_SIZE> buf;
 
	TileIndex size = MapSize();
 
@@ -108,8 +122,12 @@ static void Save_MAPH()
 
		SlCopy(buf.data(), MAP_SL_BUF_SIZE, SLE_UINT8);
 
	}
 
}
 
};
 

	
 
static void Load_MAP1()
 
struct MAPOChunkHandler : ChunkHandler {
 
	MAPOChunkHandler() : ChunkHandler('MAPO', CH_RIFF) {}
 

	
 
	void Load() const override
 
{
 
	std::array<byte, MAP_SL_BUF_SIZE> buf;
 
	TileIndex size = MapSize();
 
@@ -120,7 +138,7 @@ static void Load_MAP1()
 
	}
 
}
 

	
 
static void Save_MAP1()
 
	void Save() const override
 
{
 
	std::array<byte, MAP_SL_BUF_SIZE> buf;
 
	TileIndex size = MapSize();
 
@@ -131,8 +149,12 @@ static void Save_MAP1()
 
		SlCopy(buf.data(), MAP_SL_BUF_SIZE, SLE_UINT8);
 
	}
 
}
 
};
 

	
 
static void Load_MAP2()
 
struct MAP2ChunkHandler : ChunkHandler {
 
	MAP2ChunkHandler() : ChunkHandler('MAP2', CH_RIFF) {}
 

	
 
	void Load() const override
 
{
 
	std::array<uint16, MAP_SL_BUF_SIZE> buf;
 
	TileIndex size = MapSize();
 
@@ -146,7 +168,7 @@ static void Load_MAP2()
 
	}
 
}
 

	
 
static void Save_MAP2()
 
	void Save() const override
 
{
 
	std::array<uint16, MAP_SL_BUF_SIZE> buf;
 
	TileIndex size = MapSize();
 
@@ -157,8 +179,12 @@ static void Save_MAP2()
 
		SlCopy(buf.data(), MAP_SL_BUF_SIZE, SLE_UINT16);
 
	}
 
}
 
};
 

	
 
static void Load_MAP3()
 
struct M3LOChunkHandler : ChunkHandler {
 
	M3LOChunkHandler() : ChunkHandler('M3LO', CH_RIFF) {}
 

	
 
	void Load() const override
 
{
 
	std::array<byte, MAP_SL_BUF_SIZE> buf;
 
	TileIndex size = MapSize();
 
@@ -169,7 +195,7 @@ static void Load_MAP3()
 
	}
 
}
 

	
 
static void Save_MAP3()
 
	void Save() const override
 
{
 
	std::array<byte, MAP_SL_BUF_SIZE> buf;
 
	TileIndex size = MapSize();
 
@@ -180,8 +206,12 @@ static void Save_MAP3()
 
		SlCopy(buf.data(), MAP_SL_BUF_SIZE, SLE_UINT8);
 
	}
 
}
 
};
 

	
 
static void Load_MAP4()
 
struct M3HIChunkHandler : ChunkHandler {
 
	M3HIChunkHandler() : ChunkHandler('M3HI', CH_RIFF) {}
 

	
 
	void Load() const override
 
{
 
	std::array<byte, MAP_SL_BUF_SIZE> buf;
 
	TileIndex size = MapSize();
 
@@ -192,7 +222,7 @@ static void Load_MAP4()
 
	}
 
}
 

	
 
static void Save_MAP4()
 
	void Save() const override
 
{
 
	std::array<byte, MAP_SL_BUF_SIZE> buf;
 
	TileIndex size = MapSize();
 
@@ -203,8 +233,12 @@ static void Save_MAP4()
 
		SlCopy(buf.data(), MAP_SL_BUF_SIZE, SLE_UINT8);
 
	}
 
}
 
};
 

	
 
static void Load_MAP5()
 
struct MAP5ChunkHandler : ChunkHandler {
 
	MAP5ChunkHandler() : ChunkHandler('MAP5', CH_RIFF) {}
 

	
 
	void Load() const override
 
{
 
	std::array<byte, MAP_SL_BUF_SIZE> buf;
 
	TileIndex size = MapSize();
 
@@ -215,7 +249,7 @@ static void Load_MAP5()
 
	}
 
}
 

	
 
static void Save_MAP5()
 
	void Save() const override
 
{
 
	std::array<byte, MAP_SL_BUF_SIZE> buf;
 
	TileIndex size = MapSize();
 
@@ -226,8 +260,12 @@ static void Save_MAP5()
 
		SlCopy(buf.data(), MAP_SL_BUF_SIZE, SLE_UINT8);
 
	}
 
}
 
};
 

	
 
static void Load_MAP6()
 
struct MAPEChunkHandler : ChunkHandler {
 
	MAPEChunkHandler() : ChunkHandler('MAPE', CH_RIFF) {}
 

	
 
	void Load() const override
 
{
 
	std::array<byte, MAP_SL_BUF_SIZE> buf;
 
	TileIndex size = MapSize();
 
@@ -251,7 +289,7 @@ static void Load_MAP6()
 
	}
 
}
 

	
 
static void Save_MAP6()
 
	void Save() const override
 
{
 
	std::array<byte, MAP_SL_BUF_SIZE> buf;
 
	TileIndex size = MapSize();
 
@@ -262,8 +300,12 @@ static void Save_MAP6()
 
		SlCopy(buf.data(), MAP_SL_BUF_SIZE, SLE_UINT8);
 
	}
 
}
 
};
 

	
 
static void Load_MAP7()
 
struct MAP7ChunkHandler : ChunkHandler {
 
	MAP7ChunkHandler() : ChunkHandler('MAP7', CH_RIFF) {}
 

	
 
	void Load() const override
 
{
 
	std::array<byte, MAP_SL_BUF_SIZE> buf;
 
	TileIndex size = MapSize();
 
@@ -274,7 +316,7 @@ static void Load_MAP7()
 
	}
 
}
 

	
 
static void Save_MAP7()
 
	void Save() const override
 
{
 
	std::array<byte, MAP_SL_BUF_SIZE> buf;
 
	TileIndex size = MapSize();
 
@@ -285,8 +327,12 @@ static void Save_MAP7()
 
		SlCopy(buf.data(), MAP_SL_BUF_SIZE, SLE_UINT8);
 
	}
 
}
 
};
 

	
 
static void Load_MAP8()
 
struct MAP8ChunkHandler : ChunkHandler {
 
	MAP8ChunkHandler() : ChunkHandler('MAP8', CH_RIFF) {}
 

	
 
	void Load() const override
 
{
 
	std::array<uint16, MAP_SL_BUF_SIZE> buf;
 
	TileIndex size = MapSize();
 
@@ -297,7 +343,7 @@ static void Load_MAP8()
 
	}
 
}
 

	
 
static void Save_MAP8()
 
	void Save() const override
 
{
 
	std::array<uint16, MAP_SL_BUF_SIZE> buf;
 
	TileIndex size = MapSize();
 
@@ -308,18 +354,19 @@ static void Save_MAP8()
 
		SlCopy(buf.data(), MAP_SL_BUF_SIZE, SLE_UINT16);
 
	}
 
}
 
};
 

	
 
static const ChunkHandler MAPS{ 'MAPS', Save_MAPS, Load_MAPS, nullptr, Check_MAPS, CH_TABLE };
 
static const ChunkHandler MAPT{ 'MAPT', Save_MAPT, Load_MAPT, nullptr, nullptr,    CH_RIFF };
 
static const ChunkHandler MAPH{ 'MAPH', Save_MAPH, Load_MAPH, nullptr, nullptr,    CH_RIFF };
 
static const ChunkHandler MAPO{ 'MAPO', Save_MAP1, Load_MAP1, nullptr, nullptr,    CH_RIFF };
 
static const ChunkHandler MAP2{ 'MAP2', Save_MAP2, Load_MAP2, nullptr, nullptr,    CH_RIFF };
 
static const ChunkHandler M3LO{ 'M3LO', Save_MAP3, Load_MAP3, nullptr, nullptr,    CH_RIFF };
 
static const ChunkHandler M3HI{ 'M3HI', Save_MAP4, Load_MAP4, nullptr, nullptr,    CH_RIFF };
 
static const ChunkHandler MAP5{ 'MAP5', Save_MAP5, Load_MAP5, nullptr, nullptr,    CH_RIFF };
 
static const ChunkHandler MAPE{ 'MAPE', Save_MAP6, Load_MAP6, nullptr, nullptr,    CH_RIFF };
 
static const ChunkHandler MAP7{ 'MAP7', Save_MAP7, Load_MAP7, nullptr, nullptr,    CH_RIFF };
 
static const ChunkHandler MAP8{ 'MAP8', Save_MAP8, Load_MAP8, nullptr, nullptr,    CH_RIFF };
 
static const MAPSChunkHandler MAPS;
 
static const MAPTChunkHandler MAPT;
 
static const MAPHChunkHandler MAPH;
 
static const MAPOChunkHandler MAPO;
 
static const MAP2ChunkHandler MAP2;
 
static const M3LOChunkHandler M3LO;
 
static const M3HIChunkHandler M3HI;
 
static const MAP5ChunkHandler MAP5;
 
static const MAPEChunkHandler MAPE;
 
static const MAP7ChunkHandler MAP7;
 
static const MAP8ChunkHandler MAP8;
 
static const ChunkHandlerRef map_chunk_handlers[] = {
 
	MAPS,
 
	MAPT,
src/saveload/misc_sl.cpp
Show inline comments
 
@@ -95,7 +95,13 @@ static const SaveLoad _date_check_desc[]
 

	
 
/* Save load date related variables as well as persistent tick counters
 
 * XXX: currently some unrelated stuff is just put here */
 
static void Save_DATE()
 
struct DATEChunkHandler : ChunkHandler {
 
	DATEChunkHandler() : ChunkHandler('DATE', CH_TABLE)
 
	{
 
		this->load_check = true;
 
	}
 

	
 
	void Save() const override
 
{
 
	SlTableHeader(_date_desc);
 

	
 
@@ -103,7 +109,7 @@ static void Save_DATE()
 
	SlGlobList(_date_desc);
 
}
 

	
 
static void Load_DATE_common(const SaveLoadTable &slt, const SaveLoadCompatTable &slct)
 
	void LoadCommon(const SaveLoadTable &slt, const SaveLoadCompatTable &slct) const
 
{
 
	const std::vector<SaveLoad> oslt = SlCompatTableHeader(slt, slct);
 

	
 
@@ -112,20 +118,21 @@ static void Load_DATE_common(const SaveL
 
	if (!IsSavegameVersionBefore(SLV_RIFF_TO_ARRAY) && SlIterateArray() != -1) SlErrorCorrupt("Too many DATE entries");
 
}
 

	
 
static void Load_DATE()
 
	void Load() const override
 
{
 
	Load_DATE_common(_date_desc, _date_sl_compat);
 
		this->LoadCommon(_date_desc, _date_sl_compat);
 
}
 

	
 
static void Check_DATE()
 

	
 
	void LoadCheck(size_t) const override
 
{
 
	Load_DATE_common(_date_check_desc, _date_check_sl_compat);
 
		this->LoadCommon(_date_check_desc, _date_check_sl_compat);
 

	
 
	if (IsSavegameVersionBefore(SLV_31)) {
 
		_load_check_data.current_date += DAYS_TILL_ORIGINAL_BASE_YEAR;
 
	}
 
}
 

	
 
};
 

	
 
static const SaveLoad _view_desc[] = {
 
	SLEG_CONDVAR("x",    _saved_scrollpos_x,    SLE_FILE_I16 | SLE_VAR_I32, SL_MIN_VERSION, SLV_6),
 
@@ -135,7 +142,10 @@ static const SaveLoad _view_desc[] = {
 
	    SLEG_VAR("zoom", _saved_scrollpos_zoom, SLE_UINT8),
 
};
 

	
 
static void Save_VIEW()
 
struct VIEWChunkHandler : ChunkHandler {
 
	VIEWChunkHandler() : ChunkHandler('VIEW', CH_TABLE) {}
 

	
 
	void Save() const override
 
{
 
	SlTableHeader(_view_desc);
 

	
 
@@ -143,7 +153,7 @@ static void Save_VIEW()
 
	SlGlobList(_view_desc);
 
}
 

	
 
static void Load_VIEW()
 
	void Load() const override
 
{
 
	const std::vector<SaveLoad> slt = SlCompatTableHeader(_view_desc, _view_sl_compat);
 

	
 
@@ -151,9 +161,10 @@ static void Load_VIEW()
 
	SlGlobList(slt);
 
	if (!IsSavegameVersionBefore(SLV_RIFF_TO_ARRAY) && SlIterateArray() != -1) SlErrorCorrupt("Too many DATE entries");
 
}
 
};
 

	
 
static const ChunkHandler DATE{ 'DATE', Save_DATE, Load_DATE, nullptr, Check_DATE, CH_TABLE };
 
static const ChunkHandler VIEW{ 'VIEW', Save_VIEW, Load_VIEW, nullptr, nullptr,    CH_TABLE };
 
static const DATEChunkHandler DATE;
 
static const VIEWChunkHandler VIEW;
 
static const ChunkHandlerRef misc_chunk_handlers[] = {
 
	DATE,
 
	VIEW,
src/saveload/newgrf_sl.cpp
Show inline comments
 
@@ -73,7 +73,13 @@ static const SaveLoad _grfconfig_desc[] 
 
};
 

	
 

	
 
static void Save_NGRF()
 
struct NGRFChunkHandler : ChunkHandler {
 
	NGRFChunkHandler() : ChunkHandler('NGRF', CH_TABLE)
 
	{
 
		this->load_check = true;
 
	}
 

	
 
	void Save() const override
 
{
 
	SlTableHeader(_grfconfig_desc);
 

	
 
@@ -87,7 +93,7 @@ static void Save_NGRF()
 
}
 

	
 

	
 
static void Load_NGRF_common(GRFConfig *&grfconfig)
 
	void LoadCommon(GRFConfig *&grfconfig) const
 
{
 
	const std::vector<SaveLoad> slt = SlCompatTableHeader(_grfconfig_desc, _grfconfig_sl_compat);
 

	
 
@@ -100,9 +106,9 @@ static void Load_NGRF_common(GRFConfig *
 
	}
 
}
 

	
 
static void Load_NGRF()
 
	void Load() const override
 
{
 
	Load_NGRF_common(_grfconfig);
 
		this->LoadCommon(_grfconfig);
 

	
 
	if (_game_mode == GM_MENU) {
 
		/* Intro game must not have NewGRF. */
 
@@ -116,12 +122,13 @@ static void Load_NGRF()
 
	}
 
}
 

	
 
static void Check_NGRF()
 
	void LoadCheck(size_t) const override
 
{
 
	Load_NGRF_common(_load_check_data.grfconfig);
 
		this->LoadCommon(_load_check_data.grfconfig);
 
}
 
};
 

	
 
static const ChunkHandler NGRF{ 'NGRF', Save_NGRF, Load_NGRF, nullptr, Check_NGRF, CH_TABLE };
 
static const NGRFChunkHandler NGRF;
 
static const ChunkHandlerRef newgrf_chunk_handlers[] = {
 
	NGRF,
 
};
src/saveload/object_sl.cpp
Show inline comments
 
@@ -29,7 +29,13 @@ static const SaveLoad _object_desc[] = {
 
	SLE_CONDVAR(Object, type,                       SLE_UINT16,                 SLV_186, SL_MAX_VERSION),
 
};
 

	
 
static void Save_OBJS()
 
struct OBJSChunkHandler : ChunkHandler {
 
	OBJSChunkHandler() : ChunkHandler('OBJS', CH_TABLE)
 
	{
 
		this->fix_pointers = true;
 
	}
 

	
 
	void Save() const override
 
{
 
	SlTableHeader(_object_desc);
 

	
 
@@ -40,7 +46,7 @@ static void Save_OBJS()
 
	}
 
}
 

	
 
static void Load_OBJS()
 
	void Load() const override
 
{
 
	const std::vector<SaveLoad> slt = SlCompatTableHeader(_object_desc, _object_sl_compat);
 

	
 
@@ -51,7 +57,7 @@ static void Load_OBJS()
 
	}
 
}
 

	
 
static void Ptrs_OBJS()
 
	void FixPointers() const override
 
{
 
	for (Object *o : Object::Iterate()) {
 
		SlObject(o, _object_desc);
 
@@ -61,19 +67,24 @@ static void Ptrs_OBJS()
 
		}
 
	}
 
}
 
};
 

	
 
static void Save_OBID()
 
struct OBIDChunkHandler : ChunkHandler {
 
	OBIDChunkHandler() : ChunkHandler('OBID', CH_TABLE) {}
 

	
 
	void Save() const override
 
{
 
	Save_NewGRFMapping(_object_mngr);
 
}
 

	
 
static void Load_OBID()
 
	void Load() const override
 
{
 
	Load_NewGRFMapping(_object_mngr);
 
}
 
};
 

	
 
static const ChunkHandler OBID{ 'OBID', Save_OBID, Load_OBID, nullptr,   nullptr, CH_TABLE };
 
static const ChunkHandler OBJS{ 'OBJS', Save_OBJS, Load_OBJS, Ptrs_OBJS, nullptr, CH_TABLE };
 
static const OBIDChunkHandler OBID;
 
static const OBJSChunkHandler OBJS;
 
static const ChunkHandlerRef object_chunk_handlers[] = {
 
	OBID,
 
	OBJS,
src/saveload/order_sl.cpp
Show inline comments
 
@@ -118,7 +118,13 @@ SaveLoadTable GetOrderDescription()
 
	return _order_desc;
 
}
 

	
 
static void Save_ORDR()
 
struct ORDRChunkHandler : ChunkHandler {
 
	ORDRChunkHandler() : ChunkHandler('ORDR', CH_TABLE)
 
	{
 
		this->fix_pointers = true;
 
	}
 

	
 
	void Save() const override
 
{
 
	const SaveLoadTable slt = GetOrderDescription();
 
	SlTableHeader(slt);
 
@@ -129,7 +135,7 @@ static void Save_ORDR()
 
	}
 
}
 

	
 
static void Load_ORDR()
 
	void Load() const override
 
{
 
	if (IsSavegameVersionBefore(SLV_5, 2)) {
 
		/* Version older than 5.2 did not have a ->next pointer. Convert them
 
@@ -188,7 +194,7 @@ static void Load_ORDR()
 
	}
 
}
 

	
 
static void Ptrs_ORDR()
 
	void FixPointers() const override
 
{
 
	/* Orders from old savegames have pointers corrected in Load_ORDR */
 
	if (IsSavegameVersionBefore(SLV_5, 2)) return;
 
@@ -197,6 +203,7 @@ static void Ptrs_ORDR()
 
		SlObject(o, GetOrderDescription());
 
	}
 
}
 
};
 

	
 
SaveLoadTable GetOrderListDescription()
 
{
 
@@ -207,7 +214,13 @@ SaveLoadTable GetOrderListDescription()
 
	return _orderlist_desc;
 
}
 

	
 
static void Save_ORDL()
 
struct ORDLChunkHandler : ChunkHandler {
 
	ORDLChunkHandler() : ChunkHandler('ORDL', CH_TABLE)
 
	{
 
		this->fix_pointers = true;
 
	}
 

	
 
	void Save() const override
 
{
 
	const SaveLoadTable slt = GetOrderListDescription();
 
	SlTableHeader(slt);
 
@@ -218,7 +231,7 @@ static void Save_ORDL()
 
	}
 
}
 

	
 
static void Load_ORDL()
 
	void Load() const override
 
{
 
	const std::vector<SaveLoad> slt = SlCompatTableHeader(GetOrderListDescription(), _orderlist_sl_compat);
 

	
 
@@ -232,12 +245,13 @@ static void Load_ORDL()
 

	
 
}
 

	
 
static void Ptrs_ORDL()
 
	void FixPointers() const override
 
{
 
	for (OrderList *list : OrderList::Iterate()) {
 
		SlObject(list, GetOrderListDescription());
 
	}
 
}
 
};
 

	
 
SaveLoadTable GetOrderBackupDescription()
 
{
 
@@ -262,7 +276,13 @@ SaveLoadTable GetOrderBackupDescription(
 
	return _order_backup_desc;
 
}
 

	
 
static void Save_BKOR()
 
struct BKORChunkHandler : ChunkHandler {
 
	BKORChunkHandler() : ChunkHandler('BKOR', CH_TABLE)
 
	{
 
		this->fix_pointers = true;
 
	}
 

	
 
	void Save() const override
 
{
 
	const SaveLoadTable slt = GetOrderBackupDescription();
 
	SlTableHeader(slt);
 
@@ -278,7 +298,7 @@ static void Save_BKOR()
 
	}
 
}
 

	
 
void Load_BKOR()
 
	void Load() const override
 
{
 
	const std::vector<SaveLoad> slt = SlCompatTableHeader(GetOrderBackupDescription(), _order_backup_sl_compat);
 

	
 
@@ -291,16 +311,17 @@ void Load_BKOR()
 
	}
 
}
 

	
 
static void Ptrs_BKOR()
 
	void FixPointers() const override
 
{
 
	for (OrderBackup *ob : OrderBackup::Iterate()) {
 
		SlObject(ob, GetOrderBackupDescription());
 
	}
 
}
 
};
 

	
 
static const ChunkHandler BKOR{ 'BKOR', Save_BKOR, Load_BKOR, Ptrs_BKOR, nullptr, CH_TABLE };
 
static const ChunkHandler ORDR{ 'ORDR', Save_ORDR, Load_ORDR, Ptrs_ORDR, nullptr, CH_TABLE };
 
static const ChunkHandler ORDL{ 'ORDL', Save_ORDL, Load_ORDL, Ptrs_ORDL, nullptr, CH_TABLE };
 
static const BKORChunkHandler BKOR;
 
static const ORDRChunkHandler ORDR;
 
static const ORDLChunkHandler ORDL;
 
static const ChunkHandlerRef order_chunk_handlers[] = {
 
	BKOR,
 
	ORDR,
src/saveload/settings_sl.cpp
Show inline comments
 
@@ -142,7 +142,10 @@ static void SaveSettings(const SettingTa
 
	SlObject(object, slt);
 
}
 

	
 
static void Load_OPTS()
 
struct OPTSChunkHandler : ChunkHandler {
 
	OPTSChunkHandler() : ChunkHandler('OPTS', CH_READONLY) {}
 

	
 
	void Load() const override
 
{
 
	/* Copy over default setting since some might not get loaded in
 
	 * a networking environment. This ensures for example that the local
 
@@ -151,8 +154,15 @@ static void Load_OPTS()
 
	LoadSettings(_gameopt_settings, &_settings_game, _gameopt_sl_compat);
 
	HandleOldDiffCustom(true);
 
}
 
};
 

	
 
static void Load_PATS()
 
struct PATSChunkHandler : ChunkHandler {
 
	PATSChunkHandler() : ChunkHandler('PATS', CH_TABLE)
 
	{
 
		this->load_check = true;
 
	}
 

	
 
	void Load() const override
 
{
 
	/* Copy over default setting since some might not get loaded in
 
	 * a networking environment. This ensures for example that the local
 
@@ -160,18 +170,19 @@ static void Load_PATS()
 
	LoadSettings(_settings, &_settings_game, _settings_sl_compat);
 
}
 

	
 
static void Check_PATS()
 
	void LoadCheck(size_t) const override
 
{
 
	LoadSettings(_settings, &_load_check_data.settings, _settings_sl_compat);
 
}
 

	
 
static void Save_PATS()
 
	void Save() const override
 
{
 
	SaveSettings(_settings, &_settings_game);
 
}
 
};
 

	
 
static const ChunkHandler OPTS{ 'OPTS', nullptr,   Load_OPTS, nullptr, nullptr,    CH_READONLY };
 
static const ChunkHandler PATS{ 'PATS', Save_PATS, Load_PATS, nullptr, Check_PATS, CH_TABLE };
 
static const OPTSChunkHandler OPTS;
 
static const PATSChunkHandler PATS;
 
static const ChunkHandlerRef setting_chunk_handlers[] = {
 
	OPTS,
 
	PATS,
src/saveload/signs_sl.cpp
Show inline comments
 
@@ -30,8 +30,10 @@ static const SaveLoad _sign_desc[] = {
 
	SLE_CONDVAR(Sign, z,     SLE_INT32,                SLV_164, SL_MAX_VERSION),
 
};
 

	
 
/** Save all signs */
 
static void Save_SIGN()
 
struct SIGNChunkHandler : ChunkHandler {
 
	SIGNChunkHandler() : ChunkHandler('SIGN', CH_TABLE) {}
 

	
 
	void Save() const override
 
{
 
	SlTableHeader(_sign_desc);
 

	
 
@@ -41,8 +43,7 @@ static void Save_SIGN()
 
	}
 
}
 

	
 
/** Load all signs */
 
static void Load_SIGN()
 
	void Load() const override
 
{
 
	const std::vector<SaveLoad> slt = SlCompatTableHeader(_sign_desc, _sign_sl_compat);
 

	
 
@@ -66,8 +67,9 @@ static void Load_SIGN()
 
		}
 
	}
 
}
 
};
 

	
 
static const ChunkHandler SIGN{ 'SIGN', Save_SIGN, Load_SIGN, nullptr, nullptr, CH_TABLE };
 
static const SIGNChunkHandler SIGN;
 
static const ChunkHandlerRef sign_chunk_handlers[] = {
 
	SIGN,
 
};
src/saveload/station_sl.cpp
Show inline comments
 
@@ -484,7 +484,13 @@ static const SaveLoad _old_station_desc[
 
	SLEG_CONDSTRUCTLIST("speclist", SlStationSpecList,                           SLV_27, SL_MAX_VERSION),
 
};
 

	
 
static void Load_STNS()
 
struct STNSChunkHandler : ChunkHandler {
 
	STNSChunkHandler() : ChunkHandler('STNS', CH_READONLY)
 
	{
 
		this->fix_pointers = true;
 
	}
 

	
 
	void Load() const override
 
{
 
	const std::vector<SaveLoad> slt = SlCompatTableHeader(_old_station_desc, _old_station_sl_compat);
 

	
 
@@ -501,7 +507,7 @@ static void Load_STNS()
 
	}
 
}
 

	
 
static void Ptrs_STNS()
 
	void FixPointers() const override
 
{
 
	/* From SLV_123 we store stations in STNN; before that in STNS. So do not
 
	 * fix pointers when the version is SLV_123 or up, as that would fix
 
@@ -512,6 +518,7 @@ static void Ptrs_STNS()
 
		SlObject(st, _old_station_desc);
 
	}
 
}
 
};
 

	
 
/**
 
 * SaveLoad handler for the BaseStation, which all other stations / waypoints
 
@@ -651,7 +658,13 @@ static const SaveLoad _station_desc[] = 
 
	SLEG_CONDSTRUCTLIST("speclist", SlStationSpecList, SLV_27, SL_MAX_VERSION),
 
};
 

	
 
static void Save_STNN()
 
struct STNNChunkHandler : ChunkHandler {
 
	STNNChunkHandler() : ChunkHandler('STNN', CH_TABLE)
 
	{
 
		this->fix_pointers = true;
 
	}
 

	
 
	void Save() const override
 
{
 
	SlTableHeader(_station_desc);
 

	
 
@@ -662,7 +675,8 @@ static void Save_STNN()
 
	}
 
}
 

	
 
static void Load_STNN()
 

	
 
	void Load() const override
 
{
 
	const std::vector<SaveLoad> slt = SlCompatTableHeader(_station_desc, _station_sl_compat);
 

	
 
@@ -677,7 +691,7 @@ static void Load_STNN()
 
	}
 
}
 

	
 
static void Ptrs_STNN()
 
	void FixPointers() const override
 
{
 
	/* From SLV_123 we store stations in STNN; before that in STNS. So do not
 
	 * fix pointers when the version is below SLV_123, as that would fix
 
@@ -688,8 +702,15 @@ static void Ptrs_STNN()
 
		SlObject(bst, _station_desc);
 
	}
 
}
 
};
 

	
 
static void Save_ROADSTOP()
 
struct ROADChunkHandler : ChunkHandler {
 
	ROADChunkHandler() : ChunkHandler('ROAD', CH_TABLE)
 
	{
 
		this->fix_pointers = true;
 
	}
 

	
 
	void Save() const override
 
{
 
	SlTableHeader(_roadstop_desc);
 

	
 
@@ -699,7 +720,7 @@ static void Save_ROADSTOP()
 
	}
 
}
 

	
 
static void Load_ROADSTOP()
 
	void Load() const override
 
{
 
	const std::vector<SaveLoad> slt = SlCompatTableHeader(_roadstop_desc, _roadstop_sl_compat);
 

	
 
@@ -712,16 +733,17 @@ static void Load_ROADSTOP()
 
	}
 
}
 

	
 
static void Ptrs_ROADSTOP()
 
	void FixPointers() const override
 
{
 
	for (RoadStop *rs : RoadStop::Iterate()) {
 
		SlObject(rs, _roadstop_desc);
 
	}
 
}
 
};
 

	
 
static const ChunkHandler STNS{ 'STNS', nullptr,       Load_STNS,     Ptrs_STNS,     nullptr, CH_READONLY };
 
static const ChunkHandler STNN{ 'STNN', Save_STNN,     Load_STNN,     Ptrs_STNN,     nullptr, CH_TABLE };
 
static const ChunkHandler ROAD{ 'ROAD', Save_ROADSTOP, Load_ROADSTOP, Ptrs_ROADSTOP, nullptr, CH_TABLE };
 
static const STNSChunkHandler STNS;
 
static const STNNChunkHandler STNN;
 
static const ROADChunkHandler ROAD;
 
static const ChunkHandlerRef station_chunk_handlers[] = {
 
	STNS,
 
	STNN,
src/saveload/storage_sl.cpp
Show inline comments
 
@@ -23,8 +23,11 @@ static const SaveLoad _storage_desc[] = 
 
	 SLE_CONDARR(PersistentStorage, storage,  SLE_UINT32, 256,           SLV_EXTEND_PERSISTENT_STORAGE, SL_MAX_VERSION),
 
};
 

	
 
/** Load persistent storage data. */
 
static void Load_PSAC()
 
/** Persistent storage data. */
 
struct PSACChunkHandler : ChunkHandler {
 
	PSACChunkHandler() : ChunkHandler('PSAC', CH_TABLE) {}
 

	
 
	void Load() const override
 
{
 
	const std::vector<SaveLoad> slt = SlCompatTableHeader(_storage_desc, _storage_sl_compat);
 

	
 
@@ -37,8 +40,7 @@ static void Load_PSAC()
 
	}
 
}
 

	
 
/** Save persistent storage data. */
 
static void Save_PSAC()
 
	void Save() const override
 
{
 
	SlTableHeader(_storage_desc);
 

	
 
@@ -49,8 +51,9 @@ static void Save_PSAC()
 
		SlObject(ps, _storage_desc);
 
	}
 
}
 
};
 

	
 
static const ChunkHandler PSAC{ 'PSAC', Save_PSAC, Load_PSAC, nullptr, nullptr, CH_TABLE };
 
static const PSACChunkHandler PSAC;
 
static const ChunkHandlerRef persistent_storage_chunk_handlers[] = {
 
	PSAC,
 
};
src/saveload/story_sl.cpp
Show inline comments
 
@@ -38,7 +38,10 @@ static const SaveLoad _story_page_elemen
 
	    SLE_STR(StoryPageElement, text,          SLE_STR | SLF_ALLOW_CONTROL, 0),
 
};
 

	
 
static void Save_STORY_PAGE_ELEMENT()
 
struct STPEChunkHandler : ChunkHandler {
 
	STPEChunkHandler() : ChunkHandler('STPE', CH_TABLE) {}
 

	
 
	void Save() const override
 
{
 
	SlTableHeader(_story_page_elements_desc);
 

	
 
@@ -48,7 +51,7 @@ static void Save_STORY_PAGE_ELEMENT()
 
	}
 
}
 

	
 
static void Load_STORY_PAGE_ELEMENT()
 
	void Load() const override
 
{
 
	const std::vector<SaveLoad> slt = SlCompatTableHeader(_story_page_elements_desc, _story_page_elements_sl_compat);
 

	
 
@@ -66,6 +69,7 @@ static void Load_STORY_PAGE_ELEMENT()
 
	 */
 
	_story_page_element_next_sort_value = max_sort_value + 1;
 
}
 
};
 

	
 
static const SaveLoad _story_pages_desc[] = {
 
	SLE_CONDVAR(StoryPage, sort_value, SLE_FILE_U16 | SLE_VAR_U32, SL_MIN_VERSION,   SLV_185),
 
@@ -76,7 +80,10 @@ static const SaveLoad _story_pages_desc[
 
	    SLE_STR(StoryPage, title,      SLE_STR | SLF_ALLOW_CONTROL, 0),
 
};
 

	
 
static void Save_STORY_PAGE()
 
struct STPAChunkHandler : ChunkHandler {
 
	STPAChunkHandler() : ChunkHandler('STPA', CH_TABLE) {}
 

	
 
	void Save() const override
 
{
 
	SlTableHeader(_story_pages_desc);
 

	
 
@@ -86,7 +93,7 @@ static void Save_STORY_PAGE()
 
	}
 
}
 

	
 
static void Load_STORY_PAGE()
 
	void Load() const override
 
{
 
	const std::vector<SaveLoad> slt = SlCompatTableHeader(_story_pages_desc, _story_pages_sl_compat);
 

	
 
@@ -104,9 +111,10 @@ static void Load_STORY_PAGE()
 
	 */
 
	_story_page_next_sort_value = max_sort_value + 1;
 
}
 
};
 

	
 
static const ChunkHandler STPE{ 'STPE', Save_STORY_PAGE_ELEMENT, Load_STORY_PAGE_ELEMENT, nullptr, nullptr, CH_TABLE };
 
static const ChunkHandler STPA{ 'STPA', Save_STORY_PAGE,         Load_STORY_PAGE,         nullptr, nullptr, CH_TABLE };
 
static const STPEChunkHandler STPE;
 
static const STPAChunkHandler STPA;
 
static const ChunkHandlerRef story_page_chunk_handlers[] = {
 
	STPE,
 
	STPA,
src/saveload/strings_sl.cpp
Show inline comments
 
@@ -113,10 +113,10 @@ void InitializeOldNames()
 
	_old_name_array = CallocT<char>(NUM_OLD_STRINGS * LEN_OLD_STRINGS); // 200 * 24 would be enough for TTO savegames
 
}
 

	
 
/**
 
 * Load the NAME chunk.
 
 */
 
static void Load_NAME()
 
struct NAMEChunkHandler : ChunkHandler {
 
	NAMEChunkHandler() : ChunkHandler('NAME', CH_READONLY) {}
 

	
 
	void Load() const override
 
{
 
	int index;
 

	
 
@@ -129,8 +129,9 @@ static void Load_NAME()
 
		_old_name_array[LEN_OLD_STRINGS * index + LEN_OLD_STRINGS - 1] = '\0';
 
	}
 
}
 
};
 

	
 
static const ChunkHandler NAME{ 'NAME', nullptr, Load_NAME, nullptr, nullptr, CH_READONLY };
 
static const NAMEChunkHandler NAME;
 
static const ChunkHandlerRef name_chunk_handlers[] = {
 
	NAME,
 
};
src/saveload/subsidy_sl.cpp
Show inline comments
 
@@ -29,7 +29,10 @@ static const SaveLoad _subsidies_desc[] 
 
	SLE_CONDVAR(Subsidy, dst,        SLE_UINT16,                                      SLV_5, SL_MAX_VERSION),
 
};
 

	
 
static void Save_SUBS()
 
struct SUBSChunkHandler : ChunkHandler {
 
	SUBSChunkHandler() : ChunkHandler('SUBS', CH_TABLE) {}
 

	
 
	void Save() const override
 
{
 
	SlTableHeader(_subsidies_desc);
 

	
 
@@ -39,7 +42,7 @@ static void Save_SUBS()
 
	}
 
}
 

	
 
static void Load_SUBS()
 
	void Load() const override
 
{
 
	const std::vector<SaveLoad> slt = SlCompatTableHeader(_subsidies_desc, _subsidies_sl_compat);
 

	
 
@@ -49,8 +52,9 @@ static void Load_SUBS()
 
		SlObject(s, slt);
 
	}
 
}
 
};
 

	
 
static const ChunkHandler SUBS{ 'SUBS', Save_SUBS, Load_SUBS, nullptr, nullptr, CH_TABLE };
 
static const SUBSChunkHandler SUBS;
 
static const ChunkHandlerRef subsidy_chunk_handlers[] = {
 
	SUBS,
 
};
src/saveload/town_sl.cpp
Show inline comments
 
@@ -272,17 +272,27 @@ static const SaveLoad _town_desc[] = {
 
	SLEG_CONDSTRUCTLIST("acceptance_matrix", SlTownAcceptanceMatrix,   SLV_166, SLV_REMOVE_TOWN_CARGO_CACHE),
 
};
 

	
 
static void Save_HIDS()
 
struct HIDSChunkHandler : ChunkHandler {
 
	HIDSChunkHandler() : ChunkHandler('HIDS', CH_TABLE) {}
 

	
 
	void Save() const override
 
{
 
	Save_NewGRFMapping(_house_mngr);
 
}
 

	
 
static void Load_HIDS()
 
	void Load() const override
 
{
 
	Load_NewGRFMapping(_house_mngr);
 
}
 
};
 

	
 
static void Save_TOWN()
 
struct CITYChunkHandler : ChunkHandler {
 
	CITYChunkHandler() : ChunkHandler('CITY', CH_TABLE)
 
	{
 
		this->fix_pointers = true;
 
	}
 

	
 
	void Save() const override
 
{
 
	SlTableHeader(_town_desc);
 

	
 
@@ -292,7 +302,7 @@ static void Save_TOWN()
 
	}
 
}
 

	
 
static void Load_TOWN()
 
	void Load() const override
 
{
 
	const std::vector<SaveLoad> slt = SlCompatTableHeader(_town_desc, _town_sl_compat);
 

	
 
@@ -308,8 +318,7 @@ static void Load_TOWN()
 
	}
 
}
 

	
 
/** Fix pointers when loading town data. */
 
static void Ptrs_TOWN()
 
	void FixPointers() const override
 
{
 
	if (IsSavegameVersionBefore(SLV_161)) return;
 

	
 
@@ -317,9 +326,10 @@ static void Ptrs_TOWN()
 
		SlObject(t, _town_desc);
 
	}
 
}
 
};
 

	
 
static const ChunkHandler HIDS{ 'HIDS', Save_HIDS, Load_HIDS, nullptr,   nullptr, CH_TABLE };
 
static const ChunkHandler CITY{ 'CITY', Save_TOWN, Load_TOWN, Ptrs_TOWN, nullptr, CH_TABLE };
 
static const HIDSChunkHandler HIDS;
 
static const CITYChunkHandler CITY;
 
static const ChunkHandlerRef town_chunk_handlers[] = {
 
	HIDS,
 
	CITY,
src/saveload/vehicle_sl.cpp
Show inline comments
 
@@ -994,8 +994,13 @@ const static SaveLoad _vehicle_desc[] = 
 
	SLEG_STRUCT("disaster", SlVehicleDisaster),
 
};
 

	
 
/** Will be called when the vehicles need to be saved. */
 
static void Save_VEHS()
 
struct VEHSChunkHandler : ChunkHandler {
 
	VEHSChunkHandler() : ChunkHandler('VEHS', CH_SPARSE_TABLE)
 
	{
 
		this->fix_pointers = true;
 
	}
 

	
 
	void Save() const override
 
{
 
	SlTableHeader(_vehicle_desc);
 

	
 
@@ -1006,8 +1011,7 @@ static void Save_VEHS()
 
	}
 
}
 

	
 
/** Will be called when vehicles need to be loaded. */
 
void Load_VEHS()
 
	void Load() const override
 
{
 
	const std::vector<SaveLoad> slt = SlCompatTableHeader(_vehicle_desc, _vehicle_sl_compat);
 

	
 
@@ -1057,14 +1061,15 @@ void Load_VEHS()
 
	}
 
}
 

	
 
void Ptrs_VEHS()
 
	void FixPointers() const override
 
{
 
	for (Vehicle *v : Vehicle::Iterate()) {
 
		SlObject(v, _vehicle_desc);
 
	}
 
}
 
};
 

	
 
static const ChunkHandler VEHS{ 'VEHS', Save_VEHS, Load_VEHS, Ptrs_VEHS, nullptr, CH_SPARSE_TABLE };
 
static const VEHSChunkHandler VEHS;
 
static const ChunkHandlerRef veh_chunk_handlers[] = {
 
	VEHS,
 
};
src/saveload/waypoint_sl.cpp
Show inline comments
 
@@ -182,7 +182,13 @@ static const SaveLoad _old_waypoint_desc
 
	SLE_CONDVAR(OldWaypoint, owner,      SLE_UINT8,                 SLV_101, SL_MAX_VERSION),
 
};
 

	
 
static void Load_WAYP()
 
struct CHKPChunkHandler : ChunkHandler {
 
	CHKPChunkHandler() : ChunkHandler('CHKP', CH_READONLY)
 
	{
 
		this->fix_pointers = true;
 
	}
 

	
 
	void Load() const override
 
{
 
	/* Precaution for when loading failed and it didn't get cleared */
 
	ResetOldWaypoints();
 
@@ -197,7 +203,7 @@ static void Load_WAYP()
 
	}
 
}
 

	
 
static void Ptrs_WAYP()
 
	void FixPointers() const override
 
{
 
	for (OldWaypoint &wp : _old_waypoints) {
 
		SlObject(&wp, _old_waypoint_desc);
 
@@ -223,8 +229,9 @@ static void Ptrs_WAYP()
 
		}
 
	}
 
}
 
};
 

	
 
static const ChunkHandler CHKP{ 'CHKP', nullptr, Load_WAYP, Ptrs_WAYP, nullptr, CH_READONLY };
 
static const CHKPChunkHandler CHKP;
 
static const ChunkHandlerRef waypoint_chunk_handlers[] = {
 
	CHKP,
 
};
0 comments (0 inline, 0 general)