diff --git a/src/saveload/saveload.cpp b/src/saveload/saveload.cpp
new file mode 100644
--- /dev/null
+++ b/src/saveload/saveload.cpp
@@ -0,0 +1,1899 @@
+/* $Id$ */
+
+/** @file saveload.cpp
+ * All actions handling saving and loading goes on in this file. The general actions
+ * are as follows for saving a game (loading is analogous):
+ *
+ * - initialize the writer by creating a temporary memory-buffer for it
+ *
- go through all to-be saved elements, each 'chunk' (ChunkHandler) prefixed by a label
+ *
- use their description array (SaveLoad) to know what elements to save and in what version
+ * of the game it was active (used when loading)
+ *
- write all data byte-by-byte to the temporary buffer so it is endian-safe
+ *
- when the buffer is full; flush it to the output (eg save to file) (_sl.buf, _sl.bufp, _sl.bufe)
+ *
- repeat this until everything is done, and flush any remaining output to file
+ *
+ */
+#include "../stdafx.h"
+#include "../openttd.h"
+#include "../debug.h"
+#include "../station_base.h"
+#include "../thread.h"
+#include "../town.h"
+#include "../network/network.h"
+#include "../variables.h"
+#include "../window_func.h"
+#include "../strings_func.h"
+#include "../gfx_func.h"
+#include "../core/alloc_func.hpp"
+#include "../functions.h"
+#include "../core/endian_func.hpp"
+#include "../vehicle_base.h"
+#include "../company_func.h"
+#include "../date_func.h"
+#include "../autoreplace_base.h"
+#include "../statusbar_gui.h"
+#include "../fileio_func.h"
+#include "../gamelog.h"
+
+#include "table/strings.h"
+
+#include "saveload.h"
+#include "saveload_internal.h"
+
+#include
+
+extern const uint16 SAVEGAME_VERSION = 105;
+
+SavegameType _savegame_type; ///< type of savegame we are loading
+
+uint32 _ttdp_version; ///< version of TTDP savegame (if applicable)
+uint16 _sl_version; ///< the major savegame version identifier
+byte _sl_minor_version; ///< the minor savegame version, DO NOT USE!
+
+typedef void WriterProc(size_t len);
+typedef size_t ReaderProc();
+
+/** The saveload struct, containing reader-writer functions, bufffer, version, etc. */
+static struct {
+ bool save; ///< are we doing a save or a load atm. True when saving
+ byte need_length; ///< ???
+ byte block_mode; ///< ???
+ bool error; ///< did an error occur or not
+
+ size_t obj_len; ///< the length of the current object we are busy with
+ int array_index, last_array_index; ///< in the case of an array, the current and last positions
+
+ size_t offs_base; ///< the offset in number of bytes since we started writing data (eg uncompressed savegame size)
+
+ WriterProc *write_bytes; ///< savegame writer function
+ ReaderProc *read_bytes; ///< savegame loader function
+
+ const ChunkHandler* const *chs; ///< the chunk of data that is being processed atm (vehicles, signs, etc.)
+
+ /* When saving/loading savegames, they are always saved to a temporary memory-place
+ * to be flushed to file (save) or to final place (load) when full. */
+ byte *bufp, *bufe; ///< bufp(ointer) gives the current position in the buffer bufe(nd) gives the end of the buffer
+
+ /* these 3 may be used by compressor/decompressors. */
+ byte *buf; ///< pointer to temporary memory to read/write, initialized by SaveLoadFormat->initread/write
+ byte *buf_ori; ///< pointer to the original memory location of buf, used to free it afterwards
+ uint bufsize; ///< the size of the temporary memory *buf
+ FILE *fh; ///< the file from which is read or written to
+
+ void (*excpt_uninit)(); ///< the function to execute on any encountered error
+ StringID error_str; ///< the translateable error message to show
+ char *extra_msg; ///< the error message
+} _sl;
+
+
+enum NeedLengthValues {NL_NONE = 0, NL_WANTLENGTH = 1, NL_CALCLENGTH = 2};
+
+/** Error handler, calls longjmp to simulate an exception.
+ * @todo this was used to have a central place to handle errors, but it is
+ * pretty ugly, and seriously interferes with any multithreaded approaches */
+static void NORETURN SlError(StringID string, const char *extra_msg = NULL)
+{
+ _sl.error_str = string;
+ free(_sl.extra_msg);
+ _sl.extra_msg = (extra_msg == NULL) ? NULL : strdup(extra_msg);
+ throw std::exception();
+}
+
+typedef void (*AsyncSaveFinishProc)();
+static AsyncSaveFinishProc _async_save_finish = NULL;
+static ThreadObject *_save_thread;
+
+/**
+ * Called by save thread to tell we finished saving.
+ */
+static void SetAsyncSaveFinish(AsyncSaveFinishProc proc)
+{
+ if (_exit_game) return;
+ while (_async_save_finish != NULL) CSleep(10);
+
+ _async_save_finish = proc;
+}
+
+/**
+ * Handle async save finishes.
+ */
+void ProcessAsyncSaveFinish()
+{
+ if (_async_save_finish == NULL) return;
+
+ _async_save_finish();
+
+ _async_save_finish = NULL;
+
+ if (_save_thread != NULL) {
+ _save_thread->Join();
+ delete _save_thread;
+ _save_thread = NULL;
+ }
+}
+
+/**
+ * Fill the input buffer by reading from the file with the given reader
+ */
+static void SlReadFill()
+{
+ size_t len = _sl.read_bytes();
+ if (len == 0) SlError(STR_GAME_SAVELOAD_ERROR_BROKEN_SAVEGAME, "Unexpected end of chunk");
+
+ _sl.bufp = _sl.buf;
+ _sl.bufe = _sl.buf + len;
+ _sl.offs_base += len;
+}
+
+static inline size_t SlGetOffs() {return _sl.offs_base - (_sl.bufe - _sl.bufp);}
+
+/** Return the size in bytes of a certain type of normal/atomic variable
+ * as it appears in memory. See VarTypes
+ * @param conv VarType type of variable that is used for calculating the size
+ * @return Return the size of this type in bytes */
+static inline byte SlCalcConvMemLen(VarType conv)
+{
+ static const byte conv_mem_size[] = {1, 1, 1, 2, 2, 4, 4, 8, 8, 0};
+ byte length = GB(conv, 4, 4);
+ assert(length < lengthof(conv_mem_size));
+ return conv_mem_size[length];
+}
+
+/** Return the size in bytes of a certain type of normal/atomic variable
+ * as it appears in a saved game. See VarTypes
+ * @param conv VarType type of variable that is used for calculating the size
+ * @return Return the size of this type in bytes */
+static inline byte SlCalcConvFileLen(VarType conv)
+{
+ static const byte conv_file_size[] = {1, 1, 2, 2, 4, 4, 8, 8, 2};
+ byte length = GB(conv, 0, 4);
+ assert(length < lengthof(conv_file_size));
+ return conv_file_size[length];
+}
+
+/** Return the size in bytes of a reference (pointer) */
+static inline size_t SlCalcRefLen() {return CheckSavegameVersion(69) ? 2 : 4;}
+
+/** Flush the output buffer by writing to disk with the given reader.
+ * If the buffer pointer has not yet been set up, set it up now. Usually
+ * only called when the buffer is full, or there is no more data to be processed
+ */
+static void SlWriteFill()
+{
+ /* flush the buffer to disk (the writer) */
+ if (_sl.bufp != NULL) {
+ uint len = _sl.bufp - _sl.buf;
+ _sl.offs_base += len;
+ if (len) _sl.write_bytes(len);
+ }
+
+ /* All the data from the buffer has been written away, rewind to the beginning
+ * to start reading in more data */
+ _sl.bufp = _sl.buf;
+ _sl.bufe = _sl.buf + _sl.bufsize;
+}
+
+/** Read in a single byte from file. If the temporary buffer is full,
+ * flush it to its final destination
+ * @return return the read byte from file
+ */
+static inline byte SlReadByteInternal()
+{
+ if (_sl.bufp == _sl.bufe) SlReadFill();
+ return *_sl.bufp++;
+}
+
+/** Wrapper for SlReadByteInternal */
+byte SlReadByte() {return SlReadByteInternal();}
+
+/** Write away a single byte from memory. If the temporary buffer is full,
+ * flush it to its destination (file)
+ * @param b the byte that is currently written
+ */
+static inline void SlWriteByteInternal(byte b)
+{
+ if (_sl.bufp == _sl.bufe) SlWriteFill();
+ *_sl.bufp++ = b;
+}
+
+/** Wrapper for SlWriteByteInternal */
+void SlWriteByte(byte b) {SlWriteByteInternal(b);}
+
+static inline int SlReadUint16()
+{
+ int x = SlReadByte() << 8;
+ return x | SlReadByte();
+}
+
+static inline uint32 SlReadUint32()
+{
+ uint32 x = SlReadUint16() << 16;
+ return x | SlReadUint16();
+}
+
+static inline uint64 SlReadUint64()
+{
+ uint32 x = SlReadUint32();
+ uint32 y = SlReadUint32();
+ return (uint64)x << 32 | y;
+}
+
+static inline void SlWriteUint16(uint16 v)
+{
+ SlWriteByte(GB(v, 8, 8));
+ SlWriteByte(GB(v, 0, 8));
+}
+
+static inline void SlWriteUint32(uint32 v)
+{
+ SlWriteUint16(GB(v, 16, 16));
+ SlWriteUint16(GB(v, 0, 16));
+}
+
+static inline void SlWriteUint64(uint64 x)
+{
+ SlWriteUint32((uint32)(x >> 32));
+ SlWriteUint32((uint32)x);
+}
+
+/**
+ * Read in the header descriptor of an object or an array.
+ * If the highest bit is set (7), then the index is bigger than 127
+ * elements, so use the next byte to read in the real value.
+ * The actual value is then both bytes added with the first shifted
+ * 8 bits to the left, and dropping the highest bit (which only indicated a big index).
+ * x = ((x & 0x7F) << 8) + SlReadByte();
+ * @return Return the value of the index
+ */
+static uint SlReadSimpleGamma()
+{
+ uint i = SlReadByte();
+ if (HasBit(i, 7)) {
+ i &= ~0x80;
+ if (HasBit(i, 6)) {
+ i &= ~0x40;
+ if (HasBit(i, 5)) {
+ i &= ~0x20;
+ if (HasBit(i, 4))
+ SlError(STR_GAME_SAVELOAD_ERROR_BROKEN_SAVEGAME, "Unsupported gamma");
+ i = (i << 8) | SlReadByte();
+ }
+ i = (i << 8) | SlReadByte();
+ }
+ i = (i << 8) | SlReadByte();
+ }
+ return i;
+}
+
+/**
+ * Write the header descriptor of an object or an array.
+ * If the element is bigger than 127, use 2 bytes for saving
+ * and use the highest byte of the first written one as a notice
+ * that the length consists of 2 bytes, etc.. like this:
+ * 0xxxxxxx
+ * 10xxxxxx xxxxxxxx
+ * 110xxxxx xxxxxxxx xxxxxxxx
+ * 1110xxxx xxxxxxxx xxxxxxxx xxxxxxxx
+ * @param i Index being written
+ */
+
+static void SlWriteSimpleGamma(size_t i)
+{
+ if (i >= (1 << 7)) {
+ if (i >= (1 << 14)) {
+ if (i >= (1 << 21)) {
+ assert(i < (1 << 28));
+ SlWriteByte((byte)(0xE0 | (i >> 24)));
+ SlWriteByte((byte)(i >> 16));
+ } else {
+ SlWriteByte((byte)(0xC0 | (i >> 16)));
+ }
+ SlWriteByte((byte)(i >> 8));
+ } else {
+ SlWriteByte((byte)(0x80 | (i >> 8)));
+ }
+ }
+ SlWriteByte((byte)i);
+}
+
+/** Return how many bytes used to encode a gamma value */
+static inline uint SlGetGammaLength(size_t i)
+{
+ return 1 + (i >= (1 << 7)) + (i >= (1 << 14)) + (i >= (1 << 21));
+}
+
+static inline uint SlReadSparseIndex() {return SlReadSimpleGamma();}
+static inline void SlWriteSparseIndex(uint index) {SlWriteSimpleGamma(index);}
+
+static inline uint SlReadArrayLength() {return SlReadSimpleGamma();}
+static inline void SlWriteArrayLength(size_t length) {SlWriteSimpleGamma(length);}
+static inline uint SlGetArrayLength(size_t length) {return SlGetGammaLength(length);}
+
+void SlSetArrayIndex(uint index)
+{
+ _sl.need_length = NL_WANTLENGTH;
+ _sl.array_index = index;
+}
+
+static size_t _next_offs;
+
+/**
+ * Iterate through the elements of an array and read the whole thing
+ * @return The index of the object, or -1 if we have reached the end of current block
+ */
+int SlIterateArray()
+{
+ int index;
+
+ /* After reading in the whole array inside the loop
+ * we must have read in all the data, so we must be at end of current block. */
+ if (_next_offs != 0 && SlGetOffs() != _next_offs) SlError(STR_GAME_SAVELOAD_ERROR_BROKEN_SAVEGAME, "Invalid chunk size");
+
+ while (true) {
+ uint length = SlReadArrayLength();
+ if (length == 0) {
+ _next_offs = 0;
+ return -1;
+ }
+
+ _sl.obj_len = --length;
+ _next_offs = SlGetOffs() + length;
+
+ switch (_sl.block_mode) {
+ case CH_SPARSE_ARRAY: index = (int)SlReadSparseIndex(); break;
+ case CH_ARRAY: index = _sl.array_index++; break;
+ default:
+ DEBUG(sl, 0, "SlIterateArray error");
+ return -1; // error
+ }
+
+ if (length != 0) return index;
+ }
+}
+
+/**
+ * Sets the length of either a RIFF object or the number of items in an array.
+ * This lets us load an object or an array of arbitrary size
+ * @param length The length of the sought object/array
+ */
+void SlSetLength(size_t length)
+{
+ assert(_sl.save);
+
+ switch (_sl.need_length) {
+ case NL_WANTLENGTH:
+ _sl.need_length = NL_NONE;
+ switch (_sl.block_mode) {
+ case CH_RIFF:
+ /* Ugly encoding of >16M RIFF chunks
+ * The lower 24 bits are normal
+ * The uppermost 4 bits are bits 24:27 */
+ assert(length < (1 << 28));
+ SlWriteUint32((uint32)((length & 0xFFFFFF) | ((length >> 24) << 28)));
+ break;
+ case CH_ARRAY:
+ assert(_sl.last_array_index <= _sl.array_index);
+ while (++_sl.last_array_index <= _sl.array_index)
+ SlWriteArrayLength(1);
+ SlWriteArrayLength(length + 1);
+ break;
+ case CH_SPARSE_ARRAY:
+ SlWriteArrayLength(length + 1 + SlGetArrayLength(_sl.array_index)); // Also include length of sparse index.
+ SlWriteSparseIndex(_sl.array_index);
+ break;
+ default: NOT_REACHED();
+ } break;
+ case NL_CALCLENGTH:
+ _sl.obj_len += (int)length;
+ break;
+ }
+}
+
+/**
+ * Save/Load bytes. These do not need to be converted to Little/Big Endian
+ * so directly write them or read them to/from file
+ * @param ptr The source or destination of the object being manipulated
+ * @param length number of bytes this fast CopyBytes lasts
+ */
+static void SlCopyBytes(void *ptr, size_t length)
+{
+ byte *p = (byte*)ptr;
+
+ if (_sl.save) {
+ for (; length != 0; length--) {SlWriteByteInternal(*p++);}
+ } else {
+ for (; length != 0; length--) {*p++ = SlReadByteInternal();}
+ }
+}
+
+/** Read in bytes from the file/data structure but don't do
+ * anything with them, discarding them in effect
+ * @param length The amount of bytes that is being treated this way
+ */
+static inline void SlSkipBytes(size_t length)
+{
+ for (; length != 0; length--) SlReadByte();
+}
+
+/* Get the length of the current object */
+size_t SlGetFieldLength() {return _sl.obj_len;}
+
+/** Return a signed-long version of the value of a setting
+ * @param ptr pointer to the variable
+ * @param conv type of variable, can be a non-clean
+ * type, eg one with other flags because it is parsed
+ * @return returns the value of the pointer-setting */
+int64 ReadValue(const void *ptr, VarType conv)
+{
+ switch (GetVarMemType(conv)) {
+ case SLE_VAR_BL: return (*(bool*)ptr != 0);
+ case SLE_VAR_I8: return *(int8* )ptr;
+ case SLE_VAR_U8: return *(byte* )ptr;
+ case SLE_VAR_I16: return *(int16* )ptr;
+ case SLE_VAR_U16: return *(uint16*)ptr;
+ case SLE_VAR_I32: return *(int32* )ptr;
+ case SLE_VAR_U32: return *(uint32*)ptr;
+ case SLE_VAR_I64: return *(int64* )ptr;
+ case SLE_VAR_U64: return *(uint64*)ptr;
+ case SLE_VAR_NULL:return 0;
+ default: NOT_REACHED();
+ }
+
+ /* useless, but avoids compiler warning this way */
+ return 0;
+}
+
+/** Write the value of a setting
+ * @param ptr pointer to the variable
+ * @param conv type of variable, can be a non-clean type, eg
+ * with other flags. It is parsed upon read
+ * @param val the new value being given to the variable */
+void WriteValue(void *ptr, VarType conv, int64 val)
+{
+ switch (GetVarMemType(conv)) {
+ case SLE_VAR_BL: *(bool *)ptr = (val != 0); break;
+ case SLE_VAR_I8: *(int8 *)ptr = val; break;
+ case SLE_VAR_U8: *(byte *)ptr = val; break;
+ case SLE_VAR_I16: *(int16 *)ptr = val; break;
+ case SLE_VAR_U16: *(uint16*)ptr = val; break;
+ case SLE_VAR_I32: *(int32 *)ptr = val; break;
+ case SLE_VAR_U32: *(uint32*)ptr = val; break;
+ case SLE_VAR_I64: *(int64 *)ptr = val; break;
+ case SLE_VAR_U64: *(uint64*)ptr = val; break;
+ case SLE_VAR_NAME: *(char**)ptr = CopyFromOldName(val); break;
+ case SLE_VAR_NULL: break;
+ default: NOT_REACHED();
+ }
+}
+
+/**
+ * Handle all conversion and typechecking of variables here.
+ * In the case of saving, read in the actual value from the struct
+ * and then write them to file, endian safely. Loading a value
+ * goes exactly the opposite way
+ * @param ptr The object being filled/read
+ * @param conv VarType type of the current element of the struct
+ */
+static void SlSaveLoadConv(void *ptr, VarType conv)
+{
+ int64 x = 0;
+
+ if (_sl.save) { // SAVE values
+ /* Read a value from the struct. These ARE endian safe. */
+ x = ReadValue(ptr, conv);
+
+ /* Write the value to the file and check if its value is in the desired range */
+ switch (GetVarFileType(conv)) {
+ case SLE_FILE_I8: assert(x >= -128 && x <= 127); SlWriteByte(x);break;
+ case SLE_FILE_U8: assert(x >= 0 && x <= 255); SlWriteByte(x);break;
+ case SLE_FILE_I16:assert(x >= -32768 && x <= 32767); SlWriteUint16(x);break;
+ case SLE_FILE_STRINGID:
+ case SLE_FILE_U16:assert(x >= 0 && x <= 65535); SlWriteUint16(x);break;
+ case SLE_FILE_I32:
+ case SLE_FILE_U32: SlWriteUint32((uint32)x);break;
+ case SLE_FILE_I64:
+ case SLE_FILE_U64: SlWriteUint64(x);break;
+ default: NOT_REACHED();
+ }
+ } else { // LOAD values
+
+ /* Read a value from the file */
+ switch (GetVarFileType(conv)) {
+ case SLE_FILE_I8: x = (int8 )SlReadByte(); break;
+ case SLE_FILE_U8: x = (byte )SlReadByte(); break;
+ case SLE_FILE_I16: x = (int16 )SlReadUint16(); break;
+ case SLE_FILE_U16: x = (uint16)SlReadUint16(); break;
+ case SLE_FILE_I32: x = (int32 )SlReadUint32(); break;
+ case SLE_FILE_U32: x = (uint32)SlReadUint32(); break;
+ case SLE_FILE_I64: x = (int64 )SlReadUint64(); break;
+ case SLE_FILE_U64: x = (uint64)SlReadUint64(); break;
+ case SLE_FILE_STRINGID: x = RemapOldStringID((uint16)SlReadUint16()); break;
+ default: NOT_REACHED();
+ }
+
+ /* Write The value to the struct. These ARE endian safe. */
+ WriteValue(ptr, conv, x);
+ }
+}
+
+/** Calculate the net length of a string. This is in almost all cases
+ * just strlen(), but if the string is not properly terminated, we'll
+ * resort to the maximum length of the buffer.
+ * @param ptr pointer to the stringbuffer
+ * @param length maximum length of the string (buffer). If -1 we don't care
+ * about a maximum length, but take string length as it is.
+ * @return return the net length of the string */
+static inline size_t SlCalcNetStringLen(const char *ptr, size_t length)
+{
+ if (ptr == NULL) return 0;
+ return min(strlen(ptr), length - 1);
+}
+
+/** Calculate the gross length of the string that it
+ * will occupy in the savegame. This includes the real length, returned
+ * by SlCalcNetStringLen and the length that the index will occupy.
+ * @param ptr pointer to the stringbuffer
+ * @param length maximum length of the string (buffer size, etc.)
+ * @param conv type of data been used
+ * @return return the gross length of the string */
+static inline size_t SlCalcStringLen(const void *ptr, size_t length, VarType conv)
+{
+ size_t len;
+ const char *str;
+
+ switch (GetVarMemType(conv)) {
+ default: NOT_REACHED();
+ case SLE_VAR_STR:
+ case SLE_VAR_STRQ:
+ str = *(const char**)ptr;
+ len = SIZE_MAX;
+ break;
+ case SLE_VAR_STRB:
+ case SLE_VAR_STRBQ:
+ str = (const char*)ptr;
+ len = length;
+ break;
+ }
+
+ len = SlCalcNetStringLen(str, len);
+ return len + SlGetArrayLength(len); // also include the length of the index
+}
+
+/**
+ * Save/Load a string.
+ * @param ptr the string being manipulated
+ * @param length of the string (full length)
+ * @param conv must be SLE_FILE_STRING */
+static void SlString(void *ptr, size_t length, VarType conv)
+{
+ size_t len;
+
+ if (_sl.save) { // SAVE string
+ switch (GetVarMemType(conv)) {
+ default: NOT_REACHED();
+ case SLE_VAR_STRB:
+ case SLE_VAR_STRBQ:
+ len = SlCalcNetStringLen((char*)ptr, length);
+ break;
+ case SLE_VAR_STR:
+ case SLE_VAR_STRQ:
+ ptr = *(char**)ptr;
+ len = SlCalcNetStringLen((char*)ptr, SIZE_MAX);
+ break;
+ }
+
+ SlWriteArrayLength(len);
+ SlCopyBytes(ptr, len);
+ } else { // LOAD string
+ len = SlReadArrayLength();
+
+ switch (GetVarMemType(conv)) {
+ default: NOT_REACHED();
+ case SLE_VAR_STRB:
+ case SLE_VAR_STRBQ:
+ if (len >= length) {
+ DEBUG(sl, 1, "String length in savegame is bigger than buffer, truncating");
+ SlCopyBytes(ptr, length);
+ SlSkipBytes(len - length);
+ len = length - 1;
+ } else {
+ SlCopyBytes(ptr, len);
+ }
+ break;
+ case SLE_VAR_STR:
+ case SLE_VAR_STRQ: // Malloc'd string, free previous incarnation, and allocate
+ free(*(char**)ptr);
+ if (len == 0) {
+ *(char**)ptr = NULL;
+ } else {
+ *(char**)ptr = MallocT(len + 1); // terminating '\0'
+ ptr = *(char**)ptr;
+ SlCopyBytes(ptr, len);
+ }
+ break;
+ }
+
+ ((char*)ptr)[len] = '\0'; // properly terminate the string
+ }
+}
+
+/**
+ * Return the size in bytes of a certain type of atomic array
+ * @param length The length of the array counted in elements
+ * @param conv VarType type of the variable that is used in calculating the size
+ */
+static inline size_t SlCalcArrayLen(size_t length, VarType conv)
+{
+ return SlCalcConvFileLen(conv) * length;
+}
+
+/**
+ * Save/Load an array.
+ * @param array The array being manipulated
+ * @param length The length of the array in elements
+ * @param conv VarType type of the atomic array (int, byte, uint64, etc.)
+ */
+void SlArray(void *array, size_t length, VarType conv)
+{
+ /* Automatically calculate the length? */
+ if (_sl.need_length != NL_NONE) {
+ SlSetLength(SlCalcArrayLen(length, conv));
+ /* Determine length only? */
+ if (_sl.need_length == NL_CALCLENGTH) return;
+ }
+
+ /* NOTICE - handle some buggy stuff, in really old versions everything was saved
+ * as a byte-type. So detect this, and adjust array size accordingly */
+ if (!_sl.save && _sl_version == 0) {
+ /* all arrays except difficulty settings */
+ if (conv == SLE_INT16 || conv == SLE_UINT16 || conv == SLE_STRINGID ||
+ conv == SLE_INT32 || conv == SLE_UINT32) {
+ SlCopyBytes(array, length * SlCalcConvFileLen(conv));
+ return;
+ }
+ /* used for conversion of Money 32bit->64bit */
+ if (conv == (SLE_FILE_I32 | SLE_VAR_I64)) {
+ for (uint i = 0; i < length; i++) {
+ ((int64*)array)[i] = (int32)BSWAP32(SlReadUint32());
+ }
+ return;
+ }
+ }
+
+ /* If the size of elements is 1 byte both in file and memory, no special
+ * conversion is needed, use specialized copy-copy function to speed up things */
+ if (conv == SLE_INT8 || conv == SLE_UINT8) {
+ SlCopyBytes(array, length);
+ } else {
+ byte *a = (byte*)array;
+ byte mem_size = SlCalcConvMemLen(conv);
+
+ for (; length != 0; length --) {
+ SlSaveLoadConv(a, conv);
+ a += mem_size; // get size
+ }
+ }
+}
+
+
+static uint ReferenceToInt(const void* obj, SLRefType rt);
+static void* IntToReference(uint index, SLRefType rt);
+
+
+/**
+ * Return the size in bytes of a list
+ * @param list The std::list to find the size of
+ */
+static inline size_t SlCalcListLen(const void *list)
+{
+ std::list *l = (std::list *) list;
+
+ int type_size = CheckSavegameVersion(69) ? 2 : 4;
+ /* Each entry is saved as type_size bytes, plus type_size bytes are used for the length
+ * of the list */
+ return l->size() * type_size + type_size;
+}
+
+
+/**
+ * Save/Load a list.
+ * @param list The list being manipulated
+ * @param conv SLRefType type of the list (Vehicle *, Station *, etc)
+ */
+void SlList(void *list, SLRefType conv)
+{
+ /* Automatically calculate the length? */
+ if (_sl.need_length != NL_NONE) {
+ SlSetLength(SlCalcListLen(list));
+ /* Determine length only? */
+ if (_sl.need_length == NL_CALCLENGTH) return;
+ }
+
+ std::list *l = (std::list *) list;
+
+ if (_sl.save) {
+ SlWriteUint32((uint32)l->size());
+
+ std::list::iterator iter;
+ for (iter = l->begin(); iter != l->end(); ++iter) {
+ void *ptr = *iter;
+ SlWriteUint32(ReferenceToInt(ptr, conv));
+ }
+ } else {
+ uint length = CheckSavegameVersion(69) ? SlReadUint16() : SlReadUint32();
+
+ /* Load each reference and push to the end of the list */
+ for (uint i = 0; i < length; i++) {
+ void *ptr = IntToReference(CheckSavegameVersion(69) ? SlReadUint16() : SlReadUint32(), conv);
+ l->push_back(ptr);
+ }
+ }
+}
+
+
+/** Are we going to save this object or not? */
+static inline bool SlIsObjectValidInSavegame(const SaveLoad *sld)
+{
+ if (_sl_version < sld->version_from || _sl_version > sld->version_to) return false;
+ if (sld->conv & SLF_SAVE_NO) return false;
+
+ return true;
+}
+
+/** Are we going to load this variable when loading a savegame or not?
+ * @note If the variable is skipped it is skipped in the savegame
+ * bytestream itself as well, so there is no need to skip it somewhere else */
+static inline bool SlSkipVariableOnLoad(const SaveLoad *sld)
+{
+ if ((sld->conv & SLF_NETWORK_NO) && !_sl.save && _networking && !_network_server) {
+ SlSkipBytes(SlCalcConvMemLen(sld->conv) * sld->length);
+ return true;
+ }
+
+ return false;
+}
+
+/**
+ * Calculate the size of an object.
+ * @param object to be measured
+ * @param sld The SaveLoad description of the object so we know how to manipulate it
+ * @return size of given objetc
+ */
+size_t SlCalcObjLength(const void *object, const SaveLoad *sld)
+{
+ size_t length = 0;
+
+ /* Need to determine the length and write a length tag. */
+ for (; sld->cmd != SL_END; sld++) {
+ length += SlCalcObjMemberLength(object, sld);
+ }
+ return length;
+}
+
+size_t SlCalcObjMemberLength(const void *object, const SaveLoad *sld)
+{
+ assert(_sl.save);
+
+ switch (sld->cmd) {
+ case SL_VAR:
+ case SL_REF:
+ case SL_ARR:
+ case SL_STR:
+ case SL_LST:
+ /* CONDITIONAL saveload types depend on the savegame version */
+ if (!SlIsObjectValidInSavegame(sld)) break;
+
+ switch (sld->cmd) {
+ case SL_VAR: return SlCalcConvFileLen(sld->conv);
+ case SL_REF: return SlCalcRefLen();
+ case SL_ARR: return SlCalcArrayLen(sld->length, sld->conv);
+ case SL_STR: return SlCalcStringLen(GetVariableAddress(object, sld), sld->length, sld->conv);
+ case SL_LST: return SlCalcListLen(GetVariableAddress(object, sld));
+ default: NOT_REACHED();
+ }
+ break;
+ case SL_WRITEBYTE: return 1; // a byte is logically of size 1
+ case SL_VEH_INCLUDE: return SlCalcObjLength(object, GetVehicleDescription(VEH_END));
+ default: NOT_REACHED();
+ }
+ return 0;
+}
+
+
+bool SlObjectMember(void *ptr, const SaveLoad *sld)
+{
+ VarType conv = GB(sld->conv, 0, 8);
+ switch (sld->cmd) {
+ case SL_VAR:
+ case SL_REF:
+ case SL_ARR:
+ case SL_STR:
+ case SL_LST:
+ /* CONDITIONAL saveload types depend on the savegame version */
+ if (!SlIsObjectValidInSavegame(sld)) return false;
+ if (SlSkipVariableOnLoad(sld)) return false;
+
+ switch (sld->cmd) {
+ case SL_VAR: SlSaveLoadConv(ptr, conv); break;
+ case SL_REF: // Reference variable, translate
+ if (_sl.save) {
+ SlWriteUint32(ReferenceToInt(*(void**)ptr, (SLRefType)conv));
+ } else {
+ *(void**)ptr = IntToReference(CheckSavegameVersion(69) ? SlReadUint16() : SlReadUint32(), (SLRefType)conv);
+ }
+ break;
+ case SL_ARR: SlArray(ptr, sld->length, conv); break;
+ case SL_STR: SlString(ptr, sld->length, conv); break;
+ case SL_LST: SlList(ptr, (SLRefType)conv); break;
+ default: NOT_REACHED();
+ }
+ break;
+
+ /* SL_WRITEBYTE translates a value of a variable to another one upon
+ * saving or loading.
+ * XXX - variable renaming abuse
+ * game_value: the value of the variable ingame is abused by sld->version_from
+ * file_value: the value of the variable in the savegame is abused by sld->version_to */
+ case SL_WRITEBYTE:
+ if (_sl.save) {
+ SlWriteByte(sld->version_to);
+ } else {
+ *(byte*)ptr = sld->version_from;
+ }
+ break;
+
+ /* SL_VEH_INCLUDE loads common code for vehicles */
+ case SL_VEH_INCLUDE:
+ SlObject(ptr, GetVehicleDescription(VEH_END));
+ break;
+ default: NOT_REACHED();
+ }
+ return true;
+}
+
+/**
+ * Main SaveLoad function.
+ * @param object The object that is being saved or loaded
+ * @param sld The SaveLoad description of the object so we know how to manipulate it
+ */
+void SlObject(void *object, const SaveLoad *sld)
+{
+ /* Automatically calculate the length? */
+ if (_sl.need_length != NL_NONE) {
+ SlSetLength(SlCalcObjLength(object, sld));
+ if (_sl.need_length == NL_CALCLENGTH) return;
+ }
+
+ for (; sld->cmd != SL_END; sld++) {
+ void *ptr = sld->global ? sld->address : GetVariableAddress(object, sld);
+ SlObjectMember(ptr, sld);
+ }
+}
+
+/**
+ * Save or Load (a list of) global variables
+ * @param sldg The global variable that is being loaded or saved
+ */
+void SlGlobList(const SaveLoadGlobVarList *sldg)
+{
+ SlObject(NULL, (const SaveLoad*)sldg);
+}
+
+/**
+ * Do something of which I have no idea what it is :P
+ * @param proc The callback procedure that is called
+ * @param arg The variable that will be used for the callback procedure
+ */
+void SlAutolength(AutolengthProc *proc, void *arg)
+{
+ size_t offs;
+
+ assert(_sl.save);
+
+ /* Tell it to calculate the length */
+ _sl.need_length = NL_CALCLENGTH;
+ _sl.obj_len = 0;
+ proc(arg);
+
+ /* Setup length */
+ _sl.need_length = NL_WANTLENGTH;
+ SlSetLength(_sl.obj_len);
+
+ offs = SlGetOffs() + _sl.obj_len;
+
+ /* And write the stuff */
+ proc(arg);
+
+ if (offs != SlGetOffs()) SlError(STR_GAME_SAVELOAD_ERROR_BROKEN_SAVEGAME, "Invalid chunk size");
+}
+
+/**
+ * Load a chunk of data (eg vehicles, stations, etc.)
+ * @param ch The chunkhandler that will be used for the operation
+ */
+static void SlLoadChunk(const ChunkHandler *ch)
+{
+ byte m = SlReadByte();
+ size_t len;
+ size_t endoffs;
+
+ _sl.block_mode = m;
+ _sl.obj_len = 0;
+
+ switch (m) {
+ case CH_ARRAY:
+ _sl.array_index = 0;
+ ch->load_proc();
+ break;
+ case CH_SPARSE_ARRAY:
+ ch->load_proc();
+ break;
+ default:
+ if ((m & 0xF) == CH_RIFF) {
+ /* Read length */
+ len = (SlReadByte() << 16) | ((m >> 4) << 24);
+ len += SlReadUint16();
+ _sl.obj_len = len;
+ endoffs = SlGetOffs() + len;
+ ch->load_proc();
+ if (SlGetOffs() != endoffs) SlError(STR_GAME_SAVELOAD_ERROR_BROKEN_SAVEGAME, "Invalid chunk size");
+ } else {
+ SlError(STR_GAME_SAVELOAD_ERROR_BROKEN_SAVEGAME, "Invalid chunk type");
+ }
+ break;
+ }
+}
+
+/* Stub Chunk handlers to only calculate length and do nothing else */
+static ChunkSaveLoadProc *_tmp_proc_1;
+static inline void SlStubSaveProc2(void *arg) {_tmp_proc_1();}
+static void SlStubSaveProc() {SlAutolength(SlStubSaveProc2, NULL);}
+
+/** Save a chunk of data (eg. vehicles, stations, etc.). Each chunk is
+ * prefixed by an ID identifying it, followed by data, and terminator where appropiate
+ * @param ch The chunkhandler that will be used for the operation
+ */
+static void SlSaveChunk(const ChunkHandler *ch)
+{
+ ChunkSaveLoadProc *proc = ch->save_proc;
+
+ /* Don't save any chunk information if there is no save handler. */
+ if (proc == NULL) return;
+
+ SlWriteUint32(ch->id);
+ DEBUG(sl, 2, "Saving chunk %c%c%c%c", ch->id >> 24, ch->id >> 16, ch->id >> 8, ch->id);
+
+ if (ch->flags & CH_AUTO_LENGTH) {
+ /* Need to calculate the length. Solve that by calling SlAutoLength in the save_proc. */
+ _tmp_proc_1 = proc;
+ proc = SlStubSaveProc;
+ }
+
+ _sl.block_mode = ch->flags & CH_TYPE_MASK;
+ switch (ch->flags & CH_TYPE_MASK) {
+ case CH_RIFF:
+ _sl.need_length = NL_WANTLENGTH;
+ proc();
+ break;
+ case CH_ARRAY:
+ _sl.last_array_index = 0;
+ SlWriteByte(CH_ARRAY);
+ proc();
+ SlWriteArrayLength(0); // Terminate arrays
+ break;
+ case CH_SPARSE_ARRAY:
+ SlWriteByte(CH_SPARSE_ARRAY);
+ proc();
+ SlWriteArrayLength(0); // Terminate arrays
+ break;
+ default: NOT_REACHED();
+ }
+}
+
+/** Save all chunks */
+static void SlSaveChunks()
+{
+ const ChunkHandler *ch;
+ const ChunkHandler* const *chsc;
+ uint p;
+
+ for (p = 0; p != CH_NUM_PRI_LEVELS; p++) {
+ for (chsc = _sl.chs; (ch = *chsc++) != NULL;) {
+ while (true) {
+ if (((ch->flags >> CH_PRI_SHL) & (CH_NUM_PRI_LEVELS - 1)) == p)
+ SlSaveChunk(ch);
+ if (ch->flags & CH_LAST)
+ break;
+ ch++;
+ }
+ }
+ }
+
+ /* Terminator */
+ SlWriteUint32(0);
+}
+
+/** Find the ChunkHandler that will be used for processing the found
+ * chunk in the savegame or in memory
+ * @param id the chunk in question
+ * @return returns the appropiate chunkhandler
+ */
+static const ChunkHandler *SlFindChunkHandler(uint32 id)
+{
+ const ChunkHandler *ch;
+ const ChunkHandler *const *chsc;
+ for (chsc = _sl.chs; (ch = *chsc++) != NULL;) {
+ for (;;) {
+ if (ch->id == id) return ch;
+ if (ch->flags & CH_LAST) break;
+ ch++;
+ }
+ }
+ return NULL;
+}
+
+/** Load all chunks */
+static void SlLoadChunks()
+{
+ uint32 id;
+ const ChunkHandler *ch;
+
+ for (id = SlReadUint32(); id != 0; id = SlReadUint32()) {
+ DEBUG(sl, 2, "Loading chunk %c%c%c%c", id >> 24, id >> 16, id >> 8, id);
+
+ ch = SlFindChunkHandler(id);
+ if (ch == NULL) SlError(STR_GAME_SAVELOAD_ERROR_BROKEN_SAVEGAME, "Unknown chunk type");
+ SlLoadChunk(ch);
+ }
+}
+
+/*******************************************
+ ********** START OF LZO CODE **************
+ *******************************************/
+#define LZO_SIZE 8192
+
+#include "../minilzo.h"
+
+static size_t ReadLZO()
+{
+ byte out[LZO_SIZE + LZO_SIZE / 64 + 16 + 3 + 8];
+ uint32 tmp[2];
+ uint32 size;
+ uint len;
+
+ /* Read header*/
+ if (fread(tmp, sizeof(tmp), 1, _sl.fh) != 1) SlError(STR_GAME_SAVELOAD_ERROR_FILE_NOT_READABLE, "File read failed");
+
+ /* Check if size is bad */
+ ((uint32*)out)[0] = size = tmp[1];
+
+ if (_sl_version != 0) {
+ tmp[0] = TO_BE32(tmp[0]);
+ size = TO_BE32(size);
+ }
+
+ if (size >= sizeof(out)) SlError(STR_GAME_SAVELOAD_ERROR_BROKEN_SAVEGAME, "Inconsistent size");
+
+ /* Read block */
+ if (fread(out + sizeof(uint32), size, 1, _sl.fh) != 1) SlError(STR_GAME_SAVELOAD_ERROR_FILE_NOT_READABLE);
+
+ /* Verify checksum */
+ if (tmp[0] != lzo_adler32(0, out, size + sizeof(uint32))) SlError(STR_GAME_SAVELOAD_ERROR_BROKEN_SAVEGAME, "Bad checksum");
+
+ /* Decompress */
+ lzo1x_decompress(out + sizeof(uint32)*1, size, _sl.buf, &len, NULL);
+ return len;
+}
+
+/* p contains the pointer to the buffer, len contains the pointer to the length.
+ * len bytes will be written, p and l will be updated to reflect the next buffer. */
+static void WriteLZO(size_t size)
+{
+ byte out[LZO_SIZE + LZO_SIZE / 64 + 16 + 3 + 8];
+ byte wrkmem[sizeof(byte*)*4096];
+ uint outlen;
+
+ lzo1x_1_compress(_sl.buf, (lzo_uint)size, out + sizeof(uint32)*2, &outlen, wrkmem);
+ ((uint32*)out)[1] = TO_BE32(outlen);
+ ((uint32*)out)[0] = TO_BE32(lzo_adler32(0, out + sizeof(uint32), outlen + sizeof(uint32)));
+ if (fwrite(out, outlen + sizeof(uint32)*2, 1, _sl.fh) != 1) SlError(STR_GAME_SAVELOAD_ERROR_FILE_NOT_WRITEABLE);
+}
+
+static bool InitLZO()
+{
+ _sl.bufsize = LZO_SIZE;
+ _sl.buf = _sl.buf_ori = MallocT(LZO_SIZE);
+ return true;
+}
+
+static void UninitLZO()
+{
+ free(_sl.buf_ori);
+}
+
+/*********************************************
+ ******** START OF NOCOMP CODE (uncompressed)*
+ *********************************************/
+static size_t ReadNoComp()
+{
+ return fread(_sl.buf, 1, LZO_SIZE, _sl.fh);
+}
+
+static void WriteNoComp(size_t size)
+{
+ if (fwrite(_sl.buf, 1, size, _sl.fh) != size) SlError(STR_GAME_SAVELOAD_ERROR_FILE_NOT_WRITEABLE);
+}
+
+static bool InitNoComp()
+{
+ _sl.bufsize = LZO_SIZE;
+ _sl.buf = _sl.buf_ori = MallocT(LZO_SIZE);
+ return true;
+}
+
+static void UninitNoComp()
+{
+ free(_sl.buf_ori);
+}
+
+/********************************************
+ ********** START OF MEMORY CODE (in ram)****
+ ********************************************/
+
+#include "../table/sprites.h"
+#include "../gui.h"
+
+struct ThreadedSave {
+ uint count;
+ byte ff_state;
+ bool saveinprogress;
+ CursorID cursor;
+};
+
+/* A maximum size of of 128K * 500 = 64.000KB savegames */
+STATIC_OLD_POOL(Savegame, byte, 17, 500, NULL, NULL)
+static ThreadedSave _ts;
+
+static bool InitMem()
+{
+ _ts.count = 0;
+
+ _Savegame_pool.CleanPool();
+ _Savegame_pool.AddBlockToPool();
+
+ /* A block from the pool is a contigious area of memory, so it is safe to write to it sequentially */
+ _sl.bufsize = GetSavegamePoolSize();
+ _sl.buf = GetSavegame(_ts.count);
+ return true;
+}
+
+static void UnInitMem()
+{
+ _Savegame_pool.CleanPool();
+}
+
+static void WriteMem(size_t size)
+{
+ _ts.count += (uint)size;
+ /* Allocate new block and new buffer-pointer */
+ _Savegame_pool.AddBlockIfNeeded(_ts.count);
+ _sl.buf = GetSavegame(_ts.count);
+}
+
+/********************************************
+ ********** START OF ZLIB CODE **************
+ ********************************************/
+
+#if defined(WITH_ZLIB)
+#include
+
+static z_stream _z;
+
+static bool InitReadZlib()
+{
+ memset(&_z, 0, sizeof(_z));
+ if (inflateInit(&_z) != Z_OK) return false;
+
+ _sl.bufsize = 4096;
+ _sl.buf = _sl.buf_ori = MallocT(4096 + 4096); // also contains fread buffer
+ return true;
+}
+
+static size_t ReadZlib()
+{
+ int r;
+
+ _z.next_out = _sl.buf;
+ _z.avail_out = 4096;
+
+ do {
+ /* read more bytes from the file? */
+ if (_z.avail_in == 0) {
+ _z.avail_in = (uint)fread(_z.next_in = _sl.buf + 4096, 1, 4096, _sl.fh);
+ }
+
+ /* inflate the data */
+ r = inflate(&_z, 0);
+ if (r == Z_STREAM_END)
+ break;
+
+ if (r != Z_OK) SlError(STR_GAME_SAVELOAD_ERROR_BROKEN_INTERNAL_ERROR, "inflate() failed");
+ } while (_z.avail_out);
+
+ return 4096 - _z.avail_out;
+}
+
+static void UninitReadZlib()
+{
+ inflateEnd(&_z);
+ free(_sl.buf_ori);
+}
+
+static bool InitWriteZlib()
+{
+ memset(&_z, 0, sizeof(_z));
+ if (deflateInit(&_z, 6) != Z_OK) return false;
+
+ _sl.bufsize = 4096;
+ _sl.buf = _sl.buf_ori = MallocT(4096); // also contains fread buffer
+ return true;
+}
+
+static void WriteZlibLoop(z_streamp z, byte *p, size_t len, int mode)
+{
+ byte buf[1024]; // output buffer
+ int r;
+ uint n;
+ z->next_in = p;
+ z->avail_in = (uInt)len;
+ do {
+ z->next_out = buf;
+ z->avail_out = sizeof(buf);
+ r = deflate(z, mode);
+ /* bytes were emitted? */
+ if ((n = sizeof(buf) - z->avail_out) != 0) {
+ if (fwrite(buf, n, 1, _sl.fh) != 1) SlError(STR_GAME_SAVELOAD_ERROR_FILE_NOT_WRITEABLE);
+ }
+ if (r == Z_STREAM_END)
+ break;
+ if (r != Z_OK) SlError(STR_GAME_SAVELOAD_ERROR_BROKEN_INTERNAL_ERROR, "zlib returned error code");
+ } while (z->avail_in || !z->avail_out);
+}
+
+static void WriteZlib(size_t len)
+{
+ WriteZlibLoop(&_z, _sl.buf, len, 0);
+}
+
+static void UninitWriteZlib()
+{
+ /* flush any pending output. */
+ if (_sl.fh) WriteZlibLoop(&_z, NULL, 0, Z_FINISH);
+ deflateEnd(&_z);
+ free(_sl.buf_ori);
+}
+
+#endif /* WITH_ZLIB */
+
+/*******************************************
+ ************* END OF CODE *****************
+ *******************************************/
+
+/* these define the chunks */
+extern const ChunkHandler _gamelog_chunk_handlers[];
+extern const ChunkHandler _map_chunk_handlers[];
+extern const ChunkHandler _misc_chunk_handlers[];
+extern const ChunkHandler _name_chunk_handlers[];
+extern const ChunkHandler _cheat_chunk_handlers[] ;
+extern const ChunkHandler _setting_chunk_handlers[];
+extern const ChunkHandler _company_chunk_handlers[];
+extern const ChunkHandler _engine_chunk_handlers[];
+extern const ChunkHandler _veh_chunk_handlers[];
+extern const ChunkHandler _waypoint_chunk_handlers[];
+extern const ChunkHandler _depot_chunk_handlers[];
+extern const ChunkHandler _order_chunk_handlers[];
+extern const ChunkHandler _town_chunk_handlers[];
+extern const ChunkHandler _sign_chunk_handlers[];
+extern const ChunkHandler _station_chunk_handlers[];
+extern const ChunkHandler _industry_chunk_handlers[];
+extern const ChunkHandler _economy_chunk_handlers[];
+extern const ChunkHandler _subsidy_chunk_handlers[];
+extern const ChunkHandler _animated_tile_chunk_handlers[];
+extern const ChunkHandler _newgrf_chunk_handlers[];
+extern const ChunkHandler _group_chunk_handlers[];
+extern const ChunkHandler _cargopacket_chunk_handlers[];
+extern const ChunkHandler _autoreplace_chunk_handlers[];
+
+static const ChunkHandler * const _chunk_handlers[] = {
+ _gamelog_chunk_handlers,
+ _map_chunk_handlers,
+ _misc_chunk_handlers,
+ _name_chunk_handlers,
+ _cheat_chunk_handlers,
+ _setting_chunk_handlers,
+ _veh_chunk_handlers,
+ _waypoint_chunk_handlers,
+ _depot_chunk_handlers,
+ _order_chunk_handlers,
+ _industry_chunk_handlers,
+ _economy_chunk_handlers,
+ _subsidy_chunk_handlers,
+ _engine_chunk_handlers,
+ _town_chunk_handlers,
+ _sign_chunk_handlers,
+ _station_chunk_handlers,
+ _company_chunk_handlers,
+ _animated_tile_chunk_handlers,
+ _newgrf_chunk_handlers,
+ _group_chunk_handlers,
+ _cargopacket_chunk_handlers,
+ _autoreplace_chunk_handlers,
+ NULL,
+};
+
+/**
+ * Pointers cannot be saved to a savegame, so this functions gets
+ * the index of the item, and if not available, it hussles with
+ * pointers (looks really bad :()
+ * Remember that a NULL item has value 0, and all
+ * indeces have +1, so vehicle 0 is saved as index 1.
+ * @param obj The object that we want to get the index of
+ * @param rt SLRefType type of the object the index is being sought of
+ * @return Return the pointer converted to an index of the type pointed to
+ */
+static uint ReferenceToInt(const void *obj, SLRefType rt)
+{
+ if (obj == NULL) return 0;
+
+ switch (rt) {
+ case REF_VEHICLE_OLD: // Old vehicles we save as new onces
+ case REF_VEHICLE: return ((const Vehicle*)obj)->index + 1;
+ case REF_STATION: return ((const Station*)obj)->index + 1;
+ case REF_TOWN: return ((const Town*)obj)->index + 1;
+ case REF_ORDER: return ((const Order*)obj)->index + 1;
+ case REF_ROADSTOPS: return ((const RoadStop*)obj)->index + 1;
+ case REF_ENGINE_RENEWS: return ((const EngineRenew*)obj)->index + 1;
+ case REF_CARGO_PACKET: return ((const CargoPacket*)obj)->index + 1;
+ case REF_ORDERLIST: return ((const OrderList*)obj)->index + 1;
+ default: NOT_REACHED();
+ }
+
+ return 0; // avoid compiler warning
+}
+
+/**
+ * Pointers cannot be loaded from a savegame, so this function
+ * gets the index from the savegame and returns the appropiate
+ * pointer from the already loaded base.
+ * Remember that an index of 0 is a NULL pointer so all indeces
+ * are +1 so vehicle 0 is saved as 1.
+ * @param index The index that is being converted to a pointer
+ * @param rt SLRefType type of the object the pointer is sought of
+ * @return Return the index converted to a pointer of any type
+ */
+static void *IntToReference(uint index, SLRefType rt)
+{
+ /* After version 4.3 REF_VEHICLE_OLD is saved as REF_VEHICLE,
+ * and should be loaded like that */
+ if (rt == REF_VEHICLE_OLD && !CheckSavegameVersionOldStyle(4, 4)) {
+ rt = REF_VEHICLE;
+ }
+
+ /* No need to look up NULL pointers, just return immediately */
+ if (rt != REF_VEHICLE_OLD && index == 0) {
+ return NULL;
+ }
+
+ index--; // correct for the NULL index
+
+ switch (rt) {
+ case REF_ORDERLIST:
+ if (_OrderList_pool.AddBlockIfNeeded(index)) return GetOrderList(index);
+ error("Orders: failed loading savegame: too many order lists");
+
+ case REF_ORDER:
+ if (_Order_pool.AddBlockIfNeeded(index)) return GetOrder(index);
+ error("Orders: failed loading savegame: too many orders");
+
+ case REF_VEHICLE:
+ if (_Vehicle_pool.AddBlockIfNeeded(index)) return GetVehicle(index);
+ error("Vehicles: failed loading savegame: too many vehicles");
+
+ case REF_STATION:
+ if (_Station_pool.AddBlockIfNeeded(index)) return GetStation(index);
+ error("Stations: failed loading savegame: too many stations");
+
+ case REF_TOWN:
+ if (_Town_pool.AddBlockIfNeeded(index)) return GetTown(index);
+ error("Towns: failed loading savegame: too many towns");
+
+ case REF_ROADSTOPS:
+ if (_RoadStop_pool.AddBlockIfNeeded(index)) return GetRoadStop(index);
+ error("RoadStops: failed loading savegame: too many RoadStops");
+
+ case REF_ENGINE_RENEWS:
+ if (_EngineRenew_pool.AddBlockIfNeeded(index)) return GetEngineRenew(index);
+ error("EngineRenews: failed loading savegame: too many EngineRenews");
+
+ case REF_CARGO_PACKET:
+ if (_CargoPacket_pool.AddBlockIfNeeded(index)) return GetCargoPacket(index);
+ error("CargoPackets: failed loading savegame: too many Cargo packets");
+
+ case REF_VEHICLE_OLD:
+ /* Old vehicles were saved differently:
+ * invalid vehicle was 0xFFFF,
+ * and the index was not - 1.. correct for this */
+ index++;
+ if (index == INVALID_VEHICLE) return NULL;
+
+ if (_Vehicle_pool.AddBlockIfNeeded(index)) return GetVehicle(index);
+ error("Vehicles: failed loading savegame: too many vehicles");
+
+ default: NOT_REACHED();
+ }
+
+ return NULL;
+}
+
+/** The format for a reader/writer type of a savegame */
+struct SaveLoadFormat {
+ const char *name; ///< name of the compressor/decompressor (debug-only)
+ uint32 tag; ///< the 4-letter tag by which it is identified in the savegame
+
+ bool (*init_read)(); ///< function executed upon initalization of the loader
+ ReaderProc *reader; ///< function that loads the data from the file
+ void (*uninit_read)(); ///< function executed when reading is finished
+
+ bool (*init_write)(); ///< function executed upon intialization of the saver
+ WriterProc *writer; ///< function that saves the data to the file
+ void (*uninit_write)(); ///< function executed when writing is done
+};
+
+static const SaveLoadFormat _saveload_formats[] = {
+ {"memory", 0, NULL, NULL, NULL, InitMem, WriteMem, UnInitMem},
+ {"lzo", TO_BE32X('OTTD'), InitLZO, ReadLZO, UninitLZO, InitLZO, WriteLZO, UninitLZO},
+ {"none", TO_BE32X('OTTN'), InitNoComp, ReadNoComp, UninitNoComp, InitNoComp, WriteNoComp, UninitNoComp},
+#if defined(WITH_ZLIB)
+ {"zlib", TO_BE32X('OTTZ'), InitReadZlib, ReadZlib, UninitReadZlib, InitWriteZlib, WriteZlib, UninitWriteZlib},
+#else
+ {"zlib", TO_BE32X('OTTZ'), NULL, NULL, NULL, NULL, NULL, NULL},
+#endif
+};
+
+/**
+ * Return the savegameformat of the game. Whether it was create with ZLIB compression
+ * uncompressed, or another type
+ * @param s Name of the savegame format. If NULL it picks the first available one
+ * @return Pointer to SaveLoadFormat struct giving all characteristics of this type of savegame
+ */
+static const SaveLoadFormat *GetSavegameFormat(const char *s)
+{
+ const SaveLoadFormat *def = endof(_saveload_formats) - 1;
+
+ /* find default savegame format, the highest one with which files can be written */
+ while (!def->init_write) def--;
+
+ if (s != NULL && s[0] != '\0') {
+ const SaveLoadFormat *slf;
+ for (slf = &_saveload_formats[0]; slf != endof(_saveload_formats); slf++) {
+ if (slf->init_write != NULL && strcmp(s, slf->name) == 0)
+ return slf;
+ }
+
+ ShowInfoF("Savegame format '%s' is not available. Reverting to '%s'.", s, def->name);
+ }
+ return def;
+}
+
+/* actual loader/saver function */
+void InitializeGame(uint size_x, uint size_y, bool reset_date);
+extern bool AfterLoadGame();
+extern bool LoadOldSaveGame(const char *file);
+
+/** Small helper function to close the to be loaded savegame an signal error */
+static inline SaveOrLoadResult AbortSaveLoad()
+{
+ if (_sl.fh != NULL) fclose(_sl.fh);
+
+ _sl.fh = NULL;
+ return SL_ERROR;
+}
+
+/** Update the gui accordingly when starting saving
+ * and set locks on saveload. Also turn off fast-forward cause with that
+ * saving takes Aaaaages */
+static void SaveFileStart()
+{
+ _ts.ff_state = _fast_forward;
+ _fast_forward = 0;
+ if (_cursor.sprite == SPR_CURSOR_MOUSE) SetMouseCursor(SPR_CURSOR_ZZZ, PAL_NONE);
+
+ InvalidateWindowData(WC_STATUS_BAR, 0, SBI_SAVELOAD_START);
+ _ts.saveinprogress = true;
+}
+
+/** Update the gui accordingly when saving is done and release locks
+ * on saveload */
+static void SaveFileDone()
+{
+ if (_game_mode != GM_MENU) _fast_forward = _ts.ff_state;
+ if (_cursor.sprite == SPR_CURSOR_ZZZ) SetMouseCursor(SPR_CURSOR_MOUSE, PAL_NONE);
+
+ InvalidateWindowData(WC_STATUS_BAR, 0, SBI_SAVELOAD_FINISH);
+ _ts.saveinprogress = false;
+}
+
+/** Set the error message from outside of the actual loading/saving of the game (AfterLoadGame and friends) */
+void SetSaveLoadError(StringID str)
+{
+ _sl.error_str = str;
+}
+
+/** Get the string representation of the error message */
+const char *GetSaveLoadErrorString()
+{
+ SetDParam(0, _sl.error_str);
+ SetDParamStr(1, _sl.extra_msg);
+
+ static char err_str[512];
+ GetString(err_str, _sl.save ? STR_4007_GAME_SAVE_FAILED : STR_4009_GAME_LOAD_FAILED, lastof(err_str));
+ return err_str;
+}
+
+/** Show a gui message when saving has failed */
+static void SaveFileError()
+{
+ SetDParamStr(0, GetSaveLoadErrorString());
+ ShowErrorMessage(STR_JUST_RAW_STRING, STR_NULL, 0, 0);
+ SaveFileDone();
+}
+
+/** We have written the whole game into memory, _Savegame_pool, now find
+ * and appropiate compressor and start writing to file.
+ */
+static SaveOrLoadResult SaveFileToDisk(bool threaded)
+{
+ const SaveLoadFormat *fmt;
+ uint32 hdr[2];
+
+ _sl.excpt_uninit = NULL;
+ try {
+ fmt = GetSavegameFormat(_savegame_format);
+
+ /* We have written our stuff to memory, now write it to file! */
+ hdr[0] = fmt->tag;
+ hdr[1] = TO_BE32(SAVEGAME_VERSION << 16);
+ if (fwrite(hdr, sizeof(hdr), 1, _sl.fh) != 1) SlError(STR_GAME_SAVELOAD_ERROR_FILE_NOT_WRITEABLE);
+
+ if (!fmt->init_write()) SlError(STR_GAME_SAVELOAD_ERROR_BROKEN_INTERNAL_ERROR, "cannot initialize compressor");
+
+ {
+ uint i;
+ uint count = 1 << Savegame_POOL_BLOCK_SIZE_BITS;
+
+ if (_ts.count != _sl.offs_base) SlError(STR_GAME_SAVELOAD_ERROR_BROKEN_SAVEGAME, "Unexpected size of chunk");
+ for (i = 0; i != _Savegame_pool.GetBlockCount() - 1; i++) {
+ _sl.buf = _Savegame_pool.blocks[i];
+ fmt->writer(count);
+ }
+
+ /* The last block is (almost) always not fully filled, so only write away
+ * as much data as it is in there */
+ _sl.buf = _Savegame_pool.blocks[i];
+ fmt->writer(_ts.count - (i * count));
+ }
+
+ fmt->uninit_write();
+ if (_ts.count != _sl.offs_base) SlError(STR_GAME_SAVELOAD_ERROR_BROKEN_SAVEGAME, "Unexpected size of chunk");
+ GetSavegameFormat("memory")->uninit_write(); // clean the memorypool
+ fclose(_sl.fh);
+
+ if (threaded) SetAsyncSaveFinish(SaveFileDone);
+
+ return SL_OK;
+ }
+ catch (...) {
+ AbortSaveLoad();
+ if (_sl.excpt_uninit != NULL) _sl.excpt_uninit();
+
+ /* Skip the "color" character */
+ DEBUG(sl, 0, GetSaveLoadErrorString() + 3);
+
+ if (threaded) {
+ SetAsyncSaveFinish(SaveFileError);
+ } else {
+ SaveFileError();
+ }
+ return SL_ERROR;
+ }
+}
+
+static void SaveFileToDiskThread(void *arg)
+{
+ SaveFileToDisk(true);
+}
+
+void WaitTillSaved()
+{
+ if (_save_thread == NULL) return;
+
+ _save_thread->Join();
+ delete _save_thread;
+ _save_thread = NULL;
+}
+
+/**
+ * Main Save or Load function where the high-level saveload functions are
+ * handled. It opens the savegame, selects format and checks versions
+ * @param filename The name of the savegame being created/loaded
+ * @param mode Save or load. Load can also be a TTD(Patch) game. Use SL_LOAD, SL_OLD_LOAD or SL_SAVE
+ * @return Return the results of the action. SL_OK, SL_ERROR or SL_REINIT ("unload" the game)
+ */
+SaveOrLoadResult SaveOrLoad(const char *filename, int mode, Subdirectory sb)
+{
+ uint32 hdr[2];
+ const SaveLoadFormat *fmt;
+
+ /* An instance of saving is already active, so don't go saving again */
+ if (_ts.saveinprogress && mode == SL_SAVE) {
+ /* if not an autosave, but a user action, show error message */
+ if (!_do_autosave) ShowErrorMessage(INVALID_STRING_ID, STR_SAVE_STILL_IN_PROGRESS, 0, 0);
+ return SL_OK;
+ }
+ WaitTillSaved();
+
+ _next_offs = 0;
+
+ /* Load a TTDLX or TTDPatch game */
+ if (mode == SL_OLD_LOAD) {
+ InitializeGame(256, 256, true); // set a mapsize of 256x256 for TTDPatch games or it might get confused
+ GamelogReset();
+ if (!LoadOldSaveGame(filename)) return SL_REINIT;
+ _sl_version = 0;
+ _sl_minor_version = 0;
+ GamelogStartAction(GLAT_LOAD);
+ if (!AfterLoadGame()) {
+ GamelogStopAction();
+ return SL_REINIT;
+ }
+ GamelogStopAction();
+ return SL_OK;
+ }
+
+ _sl.excpt_uninit = NULL;
+ try {
+ _sl.fh = (mode == SL_SAVE) ? FioFOpenFile(filename, "wb", sb) : FioFOpenFile(filename, "rb", sb);
+
+ /* Make it a little easier to load savegames from the console */
+ if (_sl.fh == NULL && mode == SL_LOAD) _sl.fh = FioFOpenFile(filename, "rb", SAVE_DIR);
+ if (_sl.fh == NULL && mode == SL_LOAD) _sl.fh = FioFOpenFile(filename, "rb", BASE_DIR);
+
+ if (_sl.fh == NULL) {
+ SlError(mode == SL_SAVE ? STR_GAME_SAVELOAD_ERROR_FILE_NOT_WRITEABLE : STR_GAME_SAVELOAD_ERROR_FILE_NOT_READABLE);
+ }
+
+ _sl.bufe = _sl.bufp = NULL;
+ _sl.offs_base = 0;
+ _sl.save = (mode != 0);
+ _sl.chs = _chunk_handlers;
+
+ /* General tactic is to first save the game to memory, then use an available writer
+ * to write it to file, either in threaded mode if possible, or single-threaded */
+ if (mode == SL_SAVE) { /* SAVE game */
+ DEBUG(desync, 1, "save: %s\n", filename);
+ fmt = GetSavegameFormat("memory"); // write to memory
+
+ _sl.write_bytes = fmt->writer;
+ _sl.excpt_uninit = fmt->uninit_write;
+ if (!fmt->init_write()) {
+ DEBUG(sl, 0, "Initializing writer '%s' failed.", fmt->name);
+ return AbortSaveLoad();
+ }
+
+ _sl_version = SAVEGAME_VERSION;
+
+ SaveViewportBeforeSaveGame();
+ SlSaveChunks();
+ SlWriteFill(); // flush the save buffer
+
+ SaveFileStart();
+ if (_network_server ||
+ (_save_thread = ThreadObject::New(&SaveFileToDiskThread, NULL)) == NULL) {
+ if (!_network_server) DEBUG(sl, 1, "Cannot create savegame thread, reverting to single-threaded mode...");
+
+ SaveOrLoadResult result = SaveFileToDisk(false);
+ SaveFileDone();
+
+ return result;
+ }
+ } else { /* LOAD game */
+ assert(mode == SL_LOAD);
+ DEBUG(desync, 1, "load: %s\n", filename);
+
+ if (fread(hdr, sizeof(hdr), 1, _sl.fh) != 1) SlError(STR_GAME_SAVELOAD_ERROR_FILE_NOT_READABLE);
+
+ /* see if we have any loader for this type. */
+ for (fmt = _saveload_formats; ; fmt++) {
+ /* No loader found, treat as version 0 and use LZO format */
+ if (fmt == endof(_saveload_formats)) {
+ DEBUG(sl, 0, "Unknown savegame type, trying to load it as the buggy format");
+ #if defined(WINCE)
+ /* Of course some system had not to support rewind ;) */
+ fseek(_sl.fh, 0L, SEEK_SET);
+ clearerr(_sl.fh);
+ #else
+ rewind(_sl.fh);
+ #endif
+ _sl_version = 0;
+ _sl_minor_version = 0;
+ fmt = _saveload_formats + 1; // LZO
+ break;
+ }
+
+ if (fmt->tag == hdr[0]) {
+ /* check version number */
+ _sl_version = TO_BE32(hdr[1]) >> 16;
+ /* Minor is not used anymore from version 18.0, but it is still needed
+ * in versions before that (4 cases) which can't be removed easy.
+ * Therefor it is loaded, but never saved (or, it saves a 0 in any scenario).
+ * So never EVER use this minor version again. -- TrueLight -- 22-11-2005 */
+ _sl_minor_version = (TO_BE32(hdr[1]) >> 8) & 0xFF;
+
+ DEBUG(sl, 1, "Loading savegame version %d", _sl_version);
+
+ /* Is the version higher than the current? */
+ if (_sl_version > SAVEGAME_VERSION) SlError(STR_GAME_SAVELOAD_ERROR_TOO_NEW_SAVEGAME);
+ break;
+ }
+ }
+
+ _sl.read_bytes = fmt->reader;
+ _sl.excpt_uninit = fmt->uninit_read;
+
+ /* loader for this savegame type is not implemented? */
+ if (fmt->init_read == NULL) {
+ char err_str[64];
+ snprintf(err_str, lengthof(err_str), "Loader for '%s' is not available.", fmt->name);
+ SlError(STR_GAME_SAVELOAD_ERROR_BROKEN_INTERNAL_ERROR, err_str);
+ }
+
+ if (!fmt->init_read()) {
+ char err_str[64];
+ snprintf(err_str, lengthof(err_str), "Initializing loader '%s' failed", fmt->name);
+ SlError(STR_GAME_SAVELOAD_ERROR_BROKEN_INTERNAL_ERROR, err_str);
+ }
+
+ /* Old maps were hardcoded to 256x256 and thus did not contain
+ * any mapsize information. Pre-initialize to 256x256 to not to
+ * confuse old games */
+ InitializeGame(256, 256, true);
+
+ GamelogReset();
+
+ SlLoadChunks();
+ fmt->uninit_read();
+ fclose(_sl.fh);
+
+ GamelogStartAction(GLAT_LOAD);
+
+ _savegame_type = SGT_OTTD;
+
+ /* After loading fix up savegame for any internal changes that
+ * might've occured since then. If it fails, load back the old game */
+ if (!AfterLoadGame()) {
+ GamelogStopAction();
+ return SL_REINIT;
+ }
+
+ GamelogStopAction();
+ }
+
+ return SL_OK;
+ }
+ catch (...) {
+ AbortSaveLoad();
+
+ /* deinitialize compressor. */
+ if (_sl.excpt_uninit != NULL) _sl.excpt_uninit();
+
+ /* Skip the "color" character */
+ DEBUG(sl, 0, GetSaveLoadErrorString() + 3);
+
+ /* A saver/loader exception!! reinitialize all variables to prevent crash! */
+ return (mode == SL_LOAD) ? SL_REINIT : SL_ERROR;
+ }
+}
+
+/** Do a save when exiting the game (patch option) _settings_client.gui.autosave_on_exit */
+void DoExitSave()
+{
+ SaveOrLoad("exit.sav", SL_SAVE, AUTOSAVE_DIR);
+}
+
+/**
+ * Fill the buffer with the default name for a savegame *or* screenshot.
+ * @param buf the buffer to write to.
+ * @param last the last element in the buffer.
+ */
+void GenerateDefaultSaveName(char *buf, const char *last)
+{
+ /* Check if we have a name for this map, which is the name of the first
+ * available company. When there's no company available we'll use
+ * 'Spectator' as "company" name. */
+ CompanyID cid = _local_company;
+ if (!IsValidCompanyID(cid)) {
+ const Company *c;
+ FOR_ALL_COMPANIES(c) {
+ cid = c->index;
+ break;
+ }
+ }
+
+ SetDParam(0, cid);
+
+ /* Insert current date */
+ switch (_settings_client.gui.date_format_in_default_names) {
+ case 0: SetDParam(1, STR_JUST_DATE_LONG); break;
+ case 1: SetDParam(1, STR_JUST_DATE_TINY); break;
+ case 2: SetDParam(1, STR_JUST_DATE_ISO); break;
+ default: NOT_REACHED();
+ }
+ SetDParam(2, _date);
+
+ /* Get the correct string (special string for when there's not company) */
+ GetString(buf, !IsValidCompanyID(cid) ? STR_GAME_SAVELOAD_SPECTATOR_SAVEGAME : STR_4004, last);
+ SanitizeFilename(buf);
+}
+
+#if 0
+/**
+ * Function to get the type of the savegame by looking at the file header.
+ * NOTICE: Not used right now, but could be used if extensions of savegames are garbled
+ * @param file Savegame to be checked
+ * @return SL_OLD_LOAD or SL_LOAD of the file
+ */
+int GetSavegameType(char *file)
+{
+ const SaveLoadFormat *fmt;
+ uint32 hdr;
+ FILE *f;
+ int mode = SL_OLD_LOAD;
+
+ f = fopen(file, "rb");
+ if (fread(&hdr, sizeof(hdr), 1, f) != 1) {
+ DEBUG(sl, 0, "Savegame is obsolete or invalid format");
+ mode = SL_LOAD; // don't try to get filename, just show name as it is written
+ } else {
+ /* see if we have any loader for this type. */
+ for (fmt = _saveload_formats; fmt != endof(_saveload_formats); fmt++) {
+ if (fmt->tag == hdr) {
+ mode = SL_LOAD; // new type of savegame
+ break;
+ }
+ }
+ }
+
+ fclose(f);
+ return mode;
+}
+#endif