dave/openttd
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Merge branch 'master' into jgrpp-beta

Browse Source 
# Conflicts:
#	src/cargopacket.h
#	src/lang/korean.txt
#	src/linkgraph/linkgraph.h
#	src/linkgraph/linkgraphjob.h
#	src/linkgraph/linkgraphschedule.h
#	src/network/network_admin.h
#	src/network/network_func.h
#	src/network/network_server.cpp
#	src/network/network_server.h
#	src/order_base.h
#	src/rail_cmd.cpp
#	src/saveload/company_sl.cpp
#	src/saveload/depot_sl.cpp
#	src/saveload/economy_sl.cpp
#	src/saveload/linkgraph_sl.cpp
#	src/saveload/map_sl.cpp
#	src/saveload/newgrf_sl.cpp
#	src/saveload/order_sl.cpp
#	src/saveload/saveload.cpp
#	src/saveload/saveload.h
#	src/saveload/signs_sl.cpp
#	src/saveload/station_sl.cpp
#	src/saveload/subsidy_sl.cpp
#	src/saveload/town_sl.cpp
#	src/saveload/vehicle_sl.cpp
#	src/script/api/script_object.cpp
#	src/settings.cpp
#	src/string.cpp
#	src/string_func.h
#	src/table/CMakeLists.txt
#	src/table/settings/settings.ini
#	src/viewport_sprite_sorter_sse4.cpp
This commit is contained in:
Jonathan G Rennison
2021-10-18 18:01:27 +01:00
parent 406b81abb1 f8dd5dd00a
commit 544da99102
113 changed files with 721 additions and 755 deletions
Download Patch File Download Diff File Expand all files Collapse all files

1
src/saveload/ai_sl.cpp
View File

@@ -30,7 +30,6 @@ static const SaveLoad _ai_company[] = {
SLEG_SSTR(_ai_saveload_settings, SLE_STR),
SLEG_CONDVAR(_ai_saveload_version, SLE_UINT32, SLV_108, SL_MAX_VERSION),
SLEG_CONDVAR(_ai_saveload_is_random, SLE_BOOL, SLV_136, SL_MAX_VERSION),
SLE_END()
};
static void SaveReal_AIPL(int *index_ptr)

1
src/saveload/autoreplace_sl.cpp
View File

@@ -21,7 +21,6 @@ static const SaveLoad _engine_renew_desc[] = {
SLE_REF(EngineRenew, next, REF_ENGINE_RENEWS),
SLE_CONDVAR(EngineRenew, group_id, SLE_UINT16, SLV_60, SL_MAX_VERSION),
SLE_CONDVAR(EngineRenew, replace_when_old, SLE_BOOL, SLV_175, SL_MAX_VERSION),
SLE_END()
};
static void Save_ERNW()

1
src/saveload/bridge_signal_sl.cpp
View File

@@ -19,7 +19,6 @@ struct LongBridgeSignalStorageStub {
static const SaveLoad _long_bridge_signal_storage_stub_desc[] = {
SLE_VAR(LongBridgeSignalStorageStub, length, SLE_UINT32),
SLE_END()
};
static void Load_XBSS()

1
src/saveload/cargomonitor_sl.cpp
View File

@@ -24,7 +24,6 @@ struct TempStorage {
static const SaveLoad _cargomonitor_pair_desc[] = {
SLE_VAR(TempStorage, number, SLE_UINT32),
SLE_VAR(TempStorage, amount, SLE_UINT32),
SLE_END()
};
static CargoMonitorID FixupCargoMonitor(CargoMonitorID number)

8
src/saveload/cargopacket_sl.cpp
View File

@@ -108,7 +108,7 @@ extern btree::btree_map<uint64, Money> _cargo_packet_deferred_payments;
* some of the variables itself are private.
* @return the saveload description for CargoPackets.
*/
const SaveLoad *GetCargoPacketDesc()
SaveLoadTable GetCargoPacketDesc()
{
static const SaveLoad _cargopacket_desc[] = {
SLE_VAR(CargoPacket, source, SLE_UINT16),
@@ -122,8 +122,6 @@ const SaveLoad *GetCargoPacketDesc()
/* Used to be paid_for, but that got changed. */
SLE_CONDNULL(1, SL_MIN_VERSION, SLV_121),
SLE_END()
};
return _cargopacket_desc;
}
@@ -136,7 +134,7 @@ static void Save_CAPA()
std::vector<SaveLoad> filtered_packet_desc = SlFilterObject(GetCargoPacketDesc());
for (CargoPacket *cp : CargoPacket::Iterate()) {
SlSetArrayIndex(cp->index);
SlObjectSaveFiltered(cp, filtered_packet_desc.data());
SlObjectSaveFiltered(cp, filtered_packet_desc);
}
}
@@ -149,7 +147,7 @@ static void Load_CAPA()
int index;
while ((index = SlIterateArray()) != -1) {
CargoPacket *cp = new (index) CargoPacket();
SlObjectLoadFiltered(cp, filtered_packet_desc.data());
SlObjectLoadFiltered(cp, filtered_packet_desc);
}
}

3
src/saveload/cheat_sl.cpp
View File

@@ -79,7 +79,6 @@ static void Load_CHTX()
SLE_STR(CheatsExtLoad, name, SLE_STRB, 256),
SLE_VAR(CheatsExtLoad, cht.been_used, SLE_BOOL),
SLE_VAR(CheatsExtLoad, cht.value, SLE_BOOL),
SLE_END()
};
CheatsExtLoad current_cheat;
@@ -122,7 +121,6 @@ static void Save_CHTX()
SLE_STR(CheatsExtSave, name, SLE_STR, 0),
SLE_VAR(CheatsExtSave, cht.been_used, SLE_BOOL),
SLE_VAR(CheatsExtSave, cht.value, SLE_BOOL),
SLE_END()
};
SlAutolength([](void *) {
@@ -153,7 +151,6 @@ static const SaveLoad _settings_ext_save_desc[] = {
SLE_VAR(SettingsExtSave, flags, SLE_UINT32),
SLE_STR(SettingsExtSave, name, SLE_STR, 0),
SLE_VAR(SettingsExtSave, setting_length, SLE_UINT32),
SLE_END()
};

11
src/saveload/company_sl.cpp
View File

@@ -294,8 +294,6 @@ static const SaveLoad _company_desc[] = {
SLE_CONDVAR(CompanyProperties, tree_limit, SLE_UINT32, SLV_175, SL_MAX_VERSION),
SLE_CONDVAR_X(CompanyProperties, purchase_land_limit, SLE_UINT32, SL_MIN_VERSION, SL_MAX_VERSION, SlXvFeatureTest(XSLFTO_AND, XSLFI_BUY_LAND_RATE_LIMIT)),
SLE_CONDVAR_X(CompanyProperties, build_object_limit, SLE_UINT32, SL_MIN_VERSION, SL_MAX_VERSION, SlXvFeatureTest(XSLFTO_AND, XSLFI_BUILD_OBJECT_RATE_LIMIT)),
SLE_END()
};
static const SaveLoad _company_settings_desc[] = {
@@ -316,8 +314,6 @@ static const SaveLoad _company_settings_desc[] = {
SLE_CONDVAR_X(Company, settings.vehicle.auto_timetable_by_default, SLE_BOOL, SL_MIN_VERSION, SL_MAX_VERSION, SlXvFeatureTest(XSLFTO_AND, XSLFI_AUTO_TIMETABLE, 2, 2)),
SLE_CONDNULL(63, SLV_2, SLV_144), // old reserved space
SLE_END()
};
static const SaveLoad _company_settings_skip_desc[] = {
@@ -339,8 +335,6 @@ static const SaveLoad _company_settings_skip_desc[] = {
SLE_CONDNULL_X(1, SL_MIN_VERSION, SL_MAX_VERSION, SlXvFeatureTest(XSLFTO_AND, XSLFI_AUTO_TIMETABLE, 2, 2)), // settings.vehicle.auto_timetable_by_default
SLE_CONDNULL(63, SLV_2, SLV_144), // old reserved space
SLE_END()
};
static const SaveLoad _company_economy_desc[] = {
@@ -356,8 +350,6 @@ static const SaveLoad _company_economy_desc[] = {
SLE_CONDARR(CompanyEconomyEntry, delivered_cargo, SLE_UINT32, 32, SLV_170, SLV_EXTEND_CARGOTYPES),
SLE_CONDARR(CompanyEconomyEntry, delivered_cargo, SLE_UINT32, NUM_CARGO, SLV_EXTEND_CARGOTYPES, SL_MAX_VERSION),
SLE_VAR(CompanyEconomyEntry, performance_history, SLE_INT32),
SLE_END()
};
/* We do need to read this single value, as the bigger it gets, the more data is stored */
@@ -393,7 +385,6 @@ static const SaveLoad _company_ai_desc[] = {
SLE_CONDNULL(32, SL_MIN_VERSION, SLV_107),
SLE_CONDNULL(64, SLV_2, SLV_107),
SLE_END()
};
static const SaveLoad _company_ai_build_rec_desc[] = {
@@ -402,14 +393,12 @@ static const SaveLoad _company_ai_build_rec_desc[] = {
SLE_CONDNULL(2, SL_MIN_VERSION, SLV_6),
SLE_CONDNULL(4, SLV_6, SLV_107),
SLE_CONDNULL(8, SL_MIN_VERSION, SLV_107),
SLE_END()
};
static const SaveLoad _company_livery_desc[] = {
SLE_CONDVAR(Livery, in_use, SLE_UINT8, SLV_34, SL_MAX_VERSION),
SLE_CONDVAR(Livery, colour1, SLE_UINT8, SLV_34, SL_MAX_VERSION),
SLE_CONDVAR(Livery, colour2, SLE_UINT8, SLV_34, SL_MAX_VERSION),
SLE_END()
};
static void SaveLoad_PLYR_common(Company *c, CompanyProperties *cprops)

1
src/saveload/depot_sl.cpp
View File

@@ -26,7 +26,6 @@ static const SaveLoad _depot_desc[] = {
SLE_CONDSTR(Depot, name, SLE_STR, 0, SLV_141, SL_MAX_VERSION),
SLE_CONDVAR(Depot, build_date, SLE_INT32, SLV_142, SL_MAX_VERSION),
SLE_CONDNULL_X(4, SL_MIN_VERSION, SL_MAX_VERSION, SlXvFeatureTest(XSLFTO_AND, XSLFI_SPRINGPP, 5)),
SLE_END()
};
static void Save_DEPT()

2
src/saveload/economy_sl.cpp
View File

@@ -47,7 +47,6 @@ static const SaveLoad _economy_desc[] = {
SLE_VAR(Economy, infl_amount_pr, SLE_UINT8),
SLE_CONDVAR(Economy, industry_daily_change_counter, SLE_UINT32, SLV_102, SL_MAX_VERSION),
SLE_CONDNULL_X(8, SL_MIN_VERSION, SL_MAX_VERSION, SlXvFeatureTest(XSLFTO_AND, XSLFI_JOKERPP)),
SLE_END()
};
/** Economy variables */
@@ -68,7 +67,6 @@ static const SaveLoad _cargopayment_desc[] = {
SLE_VAR(CargoPayment, route_profit, SLE_INT64),
SLE_VAR(CargoPayment, visual_profit, SLE_INT64),
SLE_CONDVAR_X(CargoPayment, visual_transfer, SLE_INT64, SLV_181, SL_MAX_VERSION, SlXvFeatureTest(XSLFTO_OR, XSLFI_CHILLPP)),
SLE_END()
};
static void Save_CAPY()

3
src/saveload/engine_sl.cpp
View File

@@ -43,8 +43,6 @@ static const SaveLoad _engine_desc[] = {
SLE_CONDSTR(Engine, name, SLE_STR, 0, SLV_84, SL_MAX_VERSION),
SLE_CONDNULL(16, SLV_2, SLV_144), // old reserved space
SLE_END()
};
static std::vector<Engine*> _temp_engine;
@@ -174,7 +172,6 @@ static const SaveLoad _engine_id_mapping_desc[] = {
SLE_VAR(EngineIDMapping, internal_id, SLE_UINT16),
SLE_VAR(EngineIDMapping, type, SLE_UINT8),
SLE_VAR(EngineIDMapping, substitute_id, SLE_UINT8),
SLE_END()
};
static void Save_EIDS()

4
src/saveload/extended_ver_sl.cpp
View File

@@ -463,7 +463,6 @@ static void Save_SLXI()
static const SaveLoad _xlsi_sub_chunk_desc[] = {
SLE_STR(SlxiSubChunkInfo, name, SLE_STR, 0),
SLE_END()
};
// calculate lengths
@@ -550,9 +549,8 @@ static void Load_SLXI()
if (chunk_flags != 0) SlErrorCorruptFmt("SLXI chunk: unknown chunk header flags: 0x%X", chunk_flags);
char name_buffer[256];
const SaveLoadGlobVarList xlsi_sub_chunk_name_desc[] = {
const SaveLoad xlsi_sub_chunk_name_desc[] = {
SLEG_STR(name_buffer, SLE_STRB),
SLEG_END()
};
auto version_error = [](StringID str, const char *feature, int64 p1, int64 p2) {

3
src/saveload/game_sl.cpp
View File

@@ -30,7 +30,6 @@ static const SaveLoad _game_script[] = {
SLEG_SSTR(_game_saveload_settings, SLE_STR),
SLEG_VAR(_game_saveload_version, SLE_UINT32),
SLEG_VAR(_game_saveload_is_random, SLE_BOOL),
SLE_END()
};
static void SaveReal_GSDT(int *index_ptr)
@@ -117,12 +116,10 @@ static uint _game_saveload_strings;
static const SaveLoad _game_language_header[] = {
SLEG_SSTR(_game_saveload_string, SLE_STR),
SLEG_VAR(_game_saveload_strings, SLE_UINT32),
SLE_END()
};
static const SaveLoad _game_language_string[] = {
SLEG_SSTR(_game_saveload_string, SLE_STR | SLF_ALLOW_CONTROL),
SLE_END()
};
static void SaveReal_GSTR(const LanguageStrings *ls)

15
src/saveload/gamelog_sl.cpp
View File

@@ -18,13 +18,11 @@
static const SaveLoad _glog_action_desc[] = {
SLE_VAR(LoggedAction, tick, SLE_UINT16),
SLE_END()
};
static const SaveLoad _glog_mode_desc[] = {
SLE_VAR(LoggedChange, mode.mode, SLE_UINT8),
SLE_VAR(LoggedChange, mode.landscape, SLE_UINT8),
SLE_END()
};
static char old_revision_text[GAMELOG_REVISION_LENGTH];
@@ -35,62 +33,53 @@ static const SaveLoad _glog_revision_desc[] = {
SLE_VAR(LoggedChange, revision.newgrf, SLE_UINT32),
SLE_VAR(LoggedChange, revision.slver, SLE_UINT16),
SLE_VAR(LoggedChange, revision.modified, SLE_UINT8),
SLE_END()
};
static const SaveLoad _glog_oldver_desc[] = {
SLE_VAR(LoggedChange, oldver.type, SLE_UINT32),
SLE_VAR(LoggedChange, oldver.version, SLE_UINT32),
SLE_END()
};
static const SaveLoad _glog_setting_desc[] = {
SLE_STR(LoggedChange, setting.name, SLE_STR, 128),
SLE_VAR(LoggedChange, setting.oldval, SLE_INT32),
SLE_VAR(LoggedChange, setting.newval, SLE_INT32),
SLE_END()
};
static const SaveLoad _glog_grfadd_desc[] = {
SLE_VAR(LoggedChange, grfadd.grfid, SLE_UINT32 ),
SLE_ARR(LoggedChange, grfadd.md5sum, SLE_UINT8, 16),
SLE_END()
};
static const SaveLoad _glog_grfrem_desc[] = {
SLE_VAR(LoggedChange, grfrem.grfid, SLE_UINT32),
SLE_END()
};
static const SaveLoad _glog_grfcompat_desc[] = {
SLE_VAR(LoggedChange, grfcompat.grfid, SLE_UINT32 ),
SLE_ARR(LoggedChange, grfcompat.md5sum, SLE_UINT8, 16),
SLE_END()
};
static const SaveLoad _glog_grfparam_desc[] = {
SLE_VAR(LoggedChange, grfparam.grfid, SLE_UINT32),
SLE_END()
};
static const SaveLoad _glog_grfmove_desc[] = {
SLE_VAR(LoggedChange, grfmove.grfid, SLE_UINT32),
SLE_VAR(LoggedChange, grfmove.offset, SLE_INT32),
SLE_END()
};
static const SaveLoad _glog_grfbug_desc[] = {
SLE_VAR(LoggedChange, grfbug.data, SLE_UINT64),
SLE_VAR(LoggedChange, grfbug.grfid, SLE_UINT32),
SLE_VAR(LoggedChange, grfbug.bug, SLE_UINT8),
SLE_END()
};
static const SaveLoad _glog_emergency_desc[] = {
SLE_END()
SLE_CONDNULL(0, SL_MIN_VERSION, SL_MIN_VERSION), // Just an empty list, to keep the rest of the code easier.
};
static const SaveLoad * const _glog_desc[] = {
static const SaveLoadTable _glog_desc[] = {
_glog_mode_desc,
_glog_revision_desc,
_glog_oldver_desc,

1
src/saveload/goal_sl.cpp
View File

@@ -21,7 +21,6 @@ static const SaveLoad _goals_desc[] = {
SLE_STR(Goal, text, SLE_STR | SLF_ALLOW_CONTROL, 0),
SLE_CONDSTR(Goal, progress, SLE_STR | SLF_ALLOW_CONTROL, 0, SLV_182, SL_MAX_VERSION),
SLE_CONDVAR(Goal, completed, SLE_BOOL, SLV_182, SL_MAX_VERSION),
SLE_END()
};
static void Save_GOAL()

1
src/saveload/group_sl.cpp
View File

@@ -26,7 +26,6 @@ static const SaveLoad _group_desc[] = {
SLE_CONDVAR(Group, livery.colour1, SLE_UINT8, SLV_GROUP_LIVERIES, SL_MAX_VERSION),
SLE_CONDVAR(Group, livery.colour2, SLE_UINT8, SLV_GROUP_LIVERIES, SL_MAX_VERSION),
SLE_CONDVAR(Group, parent, SLE_UINT16, SLV_189, SL_MAX_VERSION),
SLE_END()
};
static void Save_GRPS()

4
src/saveload/industry_sl.cpp
View File

@@ -75,8 +75,6 @@ static const SaveLoad _industry_desc[] = {
SLE_CONDSSTR(Industry, text, SLE_STR | SLF_ALLOW_CONTROL, SLV_INDUSTRY_TEXT, SL_MAX_VERSION),
SLE_CONDNULL(32, SLV_2, SLV_144), // old reserved space
SLE_END()
};
static void Save_INDY()
@@ -139,7 +137,6 @@ static void Ptrs_INDY()
/** Description of the data to save and load in #IndustryBuildData. */
static const SaveLoad _industry_builder_desc[] = {
SLEG_VAR(_industry_builder.wanted_inds, SLE_UINT32),
SLEG_END()
};
/** Load/save industry builder. */
@@ -155,7 +152,6 @@ static const SaveLoad _industrytype_builder_desc[] = {
SLE_VAR(IndustryTypeBuildData, target_count, SLE_UINT16),
SLE_VAR(IndustryTypeBuildData, max_wait, SLE_UINT16),
SLE_VAR(IndustryTypeBuildData, wait_count, SLE_UINT16),
SLE_END()
};
/** Save industry-type build data. */

1
src/saveload/labelmaps_sl.cpp
View File

@@ -104,7 +104,6 @@ struct LabelObject {
static const SaveLoad _label_object_desc[] = {
SLE_VAR(LabelObject, label, SLE_UINT32),
SLE_END(),
};
static void Save_RAIL()

34
src/saveload/linkgraph_sl.cpp
View File

@@ -28,13 +28,12 @@ static uint16 _num_nodes;
* Get a SaveLoad array for a link graph.
* @return SaveLoad array for link graph.
*/
const SaveLoad *GetLinkGraphDesc()
SaveLoadTable GetLinkGraphDesc()
{
static const SaveLoad link_graph_desc[] = {
SLE_VAR(LinkGraph, last_compression, SLE_INT32),
SLEG_VAR(_num_nodes, SLE_UINT16),
SLE_VAR(LinkGraph, cargo, SLE_UINT8),
SLE_END()
};
return link_graph_desc;
}
@@ -55,7 +54,7 @@ void GetLinkGraphJobDayLengthScaleAfterLoad(LinkGraphJob *lgj)
* Of course the settings have to be saved and loaded, too, to avoid desyncs.
* @return Array of SaveLoad structs.
*/
const SaveLoad *GetLinkGraphJobDesc()
SaveLoadTable GetLinkGraphJobDesc()
{
static std::vector<SaveLoad> saveloads;
static const char *prefix = "linkgraph.";
@@ -84,28 +83,25 @@ const SaveLoad *GetLinkGraphJobDesc()
SLE_VAR(LinkGraphJob, join_date_ticks, SLE_INT32),
SLE_CONDVAR_X(LinkGraphJob, start_date_ticks, SLE_INT32, SL_MIN_VERSION, SL_MAX_VERSION, SlXvFeatureTest(XSLFTO_AND, XSLFI_LINKGRAPH_DAY_SCALE)),
SLE_VAR(LinkGraphJob, link_graph.index, SLE_UINT16),
SLE_END()
};
int i = 0;
do {
saveloads.push_back(job_desc[i++]);
} while (saveloads.back().cmd != SL_END);
for (auto &sld : job_desc) {
saveloads.push_back(sld);
}
}
return &saveloads[0];
return saveloads;
}
/**
* Get a SaveLoad array for the link graph schedule.
* @return SaveLoad array for the link graph schedule.
*/
const SaveLoad *GetLinkGraphScheduleDesc()
SaveLoadTable GetLinkGraphScheduleDesc()
{
static const SaveLoad schedule_desc[] = {
SLE_LST(LinkGraphSchedule, schedule, REF_LINK_GRAPH),
SLE_LST(LinkGraphSchedule, running, REF_LINK_GRAPH_JOB),
SLE_END()
};
return schedule_desc;
}
@@ -121,7 +117,6 @@ static const SaveLoad _node_desc[] = {
SLE_VAR(Node, demand, SLE_UINT32),
SLE_VAR(Node, station, SLE_UINT16),
SLE_VAR(Node, last_update, SLE_INT32),
SLE_END()
};
/**
@@ -134,7 +129,6 @@ static const SaveLoad _edge_desc[] = {
SLE_VAR(Edge, last_unrestricted_update, SLE_INT32),
SLE_CONDVAR(Edge, last_restricted_update, SLE_INT32, SLV_187, SL_MAX_VERSION),
SLE_VAR(Edge, next_edge, SLE_UINT16),
SLE_END()
};
std::vector<SaveLoad> _filtered_node_desc;
@@ -157,10 +151,10 @@ void Save_LinkGraph(LinkGraph &lg)
uint16 size = lg.Size();
for (NodeID from = 0; from < size; ++from) {
Node *node = &lg.nodes[from];
SlObjectSaveFiltered(node, _filtered_node_desc.data());
SlObjectSaveFiltered(node, _filtered_node_desc);
/* ... but as that wasted a lot of space we save a sparse matrix now. */
for (NodeID to = from; to != INVALID_NODE; to = lg.edges[from][to].next_edge) {
SlObjectSaveFiltered(&lg.edges[from][to], _filtered_edge_desc.data());
SlObjectSaveFiltered(&lg.edges[from][to], _filtered_edge_desc);
}
}
}
@@ -174,17 +168,17 @@ void Load_LinkGraph(LinkGraph &lg)
uint size = lg.Size();
for (NodeID from = 0; from < size; ++from) {
Node *node = &lg.nodes[from];
SlObjectLoadFiltered(node, _filtered_node_desc.data());
SlObjectLoadFiltered(node, _filtered_node_desc);
if (IsSavegameVersionBefore(SLV_191)) {
/* We used to save the full matrix ... */
for (NodeID to = 0; to < size; ++to) {
SlObjectLoadFiltered(&lg.edges[from][to], _filtered_edge_desc.data());
SlObjectLoadFiltered(&lg.edges[from][to], _filtered_edge_desc);
}
} else {
/* ... but as that wasted a lot of space we save a sparse matrix now. */
for (NodeID to = from; to != INVALID_NODE; to = lg.edges[from][to].next_edge) {
if (to >= size) SlErrorCorrupt("Link graph structure overflow");
SlObjectLoadFiltered(&lg.edges[from][to], _filtered_edge_desc.data());
SlObjectLoadFiltered(&lg.edges[from][to], _filtered_edge_desc);
}
}
}
@@ -196,7 +190,7 @@ void Load_LinkGraph(LinkGraph &lg)
*/
static void DoSave_LGRJ(LinkGraphJob *lgj)
{
SlObjectSaveFiltered(lgj, _filtered_job_desc.data());
SlObjectSaveFiltered(lgj, _filtered_job_desc);
_num_nodes = lgj->Size();
SlObjectSaveFiltered(const_cast<LinkGraph *>(&lgj->Graph()), GetLinkGraphDesc()); // GetLinkGraphDesc has no conditionals
Save_LinkGraph(const_cast<LinkGraph &>(lgj->Graph()));
@@ -245,7 +239,7 @@ static void Load_LGRJ()
NOT_REACHED();
}
LinkGraphJob *lgj = new (index) LinkGraphJob();
SlObjectLoadFiltered(lgj, _filtered_job_desc.data());
SlObjectLoadFiltered(lgj, _filtered_job_desc);
if (SlXvIsFeatureMissing(XSLFI_LINKGRAPH_DAY_SCALE)) {
GetLinkGraphJobDayLengthScaleAfterLoad(lgj);
}

3
src/saveload/map_sl.cpp
View File

@@ -25,10 +25,9 @@ static uint32 _map_dim_y;
extern bool _sl_maybe_chillpp;
static const SaveLoadGlobVarList _map_dimensions[] = {
static const SaveLoad _map_dimensions[] = {
SLEG_CONDVAR(_map_dim_x, SLE_UINT32, SLV_6, SL_MAX_VERSION),
SLEG_CONDVAR(_map_dim_y, SLE_UINT32, SLV_6, SL_MAX_VERSION),
SLEG_END()
};
static void Save_MAPS()

9
src/saveload/misc_sl.cpp
View File

@@ -72,7 +72,7 @@ void ResetViewportAfterLoadGame()
byte _age_cargo_skip_counter; ///< Skip aging of cargo? Used before savegame version 162.
static const SaveLoadGlobVarList _date_desc[] = {
static const SaveLoad _date_desc[] = {
SLEG_CONDVAR(_date, SLE_FILE_U16 | SLE_VAR_I32, SL_MIN_VERSION, SLV_31),
SLEG_CONDVAR(_date, SLE_INT32, SLV_31, SL_MAX_VERSION),
SLEG_VAR(_date_fract, SLE_UINT16),
@@ -99,10 +99,9 @@ static const SaveLoadGlobVarList _date_desc[] = {
SLEG_CONDVAR_X(_road_layout_change_counter, SLE_UINT32, SL_MIN_VERSION, SL_MAX_VERSION, SlXvFeatureTest(XSLFTO_AND, XSLFI_ROAD_LAYOUT_CHANGE_CTR)),
SLEG_CONDVAR_X(_extra_aspects, SLE_UINT8, SL_MIN_VERSION, SL_MAX_VERSION, SlXvFeatureTest(XSLFTO_AND, XSLFI_REALISTIC_TRAIN_BRAKING, 4)),
SLE_CONDNULL(4, SLV_11, SLV_120),
SLEG_END()
};
static const SaveLoadGlobVarList _date_check_desc[] = {
static const SaveLoad _date_check_desc[] = {
SLEG_CONDVAR(_load_check_data.current_date, SLE_FILE_U16 | SLE_VAR_I32, SL_MIN_VERSION, SLV_31),
SLEG_CONDVAR(_load_check_data.current_date, SLE_INT32, SLV_31, SL_MAX_VERSION),
SLE_NULL(2), // _date_fract
@@ -129,7 +128,6 @@ static const SaveLoadGlobVarList _date_check_desc[] = {
SLE_CONDNULL_X(4, SL_MIN_VERSION, SL_MAX_VERSION, SlXvFeatureTest(XSLFTO_AND, XSLFI_ROAD_LAYOUT_CHANGE_CTR)), // _road_layout_change_counter
SLE_CONDNULL_X(1, SL_MIN_VERSION, SL_MAX_VERSION, SlXvFeatureTest(XSLFTO_AND, XSLFI_REALISTIC_TRAIN_BRAKING, 4)), // _extra_aspects
SLE_CONDNULL(4, SLV_11, SLV_120),
SLEG_END()
};
/* Save load date related variables as well as persistent tick counters
@@ -149,13 +147,12 @@ static void Check_DATE()
}
static const SaveLoadGlobVarList _view_desc[] = {
static const SaveLoad _view_desc[] = {
SLEG_CONDVAR(_saved_scrollpos_x, SLE_FILE_I16 | SLE_VAR_I32, SL_MIN_VERSION, SLV_6),
SLEG_CONDVAR(_saved_scrollpos_x, SLE_INT32, SLV_6, SL_MAX_VERSION),
SLEG_CONDVAR(_saved_scrollpos_y, SLE_FILE_I16 | SLE_VAR_I32, SL_MIN_VERSION, SLV_6),
SLEG_CONDVAR(_saved_scrollpos_y, SLE_INT32, SLV_6, SL_MAX_VERSION),
SLEG_VAR(_saved_scrollpos_zoom, SLE_UINT8),
SLEG_END()
};
static void SaveLoad_VIEW()

2
src/saveload/newgrf_sl.cpp
View File

@@ -21,7 +21,6 @@ static const SaveLoad _newgrf_mapping_desc[] = {
SLE_VAR(EntityIDMapping, grfid, SLE_UINT32),
SLE_VAR(EntityIDMapping, entity_id, SLE_UINT8),
SLE_VAR(EntityIDMapping, substitute_id, SLE_UINT8),
SLE_END()
};
/**
@@ -69,7 +68,6 @@ static const SaveLoad _grfconfig_desc[] = {
SLE_VAR(GRFConfig, num_params, SLE_UINT8),
SLE_CONDVAR(GRFConfig, palette, SLE_UINT8, SLV_101, SL_MAX_VERSION),
SLEG_CONDSSTR_X(_grf_name, 0, SL_MIN_VERSION, SL_MAX_VERSION, SlXvFeatureTest(XSLFTO_AND, XSLFI_NEWGRF_INFO_EXTRA)),
SLE_END()
};

2
src/saveload/object_sl.cpp
View File

@@ -25,8 +25,6 @@ static const SaveLoad _object_desc[] = {
SLE_CONDVAR(Object, colour, SLE_UINT8, SLV_148, SL_MAX_VERSION),
SLE_CONDVAR(Object, view, SLE_UINT8, SLV_155, SL_MAX_VERSION),
SLE_CONDVAR(Object, type, SLE_UINT16, SLV_186, SL_MAX_VERSION),
SLE_END()
};
static void Save_OBJS()

2
src/saveload/oldloader.cpp
View File

@@ -236,7 +236,7 @@ static inline bool CheckOldSavegameType(FILE *f, char *temp, const char *last, u
bool ret = VerifyOldNameChecksum(temp, len);
temp[len - 2] = '\0'; // name is null-terminated in savegame, but it's better to be sure
str_validate(temp, last);
StrMakeValidInPlace(temp, last);
return ret;
}

20
src/saveload/order_sl.cpp
View File

@@ -113,7 +113,7 @@ Order UnpackOldOrder(uint16 packed)
return order;
}
const SaveLoad *GetOrderDescription()
SaveLoadTable GetOrderDescription()
{
static const SaveLoad _order_desc[] = {
SLE_VAR(Order, type, SLE_UINT8),
@@ -135,7 +135,6 @@ const SaveLoad *GetOrderDescription()
/* Leftover from the minor savegame version stuff
* We will never use those free bytes, but we have to keep this line to allow loading of old savegames */
SLE_CONDNULL(10, SLV_5, SLV_36),
SLE_END()
};
return _order_desc;
@@ -148,7 +147,7 @@ static void Save_ORDR()
_filtered_desc = SlFilterObject(GetOrderDescription());
for (Order *order : Order::Iterate()) {
SlSetArrayIndex(order->index);
SlObjectSaveFiltered(order, _filtered_desc.data());
SlObjectSaveFiltered(order, _filtered_desc);
}
}
@@ -206,19 +205,18 @@ static void Load_ORDR()
while ((index = SlIterateArray()) != -1) {
Order *order = new (index) Order();
SlObjectLoadFiltered(order, _filtered_desc.data());
SlObjectLoadFiltered(order, _filtered_desc);
}
}
}
const SaveLoad *GetOrderExtraInfoDescription()
const SaveLoadTable GetOrderExtraInfoDescription()
{
static const SaveLoad _order_extra_info_desc[] = {
SLE_CONDARR_X(OrderExtraInfo, cargo_type_flags, SLE_UINT8, 32, SL_MIN_VERSION, SL_MAX_VERSION, SlXvFeatureTest(XSLFTO_AND, XSLFI_CARGO_TYPE_ORDERS, 1, 2)),
SLE_CONDARR_X(OrderExtraInfo, cargo_type_flags, SLE_UINT8, NUM_CARGO, SL_MIN_VERSION, SL_MAX_VERSION, SlXvFeatureTest(XSLFTO_AND, XSLFI_CARGO_TYPE_ORDERS, 3)),
SLE_CONDVAR_X(OrderExtraInfo, xflags, SLE_UINT8, SL_MIN_VERSION, SL_MAX_VERSION, SlXvFeatureTest(XSLFTO_AND, XSLFI_TIMETABLE_EXTRA)),
SLE_CONDVAR_X(OrderExtraInfo, xdata, SLE_UINT32, SL_MIN_VERSION, SL_MAX_VERSION, SlXvFeatureTest(XSLFTO_AND, XSLFI_ORDER_EXTRA_DATA)),
SLE_END()
};
return _order_extra_info_desc;
@@ -230,7 +228,7 @@ void Save_ORDX()
for (Order *order : Order::Iterate()) {
if (order->extra) {
SlSetArrayIndex(order->index);
SlObjectSaveFiltered(order->extra.get(), _filtered_desc.data());
SlObjectSaveFiltered(order->extra.get(), _filtered_desc);
}
}
}
@@ -243,7 +241,7 @@ void Load_ORDX()
Order *order = Order::GetIfValid(index);
assert(order != nullptr);
order->AllocExtraInfo();
SlObjectLoadFiltered(order->extra.get(), _filtered_desc.data());
SlObjectLoadFiltered(order->extra.get(), _filtered_desc);
}
}
@@ -257,7 +255,7 @@ static void Ptrs_ORDR()
}
}
const SaveLoad *GetOrderListDescription()
SaveLoadTable GetOrderListDescription()
{
static const SaveLoad _orderlist_desc[] = {
SLE_REF(OrderList, first, REF_ORDER),
@@ -269,7 +267,6 @@ const SaveLoad *GetOrderListDescription()
SLE_CONDVAR_X(OrderList, scheduled_dispatch_max_delay, SLE_INT32, SL_MIN_VERSION, SL_MAX_VERSION, SlXvFeatureTest(XSLFTO_AND, XSLFI_SCHEDULED_DISPATCH)),
SLEG_CONDVAR_X(_jokerpp_separation_mode, SLE_UINT32, SL_MIN_VERSION, SL_MAX_VERSION, SlXvFeatureTest(XSLFTO_AND, XSLFI_JOKERPP)),
SLE_CONDNULL_X(21, SL_MIN_VERSION, SL_MAX_VERSION, SlXvFeatureTest(XSLFTO_AND, XSLFI_JOKERPP)),
SLE_END()
};
return _orderlist_desc;
@@ -312,7 +309,7 @@ void Ptrs_ORDL()
}
}
const SaveLoad *GetOrderBackupDescription()
SaveLoadTable GetOrderBackupDescription()
{
static const SaveLoad _order_backup_desc[] = {
SLE_VAR(OrderBackup, user, SLE_UINT32),
@@ -338,7 +335,6 @@ const SaveLoad *GetOrderBackupDescription()
SLE_CONDVAR_X(OrderBackup, scheduled_dispatch_start_date, SLE_INT32, SL_MIN_VERSION, SL_MAX_VERSION, SlXvFeatureTest(XSLFTO_AND, XSLFI_SCHEDULED_DISPATCH, 2)),
SLE_CONDVAR_X(OrderBackup, scheduled_dispatch_start_full_date_fract, SLE_UINT16, SL_MIN_VERSION, SL_MAX_VERSION, SlXvFeatureTest(XSLFTO_AND, XSLFI_SCHEDULED_DISPATCH, 2)),
SLE_CONDVAR_X(OrderBackup, scheduled_dispatch_max_delay, SLE_INT32, SL_MIN_VERSION, SL_MAX_VERSION, SlXvFeatureTest(XSLFTO_AND, XSLFI_SCHEDULED_DISPATCH, 2)),
SLE_END()
};
return _order_backup_desc;

1
src/saveload/plans_sl.cpp
View File

@@ -22,7 +22,6 @@ static const SaveLoad _plan_desc[] = {
SLE_CONDSSTR_X(Plan, name, 0, SL_MIN_VERSION, SL_MAX_VERSION, SlXvFeatureTest(XSLFTO_AND, XSLFI_ENH_VIEWPORT_PLANS, 3)),
SLE_CONDSSTR_X(Plan, name, 0, SL_MIN_VERSION, SL_MAX_VERSION, SlXvFeatureTest(XSLFTO_AND, XSLFI_JOKERPP, SL_JOKER_1_20)),
SLE_CONDVAR_X(Plan, colour, SLE_UINT8, SL_MIN_VERSION, SL_MAX_VERSION, SlXvFeatureTest(XSLFTO_AND, XSLFI_ENH_VIEWPORT_PLANS, 4)),
SLE_END()
};
static void RealSave_PLAN(Plan *p)

147
src/saveload/saveload.cpp
View File

@@ -1112,7 +1112,7 @@ static void SlString(void *ptr, size_t length, VarType conv)
if ((conv & SLF_ALLOW_NEWLINE) != 0) {
settings = settings | SVS_ALLOW_NEWLINE;
}
str_validate((char *)ptr, (char *)ptr + len, settings);
StrMakeValidInPlace((char *)ptr, (char *)ptr + len, settings);
break;
}
case SLA_PTRS: break;
@@ -1151,7 +1151,7 @@ static void SlStdString(std::string &str, VarType conv)
if ((conv & SLF_ALLOW_NEWLINE) != 0) {
settings = settings | SVS_ALLOW_NEWLINE;
}
str_validate_inplace(str, settings);
StrMakeValidInPlace(str, settings);
break;
}
case SLA_PTRS: break;
@@ -1593,10 +1593,10 @@ static void SlDeque(void *deque, VarType conv)
/** Are we going to save this object or not? */
static inline bool SlIsObjectValidInSavegame(const SaveLoad *sld)
static inline bool SlIsObjectValidInSavegame(const SaveLoad &sld)
{
if (!sld->ext_feature_test.IsFeaturePresent(_sl_version, sld->version_from, sld->version_to)) return false;
if (sld->conv & SLF_NOT_IN_SAVE) return false;
if (!sld.ext_feature_test.IsFeaturePresent(_sl_version, sld.version_from, sld.version_to)) return false;
if (sld.conv & SLF_NOT_IN_SAVE) return false;
return true;
}
@@ -1606,10 +1606,10 @@ static inline bool SlIsObjectValidInSavegame(const SaveLoad *sld)
* @note If the variable is skipped it is skipped in the savegame
* bytestream itself as well, so there is no need to skip it somewhere else
*/
static inline bool SlSkipVariableOnLoad(const SaveLoad *sld)
static inline bool SlSkipVariableOnLoad(const SaveLoad &sld)
{
if ((sld->conv & SLF_NO_NETWORK_SYNC) && _sl.action != SLA_SAVE && _networking && !_network_server) {
SlSkipBytes(SlCalcConvMemLen(sld->conv) * sld->length);
if ((sld.conv & SLF_NO_NETWORK_SYNC) && _sl.action != SLA_SAVE && _networking && !_network_server) {
SlSkipBytes(SlCalcConvMemLen(sld.conv) * sld.length);
return true;
}
@@ -1618,26 +1618,26 @@ static inline bool SlSkipVariableOnLoad(const SaveLoad *sld)
/**
* Calculate the size of an object.
* @param object to be measured
* @param sld The SaveLoad description of the object so we know how to manipulate it
* @return size of given object
* @param object to be measured.
* @param slt The SaveLoad table with objects to save/load.
* @return size of given object.
*/
size_t SlCalcObjLength(const void *object, const SaveLoad *sld)
size_t SlCalcObjLength(const void *object, const SaveLoadTable &slt)
{
size_t length = 0;
/* Need to determine the length and write a length tag. */
for (; sld->cmd != SL_END; sld++) {
for (auto &sld : slt) {
length += SlCalcObjMemberLength(object, sld);
}
return length;
}
size_t SlCalcObjMemberLength(const void *object, const SaveLoad *sld)
size_t SlCalcObjMemberLength(const void *object, const SaveLoad &sld)
{
assert(_sl.action == SLA_SAVE);
switch (sld->cmd) {
switch (sld.cmd) {
case SL_VAR:
case SL_REF:
case SL_ARR:
@@ -1651,17 +1651,17 @@ size_t SlCalcObjMemberLength(const void *object, const SaveLoad *sld)
/* CONDITIONAL saveload types depend on the savegame version */
if (!SlIsObjectValidInSavegame(sld)) break;
switch (sld->cmd) {
case SL_VAR: return SlCalcConvFileLen(sld->conv);
switch (sld.cmd) {
case SL_VAR: return SlCalcConvFileLen(sld.conv);
case SL_REF: return SlCalcRefLen();
case SL_ARR: return SlCalcArrayLen(sld->length, sld->conv);
case SL_STR: return SlCalcStringLen(GetVariableAddress(object, sld), sld->length, sld->conv);
case SL_ARR: return SlCalcArrayLen(sld.length, sld.conv);
case SL_STR: return SlCalcStringLen(GetVariableAddress(object, sld), sld.length, sld.conv);
case SL_LST: return SlCalcListLen<std::list<void *>>(GetVariableAddress(object, sld));
case SL_PTRDEQ: return SlCalcListLen<std::deque<void *>>(GetVariableAddress(object, sld));
case SL_VEC: return SlCalcListLen<std::vector<void *>>(GetVariableAddress(object, sld));
case SL_DEQUE: return SlCalcDequeLen(GetVariableAddress(object, sld), sld->conv);
case SL_DEQUE: return SlCalcDequeLen(GetVariableAddress(object, sld), sld.conv);
case SL_VARVEC: {
const size_t size_len = SlCalcConvMemLen(sld->conv);
const size_t size_len = SlCalcConvMemLen(sld.conv);
switch (size_len) {
case 1: return SlCalcVarListLen<std::vector<byte>>(GetVariableAddress(object, sld), 1);
case 2: return SlCalcVarListLen<std::vector<uint16>>(GetVariableAddress(object, sld), 2);
@@ -1689,41 +1689,41 @@ size_t SlCalcObjMemberLength(const void *object, const SaveLoad *sld)
* matches with the actual variable size.
* @param sld The saveload configuration to test.
*/
static bool IsVariableSizeRight(const SaveLoad *sld)
static bool IsVariableSizeRight(const SaveLoad &sld)
{
switch (sld->cmd) {
switch (sld.cmd) {
case SL_VAR:
switch (GetVarMemType(sld->conv)) {
switch (GetVarMemType(sld.conv)) {
case SLE_VAR_BL:
return sld->size == sizeof(bool);
return sld.size == sizeof(bool);
case SLE_VAR_I8:
case SLE_VAR_U8:
return sld->size == sizeof(int8);
return sld.size == sizeof(int8);
case SLE_VAR_I16:
case SLE_VAR_U16:
return sld->size == sizeof(int16);
return sld.size == sizeof(int16);
case SLE_VAR_I32:
case SLE_VAR_U32:
return sld->size == sizeof(int32);
return sld.size == sizeof(int32);
case SLE_VAR_I64:
case SLE_VAR_U64:
return sld->size == sizeof(int64);
return sld.size == sizeof(int64);
case SLE_VAR_NAME:
return sld->size == sizeof(std::string);
return sld.size == sizeof(std::string);
default:
return sld->size == sizeof(void *);
return sld.size == sizeof(void *);
}
case SL_REF:
/* These should all be pointer sized. */
return sld->size == sizeof(void *);
return sld.size == sizeof(void *);
case SL_STR:
/* These should be pointer sized, or fixed array. */
return sld->size == sizeof(void *) || sld->size == sld->length;
return sld.size == sizeof(void *) || sld.size == sld.length;
case SL_STDSTR:
/* These should be all pointers to std::string. */
return sld->size == sizeof(std::string);
return sld.size == sizeof(std::string);
default:
return true;
@@ -1732,15 +1732,15 @@ static bool IsVariableSizeRight(const SaveLoad *sld)
#endif /* OTTD_ASSERT */
void SlFilterObject(const SaveLoad *sld, std::vector<SaveLoad> &save);
void SlFilterObject(const SaveLoadTable &slt, std::vector<SaveLoad> &save);
static void SlFilterObjectMember(const SaveLoad *sld, std::vector<SaveLoad> &save)
static void SlFilterObjectMember(const SaveLoad &sld, std::vector<SaveLoad> &save)
{
#ifdef OTTD_ASSERT
assert(IsVariableSizeRight(sld));
#endif
switch (sld->cmd) {
switch (sld.cmd) {
case SL_VAR:
case SL_REF:
case SL_ARR:
@@ -1762,7 +1762,7 @@ static void SlFilterObjectMember(const SaveLoad *sld, std::vector<SaveLoad> &sav
break;
case SLA_PTRS:
case SLA_NULL:
switch (sld->cmd) {
switch (sld.cmd) {
case SL_REF:
case SL_LST:
case SL_PTRDEQ:
@@ -1777,14 +1777,14 @@ static void SlFilterObjectMember(const SaveLoad *sld, std::vector<SaveLoad> &sav
default: NOT_REACHED();
}
save.push_back(*sld);
save.push_back(sld);
break;
/* SL_WRITEBYTE writes a value to the savegame to identify the type of an object.
* When loading, the value is read explictly with SlReadByte() to determine which
* object description to use. */
case SL_WRITEBYTE:
if (_sl.action == SLA_SAVE) save.push_back(*sld);
if (_sl.action == SLA_SAVE) save.push_back(sld);
break;
/* SL_VEH_INCLUDE loads common code for vehicles */
@@ -1800,30 +1800,29 @@ static void SlFilterObjectMember(const SaveLoad *sld, std::vector<SaveLoad> &sav
}
}
void SlFilterObject(const SaveLoad *sld, std::vector<SaveLoad> &save)
void SlFilterObject(const SaveLoadTable &slt, std::vector<SaveLoad> &save)
{
for (; sld->cmd != SL_END; sld++) {
for (auto &sld : slt) {
SlFilterObjectMember(sld, save);
}
}
std::vector<SaveLoad> SlFilterObject(const SaveLoad *sld)
std::vector<SaveLoad> SlFilterObject(const SaveLoadTable &slt)
{
std::vector<SaveLoad> save;
SlFilterObject(sld, save);
save.push_back(SLE_END());
SlFilterObject(slt, save);
return save;
}
template <SaveLoadAction action, bool check_version>
bool SlObjectMemberGeneric(void *ptr, const SaveLoad *sld)
bool SlObjectMemberGeneric(void *ptr, const SaveLoad &sld)
{
#ifdef OTTD_ASSERT
if (check_version) assert(IsVariableSizeRight(sld));
#endif
VarType conv = GB(sld->conv, 0, 8);
switch (sld->cmd) {
VarType conv = GB(sld.conv, 0, 8);
switch (sld.cmd) {
case SL_VAR:
case SL_REF:
case SL_ARR:
@@ -1840,7 +1839,7 @@ bool SlObjectMemberGeneric(void *ptr, const SaveLoad *sld)
if (SlSkipVariableOnLoad(sld)) return false;
}
switch (sld->cmd) {
switch (sld.cmd) {
case SL_VAR: SlSaveLoadConvGeneric<action>(ptr, conv); break;
case SL_REF: // Reference variable, translate
switch (action) {
@@ -1860,14 +1859,14 @@ bool SlObjectMemberGeneric(void *ptr, const SaveLoad *sld)
default: NOT_REACHED();
}
break;
case SL_ARR: SlArray(ptr, sld->length, conv); break;
case SL_STR: SlString(ptr, sld->length, sld->conv); break;
case SL_ARR: SlArray(ptr, sld.length, conv); break;
case SL_STR: SlString(ptr, sld.length, sld.conv); break;
case SL_LST: SlList<std::list<void *>>(ptr, (SLRefType)conv); break;
case SL_PTRDEQ: SlList<std::deque<void *>>(ptr, (SLRefType)conv); break;
case SL_VEC: SlList<std::vector<void *>>(ptr, (SLRefType)conv); break;
case SL_DEQUE: SlDeque(ptr, conv); break;
case SL_VARVEC: {
const size_t size_len = SlCalcConvMemLen(sld->conv);
const size_t size_len = SlCalcConvMemLen(sld.conv);
switch (size_len) {
case 1: SlVarList<std::vector<byte>>(ptr, conv); break;
case 2: SlVarList<std::vector<uint16>>(ptr, conv); break;
@@ -1877,7 +1876,7 @@ bool SlObjectMemberGeneric(void *ptr, const SaveLoad *sld)
}
break;
}
case SL_STDSTR: SlStdString(*static_cast<std::string *>(ptr), sld->conv); break;
case SL_STDSTR: SlStdString(*static_cast<std::string *>(ptr), sld.conv); break;
default: NOT_REACHED();
}
break;
@@ -1910,7 +1909,7 @@ bool SlObjectMemberGeneric(void *ptr, const SaveLoad *sld)
return true;
}
bool SlObjectMember(void *ptr, const SaveLoad *sld)
bool SlObjectMember(void *ptr, const SaveLoad &sld)
{
switch (_sl.action) {
case SLA_SAVE:
@@ -1928,71 +1927,71 @@ bool SlObjectMember(void *ptr, const SaveLoad *sld)
/**
* Main SaveLoad function.
* @param object The object that is being saved or loaded
* @param sld The SaveLoad description of the object so we know how to manipulate it
* @param object The object that is being saved or loaded.
* @param slt The SaveLoad table with objects to save/load.
*/
void SlObject(void *object, const SaveLoad *sld)
void SlObject(void *object, const SaveLoadTable &slt)
{
/* Automatically calculate the length? */
if (_sl.need_length != NL_NONE) {
SlSetLength(SlCalcObjLength(object, sld));
SlSetLength(SlCalcObjLength(object, slt));
}
for (; sld->cmd != SL_END; sld++) {
for (auto &sld : slt) {
void *ptr = GetVariableAddress(object, sld);
SlObjectMember(ptr, sld);
}
}
template <SaveLoadAction action, bool check_version>
void SlObjectIterateBase(void *object, const SaveLoad *sld)
void SlObjectIterateBase(void *object, const SaveLoadTable &slt)
{
for (; sld->cmd != SL_END; sld++) {
void *ptr = sld->global ? sld->address : GetVariableAddress(object, sld);
for (auto &sld : slt) {
void *ptr = sld.global ? sld.address : GetVariableAddress(object, sld);
SlObjectMemberGeneric<action, check_version>(ptr, sld);
}
}
void SlObjectSaveFiltered(void *object, const SaveLoad *sld)
void SlObjectSaveFiltered(void *object, const SaveLoadTable &slt)
{
if (_sl.need_length != NL_NONE) {
_sl.need_length = NL_NONE;
_sl.dumper->StartAutoLength();
SlObjectIterateBase<SLA_SAVE, false>(object, sld);
SlObjectIterateBase<SLA_SAVE, false>(object, slt);
auto result = _sl.dumper->StopAutoLength();
_sl.need_length = NL_WANTLENGTH;
SlSetLength(result.second);
_sl.dumper->CopyBytes(result.first, result.second);
} else {
SlObjectIterateBase<SLA_SAVE, false>(object, sld);
SlObjectIterateBase<SLA_SAVE, false>(object, slt);
}
}
void SlObjectLoadFiltered(void *object, const SaveLoad *sld)
void SlObjectLoadFiltered(void *object, const SaveLoadTable &slt)
{
SlObjectIterateBase<SLA_LOAD, false>(object, sld);
SlObjectIterateBase<SLA_LOAD, false>(object, slt);
}
void SlObjectPtrOrNullFiltered(void *object, const SaveLoad *sld)
void SlObjectPtrOrNullFiltered(void *object, const SaveLoadTable &slt)
{
switch (_sl.action) {
case SLA_PTRS:
SlObjectIterateBase<SLA_PTRS, false>(object, sld);
SlObjectIterateBase<SLA_PTRS, false>(object, slt);
return;
case SLA_NULL:
SlObjectIterateBase<SLA_NULL, false>(object, sld);
SlObjectIterateBase<SLA_NULL, false>(object, slt);
return;
default: NOT_REACHED();
}
}
/**
* Save or Load (a list of) global variables
* @param sldg The global variable that is being loaded or saved
* Save or Load (a list of) global variables.
* @param slt The SaveLoad table with objects to save/load.
*/
void SlGlobList(const SaveLoadGlobVarList *sldg)
void SlGlobList(const SaveLoadTable &slt)
{
SlObject(nullptr, (const SaveLoad*)sldg);
SlObject(nullptr, slt);
}
/**

40
src/saveload/saveload.h
View File

@@ -12,6 +12,7 @@
#include "../fileio_type.h"
#include "../strings_type.h"
#include "../core/span_type.hpp"
#include "extended_ver_sl.h"
#include <stdarg.h>
@@ -564,7 +565,6 @@ enum SaveLoadTypes {
SL_PTRDEQ = 13, ///< Save/load a pointer type deque.
SL_VARVEC = 14, ///< Save/load a primitive type vector.
SL_END = 15
};
typedef byte SaveLoadType; ///< Save/load type. @see SaveLoadTypes
@@ -586,8 +586,8 @@ struct SaveLoad {
SlXvFeatureTest ext_feature_test; ///< extended feature test
};
/** Same as #SaveLoad but global variables are used (for better readability); */
typedef SaveLoad SaveLoadGlobVarList;
/** A table of SaveLoad entries. */
using SaveLoadTable = span<const SaveLoad>;
/**
* Storage of simple variables, references (pointers), and arrays.
@@ -813,9 +813,6 @@ typedef SaveLoad SaveLoadGlobVarList;
#define SLE_VEH_INCLUDE() {false, SL_VEH_INCLUDE, 0, 0, SL_MIN_VERSION, SL_MAX_VERSION, nullptr, 0, SlXvFeatureTest()}
#define SLE_ST_INCLUDE() {false, SL_ST_INCLUDE, 0, 0, SL_MIN_VERSION, SL_MAX_VERSION, nullptr, 0, SlXvFeatureTest()}
/** End marker of a struct/class save or load. */
#define SLE_END() {false, SL_END, 0, 0, SL_MIN_VERSION, SL_MIN_VERSION, nullptr, 0, SlXvFeatureTest()}
/**
* Storage of global simple variables, references (pointers), and arrays.
* @param cmd Load/save type. @see SaveLoadType
@@ -983,9 +980,6 @@ typedef SaveLoad SaveLoadGlobVarList;
*/
#define SLEG_CONDNULL(length, from, to) {true, SL_ARR, SLE_FILE_U8 | SLE_VAR_NULL | SLF_NOT_IN_CONFIG, length, from, to, (void*)nullptr, SlXvFeatureTest()}
/** End marker of global variables save or load. */
#define SLEG_END() {true, SL_END, 0, 0, SL_MIN_VERSION, SL_MIN_VERSION, nullptr, 0, SlXvFeatureTest()}
/**
* Checks whether the savegame is below \a major.\a minor.
* @param major Major number of the version to check against.
@@ -1065,22 +1059,22 @@ static inline bool IsNumericType(VarType conv)
* is taken. If non-null only the offset is stored in the union and we need
* to add this to the address of the object
*/
static inline void *GetVariableAddress(const void *object, const SaveLoad *sld)
static inline void *GetVariableAddress(const void *object, const SaveLoad &sld)
{
/* Entry is a global address. */
if (sld->global) return sld->address;
if (sld.global) return sld.address;
#ifdef _DEBUG
/* Entry is a null-variable, mostly used to read old savegames etc. */
if (GetVarMemType(sld->conv) == SLE_VAR_NULL) {
assert(sld->address == nullptr);
if (GetVarMemType(sld.conv) == SLE_VAR_NULL) {
assert(sld.address == nullptr);
return nullptr;
}
/* Everything else should be a non-null pointer. */
assert(object != nullptr);
#endif
return const_cast<byte *>((const byte *)object + (ptrdiff_t)sld->address);
return const_cast<byte *>((const byte *)object + (ptrdiff_t)sld.address);
}
int64 ReadValue(const void *ptr, VarType conv);
@@ -1092,8 +1086,8 @@ int SlIterateArray();
void SlAutolength(AutolengthProc *proc, void *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 SaveLoad *sld);
size_t SlCalcObjMemberLength(const void *object, const SaveLoad &sld);
size_t SlCalcObjLength(const void *object, const SaveLoadTable &slt);
byte SlReadByte();
void SlWriteByte(byte b);
@@ -1111,15 +1105,15 @@ void SlSkipBytes(size_t length);
size_t SlGetBytesRead();
size_t SlGetBytesWritten();
void SlGlobList(const SaveLoadGlobVarList *sldg);
void SlGlobList(const SaveLoadTable &slt);
void SlArray(void *array, size_t length, VarType conv);
void SlObject(void *object, const SaveLoad *sld);
bool SlObjectMember(void *object, const SaveLoad *sld);
void SlObject(void *object, const SaveLoadTable &slt);
bool SlObjectMember(void *object, const SaveLoad &sld);
std::vector<SaveLoad> SlFilterObject(const SaveLoad *sld);
void SlObjectSaveFiltered(void *object, const SaveLoad *sld);
void SlObjectLoadFiltered(void *object, const SaveLoad *sld);
void SlObjectPtrOrNullFiltered(void *object, const SaveLoad *sld);
std::vector<SaveLoad> SlFilterObject(const SaveLoadTable &slt);
void SlObjectSaveFiltered(void *object, const SaveLoadTable &slt);
void SlObjectLoadFiltered(void *object, const SaveLoadTable &slt);
void SlObjectPtrOrNullFiltered(void *object, const SaveLoadTable &slt);
void NORETURN SlError(StringID string, const char *extra_msg = nullptr, bool already_malloced = false);
void NORETURN SlErrorCorrupt(const char *msg, bool already_malloced = false);

2
src/saveload/saveload_internal.h
View File

@@ -23,7 +23,7 @@ void ResetOldNames();
void ResetOldWaypoints();
void MoveBuoysToWaypoints();
void MoveWaypointsToBaseStations();
const SaveLoad *GetBaseStationDescription();
SaveLoadTable GetBaseStationDescription();
void AfterLoadVehicles(bool part_of_load);
void AfterLoadEngines();

1
src/saveload/signs_sl.cpp
View File

@@ -26,7 +26,6 @@ static const SaveLoad _sign_desc[] = {
SLE_CONDVAR(Sign, owner, SLE_UINT8, SLV_6, SL_MAX_VERSION),
SLE_CONDVAR_X(Sign, z, SLE_FILE_U8 | SLE_VAR_I32, SL_MIN_VERSION, SLV_164, SlXvFeatureTest(XSLFTO_AND, XSLFI_ZPOS_32_BIT, 0, 0)),
SLE_CONDVAR_X(Sign, z, SLE_INT32, SLV_164, SL_MAX_VERSION, SlXvFeatureTest(XSLFTO_OR, XSLFI_ZPOS_32_BIT)),
SLE_END()
};
/** Save all signs */

45
src/saveload/station_sl.cpp
View File

@@ -157,8 +157,6 @@ static const SaveLoad _roadstop_desc[] = {
SLE_CONDNULL(4, SL_MIN_VERSION, SLV_25),
SLE_CONDNULL(1, SLV_25, SLV_26),
SLE_END()
};
static const SaveLoad _old_station_desc[] = {
@@ -218,8 +216,6 @@ static const SaveLoad _old_station_desc[] = {
/* reserve extra space in savegame here. (currently 32 bytes) */
SLE_CONDNULL(32, SLV_2, SL_MAX_VERSION),
SLE_END()
};
static uint16 _waiting_acceptance;
@@ -232,8 +228,6 @@ static Money _cargo_feeder_share;
static const SaveLoad _station_speclist_desc[] = {
SLE_CONDVAR(StationSpecList, grfid, SLE_UINT32, SLV_27, SL_MAX_VERSION),
SLE_CONDVAR(StationSpecList, localidx, SLE_UINT8, SLV_27, SL_MAX_VERSION),
SLE_END()
};
CargoPacketList _packets;
@@ -253,7 +247,6 @@ static const SaveLoad _flow_desc[] = {
SLE_VAR(FlowSaveLoad, via, SLE_UINT16),
SLE_VAR(FlowSaveLoad, share, SLE_UINT32),
SLE_CONDVAR(FlowSaveLoad, restricted, SLE_BOOL, SLV_187, SL_MAX_VERSION),
SLE_END()
};
#endif
@@ -262,7 +255,7 @@ static const SaveLoad _flow_desc[] = {
* some of the variables itself are private.
* @return the saveload description for GoodsEntry.
*/
const SaveLoad *GetGoodsDesc()
SaveLoadTable GetGoodsDesc()
{
static const SaveLoad goods_desc[] = {
SLEG_CONDVAR( _waiting_acceptance, SLE_UINT16, SL_MIN_VERSION, SLV_68),
@@ -289,7 +282,6 @@ const SaveLoad *GetGoodsDesc()
SLE_CONDVAR(GoodsEntry, max_waiting_cargo, SLE_UINT32, SLV_183, SL_MAX_VERSION),
SLE_CONDNULL_X(4, SL_MIN_VERSION, SL_MAX_VERSION, SlXvFeatureTest(XSLFTO_AND, XSLFI_JOKERPP)),
SLE_CONDVAR_X(GoodsEntry, last_vehicle_type, SLE_UINT8, SL_MIN_VERSION, SL_MAX_VERSION, SlXvFeatureTest(XSLFTO_AND, XSLFI_ST_LAST_VEH_TYPE, 1)),
SLE_END()
};
return goods_desc;
@@ -300,7 +292,6 @@ typedef std::pair<const StationID, CargoPacketList> StationCargoPair;
static const SaveLoad _cargo_list_desc[] = {
SLE_VAR(StationCargoPair, first, SLE_UINT16),
SLE_PTRDEQ(StationCargoPair, second, REF_CARGO_PACKET),
SLE_END()
};
/**
@@ -411,8 +402,6 @@ static const SaveLoad _base_station_desc[] = {
SLE_VAR(BaseStation, random_bits, SLE_UINT16),
SLE_VAR(BaseStation, waiting_triggers, SLE_UINT8),
SLE_VAR(BaseStation, num_specs, SLE_UINT8),
SLE_END()
};
static OldPersistentStorage _old_st_persistent_storage;
@@ -461,8 +450,6 @@ static const SaveLoad _station_desc[] = {
SLE_CONDVAR(Station, always_accepted, SLE_UINT64, SLV_EXTEND_CARGOTYPES, SL_MAX_VERSION),
SLE_CONDNULL_X(32 * 24, SL_MIN_VERSION, SL_MAX_VERSION, SlXvFeatureTest(XSLFTO_AND, XSLFI_JOKERPP, SL_JOKER_1_22)),
SLE_CONDVAR_X(Station, station_cargo_history_cargoes, SLE_UINT64, SL_MIN_VERSION, SL_MAX_VERSION, SlXvFeatureTest(XSLFTO_AND, XSLFI_STATION_CARGO_HISTORY)),
SLE_END()
};
static const SaveLoad _waypoint_desc[] = {
@@ -474,15 +461,13 @@ static const SaveLoad _waypoint_desc[] = {
SLE_CONDVAR(Waypoint, train_station.tile, SLE_UINT32, SLV_124, SL_MAX_VERSION),
SLE_CONDVAR(Waypoint, train_station.w, SLE_FILE_U8 | SLE_VAR_U16, SLV_124, SL_MAX_VERSION),
SLE_CONDVAR(Waypoint, train_station.h, SLE_FILE_U8 | SLE_VAR_U16, SLV_124, SL_MAX_VERSION),
SLE_END()
};
/**
* Get the base station description to be used for SL_ST_INCLUDE
* @return the base station description.
*/
const SaveLoad *GetBaseStationDescription()
SaveLoadTable GetBaseStationDescription()
{
return _base_station_desc;
}
@@ -511,7 +496,7 @@ static void SetupDescs_ROADSTOP()
static void RealSave_STNN(BaseStation *bst)
{
bool waypoint = (bst->facilities & FACIL_WAYPOINT) != 0;
SlObjectSaveFiltered(bst, waypoint ? _filtered_waypoint_desc.data() : _filtered_station_desc.data());
SlObjectSaveFiltered(bst, waypoint ? SaveLoadTable(_filtered_waypoint_desc) : SaveLoadTable(_filtered_station_desc));
MemoryDumper *dumper = MemoryDumper::GetCurrent();
@@ -520,7 +505,7 @@ static void RealSave_STNN(BaseStation *bst)
for (CargoID i = 0; i < NUM_CARGO; i++) {
_num_dests = (uint32)st->goods[i].cargo.Packets()->MapSize();
_num_flows = (uint32)st->goods[i].flows.size();
SlObjectSaveFiltered(&st->goods[i], _filtered_goods_desc.data());
SlObjectSaveFiltered(&st->goods[i], _filtered_goods_desc);
for (FlowStatMap::const_iterator outer_it(st->goods[i].flows.begin()); outer_it != st->goods[i].flows.end(); ++outer_it) {
uint32 sum_shares = 0;
FlowSaveLoad flow;
@@ -563,7 +548,7 @@ static void RealSave_STNN(BaseStation *bst)
}
for (uint i = 0; i < bst->num_specs; i++) {
SlObjectSaveFiltered(&bst->speclist[i], _filtered_station_speclist_desc.data());
SlObjectSaveFiltered(&bst->speclist[i], _filtered_station_speclist_desc);
}
}
@@ -592,7 +577,7 @@ static void Load_STNN()
bool waypoint = (SlReadByte() & FACIL_WAYPOINT) != 0;
BaseStation *bst = waypoint ? (BaseStation *)new (index) Waypoint() : new (index) Station();
SlObjectLoadFiltered(bst, waypoint ? _filtered_waypoint_desc.data() : _filtered_station_desc.data());
SlObjectLoadFiltered(bst, waypoint ? SaveLoadTable(_filtered_waypoint_desc) : SaveLoadTable(_filtered_station_desc));
if (!waypoint) {
Station *st = Station::From(bst);
@@ -606,7 +591,7 @@ static void Load_STNN()
}
for (CargoID i = 0; i < num_cargo; i++) {
SlObjectLoadFiltered(&st->goods[i], _filtered_goods_desc.data());
SlObjectLoadFiltered(&st->goods[i], _filtered_goods_desc);
StationID prev_source = INVALID_STATION;
if (SlXvIsFeaturePresent(XSLFI_FLOW_STAT_FLAGS)) {
for (uint32 j = 0; j < _num_flows; ++j) {
@@ -684,7 +669,7 @@ static void Load_STNN()
/* Allocate speclist memory when loading a game */
bst->speclist = CallocT<StationSpecList>(bst->num_specs);
for (uint i = 0; i < bst->num_specs; i++) {
SlObjectLoadFiltered(&bst->speclist[i], _filtered_station_speclist_desc.data());
SlObjectLoadFiltered(&bst->speclist[i], _filtered_station_speclist_desc);
}
}
}
@@ -698,7 +683,7 @@ static void Ptrs_STNN()
SetupDescs_STNN();
if (!IsSavegameVersionBefore(SLV_183)) {
assert(_filtered_goods_desc[0].cmd == SL_END);
assert(_filtered_goods_desc.size() == 0);
}
uint num_cargo = IsSavegameVersionBefore(SLV_EXTEND_CARGOTYPES) ? 32 : NUM_CARGO;
@@ -707,7 +692,7 @@ static void Ptrs_STNN()
GoodsEntry *ge = &st->goods[i];
if (IsSavegameVersionBefore(SLV_183) && SlXvIsFeatureMissing(XSLFI_CHILLPP)) {
SwapPackets(ge);
SlObjectPtrOrNullFiltered(ge, _filtered_goods_desc.data());
SlObjectPtrOrNullFiltered(ge, _filtered_goods_desc);
SwapPackets(ge);
} else {
//SlObject(ge, GetGoodsDesc());
@@ -716,11 +701,11 @@ static void Ptrs_STNN()
}
}
}
SlObjectPtrOrNullFiltered(st, _filtered_station_desc.data());
SlObjectPtrOrNullFiltered(st, _filtered_station_desc);
}
for (Waypoint *wp : Waypoint::Iterate()) {
SlObjectPtrOrNullFiltered(wp, _filtered_waypoint_desc.data());
SlObjectPtrOrNullFiltered(wp, _filtered_waypoint_desc);
}
}
@@ -729,7 +714,7 @@ static void Save_ROADSTOP()
SetupDescs_ROADSTOP();
for (RoadStop *rs : RoadStop::Iterate()) {
SlSetArrayIndex(rs->index);
SlObjectSaveFiltered(rs, _filtered_roadstop_desc.data());
SlObjectSaveFiltered(rs, _filtered_roadstop_desc);
}
}
@@ -740,7 +725,7 @@ static void Load_ROADSTOP()
while ((index = SlIterateArray()) != -1) {
RoadStop *rs = new (index) RoadStop(INVALID_TILE);
SlObjectLoadFiltered(rs, _filtered_roadstop_desc.data());
SlObjectLoadFiltered(rs, _filtered_roadstop_desc);
}
}
@@ -748,7 +733,7 @@ static void Ptrs_ROADSTOP()
{
SetupDescs_ROADSTOP();
for (RoadStop *rs : RoadStop::Iterate()) {
SlObjectPtrOrNullFiltered(rs, _filtered_roadstop_desc.data());
SlObjectPtrOrNullFiltered(rs, _filtered_roadstop_desc);
}
}

1
src/saveload/storage_sl.cpp
View File

@@ -18,7 +18,6 @@ static const SaveLoad _storage_desc[] = {
SLE_CONDVAR(PersistentStorage, grfid, SLE_UINT32, SLV_6, SL_MAX_VERSION),
SLE_CONDARR(PersistentStorage, storage, SLE_UINT32, 16, SLV_161, SLV_EXTEND_PERSISTENT_STORAGE),
SLE_CONDARR(PersistentStorage, storage, SLE_UINT32, 256, SLV_EXTEND_PERSISTENT_STORAGE, SL_MAX_VERSION),
SLE_END()
};
/** Load persistent storage data. */

2
src/saveload/story_sl.cpp
View File

@@ -34,7 +34,6 @@ static const SaveLoad _story_page_elements_desc[] = {
SLE_CONDVAR(StoryPageElement, type, SLE_UINT8, SLV_185, SL_MAX_VERSION),
SLE_VAR(StoryPageElement, referenced_id, SLE_UINT32),
SLE_STR(StoryPageElement, text, SLE_STR | SLF_ALLOW_CONTROL, 0),
SLE_END()
};
static void Save_STORY_PAGE_ELEMENT()
@@ -69,7 +68,6 @@ static const SaveLoad _story_pages_desc[] = {
SLE_CONDVAR(StoryPage, company, SLE_FILE_U16 | SLE_VAR_U8, SL_MIN_VERSION, SLV_185),
SLE_CONDVAR(StoryPage, company, SLE_UINT8, SLV_185, SL_MAX_VERSION),
SLE_STR(StoryPage, title, SLE_STR | SLF_ALLOW_CONTROL, 0),
SLE_END()
};
static void Save_STORY_PAGE()

1
src/saveload/subsidy_sl.cpp
View File

@@ -25,7 +25,6 @@ static const SaveLoad _subsidies_desc[] = {
SLE_CONDVAR(Subsidy, src, SLE_UINT16, SLV_5, SL_MAX_VERSION),
SLE_CONDVAR(Subsidy, dst, SLE_FILE_U8 | SLE_VAR_U16, SL_MIN_VERSION, SLV_5),
SLE_CONDVAR(Subsidy, dst, SLE_UINT16, SLV_5, SL_MAX_VERSION),
SLE_END()
};
static void Save_SUBS()

1
src/saveload/tbtr_template_replacement_sl.cpp
View File

@@ -7,7 +7,6 @@
static const SaveLoad _template_replacement_desc[] = {
SLE_VAR(TemplateReplacement, sel_template, SLE_UINT16),
SLE_VAR(TemplateReplacement, group, SLE_UINT16),
SLE_END()
};
static void Save_TMPL_RPLS()

10
src/saveload/tbtr_template_veh_sl.cpp
View File

@@ -9,7 +9,7 @@
#include "saveload.h"
const SaveLoad* GTD() {
const SaveLoadTable GTD() {
static const SaveLoad _template_veh_desc[] = {
SLE_REF(TemplateVehicle, next, REF_TEMPLATE_VEHICLE),
@@ -49,15 +49,9 @@ const SaveLoad* GTD() {
SLE_CONDNULL_X(36, SL_MIN_VERSION, SL_MAX_VERSION, SlXvFeatureTest(XSLFTO_AND, XSLFI_TEMPLATE_REPLACEMENT, 2, 3)),
SLE_CONDNULL_X(36, SL_MIN_VERSION, SL_MAX_VERSION, SlXvFeatureTest(XSLFTO_AND, XSLFI_JOKERPP)),
SLE_CONDNULL_X(4, SL_MIN_VERSION, SL_MAX_VERSION, SlXvFeatureTest(XSLFTO_AND, XSLFI_TEMPLATE_REPLACEMENT, 0, 3)),
SLE_END()
};
static const SaveLoad * const _ret[] = {
_template_veh_desc,
};
return _ret[0];
return _template_veh_desc;
}
static void Save_TMPLS()

22
src/saveload/town_sl.cpp
View File

@@ -243,8 +243,6 @@ static const SaveLoad _town_desc[] = {
SLE_CONDNULL(4, SLV_166, SLV_EXTEND_CARGOTYPES), ///< cargo_produced, no longer in use
SLE_CONDNULL(8, SLV_EXTEND_CARGOTYPES, SLV_REMOVE_TOWN_CARGO_CACHE), ///< cargo_produced, no longer in use
SLE_CONDNULL(30, SLV_2, SLV_REMOVE_TOWN_CARGO_CACHE), ///< old reserved space
SLE_END()
};
static const SaveLoad _town_supplied_desc[] = {
@@ -252,8 +250,6 @@ static const SaveLoad _town_supplied_desc[] = {
SLE_CONDVAR(TransportedCargoStat<uint32>, new_max, SLE_UINT32, SLV_165, SL_MAX_VERSION),
SLE_CONDVAR(TransportedCargoStat<uint32>, old_act, SLE_UINT32, SLV_165, SL_MAX_VERSION),
SLE_CONDVAR(TransportedCargoStat<uint32>, new_act, SLE_UINT32, SLV_165, SL_MAX_VERSION),
SLE_END()
};
static const SaveLoad _town_received_desc[] = {
@@ -261,8 +257,6 @@ static const SaveLoad _town_received_desc[] = {
SLE_CONDVAR(TransportedCargoStat<uint16>, new_max, SLE_UINT16, SLV_165, SL_MAX_VERSION),
SLE_CONDVAR(TransportedCargoStat<uint16>, old_act, SLE_UINT16, SLV_165, SL_MAX_VERSION),
SLE_CONDVAR(TransportedCargoStat<uint16>, new_act, SLE_UINT16, SLV_165, SL_MAX_VERSION),
SLE_END()
};
static const SaveLoad _town_received_desc_spp[] = {
@@ -270,8 +264,6 @@ static const SaveLoad _town_received_desc_spp[] = {
SLE_CONDVAR(TransportedCargoStat<uint16>, new_max, SLE_FILE_U32 | SLE_VAR_U16, SLV_165, SL_MAX_VERSION),
SLE_CONDVAR(TransportedCargoStat<uint16>, old_act, SLE_FILE_U32 | SLE_VAR_U16, SLV_165, SL_MAX_VERSION),
SLE_CONDVAR(TransportedCargoStat<uint16>, new_act, SLE_FILE_U32 | SLE_VAR_U16, SLV_165, SL_MAX_VERSION),
SLE_END()
};
std::vector<SaveLoad> _filtered_town_desc;
@@ -297,13 +289,13 @@ static void Load_HIDS()
static void RealSave_Town(Town *t)
{
SlObjectSaveFiltered(t, _filtered_town_desc.data());
SlObjectSaveFiltered(t, _filtered_town_desc);
for (CargoID i = 0; i < NUM_CARGO; i++) {
SlObjectSaveFiltered(&t->supplied[i], _filtered_town_supplied_desc.data());
SlObjectSaveFiltered(&t->supplied[i], _filtered_town_supplied_desc);
}
for (int i = TE_BEGIN; i < NUM_TE; i++) {
SlObjectSaveFiltered(&t->received[i], _filtered_town_received_desc.data());
SlObjectSaveFiltered(&t->received[i], _filtered_town_received_desc);
}
}
@@ -324,10 +316,10 @@ static void Load_TOWN()
while ((index = SlIterateArray()) != -1) {
Town *t = new (index) Town();
SlObjectLoadFiltered(t, _filtered_town_desc.data());
SlObjectLoadFiltered(t, _filtered_town_desc);
for (CargoID i = 0; i < num_cargo; i++) {
SlObjectLoadFiltered(&t->supplied[i], _filtered_town_supplied_desc.data());
SlObjectLoadFiltered(&t->supplied[i], _filtered_town_supplied_desc);
}
if (SlXvIsFeaturePresent(XSLFI_SPRINGPP)) {
for (int i = TE_BEGIN; i < NUM_TE; i++) {
@@ -335,7 +327,7 @@ static void Load_TOWN()
}
} else {
for (int i = TE_BEGIN; i < NUM_TE; i++) {
SlObjectLoadFiltered(&t->received[i], _filtered_town_received_desc.data());
SlObjectLoadFiltered(&t->received[i], _filtered_town_received_desc);
}
}
@@ -362,7 +354,7 @@ static void Ptrs_TOWN()
SetupDescs_TOWN();
for (Town *t : Town::Iterate()) {
SlObjectPtrOrNullFiltered(t, _filtered_town_desc.data());
SlObjectPtrOrNullFiltered(t, _filtered_town_desc);
}
}

5
src/saveload/tracerestrict_sl.cpp
View File

@@ -16,7 +16,6 @@
static const SaveLoad _trace_restrict_mapping_desc[] = {
SLE_VAR(TraceRestrictMappingItem, program_id, SLE_UINT32),
SLE_END()
};
/**
@@ -50,7 +49,6 @@ struct TraceRestrictProgramStub {
static const SaveLoad _trace_restrict_program_stub_desc[] = {
SLE_VAR(TraceRestrictProgramStub, length, SLE_UINT32),
SLE_END()
};
/**
@@ -120,14 +118,12 @@ struct TraceRestrictSlotStub {
static const SaveLoad _trace_restrict_slot_stub_desc[] = {
SLE_VAR(TraceRestrictSlotStub, length, SLE_UINT32),
SLE_END()
};
static const SaveLoad _trace_restrict_slot_desc[] = {
SLE_VAR(TraceRestrictSlot, max_occupancy, SLE_UINT32),
SLE_SSTR(TraceRestrictSlot, name, SLF_ALLOW_CONTROL),
SLE_VAR(TraceRestrictSlot, owner, SLE_UINT8),
SLE_END()
};
/**
@@ -174,7 +170,6 @@ static const SaveLoad _trace_restrict_counter_desc[] = {
SLE_VAR(TraceRestrictCounter, value, SLE_INT32),
SLE_SSTR(TraceRestrictCounter, name, SLF_ALLOW_CONTROL),
SLE_VAR(TraceRestrictCounter, owner, SLE_UINT8),
SLE_END()
};
/**

1
src/saveload/train_speed_adaptation.cpp
View File

@@ -18,7 +18,6 @@ static const SaveLoad _train_speed_adaptation_map_desc[] = {
SLE_VAR(SignalSpeedType, first.last_passing_train_dir, SLE_UINT8),
SLE_VAR(SignalSpeedType, second.train_speed, SLE_UINT16),
SLE_VAR(SignalSpeedType, second.time_stamp, SLE_UINT64),
SLE_END()
};
static void Load_TSAS()

1
src/saveload/tunnel_sl.cpp
View File

@@ -20,7 +20,6 @@ static const SaveLoad _tunnel_desc[] = {
SLE_CONDVAR(Tunnel, tile_s, SLE_UINT32, SL_MIN_VERSION, SL_MAX_VERSION),
SLE_CONDVAR(Tunnel, height, SLE_UINT8, SL_MIN_VERSION, SL_MAX_VERSION),
SLE_CONDVAR(Tunnel, is_chunnel, SLE_BOOL, SL_MIN_VERSION, SL_MAX_VERSION),
SLE_END()
};
static void Save_TUNN()

37
src/saveload/vehicle_sl.cpp
View File

@@ -616,7 +616,7 @@ static uint32 _old_ahead_separation;
* @param vt the vehicle type. Can be VEH_END for the common vehicle description data
* @return the saveload description
*/
const SaveLoad *GetVehicleDescription(VehicleType vt)
SaveLoadTable GetVehicleDescription(VehicleType vt)
{
/** Save and load of vehicles */
static const SaveLoad _common_veh_desc[] = {
@@ -780,11 +780,8 @@ const SaveLoad *GetVehicleDescription(VehicleType vt)
SLE_CONDNULL_X(2, SL_MIN_VERSION, SL_MAX_VERSION, SlXvFeatureTest(XSLFTO_AND, XSLFI_SPRINGPP)),
SLE_CONDNULL_X(160, SL_MIN_VERSION, SL_MAX_VERSION, SlXvFeatureTest(XSLFTO_AND, XSLFI_JOKERPP)),
SLE_END()
};
static const SaveLoad _train_desc[] = {
SLE_WRITEBYTE(Vehicle, type),
SLE_VEH_INCLUDE(),
@@ -809,8 +806,6 @@ const SaveLoad *GetVehicleDescription(VehicleType vt)
SLE_CONDVAR_X(Train, speed_restriction, SLE_UINT16, SL_MIN_VERSION, SL_MAX_VERSION, SlXvFeatureTest(XSLFTO_AND, XSLFI_SPEED_RESTRICTION)),
SLE_CONDVAR_X(Train, signal_speed_restriction, SLE_UINT16, SL_MIN_VERSION, SL_MAX_VERSION, SlXvFeatureTest(XSLFTO_AND, XSLFI_TRAIN_SPEED_ADAPTATION)),
SLE_CONDVAR_X(Train, critical_breakdown_count, SLE_UINT8, SL_MIN_VERSION, SL_MAX_VERSION, SlXvFeatureTest(XSLFTO_AND, XSLFI_IMPROVED_BREAKDOWNS, 2)),
SLE_END()
};
static const SaveLoad _roadveh_desc[] = {
@@ -833,8 +828,6 @@ const SaveLoad *GetVehicleDescription(VehicleType vt)
SLE_CONDNULL(2, SLV_6, SLV_131),
SLE_CONDNULL(16, SLV_2, SLV_144), // old reserved space
SLE_CONDVAR_X(RoadVehicle, critical_breakdown_count, SLE_UINT8, SL_MIN_VERSION, SL_MAX_VERSION, SlXvFeatureTest(XSLFTO_AND, XSLFI_IMPROVED_BREAKDOWNS, 6)),
SLE_END()
};
static const SaveLoad _ship_desc[] = {
@@ -847,8 +840,6 @@ const SaveLoad *GetVehicleDescription(VehicleType vt)
SLE_CONDVAR_X(Ship, critical_breakdown_count, SLE_UINT8, SL_MIN_VERSION, SL_MAX_VERSION, SlXvFeatureTest(XSLFTO_AND, XSLFI_IMPROVED_BREAKDOWNS, 8)),
SLE_CONDNULL(16, SLV_2, SLV_144), // old reserved space
SLE_END()
};
static const SaveLoad _aircraft_desc[] = {
@@ -872,8 +863,6 @@ const SaveLoad *GetVehicleDescription(VehicleType vt)
SLE_CONDVAR(Aircraft, flags, SLE_UINT8, SLV_167, SL_MAX_VERSION),
SLE_CONDNULL(13, SLV_2, SLV_144), // old reserved space
SLE_END()
};
static const SaveLoad _special_desc[] = {
@@ -904,8 +893,6 @@ const SaveLoad *GetVehicleDescription(VehicleType vt)
SLE_CONDVAR(Vehicle, spritenum, SLE_UINT8, SLV_2, SL_MAX_VERSION),
SLE_CONDNULL(15, SLV_2, SLV_144), // old reserved space
SLE_END()
};
static const SaveLoad _disaster_desc[] = {
@@ -947,12 +934,10 @@ const SaveLoad *GetVehicleDescription(VehicleType vt)
SLE_CONDVAR(DisasterVehicle, flags, SLE_UINT8, SLV_194, SL_MAX_VERSION),
SLE_CONDNULL(16, SLV_2, SLV_144), // old reserved space
SLE_END()
};
static const SaveLoad * const _veh_descs[] = {
static const SaveLoadTable _veh_descs[] = {
_train_desc,
_roadveh_desc,
_ship_desc,
@@ -981,9 +966,9 @@ static std::vector<SaveLoad> * const _filtered_veh_descs[] = {
&_filtered_disaster_desc,
};
const SaveLoad *GetVehicleDescriptionFiltered(VehicleType vt)
const SaveLoadTable GetVehicleDescriptionFiltered(VehicleType vt)
{
return _filtered_veh_descs[vt]->data();
return *(_filtered_veh_descs[vt]);
}
static void SetupDescs_VEHS()
@@ -1078,7 +1063,7 @@ static void Ptrs_VEHS()
}
}
const SaveLoad *GetOrderExtraInfoDescription();
const SaveLoadTable GetOrderExtraInfoDescription();
void Save_VEOX()
{
@@ -1103,14 +1088,13 @@ void Load_VEOX()
}
}
const SaveLoad *GetVehicleSpeedRestrictionDescription()
const SaveLoadTable GetVehicleSpeedRestrictionDescription()
{
static const SaveLoad _vehicle_speed_restriction_desc[] = {
SLE_VAR(PendingSpeedRestrictionChange, distance, SLE_UINT16),
SLE_VAR(PendingSpeedRestrictionChange, new_speed, SLE_UINT16),
SLE_VAR(PendingSpeedRestrictionChange, prev_speed, SLE_UINT16),
SLE_VAR(PendingSpeedRestrictionChange, flags, SLE_UINT16),
SLE_END()
};
return _vehicle_speed_restriction_desc;
@@ -1391,7 +1375,7 @@ void SlProcessVENC()
}
}
const SaveLoad *GetVehicleLookAheadDescription()
const SaveLoadTable GetVehicleLookAheadDescription()
{
static const SaveLoad _vehicle_look_ahead_desc[] = {
SLE_VAR(TrainReservationLookAhead, reservation_end_tile, SLE_UINT32),
@@ -1402,13 +1386,12 @@ const SaveLoad *GetVehicleLookAheadDescription()
SLE_VAR(TrainReservationLookAhead, tunnel_bridge_reserved_tiles, SLE_INT16),
SLE_VAR(TrainReservationLookAhead, flags, SLE_UINT16),
SLE_VAR(TrainReservationLookAhead, speed_restriction, SLE_UINT16),
SLE_END()
};
return _vehicle_look_ahead_desc;
}
const SaveLoad *GetVehicleLookAheadItemDescription()
const SaveLoadTable GetVehicleLookAheadItemDescription()
{
static const SaveLoad _vehicle_look_ahead_item_desc[] = {
SLE_VAR(TrainReservationLookAheadItem, start, SLE_INT32),
@@ -1416,18 +1399,16 @@ const SaveLoad *GetVehicleLookAheadItemDescription()
SLE_VAR(TrainReservationLookAheadItem, z_pos, SLE_INT16),
SLE_VAR(TrainReservationLookAheadItem, data_id, SLE_UINT16),
SLE_VAR(TrainReservationLookAheadItem, type, SLE_UINT8),
SLE_END()
};
return _vehicle_look_ahead_item_desc;
}
const SaveLoad *GetVehicleLookAheadCurveDescription()
const SaveLoadTable GetVehicleLookAheadCurveDescription()
{
static const SaveLoad _vehicle_look_ahead_curve_desc[] = {
SLE_VAR(TrainReservationLookAheadCurve, position, SLE_INT32),
SLE_VAR(TrainReservationLookAheadCurve, dir_diff, SLE_UINT8),
SLE_END()
};
return _vehicle_look_ahead_curve_desc;

2
src/saveload/waypoint_sl.cpp
View File

@@ -180,8 +180,6 @@ static const SaveLoad _old_waypoint_desc[] = {
SLE_CONDVAR(OldWaypoint, localidx, SLE_UINT8, SLV_3, SL_MAX_VERSION),
SLE_CONDVAR(OldWaypoint, grfid, SLE_UINT32, SLV_17, SL_MAX_VERSION),
SLE_CONDVAR(OldWaypoint, owner, SLE_UINT8, SLV_101, SL_MAX_VERSION),
SLE_END()
};
static void Load_WAYP()