Merge branch 'tracerestrict-sx' into jgrpp

src/saveload/afterload.cpp

@@ -2988,6 +2988,8 @@ bool AfterLoadGame()
 	ResetSignalHandlers();
 
 	AfterLoadLinkGraphs();
+
+	AfterLoadTraceRestrict();
 	return true;
 }
 

src/saveload/extended_ver_sl.cpp

@@ -45,6 +45,7 @@ std::vector<uint32> _sl_xv_discardable_chunk_ids;           ///< list of chunks
 static const uint32 _sl_xv_slxi_chunk_version = 0;          ///< current version os SLXI chunk
 
 const SlxiSubChunkInfo _sl_xv_sub_chunk_infos[] = {
+	{ XSLFI_TRACE_RESTRICT, XSCF_NULL, 1, 1, "tracerestrict", NULL, NULL, "TRRM,TRRP" },
 	{ XSLFI_NULL, XSCF_NULL, 0, 0, NULL, NULL, NULL, NULL },// This is the end marker
 };
 
@@ -121,7 +122,12 @@ void SlXvCheckSpecialSavegameVersions()
 {
 	extern uint16 _sl_version;
 
-	// TODO: check for savegame versions
+	if (_sl_version == 2000) {
+		DEBUG(sl, 1, "Loading a trace restrict patch savegame version %d as version 194", _sl_version);
+		_sl_version = 194;
+		_sl_is_faked_ext = true;
+		_sl_xv_feature_versions[XSLFI_TRACE_RESTRICT] = 1;
+	}
 }
 
 /**

src/saveload/extended_ver_sl.h

@@ -21,6 +21,7 @@
  */
 enum SlXvFeatureIndex {
 	XSLFI_NULL                          = 0,      ///< Unused value, to indicate that no extended feature test is in use
+	XSLFI_TRACE_RESTRICT,                         ///< Trace restrict
 
 	XSLFI_SIZE,                                   ///< Total count of features, including null feature
 };

src/saveload/saveload.cpp

@@ -454,6 +454,7 @@ extern const ChunkHandler _linkgraph_chunk_handlers[];
 extern const ChunkHandler _airport_chunk_handlers[];
 extern const ChunkHandler _object_chunk_handlers[];
 extern const ChunkHandler _persistent_storage_chunk_handlers[];
+extern const ChunkHandler _trace_restrict_chunk_handlers[];
 
 /** Array of all chunks in a savegame, \c NULL terminated. */
 static const ChunkHandler * const _chunk_handlers[] = {
@@ -491,6 +492,7 @@ static const ChunkHandler * const _chunk_handlers[] = {
 	_airport_chunk_handlers,
 	_object_chunk_handlers,
 	_persistent_storage_chunk_handlers,
+	_trace_restrict_chunk_handlers,
 	NULL,
 };
 

src/saveload/saveload_internal.h

@@ -34,6 +34,7 @@ void AfterLoadLabelMaps();
 void AfterLoadStoryBook();
 void AfterLoadLinkGraphs();
 void AfterLoadCompanyStats();
+void AfterLoadTraceRestrict();
 void UpdateHousesAndTowns();
 
 void UpdateOldAircraft();

src/saveload/tracerestrict_sl.cpp

@@ -0,0 +1,111 @@
+/* $Id$ */
+
+/*
+ * 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 tracerestrict_sl.cpp Code handling saving and loading of trace restrict programs */
+
+#include "../stdafx.h"
+#include "../tracerestrict.h"
+#include "saveload.h"
+#include <vector>
+#include "saveload.h"
+
+static const SaveLoad _trace_restrict_mapping_desc[] = {
+  SLE_VAR(TraceRestrictMappingItem, program_id, SLE_UINT32),
+  SLE_END()
+};
+
+/**
+ * Load mappings
+ */
+static void Load_TRRM()
+{
+	int index;
+	while ((index = SlIterateArray()) != -1) {
+		TraceRestrictMappingItem &item = _tracerestrictprogram_mapping[index];
+		SlObject(&item, _trace_restrict_mapping_desc);
+	}
+}
+
+/**
+ * Save mappings
+ */
+static void Save_TRRM()
+{
+	for (TraceRestrictMapping::iterator iter = _tracerestrictprogram_mapping.begin();
+			iter != _tracerestrictprogram_mapping.end(); ++iter) {
+		SlSetArrayIndex(iter->first);
+		SlObject(&(iter->second), _trace_restrict_mapping_desc);
+	}
+}
+
+/** program length save header struct */
+struct TraceRestrictProgramStub {
+	uint32 length;
+};
+
+static const SaveLoad _trace_restrict_program_stub_desc[] = {
+	SLE_VAR(TraceRestrictProgramStub, length, SLE_UINT32),
+	SLE_END()
+};
+
+/**
+ * Load program pool
+ */
+static void Load_TRRP()
+{
+	int index;
+	TraceRestrictProgramStub stub;
+	while ((index = SlIterateArray()) != -1) {
+		TraceRestrictProgram *prog = new (index) TraceRestrictProgram();
+		SlObject(&stub, _trace_restrict_program_stub_desc);
+		prog->items.resize(stub.length);
+		SlArray(&(prog->items[0]), stub.length, SLE_UINT32);
+		assert(prog->Validate().Succeeded());
+	}
+}
+
+/**
+ * Save a program, used by SlAutolength
+ */
+static void RealSave_TRRP(TraceRestrictProgram *prog)
+{
+	TraceRestrictProgramStub stub;
+	stub.length = prog->items.size();
+	SlObject(&stub, _trace_restrict_program_stub_desc);
+	SlArray(&(prog->items[0]), stub.length, SLE_UINT32);
+}
+
+/**
+ * Save program pool
+ */
+static void Save_TRRP()
+{
+	TraceRestrictProgram *prog;
+
+	FOR_ALL_TRACE_RESTRICT_PROGRAMS(prog) {
+		SlSetArrayIndex(prog->index);
+		SlAutolength((AutolengthProc*) RealSave_TRRP, prog);
+	}
+}
+
+/**
+ * Update program reference counts from just-loaded mapping
+ */
+void AfterLoadTraceRestrict()
+{
+	for (TraceRestrictMapping::iterator iter = _tracerestrictprogram_mapping.begin();
+			iter != _tracerestrictprogram_mapping.end(); ++iter) {
+		_tracerestrictprogram_pool.Get(iter->second.program_id)->IncrementRefCount();
+	}
+}
+
+extern const ChunkHandler _trace_restrict_chunk_handlers[] = {
+	{ 'TRRM', Save_TRRM, Load_TRRM, NULL, NULL, CH_SPARSE_ARRAY},    // Trace Restrict Mapping chunk
+	{ 'TRRP', Save_TRRP, Load_TRRP, NULL, NULL, CH_ARRAY | CH_LAST}, // Trace Restrict Mapping Program Pool chunk
+};