24 #include "../stdafx.h" 26 #include "../station_base.h" 27 #include "../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" 48 #include "table/strings.h" 53 #include "../safeguards.h" 100 inline byte ReadByte()
102 if (this->bufp == this->bufe) {
103 size_t len = this->reader->
Read(this->buf,
lengthof(this->buf));
107 this->bufp = this->
buf;
108 this->bufe = this->buf + len;
111 return *this->bufp++;
120 return this->read - (this->bufe - this->
bufp);
138 for (
auto p : this->blocks) {
150 if (this->buf == this->bufe) {
152 this->blocks.push_back(this->buf);
169 size_t to_write =
min(MEMORY_CHUNK_SIZE, t);
171 writer->
Write(this->blocks[i++], to_write);
184 return this->blocks.size() * MEMORY_CHUNK_SIZE - (this->bufe - this->
buf);
241 extern const ChunkHandler _autoreplace_chunk_handlers[];
250 _gamelog_chunk_handlers,
252 _misc_chunk_handlers,
255 _setting_chunk_handlers,
257 _waypoint_chunk_handlers,
258 _depot_chunk_handlers,
259 _order_chunk_handlers,
260 _industry_chunk_handlers,
261 _economy_chunk_handlers,
262 _subsidy_chunk_handlers,
264 _goal_chunk_handlers,
265 _story_page_chunk_handlers,
266 _engine_chunk_handlers,
269 _station_chunk_handlers,
270 _company_chunk_handlers,
272 _game_chunk_handlers,
274 _newgrf_chunk_handlers,
275 _group_chunk_handlers,
277 _autoreplace_chunk_handlers,
278 _labelmaps_chunk_handlers,
279 _linkgraph_chunk_handlers,
280 _airport_chunk_handlers,
281 _object_chunk_handlers,
290 #define FOR_ALL_CHUNK_HANDLERS(ch) \ 291 for (const ChunkHandler * const *chsc = _chunk_handlers; *chsc != nullptr; chsc++) \ 292 for (const ChunkHandler *ch = *chsc; ch != nullptr; ch = (ch->flags & CH_LAST) ? nullptr : ch + 1) 304 DEBUG(sl, 1,
"Nulling pointers");
307 if (ch->ptrs_proc !=
nullptr) {
308 DEBUG(sl, 2,
"Nulling pointers for %c%c%c%c", ch->id >> 24, ch->id >> 16, ch->id >> 8, ch->id);
313 DEBUG(sl, 1,
"All pointers nulled");
344 throw std::exception();
356 SlError(STR_GAME_SAVELOAD_ERROR_BROKEN_SAVEGAME, msg);
371 va_start(ap, format);
389 if (_exit_game)
return;
390 while (_async_save_finish.load(std::memory_order_acquire) !=
nullptr)
CSleep(10);
392 _async_save_finish.store(proc, std::memory_order_release);
400 AsyncSaveFinishProc proc = _async_save_finish.exchange(
nullptr, std::memory_order_acq_rel);
401 if (proc ==
nullptr)
return;
405 if (_save_thread.joinable()) {
416 return _sl.
reader->ReadByte();
428 static inline int SlReadUint16()
434 static inline uint32 SlReadUint32()
436 uint32 x = SlReadUint16() << 16;
437 return x | SlReadUint16();
440 static inline uint64 SlReadUint64()
442 uint32 x = SlReadUint32();
443 uint32 y = SlReadUint32();
444 return (uint64)x << 32 | y;
447 static inline void SlWriteUint16(uint16 v)
453 static inline void SlWriteUint32(uint32 v)
455 SlWriteUint16(
GB(v, 16, 16));
456 SlWriteUint16(
GB(v, 0, 16));
459 static inline void SlWriteUint64(uint64 x)
461 SlWriteUint32((uint32)(x >> 32));
462 SlWriteUint32((uint32)x);
529 if (i >= (1 << 14)) {
530 if (i >= (1 << 21)) {
531 if (i >= (1 << 28)) {
532 assert(i <= UINT32_MAX);
553 return 1 + (i >= (1 << 7)) + (i >= (1 << 14)) + (i >= (1 << 21)) + (i >= (1 << 28));
556 static inline uint SlReadSparseIndex()
561 static inline void SlWriteSparseIndex(uint index)
566 static inline uint SlReadArrayLength()
571 static inline void SlWriteArrayLength(
size_t length)
576 static inline uint SlGetArrayLength(
size_t length)
589 static const byte conv_mem_size[] = {1, 1, 1, 2, 2, 4, 4, 8, 8, 0};
590 byte length =
GB(conv, 4, 4);
592 switch (length << 4) {
597 return SlReadArrayLength();
600 assert(length <
lengthof(conv_mem_size));
601 return conv_mem_size[length];
613 static const byte conv_file_size[] = {1, 1, 2, 2, 4, 4, 8, 8, 2};
614 byte length =
GB(conv, 0, 4);
615 assert(length <
lengthof(conv_file_size));
616 return conv_file_size[length];
625 void SlSetArrayIndex(uint index)
628 _sl.array_index = index;
631 static size_t _next_offs;
646 uint length = SlReadArrayLength();
656 case CH_SPARSE_ARRAY: index = (int)SlReadSparseIndex();
break;
657 case CH_ARRAY: index = _sl.array_index++;
break;
659 DEBUG(sl, 0,
"SlIterateArray error");
663 if (length != 0)
return index;
694 assert(length < (1 << 28));
695 SlWriteUint32((uint32)((length & 0xFFFFFF) | ((length >> 24) << 28)));
700 SlWriteArrayLength(1);
702 SlWriteArrayLength(length + 1);
704 case CH_SPARSE_ARRAY:
705 SlWriteArrayLength(length + 1 + SlGetArrayLength(_sl.array_index));
706 SlWriteSparseIndex(_sl.array_index);
708 default: NOT_REACHED();
716 default: NOT_REACHED();
728 byte *p = (byte *)ptr;
733 for (; length != 0; length--) *p++ =
SlReadByte();
738 default: NOT_REACHED();
758 case SLE_VAR_BL:
return (*(
const bool *)ptr != 0);
759 case SLE_VAR_I8:
return *(
const int8 *)ptr;
760 case SLE_VAR_U8:
return *(
const byte *)ptr;
761 case SLE_VAR_I16:
return *(
const int16 *)ptr;
762 case SLE_VAR_U16:
return *(
const uint16*)ptr;
763 case SLE_VAR_I32:
return *(
const int32 *)ptr;
764 case SLE_VAR_U32:
return *(
const uint32*)ptr;
765 case SLE_VAR_I64:
return *(
const int64 *)ptr;
766 case SLE_VAR_U64:
return *(
const uint64*)ptr;
768 default: NOT_REACHED();
782 case SLE_VAR_BL: *(
bool *)ptr = (val != 0);
break;
783 case SLE_VAR_I8: *(int8 *)ptr = val;
break;
784 case SLE_VAR_U8: *(byte *)ptr = val;
break;
785 case SLE_VAR_I16: *(int16 *)ptr = val;
break;
786 case SLE_VAR_U16: *(uint16*)ptr = val;
break;
787 case SLE_VAR_I32: *(int32 *)ptr = val;
break;
788 case SLE_VAR_U32: *(uint32*)ptr = val;
break;
789 case SLE_VAR_I64: *(int64 *)ptr = val;
break;
790 case SLE_VAR_U64: *(uint64*)ptr = val;
break;
793 default: NOT_REACHED();
813 case SLE_FILE_I8: assert(x >= -128 && x <= 127);
SlWriteByte(x);
break;
814 case SLE_FILE_U8: assert(x >= 0 && x <= 255);
SlWriteByte(x);
break;
815 case SLE_FILE_I16:assert(x >= -32768 && x <= 32767); SlWriteUint16(x);
break;
817 case SLE_FILE_U16:assert(x >= 0 && x <= 65535); SlWriteUint16(x);
break;
819 case SLE_FILE_U32: SlWriteUint32((uint32)x);
break;
821 case SLE_FILE_U64: SlWriteUint64(x);
break;
822 default: NOT_REACHED();
831 case SLE_FILE_I8: x = (int8 )
SlReadByte();
break;
832 case SLE_FILE_U8: x = (byte )
SlReadByte();
break;
833 case SLE_FILE_I16: x = (int16 )SlReadUint16();
break;
834 case SLE_FILE_U16: x = (uint16)SlReadUint16();
break;
835 case SLE_FILE_I32: x = (int32 )SlReadUint32();
break;
836 case SLE_FILE_U32: x = (uint32)SlReadUint32();
break;
837 case SLE_FILE_I64: x = (int64 )SlReadUint64();
break;
838 case SLE_FILE_U64: x = (uint64)SlReadUint64();
break;
840 default: NOT_REACHED();
849 default: NOT_REACHED();
864 if (ptr ==
nullptr)
return 0;
865 return min(strlen(ptr), length - 1);
883 default: NOT_REACHED();
886 str = *(
const char *
const *)ptr;
891 str = (
const char *)ptr;
897 return len + SlGetArrayLength(len);
906 static void SlString(
void *ptr,
size_t length, VarType conv)
912 default: NOT_REACHED();
924 SlWriteArrayLength(len);
930 size_t len = SlReadArrayLength();
933 default: NOT_REACHED();
937 DEBUG(sl, 1,
"String length in savegame is bigger than buffer, truncating");
949 *(
char **)ptr =
nullptr;
952 *(
char **)ptr = MallocT<char>(len + 1);
959 ((
char *)ptr)[len] =
'\0';
975 default: NOT_REACHED();
995 void SlArray(
void *array,
size_t length, VarType conv)
1010 if (conv == SLE_INT16 || conv == SLE_UINT16 || conv == SLE_STRINGID ||
1011 conv == SLE_INT32 || conv == SLE_UINT32) {
1016 if (conv == (SLE_FILE_I32 | SLE_VAR_I64)) {
1017 for (uint i = 0; i < length; i++) {
1018 ((int64*)array)[i] = (int32)
BSWAP32(SlReadUint32());
1026 if (conv == SLE_INT8 || conv == SLE_UINT8) {
1029 byte *a = (byte*)array;
1032 for (; length != 0; length --) {
1054 if (obj ==
nullptr)
return 0;
1069 default: NOT_REACHED();
1085 assert_compile(
sizeof(
size_t) <=
sizeof(
void *));
1150 default: NOT_REACHED();
1160 const std::list<void *> *l = (
const std::list<void *> *) list;
1165 return l->size() * type_size + type_size;
1183 typedef std::list<void *> PtrList;
1184 PtrList *l = (PtrList *)list;
1188 SlWriteUint32((uint32)l->size());
1190 PtrList::iterator iter;
1191 for (iter = l->begin(); iter != l->end(); ++iter) {
1202 for (
size_t i = 0; i < length; i++) {
1204 l->push_back((
void *)data);
1212 PtrList::iterator iter;
1213 for (iter = temp.begin(); iter != temp.end(); ++iter) {
1222 default: NOT_REACHED();
1230 template <
typename T>
1232 typedef std::deque<T> SlDequeT;
1241 const SlDequeT *l = (
const SlDequeT *)deque;
1256 SlDequeT *l = (SlDequeT *)deque;
1260 SlWriteUint32((uint32)l->size());
1262 typename SlDequeT::iterator iter;
1263 for (iter = l->begin(); iter != l->end(); ++iter) {
1270 size_t length = SlReadUint32();
1273 for (
size_t i = 0; i < length; i++) {
1285 default: NOT_REACHED();
1313 default: NOT_REACHED();
1345 default: NOT_REACHED();
1353 if (_sl_version < sld->version_from || _sl_version >= sld->
version_to)
return false;
1385 for (; sld->
cmd != SL_END; sld++) {
1386 length += SlCalcObjMemberLength(
object, sld);
1391 size_t SlCalcObjMemberLength(
const void *
object,
const SaveLoad *sld)
1412 default: NOT_REACHED();
1415 case SL_WRITEBYTE:
return 1;
1418 default: NOT_REACHED();
1436 return sld->
size ==
sizeof(bool);
1439 return sld->
size ==
sizeof(int8);
1442 return sld->
size ==
sizeof(int16);
1445 return sld->
size ==
sizeof(int32);
1448 return sld->
size ==
sizeof(int64);
1450 return sld->
size ==
sizeof(
void *);
1454 return sld->
size ==
sizeof(
void *);
1467 bool SlObjectMember(
void *ptr,
const SaveLoad *sld)
1473 VarType conv =
GB(sld->
conv, 0, 8);
1500 *(
void **)ptr =
nullptr;
1502 default: NOT_REACHED();
1509 default: NOT_REACHED();
1523 default: NOT_REACHED();
1528 case SL_VEH_INCLUDE:
1536 default: NOT_REACHED();
1554 for (; sld->
cmd != SL_END; sld++) {
1556 SlObjectMember(ptr, sld);
1612 _sl.array_index = 0;
1616 case CH_SPARSE_ARRAY:
1621 if ((m & 0xF) == CH_RIFF) {
1623 len = (
SlReadByte() << 16) | ((m >> 4) << 24);
1624 len += SlReadUint16();
1652 _sl.array_index = 0;
1659 case CH_SPARSE_ARRAY:
1667 if ((m & 0xF) == CH_RIFF) {
1669 len = (
SlReadByte() << 16) | ((m >> 4) << 24);
1670 len += SlReadUint16();
1719 ChunkSaveLoadProc *proc = ch->
save_proc;
1722 if (proc ==
nullptr)
return;
1724 SlWriteUint32(ch->
id);
1725 DEBUG(sl, 2,
"Saving chunk %c%c%c%c", ch->
id >> 24, ch->
id >> 16, ch->
id >> 8, ch->
id);
1727 if (ch->
flags & CH_AUTO_LENGTH) {
1729 _stub_save_proc = proc;
1734 switch (ch->
flags & CH_TYPE_MASK) {
1743 SlWriteArrayLength(0);
1745 case CH_SPARSE_ARRAY:
1748 SlWriteArrayLength(0);
1750 default: NOT_REACHED();
1783 for (
id = SlReadUint32();
id != 0;
id = SlReadUint32()) {
1784 DEBUG(sl, 2,
"Loading chunk %c%c%c%c",
id >> 24,
id >> 16,
id >> 8,
id);
1798 for (
id = SlReadUint32();
id != 0;
id = SlReadUint32()) {
1799 DEBUG(sl, 2,
"Loading chunk %c%c%c%c",
id >> 24,
id >> 16,
id >> 8,
id);
1812 DEBUG(sl, 1,
"Fixing pointers");
1815 if (ch->ptrs_proc !=
nullptr) {
1816 DEBUG(sl, 2,
"Fixing pointers for %c%c%c%c", ch->id >> 24, ch->id >> 16, ch->id >> 8, ch->id);
1821 DEBUG(sl, 1,
"All pointers fixed");
1843 if (this->file !=
nullptr) fclose(this->file);
1844 this->file =
nullptr;
1853 if (this->file ==
nullptr)
return 0;
1855 return fread(buf, 1, size, this->file);
1860 clearerr(this->file);
1861 if (fseek(this->file, this->begin, SEEK_SET)) {
1862 DEBUG(sl, 1,
"Could not reset the file reading");
1891 if (this->file ==
nullptr)
return;
1893 if (fwrite(buf, 1, size, this->file) != size)
SlError(STR_GAME_SAVELOAD_ERROR_FILE_NOT_WRITEABLE);
1898 if (this->file !=
nullptr) fclose(this->file);
1899 this->file =
nullptr;
1908 #include <lzo/lzo1x.h> 1921 if (lzo_init() != LZO_E_OK)
SlError(STR_GAME_SAVELOAD_ERROR_BROKEN_INTERNAL_ERROR,
"cannot initialize decompressor");
1926 assert(ssize >= LZO_BUFFER_SIZE);
1929 byte out[LZO_BUFFER_SIZE + LZO_BUFFER_SIZE / 16 + 64 + 3 +
sizeof(uint32) * 2];
1932 lzo_uint len = ssize;
1935 if (this->chain->Read((byte*)tmp,
sizeof(tmp)) !=
sizeof(tmp))
SlError(STR_GAME_SAVELOAD_ERROR_FILE_NOT_READABLE,
"File read failed");
1938 ((uint32*)out)[0] = size = tmp[1];
1941 tmp[0] = TO_BE32(tmp[0]);
1942 size = TO_BE32(size);
1948 if (this->chain->Read(out +
sizeof(uint32), size) != size)
SlError(STR_GAME_SAVELOAD_ERROR_FILE_NOT_READABLE);
1951 if (tmp[0] != lzo_adler32(0, out, size +
sizeof(uint32)))
SlErrorCorrupt(
"Bad checksum");
1954 int ret = lzo1x_decompress_safe(out +
sizeof(uint32) * 1, size, buf, &len,
nullptr);
1955 if (ret != LZO_E_OK)
SlError(STR_GAME_SAVELOAD_ERROR_FILE_NOT_READABLE);
1969 if (lzo_init() != LZO_E_OK)
SlError(STR_GAME_SAVELOAD_ERROR_BROKEN_INTERNAL_ERROR,
"cannot initialize compressor");
1974 const lzo_bytep in =
buf;
1976 byte out[LZO_BUFFER_SIZE + LZO_BUFFER_SIZE / 16 + 64 + 3 +
sizeof(uint32) * 2];
1977 byte wrkmem[LZO1X_1_MEM_COMPRESS];
1982 lzo_uint len = size > LZO_BUFFER_SIZE ?
LZO_BUFFER_SIZE : (lzo_uint)size;
1983 lzo1x_1_compress(in, len, out +
sizeof(uint32) * 2, &outlen, wrkmem);
1984 ((uint32*)out)[1] = TO_BE32((uint32)outlen);
1985 ((uint32*)out)[0] = TO_BE32(lzo_adler32(0, out +
sizeof(uint32), outlen +
sizeof(uint32)));
1986 this->chain->Write(out, outlen +
sizeof(uint32) * 2);
2013 return this->chain->Read(buf, size);
2030 this->chain->Write(buf, size);
2038 #if defined(WITH_ZLIB) 2052 memset(&this->z, 0,
sizeof(this->z));
2053 if (inflateInit(&this->z) != Z_OK)
SlError(STR_GAME_SAVELOAD_ERROR_BROKEN_INTERNAL_ERROR,
"cannot initialize decompressor");
2059 inflateEnd(&this->z);
2064 this->z.next_out =
buf;
2065 this->z.avail_out = (uint)size;
2069 if (this->z.avail_in == 0) {
2070 this->z.next_in = this->fread_buf;
2071 this->z.avail_in = (uint)this->chain->Read(this->fread_buf,
sizeof(this->fread_buf));
2075 int r = inflate(&this->z, 0);
2076 if (r == Z_STREAM_END)
break;
2078 if (r != Z_OK)
SlError(STR_GAME_SAVELOAD_ERROR_BROKEN_INTERNAL_ERROR,
"inflate() failed");
2079 }
while (this->z.avail_out != 0);
2081 return size - this->z.avail_out;
2096 memset(&this->z, 0,
sizeof(this->z));
2097 if (deflateInit(&this->z, compression_level) != Z_OK)
SlError(STR_GAME_SAVELOAD_ERROR_BROKEN_INTERNAL_ERROR,
"cannot initialize compressor");
2103 deflateEnd(&this->z);
2116 this->z.next_in = p;
2117 this->z.avail_in = (uInt)len;
2119 this->z.next_out =
buf;
2120 this->z.avail_out =
sizeof(
buf);
2129 int r = deflate(&this->z, mode);
2132 if ((n =
sizeof(buf) - this->z.avail_out) != 0) {
2133 this->chain->Write(buf, n);
2135 if (r == Z_STREAM_END)
break;
2137 if (r != Z_OK)
SlError(STR_GAME_SAVELOAD_ERROR_BROKEN_INTERNAL_ERROR,
"zlib returned error code");
2138 }
while (this->z.avail_in || !this->z.avail_out);
2143 this->WriteLoop(buf, size, 0);
2148 this->WriteLoop(
nullptr, 0, Z_FINISH);
2149 this->chain->Finish();
2159 #if defined(WITH_LIBLZMA) 2182 if (lzma_auto_decoder(&this->lzma, 1 << 28, 0) != LZMA_OK)
SlError(STR_GAME_SAVELOAD_ERROR_BROKEN_INTERNAL_ERROR,
"cannot initialize decompressor");
2188 lzma_end(&this->lzma);
2193 this->lzma.next_out =
buf;
2194 this->lzma.avail_out = size;
2198 if (this->lzma.avail_in == 0) {
2199 this->lzma.next_in = this->fread_buf;
2200 this->lzma.avail_in = this->chain->Read(this->fread_buf,
sizeof(this->fread_buf));
2204 lzma_ret r = lzma_code(&this->lzma, LZMA_RUN);
2205 if (r == LZMA_STREAM_END)
break;
2206 if (r != LZMA_OK)
SlError(STR_GAME_SAVELOAD_ERROR_BROKEN_INTERNAL_ERROR,
"liblzma returned error code");
2207 }
while (this->lzma.avail_out != 0);
2209 return size - this->lzma.avail_out;
2224 if (lzma_easy_encoder(&this->lzma, compression_level, LZMA_CHECK_CRC32) != LZMA_OK)
SlError(STR_GAME_SAVELOAD_ERROR_BROKEN_INTERNAL_ERROR,
"cannot initialize compressor");
2230 lzma_end(&this->lzma);
2243 this->lzma.next_in = p;
2244 this->lzma.avail_in = len;
2246 this->lzma.next_out =
buf;
2247 this->lzma.avail_out =
sizeof(
buf);
2249 lzma_ret r = lzma_code(&this->lzma, action);
2252 if ((n =
sizeof(buf) - this->lzma.avail_out) != 0) {
2253 this->chain->Write(buf, n);
2255 if (r == LZMA_STREAM_END)
break;
2256 if (r != LZMA_OK)
SlError(STR_GAME_SAVELOAD_ERROR_BROKEN_INTERNAL_ERROR,
"liblzma returned error code");
2257 }
while (this->lzma.avail_in || !this->lzma.avail_out);
2262 this->WriteLoop(buf, size, LZMA_RUN);
2267 this->WriteLoop(
nullptr, 0, LZMA_FINISH);
2268 this->chain->Finish();
2293 #if defined(WITH_LZO) 2295 {
"lzo", TO_BE32X(
'OTTD'), CreateLoadFilter<LZOLoadFilter>, CreateSaveFilter<LZOSaveFilter>, 0, 0, 0},
2297 {
"lzo", TO_BE32X(
'OTTD'),
nullptr,
nullptr, 0, 0, 0},
2300 {
"none", TO_BE32X(
'OTTN'), CreateLoadFilter<NoCompLoadFilter>, CreateSaveFilter<NoCompSaveFilter>, 0, 0, 0},
2301 #if defined(WITH_ZLIB) 2305 {
"zlib", TO_BE32X(
'OTTZ'), CreateLoadFilter<ZlibLoadFilter>, CreateSaveFilter<ZlibSaveFilter>, 0, 6, 9},
2307 {
"zlib", TO_BE32X(
'OTTZ'),
nullptr,
nullptr, 0, 0, 0},
2309 #if defined(WITH_LIBLZMA) 2315 {
"lzma", TO_BE32X(
'OTTX'), CreateLoadFilter<LZMALoadFilter>, CreateSaveFilter<LZMASaveFilter>, 0, 2, 9},
2317 {
"lzma", TO_BE32X(
'OTTX'),
nullptr,
nullptr, 0, 0, 0},
2337 char *complevel = strrchr(s,
':');
2338 if (complevel !=
nullptr) *complevel =
'\0';
2340 for (
const SaveLoadFormat *slf = &_saveload_formats[0]; slf !=
endof(_saveload_formats); slf++) {
2341 if (slf->init_write !=
nullptr && strcmp(s, slf->name) == 0) {
2342 *compression_level = slf->default_compression;
2343 if (complevel !=
nullptr) {
2352 long level = strtol(complevel, &end, 10);
2353 if (end == complevel || level !=
Clamp(level, slf->min_compression, slf->max_compression)) {
2357 *compression_level = level;
2369 if (complevel !=
nullptr) *complevel =
':';
2376 void InitializeGame(uint size_x, uint size_y,
bool reset_date,
bool reset_settings);
2378 extern bool LoadOldSaveGame(
const char *file);
2416 if (_game_mode != GM_MENU) _fast_forward = _sl.
ff_state;
2435 static char err_str[512];
2436 GetString(err_str, _sl.
action ==
SLA_SAVE ? STR_ERROR_GAME_SAVE_FAILED : STR_ERROR_GAME_LOAD_FAILED,
lastof(err_str));
2460 _sl.
sf->
Write((byte*)hdr,
sizeof(hdr));
2477 if (_sl.
error_str != STR_NETWORK_ERROR_LOSTCONNECTION) {
2492 void WaitTillSaved()
2494 if (!_save_thread.joinable())
return;
2496 _save_thread.join();
2519 SaveViewportBeforeSaveGame();
2525 if (threaded)
DEBUG(sl, 1,
"Cannot create savegame thread, reverting to single-threaded mode...");
2546 return DoSave(writer, threaded);
2571 if (_sl.
lf->
Read((byte*)hdr,
sizeof(hdr)) !=
sizeof(hdr))
SlError(STR_GAME_SAVELOAD_ERROR_FILE_NOT_READABLE);
2577 if (fmt ==
endof(_saveload_formats)) {
2578 DEBUG(sl, 0,
"Unknown savegame type, trying to load it as the buggy format");
2581 _sl_minor_version = 0;
2586 if (fmt ==
endof(_saveload_formats)) {
2590 if (fmt->
tag == TO_BE32X(
'OTTD'))
break;
2596 if (fmt->
tag == hdr[0]) {
2602 _sl_minor_version = (TO_BE32(hdr[1]) >> 8) & 0xFF;
2604 DEBUG(sl, 1,
"Loading savegame version %d", _sl_version);
2618 SlError(STR_GAME_SAVELOAD_ERROR_BROKEN_INTERNAL_ERROR, err_str);
2629 InitializeGame(256, 256,
true,
true);
2701 return DoLoad(reader,
false);
2730 InitializeGame(256, 256,
true,
true);
2738 if (!LoadOldSaveGame(filename))
return SL_REINIT;
2740 _sl_minor_version = 0;
2764 default: NOT_REACHED();
2774 if (fh ==
nullptr) {
2775 SlError(fop ==
SLO_SAVE ? STR_GAME_SAVELOAD_ERROR_FILE_NOT_WRITEABLE : STR_GAME_SAVELOAD_ERROR_FILE_NOT_READABLE);
2787 DEBUG(desync, 1,
"load: %s", filename);
2829 case 0:
SetDParam(1, STR_JUST_DATE_LONG);
break;
2830 case 1:
SetDParam(1, STR_JUST_DATE_TINY);
break;
2831 case 2:
SetDParam(1, STR_JUST_DATE_ISO);
break;
2832 default: NOT_REACHED();
2837 GetString(buf, !
Company::IsValidID(cid) ? STR_SAVEGAME_NAME_SPECTATOR : STR_SAVEGAME_NAME_DEFAULT, last);
2865 this->file_op = fop;
2866 this->detail_ftype = dft;
2867 this->abstract_ftype = aft;
FiosType
Elements of a file system that are recognized.
~FileWriter()
Make sure everything is cleaned up.
void Write(byte *buf, size_t size) override
Write a given number of bytes into the savegame.
Owner
Enum for all companies/owners.
AbstractFileType
The different abstract types of files that the system knows about.
const ChunkHandler _name_chunk_handlers[]
Chunk handlers related to strings.
static SaveOrLoadResult DoLoad(LoadFilter *reader, bool load_check)
Actually perform the loading of a "non-old" savegame.
static void SlFixPointers()
Fix all pointers (convert index -> pointer)
static size_t SlCalcNetStringLen(const char *ptr, size_t length)
Calculate the net length of a string.
static void SlLoadCheckChunks()
Load all chunks for savegame checking.
void Finish() override
Prepare everything to finish writing the savegame.
static SaveOrLoadResult SaveFileToDisk(bool threaded)
We have written the whole game into memory, _memory_savegame, now find and appropriate compressor and...
bool _networking
are we in networking mode?
static SaveLoadParams _sl
Parameters used for/at saveload.
ChunkSaveLoadProc * load_check_proc
Load procedure for game preview.
const SaveLoad * GetVehicleDescription(VehicleType vt)
Make it possible to make the saveload tables "friends" of other classes.
static size_t SlCalcDequeLen(const void *deque, VarType conv)
Return the size in bytes of a std::deque.
static bool IsSavegameVersionBefore(SaveLoadVersion major, byte minor=0)
Checks whether the savegame is below major.
byte * bufe
End of the buffer we can read from.
GRFConfig * _grfconfig
First item in list of current GRF set up.
static uint SlCalcConvMemLen(VarType conv)
Return the size in bytes of a certain type of normal/atomic variable as it appears in memory...
Subdirectory
The different kinds of subdirectories OpenTTD uses.
LZMALoadFilter(LoadFilter *chain)
Initialise this filter.
Filter using Zlib compression.
void GenerateDefaultSaveName(char *buf, const char *last)
Fill the buffer with the default name for a savegame or screenshot.
NeedLength need_length
working in NeedLength (Autolength) mode?
z_stream z
Stream state we are reading from.
void WriteByte(byte b)
Write a single byte into the dumper.
void SetMouseCursorBusy(bool busy)
Set or unset the ZZZ cursor.
SaveLoadVersion
SaveLoad versions Previous savegame versions, the trunk revision where they were introduced and the r...
void NORETURN SlErrorCorrupt(const char *msg)
Error handler for corrupt savegames.
Yes, simply writing to a file.
static Titem * Get(size_t index)
Returns Titem with given index.
static bool SlSkipVariableOnLoad(const SaveLoad *sld)
Are we going to load this variable when loading a savegame or not?
string (with pre-allocated buffer)
void SetName(const char *name)
Set the name of the file.
uint32 flags
Flags of the chunk.
void ClearGRFConfigList(GRFConfig **config)
Clear a GRF Config list, freeing all nodes.
int CDECL seprintf(char *str, const char *last, const char *format,...)
Safer implementation of snprintf; same as snprintf except:
lzma_stream lzma
Stream state that we are reading from.
lzma_stream lzma
Stream state that we are writing to.
do not synchronize over network (but it is saved if SLF_NOT_IN_SAVE is not set)
static void SlList(void *list, SLRefType conv)
Save/Load a list.
static size_t SlCalcArrayLen(size_t length, VarType conv)
Return the size in bytes of a certain type of atomic array.
void NORETURN SlError(StringID string, const char *extra_msg)
Error handler.
FileToSaveLoad _file_to_saveload
File to save or load in the openttd loop.
ZlibLoadFilter(LoadFilter *chain)
Initialise this filter.
fluid_settings_t * settings
FluidSynth settings handle.
void GamelogStartAction(GamelogActionType at)
Stores information about new action, but doesn't allocate it Action is allocated only when there is a...
static uint SlReadSimpleGamma()
Read in the header descriptor of an object or an array.
uint32 id
Unique ID (4 letters).
int CDECL vseprintf(char *str, const char *last, const char *format, va_list ap)
Safer implementation of vsnprintf; same as vsnprintf except:
char * CopyFromOldName(StringID id)
Copy and convert old custom names to UTF-8.
LZMASaveFilter(SaveFilter *chain, byte compression_level)
Initialise this filter.
Filter using LZO compression.
bool saveinprogress
Whether there is currently a save in progress.
GRFListCompatibility IsGoodGRFConfigList(GRFConfig *grfconfig)
Check if all GRFs in the GRF config from a savegame can be loaded.
Load/save a reference to a link graph job.
Declaration of filters used for saving and loading savegames.
GRFConfig * grfconfig
NewGrf configuration from save.
long begin
The begin of the file.
int64 ReadValue(const void *ptr, VarType conv)
Return a signed-long version of the value of a setting.
byte buf[MEMORY_CHUNK_SIZE]
Buffer we're going to read from.
SaveOrLoadResult SaveWithFilter(SaveFilter *writer, bool threaded)
Save the game using a (writer) filter.
Load/save an old-style reference to a vehicle (for pre-4.4 savegames).
void ShowErrorMessage(StringID summary_msg, StringID detailed_msg, WarningLevel wl, int x=0, int y=0, const GRFFile *textref_stack_grffile=nullptr, uint textref_stack_size=0, const uint32 *textref_stack=nullptr)
Display an error message in a window.
std::vector< byte * > blocks
Buffer with blocks of allocated memory.
static const SaveLoadFormat _saveload_formats[]
The different saveload formats known/understood by OpenTTD.
partial loading into _load_check_data
void CSleep(int milliseconds)
Sleep on the current thread for a defined time.
void Write(byte *buf, size_t size) override
Write a given number of bytes into the savegame.
void * address
address of variable OR offset of variable in the struct (max offset is 65536)
static void SaveFileDone()
Update the gui accordingly when saving is done and release locks on saveload.
DetailedFileType GetDetailedFileType(FiosType fios_type)
Extract the detailed file type from a FiosType.
const ChunkHandler _town_chunk_handlers[]
Chunk handler for towns.
void DoExitSave()
Do a save when exiting the game (_settings_client.gui.autosave_on_exit)
SaveLoadVersion _sl_version
the major savegame version identifier
Load/save a reference to a town.
#define lastof(x)
Get the last element of an fixed size array.
static void SetAsyncSaveFinish(AsyncSaveFinishProc proc)
Called by save thread to tell we finished saving.
const ChunkHandler _sign_chunk_handlers[]
Chunk handlers related to signs.
LoadFilter * reader
The filter used to actually read.
Filter without any compression.
virtual void Write(byte *buf, size_t len)=0
Write a given number of bytes into the savegame.
SavegameType
Types of save games.
void NORETURN SlErrorCorruptFmt(const char *format,...)
Issue an SlErrorCorrupt with a format string.
byte ff_state
The state of fast-forward when saving started.
static bool SlIsObjectValidInSavegame(const SaveLoad *sld)
Are we going to save this object or not?
size_t Read(byte *buf, size_t size) override
Read a given number of bytes from the savegame.
Deals with the type of the savegame, independent of extension.
size_t size
the sizeof size.
~ZlibLoadFilter()
Clean everything up.
size_t Read(byte *buf, size_t size) override
Read a given number of bytes from the savegame.
const char * GetSaveLoadErrorString()
Get the string representation of the error message.
FILE * file
The file to write to.
size_t SlGetFieldLength()
Get the length of the current object.
Load file for checking and/or preview.
void Write(byte *buf, size_t size) override
Write a given number of bytes into the savegame.
StringValidationSettings
Settings for the string validation.
not working in NeedLength mode
A connected component of a link graph.
static void SlSaveChunk(const ChunkHandler *ch)
Save a chunk of data (eg.
void SlArray(void *array, size_t length, VarType conv)
Save/Load an array.
void ProcessAsyncSaveFinish()
Handle async save finishes.
z_stream z
Stream state we are writing to.
Save game or scenario file.
Interface for filtering a savegame till it is loaded.
bool checkable
True if the savegame could be checked by SL_LOAD_CHECK. (Old savegames are not checkable.)
uint16 length
(conditional) length of the variable (eg. arrays) (max array size is 65536 elements) ...
Load/save a reference to a bus/truck stop.
virtual void Finish()
Prepare everything to finish writing the savegame.
Critical errors, the MessageBox is shown in all cases.
bool StartNewThread(std::thread *thr, const char *name, TFn &&_Fx, TArgs &&... _Ax)
Start a new thread.
Filter using Zlib compression.
static size_t SlCalcStringLen(const void *ptr, size_t length, VarType conv)
Calculate the gross length of the string that it will occupy in the savegame.
Shared order list linking together the linked list of orders and the list of vehicles sharing this or...
void SetDParamStr(uint n, const char *str)
This function is used to "bind" a C string to a OpenTTD dparam slot.
LoadCheckData _load_check_data
Data loaded from save during SL_LOAD_CHECK.
void WriteLoop(byte *p, size_t len, lzma_action action)
Helper loop for writing the data.
Base directory for all scenarios.
bool global
should we load a global variable or a non-global one
char _savegame_format[8]
how to compress savegames
void GamelogReset()
Resets and frees all memory allocated - used before loading or starting a new game.
void SetTitle(const char *title)
Set the title of the file.
Load/save a reference to an engine renewal (autoreplace).
ReadBuffer * reader
Savegame reading buffer.
VarType conv
type of the variable to be saved, int
static void SlCopyBytes(void *ptr, size_t length)
Save/Load bytes.
SLRefType
Type of reference (SLE_REF, SLE_CONDREF).
FILE * file
The file to read from.
const ChunkHandler _persistent_storage_chunk_handlers[]
Chunk handler for persistent storages.
DateFract _date_fract
Fractional part of the day.
allow new lines in the strings
Highest possible saveload version.
SaveOrLoadResult
Save or load result codes.
Filter using LZO compression.
void str_validate(char *str, const char *last, StringValidationSettings settings)
Scans the string for valid characters and if it finds invalid ones, replaces them with a question mar...
do not save with savegame, basically client-based
static void SlDeque(void *deque, VarType conv)
Save/load a std::deque.
Filter without any compression.
Old save game or scenario file.
~ZlibSaveFilter()
Clean up what we allocated.
allow control codes in the strings
static void SlSaveChunks()
Save all chunks.
5.0 1429 5.1 1440 5.2 1525 0.3.6
byte _sl_minor_version
the minor savegame version, DO NOT USE!
StringID offset into strings-array.
need to calculate the length
ClientSettings _settings_client
The current settings for this game.
static bool IsVariableSizeRight(const SaveLoad *sld)
Check whether the variable size of the variable in the saveload configuration matches with the actual...
FILE * FioFOpenFile(const char *filename, const char *mode, Subdirectory subdir, size_t *filesize)
Opens a OpenTTD file somewhere in a personal or global directory.
byte * bufe
End of the buffer we write to.
static std::atomic< AsyncSaveFinishProc > _async_save_finish
Callback to call when the savegame loading is finished.
Container for cargo from the same location and time.
static void SlDeque(void *deque, VarType conv)
Internal templated helper to save/load a std::deque.
uint8 date_format_in_default_names
should the default savegame/screenshot name use long dates (31th Dec 2008), short dates (31-12-2008) ...
void Clear()
Reset read data.
size_t SlCalcObjLength(const void *object, const SaveLoad *sld)
Calculate the size of an object.
Filter without any compression.
virtual void Reset()
Reset this filter to read from the beginning of the file.
const SaveLoad * GetBaseStationDescription()
Get the base station description to be used for SL_ST_INCLUDE.
Load/save a reference to a station.
const ChunkHandler _animated_tile_chunk_handlers[]
"Definition" imported by the saveload code to be able to load and save the animated tile table...
size_t obj_len
the length of the current object we are busy with
Base directory for all savegames.
Subdirectory of save for autosaves.
ReadBuffer(LoadFilter *reader)
Initialise our variables.
void SanitizeFilename(char *filename)
Sanitizes a filename, i.e.
Base directory for all subdirectories.
char * stredup(const char *s, const char *last)
Create a duplicate of the given string.
Class for pooled persistent storage of data.
static void SlLoadCheckChunk(const ChunkHandler *ch)
Load a chunk of data for checking savegames.
char * error_data
Data to pass to SetDParamStr when displaying error.
Load/save a reference to an order.
static std::thread _save_thread
The thread we're using to compress and write a savegame.
static void SlWriteSimpleGamma(size_t i)
Write the header descriptor of an object or an array.
void Write(byte *buf, size_t size) override
Write a given number of bytes into the savegame.
const SaveLoadVersion SAVEGAME_VERSION
Current savegame version of OpenTTD.
void Finish() override
Prepare everything to finish writing the savegame.
ZlibSaveFilter(SaveFilter *chain, byte compression_level)
Initialise this filter.
SaveOrLoadResult LoadWithFilter(LoadFilter *reader)
Load the game using a (reader) filter.
void SetSaveLoadError(StringID str)
Set the error message from outside of the actual loading/saving of the game (AfterLoadGame and friend...
static VarType GetVarFileType(VarType type)
Get the FileType of a setting.
AbstractFileType GetAbstractFileType(FiosType fios_type)
Extract the abstract file type from a FiosType.
MemoryDumper * dumper
Memory dumper to write the savegame to.
SaveOrLoadResult SaveOrLoad(const char *filename, SaveLoadOperation fop, DetailedFileType dft, Subdirectory sb, bool threaded)
Main Save or Load function where the high-level saveload functions are handled.
size_t GetSize() const
Get the size of the memory dump made so far.
static void SlLoadChunks()
Load all chunks.
void Write(byte *buf, size_t size) override
Write a given number of bytes into the savegame.
A buffer for reading (and buffering) savegame data.
#define lengthof(x)
Return the length of an fixed size array.
byte * buf
Buffer we're going to write to.
virtual size_t Read(byte *buf, size_t len)=0
Read a given number of bytes from the savegame.
static T min(const T a, const T b)
Returns the minimum of two values.
static const uint LZO_BUFFER_SIZE
Buffer size for the LZO compressor.
static uint SlGetGammaLength(size_t i)
Return how many bytes used to encode a gamma value.
byte SlReadByte()
Wrapper for reading a byte from the buffer.
StringID error
Error message from loading. INVALID_STRING_ID if no error.
static VarType GetVarMemType(VarType type)
Get the NumberType of a setting.
uint32 StringID
Numeric value that represents a string, independent of the selected language.
static void SaveFileError()
Show a gui message when saving has failed.
ChunkSaveLoadProc * save_proc
Save procedure of the chunk.
SaveLoadOperation
Operation performed on the file.
int SlIterateArray()
Iterate through the elements of an array and read the whole thing.
ChunkSaveLoadProc * load_proc
Load procedure of the chunk.
Load/save a reference to a vehicle.
static const ChunkHandler * SlFindChunkHandler(uint32 id)
Find the ChunkHandler that will be used for processing the found chunk in the savegame or in memory...
void Reset() override
Reset this filter to read from the beginning of the file.
Handlers and description of chunk.
static void SlSkipBytes(size_t length)
Read in bytes from the file/data structure but don't do anything with them, discarding them in effect...
void SlSkipArray()
Skip an array or sparse array.
The saveload struct, containing reader-writer functions, buffer, version, etc.
byte * bufp
Location we're at reading the buffer.
static size_t SlCalcDequeLen(const void *deque, VarType conv)
Internal templated helper to return the size in bytes of a std::deque.
static T Clamp(const T a, const T min, const T max)
Clamp a value between an interval.
void GamelogStopAction()
Stops logging of any changes.
#define DEBUG(name, level,...)
Output a line of debugging information.
StringID RemapOldStringID(StringID s)
Remap a string ID from the old format to the new format.
string enclosed in quotes (with pre-allocated buffer)
static void ClearSaveLoadState()
Clear/free saveload state.
size_t Read(byte *buf, size_t size) override
Read a given number of bytes from the savegame.
static void * GetVariableAddress(const void *object, const SaveLoad *sld)
Get the address of the variable.
MemoryDumper()
Initialise our variables.
static const lzma_stream _lzma_init
Have a copy of an initialised LZMA stream.
bool AfterLoadGame()
Perform a (large) amount of savegame conversion magic in order to load older savegames and to fill th...
static void SlStubSaveProc2(void *arg)
Stub Chunk handlers to only calculate length and do nothing else.
SaveLoadAction action
are we doing a save or a load atm.
static const SaveLoadFormat * GetSavegameFormat(char *s, byte *compression_level)
Return the savegameformat of the game.
Load/save a reference to a cargo packet.
bool error
did an error occur or not
GUISettings gui
settings related to the GUI
static Pool::IterateWrapper< Titem > Iterate(size_t from=0)
Returns an iterable ensemble of all valid Titem.
const ChunkHandler _cargopacket_chunk_handlers[]
Chunk handlers related to cargo packets.
static const size_t MEMORY_CHUNK_SIZE
Save in chunks of 128 KiB.
static bool StrEmpty(const char *s)
Check if a string buffer is empty.
SaveLoadVersion version_to
save/load the variable until this savegame version
const ChunkHandler _cargomonitor_chunk_handlers[]
Chunk definition of the cargomonitoring maps.
static void SlNullPointers()
Null all pointers (convert index -> nullptr)
Replace the unknown/bad bits with question marks.
~LZMALoadFilter()
Clean everything up.
useful to write zeros in savegame.
string pointer enclosed in quotes
Invalid or unknown file type.
~FileReader()
Make sure everything is cleaned up.
Struct to store engine replacements.
static void SaveFileStart()
Update the gui accordingly when starting saving and set locks on saveload.
static uint GB(const T x, const uint8 s, const uint8 n)
Fetch n bits from x, started at bit s.
SaveLoadType cmd
the action to take with the saved/loaded type, All types need different action
char * strecpy(char *dst, const char *src, const char *last)
Copies characters from one buffer to another.
void SlObject(void *object, const SaveLoad *sld)
Main SaveLoad function.
#define endof(x)
Get the end element of an fixed size array.
static byte SlCalcConvFileLen(VarType conv)
Return the size in bytes of a certain type of normal/atomic variable as it appears in a saved game...
size_t Read(byte *buf, size_t size) override
Read a given number of bytes from the savegame.
Statusbar (at the bottom of your screen); Window numbers:
static bool IsValidID(size_t index)
Tests whether given index is a valid index for station of this type.
FileReader(FILE *file)
Create the file reader, so it reads from a specific file.
bool _network_server
network-server is active
A Stop for a Road Vehicle.
static bool IsValidID(size_t index)
Tests whether given index can be used to get valid (non-nullptr) Titem.
StringID error_str
the translatable error message to show
void SlGlobList(const SaveLoadGlobVarList *sldg)
Save or Load (a list of) global variables.
LZOSaveFilter(SaveFilter *chain, byte compression_level)
Initialise this filter.
char * extra_msg
the error message
void SlAutolength(AutolengthProc *proc, void *arg)
Do something of which I have no idea what it is :P.
const ChunkHandler _cheat_chunk_handlers[]
Chunk handlers related to cheats.
void str_fix_scc_encoded(char *str, const char *last)
Scan the string for old values of SCC_ENCODED and fix it to it's new, static value.
Allow the special control codes.
static const StringID INVALID_STRING_ID
Constant representing an invalid string (16bit in case it is used in savegames)
static size_t SlCalcListLen(const void *list)
Return the size in bytes of a list.
static void free(const void *ptr)
Version of the standard free that accepts const pointers.
void Flush(SaveFilter *writer)
Flush this dumper into a writer.
SavegameType _savegame_type
type of savegame we are loading
SaveLoadAction
What are we currently doing?
SaveFilter * sf
Filter to write the savegame to.
bool threaded_saves
should we do threaded saves?
Load/save a reference to an orderlist.
Filter using LZMA compression.
static bool HasBit(const T x, const uint8 y)
Checks if a bit in a value is set.
Template class to help with std::deque.
Load/save a reference to a link graph.
FileWriter(FILE *file)
Create the file writer, so it writes to a specific file.
static void SlStubSaveProc()
Stub Chunk handlers to only calculate length and do nothing else.
void(* AsyncSaveFinishProc)()
Callback for when the savegame loading is finished.
void SlSetLength(size_t length)
Sets the length of either a RIFF object or the number of items in an array.
void SetMode(FiosType ft)
Set the mode and file type of the file to save or load based on the type of file entry at the file sy...
static void SlLoadChunk(const ChunkHandler *ch)
Load a chunk of data (eg vehicles, stations, etc.)
static uint32 BSWAP32(uint32 x)
Perform a 32 bits endianness bitswap on x.
size_t GetSize() const
Get the size of the memory dump made so far.
Interface for filtering a savegame till it is written.
static SaveOrLoadResult DoSave(SaveFilter *writer, bool threaded)
Actually perform the saving of the savegame.
NoCompSaveFilter(SaveFilter *chain, byte compression_level)
Initialise this filter.
LoadFilter * lf
Filter to read the savegame from.
Errors (eg. saving/loading failed)
static void SlString(void *ptr, size_t length, VarType conv)
Save/Load a string.
error that was caught before internal structures were modified
static Station * Get(size_t index)
Gets station with given index.
Date _date
Current date in days (day counter)
void Finish() override
Prepare everything to finish writing the savegame.
null all pointers (on loading error)
LZOLoadFilter(LoadFilter *chain)
Initialise this filter.
~LZMASaveFilter()
Clean up what we allocated.
size_t read
The amount of read bytes so far from the filter.
Declaration of functions used in more save/load files.
CompanyID _local_company
Company controlled by the human player at this client. Can also be COMPANY_SPECTATOR.
DetailedFileType
Kinds of files in each AbstractFileType.
size_t Read(byte *buf, size_t ssize) override
Read a given number of bytes from the savegame.
Container for dumping the savegame (quickly) to memory.
void WriteValue(void *ptr, VarType conv, int64 val)
Write the value of a setting.
void SlWriteByte(byte b)
Wrapper for writing a byte to the dumper.
GRFListCompatibility grf_compatibility
Summary state of NewGrfs, whether missing files or only compatible found.
static const ChunkHandler *const _chunk_handlers[]
Array of all chunks in a savegame, nullptr terminated.
static ChunkSaveLoadProc * _stub_save_proc
Stub Chunk handlers to only calculate length and do nothing else.
bool _do_autosave
are we doing an autosave at the moment?
NoCompLoadFilter(LoadFilter *chain)
Initialise this filter.
static size_t ReferenceToInt(const void *obj, SLRefType rt)
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 nullptr item has value 0, and all indices have +1, so vehicle 0 is saved as index 1.
int last_array_index
in the case of an array, the current and last positions
static void SlSaveLoadConv(void *ptr, VarType conv)
Handle all conversion and typechecking of variables here.
Class for calculation jobs to be run on link graphs.
static void * IntToReference(size_t index, SLRefType rt)
Pointers cannot be loaded from a savegame, so this function gets the index from the savegame and retu...
void InvalidateWindowData(WindowClass cls, WindowNumber number, int data, bool gui_scope)
Mark window data of the window of a given class and specific window number as invalid (in need of re-...
old custom name to be converted to a char pointer
4.0 1 4.1 122 0.3.3, 0.3.4 4.2 1222 0.3.5 4.3 1417 4.4 1426
uint32 _ttdp_version
version of TTDP savegame (if applicable)
static size_t SlCalcRefLen()
Return the size in bytes of a reference (pointer)
Load/save a reference to a persistent storage.
void WriteLoop(byte *p, size_t len, int mode)
Helper loop for writing the data.
#define FOR_ALL_CHUNK_HANDLERS(ch)
Iterate over all chunk handlers.
static void SetDParam(uint n, uint64 v)
Set a string parameter v at index n in the global string parameter array.
Yes, simply reading from a file.
error that was caught in the middle of updating game state, need to clear it. (can only happen during...