24 #include "../stdafx.h" 
   26 #include "../station_base.h" 
   27 #include "../thread/thread.h" 
   29 #include "../network/network.h" 
   30 #include "../window_func.h" 
   31 #include "../strings_func.h" 
   32 #include "../core/endian_func.hpp" 
   33 #include "../vehicle_base.h" 
   34 #include "../company_func.h" 
   35 #include "../date_func.h" 
   36 #include "../autoreplace_base.h" 
   37 #include "../roadstop_base.h" 
   38 #include "../linkgraph/linkgraph.h" 
   39 #include "../linkgraph/linkgraphjob.h" 
   40 #include "../statusbar_gui.h" 
   41 #include "../fileio_func.h" 
   42 #include "../gamelog.h" 
   43 #include "../string_func.h" 
   47 #include "table/strings.h" 
   52 #include "../safeguards.h" 
  312   inline byte ReadByte()
 
  323     return *this->
bufp++;
 
  446 extern const ChunkHandler _autoreplace_chunk_handlers[];
 
  451 extern const ChunkHandler _persistent_storage_chunk_handlers[];
 
  455   _gamelog_chunk_handlers,
 
  457   _misc_chunk_handlers,
 
  458   _name_chunk_handlers,
 
  459   _cheat_chunk_handlers,
 
  460   _setting_chunk_handlers,
 
  462   _waypoint_chunk_handlers,
 
  463   _depot_chunk_handlers,
 
  464   _order_chunk_handlers,
 
  465   _industry_chunk_handlers,
 
  466   _economy_chunk_handlers,
 
  467   _subsidy_chunk_handlers,
 
  468   _cargomonitor_chunk_handlers,
 
  469   _goal_chunk_handlers,
 
  470   _story_page_chunk_handlers,
 
  471   _engine_chunk_handlers,
 
  472   _town_chunk_handlers,
 
  473   _sign_chunk_handlers,
 
  474   _station_chunk_handlers,
 
  475   _company_chunk_handlers,
 
  477   _game_chunk_handlers,
 
  478   _animated_tile_chunk_handlers,
 
  479   _newgrf_chunk_handlers,
 
  480   _group_chunk_handlers,
 
  481   _cargopacket_chunk_handlers,
 
  482   _autoreplace_chunk_handlers,
 
  483   _labelmaps_chunk_handlers,
 
  484   _linkgraph_chunk_handlers,
 
  485   _airport_chunk_handlers,
 
  486   _object_chunk_handlers,
 
  487   _persistent_storage_chunk_handlers,
 
  495 #define FOR_ALL_CHUNK_HANDLERS(ch) \ 
  496   for (const ChunkHandler * const *chsc = _chunk_handlers; *chsc != NULL; chsc++) \ 
  497     for (const ChunkHandler *ch = *chsc; ch != NULL; ch = (ch->flags & CH_LAST) ? NULL : ch + 1) 
  509   DEBUG(sl, 1, 
"Nulling pointers");
 
  512     if (ch->ptrs_proc != NULL) {
 
  513       DEBUG(sl, 2, 
"Nulling pointers for %c%c%c%c", ch->id >> 24, ch->id >> 16, ch->id >> 8, ch->id);
 
  518   DEBUG(sl, 1, 
"All pointers nulled");
 
  549   throw std::exception();
 
  561   SlError(STR_GAME_SAVELOAD_ERROR_BROKEN_SAVEGAME, msg);
 
  575   if (_exit_game) 
return;
 
  576   while (_async_save_finish != NULL) CSleep(10);
 
  578   _async_save_finish = proc;
 
  586   if (_async_save_finish == NULL) 
return;
 
  590   _async_save_finish = NULL;
 
  592   if (_save_thread != NULL) {
 
  593     _save_thread->
Join();
 
  605   return _sl.
reader->ReadByte();
 
  617 static inline int SlReadUint16()
 
  623 static inline uint32 SlReadUint32()
 
  625   uint32 x = SlReadUint16() << 16;
 
  626   return x | SlReadUint16();
 
  629 static inline uint64 SlReadUint64()
 
  631   uint32 x = SlReadUint32();
 
  632   uint32 y = SlReadUint32();
 
  633   return (uint64)x << 32 | y;
 
  636 static inline void SlWriteUint16(uint16 v)
 
  642 static inline void SlWriteUint32(uint32 v)
 
  644   SlWriteUint16(
GB(v, 16, 16));
 
  645   SlWriteUint16(
GB(v,  0, 16));
 
  648 static inline void SlWriteUint64(uint64 x)
 
  650   SlWriteUint32((uint32)(x >> 32));
 
  651   SlWriteUint32((uint32)x);
 
  718     if (i >= (1 << 14)) {
 
  719       if (i >= (1 << 21)) {
 
  720         if (i >= (1 << 28)) {
 
  721           assert(i <= UINT32_MAX); 
 
  742   return 1 + (i >= (1 << 7)) + (i >= (1 << 14)) + (i >= (1 << 21)) + (i >= (1 << 28));
 
  745 static inline uint SlReadSparseIndex()
 
  750 static inline void SlWriteSparseIndex(uint index)
 
  755 static inline uint SlReadArrayLength()
 
  760 static inline void SlWriteArrayLength(
size_t length)
 
  765 static inline uint SlGetArrayLength(
size_t length)
 
  778   static const byte conv_mem_size[] = {1, 1, 1, 2, 2, 4, 4, 8, 8, 0};
 
  779   byte length = 
GB(conv, 4, 4);
 
  781   switch (length << 4) {
 
  786       return SlReadArrayLength();
 
  789       assert(length < 
lengthof(conv_mem_size));
 
  790       return conv_mem_size[length];
 
  802   static const byte conv_file_size[] = {1, 1, 2, 2, 4, 4, 8, 8, 2};
 
  803   byte length = 
GB(conv, 0, 4);
 
  804   assert(length < 
lengthof(conv_file_size));
 
  805   return conv_file_size[length];
 
  814 void SlSetArrayIndex(uint index)
 
  817   _sl.array_index = index;
 
  820 static size_t _next_offs;
 
  835     uint length = SlReadArrayLength();
 
  845       case CH_SPARSE_ARRAY: index = (int)SlReadSparseIndex(); 
break;
 
  846       case CH_ARRAY:        index = _sl.array_index++; 
break;
 
  848         DEBUG(sl, 0, 
"SlIterateArray error");
 
  852     if (length != 0) 
return index;
 
  883           assert(length < (1 << 28));
 
  884           SlWriteUint32((uint32)((length & 0xFFFFFF) | ((length >> 24) << 28)));
 
  889             SlWriteArrayLength(1);
 
  891           SlWriteArrayLength(length + 1);
 
  893         case CH_SPARSE_ARRAY:
 
  894           SlWriteArrayLength(length + 1 + SlGetArrayLength(_sl.array_index)); 
 
  895           SlWriteSparseIndex(_sl.array_index);
 
  897         default: NOT_REACHED();
 
  905     default: NOT_REACHED();
 
  917   byte *p = (byte *)ptr;
 
  922       for (; length != 0; length--) *p++ = 
SlReadByte();
 
  927     default: NOT_REACHED();
 
  947     case SLE_VAR_BL:  
return (*(
const bool *)ptr != 0);
 
  948     case SLE_VAR_I8:  
return *(
const int8  *)ptr;
 
  949     case SLE_VAR_U8:  
return *(
const byte  *)ptr;
 
  950     case SLE_VAR_I16: 
return *(
const int16 *)ptr;
 
  951     case SLE_VAR_U16: 
return *(
const uint16*)ptr;
 
  952     case SLE_VAR_I32: 
return *(
const int32 *)ptr;
 
  953     case SLE_VAR_U32: 
return *(
const uint32*)ptr;
 
  954     case SLE_VAR_I64: 
return *(
const int64 *)ptr;
 
  955     case SLE_VAR_U64: 
return *(
const uint64*)ptr;
 
  957     default: NOT_REACHED();
 
  971     case SLE_VAR_BL:  *(
bool  *)ptr = (val != 0);  
break;
 
  972     case SLE_VAR_I8:  *(int8  *)ptr = val; 
break;
 
  973     case SLE_VAR_U8:  *(byte  *)ptr = val; 
break;
 
  974     case SLE_VAR_I16: *(int16 *)ptr = val; 
break;
 
  975     case SLE_VAR_U16: *(uint16*)ptr = val; 
break;
 
  976     case SLE_VAR_I32: *(int32 *)ptr = val; 
break;
 
  977     case SLE_VAR_U32: *(uint32*)ptr = val; 
break;
 
  978     case SLE_VAR_I64: *(int64 *)ptr = val; 
break;
 
  979     case SLE_VAR_U64: *(uint64*)ptr = val; 
break;
 
  982     default: NOT_REACHED();
 
 1002         case SLE_FILE_I8: assert(x >= -128 && x <= 127);     
SlWriteByte(x);
break;
 
 1003         case SLE_FILE_U8: assert(x >= 0 && x <= 255);        
SlWriteByte(x);
break;
 
 1004         case SLE_FILE_I16:assert(x >= -32768 && x <= 32767); SlWriteUint16(x);
break;
 
 1006         case SLE_FILE_U16:assert(x >= 0 && x <= 65535);      SlWriteUint16(x);
break;
 
 1008         case SLE_FILE_U32:                                   SlWriteUint32((uint32)x);
break;
 
 1010         case SLE_FILE_U64:                                   SlWriteUint64(x);
break;
 
 1011         default: NOT_REACHED();
 
 1020         case SLE_FILE_I8:  x = (int8  )
SlReadByte();   
break;
 
 1021         case SLE_FILE_U8:  x = (byte  )
SlReadByte();   
break;
 
 1022         case SLE_FILE_I16: x = (int16 )SlReadUint16(); 
break;
 
 1023         case SLE_FILE_U16: x = (uint16)SlReadUint16(); 
break;
 
 1024         case SLE_FILE_I32: x = (int32 )SlReadUint32(); 
break;
 
 1025         case SLE_FILE_U32: x = (uint32)SlReadUint32(); 
break;
 
 1026         case SLE_FILE_I64: x = (int64 )SlReadUint64(); 
break;
 
 1027         case SLE_FILE_U64: x = (uint64)SlReadUint64(); 
break;
 
 1029         default: NOT_REACHED();
 
 1038     default: NOT_REACHED();
 
 1053   if (ptr == NULL) 
return 0;
 
 1054   return min(strlen(ptr), length - 1);
 
 1072     default: NOT_REACHED();
 
 1075       str = *(
const char * 
const *)ptr;
 
 1080       str = (
const char *)ptr;
 
 1086   return len + SlGetArrayLength(len); 
 
 1095 static void SlString(
void *ptr, 
size_t length, VarType conv)
 
 1101         default: NOT_REACHED();
 
 1108           ptr = *(
char **)ptr;
 
 1113       SlWriteArrayLength(len);
 
 1119       size_t len = SlReadArrayLength();
 
 1122         default: NOT_REACHED();
 
 1125           if (len >= length) {
 
 1126             DEBUG(sl, 1, 
"String length in savegame is bigger than buffer, truncating");
 
 1136           free(*(
char **)ptr);
 
 1138             *(
char **)ptr = NULL;
 
 1141             *(
char **)ptr = MallocT<char>(len + 1); 
 
 1142             ptr = *(
char **)ptr;
 
 1148       ((
char *)ptr)[len] = 
'\0'; 
 
 1159       str_validate((
char *)ptr, (
char *)ptr + len, settings);
 
 1164     default: NOT_REACHED();
 
 1184 void SlArray(
void *array, 
size_t length, VarType conv)
 
 1199     if (conv == SLE_INT16 || conv == SLE_UINT16 || conv == SLE_STRINGID ||
 
 1200         conv == SLE_INT32 || conv == SLE_UINT32) {
 
 1205     if (conv == (SLE_FILE_I32 | SLE_VAR_I64)) {
 
 1206       for (uint i = 0; i < length; i++) {
 
 1207         ((int64*)array)[i] = (int32)
BSWAP32(SlReadUint32());
 
 1215   if (conv == SLE_INT8 || conv == SLE_UINT8) {
 
 1218     byte *a = (byte*)array;
 
 1221     for (; length != 0; length --) {
 
 1243   if (obj == NULL) 
return 0;
 
 1258     default: NOT_REACHED();
 
 1274   assert_compile(
sizeof(
size_t) <= 
sizeof(
void *));
 
 1339     default: NOT_REACHED();
 
 1349   const std::list<void *> *l = (
const std::list<void *> *) list;
 
 1354   return l->size() * type_size + type_size;
 
 1372   typedef std::list<void *> PtrList;
 
 1373   PtrList *l = (PtrList *)list;
 
 1377       SlWriteUint32((uint32)l->size());
 
 1379       PtrList::iterator iter;
 
 1380       for (iter = l->begin(); iter != l->end(); ++iter) {
 
 1391       for (
size_t i = 0; i < length; i++) {
 
 1393         l->push_back((
void *)data);
 
 1401       PtrList::iterator iter;
 
 1402       for (iter = temp.begin(); iter != temp.end(); ++iter) {
 
 1411     default: NOT_REACHED();
 
 1451   for (; sld->
cmd != SL_END; sld++) {
 
 1452     length += SlCalcObjMemberLength(
object, sld);
 
 1457 size_t SlCalcObjMemberLength(
const void *
object, 
const SaveLoad *sld)
 
 1476         default: NOT_REACHED();
 
 1479     case SL_WRITEBYTE: 
return 1; 
 
 1482     default: NOT_REACHED();
 
 1500           return sld->
size == 
sizeof(bool);
 
 1503           return sld->
size == 
sizeof(int8);
 
 1506           return sld->
size == 
sizeof(int16);
 
 1509           return sld->
size == 
sizeof(int32);
 
 1512           return sld->
size == 
sizeof(int64);
 
 1514           return sld->
size == 
sizeof(
void *);
 
 1518       return sld->
size == 
sizeof(
void *);
 
 1531 bool SlObjectMember(
void *ptr, 
const SaveLoad *sld)
 
 1537   VarType conv = 
GB(sld->
conv, 0, 8);
 
 1563               *(
void **)ptr = NULL;
 
 1565             default: NOT_REACHED();
 
 1571         default: NOT_REACHED();
 
 1587         default: NOT_REACHED();
 
 1592     case SL_VEH_INCLUDE:
 
 1600     default: NOT_REACHED();
 
 1618   for (; sld->
cmd != SL_END; sld++) {
 
 1620     SlObjectMember(ptr, sld);
 
 1676       _sl.array_index = 0;
 
 1680     case CH_SPARSE_ARRAY:
 
 1685       if ((m & 0xF) == CH_RIFF) {
 
 1687         len = (
SlReadByte() << 16) | ((m >> 4) << 24);
 
 1688         len += SlReadUint16();
 
 1716       _sl.array_index = 0;
 
 1723     case CH_SPARSE_ARRAY:
 
 1731       if ((m & 0xF) == CH_RIFF) {
 
 1733         len = (
SlReadByte() << 16) | ((m >> 4) << 24);
 
 1734         len += SlReadUint16();
 
 1783   ChunkSaveLoadProc *proc = ch->
save_proc;
 
 1786   if (proc == NULL) 
return;
 
 1788   SlWriteUint32(ch->
id);
 
 1789   DEBUG(sl, 2, 
"Saving chunk %c%c%c%c", ch->
id >> 24, ch->
id >> 16, ch->
id >> 8, ch->
id);
 
 1791   if (ch->
flags & CH_AUTO_LENGTH) {
 
 1793     _stub_save_proc = proc;
 
 1798   switch (ch->
flags & CH_TYPE_MASK) {
 
 1807       SlWriteArrayLength(0); 
 
 1809     case CH_SPARSE_ARRAY:
 
 1812       SlWriteArrayLength(0); 
 
 1814     default: NOT_REACHED();
 
 1847   for (
id = SlReadUint32(); 
id != 0; 
id = SlReadUint32()) {
 
 1848     DEBUG(sl, 2, 
"Loading chunk %c%c%c%c", 
id >> 24, 
id >> 16, 
id >> 8, 
id);
 
 1862   for (
id = SlReadUint32(); 
id != 0; 
id = SlReadUint32()) {
 
 1863     DEBUG(sl, 2, 
"Loading chunk %c%c%c%c", 
id >> 24, 
id >> 16, 
id >> 8, 
id);
 
 1876   DEBUG(sl, 1, 
"Fixing pointers");
 
 1879     if (ch->ptrs_proc != NULL) {
 
 1880       DEBUG(sl, 2, 
"Fixing pointers for %c%c%c%c", ch->id >> 24, ch->id >> 16, ch->id >> 8, ch->id);
 
 1885   DEBUG(sl, 1, 
"All pointers fixed");
 
 1907     if (this->
file != NULL) fclose(this->
file);
 
 1914    size_t Read(byte *buf, 
size_t size)
 
 1917     if (this->
file == NULL) 
return 0;
 
 1919     return fread(buf, 1, size, this->
file);
 
 1924     clearerr(this->
file);
 
 1925     if (fseek(this->
file, this->
begin, SEEK_SET)) {
 
 1926       DEBUG(sl, 1, 
"Could not reset the file reading");
 
 1955     if (this->
file == NULL) 
return;
 
 1957     if (fwrite(buf, 1, size, this->
file) != size) 
SlError(STR_GAME_SAVELOAD_ERROR_FILE_NOT_WRITEABLE);
 
 1962     if (this->
file != NULL) fclose(this->
file);
 
 1972 #include <lzo/lzo1x.h> 
 1985     if (lzo_init() != LZO_E_OK) 
SlError(STR_GAME_SAVELOAD_ERROR_BROKEN_INTERNAL_ERROR, 
"cannot initialize decompressor");
 
 1988    size_t Read(byte *buf, 
size_t ssize)
 
 1990     assert(ssize >= LZO_BUFFER_SIZE);
 
 1993     byte out[LZO_BUFFER_SIZE + LZO_BUFFER_SIZE / 16 + 64 + 3 + 
sizeof(uint32) * 2];
 
 1999     if (this->
chain->
Read((byte*)tmp, 
sizeof(tmp)) != 
sizeof(tmp)) 
SlError(STR_GAME_SAVELOAD_ERROR_FILE_NOT_READABLE, 
"File read failed");
 
 2002     ((uint32*)out)[0] = size = tmp[1];
 
 2005       tmp[0] = TO_BE32(tmp[0]);
 
 2006       size = TO_BE32(size);
 
 2012     if (this->
chain->
Read(out + 
sizeof(uint32), size) != size) 
SlError(STR_GAME_SAVELOAD_ERROR_FILE_NOT_READABLE);
 
 2015     if (tmp[0] != lzo_adler32(0, out, size + 
sizeof(uint32))) 
SlErrorCorrupt(
"Bad checksum");
 
 2018     lzo1x_decompress_safe(out + 
sizeof(uint32) * 1, size, buf, &len, NULL);
 
 2032     if (lzo_init() != LZO_E_OK) 
SlError(STR_GAME_SAVELOAD_ERROR_BROKEN_INTERNAL_ERROR, 
"cannot initialize compressor");
 
 2037     const lzo_bytep in = buf;
 
 2039     byte out[LZO_BUFFER_SIZE + LZO_BUFFER_SIZE / 16 + 64 + 3 + 
sizeof(uint32) * 2];
 
 2040     byte wrkmem[LZO1X_1_MEM_COMPRESS];
 
 2045       lzo_uint len = size > LZO_BUFFER_SIZE ? LZO_BUFFER_SIZE : (lzo_uint)size;
 
 2046       lzo1x_1_compress(in, len, out + 
sizeof(uint32) * 2, &outlen, wrkmem);
 
 2047       ((uint32*)out)[1] = TO_BE32((uint32)outlen);
 
 2048       ((uint32*)out)[0] = TO_BE32(lzo_adler32(0, out + 
sizeof(uint32), outlen + 
sizeof(uint32)));
 
 2049       this->
chain->
Write(out, outlen + 
sizeof(uint32) * 2);
 
 2074    size_t Read(byte *buf, 
size_t size)
 
 2101 #if defined(WITH_ZLIB) 
 2115     memset(&this->
z, 0, 
sizeof(this->
z));
 
 2116     if (inflateInit(&this->
z) != Z_OK) 
SlError(STR_GAME_SAVELOAD_ERROR_BROKEN_INTERNAL_ERROR, 
"cannot initialize decompressor");
 
 2122     inflateEnd(&this->
z);
 
 2125    size_t Read(byte *buf, 
size_t size)
 
 2127     this->
z.next_out  = buf;
 
 2128     this->
z.avail_out = (uint)size;
 
 2132       if (this->
z.avail_in == 0) {
 
 2134         this->
z.avail_in = (uint)this->
chain->
Read(this->fread_buf, 
sizeof(this->fread_buf));
 
 2138       int r = inflate(&this->
z, 0);
 
 2139       if (r == Z_STREAM_END) 
break;
 
 2141       if (r != Z_OK) 
SlError(STR_GAME_SAVELOAD_ERROR_BROKEN_INTERNAL_ERROR, 
"inflate() failed");
 
 2142     } 
while (this->
z.avail_out != 0);
 
 2144     return size - this->
z.avail_out;
 
 2159     memset(&this->
z, 0, 
sizeof(this->
z));
 
 2160     if (deflateInit(&this->
z, compression_level) != Z_OK) 
SlError(STR_GAME_SAVELOAD_ERROR_BROKEN_INTERNAL_ERROR, 
"cannot initialize compressor");
 
 2166     deflateEnd(&this->
z);
 
 2179     this->
z.next_in = p;
 
 2180     this->
z.avail_in = (uInt)len;
 
 2182       this->
z.next_out = buf;
 
 2183       this->
z.avail_out = 
sizeof(buf);
 
 2192       int r = deflate(&this->
z, mode);
 
 2195       if ((n = 
sizeof(buf) - this->
z.avail_out) != 0) {
 
 2198       if (r == Z_STREAM_END) 
break;
 
 2200       if (r != Z_OK) 
SlError(STR_GAME_SAVELOAD_ERROR_BROKEN_INTERNAL_ERROR, 
"zlib returned error code");
 
 2201     } 
while (this->
z.avail_in || !this->z.avail_out);
 
 2222 #if defined(WITH_LZMA) 
 2245     if (lzma_auto_decoder(&this->
lzma, 1 << 28, 0) != LZMA_OK) 
SlError(STR_GAME_SAVELOAD_ERROR_BROKEN_INTERNAL_ERROR, 
"cannot initialize decompressor");
 
 2251     lzma_end(&this->
lzma);
 
 2254    size_t Read(byte *buf, 
size_t size)
 
 2256     this->
lzma.next_out  = buf;
 
 2257     this->
lzma.avail_out = size;
 
 2261       if (this->
lzma.avail_in == 0) {
 
 2267       lzma_ret r = lzma_code(&this->
lzma, LZMA_RUN);
 
 2268       if (r == LZMA_STREAM_END) 
break;
 
 2269       if (r != LZMA_OK) 
SlError(STR_GAME_SAVELOAD_ERROR_BROKEN_INTERNAL_ERROR, 
"liblzma returned error code");
 
 2270     } 
while (this->
lzma.avail_out != 0);
 
 2272     return size - this->
lzma.avail_out;
 
 2287     if (lzma_easy_encoder(&this->
lzma, compression_level, LZMA_CHECK_CRC32) != LZMA_OK) 
SlError(STR_GAME_SAVELOAD_ERROR_BROKEN_INTERNAL_ERROR, 
"cannot initialize compressor");
 
 2293     lzma_end(&this->
lzma);
 
 2306     this->
lzma.next_in = p;
 
 2307     this->
lzma.avail_in = len;
 
 2309       this->
lzma.next_out = buf;
 
 2310       this->
lzma.avail_out = 
sizeof(buf);
 
 2312       lzma_ret r = lzma_code(&this->
lzma, action);
 
 2315       if ((n = 
sizeof(buf) - this->
lzma.avail_out) != 0) {
 
 2318       if (r == LZMA_STREAM_END) 
break;
 
 2319       if (r != LZMA_OK) 
SlError(STR_GAME_SAVELOAD_ERROR_BROKEN_INTERNAL_ERROR, 
"liblzma returned error code");
 
 2320     } 
while (this->
lzma.avail_in || !this->lzma.avail_out);
 
 2356 #if defined(WITH_LZO) 
 2358   {
"lzo",    TO_BE32X(
'OTTD'), CreateLoadFilter<LZOLoadFilter>,    CreateSaveFilter<LZOSaveFilter>,    0, 0, 0},
 
 2360   {
"lzo",    TO_BE32X(
'OTTD'), NULL,                               NULL,                               0, 0, 0},
 
 2363   {
"none",   TO_BE32X(
'OTTN'), CreateLoadFilter<NoCompLoadFilter>, CreateSaveFilter<NoCompSaveFilter>, 0, 0, 0},
 
 2364 #if defined(WITH_ZLIB) 
 2368   {
"zlib",   TO_BE32X(
'OTTZ'), CreateLoadFilter<ZlibLoadFilter>,   CreateSaveFilter<ZlibSaveFilter>,   0, 6, 9},
 
 2370   {
"zlib",   TO_BE32X(
'OTTZ'), NULL,                               NULL,                               0, 0, 0},
 
 2372 #if defined(WITH_LZMA) 
 2378   {
"lzma",   TO_BE32X(
'OTTX'), CreateLoadFilter<LZMALoadFilter>,   CreateSaveFilter<LZMASaveFilter>,   0, 2, 9},
 
 2380   {
"lzma",   TO_BE32X(
'OTTX'), NULL,                               NULL,                               0, 0, 0},
 
 2400     char *complevel = strrchr(s, 
':');
 
 2401     if (complevel != NULL) *complevel = 
'\0';
 
 2403     for (
const SaveLoadFormat *slf = &_saveload_formats[0]; slf != 
endof(_saveload_formats); slf++) {
 
 2404       if (slf->init_write != NULL && strcmp(s, slf->name) == 0) {
 
 2405         *compression_level = slf->default_compression;
 
 2406         if (complevel != NULL) {
 
 2415           long level = strtol(complevel, &end, 10);
 
 2416           if (end == complevel || level != 
Clamp(level, slf->min_compression, slf->max_compression)) {
 
 2420             *compression_level = level;
 
 2432     if (complevel != NULL) *complevel = 
':';
 
 2439 void InitializeGame(uint size_x, uint size_y, 
bool reset_date, 
bool reset_settings);
 
 2441 extern bool LoadOldSaveGame(
const char *file);
 
 2479   if (_game_mode != GM_MENU) _fast_forward = _sl.
ff_state;
 
 2498   static char err_str[512];
 
 2499   GetString(err_str, _sl.
action == 
SLA_SAVE ? STR_ERROR_GAME_SAVE_FAILED : STR_ERROR_GAME_LOAD_FAILED, 
lastof(err_str));
 
 2523     _sl.
sf->
Write((byte*)hdr, 
sizeof(hdr));
 
 2540     if (_sl.
error_str != STR_NETWORK_ERROR_LOSTCONNECTION) {
 
 2561 void WaitTillSaved()
 
 2563   if (_save_thread == NULL) 
return;
 
 2565   _save_thread->
Join();
 
 2567   _save_thread = NULL;
 
 2590   SaveViewportBeforeSaveGame();
 
 2595     if (threaded) 
DEBUG(sl, 1, 
"Cannot create savegame thread, reverting to single-threaded mode...");
 
 2616     return DoSave(writer, threaded);
 
 2641   if (_sl.
lf->
Read((byte*)hdr, 
sizeof(hdr)) != 
sizeof(hdr)) 
SlError(STR_GAME_SAVELOAD_ERROR_FILE_NOT_READABLE);
 
 2647     if (fmt == 
endof(_saveload_formats)) {
 
 2648       DEBUG(sl, 0, 
"Unknown savegame type, trying to load it as the buggy format");
 
 2656         if (fmt == 
endof(_saveload_formats)) {
 
 2660         if (fmt->
tag == TO_BE32X(
'OTTD')) 
break;
 
 2666     if (fmt->
tag == hdr[0]) {
 
 2688     SlError(STR_GAME_SAVELOAD_ERROR_BROKEN_INTERNAL_ERROR, err_str);
 
 2699     InitializeGame(256, 256, 
true, 
true);
 
 2771     return DoLoad(reader, 
false);
 
 2800       InitializeGame(256, 256, 
true, 
true); 
 
 2808       if (!LoadOldSaveGame(filename)) 
return SL_REINIT;
 
 2834       default: NOT_REACHED();
 
 2845       SlError(fop == 
SLO_SAVE ? STR_GAME_SAVELOAD_ERROR_FILE_NOT_WRITEABLE : STR_GAME_SAVELOAD_ERROR_FILE_NOT_READABLE);
 
 2857     DEBUG(desync, 1, 
"load: %s", filename);
 
 2890     FOR_ALL_COMPANIES(c) {
 
 2900     case 0: 
SetDParam(1, STR_JUST_DATE_LONG); 
break;
 
 2901     case 1: 
SetDParam(1, STR_JUST_DATE_TINY); 
break;
 
 2902     case 2: 
SetDParam(1, STR_JUST_DATE_ISO); 
break;
 
 2903     default: NOT_REACHED();
 
 2908   GetString(buf, !
Company::IsValidID(cid) ? STR_SAVEGAME_NAME_SPECTATOR : STR_SAVEGAME_NAME_DEFAULT, last);
 
 2966 int GetSavegameType(
char *file)
 
 2971   int mode = SL_OLD_LOAD;
 
 2973   f = fopen(file, 
"rb");
 
 2974   if (fread(&hdr, 
sizeof(hdr), 1, f) != 1) {
 
 2975     DEBUG(sl, 0, 
"Savegame is obsolete or invalid format");
 
 2979     for (fmt = _saveload_formats; fmt != 
endof(_saveload_formats); fmt++) {
 
 2980       if (fmt->
tag == hdr) {