26 #include "../stdafx.h" 28 #include "../station_base.h" 29 #include "../thread/thread.h" 31 #include "../network/network.h" 32 #include "../window_func.h" 33 #include "../strings_func.h" 34 #include "../core/endian_func.hpp" 35 #include "../vehicle_base.h" 36 #include "../company_func.h" 37 #include "../date_func.h" 38 #include "../autoreplace_base.h" 39 #include "../roadstop_base.h" 40 #include "../linkgraph/linkgraph.h" 41 #include "../linkgraph/linkgraphjob.h" 42 #include "../statusbar_gui.h" 43 #include "../fileio_func.h" 44 #include "../gamelog.h" 45 #include "../string_func.h" 49 #include "table/strings.h" 54 #include "../safeguards.h" 101 inline byte ReadByte()
103 if (this->bufp == this->bufe) {
104 size_t len = this->reader->
Read(this->buf,
lengthof(this->buf));
108 this->bufp = this->
buf;
109 this->bufe = this->buf + len;
112 return *this->bufp++;
121 return this->read - (this->bufe - this->
bufp);
144 if (this->buf == this->bufe) {
163 size_t to_write =
min(MEMORY_CHUNK_SIZE, t);
165 writer->
Write(this->blocks[i++], to_write);
178 return this->blocks.
Length() * MEMORY_CHUNK_SIZE - (this->bufe - this->
buf);
235 extern const ChunkHandler _autoreplace_chunk_handlers[];
244 _gamelog_chunk_handlers,
246 _misc_chunk_handlers,
249 _setting_chunk_handlers,
251 _waypoint_chunk_handlers,
252 _depot_chunk_handlers,
253 _order_chunk_handlers,
254 _industry_chunk_handlers,
255 _economy_chunk_handlers,
256 _subsidy_chunk_handlers,
258 _goal_chunk_handlers,
259 _story_page_chunk_handlers,
260 _engine_chunk_handlers,
263 _station_chunk_handlers,
264 _company_chunk_handlers,
266 _game_chunk_handlers,
268 _newgrf_chunk_handlers,
269 _group_chunk_handlers,
271 _autoreplace_chunk_handlers,
272 _labelmaps_chunk_handlers,
273 _linkgraph_chunk_handlers,
274 _airport_chunk_handlers,
275 _object_chunk_handlers,
284 #define FOR_ALL_CHUNK_HANDLERS(ch) \ 285 for (const ChunkHandler * const *chsc = _chunk_handlers; *chsc != NULL; chsc++) \ 286 for (const ChunkHandler *ch = *chsc; ch != NULL; ch = (ch->flags & CH_LAST) ? NULL : ch + 1) 298 DEBUG(sl, 1,
"Nulling pointers");
301 if (ch->ptrs_proc != NULL) {
302 DEBUG(sl, 2,
"Nulling pointers for %c%c%c%c", ch->id >> 24, ch->id >> 16, ch->id >> 8, ch->id);
307 DEBUG(sl, 1,
"All pointers nulled");
338 throw std::exception();
350 SlError(STR_GAME_SAVELOAD_ERROR_BROKEN_SAVEGAME, msg);
364 if (_exit_game)
return;
365 while (_async_save_finish != NULL) CSleep(10);
367 _async_save_finish = proc;
375 if (_async_save_finish == NULL)
return;
379 _async_save_finish = NULL;
381 if (_save_thread != NULL) {
382 _save_thread->
Join();
394 return _sl.
reader->ReadByte();
406 static inline int SlReadUint16()
412 static inline uint32 SlReadUint32()
414 uint32 x = SlReadUint16() << 16;
415 return x | SlReadUint16();
418 static inline uint64 SlReadUint64()
420 uint32 x = SlReadUint32();
421 uint32 y = SlReadUint32();
422 return (uint64)x << 32 | y;
425 static inline void SlWriteUint16(uint16 v)
431 static inline void SlWriteUint32(uint32 v)
433 SlWriteUint16(
GB(v, 16, 16));
434 SlWriteUint16(
GB(v, 0, 16));
437 static inline void SlWriteUint64(uint64 x)
439 SlWriteUint32((uint32)(x >> 32));
440 SlWriteUint32((uint32)x);
507 if (i >= (1 << 14)) {
508 if (i >= (1 << 21)) {
509 if (i >= (1 << 28)) {
510 assert(i <= UINT32_MAX);
531 return 1 + (i >= (1 << 7)) + (i >= (1 << 14)) + (i >= (1 << 21)) + (i >= (1 << 28));
534 static inline uint SlReadSparseIndex()
539 static inline void SlWriteSparseIndex(uint index)
544 static inline uint SlReadArrayLength()
549 static inline void SlWriteArrayLength(
size_t length)
554 static inline uint SlGetArrayLength(
size_t length)
567 static const byte conv_mem_size[] = {1, 1, 1, 2, 2, 4, 4, 8, 8, 0};
568 byte length =
GB(conv, 4, 4);
570 switch (length << 4) {
575 return SlReadArrayLength();
578 assert(length <
lengthof(conv_mem_size));
579 return conv_mem_size[length];
591 static const byte conv_file_size[] = {1, 1, 2, 2, 4, 4, 8, 8, 2};
592 byte length =
GB(conv, 0, 4);
593 assert(length <
lengthof(conv_file_size));
594 return conv_file_size[length];
603 void SlSetArrayIndex(uint index)
606 _sl.array_index = index;
609 static size_t _next_offs;
624 uint length = SlReadArrayLength();
634 case CH_SPARSE_ARRAY: index = (int)SlReadSparseIndex();
break;
635 case CH_ARRAY: index = _sl.array_index++;
break;
637 DEBUG(sl, 0,
"SlIterateArray error");
641 if (length != 0)
return index;
672 assert(length < (1 << 28));
673 SlWriteUint32((uint32)((length & 0xFFFFFF) | ((length >> 24) << 28)));
678 SlWriteArrayLength(1);
680 SlWriteArrayLength(length + 1);
682 case CH_SPARSE_ARRAY:
683 SlWriteArrayLength(length + 1 + SlGetArrayLength(_sl.array_index));
684 SlWriteSparseIndex(_sl.array_index);
686 default: NOT_REACHED();
694 default: NOT_REACHED();
706 byte *p = (byte *)ptr;
711 for (; length != 0; length--) *p++ =
SlReadByte();
716 default: NOT_REACHED();
736 case SLE_VAR_BL:
return (*(
const bool *)ptr != 0);
737 case SLE_VAR_I8:
return *(
const int8 *)ptr;
738 case SLE_VAR_U8:
return *(
const byte *)ptr;
739 case SLE_VAR_I16:
return *(
const int16 *)ptr;
740 case SLE_VAR_U16:
return *(
const uint16*)ptr;
741 case SLE_VAR_I32:
return *(
const int32 *)ptr;
742 case SLE_VAR_U32:
return *(
const uint32*)ptr;
743 case SLE_VAR_I64:
return *(
const int64 *)ptr;
744 case SLE_VAR_U64:
return *(
const uint64*)ptr;
746 default: NOT_REACHED();
760 case SLE_VAR_BL: *(
bool *)ptr = (val != 0);
break;
761 case SLE_VAR_I8: *(int8 *)ptr = val;
break;
762 case SLE_VAR_U8: *(byte *)ptr = val;
break;
763 case SLE_VAR_I16: *(int16 *)ptr = val;
break;
764 case SLE_VAR_U16: *(uint16*)ptr = val;
break;
765 case SLE_VAR_I32: *(int32 *)ptr = val;
break;
766 case SLE_VAR_U32: *(uint32*)ptr = val;
break;
767 case SLE_VAR_I64: *(int64 *)ptr = val;
break;
768 case SLE_VAR_U64: *(uint64*)ptr = val;
break;
771 default: NOT_REACHED();
791 case SLE_FILE_I8: assert(x >= -128 && x <= 127);
SlWriteByte(x);
break;
792 case SLE_FILE_U8: assert(x >= 0 && x <= 255);
SlWriteByte(x);
break;
793 case SLE_FILE_I16:assert(x >= -32768 && x <= 32767); SlWriteUint16(x);
break;
795 case SLE_FILE_U16:assert(x >= 0 && x <= 65535); SlWriteUint16(x);
break;
797 case SLE_FILE_U32: SlWriteUint32((uint32)x);
break;
799 case SLE_FILE_U64: SlWriteUint64(x);
break;
800 default: NOT_REACHED();
809 case SLE_FILE_I8: x = (int8 )
SlReadByte();
break;
810 case SLE_FILE_U8: x = (byte )
SlReadByte();
break;
811 case SLE_FILE_I16: x = (int16 )SlReadUint16();
break;
812 case SLE_FILE_U16: x = (uint16)SlReadUint16();
break;
813 case SLE_FILE_I32: x = (int32 )SlReadUint32();
break;
814 case SLE_FILE_U32: x = (uint32)SlReadUint32();
break;
815 case SLE_FILE_I64: x = (int64 )SlReadUint64();
break;
816 case SLE_FILE_U64: x = (uint64)SlReadUint64();
break;
818 default: NOT_REACHED();
827 default: NOT_REACHED();
842 if (ptr == NULL)
return 0;
843 return min(strlen(ptr), length - 1);
861 default: NOT_REACHED();
864 str = *(
const char *
const *)ptr;
869 str = (
const char *)ptr;
875 return len + SlGetArrayLength(len);
884 static void SlString(
void *ptr,
size_t length, VarType conv)
890 default: NOT_REACHED();
902 SlWriteArrayLength(len);
908 size_t len = SlReadArrayLength();
911 default: NOT_REACHED();
915 DEBUG(sl, 1,
"String length in savegame is bigger than buffer, truncating");
927 *(
char **)ptr = NULL;
930 *(
char **)ptr = MallocT<char>(len + 1);
937 ((
char *)ptr)[len] =
'\0';
953 default: NOT_REACHED();
973 void SlArray(
void *array,
size_t length, VarType conv)
988 if (conv == SLE_INT16 || conv == SLE_UINT16 || conv == SLE_STRINGID ||
989 conv == SLE_INT32 || conv == SLE_UINT32) {
994 if (conv == (SLE_FILE_I32 | SLE_VAR_I64)) {
995 for (uint i = 0; i < length; i++) {
996 ((int64*)array)[i] = (int32)
BSWAP32(SlReadUint32());
1004 if (conv == SLE_INT8 || conv == SLE_UINT8) {
1007 byte *a = (byte*)array;
1010 for (; length != 0; length --) {
1032 if (obj == NULL)
return 0;
1047 default: NOT_REACHED();
1063 assert_compile(
sizeof(
size_t) <=
sizeof(
void *));
1128 default: NOT_REACHED();
1138 const std::list<void *> *l = (
const std::list<void *> *) list;
1143 return l->size() * type_size + type_size;
1161 typedef std::list<void *> PtrList;
1162 PtrList *l = (PtrList *)list;
1166 SlWriteUint32((uint32)l->size());
1168 PtrList::iterator iter;
1169 for (iter = l->begin(); iter != l->end(); ++iter) {
1180 for (
size_t i = 0; i < length; i++) {
1182 l->push_back((
void *)data);
1190 PtrList::iterator iter;
1191 for (iter = temp.begin(); iter != temp.end(); ++iter) {
1200 default: NOT_REACHED();
1208 template <
typename T>
1210 typedef std::deque<T> SlDequeT;
1219 const SlDequeT *l = (
const SlDequeT *)deque;
1234 SlDequeT *l = (SlDequeT *)deque;
1238 SlWriteUint32((uint32)l->size());
1240 typename SlDequeT::iterator iter;
1241 for (iter = l->begin(); iter != l->end(); ++iter) {
1248 size_t length = SlReadUint32();
1251 for (
size_t i = 0; i < length; i++) {
1263 default: NOT_REACHED();
1291 default: NOT_REACHED();
1323 default: NOT_REACHED();
1331 if (_sl_version < sld->version_from || _sl_version >= sld->
version_to)
return false;
1363 for (; sld->
cmd != SL_END; sld++) {
1364 length += SlCalcObjMemberLength(
object, sld);
1369 size_t SlCalcObjMemberLength(
const void *
object,
const SaveLoad *sld)
1390 default: NOT_REACHED();
1393 case SL_WRITEBYTE:
return 1;
1396 default: NOT_REACHED();
1414 return sld->
size ==
sizeof(bool);
1417 return sld->
size ==
sizeof(int8);
1420 return sld->
size ==
sizeof(int16);
1423 return sld->
size ==
sizeof(int32);
1426 return sld->
size ==
sizeof(int64);
1428 return sld->
size ==
sizeof(
void *);
1432 return sld->
size ==
sizeof(
void *);
1445 bool SlObjectMember(
void *ptr,
const SaveLoad *sld)
1451 VarType conv =
GB(sld->
conv, 0, 8);
1478 *(
void **)ptr = NULL;
1480 default: NOT_REACHED();
1487 default: NOT_REACHED();
1501 default: NOT_REACHED();
1506 case SL_VEH_INCLUDE:
1514 default: NOT_REACHED();
1532 for (; sld->
cmd != SL_END; sld++) {
1534 SlObjectMember(ptr, sld);
1590 _sl.array_index = 0;
1594 case CH_SPARSE_ARRAY:
1599 if ((m & 0xF) == CH_RIFF) {
1601 len = (
SlReadByte() << 16) | ((m >> 4) << 24);
1602 len += SlReadUint16();
1630 _sl.array_index = 0;
1637 case CH_SPARSE_ARRAY:
1645 if ((m & 0xF) == CH_RIFF) {
1647 len = (
SlReadByte() << 16) | ((m >> 4) << 24);
1648 len += SlReadUint16();
1697 ChunkSaveLoadProc *proc = ch->
save_proc;
1700 if (proc == NULL)
return;
1702 SlWriteUint32(ch->
id);
1703 DEBUG(sl, 2,
"Saving chunk %c%c%c%c", ch->
id >> 24, ch->
id >> 16, ch->
id >> 8, ch->
id);
1705 if (ch->
flags & CH_AUTO_LENGTH) {
1707 _stub_save_proc = proc;
1712 switch (ch->
flags & CH_TYPE_MASK) {
1721 SlWriteArrayLength(0);
1723 case CH_SPARSE_ARRAY:
1726 SlWriteArrayLength(0);
1728 default: NOT_REACHED();
1761 for (
id = SlReadUint32();
id != 0;
id = SlReadUint32()) {
1762 DEBUG(sl, 2,
"Loading chunk %c%c%c%c",
id >> 24,
id >> 16,
id >> 8,
id);
1776 for (
id = SlReadUint32();
id != 0;
id = SlReadUint32()) {
1777 DEBUG(sl, 2,
"Loading chunk %c%c%c%c",
id >> 24,
id >> 16,
id >> 8,
id);
1790 DEBUG(sl, 1,
"Fixing pointers");
1793 if (ch->ptrs_proc != NULL) {
1794 DEBUG(sl, 2,
"Fixing pointers for %c%c%c%c", ch->id >> 24, ch->id >> 16, ch->id >> 8, ch->id);
1799 DEBUG(sl, 1,
"All pointers fixed");
1821 if (this->file != NULL) fclose(this->file);
1831 if (this->file == NULL)
return 0;
1833 return fread(buf, 1, size, this->file);
1838 clearerr(this->file);
1839 if (fseek(this->file, this->begin, SEEK_SET)) {
1840 DEBUG(sl, 1,
"Could not reset the file reading");
1869 if (this->file == NULL)
return;
1871 if (fwrite(buf, 1, size, this->file) != size)
SlError(STR_GAME_SAVELOAD_ERROR_FILE_NOT_WRITEABLE);
1876 if (this->file != NULL) fclose(this->file);
1886 #include <lzo/lzo1x.h> 1899 if (lzo_init() != LZO_E_OK)
SlError(STR_GAME_SAVELOAD_ERROR_BROKEN_INTERNAL_ERROR,
"cannot initialize decompressor");
1904 assert(ssize >= LZO_BUFFER_SIZE);
1907 byte out[LZO_BUFFER_SIZE + LZO_BUFFER_SIZE / 16 + 64 + 3 +
sizeof(uint32) * 2];
1910 lzo_uint len = ssize;
1913 if (this->chain->Read((byte*)tmp,
sizeof(tmp)) !=
sizeof(tmp))
SlError(STR_GAME_SAVELOAD_ERROR_FILE_NOT_READABLE,
"File read failed");
1916 ((uint32*)out)[0] = size = tmp[1];
1919 tmp[0] = TO_BE32(tmp[0]);
1920 size = TO_BE32(size);
1926 if (this->chain->Read(out +
sizeof(uint32), size) != size)
SlError(STR_GAME_SAVELOAD_ERROR_FILE_NOT_READABLE);
1929 if (tmp[0] != lzo_adler32(0, out, size +
sizeof(uint32)))
SlErrorCorrupt(
"Bad checksum");
1932 int ret = lzo1x_decompress_safe(out +
sizeof(uint32) * 1, size, buf, &len, NULL);
1933 if (ret != LZO_E_OK)
SlError(STR_GAME_SAVELOAD_ERROR_FILE_NOT_READABLE);
1947 if (lzo_init() != LZO_E_OK)
SlError(STR_GAME_SAVELOAD_ERROR_BROKEN_INTERNAL_ERROR,
"cannot initialize compressor");
1952 const lzo_bytep in =
buf;
1954 byte out[LZO_BUFFER_SIZE + LZO_BUFFER_SIZE / 16 + 64 + 3 +
sizeof(uint32) * 2];
1955 byte wrkmem[LZO1X_1_MEM_COMPRESS];
1960 lzo_uint len = size > LZO_BUFFER_SIZE ?
LZO_BUFFER_SIZE : (lzo_uint)size;
1961 lzo1x_1_compress(in, len, out +
sizeof(uint32) * 2, &outlen, wrkmem);
1962 ((uint32*)out)[1] = TO_BE32((uint32)outlen);
1963 ((uint32*)out)[0] = TO_BE32(lzo_adler32(0, out +
sizeof(uint32), outlen +
sizeof(uint32)));
1964 this->chain->Write(out, outlen +
sizeof(uint32) * 2);
1991 return this->chain->Read(buf, size);
2008 this->chain->Write(buf, size);
2016 #if defined(WITH_ZLIB) 2030 memset(&this->z, 0,
sizeof(this->z));
2031 if (inflateInit(&this->z) != Z_OK)
SlError(STR_GAME_SAVELOAD_ERROR_BROKEN_INTERNAL_ERROR,
"cannot initialize decompressor");
2037 inflateEnd(&this->z);
2042 this->z.next_out =
buf;
2043 this->z.avail_out = (uint)size;
2047 if (this->z.avail_in == 0) {
2048 this->z.next_in = this->fread_buf;
2049 this->z.avail_in = (uint)this->chain->Read(this->fread_buf,
sizeof(this->fread_buf));
2053 int r = inflate(&this->z, 0);
2054 if (r == Z_STREAM_END)
break;
2056 if (r != Z_OK)
SlError(STR_GAME_SAVELOAD_ERROR_BROKEN_INTERNAL_ERROR,
"inflate() failed");
2057 }
while (this->z.avail_out != 0);
2059 return size - this->z.avail_out;
2074 memset(&this->z, 0,
sizeof(this->z));
2075 if (deflateInit(&this->z, compression_level) != Z_OK)
SlError(STR_GAME_SAVELOAD_ERROR_BROKEN_INTERNAL_ERROR,
"cannot initialize compressor");
2081 deflateEnd(&this->z);
2094 this->z.next_in = p;
2095 this->z.avail_in = (uInt)len;
2097 this->z.next_out =
buf;
2098 this->z.avail_out =
sizeof(
buf);
2107 int r = deflate(&this->z, mode);
2110 if ((n =
sizeof(buf) - this->z.avail_out) != 0) {
2111 this->chain->Write(buf, n);
2113 if (r == Z_STREAM_END)
break;
2115 if (r != Z_OK)
SlError(STR_GAME_SAVELOAD_ERROR_BROKEN_INTERNAL_ERROR,
"zlib returned error code");
2116 }
while (this->z.avail_in || !this->z.avail_out);
2121 this->WriteLoop(buf, size, 0);
2126 this->WriteLoop(NULL, 0, Z_FINISH);
2127 this->chain->Finish();
2137 #if defined(WITH_LZMA) 2160 if (lzma_auto_decoder(&this->lzma, 1 << 28, 0) != LZMA_OK)
SlError(STR_GAME_SAVELOAD_ERROR_BROKEN_INTERNAL_ERROR,
"cannot initialize decompressor");
2166 lzma_end(&this->lzma);
2171 this->lzma.next_out =
buf;
2172 this->lzma.avail_out = size;
2176 if (this->lzma.avail_in == 0) {
2177 this->lzma.next_in = this->fread_buf;
2178 this->lzma.avail_in = this->chain->Read(this->fread_buf,
sizeof(this->fread_buf));
2182 lzma_ret r = lzma_code(&this->lzma, LZMA_RUN);
2183 if (r == LZMA_STREAM_END)
break;
2184 if (r != LZMA_OK)
SlError(STR_GAME_SAVELOAD_ERROR_BROKEN_INTERNAL_ERROR,
"liblzma returned error code");
2185 }
while (this->lzma.avail_out != 0);
2187 return size - this->lzma.avail_out;
2202 if (lzma_easy_encoder(&this->lzma, compression_level, LZMA_CHECK_CRC32) != LZMA_OK)
SlError(STR_GAME_SAVELOAD_ERROR_BROKEN_INTERNAL_ERROR,
"cannot initialize compressor");
2208 lzma_end(&this->lzma);
2221 this->lzma.next_in = p;
2222 this->lzma.avail_in = len;
2224 this->lzma.next_out =
buf;
2225 this->lzma.avail_out =
sizeof(
buf);
2227 lzma_ret r = lzma_code(&this->lzma, action);
2230 if ((n =
sizeof(buf) - this->lzma.avail_out) != 0) {
2231 this->chain->Write(buf, n);
2233 if (r == LZMA_STREAM_END)
break;
2234 if (r != LZMA_OK)
SlError(STR_GAME_SAVELOAD_ERROR_BROKEN_INTERNAL_ERROR,
"liblzma returned error code");
2235 }
while (this->lzma.avail_in || !this->lzma.avail_out);
2240 this->WriteLoop(buf, size, LZMA_RUN);
2245 this->WriteLoop(NULL, 0, LZMA_FINISH);
2246 this->chain->Finish();
2271 #if defined(WITH_LZO) 2273 {
"lzo", TO_BE32X(
'OTTD'), CreateLoadFilter<LZOLoadFilter>, CreateSaveFilter<LZOSaveFilter>, 0, 0, 0},
2275 {
"lzo", TO_BE32X(
'OTTD'), NULL, NULL, 0, 0, 0},
2278 {
"none", TO_BE32X(
'OTTN'), CreateLoadFilter<NoCompLoadFilter>, CreateSaveFilter<NoCompSaveFilter>, 0, 0, 0},
2279 #if defined(WITH_ZLIB) 2283 {
"zlib", TO_BE32X(
'OTTZ'), CreateLoadFilter<ZlibLoadFilter>, CreateSaveFilter<ZlibSaveFilter>, 0, 6, 9},
2285 {
"zlib", TO_BE32X(
'OTTZ'), NULL, NULL, 0, 0, 0},
2287 #if defined(WITH_LZMA) 2293 {
"lzma", TO_BE32X(
'OTTX'), CreateLoadFilter<LZMALoadFilter>, CreateSaveFilter<LZMASaveFilter>, 0, 2, 9},
2295 {
"lzma", TO_BE32X(
'OTTX'), NULL, NULL, 0, 0, 0},
2315 char *complevel = strrchr(s,
':');
2316 if (complevel != NULL) *complevel =
'\0';
2318 for (
const SaveLoadFormat *slf = &_saveload_formats[0]; slf !=
endof(_saveload_formats); slf++) {
2319 if (slf->init_write != NULL && strcmp(s, slf->name) == 0) {
2320 *compression_level = slf->default_compression;
2321 if (complevel != NULL) {
2330 long level = strtol(complevel, &end, 10);
2331 if (end == complevel || level !=
Clamp(level, slf->min_compression, slf->max_compression)) {
2335 *compression_level = level;
2347 if (complevel != NULL) *complevel =
':';
2354 void InitializeGame(uint size_x, uint size_y,
bool reset_date,
bool reset_settings);
2356 extern bool LoadOldSaveGame(
const char *file);
2394 if (_game_mode != GM_MENU) _fast_forward = _sl.
ff_state;
2413 static char err_str[512];
2414 GetString(err_str, _sl.
action ==
SLA_SAVE ? STR_ERROR_GAME_SAVE_FAILED : STR_ERROR_GAME_LOAD_FAILED,
lastof(err_str));
2438 _sl.
sf->
Write((byte*)hdr,
sizeof(hdr));
2455 if (_sl.
error_str != STR_NETWORK_ERROR_LOSTCONNECTION) {
2476 void WaitTillSaved()
2478 if (_save_thread == NULL)
return;
2480 _save_thread->
Join();
2482 _save_thread = NULL;
2505 SaveViewportBeforeSaveGame();
2510 if (threaded)
DEBUG(sl, 1,
"Cannot create savegame thread, reverting to single-threaded mode...");
2531 return DoSave(writer, threaded);
2556 if (_sl.
lf->
Read((byte*)hdr,
sizeof(hdr)) !=
sizeof(hdr))
SlError(STR_GAME_SAVELOAD_ERROR_FILE_NOT_READABLE);
2562 if (fmt ==
endof(_saveload_formats)) {
2563 DEBUG(sl, 0,
"Unknown savegame type, trying to load it as the buggy format");
2566 _sl_minor_version = 0;
2571 if (fmt ==
endof(_saveload_formats)) {
2575 if (fmt->
tag == TO_BE32X(
'OTTD'))
break;
2581 if (fmt->
tag == hdr[0]) {
2587 _sl_minor_version = (TO_BE32(hdr[1]) >> 8) & 0xFF;
2589 DEBUG(sl, 1,
"Loading savegame version %d", _sl_version);
2603 SlError(STR_GAME_SAVELOAD_ERROR_BROKEN_INTERNAL_ERROR, err_str);
2614 InitializeGame(256, 256,
true,
true);
2686 return DoLoad(reader,
false);
2715 InitializeGame(256, 256,
true,
true);
2723 if (!LoadOldSaveGame(filename))
return SL_REINIT;
2725 _sl_minor_version = 0;
2749 default: NOT_REACHED();
2760 SlError(fop ==
SLO_SAVE ? STR_GAME_SAVELOAD_ERROR_FILE_NOT_WRITEABLE : STR_GAME_SAVELOAD_ERROR_FILE_NOT_READABLE);
2772 DEBUG(desync, 1,
"load: %s", filename);
2805 FOR_ALL_COMPANIES(c) {
2815 case 0:
SetDParam(1, STR_JUST_DATE_LONG);
break;
2816 case 1:
SetDParam(1, STR_JUST_DATE_TINY);
break;
2817 case 2:
SetDParam(1, STR_JUST_DATE_ISO);
break;
2818 default: NOT_REACHED();
2823 GetString(buf, !
Company::IsValidID(cid) ? STR_SAVEGAME_NAME_SPECTATOR : STR_SAVEGAME_NAME_DEFAULT, last);
2851 this->file_op = fop;
2852 this->detail_ftype = dft;
2853 this->abstract_ftype = aft;
2881 int GetSavegameType(
char *file)
2886 int mode = SL_OLD_LOAD;
2888 f = fopen(file,
"rb");
2889 if (fread(&hdr,
sizeof(hdr), 1, f) != 1) {
2890 DEBUG(sl, 0,
"Savegame is obsolete or invalid format");
2894 for (fmt = _saveload_formats; fmt !=
endof(_saveload_formats); fmt++) {
2895 if (fmt->
tag == hdr) {
FiosType
Elements of a file system that are recognized.
~FileWriter()
Make sure everything is cleaned up.
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.
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...
size_t Read(byte *buf, size_t size)
Read a given number of bytes from the savegame.
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?
void Finish()
Prepare everything to finish writing the savegame.
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.
size_t Read(byte *buf, size_t size)
Read a given number of bytes from the savegame.
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.
void Finish()
Prepare everything to finish writing the savegame.
void Write(byte *buf, size_t size)
Write a given number of bytes into the savegame.
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).
char * CopyFromOldName(StringID id)
Copy and convert old custom names to UTF-8.
LZMASaveFilter(SaveFilter *chain, byte compression_level)
Initialise this filter.
void Write(byte *buf, size_t size)
Write a given number of bytes into the savegame.
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).
Tindex index
Index of this pool item.
static const SaveLoadFormat _saveload_formats[]
The different saveload formats known/understood by OpenTTD.
partial loading into _load_check_data
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.
size_t Read(byte *buf, size_t size)
Read a given number of bytes from the savegame.
virtual void Write(byte *buf, size_t len)=0
Write a given number of bytes into the savegame.
SavegameType
Types of save games.
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?
Deals with the type of the savegame, independent of extension.
size_t size
the sizeof size.
~ZlibLoadFilter()
Clean everything up.
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.
T * Append(uint to_add=1)
Append an item and return it.
static void SaveFileToDiskThread(void *arg)
Thread run function for saving the file to disk.
CompanyByte _local_company
Company controlled by the human player at this client. Can also be COMPANY_SPECTATOR.
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.
void Reset()
Reset this filter to read from the beginning of the file.
virtual void Finish()
Prepare everything to finish writing the savegame.
Critical errors, the MessageBox is shown in all cases.
void ShowErrorMessage(StringID summary_msg, StringID detailed_msg, WarningLevel wl, int x=0, int y=0, const GRFFile *textref_stack_grffile=NULL, uint textref_stack_size=0, const uint32 *textref_stack=NULL)
Display an error message in a window.
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.
size_t Read(byte *buf, size_t ssize)
Read a given number of bytes from the savegame.
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.
uint Length() const
Get the number of items in the list.
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.
size_t Read(byte *buf, size_t size)
Read a given number of bytes from the savegame.
byte * bufe
End of the buffer we write to.
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 void SlWriteSimpleGamma(size_t i)
Write the header descriptor of an object or an array.
const SaveLoadVersion SAVEGAME_VERSION
Current savegame version of OpenTTD.
ZlibSaveFilter(SaveFilter *chain, byte compression_level)
Initialise this filter.
SaveOrLoadResult LoadWithFilter(LoadFilter *reader)
Load the game using a (reader) filter.
AutoFreeSmallVector< byte *, 16 > blocks
Buffer with blocks of allocated memory.
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.
A buffer for reading (and buffering) savegame data.
static ThreadObject * _save_thread
The thread we're using to compress and write a savegame.
#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...
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.
void Write(byte *buf, size_t size)
Write a given number of bytes into the savegame.
static void * GetVariableAddress(const void *object, const SaveLoad *sld)
Get the address of the variable.
virtual void Join()=0
Join this thread.
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
const ChunkHandler _cargopacket_chunk_handlers[]
Chunk handlers related to cargo packets.
static AsyncSaveFinishProc _async_save_finish
Callback to call when the savegame loading is finished.
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 -> NULL)
Replace the unknown/bad bits with question marks.
void Write(byte *buf, size_t size)
Write a given number of bytes into the savegame.
~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...
void Write(byte *buf, size_t size)
Write a given number of bytes into 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-NULL) Titem.
StringID error_str
the translatable error message to show
void Finish()
Prepare everything to finish writing the savegame.
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.
Owner
Enum for all companies/owners.
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)
null all pointers (on loading error)
A Thread Object which works on all our supported OSes.
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.
static bool New(OTTDThreadFunc proc, void *param, ThreadObject **thread=NULL, const char *name=NULL)
Create a thread; proc will be called as first function inside the thread, with optional params...
DetailedFileType
Kinds of files in each AbstractFileType.
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, NULL 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 NULL 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...