Add: store headers for chunks with SL_STRUCTLIST

16 files changed, 1149 insertions, 271 deletions

diff --git a/src/saveload/company_sl.cpp b/src/saveload/company_sl.cpp
index 7abec8041..27fb2cf37 100644
--- a/src/saveload/company_sl.cpp
+++ b/src/saveload/company_sl.cpp
@@ -8,6 +8,10 @@
 /** @file company_sl.cpp Code handling saving and loading of company data */
 
 #include "../stdafx.h"
+
+#include "saveload.h"
+#include "compat/company_sl_compat.h"
+
 #include "../company_func.h"
 #include "../company_manager_face.h"
 #include "../fios.h"
@@ -16,8 +20,6 @@
 #include "../station_base.h"
 #include "../strings_func.h"
 
-#include "saveload.h"
-
 #include "table/strings.h"
 
 #include "../safeguards.h"
@@ -243,79 +245,44 @@ struct CompanyOldAI {
 
 class SlCompanyOldAIBuildRec : public DefaultSaveLoadHandler<SlCompanyOldAIBuildRec, CompanyOldAI> {
 public:
-	inline static const SaveLoad description[] = {
-		SLE_CONDNULL(2, SL_MIN_VERSION, SLV_6),
-		SLE_CONDNULL(4, SLV_6, SLV_107),
-		SLE_CONDNULL(2, SL_MIN_VERSION, SLV_6),
-		SLE_CONDNULL(4, SLV_6, SLV_107),
-		SLE_CONDNULL(8, SL_MIN_VERSION, SLV_107),
-	};
+	inline static const SaveLoad description[] = {{}}; // Needed to keep DefaultSaveLoadHandler happy.
+	inline const static SaveLoadCompatTable compat_description = _company_old_ai_buildrec_compat;
+
+	SaveLoadTable GetDescription() const override { return {}; }
 
-	void GenericSaveLoad(CompanyOldAI *old_ai) const
+	void Load(CompanyOldAI *old_ai) const override
 	{
 		for (int i = 0; i != old_ai->num_build_rec; i++) {
-			SlObject(nullptr, this->GetDescription());
+			SlObject(nullptr, this->GetLoadDescription());
 		}
 	}
 
-	// No Save(); this is for backwards compatibility.
-	void Load(CompanyOldAI *old_ai) const override { this->GenericSaveLoad(old_ai); }
-	void LoadCheck(CompanyOldAI *old_ai) const override { this->GenericSaveLoad(old_ai); }
-	void FixPointers(CompanyOldAI *old_ai) const override { this->GenericSaveLoad(old_ai); }
+	void LoadCheck(CompanyOldAI *old_ai) const override { this->Load(old_ai); }
 };
 
 class SlCompanyOldAI : public DefaultSaveLoadHandler<SlCompanyOldAI, CompanyProperties> {
 public:
 	inline static const SaveLoad description[] = {
-		SLE_CONDNULL(2,  SL_MIN_VERSION, SLV_107),
-		SLE_CONDNULL(2,  SL_MIN_VERSION, SLV_13),
-		SLE_CONDNULL(4, SLV_13, SLV_107),
-		SLE_CONDNULL(8,  SL_MIN_VERSION, SLV_107),
-		 SLE_CONDVAR(CompanyOldAI, num_build_rec, SLE_UINT8, SL_MIN_VERSION, SLV_107),
-		SLE_CONDNULL(3,  SL_MIN_VERSION, SLV_107),
-
-		SLE_CONDNULL(2,  SL_MIN_VERSION,  SLV_6),
-		SLE_CONDNULL(4,  SLV_6, SLV_107),
-		SLE_CONDNULL(2,  SL_MIN_VERSION,  SLV_6),
-		SLE_CONDNULL(4,  SLV_6, SLV_107),
-		SLE_CONDNULL(2,  SL_MIN_VERSION, SLV_107),
-
-		SLE_CONDNULL(2,  SL_MIN_VERSION,  SLV_6),
-		SLE_CONDNULL(4,  SLV_6, SLV_107),
-		SLE_CONDNULL(2,  SL_MIN_VERSION,  SLV_6),
-		SLE_CONDNULL(4,  SLV_6, SLV_107),
-		SLE_CONDNULL(2,  SL_MIN_VERSION, SLV_107),
-
-		SLE_CONDNULL(2,  SL_MIN_VERSION, SLV_69),
-		SLE_CONDNULL(4,  SLV_69, SLV_107),
-
-		SLE_CONDNULL(18, SL_MIN_VERSION, SLV_107),
-		SLE_CONDNULL(20, SL_MIN_VERSION, SLV_107),
-		SLE_CONDNULL(32, SL_MIN_VERSION, SLV_107),
-
-		SLE_CONDNULL(64, SLV_2, SLV_107),
-		SLEG_STRUCTLIST("build_rec", SlCompanyOldAIBuildRec),
+		SLE_CONDVAR(CompanyOldAI, num_build_rec, SLE_UINT8, SL_MIN_VERSION, SLV_107),
+		SLEG_STRUCTLIST("buildrec", SlCompanyOldAIBuildRec),
 	};
+	inline const static SaveLoadCompatTable compat_description = _company_old_ai_compat;
 
-	void GenericSaveLoad(CompanyProperties *c) const
+	void Load(CompanyProperties *c) const override
 	{
 		if (!c->is_ai) return;
 
 		CompanyOldAI old_ai;
-		SlObject(&old_ai, this->GetDescription());
+		SlObject(&old_ai, this->GetLoadDescription());
 	}
 
-	// No Save(); this is for backwards compatibility.
-	void Load(CompanyProperties *c) const override { this->GenericSaveLoad(c); }
-	void LoadCheck(CompanyProperties *c) const override { this->GenericSaveLoad(c); }
-	void FixPointers(CompanyProperties *c) const override { this->GenericSaveLoad(c); }
+	void LoadCheck(CompanyProperties *c) const override { this->Load(c); }
 };
 
 class SlCompanySettings : public DefaultSaveLoadHandler<SlCompanySettings, CompanyProperties> {
 public:
 	inline static const SaveLoad description[] = {
 		/* Engine renewal settings */
-		SLE_CONDNULL(512, SLV_16, SLV_19),
 		SLE_CONDREF(CompanyProperties, engine_renew_list,            REF_ENGINE_RENEWS,   SLV_19, SL_MAX_VERSION),
 		SLE_CONDVAR(CompanyProperties, settings.engine_renew,        SLE_BOOL,            SLV_16, SL_MAX_VERSION),
 		SLE_CONDVAR(CompanyProperties, settings.engine_renew_months, SLE_INT16,           SLV_16, SL_MAX_VERSION),
@@ -328,19 +295,25 @@ public:
 		SLE_CONDVAR(CompanyProperties, settings.vehicle.servint_roadveh,   SLE_UINT16,     SLV_120, SL_MAX_VERSION),
 		SLE_CONDVAR(CompanyProperties, settings.vehicle.servint_aircraft,  SLE_UINT16,     SLV_120, SL_MAX_VERSION),
 		SLE_CONDVAR(CompanyProperties, settings.vehicle.servint_ships,     SLE_UINT16,     SLV_120, SL_MAX_VERSION),
-
-		SLE_CONDNULL(63, SLV_2, SLV_144), // old reserved space
 	};
+	inline const static SaveLoadCompatTable compat_description = _company_settings_compat;
 
-	void GenericSaveLoad(CompanyProperties *c) const
+	void Save(CompanyProperties *c) const override
 	{
 		SlObject(c, this->GetDescription());
 	}
 
-	void Save(CompanyProperties *c) const override { this->GenericSaveLoad(c); }
-	void Load(CompanyProperties *c) const override { this->GenericSaveLoad(c); }
-	void LoadCheck(CompanyProperties *c) const override { this->GenericSaveLoad(c); }
-	void FixPointers(CompanyProperties *c) const override { this->GenericSaveLoad(c); }
+	void Load(CompanyProperties *c) const override
+	{
+		SlObject(c, this->GetLoadDescription());
+	}
+
+	void FixPointers(CompanyProperties *c) const override
+	{
+		SlObject(c, this->GetDescription());
+	}
+
+	void LoadCheck(CompanyProperties *c) const override { this->Load(c); }
 };
 
 class SlCompanyEconomy : public DefaultSaveLoadHandler<SlCompanyEconomy, CompanyProperties> {
@@ -358,16 +331,24 @@ public:
 		SLE_CONDARR(CompanyEconomyEntry, delivered_cargo,     SLE_UINT32, NUM_CARGO,    SLV_EXTEND_CARGOTYPES, SL_MAX_VERSION),
 		    SLE_VAR(CompanyEconomyEntry, performance_history, SLE_INT32),
 	};
+	inline const static SaveLoadCompatTable compat_description = _company_economy_compat;
+
+	void Save(CompanyProperties *c) const override
+	{
+		SlObject(&c->cur_economy, this->GetDescription());
+	}
+
+	void Load(CompanyProperties *c) const override
+	{
+		SlObject(&c->cur_economy, this->GetLoadDescription());
+	}
 
-	void GenericSaveLoad(CompanyProperties *c) const
+	void FixPointers(CompanyProperties *c) const override
 	{
 		SlObject(&c->cur_economy, this->GetDescription());
 	}
 
-	void Save(CompanyProperties *c) const override { this->GenericSaveLoad(c); }
-	void Load(CompanyProperties *c) const override { this->GenericSaveLoad(c); }
-	void LoadCheck(CompanyProperties *c) const override { this->GenericSaveLoad(c); }
-	void FixPointers(CompanyProperties *c) const override { this->GenericSaveLoad(c); }
+	void LoadCheck(CompanyProperties *c) const override { this->Load(c); }
 };
 
 class SlCompanyOldEconomy : public SlCompanyEconomy {
@@ -388,7 +369,7 @@ public:
 		if (c->num_valid_stat_ent > lengthof(c->old_economy)) SlErrorCorrupt("Too many old economy entries");
 
 		for (int i = 0; i < c->num_valid_stat_ent; i++) {
-			SlObject(&c->old_economy[i], this->GetDescription());
+			SlObject(&c->old_economy[i], this->GetLoadDescription());
 		}
 	}
 
@@ -402,6 +383,7 @@ public:
 		SLE_CONDVAR(Livery, colour1, SLE_UINT8, SLV_34, SL_MAX_VERSION),
 		SLE_CONDVAR(Livery, colour2, SLE_UINT8, SLV_34, SL_MAX_VERSION),
 	};
+	inline const static SaveLoadCompatTable compat_description = _company_liveries_compat;
 
 	/**
 	 * Get the number of liveries used by this savegame version.
@@ -430,7 +412,7 @@ public:
 		bool update_in_use = IsSavegameVersionBefore(SLV_GROUP_LIVERIES);
 
 		for (size_t i = 0; i < num_liveries; i++) {
-			SlObject(&c->livery[i], this->GetDescription());
+			SlObject(&c->livery[i], this->GetLoadDescription());
 			if (update_in_use && i != LS_DEFAULT) {
 				if (c->livery[i].in_use == 0) {
 					c->livery[i].colour1 = c->livery[LS_DEFAULT].colour1;
@@ -479,11 +461,8 @@ static const SaveLoad _company_desc[] = {
 
 	    SLE_VAR(CompanyProperties, colour,                SLE_UINT8),
 	    SLE_VAR(CompanyProperties, money_fraction,        SLE_UINT8),
-	SLE_CONDNULL(1,  SL_MIN_VERSION,  SLV_58), ///< avail_railtypes
 	    SLE_VAR(CompanyProperties, block_preview,         SLE_UINT8),
 
-	SLE_CONDNULL(2,  SL_MIN_VERSION,  SLV_94), ///< cargo_types
-	SLE_CONDNULL(4, SLV_94, SLV_170), ///< cargo_types
 	SLE_CONDVAR(CompanyProperties, location_of_HQ,        SLE_FILE_U16 | SLE_VAR_U32,  SL_MIN_VERSION,  SLV_6),
 	SLE_CONDVAR(CompanyProperties, location_of_HQ,        SLE_UINT32,                  SLV_6, SL_MAX_VERSION),
 	SLE_CONDVAR(CompanyProperties, last_build_coordinate, SLE_FILE_U16 | SLE_VAR_U32,  SL_MIN_VERSION,  SLV_6),
@@ -507,8 +486,6 @@ static const SaveLoad _company_desc[] = {
 	SLE_CONDARR(CompanyProperties, yearly_expenses,       SLE_INT64, 3 * 13,                  SLV_2, SL_MAX_VERSION),
 
 	SLE_CONDVAR(CompanyProperties, is_ai,                 SLE_BOOL,                    SLV_2, SL_MAX_VERSION),
-	SLE_CONDNULL(1, SLV_107, SLV_112), ///< is_noai
-	SLE_CONDNULL(1, SLV_4, SLV_100),
 
 	SLE_CONDVAR(CompanyProperties, terraform_limit,       SLE_UINT32,                SLV_156, SL_MAX_VERSION),
 	SLE_CONDVAR(CompanyProperties, clear_limit,           SLE_UINT32,                SLV_156, SL_MAX_VERSION),
@@ -522,6 +499,8 @@ static const SaveLoad _company_desc[] = {
 
 static void Save_PLYR()
 {
+	SlTableHeader(_company_desc);
+
 	for (Company *c : Company::Iterate()) {
 		SlSetArrayIndex(c->index);
 		SlObject(c, _company_desc);
@@ -530,20 +509,24 @@ static void Save_PLYR()
 
 static void Load_PLYR()
 {
+	const std::vector<SaveLoad> slt = SlCompatTableHeader(_company_desc, _company_sl_compat);
+
 	int index;
 	while ((index = SlIterateArray()) != -1) {
 		Company *c = new (index) Company();
-		SlObject(c, _company_desc);
+		SlObject(c, slt);
 		_company_colours[index] = (Colours)c->colour;
 	}
 }
 
 static void Check_PLYR()
 {
+	const std::vector<SaveLoad> slt = SlCompatTableHeader(_company_desc, _company_sl_compat);
+
 	int index;
 	while ((index = SlIterateArray()) != -1) {
 		CompanyProperties *cprops = new CompanyProperties();
-		SlObject(cprops, _company_desc);
+		SlObject(cprops, slt);
 
 		/* We do not load old custom names */
 		if (IsSavegameVersionBefore(SLV_84)) {
@@ -576,7 +559,7 @@ static void Ptrs_PLYR()
 
 
 static const ChunkHandler company_chunk_handlers[] = {
-	{ 'PLYR', Save_PLYR, Load_PLYR, Ptrs_PLYR, Check_PLYR, CH_ARRAY },
+	{ 'PLYR', Save_PLYR, Load_PLYR, Ptrs_PLYR, Check_PLYR, CH_TABLE },
 };
 
 extern const ChunkHandlerTable _company_chunk_handlers(company_chunk_handlers);
diff --git a/src/saveload/compat/CMakeLists.txt b/src/saveload/compat/CMakeLists.txt
index 1737f9493..dc7c57e5c 100644
--- a/src/saveload/compat/CMakeLists.txt
+++ b/src/saveload/compat/CMakeLists.txt
@@ -4,6 +4,7 @@ add_files(
     cargomonitor_sl_compat.h
     cargopacket_sl_compat.h
     cheat_sl_compat.h
+    company_sl_compat.h
     depot_sl_compat.h
     economy_sl_compat.h
     engine_sl_compat.h
@@ -23,4 +24,6 @@ add_files(
     storage_sl_compat.h
     story_sl_compat.h
     subsidy_sl_compat.h
+    town_sl_compat.h
+    vehicle_sl_compat.h
 )
diff --git a/src/saveload/compat/company_sl_compat.h b/src/saveload/compat/company_sl_compat.h
new file mode 100644
index 000000000..9da01d3a4
--- /dev/null
+++ b/src/saveload/compat/company_sl_compat.h
@@ -0,0 +1,129 @@
+/*
+ * This file is part of OpenTTD.
+ * OpenTTD is free software; you can redistribute it and/or modify it under the terms of the GNU General Public License as published by the Free Software Foundation, version 2.
+ * OpenTTD is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
+ * See the GNU General Public License for more details. You should have received a copy of the GNU General Public License along with OpenTTD. If not, see <http://www.gnu.org/licenses/>.
+ */
+
+/** @file company_sl_compat.h Loading of company chunks before table headers were added. */
+
+#ifndef SAVELOAD_COMPAT_COMPANY_H
+#define SAVELOAD_COMPAT_COMPANY_H
+
+#include "../saveload.h"
+
+/** Original field order for SlCompanyOldAIBuildRec. */
+const SaveLoadCompat _company_old_ai_buildrec_compat[] = {
+	SLC_NULL(2, SL_MIN_VERSION, SLV_6),
+	SLC_NULL(4, SLV_6, SLV_107),
+	SLC_NULL(2, SL_MIN_VERSION, SLV_6),
+	SLC_NULL(4, SLV_6, SLV_107),
+	SLC_NULL(8, SL_MIN_VERSION, SLV_107),
+};
+
+/** Original field order for SlCompanyOldAI. */
+const SaveLoadCompat _company_old_ai_compat[] = {
+	SLC_NULL(2,  SL_MIN_VERSION, SLV_107),
+	SLC_NULL(2,  SL_MIN_VERSION, SLV_13),
+	SLC_NULL(4, SLV_13, SLV_107),
+	SLC_NULL(8,  SL_MIN_VERSION, SLV_107),
+	SLC_VAR("num_build_rec"),
+	SLC_NULL(3,  SL_MIN_VERSION, SLV_107),
+
+	SLC_NULL(2,  SL_MIN_VERSION,  SLV_6),
+	SLC_NULL(4,  SLV_6, SLV_107),
+	SLC_NULL(2,  SL_MIN_VERSION,  SLV_6),
+	SLC_NULL(4,  SLV_6, SLV_107),
+	SLC_NULL(2,  SL_MIN_VERSION, SLV_107),
+
+	SLC_NULL(2,  SL_MIN_VERSION,  SLV_6),
+	SLC_NULL(4,  SLV_6, SLV_107),
+	SLC_NULL(2,  SL_MIN_VERSION,  SLV_6),
+	SLC_NULL(4,  SLV_6, SLV_107),
+	SLC_NULL(2,  SL_MIN_VERSION, SLV_107),
+
+	SLC_NULL(2,  SL_MIN_VERSION, SLV_69),
+	SLC_NULL(4,  SLV_69, SLV_107),
+
+	SLC_NULL(18, SL_MIN_VERSION, SLV_107),
+	SLC_NULL(20, SL_MIN_VERSION, SLV_107),
+	SLC_NULL(32, SL_MIN_VERSION, SLV_107),
+
+	SLC_NULL(64, SLV_2, SLV_107),
+	SLC_VAR("buildrec"),
+};
+
+/** Original field order for SlCompanySettings. */
+const SaveLoadCompat _company_settings_compat[] = {
+	SLC_NULL(512, SLV_16, SLV_19),
+	SLC_VAR("engine_renew_list"),
+	SLC_VAR("settings.engine_renew"),
+	SLC_VAR("settings.engine_renew_months"),
+	SLC_VAR("settings.engine_renew_money"),
+	SLC_VAR("settings.renew_keep_length"),
+	SLC_VAR("settings.vehicle.servint_ispercent"),
+	SLC_VAR("settings.vehicle.servint_trains"),
+	SLC_VAR("settings.vehicle.servint_roadveh"),
+	SLC_VAR("settings.vehicle.servint_aircraft"),
+	SLC_VAR("settings.vehicle.servint_ships"),
+	SLC_NULL(63, SLV_2, SLV_144),
+};
+
+/** Original field order for SlCompanyEconomy. */
+const SaveLoadCompat _company_economy_compat[] = {
+	SLC_VAR("income"),
+	SLC_VAR("expenses"),
+	SLC_VAR("company_value"),
+	SLC_VAR("delivered_cargo[NUM_CARGO - 1]"),
+	SLC_VAR("delivered_cargo"),
+	SLC_VAR("performance_history"),
+};
+
+/** Original field order for SlCompanyLiveries. */
+const SaveLoadCompat _company_liveries_compat[] = {
+	SLC_VAR("in_use"),
+	SLC_VAR("colour1"),
+	SLC_VAR("colour2"),
+};
+
+/** Original field order for company_desc. */
+const SaveLoadCompat _company_sl_compat[] = {
+	SLC_VAR("name_2"),
+	SLC_VAR("name_1"),
+	SLC_VAR("name"),
+	SLC_VAR("president_name_1"),
+	SLC_VAR("president_name_2"),
+	SLC_VAR("president_name"),
+	SLC_VAR("face"),
+	SLC_VAR("money"),
+	SLC_VAR("current_loan"),
+	SLC_VAR("colour"),
+	SLC_VAR("money_fraction"),
+	SLC_NULL(1, SL_MIN_VERSION, SLV_58),
+	SLC_VAR("block_preview"),
+	SLC_NULL(2, SL_MIN_VERSION, SLV_94),
+	SLC_NULL(4, SLV_94, SLV_170),
+	SLC_VAR("location_of_HQ"),
+	SLC_VAR("last_build_coordinate"),
+	SLC_VAR("inaugurated_year"),
+	SLC_VAR("share_owners"),
+	SLC_VAR("num_valid_stat_ent"),
+	SLC_VAR("months_of_bankruptcy"),
+	SLC_VAR("bankrupt_asked"),
+	SLC_VAR("bankrupt_timeout"),
+	SLC_VAR("bankrupt_value"),
+	SLC_VAR("yearly_expenses"),
+	SLC_VAR("is_ai"),
+	SLC_NULL(1, SLV_107, SLV_112),
+	SLC_NULL(1, SLV_4, SLV_100),
+	SLC_VAR("terraform_limit"),
+	SLC_VAR("clear_limit"),
+	SLC_VAR("tree_limit"),
+	SLC_VAR("settings"),
+	SLC_VAR("old_ai"),
+	SLC_VAR("cur_economy"),
+	SLC_VAR("old_economy"),
+	SLC_VAR("liveries"),
+};
+
+#endif /* SAVELOAD_COMPAT_COMPANY_H */
diff --git a/src/saveload/compat/game_sl_compat.h b/src/saveload/compat/game_sl_compat.h
index 204504e3b..cc05913d6 100644
--- a/src/saveload/compat/game_sl_compat.h
+++ b/src/saveload/compat/game_sl_compat.h
@@ -20,4 +20,16 @@ const SaveLoadCompat _game_script_sl_compat[] = {
 	SLC_VAR("is_random"),
 };
 
+/** Original field order for SlGameLanguageString. */
+const SaveLoadCompat _game_language_string_sl_compat[] = {
+	SLC_VAR("string"),
+};
+
+/** Original field order for _game_language_desc. */
+const SaveLoadCompat _game_language_sl_compat[] = {
+	SLC_VAR("language"),
+	SLC_VAR("count"),
+	SLC_VAR("strings"),
+};
+
 #endif /* SAVELOAD_COMPAT_GAME_H */
diff --git a/src/saveload/compat/gamelog_sl_compat.h b/src/saveload/compat/gamelog_sl_compat.h
new file mode 100644
index 000000000..f1298bf92
--- /dev/null
+++ b/src/saveload/compat/gamelog_sl_compat.h
@@ -0,0 +1,105 @@
+/*
+ * This file is part of OpenTTD.
+ * OpenTTD is free software; you can redistribute it and/or modify it under the terms of the GNU General Public License as published by the Free Software Foundation, version 2.
+ * OpenTTD is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
+ * See the GNU General Public License for more details. You should have received a copy of the GNU General Public License along with OpenTTD. If not, see <http://www.gnu.org/licenses/>.
+ */
+
+/** @file gamelog_sl_compat.h Loading for gamelog chunks before table headers were added. */
+
+#ifndef SAVELOAD_COMPAT_GAMELOG_H
+#define SAVELOAD_COMPAT_GAMELOG_H
+
+#include "../saveload.h"
+
+/** Original field order for SlGamelogMode. */
+const SaveLoadCompat _gamelog_mode_sl_compat[] = {
+	SLC_VAR("mode.mode"),
+	SLC_VAR("mode.landscape"),
+};
+
+/** Original field order for SlGamelogRevision. */
+const SaveLoadCompat _gamelog_revision_sl_compat[] = {
+	SLC_VAR("revision.text"),
+	SLC_VAR("revision.newgrf"),
+	SLC_VAR("revision.slver"),
+	SLC_VAR("revision.modified"),
+};
+
+/** Original field order for SlGamelogOldver. */
+const SaveLoadCompat _gamelog_oldver_sl_compat[] = {
+	SLC_VAR("oldver.type"),
+	SLC_VAR("oldver.version"),
+};
+
+/** Original field order for SlGamelogSetting. */
+const SaveLoadCompat _gamelog_setting_sl_compat[] = {
+	SLC_VAR("setting.name"),
+	SLC_VAR("setting.oldval"),
+	SLC_VAR("setting.newval"),
+};
+
+/** Original field order for SlGamelogGrfadd. */
+const SaveLoadCompat _gamelog_grfadd_sl_compat[] = {
+	SLC_VAR("grfadd.grfid"),
+	SLC_VAR("grfadd.md5sum"),
+};
+
+/** Original field order for SlGamelogGrfrem. */
+const SaveLoadCompat _gamelog_grfrem_sl_compat[] = {
+	SLC_VAR("grfrem.grfid"),
+};
+
+/** Original field order for SlGamelogGrfcompat. */
+const SaveLoadCompat _gamelog_grfcompat_sl_compat[] = {
+	SLC_VAR("grfcompat.grfid"),
+	SLC_VAR("grfcompat.md5sum"),
+};
+
+/** Original field order for SlGamelogGrfparam. */
+const SaveLoadCompat _gamelog_grfparam_sl_compat[] = {
+	SLC_VAR("grfparam.grfid"),
+};
+
+/** Original field order for SlGamelogGrfmove. */
+const SaveLoadCompat _gamelog_grfmove_sl_compat[] = {
+	SLC_VAR("grfmove.grfid"),
+	SLC_VAR("grfmove.offset"),
+};
+
+/** Original field order for SlGamelogGrfbug. */
+const SaveLoadCompat _gamelog_grfbug_sl_compat[] = {
+	SLC_VAR("grfbug.data"),
+	SLC_VAR("grfbug.grfid"),
+	SLC_VAR("grfbug.bug"),
+};
+
+/** Original field order for SlGamelogEmergency. */
+const SaveLoadCompat _gamelog_emergency_sl_compat[] = {
+	SLC_VAR("is_emergency_save"),
+};
+
+/** Original field order for SlGamelogAction. */
+const SaveLoadCompat _gamelog_action_sl_compat[] = {
+	SLC_VAR("ct"),
+	SLC_VAR("mode"),
+	SLC_VAR("revision"),
+	SLC_VAR("oldver"),
+	SLC_VAR("setting"),
+	SLC_VAR("grfadd"),
+	SLC_VAR("grfrem"),
+	SLC_VAR("grfcompat"),
+	SLC_VAR("grfparam"),
+	SLC_VAR("grfmove"),
+	SLC_VAR("grfbug"),
+	SLC_VAR("emergency"),
+};
+
+/** Original field order for _gamelog_desc. */
+const SaveLoadCompat _gamelog_sl_compat[] = {
+	SLC_VAR("at"),
+	SLC_VAR("tick"),
+	SLC_VAR("action"),
+};
+
+#endif /* SAVELOAD_COMPAT_GAMELOG_H */
diff --git a/src/saveload/compat/linkgraph_sl_compat.h b/src/saveload/compat/linkgraph_sl_compat.h
new file mode 100644
index 000000000..eb455da8f
--- /dev/null
+++ b/src/saveload/compat/linkgraph_sl_compat.h
@@ -0,0 +1,66 @@
+/*
+ * This file is part of OpenTTD.
+ * OpenTTD is free software; you can redistribute it and/or modify it under the terms of the GNU General Public License as published by the Free Software Foundation, version 2.
+ * OpenTTD is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
+ * See the GNU General Public License for more details. You should have received a copy of the GNU General Public License along with OpenTTD. If not, see <http://www.gnu.org/licenses/>.
+ */
+
+/** @file linkgraph_sl_compat.h Loading of linkgraph chunks before table headers were added. */
+
+#ifndef SAVELOAD_COMPAT_LINKGRAPH_H
+#define SAVELOAD_COMPAT_LINKGRAPH_H
+
+#include "../saveload.h"
+
+/** Original field order for SlLinkgraphEdge. */
+const SaveLoadCompat _linkgraph_edge_sl_compat[] = {
+	SLC_NULL(4, SL_MIN_VERSION, SLV_191),
+	SLC_VAR("capacity"),
+	SLC_VAR("usage"),
+	SLC_VAR("last_unrestricted_update"),
+	SLC_VAR("last_restricted_update"),
+	SLC_VAR("next_edge"),
+};
+
+/** Original field order for SlLinkgraphNode. */
+const SaveLoadCompat _linkgraph_node_sl_compat[] = {
+	SLC_VAR("xy"),
+	SLC_VAR("supply"),
+	SLC_VAR("demand"),
+	SLC_VAR("station"),
+	SLC_VAR("last_update"),
+	SLC_VAR("edges"),
+};
+
+/** Original field order for link_graph_desc. */
+const SaveLoadCompat _linkgraph_sl_compat[] = {
+	SLC_VAR("last_compression"),
+	SLC_VAR("num_nodes"),
+	SLC_VAR("cargo"),
+	SLC_VAR("nodes"),
+};
+
+/** Original field order for job_desc. */
+const SaveLoadCompat _linkgraph_job_sl_compat[] = {
+	SLC_VAR("linkgraph.recalc_interval"),
+	SLC_VAR("linkgraph.recalc_time"),
+	SLC_VAR("linkgraph.distribution_pax"),
+	SLC_VAR("linkgraph.distribution_mail"),
+	SLC_VAR("linkgraph.distribution_armoured"),
+	SLC_VAR("linkgraph.distribution_default"),
+	SLC_VAR("linkgraph.accuracy"),
+	SLC_VAR("linkgraph.demand_distance"),
+	SLC_VAR("linkgraph.demand_size"),
+	SLC_VAR("linkgraph.short_path_saturation"),
+	SLC_VAR("join_date"),
+	SLC_VAR("link_graph.index"),
+	SLC_VAR("linkgraph"),
+};
+
+/** Original field order for schedule_desc. */
+const SaveLoadCompat _linkgraph_schedule_sl_compat[] = {
+	SLC_VAR("schedule"),
+	SLC_VAR("running"),
+};
+
+#endif /* SAVELOAD_COMPAT_LINKGRAPH_H */
diff --git a/src/saveload/compat/station_sl_compat.h b/src/saveload/compat/station_sl_compat.h
index 397e1660f..1c24a8d5d 100644
--- a/src/saveload/compat/station_sl_compat.h
+++ b/src/saveload/compat/station_sl_compat.h
@@ -26,4 +26,156 @@ const SaveLoadCompat _roadstop_sl_compat[] = {
 	SLC_NULL(1, SLV_25, SLV_26),
 };
 
+/** Original field order for SlStationSpecList. */
+const SaveLoadCompat _station_spec_list_sl_compat[] = {
+	SLC_VAR("grfid"),
+	SLC_VAR("localidx"),
+};
+
+/** Original field order for SlStationCargo. */
+const SaveLoadCompat _station_cargo_sl_compat[] = {
+	SLC_VAR("first"),
+	SLC_VAR("second"),
+};
+
+/** Original field order for SlStationFlow. */
+const SaveLoadCompat _station_flow_sl_compat[] = {
+	SLC_VAR("source"),
+	SLC_VAR("via"),
+	SLC_VAR("share"),
+	SLC_VAR("restricted"),
+};
+
+/** Original field order for SlStationGoods. */
+const SaveLoadCompat _station_goods_sl_compat[] = {
+	SLC_VAR("waiting_acceptance"),
+	SLC_VAR("status"),
+	SLC_NULL(2, SLV_51, SLV_68),
+	SLC_VAR("time_since_pickup"),
+	SLC_VAR("rating"),
+	SLC_VAR("cargo_source"),
+	SLC_VAR("cargo_source_xy"),
+	SLC_VAR("cargo_days"),
+	SLC_VAR("last_speed"),
+	SLC_VAR("last_age"),
+	SLC_VAR("cargo_feeder_share"),
+	SLC_VAR("amount_fract"),
+	SLC_VAR("packets"),
+	SLC_VAR("old_num_dests"),
+	SLC_VAR("cargo.reserved_count"),
+	SLC_VAR("link_graph"),
+	SLC_VAR("node"),
+	SLC_VAR("old_num_flows"),
+	SLC_VAR("max_waiting_cargo"),
+	SLC_VAR("flow"),
+	SLC_VAR("cargo"),
+};
+
+/** Original field order for SlStationBase. */
+const SaveLoadCompat _station_base_sl_compat[] = {
+	SLC_VAR("xy"),
+	SLC_VAR("town"),
+	SLC_VAR("string_id"),
+	SLC_VAR("name"),
+	SLC_VAR("delete_ctr"),
+	SLC_VAR("owner"),
+	SLC_VAR("facilities"),
+	SLC_VAR("build_date"),
+	SLC_VAR("random_bits"),
+	SLC_VAR("waiting_triggers"),
+	SLC_VAR("num_specs"),
+};
+
+/** Original field order for SlStationNormal. */
+const SaveLoadCompat _station_normal_sl_compat[] = {
+	SLC_VAR("base"),
+	SLC_VAR("train_station.tile"),
+	SLC_VAR("train_station.w"),
+	SLC_VAR("train_station.h"),
+	SLC_VAR("bus_stops"),
+	SLC_VAR("truck_stops"),
+	SLC_NULL(4, SL_MIN_VERSION, SLV_MULTITILE_DOCKS),
+	SLC_VAR("ship_station.tile"),
+	SLC_VAR("ship_station.w"),
+	SLC_VAR("ship_station.h"),
+	SLC_VAR("docking_station.tile"),
+	SLC_VAR("docking_station.w"),
+	SLC_VAR("docking_station.h"),
+	SLC_VAR("airport.tile"),
+	SLC_VAR("airport.w"),
+	SLC_VAR("airport.h"),
+	SLC_VAR("airport.type"),
+	SLC_VAR("airport.layout"),
+	SLC_VAR("airport.flags"),
+	SLC_VAR("airport.rotation"),
+	SLC_VAR("storage"),
+	SLC_VAR("airport.psa"),
+	SLC_VAR("indtype"),
+	SLC_VAR("time_since_load"),
+	SLC_VAR("time_since_unload"),
+	SLC_VAR("last_vehicle_type"),
+	SLC_VAR("had_vehicle_of_type"),
+	SLC_VAR("loading_vehicles"),
+	SLC_VAR("always_accepted"),
+	SLC_VAR("goods"),
+};
+
+/** Original field order for SlStationWaypoint. */
+const SaveLoadCompat _station_waypoint_sl_compat[] = {
+	SLC_VAR("base"),
+	SLC_VAR("town_cn"),
+	SLC_VAR("train_station.tile"),
+	SLC_VAR("train_station.w"),
+	SLC_VAR("train_station.h"),
+};
+
+/** Original field order for _station_desc. */
+const SaveLoadCompat _station_sl_compat[] = {
+	SLC_VAR("facilities"),
+	SLC_VAR("normal"),
+	SLC_VAR("waypoint"),
+	SLC_VAR("speclist"),
+};
+
+/** Original field order for _old_station_desc. */
+const SaveLoadCompat _old_station_sl_compat[] = {
+	SLC_VAR("xy"),
+	SLC_NULL(4, SL_MIN_VERSION, SLV_6),
+	SLC_VAR("train_station.tile"),
+	SLC_VAR("airport.tile"),
+	SLC_NULL(2, SL_MIN_VERSION, SLV_6),
+	SLC_NULL(4, SLV_6, SLV_MULTITILE_DOCKS),
+	SLC_VAR("town"),
+	SLC_VAR("train_station.w"),
+	SLC_VAR("train_station.h"),
+	SLC_NULL(1, SL_MIN_VERSION, SLV_4),
+	SLC_VAR("string_id"),
+	SLC_VAR("name"),
+	SLC_VAR("indtype"),
+	SLC_VAR("had_vehicle_of_type"),
+	SLC_VAR("time_since_load"),
+	SLC_VAR("time_since_unload"),
+	SLC_VAR("delete_ctr"),
+	SLC_VAR("owner"),
+	SLC_VAR("facilities"),
+	SLC_VAR("airport.type"),
+	SLC_NULL(2, SL_MIN_VERSION, SLV_6),
+	SLC_NULL(1, SL_MIN_VERSION, SLV_5),
+	SLC_VAR("airport.flags"),
+	SLC_NULL(2, SL_MIN_VERSION, SLV_26),
+	SLC_VAR("last_vehicle_type"),
+	SLC_NULL(2, SLV_3, SLV_26),
+	SLC_VAR("build_date"),
+	SLC_VAR("bus_stops"),
+	SLC_VAR("truck_stops"),
+	SLC_VAR("random_bits"),
+	SLC_VAR("waiting_triggers"),
+	SLC_VAR("num_specs"),
+	SLC_VAR("loading_vehicles"),
+	SLC_NULL(32, SLV_2, SL_MAX_VERSION),
+	SLC_VAR("goods"),
+	SLC_VAR("speclist"),
+
+};
+
 #endif /* SAVELOAD_COMPAT_STATION_H */
diff --git a/src/saveload/compat/town_sl_compat.h b/src/saveload/compat/town_sl_compat.h
new file mode 100644
index 000000000..34a414102
--- /dev/null
+++ b/src/saveload/compat/town_sl_compat.h
@@ -0,0 +1,87 @@
+/*
+ * This file is part of OpenTTD.
+ * OpenTTD is free software; you can redistribute it and/or modify it under the terms of the GNU General Public License as published by the Free Software Foundation, version 2.
+ * OpenTTD is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
+ * See the GNU General Public License for more details. You should have received a copy of the GNU General Public License along with OpenTTD. If not, see <http://www.gnu.org/licenses/>.
+ */
+
+/** @file town_sl_compat.h Loading of town chunks before table headers were added. */
+
+#ifndef SAVELOAD_COMPAT_TOWN_H
+#define SAVELOAD_COMPAT_TOWN_H
+
+#include "../saveload.h"
+
+/** Original field order for SlTownSupplied. */
+const SaveLoadCompat _town_supplied_sl_compat[] = {
+	SLC_VAR("old_max"),
+	SLC_VAR("new_max"),
+	SLC_VAR("old_act"),
+	SLC_VAR("new_act"),
+};
+
+/** Original field order for SlTownReceived. */
+const SaveLoadCompat _town_received_sl_compat[] = {
+	SLC_VAR("old_max"),
+	SLC_VAR("new_max"),
+	SLC_VAR("old_act"),
+	SLC_VAR("new_act"),
+};
+
+/** Original field order for SlTownAcceptanceMatrix. */
+const SaveLoadCompat _town_acceptance_matrix_sl_compat[] = {
+	SLC_VAR("area.tile"),
+	SLC_VAR("area.w"),
+	SLC_VAR("area.h"),
+};
+
+/** Original field order for town_desc. */
+const SaveLoadCompat _town_sl_compat[] = {
+	SLC_VAR("xy"),
+	SLC_NULL(2, SL_MIN_VERSION, SLV_3),
+	SLC_NULL(4, SLV_3, SLV_85),
+	SLC_NULL(2, SL_MIN_VERSION, SLV_92),
+	SLC_VAR("townnamegrfid"),
+	SLC_VAR("townnametype"),
+	SLC_VAR("townnameparts"),
+	SLC_VAR("name"),
+	SLC_VAR("flags"),
+	SLC_VAR("statues"),
+	SLC_NULL(1, SL_MIN_VERSION, SLV_2),
+	SLC_VAR("have_ratings"),
+	SLC_VAR("ratings"),
+	SLC_VAR("unwanted"),
+	SLC_VAR("supplied[CT_PASSENGERS].old_max"),
+	SLC_VAR("supplied[CT_MAIL].old_max"),
+	SLC_VAR("supplied[CT_PASSENGERS].new_max"),
+	SLC_VAR("supplied[CT_MAIL].new_max"),
+	SLC_VAR("supplied[CT_PASSENGERS].old_act"),
+	SLC_VAR("supplied[CT_MAIL].old_act"),
+	SLC_VAR("supplied[CT_PASSENGERS].new_act"),
+	SLC_VAR("supplied[CT_MAIL].new_act"),
+	SLC_NULL(2, SL_MIN_VERSION, SLV_164),
+	SLC_VAR("received[TE_FOOD].old_act"),
+	SLC_VAR("received[TE_WATER].old_act"),
+	SLC_VAR("received[TE_FOOD].new_act"),
+	SLC_VAR("received[TE_WATER].new_act"),
+	SLC_VAR("goal"),
+	SLC_VAR("text"),
+	SLC_VAR("time_until_rebuild"),
+	SLC_VAR("grow_counter"),
+	SLC_VAR("growth_rate"),
+	SLC_VAR("fund_buildings_months"),
+	SLC_VAR("road_build_months"),
+	SLC_VAR("exclusivity"),
+	SLC_VAR("exclusive_counter"),
+	SLC_VAR("larger_town"),
+	SLC_VAR("layout"),
+	SLC_VAR("psa_list"),
+	SLC_NULL(4, SLV_166, SLV_EXTEND_CARGOTYPES),
+	SLC_NULL(8, SLV_EXTEND_CARGOTYPES, SLV_REMOVE_TOWN_CARGO_CACHE),
+	SLC_NULL(30, SLV_2, SLV_REMOVE_TOWN_CARGO_CACHE),
+	SLC_VAR("supplied"),
+	SLC_VAR("received"),
+	SLC_VAR("acceptance_matrix"),
+};
+
+#endif /* SAVELOAD_COMPAT_TOWN_H */
diff --git a/src/saveload/compat/vehicle_sl_compat.h b/src/saveload/compat/vehicle_sl_compat.h
new file mode 100644
index 000000000..524ff1a3b
--- /dev/null
+++ b/src/saveload/compat/vehicle_sl_compat.h
@@ -0,0 +1,207 @@
+/*
+ * This file is part of OpenTTD.
+ * OpenTTD is free software; you can redistribute it and/or modify it under the terms of the GNU General Public License as published by the Free Software Foundation, version 2.
+ * OpenTTD is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
+ * See the GNU General Public License for more details. You should have received a copy of the GNU General Public License along with OpenTTD. If not, see <http://www.gnu.org/licenses/>.
+ */
+
+/** @file vehicle_sl_compat.h Loading of vehicle chunks before table headers were added. */
+
+#ifndef SAVELOAD_COMPAT_VEHICLE_H
+#define SAVELOAD_COMPAT_VEHICLE_H
+
+#include "../saveload.h"
+
+/** Original field order for SlVehicleCommon. */
+const SaveLoadCompat _vehicle_common_sl_compat[] = {
+	SLC_VAR("subtype"),
+	SLC_VAR("next"),
+	SLC_VAR("name"),
+	SLC_VAR("unitnumber"),
+	SLC_VAR("owner"),
+	SLC_VAR("tile"),
+	SLC_VAR("dest_tile"),
+	SLC_VAR("x_pos"),
+	SLC_VAR("y_pos"),
+	SLC_VAR("z_pos"),
+	SLC_VAR("direction"),
+	SLC_NULL(2, SL_MIN_VERSION, SLV_58),
+	SLC_VAR("spritenum"),
+	SLC_NULL(5, SL_MIN_VERSION, SLV_58),
+	SLC_VAR("engine_type"),
+	SLC_NULL(2, SL_MIN_VERSION, SLV_152),
+	SLC_VAR("cur_speed"),
+	SLC_VAR("subspeed"),
+	SLC_VAR("acceleration"),
+	SLC_VAR("motion_counter"),
+	SLC_VAR("progress"),
+	SLC_VAR("vehstatus"),
+	SLC_VAR("last_station_visited"),
+	SLC_VAR("last_loading_station"),
+	SLC_VAR("cargo_type"),
+	SLC_VAR("cargo_subtype"),
+	SLC_VAR("cargo_days"),
+	SLC_VAR("cargo_source"),
+	SLC_VAR("cargo_source_xy"),
+	SLC_VAR("cargo_cap"),
+	SLC_VAR("refit_cap"),
+	SLC_VAR("cargo_count"),
+	SLC_VAR("cargo.packets"),
+	SLC_VAR("cargo.action_counts"),
+	SLC_VAR("cargo_age_counter"),
+	SLC_VAR("day_counter"),
+	SLC_VAR("tick_counter"),
+	SLC_VAR("running_ticks"),
+	SLC_VAR("cur_implicit_order_index"),
+	SLC_VAR("cur_real_order_index"),
+	SLC_NULL(1, SL_MIN_VERSION, SLV_105),
+	SLC_VAR("current_order.type"),
+	SLC_VAR("current_order.flags"),
+	SLC_VAR("current_order.dest"),
+	SLC_VAR("current_order.refit_cargo"),
+	SLC_NULL(1, SLV_36, SLV_182),
+	SLC_VAR("current_order.wait_time"),
+	SLC_VAR("current_order.travel_time"),
+	SLC_VAR("current_order.max_speed"),
+	SLC_VAR("timetable_start"),
+	SLC_VAR("orders"),
+	SLC_VAR("age"),
+	SLC_VAR("max_age"),
+	SLC_VAR("date_of_last_service"),
+	SLC_VAR("service_interval"),
+	SLC_VAR("reliability"),
+	SLC_VAR("reliability_spd_dec"),
+	SLC_VAR("breakdown_ctr"),
+	SLC_VAR("breakdown_delay"),
+	SLC_VAR("breakdowns_since_last_service"),
+	SLC_VAR("breakdown_chance"),
+	SLC_VAR("build_year"),
+	SLC_VAR("load_unload_ticks"),
+	SLC_VAR("cargo_paid_for"),
+	SLC_VAR("vehicle_flags"),
+	SLC_VAR("profit_this_year"),
+	SLC_VAR("profit_last_year"),
+	SLC_VAR("cargo_feeder_share"),
+	SLC_VAR("cargo_loaded_at_xy"),
+	SLC_VAR("value"),
+	SLC_VAR("random_bits"),
+	SLC_VAR("waiting_triggers"),
+	SLC_VAR("next_shared"),
+	SLC_NULL(2, SLV_2, SLV_69),
+	SLC_NULL(4, SLV_69, SLV_101),
+	SLC_VAR("group_id"),
+	SLC_VAR("current_order_time"),
+	SLC_VAR("lateness_counter"),
+	SLC_NULL(10, SLV_2, SLV_144),
+};
+
+/** Original field order for SlVehicleTrain. */
+const SaveLoadCompat _vehicle_train_sl_compat[] = {
+	SLC_VAR("common"),
+	SLC_VAR("crash_anim_pos"),
+	SLC_VAR("force_proceed"),
+	SLC_VAR("railtype"),
+	SLC_VAR("track"),
+	SLC_VAR("flags"),
+	SLC_NULL(2, SLV_2, SLV_60),
+	SLC_VAR("wait_counter"),
+	SLC_NULL(2, SLV_2, SLV_20),
+	SLC_VAR("gv_flags"),
+	SLC_NULL(11, SLV_2, SLV_144),
+};
+
+/** Original field order for SlVehicleRoadVeh. */
+const SaveLoadCompat _vehicle_roadveh_sl_compat[] = {
+	SLC_VAR("common"),
+	SLC_VAR("state"),
+	SLC_VAR("frame"),
+	SLC_VAR("blocked_ctr"),
+	SLC_VAR("overtaking"),
+	SLC_VAR("overtaking_ctr"),
+	SLC_VAR("crashed_ctr"),
+	SLC_VAR("reverse_ctr"),
+	SLC_VAR("path.td"),
+	SLC_VAR("path.tile"),
+	SLC_NULL(2, SLV_6, SLV_69),
+	SLC_VAR("gv_flags"),
+	SLC_NULL(4, SLV_69, SLV_131),
+	SLC_NULL(2, SLV_6, SLV_131),
+	SLC_NULL(16, SLV_2, SLV_144),
+};
+
+/** Original field order for SlVehicleShip. */
+const SaveLoadCompat _vehicle_ship_sl_compat[] = {
+	SLC_VAR("common"),
+	SLC_VAR("state"),
+	SLC_VAR("path"),
+	SLC_VAR("rotation"),
+	SLC_NULL(16, SLV_2, SLV_144),
+};
+
+/** Original field order for SlVehicleAircraft. */
+const SaveLoadCompat _vehicle_aircraft_sl_compat[] = {
+	SLC_VAR("common"),
+	SLC_VAR("crashed_counter"),
+	SLC_VAR("pos"),
+	SLC_VAR("targetairport"),
+	SLC_VAR("state"),
+	SLC_VAR("previous_pos"),
+	SLC_VAR("last_direction"),
+	SLC_VAR("number_consecutive_turns"),
+	SLC_VAR("turn_counter"),
+	SLC_VAR("flags"),
+	SLC_NULL(13, SLV_2, SLV_144),
+};
+
+/** Original field order for SlVehicleEffect. */
+const SaveLoadCompat _vehicle_effect_sl_compat[] = {
+	SLC_VAR("subtype"),
+	SLC_VAR("tile"),
+	SLC_VAR("x_pos"),
+	SLC_VAR("y_pos"),
+	SLC_VAR("z_pos"),
+	SLC_VAR("sprite_cache.sprite_seq.seq[0].sprite"),
+	SLC_NULL(5, SL_MIN_VERSION, SLV_59),
+	SLC_VAR("progress"),
+	SLC_VAR("vehstatus"),
+	SLC_VAR("animation_state"),
+	SLC_VAR("animation_substate"),
+	SLC_VAR("spritenum"),
+	SLC_NULL(15, SLV_2, SLV_144),
+};
+
+/** Original field order for SlVehicleDisaster. */
+const SaveLoadCompat _vehicle_disaster_sl_compat[] = {
+	SLC_VAR("next"),
+	SLC_VAR("subtype"),
+	SLC_VAR("tile"),
+	SLC_VAR("dest_tile"),
+	SLC_VAR("x_pos"),
+	SLC_VAR("y_pos"),
+	SLC_VAR("z_pos"),
+	SLC_VAR("direction"),
+	SLC_NULL(5, SL_MIN_VERSION, SLV_58),
+	SLC_VAR("owner"),
+	SLC_VAR("vehstatus"),
+	SLC_VAR("current_order.dest"),
+	SLC_VAR("sprite_cache.sprite_seq.seq[0].sprite"),
+	SLC_VAR("age"),
+	SLC_VAR("tick_counter"),
+	SLC_VAR("image_override"),
+	SLC_VAR("big_ufo_destroyer_target"),
+	SLC_VAR("flags"),
+	SLC_NULL(16, SLV_2, SLV_144),
+};
+
+/** Original field order for vehicle_desc. */
+const SaveLoadCompat _vehicle_sl_compat[] = {
+	SLC_VAR("type"),
+	SLC_VAR("train"),
+	SLC_VAR("roadveh"),
+	SLC_VAR("ship"),
+	SLC_VAR("aircraft"),
+	SLC_VAR("effect"),
+	SLC_VAR("disaster"),
+};
+
+#endif /* SAVELOAD_COMPAT_VEHICLE_H */
diff --git a/src/saveload/game_sl.cpp b/src/saveload/game_sl.cpp
index 059e17333..f0083cb88 100644
--- a/src/saveload/game_sl.cpp
+++ b/src/saveload/game_sl.cpp
@@ -123,6 +123,7 @@ public:
 	inline static const SaveLoad description[] = {
 		SLEG_SSTR("string", _game_saveload_string, SLE_STR | SLF_ALLOW_CONTROL),
 	};
+	inline const static SaveLoadCompatTable compat_description = _game_language_string_sl_compat;
 
 	void Save(LanguageStrings *ls) const override
 	{
@@ -139,7 +140,7 @@ public:
 		uint32 length = IsSavegameVersionBefore(SLV_SAVELOAD_LIST_LENGTH) ? _game_saveload_strings : (uint32)SlGetStructListLength(UINT32_MAX);
 
 		for (uint32 i = 0; i < length; i++) {
-			SlObject(nullptr, this->GetDescription());
+			SlObject(nullptr, this->GetLoadDescription());
 			ls->lines.emplace_back(_game_saveload_string);
 		}
 	}
@@ -153,12 +154,14 @@ static const SaveLoad _game_language_desc[] = {
 
 static void Load_GSTR()
 {
+	const std::vector<SaveLoad> slt = SlCompatTableHeader(_game_language_desc, _game_language_sl_compat);
+
 	delete _current_data;
 	_current_data = new GameStrings();
 
 	while (SlIterateArray() != -1) {
 		LanguageStrings ls;
-		SlObject(&ls, _game_language_desc);
+		SlObject(&ls, slt);
 		_current_data->raw_strings.push_back(std::move(ls));
 	}
 
@@ -175,6 +178,8 @@ static void Load_GSTR()
 
 static void Save_GSTR()
 {
+	SlTableHeader(_game_language_desc);
+
 	if (_current_data == nullptr) return;
 
 	for (uint i = 0; i < _current_data->raw_strings.size(); i++) {
@@ -184,7 +189,7 @@ static void Save_GSTR()
 }
 
 static const ChunkHandler game_chunk_handlers[] = {
-	{ 'GSTR', Save_GSTR, Load_GSTR, nullptr, nullptr, CH_ARRAY },
+	{ 'GSTR', Save_GSTR, Load_GSTR, nullptr, nullptr, CH_TABLE },
 	{ 'GSDT', Save_GSDT, Load_GSDT, nullptr, nullptr, CH_TABLE },
 };
 
diff --git a/src/saveload/gamelog_sl.cpp b/src/saveload/gamelog_sl.cpp
index f76718d42..8cc81c8cf 100644
--- a/src/saveload/gamelog_sl.cpp
+++ b/src/saveload/gamelog_sl.cpp
@@ -8,10 +8,12 @@
 /** @file gamelog_sl.cpp Code handling saving and loading of gamelog data */
 
 #include "../stdafx.h"
-#include "../gamelog_internal.h"
-#include "../fios.h"
 
 #include "saveload.h"
+#include "compat/gamelog_sl_compat.h"
+
+#include "../gamelog_internal.h"
+#include "../fios.h"
 
 #include "../safeguards.h"
 
@@ -22,16 +24,21 @@ public:
 		SLE_VAR(LoggedChange, mode.mode,         SLE_UINT8),
 		SLE_VAR(LoggedChange, mode.landscape,    SLE_UINT8),
 	};
+	inline const static SaveLoadCompatTable compat_description = _gamelog_mode_sl_compat;
 
-	void GenericSaveLoad(LoggedChange *lc) const
+	void Save(LoggedChange *lc) const override
 	{
 		if (lc->ct != GLCT_MODE) return;
 		SlObject(lc, this->GetDescription());
 	}
 
-	void Save(LoggedChange *lc) const override { this->GenericSaveLoad(lc); }
-	void Load(LoggedChange *lc) const override { this->GenericSaveLoad(lc); }
-	void LoadCheck(LoggedChange *lc) const override { this->GenericSaveLoad(lc); }
+	void Load(LoggedChange *lc) const override
+	{
+		if (lc->ct != GLCT_MODE) return;
+		SlObject(lc, this->GetLoadDescription());
+	}
+
+	void LoadCheck(LoggedChange *lc) const override { this->Load(lc); }
 };
 
 class SlGamelogRevision : public DefaultSaveLoadHandler<SlGamelogRevision, LoggedChange> {
@@ -42,16 +49,21 @@ public:
 		SLE_VAR(LoggedChange, revision.slver,    SLE_UINT16),
 		SLE_VAR(LoggedChange, revision.modified, SLE_UINT8),
 	};
+	inline const static SaveLoadCompatTable compat_description = _gamelog_revision_sl_compat;
 
-	void GenericSaveLoad(LoggedChange *lc) const
+	void Save(LoggedChange *lc) const override
 	{
 		if (lc->ct != GLCT_REVISION) return;
 		SlObject(lc, this->GetDescription());
 	}
 
-	void Save(LoggedChange *lc) const override { this->GenericSaveLoad(lc); }
-	void Load(LoggedChange *lc) const override { this->GenericSaveLoad(lc); }
-	void LoadCheck(LoggedChange *lc) const override { this->GenericSaveLoad(lc); }
+	void Load(LoggedChange *lc) const override
+	{
+		if (lc->ct != GLCT_REVISION) return;
+		SlObject(lc, this->GetLoadDescription());
+	}
+
+	void LoadCheck(LoggedChange *lc) const override { this->Load(lc); }
 };
 
 class SlGamelogOldver : public DefaultSaveLoadHandler<SlGamelogOldver, LoggedChange> {
@@ -60,16 +72,21 @@ public:
 		SLE_VAR(LoggedChange, oldver.type,       SLE_UINT32),
 		SLE_VAR(LoggedChange, oldver.version,    SLE_UINT32),
 	};
+	inline const static SaveLoadCompatTable compat_description = _gamelog_oldver_sl_compat;
 
-	void GenericSaveLoad(LoggedChange *lc) const
+	void Save(LoggedChange *lc) const override
 	{
 		if (lc->ct != GLCT_OLDVER) return;
 		SlObject(lc, this->GetDescription());
 	}
 
-	void Save(LoggedChange *lc) const override { this->GenericSaveLoad(lc); }
-	void Load(LoggedChange *lc) const override { this->GenericSaveLoad(lc); }
-	void LoadCheck(LoggedChange *lc) const override { this->GenericSaveLoad(lc); }
+	void Load(LoggedChange *lc) const override
+	{
+		if (lc->ct != GLCT_OLDVER) return;
+		SlObject(lc, this->GetLoadDescription());
+	}
+
+	void LoadCheck(LoggedChange *lc) const override { this->Load(lc); }
 };
 
 class SlGamelogSetting : public DefaultSaveLoadHandler<SlGamelogSetting, LoggedChange> {
@@ -79,16 +96,21 @@ public:
 		SLE_VAR(LoggedChange, setting.oldval,    SLE_INT32),
 		SLE_VAR(LoggedChange, setting.newval,    SLE_INT32),
 	};
+	inline const static SaveLoadCompatTable compat_description = _gamelog_setting_sl_compat;
 
-	void GenericSaveLoad(LoggedChange *lc) const
+	void Save(LoggedChange *lc) const override
 	{
 		if (lc->ct != GLCT_SETTING) return;
 		SlObject(lc, this->GetDescription());
 	}
 
-	void Save(LoggedChange *lc) const override { this->GenericSaveLoad(lc); }
-	void Load(LoggedChange *lc) const override { this->GenericSaveLoad(lc); }
-	void LoadCheck(LoggedChange *lc) const override { this->GenericSaveLoad(lc); }
+	void Load(LoggedChange *lc) const override
+	{
+		if (lc->ct != GLCT_SETTING) return;
+		SlObject(lc, this->GetLoadDescription());
+	}
+
+	void LoadCheck(LoggedChange *lc) const override { this->Load(lc); }
 };
 
 class SlGamelogGrfadd : public DefaultSaveLoadHandler<SlGamelogGrfadd, LoggedChange> {
@@ -97,16 +119,21 @@ public:
 		SLE_VAR(LoggedChange, grfadd.grfid,      SLE_UINT32    ),
 		SLE_ARR(LoggedChange, grfadd.md5sum,     SLE_UINT8,  16),
 	};
+	inline const static SaveLoadCompatTable compat_description = _gamelog_grfadd_sl_compat;
 
-	void GenericSaveLoad(LoggedChange *lc) const
+	void Save(LoggedChange *lc) const override
 	{
 		if (lc->ct != GLCT_GRFADD) return;
 		SlObject(lc, this->GetDescription());
 	}
 
-	void Save(LoggedChange *lc) const override { this->GenericSaveLoad(lc); }
-	void Load(LoggedChange *lc) const override { this->GenericSaveLoad(lc); }
-	void LoadCheck(LoggedChange *lc) const override { this->GenericSaveLoad(lc); }
+	void Load(LoggedChange *lc) const override
+	{
+		if (lc->ct != GLCT_GRFADD) return;
+		SlObject(lc, this->GetLoadDescription());
+	}
+
+	void LoadCheck(LoggedChange *lc) const override { this->Load(lc); }
 };
 
 class SlGamelogGrfrem : public DefaultSaveLoadHandler<SlGamelogGrfrem, LoggedChange> {
@@ -114,16 +141,21 @@ public:
 	inline static const SaveLoad description[] = {
 		SLE_VAR(LoggedChange, grfrem.grfid,      SLE_UINT32),
 	};
+	inline const static SaveLoadCompatTable compat_description = _gamelog_grfrem_sl_compat;
 
-	void GenericSaveLoad(LoggedChange *lc) const
+	void Save(LoggedChange *lc) const override
 	{
 		if (lc->ct != GLCT_GRFREM) return;
 		SlObject(lc, this->GetDescription());
 	}
 
-	void Save(LoggedChange *lc) const override { this->GenericSaveLoad(lc); }
-	void Load(LoggedChange *lc) const override { this->GenericSaveLoad(lc); }
-	void LoadCheck(LoggedChange *lc) const override { this->GenericSaveLoad(lc); }
+	void Load(LoggedChange *lc) const override
+	{
+		if (lc->ct != GLCT_GRFREM) return;
+		SlObject(lc, this->GetLoadDescription());
+	}
+
+	void LoadCheck(LoggedChange *lc) const override { this->Load(lc); }
 };
 
 class SlGamelogGrfcompat : public DefaultSaveLoadHandler<SlGamelogGrfcompat, LoggedChange> {
@@ -132,16 +164,21 @@ public:
 		SLE_VAR(LoggedChange, grfcompat.grfid,   SLE_UINT32    ),
 		SLE_ARR(LoggedChange, grfcompat.md5sum,  SLE_UINT8,  16),
 	};
+	inline const static SaveLoadCompatTable compat_description = _gamelog_grfcompat_sl_compat;
 
-	void GenericSaveLoad(LoggedChange *lc) const
+	void Save(LoggedChange *lc) const override
 	{
 		if (lc->ct != GLCT_GRFCOMPAT) return;
 		SlObject(lc, this->GetDescription());
 	}
 
-	void Save(LoggedChange *lc) const override { this->GenericSaveLoad(lc); }
-	void Load(LoggedChange *lc) const override { this->GenericSaveLoad(lc); }
-	void LoadCheck(LoggedChange *lc) const override { this->GenericSaveLoad(lc); }
+	void Load(LoggedChange *lc) const override
+	{
+		if (lc->ct != GLCT_GRFCOMPAT) return;
+		SlObject(lc, this->GetLoadDescription());
+	}
+
+	void LoadCheck(LoggedChange *lc) const override { this->Load(lc); }
 };
 
 class SlGamelogGrfparam : public DefaultSaveLoadHandler<SlGamelogGrfparam, LoggedChange> {
@@ -149,16 +186,21 @@ public:
 	inline static const SaveLoad description[] = {
 		SLE_VAR(LoggedChange, grfparam.grfid,    SLE_UINT32),
 	};
+	inline const static SaveLoadCompatTable compat_description = _gamelog_grfparam_sl_compat;
 
-	void GenericSaveLoad(LoggedChange *lc) const
+	void Save(LoggedChange *lc) const override
 	{
 		if (lc->ct != GLCT_GRFPARAM) return;
 		SlObject(lc, this->GetDescription());
 	}
 
-	void Save(LoggedChange *lc) const override { this->GenericSaveLoad(lc); }
-	void Load(LoggedChange *lc) const override { this->GenericSaveLoad(lc); }
-	void LoadCheck(LoggedChange *lc) const override { this->GenericSaveLoad(lc); }
+	void Load(LoggedChange *lc) const override
+	{
+		if (lc->ct != GLCT_GRFPARAM) return;
+		SlObject(lc, this->GetLoadDescription());
+	}
+
+	void LoadCheck(LoggedChange *lc) const override { this->Load(lc); }
 };
 
 class SlGamelogGrfmove : public DefaultSaveLoadHandler<SlGamelogGrfmove, LoggedChange> {
@@ -167,16 +209,21 @@ public:
 		SLE_VAR(LoggedChange, grfmove.grfid,     SLE_UINT32),
 		SLE_VAR(LoggedChange, grfmove.offset,    SLE_INT32),
 	};
+	inline const static SaveLoadCompatTable compat_description = _gamelog_grfmove_sl_compat;
 
-	void GenericSaveLoad(LoggedChange *lc) const
+	void Save(LoggedChange *lc) const override
 	{
 		if (lc->ct != GLCT_GRFMOVE) return;
 		SlObject(lc, this->GetDescription());
 	}
 
-	void Save(LoggedChange *lc) const override { this->GenericSaveLoad(lc); }
-	void Load(LoggedChange *lc) const override { this->GenericSaveLoad(lc); }
-	void LoadCheck(LoggedChange *lc) const override { this->GenericSaveLoad(lc); }
+	void Load(LoggedChange *lc) const override
+	{
+		if (lc->ct != GLCT_GRFMOVE) return;
+		SlObject(lc, this->GetLoadDescription());
+	}
+
+	void LoadCheck(LoggedChange *lc) const override { this->Load(lc); }
 };
 
 class SlGamelogGrfbug : public DefaultSaveLoadHandler<SlGamelogGrfbug, LoggedChange> {
@@ -186,16 +233,21 @@ public:
 		SLE_VAR(LoggedChange, grfbug.grfid,      SLE_UINT32),
 		SLE_VAR(LoggedChange, grfbug.bug,        SLE_UINT8),
 	};
+	inline const static SaveLoadCompatTable compat_description = _gamelog_grfbug_sl_compat;
 
-	void GenericSaveLoad(LoggedChange *lc) const
+	void Save(LoggedChange *lc) const override
 	{
 		if (lc->ct != GLCT_GRFBUG) return;
 		SlObject(lc, this->GetDescription());
 	}
 
-	void Save(LoggedChange *lc) const override { this->GenericSaveLoad(lc); }
-	void Load(LoggedChange *lc) const override { this->GenericSaveLoad(lc); }
-	void LoadCheck(LoggedChange *lc) const override { this->GenericSaveLoad(lc); }
+	void Load(LoggedChange *lc) const override
+	{
+		if (lc->ct != GLCT_GRFBUG) return;
+		SlObject(lc, this->GetLoadDescription());
+	}
+
+	void LoadCheck(LoggedChange *lc) const override { this->Load(lc); }
 };
 
 static bool _is_emergency_save = true;
@@ -206,8 +258,9 @@ public:
 	inline static const SaveLoad description[] = {
 		SLEG_CONDVAR("is_emergency_save", _is_emergency_save, SLE_BOOL, SLV_RIFF_TO_ARRAY, SL_MAX_VERSION),
 	};
+	inline const static SaveLoadCompatTable compat_description = _gamelog_emergency_sl_compat;
 
-	void GenericSaveLoad(LoggedChange *lc) const
+	void Save(LoggedChange *lc) const override
 	{
 		if (lc->ct != GLCT_EMERGENCY) return;
 
@@ -215,9 +268,14 @@ public:
 		SlObject(lc, this->GetDescription());
 	}
 
-	void Save(LoggedChange *lc) const override { this->GenericSaveLoad(lc); }
-	void Load(LoggedChange *lc) const override { this->GenericSaveLoad(lc); }
-	void LoadCheck(LoggedChange *lc) const override { this->GenericSaveLoad(lc); }
+	void Load(LoggedChange *lc) const override
+	{
+		if (lc->ct != GLCT_EMERGENCY) return;
+
+		SlObject(lc, this->GetLoadDescription());
+	}
+
+	void LoadCheck(LoggedChange *lc) const override { this->Load(lc); }
 };
 
 class SlGamelogAction : public DefaultSaveLoadHandler<SlGamelogAction, LoggedAction> {
@@ -236,6 +294,7 @@ public:
 		SLEG_STRUCT("grfbug", SlGamelogGrfbug),
 		SLEG_STRUCT("emergency", SlGamelogEmergency),
 	};
+	inline const static SaveLoadCompatTable compat_description = _gamelog_action_sl_compat;
 
 	void Save(LoggedAction *la) const override
 	{
@@ -262,7 +321,7 @@ public:
 				memset(lc, 0, sizeof(*lc));
 				lc->ct = ct;
 
-				SlObject(lc, this->GetDescription());
+				SlObject(lc, this->GetLoadDescription());
 			}
 			return;
 		}
@@ -275,7 +334,7 @@ public:
 			memset(lc, 0, sizeof(*lc));
 
 			lc->ct = (GamelogChangeType)SlReadByte();
-			SlObject(lc, this->GetDescription());
+			SlObject(lc, this->GetLoadDescription());
 		}
 	}
 
@@ -293,6 +352,8 @@ static void Load_GLOG_common(LoggedAction *&gamelog_action, uint &gamelog_action
 	assert(gamelog_action == nullptr);
 	assert(gamelog_actions == 0);
 
+	const std::vector<SaveLoad> slt = SlCompatTableHeader(_gamelog_desc, _gamelog_sl_compat);
+
 	if (IsSavegameVersionBefore(SLV_RIFF_TO_ARRAY)) {
 		byte type;
 		while ((type = SlReadByte()) != GLAT_NONE) {
@@ -303,7 +364,7 @@ static void Load_GLOG_common(LoggedAction *&gamelog_action, uint &gamelog_action
 			memset(la, 0, sizeof(*la));
 
 			la->at = (GamelogActionType)type;
-			SlObject(la, _gamelog_desc);
+			SlObject(la, slt);
 		}
 		return;
 	}
@@ -313,12 +374,14 @@ static void Load_GLOG_common(LoggedAction *&gamelog_action, uint &gamelog_action
 		LoggedAction *la = &gamelog_action[gamelog_actions++];
 		memset(la, 0, sizeof(*la));
 
-		SlObject(la, _gamelog_desc);
+		SlObject(la, slt);
 	}
 }
 
 static void Save_GLOG()
 {
+	SlTableHeader(_gamelog_desc);
+
 	const LoggedAction *laend = &_gamelog_action[_gamelog_actions];
 
 	uint i = 0;
@@ -339,7 +402,7 @@ static void Check_GLOG()
 }
 
 static const ChunkHandler gamelog_chunk_handlers[] = {
-	{ 'GLOG', Save_GLOG, Load_GLOG, nullptr, Check_GLOG, CH_ARRAY }
+	{ 'GLOG', Save_GLOG, Load_GLOG, nullptr, Check_GLOG, CH_TABLE }
 };
 
 extern const ChunkHandlerTable _gamelog_chunk_handlers(gamelog_chunk_handlers);
diff --git a/src/saveload/linkgraph_sl.cpp b/src/saveload/linkgraph_sl.cpp
index 5456fb33e..952ae1de3 100644
--- a/src/saveload/linkgraph_sl.cpp
+++ b/src/saveload/linkgraph_sl.cpp
@@ -8,12 +8,15 @@
 /** @file linkgraph_sl.cpp Code handling saving and loading of link graphs */
 
 #include "../stdafx.h"
+
+#include "saveload.h"
+#include "compat/linkgraph_sl_compat.h"
+
 #include "../linkgraph/linkgraph.h"
 #include "../linkgraph/linkgraphjob.h"
 #include "../linkgraph/linkgraphschedule.h"
 #include "../network/network.h"
 #include "../settings_internal.h"
-#include "saveload.h"
 
 #include "../safeguards.h"
 
@@ -27,13 +30,13 @@ static NodeID _linkgraph_from; ///< Contains the current "from" node being saved
 class SlLinkgraphEdge : public DefaultSaveLoadHandler<SlLinkgraphEdge, Node> {
 public:
 	inline static const SaveLoad description[] = {
-		SLE_CONDNULL(4, SL_MIN_VERSION, SLV_191), // distance
 		    SLE_VAR(Edge, capacity,                 SLE_UINT32),
 		    SLE_VAR(Edge, usage,                    SLE_UINT32),
 		    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),
 	};
+	inline const static SaveLoadCompatTable compat_description = _linkgraph_edge_sl_compat;
 
 	void Save(Node *bn) const override
 	{
@@ -55,7 +58,7 @@ public:
 		if (IsSavegameVersionBefore(SLV_191)) {
 			/* We used to save the full matrix ... */
 			for (NodeID to = 0; to < max_size; ++to) {
-				SlObject(&_linkgraph->edges[_linkgraph_from][to], this->GetDescription());
+				SlObject(&_linkgraph->edges[_linkgraph_from][to], this->GetLoadDescription());
 			}
 			return;
 		}
@@ -68,7 +71,7 @@ public:
 			used_size--;
 
 			if (to >= max_size) SlErrorCorrupt("Link graph structure overflow");
-			SlObject(&_linkgraph->edges[_linkgraph_from][to], this->GetDescription());
+			SlObject(&_linkgraph->edges[_linkgraph_from][to], this->GetLoadDescription());
 		}
 
 		if (!IsSavegameVersionBefore(SLV_SAVELOAD_LIST_LENGTH) && used_size > 0) SlErrorCorrupt("Corrupted link graph");
@@ -85,6 +88,7 @@ public:
 		    SLE_VAR(Node, last_update, SLE_INT32),
 		SLEG_STRUCTLIST("edges", SlLinkgraphEdge),
 	};
+	inline const static SaveLoadCompatTable compat_description = _linkgraph_node_sl_compat;
 
 	void Save(LinkGraph *lg) const override
 	{
@@ -105,7 +109,7 @@ public:
 		lg->Init(length);
 		for (NodeID from = 0; from < length; ++from) {
 			_linkgraph_from = from;
-			SlObject(&lg->nodes[from], this->GetDescription());
+			SlObject(&lg->nodes[from], this->GetLoadDescription());
 		}
 	}
 };
@@ -136,15 +140,16 @@ class SlLinkgraphJobProxy : public DefaultSaveLoadHandler<SlLinkgraphJobProxy, L
 public:
 	inline static const SaveLoad description[] = {{}}; // Needed to keep DefaultSaveLoadHandler happy.
 	SaveLoadTable GetDescription() const override { return GetLinkGraphDesc(); }
+	inline const static SaveLoadCompatTable compat_description = _linkgraph_sl_compat;
 
 	void Save(LinkGraphJob *lgj) const override
 	{
-		SlObject(const_cast<LinkGraph *>(&lgj->Graph()), GetLinkGraphDesc());
+		SlObject(const_cast<LinkGraph *>(&lgj->Graph()), this->GetDescription());
 	}
 
 	void Load(LinkGraphJob *lgj) const override
 	{
-		SlObject(const_cast<LinkGraph *>(&lgj->Graph()), GetLinkGraphDesc());
+		SlObject(const_cast<LinkGraph *>(&lgj->Graph()), this->GetLoadDescription());
 	}
 };
 
@@ -241,6 +246,8 @@ void AfterLoadLinkGraphs()
  */
 static void Save_LGRP()
 {
+	SlTableHeader(GetLinkGraphDesc());
+
 	for (LinkGraph *lg : LinkGraph::Iterate()) {
 		SlSetArrayIndex(lg->index);
 		SlObject(lg, GetLinkGraphDesc());
@@ -252,10 +259,12 @@ static void Save_LGRP()
  */
 static void Load_LGRP()
 {
+	const std::vector<SaveLoad> slt = SlCompatTableHeader(GetLinkGraphDesc(), _linkgraph_sl_compat);
+
 	int index;
 	while ((index = SlIterateArray()) != -1) {
 		LinkGraph *lg = new (index) LinkGraph();
-		SlObject(lg, GetLinkGraphDesc());
+		SlObject(lg, slt);
 	}
 }
 
@@ -264,6 +273,8 @@ static void Load_LGRP()
  */
 static void Save_LGRJ()
 {
+	SlTableHeader(GetLinkGraphJobDesc());
+
 	for (LinkGraphJob *lgj : LinkGraphJob::Iterate()) {
 		SlSetArrayIndex(lgj->index);
 		SlObject(lgj, GetLinkGraphJobDesc());
@@ -275,10 +286,12 @@ static void Save_LGRJ()
  */
 static void Load_LGRJ()
 {
+	const std::vector<SaveLoad> slt = SlCompatTableHeader(GetLinkGraphJobDesc(), _linkgraph_job_sl_compat);
+
 	int index;
 	while ((index = SlIterateArray()) != -1) {
 		LinkGraphJob *lgj = new (index) LinkGraphJob();
-		SlObject(lgj, GetLinkGraphJobDesc());
+		SlObject(lgj, slt);
 	}
 }
 
@@ -287,6 +300,8 @@ static void Load_LGRJ()
  */
 static void Save_LGRS()
 {
+	SlTableHeader(GetLinkGraphScheduleDesc());
+
 	SlSetArrayIndex(0);
 	SlObject(&LinkGraphSchedule::instance, GetLinkGraphScheduleDesc());
 }
@@ -296,8 +311,10 @@ static void Save_LGRS()
  */
 static void Load_LGRS()
 {
+	const std::vector<SaveLoad> slt = SlCompatTableHeader(GetLinkGraphScheduleDesc(), _linkgraph_schedule_sl_compat);
+
 	if (!IsSavegameVersionBefore(SLV_RIFF_TO_ARRAY) && SlIterateArray() == -1) return;
-	SlObject(&LinkGraphSchedule::instance, GetLinkGraphScheduleDesc());
+	SlObject(&LinkGraphSchedule::instance, slt);
 	if (!IsSavegameVersionBefore(SLV_RIFF_TO_ARRAY) && SlIterateArray() != -1) SlErrorCorrupt("Too many LGRS entries");
 }
 
@@ -310,9 +327,9 @@ static void Ptrs_LGRS()
 }
 
 static const ChunkHandler linkgraph_chunk_handlers[] = {
-	{ 'LGRP', Save_LGRP, Load_LGRP, nullptr,   nullptr, CH_ARRAY },
-	{ 'LGRJ', Save_LGRJ, Load_LGRJ, nullptr,   nullptr, CH_ARRAY },
-	{ 'LGRS', Save_LGRS, Load_LGRS, Ptrs_LGRS, nullptr, CH_ARRAY },
+	{ 'LGRP', Save_LGRP, Load_LGRP, nullptr,   nullptr, CH_TABLE },
+	{ 'LGRJ', Save_LGRJ, Load_LGRJ, nullptr,   nullptr, CH_TABLE },
+	{ 'LGRS', Save_LGRS, Load_LGRS, Ptrs_LGRS, nullptr, CH_TABLE },
 };
 
 extern const ChunkHandlerTable _linkgraph_chunk_handlers(linkgraph_chunk_handlers);
diff --git a/src/saveload/saveload.h b/src/saveload/saveload.h
index b6e843c99..a238d8c1b 100644
--- a/src/saveload/saveload.h
+++ b/src/saveload/saveload.h
@@ -456,7 +456,7 @@ public:
 	/**
 	 * Get the pre-header description of the fields in the savegame.
 	 */
-	virtual SaveLoadCompatTable GetCompatDescription() const { return {}; }
+	virtual SaveLoadCompatTable GetCompatDescription() const = 0;
 
 	/**
 	 * Get the description for how to load the chunk. Depending on the
@@ -481,6 +481,7 @@ template <class TImpl, class TObject>
 class DefaultSaveLoadHandler : public SaveLoadHandler {
 public:
 	SaveLoadTable GetDescription() const override { return static_cast<const TImpl *>(this)->description; }
+	SaveLoadCompatTable GetCompatDescription() const override { return static_cast<const TImpl *>(this)->compat_description; }
 
 	virtual void Save(TObject *object) const {}
 	void Save(void *object) const override { this->Save(static_cast<TObject *>(object)); }
diff --git a/src/saveload/station_sl.cpp b/src/saveload/station_sl.cpp
index ebf2c94f4..d9978cd6f 100644
--- a/src/saveload/station_sl.cpp
+++ b/src/saveload/station_sl.cpp
@@ -199,6 +199,7 @@ public:
 		SLE_CONDVAR(StationSpecList, grfid,    SLE_UINT32, SLV_27, SL_MAX_VERSION),
 		SLE_CONDVAR(StationSpecList, localidx, SLE_UINT8,  SLV_27, SL_MAX_VERSION),
 	};
+	inline const static SaveLoadCompatTable compat_description = _station_spec_list_sl_compat;
 
 	void Save(BaseStation *bst) const override
 	{
@@ -218,7 +219,7 @@ public:
 			/* Allocate speclist memory when loading a game */
 			bst->speclist = CallocT<StationSpecList>(bst->num_specs);
 			for (uint i = 0; i < bst->num_specs; i++) {
-				SlObject(&bst->speclist[i], this->GetDescription());
+				SlObject(&bst->speclist[i], this->GetLoadDescription());
 			}
 		}
 	}
@@ -230,6 +231,7 @@ public:
 		    SLE_VAR(StationCargoPair, first,  SLE_UINT16),
 		SLE_REFLIST(StationCargoPair, second, REF_CARGO_PACKET),
 	};
+	inline const static SaveLoadCompatTable compat_description = _station_cargo_sl_compat;
 
 	void Save(GoodsEntry *ge) const override
 	{
@@ -245,7 +247,7 @@ public:
 
 		StationCargoPair pair;
 		for (uint j = 0; j < num_dests; ++j) {
-			SlObject(&pair, this->GetDescription());
+			SlObject(&pair, this->GetLoadDescription());
 			const_cast<StationCargoPacketMap &>(*(ge->cargo.Packets()))[pair.first].swap(pair.second);
 			assert(pair.second.empty());
 		}
@@ -267,6 +269,7 @@ public:
 		    SLE_VAR(FlowSaveLoad, share,      SLE_UINT32),
 		SLE_CONDVAR(FlowSaveLoad, restricted, SLE_BOOL, SLV_187, SL_MAX_VERSION),
 	};
+	inline const static SaveLoadCompatTable compat_description = _station_flow_sl_compat;
 
 	void Save(GoodsEntry *ge) const override
 	{
@@ -300,7 +303,7 @@ public:
 		FlowStat *fs = nullptr;
 		StationID prev_source = INVALID_STATION;
 		for (uint32 j = 0; j < num_flows; ++j) {
-			SlObject(&flow, this->GetDescription());
+			SlObject(&flow, this->GetLoadDescription());
 			if (fs == nullptr || prev_source != flow.source) {
 				fs = &(ge->flows.insert(std::make_pair(flow.source, FlowStat(flow.via, flow.share, flow.restricted))).first->second);
 			} else {
@@ -326,7 +329,6 @@ public:
 	static const SaveLoad description[] = {
 		SLEG_CONDVAR("waiting_acceptance", _waiting_acceptance, SLE_UINT16,        SL_MIN_VERSION, SLV_68),
 		 SLE_CONDVAR(GoodsEntry, status,               SLE_UINT8,                  SLV_68, SL_MAX_VERSION),
-		SLE_CONDNULL(2,                                                            SLV_51, SLV_68),
 		     SLE_VAR(GoodsEntry, time_since_pickup,    SLE_UINT8),
 		     SLE_VAR(GoodsEntry, rating,               SLE_UINT8),
 		SLEG_CONDVAR("cargo_source", _cargo_source,    SLE_FILE_U8 | SLE_VAR_U16,   SL_MIN_VERSION, SLV_7),
@@ -352,6 +354,7 @@ public:
 		return description;
 	}
 #endif
+	inline const static SaveLoadCompatTable compat_description = _station_goods_sl_compat;
 
 	/**
 	 * Get the number of cargoes used by this savegame version.
@@ -392,7 +395,7 @@ public:
 		size_t num_cargo = this->GetNumCargo();
 		for (CargoID i = 0; i < num_cargo; i++) {
 			GoodsEntry *ge = &st->goods[i];
-			SlObject(ge, this->GetDescription());
+			SlObject(ge, this->GetLoadDescription());
 			if (IsSavegameVersionBefore(SLV_183)) {
 				SwapPackets(ge);
 			}
@@ -438,19 +441,14 @@ public:
 static const SaveLoad _old_station_desc[] = {
 	SLE_CONDVAR(Station, xy,                         SLE_FILE_U16 | SLE_VAR_U32,  SL_MIN_VERSION, SLV_6),
 	SLE_CONDVAR(Station, xy,                         SLE_UINT32,                  SLV_6, SL_MAX_VERSION),
-	SLE_CONDNULL(4, SL_MIN_VERSION, SLV_6),  ///< bus/lorry tile
 	SLE_CONDVAR(Station, train_station.tile,         SLE_FILE_U16 | SLE_VAR_U32,  SL_MIN_VERSION, SLV_6),
 	SLE_CONDVAR(Station, train_station.tile,         SLE_UINT32,                  SLV_6, SL_MAX_VERSION),
 	SLE_CONDVAR(Station, airport.tile,               SLE_FILE_U16 | SLE_VAR_U32,  SL_MIN_VERSION, SLV_6),
 	SLE_CONDVAR(Station, airport.tile,               SLE_UINT32,                  SLV_6, SL_MAX_VERSION),
-	SLE_CONDNULL(2, SL_MIN_VERSION, SLV_6),
-	SLE_CONDNULL(4, SLV_6, SLV_MULTITILE_DOCKS),
 	    SLE_REF(Station, town,                       REF_TOWN),
 	    SLE_VAR(Station, train_station.w,            SLE_FILE_U8 | SLE_VAR_U16),
 	SLE_CONDVAR(Station, train_station.h,            SLE_FILE_U8 | SLE_VAR_U16,   SLV_2, SL_MAX_VERSION),
 
-	SLE_CONDNULL(1, SL_MIN_VERSION, SLV_4),  ///< alpha_order
-
 	    SLE_VAR(Station, string_id,                  SLE_STRINGID),
 	SLE_CONDSSTR(Station, name,                      SLE_STR | SLF_ALLOW_CONTROL, SLV_84, SL_MAX_VERSION),
 	SLE_CONDVAR(Station, indtype,                    SLE_UINT8,                 SLV_103, SL_MAX_VERSION),
@@ -463,18 +461,12 @@ static const SaveLoad _old_station_desc[] = {
 	    SLE_VAR(Station, owner,                      SLE_UINT8),
 	    SLE_VAR(Station, facilities,                 SLE_UINT8),
 	    SLE_VAR(Station, airport.type,               SLE_UINT8),
-
-	SLE_CONDNULL(2, SL_MIN_VERSION, SLV_6),  ///< Truck/bus stop status
-	SLE_CONDNULL(1, SL_MIN_VERSION, SLV_5),  ///< Blocked months
-
 	SLE_CONDVAR(Station, airport.flags,              SLE_VAR_U64 | SLE_FILE_U16,  SL_MIN_VERSION,  SLV_3),
 	SLE_CONDVAR(Station, airport.flags,              SLE_VAR_U64 | SLE_FILE_U32,  SLV_3, SLV_46),
 	SLE_CONDVAR(Station, airport.flags,              SLE_UINT64,                 SLV_46, SL_MAX_VERSION),
 
-	SLE_CONDNULL(2, SL_MIN_VERSION, SLV_26), ///< last-vehicle
 	SLE_CONDVAR(Station, last_vehicle_type,          SLE_UINT8,                  SLV_26, SL_MAX_VERSION),
 
-	SLE_CONDNULL(2, SLV_3, SLV_26), ///< custom station class and id
 	SLE_CONDVAR(Station, build_date,                 SLE_FILE_U16 | SLE_VAR_I32,  SLV_3, SLV_31),
 	SLE_CONDVAR(Station, build_date,                 SLE_INT32,                  SLV_31, SL_MAX_VERSION),
 
@@ -488,14 +480,14 @@ static const SaveLoad _old_station_desc[] = {
 
 	SLE_CONDREFLIST(Station, loading_vehicles,       REF_VEHICLE,                SLV_57, SL_MAX_VERSION),
 
-	/* reserve extra space in savegame here. (currently 32 bytes) */
-	SLE_CONDNULL(32, SLV_2, SL_MAX_VERSION),
 	SLEG_STRUCTLIST("goods", SlStationGoods),
 	SLEG_CONDSTRUCTLIST("speclist", SlStationSpecList,                           SLV_27, SL_MAX_VERSION),
 };
 
 static void Load_STNS()
 {
+	const std::vector<SaveLoad> slt = SlCompatTableHeader(_old_station_desc, _old_station_sl_compat);
+
 	_cargo_source_xy = 0;
 	_cargo_days = 0;
 	_cargo_feeder_share = 0;
@@ -505,7 +497,7 @@ static void Load_STNS()
 		Station *st = new (index) Station();
 
 		_waiting_acceptance = 0;
-		SlObject(st, _old_station_desc);
+		SlObject(st, slt);
 	}
 }
 
@@ -542,15 +534,22 @@ public:
 		    SLE_VAR(BaseStation, waiting_triggers,       SLE_UINT8),
 		SLE_CONDVAR(BaseStation, num_specs,              SLE_UINT8,                   SL_MIN_VERSION, SLV_SAVELOAD_LIST_LENGTH),
 	};
+	inline const static SaveLoadCompatTable compat_description = _station_base_sl_compat;
 
-	void GenericSaveLoad(BaseStation *bst) const
+	void Save(BaseStation *bst) const override
 	{
 		SlObject(bst, this->GetDescription());
 	}
 
-	void Save(BaseStation *bst) const override { this->GenericSaveLoad(bst); }
-	void Load(BaseStation *bst) const override { this->GenericSaveLoad(bst); }
-	void FixPointers(BaseStation *bst) const override { this->GenericSaveLoad(bst); }
+	void Load(BaseStation *bst) const override
+	{
+		SlObject(bst, this->GetLoadDescription());
+	}
+
+	void FixPointers(BaseStation *bst) const override
+	{
+		SlObject(bst, this->GetDescription());
+	}
 };
 
 /**
@@ -566,7 +565,6 @@ public:
 
 		    SLE_REF(Station, bus_stops,                  REF_ROADSTOPS),
 		    SLE_REF(Station, truck_stops,                REF_ROADSTOPS),
-		SLE_CONDNULL(4, SL_MIN_VERSION, SLV_MULTITILE_DOCKS),
 		SLE_CONDVAR(Station, ship_station.tile,          SLE_UINT32,                SLV_MULTITILE_DOCKS, SL_MAX_VERSION),
 		SLE_CONDVAR(Station, ship_station.w,             SLE_FILE_U8 | SLE_VAR_U16, SLV_MULTITILE_DOCKS, SL_MAX_VERSION),
 		SLE_CONDVAR(Station, ship_station.h,             SLE_FILE_U8 | SLE_VAR_U16, SLV_MULTITILE_DOCKS, SL_MAX_VERSION),
@@ -594,16 +592,25 @@ public:
 		SLE_CONDVAR(Station, always_accepted,            SLE_UINT64,                 SLV_EXTEND_CARGOTYPES, SL_MAX_VERSION),
 		SLEG_STRUCTLIST("goods", SlStationGoods),
 	};
+	inline const static SaveLoadCompatTable compat_description = _station_normal_sl_compat;
 
-	void GenericSaveLoad(BaseStation *bst) const
+	void Save(BaseStation *bst) const
 	{
 		if ((bst->facilities & FACIL_WAYPOINT) != 0) return;
 		SlObject(bst, this->GetDescription());
 	}
 
-	void Save(BaseStation *bst) const override { this->GenericSaveLoad(bst); }
-	void Load(BaseStation *bst) const override { this->GenericSaveLoad(bst); }
-	void FixPointers(BaseStation *bst) const override { this->GenericSaveLoad(bst); }
+	void Load(BaseStation *bst) const
+	{
+		if ((bst->facilities & FACIL_WAYPOINT) != 0) return;
+		SlObject(bst, this->GetLoadDescription());
+	}
+
+	void FixPointers(BaseStation *bst) const
+	{
+		if ((bst->facilities & FACIL_WAYPOINT) != 0) return;
+		SlObject(bst, this->GetDescription());
+	}
 };
 
 class SlStationWaypoint : public DefaultSaveLoadHandler<SlStationWaypoint, BaseStation> {
@@ -616,16 +623,25 @@ public:
 		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),
 	};
+	inline const static SaveLoadCompatTable compat_description = _station_waypoint_sl_compat;
 
-	void GenericSaveLoad(BaseStation *bst) const
+	void Save(BaseStation *bst) const
 	{
 		if ((bst->facilities & FACIL_WAYPOINT) == 0) return;
 		SlObject(bst, this->GetDescription());
 	}
 
-	void Save(BaseStation *bst) const override { this->GenericSaveLoad(bst); }
-	void Load(BaseStation *bst) const override { this->GenericSaveLoad(bst); }
-	void FixPointers(BaseStation *bst) const override { this->GenericSaveLoad(bst); }
+	void Load(BaseStation *bst) const
+	{
+		if ((bst->facilities & FACIL_WAYPOINT) == 0) return;
+		SlObject(bst, this->GetLoadDescription());
+	}
+
+	void FixPointers(BaseStation *bst) const
+	{
+		if ((bst->facilities & FACIL_WAYPOINT) == 0) return;
+		SlObject(bst, this->GetDescription());
+	}
 };
 
 static const SaveLoad _station_desc[] = {
@@ -637,6 +653,8 @@ static const SaveLoad _station_desc[] = {
 
 static void Save_STNN()
 {
+	SlTableHeader(_station_desc);
+
 	/* Write the stations */
 	for (BaseStation *st : BaseStation::Iterate()) {
 		SlSetArrayIndex(st->index);
@@ -646,6 +664,8 @@ static void Save_STNN()
 
 static void Load_STNN()
 {
+	const std::vector<SaveLoad> slt = SlCompatTableHeader(_station_desc, _station_sl_compat);
+
 	_old_num_flows = 0;
 
 	int index;
@@ -653,7 +673,7 @@ static void Load_STNN()
 		bool waypoint = (SlReadByte() & FACIL_WAYPOINT) != 0;
 
 		BaseStation *bst = waypoint ? (BaseStation *)new (index) Waypoint() : new (index) Station();
-		SlObject(bst, _station_desc);
+		SlObject(bst, slt);
 	}
 }
 
@@ -701,7 +721,7 @@ static void Ptrs_ROADSTOP()
 
 static const ChunkHandler station_chunk_handlers[] = {
 	{ 'STNS', nullptr,       Load_STNS,     Ptrs_STNS,     nullptr, CH_READONLY },
-	{ 'STNN', Save_STNN,     Load_STNN,     Ptrs_STNN,     nullptr, CH_ARRAY },
+	{ 'STNN', Save_STNN,     Load_STNN,     Ptrs_STNN,     nullptr, CH_TABLE },
 	{ 'ROAD', Save_ROADSTOP, Load_ROADSTOP, Ptrs_ROADSTOP, nullptr, CH_TABLE },
 };
 
diff --git a/src/saveload/town_sl.cpp b/src/saveload/town_sl.cpp
index faca4180c..c5b5b0080 100644
--- a/src/saveload/town_sl.cpp
+++ b/src/saveload/town_sl.cpp
@@ -8,6 +8,11 @@
 /** @file town_sl.cpp Code handling saving and loading of towns and houses */
 
 #include "../stdafx.h"
+
+#include "saveload.h"
+#include "compat/town_sl_compat.h"
+
+#include "newgrf_sl.h"
 #include "../newgrf_house.h"
 #include "../town.h"
 #include "../landscape.h"
@@ -15,9 +20,6 @@
 #include "../strings_func.h"
 #include "../tilematrix_type.hpp"
 
-#include "saveload.h"
-#include "newgrf_sl.h"
-
 #include "../safeguards.h"
 
 typedef TileMatrix<CargoTypes, 4> AcceptanceMatrix;
@@ -121,6 +123,7 @@ public:
 		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),
 	};
+	inline const static SaveLoadCompatTable compat_description = _town_supplied_sl_compat;
 
 	/**
 	 * Get the number of cargoes used by this savegame version.
@@ -146,7 +149,7 @@ public:
 	{
 		size_t num_cargo = this->GetNumCargo();
 		for (CargoID i = 0; i < num_cargo; i++) {
-			SlObject(&t->supplied[i], this->GetDescription());
+			SlObject(&t->supplied[i], this->GetLoadDescription());
 		}
 	}
 };
@@ -159,6 +162,7 @@ public:
 		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),
 	};
+	inline const static SaveLoadCompatTable compat_description = _town_received_sl_compat;
 
 	void Save(Town *t) const override
 	{
@@ -172,7 +176,7 @@ public:
 	{
 		size_t length = IsSavegameVersionBefore(SLV_SAVELOAD_LIST_LENGTH) ? (size_t)TE_END : SlGetStructListLength(TE_END);
 		for (size_t i = 0; i < length; i++) {
-			SlObject(&t->received[i], this->GetDescription());
+			SlObject(&t->received[i], this->GetLoadDescription());
 		}
 	}
 };
@@ -184,12 +188,13 @@ public:
 		SLE_VAR(AcceptanceMatrix, area.w,    SLE_UINT16),
 		SLE_VAR(AcceptanceMatrix, area.h,    SLE_UINT16),
 	};
+	inline const static SaveLoadCompatTable compat_description = _town_acceptance_matrix_sl_compat;
 
 	void Load(Town *t) const override
 	{
 		/* Discard now unused acceptance matrix. */
 		AcceptanceMatrix dummy;
-		SlObject(&dummy, this->GetDescription());
+		SlObject(&dummy, this->GetLoadDescription());
 		if (dummy.area.w != 0) {
 			uint arr_len = dummy.area.w / AcceptanceMatrix::GRID * dummy.area.h / AcceptanceMatrix::GRID;
 			SlSkipBytes(4 * arr_len);
@@ -201,10 +206,6 @@ static const SaveLoad _town_desc[] = {
 	SLE_CONDVAR(Town, xy,                    SLE_FILE_U16 | SLE_VAR_U32, SL_MIN_VERSION, SLV_6),
 	SLE_CONDVAR(Town, xy,                    SLE_UINT32,                 SLV_6, SL_MAX_VERSION),
 
-	SLE_CONDNULL(2, SL_MIN_VERSION, SLV_3),                   ///< population, no longer in use
-	SLE_CONDNULL(4, SLV_3, SLV_85),                  ///< population, no longer in use
-	SLE_CONDNULL(2, SL_MIN_VERSION, SLV_92),                  ///< num_houses, no longer in use
-
 	SLE_CONDVAR(Town, townnamegrfid,         SLE_UINT32, SLV_66, SL_MAX_VERSION),
 	    SLE_VAR(Town, townnametype,          SLE_UINT16),
 	    SLE_VAR(Town, townnameparts,         SLE_UINT32),
@@ -214,36 +215,30 @@ static const SaveLoad _town_desc[] = {
 	SLE_CONDVAR(Town, statues,               SLE_FILE_U8  | SLE_VAR_U16, SL_MIN_VERSION, SLV_104),
 	SLE_CONDVAR(Town, statues,               SLE_UINT16,               SLV_104, SL_MAX_VERSION),
 
-	SLE_CONDNULL(1, SL_MIN_VERSION, SLV_2),                   ///< sort_index, no longer in use
-
 	SLE_CONDVAR(Town, have_ratings,          SLE_FILE_U8  | SLE_VAR_U16, SL_MIN_VERSION, SLV_104),
 	SLE_CONDVAR(Town, have_ratings,          SLE_UINT16,               SLV_104, SL_MAX_VERSION),
 	SLE_CONDARR(Town, ratings,               SLE_INT16, 8,               SL_MIN_VERSION, SLV_104),
 	SLE_CONDARR(Town, ratings,               SLE_INT16, MAX_COMPANIES, SLV_104, SL_MAX_VERSION),
-	/* failed bribe attempts are stored since savegame format 4 */
 	SLE_CONDARR(Town, unwanted,              SLE_INT8,  8,               SLV_4, SLV_104),
 	SLE_CONDARR(Town, unwanted,              SLE_INT8,  MAX_COMPANIES, SLV_104, SL_MAX_VERSION),
 
 	SLE_CONDVAR(Town, supplied[CT_PASSENGERS].old_max, SLE_FILE_U16 | SLE_VAR_U32, SL_MIN_VERSION, SLV_9),
-	SLE_CONDVAR(Town, supplied[CT_MAIL].old_max,       SLE_FILE_U16 | SLE_VAR_U32, SL_MIN_VERSION, SLV_9),
-	SLE_CONDVAR(Town, supplied[CT_PASSENGERS].new_max, SLE_FILE_U16 | SLE_VAR_U32, SL_MIN_VERSION, SLV_9),
-	SLE_CONDVAR(Town, supplied[CT_MAIL].new_max,       SLE_FILE_U16 | SLE_VAR_U32, SL_MIN_VERSION, SLV_9),
-	SLE_CONDVAR(Town, supplied[CT_PASSENGERS].old_act, SLE_FILE_U16 | SLE_VAR_U32, SL_MIN_VERSION, SLV_9),
-	SLE_CONDVAR(Town, supplied[CT_MAIL].old_act,       SLE_FILE_U16 | SLE_VAR_U32, SL_MIN_VERSION, SLV_9),
-	SLE_CONDVAR(Town, supplied[CT_PASSENGERS].new_act, SLE_FILE_U16 | SLE_VAR_U32, SL_MIN_VERSION, SLV_9),
-	SLE_CONDVAR(Town, supplied[CT_MAIL].new_act,       SLE_FILE_U16 | SLE_VAR_U32, SL_MIN_VERSION, SLV_9),
-
 	SLE_CONDVAR(Town, supplied[CT_PASSENGERS].old_max, SLE_UINT32,                 SLV_9, SLV_165),
+	SLE_CONDVAR(Town, supplied[CT_MAIL].old_max,       SLE_FILE_U16 | SLE_VAR_U32, SL_MIN_VERSION, SLV_9),
 	SLE_CONDVAR(Town, supplied[CT_MAIL].old_max,       SLE_UINT32,                 SLV_9, SLV_165),
+	SLE_CONDVAR(Town, supplied[CT_PASSENGERS].new_max, SLE_FILE_U16 | SLE_VAR_U32, SL_MIN_VERSION, SLV_9),
 	SLE_CONDVAR(Town, supplied[CT_PASSENGERS].new_max, SLE_UINT32,                 SLV_9, SLV_165),
+	SLE_CONDVAR(Town, supplied[CT_MAIL].new_max,       SLE_FILE_U16 | SLE_VAR_U32, SL_MIN_VERSION, SLV_9),
 	SLE_CONDVAR(Town, supplied[CT_MAIL].new_max,       SLE_UINT32,                 SLV_9, SLV_165),
+	SLE_CONDVAR(Town, supplied[CT_PASSENGERS].old_act, SLE_FILE_U16 | SLE_VAR_U32, SL_MIN_VERSION, SLV_9),
 	SLE_CONDVAR(Town, supplied[CT_PASSENGERS].old_act, SLE_UINT32,                 SLV_9, SLV_165),
+	SLE_CONDVAR(Town, supplied[CT_MAIL].old_act,       SLE_FILE_U16 | SLE_VAR_U32, SL_MIN_VERSION, SLV_9),
 	SLE_CONDVAR(Town, supplied[CT_MAIL].old_act,       SLE_UINT32,                 SLV_9, SLV_165),
+	SLE_CONDVAR(Town, supplied[CT_PASSENGERS].new_act, SLE_FILE_U16 | SLE_VAR_U32, SL_MIN_VERSION, SLV_9),
 	SLE_CONDVAR(Town, supplied[CT_PASSENGERS].new_act, SLE_UINT32,                 SLV_9, SLV_165),
+	SLE_CONDVAR(Town, supplied[CT_MAIL].new_act,       SLE_FILE_U16 | SLE_VAR_U32, SL_MIN_VERSION, SLV_9),
 	SLE_CONDVAR(Town, supplied[CT_MAIL].new_act,       SLE_UINT32,                 SLV_9, SLV_165),
 
-	SLE_CONDNULL(2, SL_MIN_VERSION, SLV_164),                 ///< pct_pass_transported / pct_mail_transported, now computed on the fly
-
 	SLE_CONDVAR(Town, received[TE_FOOD].old_act,       SLE_UINT16,                 SL_MIN_VERSION, SLV_165),
 	SLE_CONDVAR(Town, received[TE_WATER].old_act,      SLE_UINT16,                 SL_MIN_VERSION, SLV_165),
 	SLE_CONDVAR(Town, received[TE_FOOD].new_act,       SLE_UINT16,                 SL_MIN_VERSION, SLV_165),
@@ -254,12 +249,10 @@ static const SaveLoad _town_desc[] = {
 	SLE_CONDSSTR(Town, text,                 SLE_STR | SLF_ALLOW_CONTROL, SLV_168, SL_MAX_VERSION),
 
 	SLE_CONDVAR(Town, time_until_rebuild,    SLE_FILE_U8 | SLE_VAR_U16,  SL_MIN_VERSION, SLV_54),
-	SLE_CONDVAR(Town, grow_counter,          SLE_FILE_U8 | SLE_VAR_U16,  SL_MIN_VERSION, SLV_54),
-	SLE_CONDVAR(Town, growth_rate,           SLE_FILE_U8 | SLE_VAR_I16,  SL_MIN_VERSION, SLV_54),
-
 	SLE_CONDVAR(Town, time_until_rebuild,    SLE_UINT16,                SLV_54, SL_MAX_VERSION),
+	SLE_CONDVAR(Town, grow_counter,          SLE_FILE_U8 | SLE_VAR_U16,  SL_MIN_VERSION, SLV_54),
 	SLE_CONDVAR(Town, grow_counter,          SLE_UINT16,                SLV_54, SL_MAX_VERSION),
-
+	SLE_CONDVAR(Town, growth_rate,           SLE_FILE_U8 | SLE_VAR_I16,  SL_MIN_VERSION, SLV_54),
 	SLE_CONDVAR(Town, growth_rate,           SLE_FILE_I16 | SLE_VAR_U16, SLV_54, SLV_165),
 	SLE_CONDVAR(Town, growth_rate,           SLE_UINT16,                 SLV_165, SL_MAX_VERSION),
 
@@ -274,10 +267,6 @@ static const SaveLoad _town_desc[] = {
 
 	SLE_CONDREFLIST(Town, psa_list,          REF_STORAGE,              SLV_161, SL_MAX_VERSION),
 
-	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
-
 	SLEG_CONDSTRUCTLIST("supplied", SlTownSupplied,                    SLV_165, SL_MAX_VERSION),
 	SLEG_CONDSTRUCTLIST("received", SlTownReceived,                    SLV_165, SL_MAX_VERSION),
 	SLEG_CONDSTRUCTLIST("acceptance_matrix", SlTownAcceptanceMatrix,   SLV_166, SLV_REMOVE_TOWN_CARGO_CACHE),
@@ -295,6 +284,8 @@ static void Load_HIDS()
 
 static void Save_TOWN()
 {
+	SlTableHeader(_town_desc);
+
 	for (Town *t : Town::Iterate()) {
 		SlSetArrayIndex(t->index);
 		SlObject(t, _town_desc);
@@ -303,11 +294,13 @@ static void Save_TOWN()
 
 static void Load_TOWN()
 {
+	const std::vector<SaveLoad> slt = SlCompatTableHeader(_town_desc, _town_sl_compat);
+
 	int index;
 
 	while ((index = SlIterateArray()) != -1) {
 		Town *t = new (index) Town();
-		SlObject(t, _town_desc);
+		SlObject(t, slt);
 
 		if (t->townnamegrfid == 0 && !IsInsideMM(t->townnametype, SPECSTR_TOWNNAME_START, SPECSTR_TOWNNAME_LAST + 1) && GetStringTab(t->townnametype) != TEXT_TAB_OLD_CUSTOM) {
 			SlErrorCorrupt("Invalid town name generator");
@@ -327,7 +320,7 @@ static void Ptrs_TOWN()
 
 static const ChunkHandler town_chunk_handlers[] = {
 	{ 'HIDS', Save_HIDS, Load_HIDS, nullptr,   nullptr, CH_TABLE },
-	{ 'CITY', Save_TOWN, Load_TOWN, Ptrs_TOWN, nullptr, CH_ARRAY },
+	{ 'CITY', Save_TOWN, Load_TOWN, Ptrs_TOWN, nullptr, CH_TABLE },
 };
 
 extern const ChunkHandlerTable _town_chunk_handlers(town_chunk_handlers);
diff --git a/src/saveload/vehicle_sl.cpp b/src/saveload/vehicle_sl.cpp
index b2d9972fe..962f5f99a 100644
--- a/src/saveload/vehicle_sl.cpp
+++ b/src/saveload/vehicle_sl.cpp
@@ -8,6 +8,10 @@
 /** @file vehicle_sl.cpp Code handling saving and loading of vehicles */
 
 #include "../stdafx.h"
+
+#include "saveload.h"
+#include "compat/vehicle_sl_compat.h"
+
 #include "../vehicle_func.h"
 #include "../train.h"
 #include "../roadveh.h"
@@ -19,8 +23,6 @@
 #include "../company_func.h"
 #include "../disaster_vehicle.h"
 
-#include "saveload.h"
-
 #include <map>
 
 #include "../safeguards.h"
@@ -607,12 +609,8 @@ public:
 		SLE_CONDVAR(Vehicle, z_pos,                 SLE_INT32,                  SLV_164, SL_MAX_VERSION),
 		    SLE_VAR(Vehicle, direction,             SLE_UINT8),
 
-		SLE_CONDNULL(2,                                                            SL_MIN_VERSION,  SLV_58),
 		    SLE_VAR(Vehicle, spritenum,             SLE_UINT8),
-		SLE_CONDNULL(5,                                                            SL_MIN_VERSION,  SLV_58),
 		    SLE_VAR(Vehicle, engine_type,           SLE_UINT16),
-
-		SLE_CONDNULL(2,                                                            SL_MIN_VERSION,  SLV_152),
 		    SLE_VAR(Vehicle, cur_speed,             SLE_UINT16),
 		    SLE_VAR(Vehicle, subspeed,              SLE_UINT8),
 		    SLE_VAR(Vehicle, acceleration,          SLE_UINT8),
@@ -643,8 +641,6 @@ public:
 
 		    SLE_VAR(Vehicle, cur_implicit_order_index,  SLE_UINT8),
 		SLE_CONDVAR(Vehicle, cur_real_order_index,  SLE_UINT8,                  SLV_158, SL_MAX_VERSION),
-		/* num_orders is now part of OrderList and is not saved but counted */
-		SLE_CONDNULL(1,                                                            SL_MIN_VERSION, SLV_105),
 
 		/* This next line is for version 4 and prior compatibility.. it temporarily reads
 		type and flags (which were both 4 bits) into type. Later on this is
@@ -659,7 +655,6 @@ public:
 
 		/* Refit in current order */
 		SLE_CONDVAR(Vehicle, current_order.refit_cargo,   SLE_UINT8,             SLV_36, SL_MAX_VERSION),
-		SLE_CONDNULL(1,                                                           SLV_36, SLV_182), // refit_subtype
 
 		/* Timetable in current order */
 		SLE_CONDVAR(Vehicle, current_order.wait_time,     SLE_UINT16,            SLV_67, SL_MAX_VERSION),
@@ -707,29 +702,31 @@ public:
 		SLE_CONDVAR(Vehicle, waiting_triggers,      SLE_UINT8,                    SLV_2, SL_MAX_VERSION),
 
 		SLE_CONDREF(Vehicle, next_shared,           REF_VEHICLE,                  SLV_2, SL_MAX_VERSION),
-		SLE_CONDNULL(2,                                                            SLV_2,  SLV_69),
-		SLE_CONDNULL(4,                                                           SLV_69, SLV_101),
-
 		SLE_CONDVAR(Vehicle, group_id,              SLE_UINT16,                  SLV_60, SL_MAX_VERSION),
 
 		SLE_CONDVAR(Vehicle, current_order_time,    SLE_UINT32,                  SLV_67, SL_MAX_VERSION),
 		SLE_CONDVAR(Vehicle, lateness_counter,      SLE_INT32,                   SLV_67, SL_MAX_VERSION),
-
-		SLE_CONDNULL(10,                                                           SLV_2, SLV_144), // old reserved space
 	};
 #if defined(_MSC_VER) && (_MSC_VER == 1915 || _MSC_VER == 1916)
 		return description;
 	}
 #endif
+	inline const static SaveLoadCompatTable compat_description = _vehicle_common_sl_compat;
 
-	void GenericSaveLoad(Vehicle *v) const
+	void Save(Vehicle *v) const override
 	{
 		SlObject(v, this->GetDescription());
 	}
 
-	void Save(Vehicle *v) const override { this->GenericSaveLoad(v); }
-	void Load(Vehicle *v) const override { this->GenericSaveLoad(v); }
-	void FixPointers(Vehicle *v) const override { this->GenericSaveLoad(v); }
+	void Load(Vehicle *v) const override
+	{
+		SlObject(v, this->GetLoadDescription());
+	}
+
+	void FixPointers(Vehicle *v) const override
+	{
+		SlObject(v, this->GetDescription());
+	}
 };
 
 class SlVehicleTrain : public DefaultSaveLoadHandler<SlVehicleTrain, Vehicle> {
@@ -743,24 +740,28 @@ public:
 
 		 SLE_CONDVAR(Train, flags,               SLE_FILE_U8  | SLE_VAR_U16,   SLV_2,  SLV_100),
 		 SLE_CONDVAR(Train, flags,               SLE_UINT16,                 SLV_100, SL_MAX_VERSION),
-		SLE_CONDNULL(2, SLV_2, SLV_60),
-
 		 SLE_CONDVAR(Train, wait_counter,        SLE_UINT16,                 SLV_136, SL_MAX_VERSION),
-
-		SLE_CONDNULL(2, SLV_2, SLV_20),
 		 SLE_CONDVAR(Train, gv_flags,            SLE_UINT16,                 SLV_139, SL_MAX_VERSION),
-		SLE_CONDNULL(11, SLV_2, SLV_144), // old reserved space
 	};
+	inline const static SaveLoadCompatTable compat_description = _vehicle_train_sl_compat;
 
-	void GenericSaveLoad(Vehicle *v) const
+	void Save(Vehicle *v) const override
 	{
 		if (v->type != VEH_TRAIN) return;
 		SlObject(v, this->GetDescription());
 	}
 
-	void Save(Vehicle *v) const override { this->GenericSaveLoad(v); }
-	void Load(Vehicle *v) const override { this->GenericSaveLoad(v); }
-	void FixPointers(Vehicle *v) const override { this->GenericSaveLoad(v); }
+	void Load(Vehicle *v) const override
+	{
+		if (v->type != VEH_TRAIN) return;
+		SlObject(v, this->GetLoadDescription());
+	}
+
+	void FixPointers(Vehicle *v) const override
+	{
+		if (v->type != VEH_TRAIN) return;
+		SlObject(v, this->GetDescription());
+	}
 };
 
 class SlVehicleRoadVeh : public DefaultSaveLoadHandler<SlVehicleRoadVeh, Vehicle> {
@@ -776,23 +777,27 @@ public:
 		      SLE_VAR(RoadVehicle, reverse_ctr,          SLE_UINT8),
 		SLE_CONDDEQUE(RoadVehicle, path.td,              SLE_UINT8,                  SLV_ROADVEH_PATH_CACHE, SL_MAX_VERSION),
 		SLE_CONDDEQUE(RoadVehicle, path.tile,            SLE_UINT32,                 SLV_ROADVEH_PATH_CACHE, SL_MAX_VERSION),
-
-		 SLE_CONDNULL(2,                                                               SLV_6,  SLV_69),
 		  SLE_CONDVAR(RoadVehicle, gv_flags,             SLE_UINT16,                 SLV_139, SL_MAX_VERSION),
-		 SLE_CONDNULL(4,                                                              SLV_69, SLV_131),
-		 SLE_CONDNULL(2,                                                               SLV_6, SLV_131),
-		 SLE_CONDNULL(16,                                                              SLV_2, SLV_144), // old reserved space
 	};
+	inline const static SaveLoadCompatTable compat_description = _vehicle_roadveh_sl_compat;
 
-	void GenericSaveLoad(Vehicle *v) const
+	void Save(Vehicle *v) const override
 	{
 		if (v->type != VEH_ROAD) return;
 		SlObject(v, this->GetDescription());
 	}
 
-	void Save(Vehicle *v) const override { this->GenericSaveLoad(v); }
-	void Load(Vehicle *v) const override { this->GenericSaveLoad(v); }
-	void FixPointers(Vehicle *v) const override { this->GenericSaveLoad(v); }
+	void Load(Vehicle *v) const override
+	{
+		if (v->type != VEH_ROAD) return;
+		SlObject(v, this->GetLoadDescription());
+	}
+
+	void FixPointers(Vehicle *v) const override
+	{
+		if (v->type != VEH_ROAD) return;
+		SlObject(v, this->GetDescription());
+	}
 };
 
 class SlVehicleShip : public DefaultSaveLoadHandler<SlVehicleShip, Vehicle> {
@@ -802,19 +807,26 @@ public:
 		      SLE_VAR(Ship, state,                     SLE_UINT8),
 		SLE_CONDDEQUE(Ship, path,                      SLE_UINT8,                  SLV_SHIP_PATH_CACHE, SL_MAX_VERSION),
 		  SLE_CONDVAR(Ship, rotation,                  SLE_UINT8,                  SLV_SHIP_ROTATION, SL_MAX_VERSION),
-
-		SLE_CONDNULL(16, SLV_2, SLV_144), // old reserved space
 	};
+	inline const static SaveLoadCompatTable compat_description = _vehicle_ship_sl_compat;
 
-	void GenericSaveLoad(Vehicle *v) const
+	void Save(Vehicle *v) const override
 	{
 		if (v->type != VEH_SHIP) return;
 		SlObject(v, this->GetDescription());
 	}
 
-	void Save(Vehicle *v) const override { this->GenericSaveLoad(v); }
-	void Load(Vehicle *v) const override { this->GenericSaveLoad(v); }
-	void FixPointers(Vehicle *v) const override { this->GenericSaveLoad(v); }
+	void Load(Vehicle *v) const override
+	{
+		if (v->type != VEH_SHIP) return;
+		SlObject(v, this->GetLoadDescription());
+	}
+
+	void FixPointers(Vehicle *v) const override
+	{
+		if (v->type != VEH_SHIP) return;
+		SlObject(v, this->GetDescription());
+	}
 };
 
 class SlVehicleAircraft : public DefaultSaveLoadHandler<SlVehicleAircraft, Vehicle> {
@@ -835,19 +847,26 @@ public:
 
 		 SLE_CONDVAR(Aircraft, turn_counter,          SLE_UINT8,                  SLV_136, SL_MAX_VERSION),
 		 SLE_CONDVAR(Aircraft, flags,                 SLE_UINT8,                  SLV_167, SL_MAX_VERSION),
-
-		SLE_CONDNULL(13,                                                           SLV_2, SLV_144), // old reserved space
 	};
+	inline const static SaveLoadCompatTable compat_description = _vehicle_aircraft_sl_compat;
 
-	void GenericSaveLoad(Vehicle *v) const
+	void Save(Vehicle *v) const override
 	{
 		if (v->type != VEH_AIRCRAFT) return;
 		SlObject(v, this->GetDescription());
 	}
 
-	void Save(Vehicle *v) const override { this->GenericSaveLoad(v); }
-	void Load(Vehicle *v) const override { this->GenericSaveLoad(v); }
-	void FixPointers(Vehicle *v) const override { this->GenericSaveLoad(v); }
+	void Load(Vehicle *v) const override
+	{
+		if (v->type != VEH_AIRCRAFT) return;
+		SlObject(v, this->GetLoadDescription());
+	}
+
+	void FixPointers(Vehicle *v) const override
+	{
+		if (v->type != VEH_AIRCRAFT) return;
+		SlObject(v, this->GetDescription());
+	}
 };
 
 class SlVehicleEffect : public DefaultSaveLoadHandler<SlVehicleEffect, Vehicle> {
@@ -866,7 +885,6 @@ public:
 		 SLE_CONDVAR(Vehicle, z_pos,                 SLE_INT32,                  SLV_164, SL_MAX_VERSION),
 
 		     SLE_VAR(Vehicle, sprite_cache.sprite_seq.seq[0].sprite, SLE_FILE_U16 | SLE_VAR_U32),
-		SLE_CONDNULL(5,                                                            SL_MIN_VERSION,  SLV_59),
 		     SLE_VAR(Vehicle, progress,              SLE_UINT8),
 		     SLE_VAR(Vehicle, vehstatus,             SLE_UINT8),
 
@@ -874,19 +892,26 @@ public:
 		     SLE_VAR(EffectVehicle, animation_substate, SLE_UINT8),
 
 		 SLE_CONDVAR(Vehicle, spritenum,             SLE_UINT8,                    SLV_2, SL_MAX_VERSION),
-
-		SLE_CONDNULL(15,                                                           SLV_2, SLV_144), // old reserved space
 	};
+	inline const static SaveLoadCompatTable compat_description = _vehicle_effect_sl_compat;
 
-	void GenericSaveLoad(Vehicle *v) const
+	void Save(Vehicle *v) const override
 	{
 		if (v->type != VEH_EFFECT) return;
 		SlObject(v, this->GetDescription());
 	}
 
-	void Save(Vehicle *v) const override { this->GenericSaveLoad(v); }
-	void Load(Vehicle *v) const override { this->GenericSaveLoad(v); }
-	void FixPointers(Vehicle *v) const override { this->GenericSaveLoad(v); }
+	void Load(Vehicle *v) const override
+	{
+		if (v->type != VEH_EFFECT) return;
+		SlObject(v, this->GetLoadDescription());
+	}
+
+	void FixPointers(Vehicle *v) const override
+	{
+		if (v->type != VEH_EFFECT) return;
+		SlObject(v, this->GetDescription());
+	}
 };
 
 class SlVehicleDisaster : public DefaultSaveLoadHandler<SlVehicleDisaster, Vehicle> {
@@ -918,7 +943,6 @@ public:
 		SLE_CONDVAR(Vehicle, z_pos,                 SLE_INT32,                  SLV_164, SL_MAX_VERSION),
 		    SLE_VAR(Vehicle, direction,             SLE_UINT8),
 
-		SLE_CONDNULL(5,                                                            SL_MIN_VERSION,  SLV_58),
 		    SLE_VAR(Vehicle, owner,                 SLE_UINT8),
 		    SLE_VAR(Vehicle, vehstatus,             SLE_UINT8),
 		SLE_CONDVAR(Vehicle, current_order.dest,    SLE_FILE_U8 | SLE_VAR_U16,    SL_MIN_VERSION,   SLV_5),
@@ -934,23 +958,30 @@ public:
 		SLE_CONDVAR(DisasterVehicle, big_ufo_destroyer_target,  SLE_FILE_U16 | SLE_VAR_U32,   SL_MIN_VERSION, SLV_191),
 		SLE_CONDVAR(DisasterVehicle, big_ufo_destroyer_target,  SLE_UINT32,                 SLV_191, SL_MAX_VERSION),
 		SLE_CONDVAR(DisasterVehicle, flags,                     SLE_UINT8,                  SLV_194, SL_MAX_VERSION),
-
-		SLE_CONDNULL(16,                                                           SLV_2, SLV_144), // old reserved space
 	};
 #if defined(_MSC_VER) && (_MSC_VER == 1915 || _MSC_VER == 1916)
 		return description;
 	}
 #endif
+	inline const static SaveLoadCompatTable compat_description = _vehicle_disaster_sl_compat;
 
-	void GenericSaveLoad(Vehicle *v) const
+	void Save(Vehicle *v) const override
 	{
 		if (v->type != VEH_DISASTER) return;
 		SlObject(v, this->GetDescription());
 	}
 
-	void Save(Vehicle *v) const override { this->GenericSaveLoad(v); }
-	void Load(Vehicle *v) const override { this->GenericSaveLoad(v); }
-	void FixPointers(Vehicle *v) const override { this->GenericSaveLoad(v); }
+	void Load(Vehicle *v) const override
+	{
+		if (v->type != VEH_DISASTER) return;
+		SlObject(v, this->GetLoadDescription());
+	}
+
+	void FixPointers(Vehicle *v) const override
+	{
+		if (v->type != VEH_DISASTER) return;
+		SlObject(v, this->GetDescription());
+	}
 };
 
 const static SaveLoad _vehicle_desc[] = {
@@ -966,6 +997,8 @@ const static SaveLoad _vehicle_desc[] = {
 /** Will be called when the vehicles need to be saved. */
 static void Save_VEHS()
 {
+	SlTableHeader(_vehicle_desc);
+
 	/* Write the vehicles */
 	for (Vehicle *v : Vehicle::Iterate()) {
 		SlSetArrayIndex(v->index);
@@ -976,6 +1009,8 @@ static void Save_VEHS()
 /** Will be called when vehicles need to be loaded. */
 void Load_VEHS()
 {
+	const std::vector<SaveLoad> slt = SlCompatTableHeader(_vehicle_desc, _vehicle_sl_compat);
+
 	int index;
 
 	_cargo_count = 0;
@@ -995,7 +1030,7 @@ void Load_VEHS()
 			default: SlErrorCorrupt("Invalid vehicle type");
 		}
 
-		SlObject(v, _vehicle_desc);
+		SlObject(v, slt);
 
 		if (_cargo_count != 0 && IsCompanyBuildableVehicleType(v) && CargoPacket::CanAllocateItem()) {
 			/* Don't construct the packet with station here, because that'll fail with old savegames */
@@ -1030,7 +1065,7 @@ void Ptrs_VEHS()
 }
 
 static const ChunkHandler veh_chunk_handlers[] = {
-	{ 'VEHS', Save_VEHS, Load_VEHS, Ptrs_VEHS, nullptr, CH_SPARSE_ARRAY },
+	{ 'VEHS', Save_VEHS, Load_VEHS, Ptrs_VEHS, nullptr, CH_SPARSE_TABLE },
 };
 
 extern const ChunkHandlerTable _veh_chunk_handlers(veh_chunk_handlers);