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);
365 va_start(ap, format);
383 if (_exit_game)
return;
384 while (_async_save_finish != NULL) CSleep(10);
386 _async_save_finish = proc;
394 if (_async_save_finish == NULL)
return;
398 _async_save_finish = NULL;
400 if (_save_thread != NULL) {
401 _save_thread->
Join();
413 return _sl.
reader->ReadByte();
425 static inline int SlReadUint16()
431 static inline uint32 SlReadUint32()
433 uint32 x = SlReadUint16() << 16;
434 return x | SlReadUint16();
437 static inline uint64 SlReadUint64()
439 uint32 x = SlReadUint32();
440 uint32 y = SlReadUint32();
441 return (uint64)x << 32 | y;
444 static inline void SlWriteUint16(uint16 v)
450 static inline void SlWriteUint32(uint32 v)
452 SlWriteUint16(
GB(v, 16, 16));
453 SlWriteUint16(
GB(v, 0, 16));
456 static inline void SlWriteUint64(uint64 x)
458 SlWriteUint32((uint32)(x >> 32));
459 SlWriteUint32((uint32)x);
526 if (i >= (1 << 14)) {
527 if (i >= (1 << 21)) {
528 if (i >= (1 << 28)) {
529 assert(i <= UINT32_MAX);
550 return 1 + (i >= (1 << 7)) + (i >= (1 << 14)) + (i >= (1 << 21)) + (i >= (1 << 28));
553 static inline uint SlReadSparseIndex()
558 static inline void SlWriteSparseIndex(uint index)
563 static inline uint SlReadArrayLength()
568 static inline void SlWriteArrayLength(
size_t length)
573 static inline uint SlGetArrayLength(
size_t length)
586 static const byte conv_mem_size[] = {1, 1, 1, 2, 2, 4, 4, 8, 8, 0};
587 byte length =
GB(conv, 4, 4);
589 switch (length << 4) {
594 return SlReadArrayLength();
597 assert(length <
lengthof(conv_mem_size));
598 return conv_mem_size[length];
610 static const byte conv_file_size[] = {1, 1, 2, 2, 4, 4, 8, 8, 2};
611 byte length =
GB(conv, 0, 4);
612 assert(length <
lengthof(conv_file_size));
613 return conv_file_size[length];
622 void SlSetArrayIndex(uint index)
625 _sl.array_index = index;
628 static size_t _next_offs;
643 uint length = SlReadArrayLength();
653 case CH_SPARSE_ARRAY: index = (int)SlReadSparseIndex();
break;
654 case CH_ARRAY: index = _sl.array_index++;
break;
656 DEBUG(sl, 0,
"SlIterateArray error");
660 if (length != 0)
return index;
691 assert(length < (1 << 28));
692 SlWriteUint32((uint32)((length & 0xFFFFFF) | ((length >> 24) << 28)));
697 SlWriteArrayLength(1);
699 SlWriteArrayLength(length + 1);
701 case CH_SPARSE_ARRAY:
702 SlWriteArrayLength(length + 1 + SlGetArrayLength(_sl.array_index));
703 SlWriteSparseIndex(_sl.array_index);
705 default: NOT_REACHED();
713 default: NOT_REACHED();
725 byte *p = (byte *)ptr;
730 for (; length != 0; length--) *p++ =
SlReadByte();
735 default: NOT_REACHED();
755 case SLE_VAR_BL:
return (*(
const bool *)ptr != 0);
756 case SLE_VAR_I8:
return *(
const int8 *)ptr;
757 case SLE_VAR_U8:
return *(
const byte *)ptr;
758 case SLE_VAR_I16:
return *(
const int16 *)ptr;
759 case SLE_VAR_U16:
return *(
const uint16*)ptr;
760 case SLE_VAR_I32:
return *(
const int32 *)ptr;
761 case SLE_VAR_U32:
return *(
const uint32*)ptr;
762 case SLE_VAR_I64:
return *(
const int64 *)ptr;
763 case SLE_VAR_U64:
return *(
const uint64*)ptr;
765 default: NOT_REACHED();
779 case SLE_VAR_BL: *(
bool *)ptr = (val != 0);
break;
780 case SLE_VAR_I8: *(int8 *)ptr = val;
break;
781 case SLE_VAR_U8: *(byte *)ptr = val;
break;
782 case SLE_VAR_I16: *(int16 *)ptr = val;
break;
783 case SLE_VAR_U16: *(uint16*)ptr = val;
break;
784 case SLE_VAR_I32: *(int32 *)ptr = val;
break;
785 case SLE_VAR_U32: *(uint32*)ptr = val;
break;
786 case SLE_VAR_I64: *(int64 *)ptr = val;
break;
787 case SLE_VAR_U64: *(uint64*)ptr = val;
break;
790 default: NOT_REACHED();
810 case SLE_FILE_I8: assert(x >= -128 && x <= 127);
SlWriteByte(x);
break;
811 case SLE_FILE_U8: assert(x >= 0 && x <= 255);
SlWriteByte(x);
break;
812 case SLE_FILE_I16:assert(x >= -32768 && x <= 32767); SlWriteUint16(x);
break;
814 case SLE_FILE_U16:assert(x >= 0 && x <= 65535); SlWriteUint16(x);
break;
816 case SLE_FILE_U32: SlWriteUint32((uint32)x);
break;
818 case SLE_FILE_U64: SlWriteUint64(x);
break;
819 default: NOT_REACHED();
828 case SLE_FILE_I8: x = (int8 )
SlReadByte();
break;
829 case SLE_FILE_U8: x = (byte )
SlReadByte();
break;
830 case SLE_FILE_I16: x = (int16 )SlReadUint16();
break;
831 case SLE_FILE_U16: x = (uint16)SlReadUint16();
break;
832 case SLE_FILE_I32: x = (int32 )SlReadUint32();
break;
833 case SLE_FILE_U32: x = (uint32)SlReadUint32();
break;
834 case SLE_FILE_I64: x = (int64 )SlReadUint64();
break;
835 case SLE_FILE_U64: x = (uint64)SlReadUint64();
break;
837 default: NOT_REACHED();
846 default: NOT_REACHED();
861 if (ptr == NULL)
return 0;
862 return min(strlen(ptr), length - 1);
880 default: NOT_REACHED();
883 str = *(
const char *
const *)ptr;
888 str = (
const char *)ptr;
894 return len + SlGetArrayLength(len);
903 static void SlString(
void *ptr,
size_t length, VarType conv)
909 default: NOT_REACHED();
921 SlWriteArrayLength(len);
927 size_t len = SlReadArrayLength();
930 default: NOT_REACHED();
934 DEBUG(sl, 1,
"String length in savegame is bigger than buffer, truncating");
946 *(
char **)ptr = NULL;
949 *(
char **)ptr = MallocT<char>(len + 1);
956 ((
char *)ptr)[len] =
'\0';
972 default: NOT_REACHED();
992 void SlArray(
void *array,
size_t length, VarType conv)
1007 if (conv == SLE_INT16 || conv == SLE_UINT16 || conv == SLE_STRINGID ||
1008 conv == SLE_INT32 || conv == SLE_UINT32) {
1013 if (conv == (SLE_FILE_I32 | SLE_VAR_I64)) {
1014 for (uint i = 0; i < length; i++) {
1015 ((int64*)array)[i] = (int32)
BSWAP32(SlReadUint32());
1023 if (conv == SLE_INT8 || conv == SLE_UINT8) {
1026 byte *a = (byte*)array;
1029 for (; length != 0; length --) {
1051 if (obj == NULL)
return 0;
1066 default: NOT_REACHED();
1082 assert_compile(
sizeof(
size_t) <=
sizeof(
void *));
1147 default: NOT_REACHED();
1157 const std::list<void *> *l = (
const std::list<void *> *) list;
1162 return l->size() * type_size + type_size;
1180 typedef std::list<void *> PtrList;
1181 PtrList *l = (PtrList *)list;
1185 SlWriteUint32((uint32)l->size());
1187 PtrList::iterator iter;
1188 for (iter = l->begin(); iter != l->end(); ++iter) {
1199 for (
size_t i = 0; i < length; i++) {
1201 l->push_back((
void *)data);
1209 PtrList::iterator iter;
1210 for (iter = temp.begin(); iter != temp.end(); ++iter) {
1219 default: NOT_REACHED();
1227 template <
typename T>
1229 typedef std::deque<T> SlDequeT;
1238 const SlDequeT *l = (
const SlDequeT *)deque;
1253 SlDequeT *l = (SlDequeT *)deque;
1257 SlWriteUint32((uint32)l->size());
1259 typename SlDequeT::iterator iter;
1260 for (iter = l->begin(); iter != l->end(); ++iter) {
1267 size_t length = SlReadUint32();
1270 for (
size_t i = 0; i < length; i++) {
1282 default: NOT_REACHED();
1310 default: NOT_REACHED();
1342 default: NOT_REACHED();
1350 if (_sl_version < sld->version_from || _sl_version >= sld->
version_to)
return false;
1382 for (; sld->
cmd != SL_END; sld++) {
1383 length += SlCalcObjMemberLength(
object, sld);
1388 size_t SlCalcObjMemberLength(
const void *
object,
const SaveLoad *sld)
1409 default: NOT_REACHED();
1412 case SL_WRITEBYTE:
return 1;
1415 default: NOT_REACHED();
1433 return sld->
size ==
sizeof(bool);
1436 return sld->
size ==
sizeof(int8);
1439 return sld->
size ==
sizeof(int16);
1442 return sld->
size ==
sizeof(int32);
1445 return sld->
size ==
sizeof(int64);
1447 return sld->
size ==
sizeof(
void *);
1451 return sld->
size ==
sizeof(
void *);
1464 bool SlObjectMember(
void *ptr,
const SaveLoad *sld)
1470 VarType conv =
GB(sld->
conv, 0, 8);
1497 *(
void **)ptr = NULL;
1499 default: NOT_REACHED();
1506 default: NOT_REACHED();
1520 default: NOT_REACHED();
1525 case SL_VEH_INCLUDE:
1533 default: NOT_REACHED();
1551 for (; sld->
cmd != SL_END; sld++) {
1553 SlObjectMember(ptr, sld);
1609 _sl.array_index = 0;
1613 case CH_SPARSE_ARRAY:
1618 if ((m & 0xF) == CH_RIFF) {
1620 len = (
SlReadByte() << 16) | ((m >> 4) << 24);
1621 len += SlReadUint16();
1649 _sl.array_index = 0;
1656 case CH_SPARSE_ARRAY:
1664 if ((m & 0xF) == CH_RIFF) {
1666 len = (
SlReadByte() << 16) | ((m >> 4) << 24);
1667 len += SlReadUint16();
1716 ChunkSaveLoadProc *proc = ch->
save_proc;
1719 if (proc == NULL)
return;
1721 SlWriteUint32(ch->
id);
1722 DEBUG(sl, 2,
"Saving chunk %c%c%c%c", ch->
id >> 24, ch->
id >> 16, ch->
id >> 8, ch->
id);
1724 if (ch->
flags & CH_AUTO_LENGTH) {
1726 _stub_save_proc = proc;
1731 switch (ch->
flags & CH_TYPE_MASK) {
1740 SlWriteArrayLength(0);
1742 case CH_SPARSE_ARRAY:
1745 SlWriteArrayLength(0);
1747 default: NOT_REACHED();
1780 for (
id = SlReadUint32();
id != 0;
id = SlReadUint32()) {
1781 DEBUG(sl, 2,
"Loading chunk %c%c%c%c",
id >> 24,
id >> 16,
id >> 8,
id);
1795 for (
id = SlReadUint32();
id != 0;
id = SlReadUint32()) {
1796 DEBUG(sl, 2,
"Loading chunk %c%c%c%c",
id >> 24,
id >> 16,
id >> 8,
id);
1809 DEBUG(sl, 1,
"Fixing pointers");
1812 if (ch->ptrs_proc != NULL) {
1813 DEBUG(sl, 2,
"Fixing pointers for %c%c%c%c", ch->id >> 24, ch->id >> 16, ch->id >> 8, ch->id);
1818 DEBUG(sl, 1,
"All pointers fixed");
1840 if (this->file != NULL) fclose(this->file);
1850 if (this->file == NULL)
return 0;
1852 return fread(buf, 1, size, this->file);
1857 clearerr(this->file);
1858 if (fseek(this->file, this->begin, SEEK_SET)) {
1859 DEBUG(sl, 1,
"Could not reset the file reading");
1888 if (this->file == NULL)
return;
1890 if (fwrite(buf, 1, size, this->file) != size)
SlError(STR_GAME_SAVELOAD_ERROR_FILE_NOT_WRITEABLE);
1895 if (this->file != NULL) fclose(this->file);
1905 #include <lzo/lzo1x.h> 1918 if (lzo_init() != LZO_E_OK)
SlError(STR_GAME_SAVELOAD_ERROR_BROKEN_INTERNAL_ERROR,
"cannot initialize decompressor");
1923 assert(ssize >= LZO_BUFFER_SIZE);
1926 byte out[LZO_BUFFER_SIZE + LZO_BUFFER_SIZE / 16 + 64 + 3 +
sizeof(uint32) * 2];
1929 lzo_uint len = ssize;
1932 if (this->chain->Read((byte*)tmp,
sizeof(tmp)) !=
sizeof(tmp))
SlError(STR_GAME_SAVELOAD_ERROR_FILE_NOT_READABLE,
"File read failed");
1935 ((uint32*)out)[0] = size = tmp[1];
1938 tmp[0] = TO_BE32(tmp[0]);
1939 size = TO_BE32(size);
1945 if (this->chain->Read(out +
sizeof(uint32), size) != size)
SlError(STR_GAME_SAVELOAD_ERROR_FILE_NOT_READABLE);
1948 if (tmp[0] != lzo_adler32(0, out, size +
sizeof(uint32)))
SlErrorCorrupt(
"Bad checksum");
1951 int ret = lzo1x_decompress_safe(out +
sizeof(uint32) * 1, size, buf, &len, NULL);
1952 if (ret != LZO_E_OK)
SlError(STR_GAME_SAVELOAD_ERROR_FILE_NOT_READABLE);
1966 if (lzo_init() != LZO_E_OK)
SlError(STR_GAME_SAVELOAD_ERROR_BROKEN_INTERNAL_ERROR,
"cannot initialize compressor");
1971 const lzo_bytep in =
buf;
1973 byte out[LZO_BUFFER_SIZE + LZO_BUFFER_SIZE / 16 + 64 + 3 +
sizeof(uint32) * 2];
1974 byte wrkmem[LZO1X_1_MEM_COMPRESS];
1979 lzo_uint len = size > LZO_BUFFER_SIZE ?
LZO_BUFFER_SIZE : (lzo_uint)size;
1980 lzo1x_1_compress(in, len, out +
sizeof(uint32) * 2, &outlen, wrkmem);
1981 ((uint32*)out)[1] = TO_BE32((uint32)outlen);
1982 ((uint32*)out)[0] = TO_BE32(lzo_adler32(0, out +
sizeof(uint32), outlen +
sizeof(uint32)));
1983 this->chain->Write(out, outlen +
sizeof(uint32) * 2);
2010 return this->chain->Read(buf, size);
2027 this->chain->Write(buf, size);
2035 #if defined(WITH_ZLIB) 2049 memset(&this->z, 0,
sizeof(this->z));
2050 if (inflateInit(&this->z) != Z_OK)
SlError(STR_GAME_SAVELOAD_ERROR_BROKEN_INTERNAL_ERROR,
"cannot initialize decompressor");
2056 inflateEnd(&this->z);
2061 this->z.next_out =
buf;
2062 this->z.avail_out = (uint)size;
2066 if (this->z.avail_in == 0) {
2067 this->z.next_in = this->fread_buf;
2068 this->z.avail_in = (uint)this->chain->Read(this->fread_buf,
sizeof(this->fread_buf));
2072 int r = inflate(&this->z, 0);
2073 if (r == Z_STREAM_END)
break;
2075 if (r != Z_OK)
SlError(STR_GAME_SAVELOAD_ERROR_BROKEN_INTERNAL_ERROR,
"inflate() failed");
2076 }
while (this->z.avail_out != 0);
2078 return size - this->z.avail_out;
2093 memset(&this->z, 0,
sizeof(this->z));
2094 if (deflateInit(&this->z, compression_level) != Z_OK)
SlError(STR_GAME_SAVELOAD_ERROR_BROKEN_INTERNAL_ERROR,
"cannot initialize compressor");
2100 deflateEnd(&this->z);
2113 this->z.next_in = p;
2114 this->z.avail_in = (uInt)len;
2116 this->z.next_out =
buf;
2117 this->z.avail_out =
sizeof(
buf);
2126 int r = deflate(&this->z, mode);
2129 if ((n =
sizeof(buf) - this->z.avail_out) != 0) {
2130 this->chain->Write(buf, n);
2132 if (r == Z_STREAM_END)
break;
2134 if (r != Z_OK)
SlError(STR_GAME_SAVELOAD_ERROR_BROKEN_INTERNAL_ERROR,
"zlib returned error code");
2135 }
while (this->z.avail_in || !this->z.avail_out);
2140 this->WriteLoop(buf, size, 0);
2145 this->WriteLoop(NULL, 0, Z_FINISH);
2146 this->chain->Finish();
2156 #if defined(WITH_LZMA) 2179 if (lzma_auto_decoder(&this->lzma, 1 << 28, 0) != LZMA_OK)
SlError(STR_GAME_SAVELOAD_ERROR_BROKEN_INTERNAL_ERROR,
"cannot initialize decompressor");
2185 lzma_end(&this->lzma);
2190 this->lzma.next_out =
buf;
2191 this->lzma.avail_out = size;
2195 if (this->lzma.avail_in == 0) {
2196 this->lzma.next_in = this->fread_buf;
2197 this->lzma.avail_in = this->chain->Read(this->fread_buf,
sizeof(this->fread_buf));
2201 lzma_ret r = lzma_code(&this->lzma, LZMA_RUN);
2202 if (r == LZMA_STREAM_END)
break;
2203 if (r != LZMA_OK)
SlError(STR_GAME_SAVELOAD_ERROR_BROKEN_INTERNAL_ERROR,
"liblzma returned error code");
2204 }
while (this->lzma.avail_out != 0);
2206 return size - this->lzma.avail_out;
2221 if (lzma_easy_encoder(&this->lzma, compression_level, LZMA_CHECK_CRC32) != LZMA_OK)
SlError(STR_GAME_SAVELOAD_ERROR_BROKEN_INTERNAL_ERROR,
"cannot initialize compressor");
2227 lzma_end(&this->lzma);
2240 this->lzma.next_in = p;
2241 this->lzma.avail_in = len;
2243 this->lzma.next_out =
buf;
2244 this->lzma.avail_out =
sizeof(
buf);
2246 lzma_ret r = lzma_code(&this->lzma, action);
2249 if ((n =
sizeof(buf) - this->lzma.avail_out) != 0) {
2250 this->chain->Write(buf, n);
2252 if (r == LZMA_STREAM_END)
break;
2253 if (r != LZMA_OK)
SlError(STR_GAME_SAVELOAD_ERROR_BROKEN_INTERNAL_ERROR,
"liblzma returned error code");
2254 }
while (this->lzma.avail_in || !this->lzma.avail_out);
2259 this->WriteLoop(buf, size, LZMA_RUN);
2264 this->WriteLoop(NULL, 0, LZMA_FINISH);
2265 this->chain->Finish();
2290 #if defined(WITH_LZO) 2292 {
"lzo", TO_BE32X(
'OTTD'), CreateLoadFilter<LZOLoadFilter>, CreateSaveFilter<LZOSaveFilter>, 0, 0, 0},
2294 {
"lzo", TO_BE32X(
'OTTD'), NULL, NULL, 0, 0, 0},
2297 {
"none", TO_BE32X(
'OTTN'), CreateLoadFilter<NoCompLoadFilter>, CreateSaveFilter<NoCompSaveFilter>, 0, 0, 0},
2298 #if defined(WITH_ZLIB) 2302 {
"zlib", TO_BE32X(
'OTTZ'), CreateLoadFilter<ZlibLoadFilter>, CreateSaveFilter<ZlibSaveFilter>, 0, 6, 9},
2304 {
"zlib", TO_BE32X(
'OTTZ'), NULL, NULL, 0, 0, 0},
2306 #if defined(WITH_LZMA) 2312 {
"lzma", TO_BE32X(
'OTTX'), CreateLoadFilter<LZMALoadFilter>, CreateSaveFilter<LZMASaveFilter>, 0, 2, 9},
2314 {
"lzma", TO_BE32X(
'OTTX'), NULL, NULL, 0, 0, 0},
2334 char *complevel = strrchr(s,
':');
2335 if (complevel != NULL) *complevel =
'\0';
2337 for (
const SaveLoadFormat *slf = &_saveload_formats[0]; slf !=
endof(_saveload_formats); slf++) {
2338 if (slf->init_write != NULL && strcmp(s, slf->name) == 0) {
2339 *compression_level = slf->default_compression;
2340 if (complevel != NULL) {
2349 long level = strtol(complevel, &end, 10);
2350 if (end == complevel || level !=
Clamp(level, slf->min_compression, slf->max_compression)) {
2354 *compression_level = level;
2366 if (complevel != NULL) *complevel =
':';
2373 void InitializeGame(uint size_x, uint size_y,
bool reset_date,
bool reset_settings);
2375 extern bool LoadOldSaveGame(
const char *file);
2413 if (_game_mode != GM_MENU) _fast_forward = _sl.
ff_state;
2432 static char err_str[512];
2433 GetString(err_str, _sl.
action ==
SLA_SAVE ? STR_ERROR_GAME_SAVE_FAILED : STR_ERROR_GAME_LOAD_FAILED,
lastof(err_str));
2457 _sl.
sf->
Write((byte*)hdr,
sizeof(hdr));
2474 if (_sl.
error_str != STR_NETWORK_ERROR_LOSTCONNECTION) {
2495 void WaitTillSaved()
2497 if (_save_thread == NULL)
return;
2499 _save_thread->
Join();
2501 _save_thread = NULL;
2524 SaveViewportBeforeSaveGame();
2529 if (threaded)
DEBUG(sl, 1,
"Cannot create savegame thread, reverting to single-threaded mode...");
2550 return DoSave(writer, threaded);
2575 if (_sl.
lf->
Read((byte*)hdr,
sizeof(hdr)) !=
sizeof(hdr))
SlError(STR_GAME_SAVELOAD_ERROR_FILE_NOT_READABLE);
2581 if (fmt ==
endof(_saveload_formats)) {
2582 DEBUG(sl, 0,
"Unknown savegame type, trying to load it as the buggy format");
2585 _sl_minor_version = 0;
2590 if (fmt ==
endof(_saveload_formats)) {
2594 if (fmt->
tag == TO_BE32X(
'OTTD'))
break;
2600 if (fmt->
tag == hdr[0]) {
2606 _sl_minor_version = (TO_BE32(hdr[1]) >> 8) & 0xFF;
2608 DEBUG(sl, 1,
"Loading savegame version %d", _sl_version);
2622 SlError(STR_GAME_SAVELOAD_ERROR_BROKEN_INTERNAL_ERROR, err_str);
2633 InitializeGame(256, 256,
true,
true);
2705 return DoLoad(reader,
false);
2734 InitializeGame(256, 256,
true,
true);
2742 if (!LoadOldSaveGame(filename))
return SL_REINIT;
2744 _sl_minor_version = 0;
2768 default: NOT_REACHED();
2779 SlError(fop ==
SLO_SAVE ? STR_GAME_SAVELOAD_ERROR_FILE_NOT_WRITEABLE : STR_GAME_SAVELOAD_ERROR_FILE_NOT_READABLE);
2791 DEBUG(desync, 1,
"load: %s", filename);
2824 FOR_ALL_COMPANIES(c) {
2834 case 0:
SetDParam(1, STR_JUST_DATE_LONG);
break;
2835 case 1:
SetDParam(1, STR_JUST_DATE_TINY);
break;
2836 case 2:
SetDParam(1, STR_JUST_DATE_ISO);
break;
2837 default: NOT_REACHED();
2842 GetString(buf, !
Company::IsValidID(cid) ? STR_SAVEGAME_NAME_SPECTATOR : STR_SAVEGAME_NAME_DEFAULT, last);
2870 this->file_op = fop;
2871 this->detail_ftype = dft;
2872 this->abstract_ftype = aft;
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).
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.
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.
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?
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...