24 #include "../stdafx.h" 26 #include "../station_base.h" 27 #include "../thread/thread.h" 29 #include "../network/network.h" 30 #include "../window_func.h" 31 #include "../strings_func.h" 32 #include "../core/endian_func.hpp" 33 #include "../vehicle_base.h" 34 #include "../company_func.h" 35 #include "../date_func.h" 36 #include "../autoreplace_base.h" 37 #include "../roadstop_base.h" 38 #include "../linkgraph/linkgraph.h" 39 #include "../linkgraph/linkgraphjob.h" 40 #include "../statusbar_gui.h" 41 #include "../fileio_func.h" 42 #include "../gamelog.h" 43 #include "../string_func.h" 47 #include "table/strings.h" 52 #include "../safeguards.h" 314 inline byte ReadByte()
316 if (this->bufp == this->bufe) {
317 size_t len = this->reader->
Read(this->buf,
lengthof(this->buf));
321 this->bufp = this->
buf;
322 this->bufe = this->buf + len;
325 return *this->bufp++;
334 return this->read - (this->bufe - this->
bufp);
357 if (this->buf == this->bufe) {
378 writer->
Write(this->blocks[i++], to_write);
448 extern const ChunkHandler _autoreplace_chunk_handlers[];
457 _gamelog_chunk_handlers,
459 _misc_chunk_handlers,
462 _setting_chunk_handlers,
464 _waypoint_chunk_handlers,
465 _depot_chunk_handlers,
466 _order_chunk_handlers,
467 _industry_chunk_handlers,
468 _economy_chunk_handlers,
469 _subsidy_chunk_handlers,
471 _goal_chunk_handlers,
472 _story_page_chunk_handlers,
473 _engine_chunk_handlers,
476 _station_chunk_handlers,
477 _company_chunk_handlers,
479 _game_chunk_handlers,
481 _newgrf_chunk_handlers,
482 _group_chunk_handlers,
484 _autoreplace_chunk_handlers,
485 _labelmaps_chunk_handlers,
486 _linkgraph_chunk_handlers,
487 _airport_chunk_handlers,
488 _object_chunk_handlers,
497 #define FOR_ALL_CHUNK_HANDLERS(ch) \ 498 for (const ChunkHandler * const *chsc = _chunk_handlers; *chsc != NULL; chsc++) \ 499 for (const ChunkHandler *ch = *chsc; ch != NULL; ch = (ch->flags & CH_LAST) ? NULL : ch + 1) 511 DEBUG(sl, 1,
"Nulling pointers");
514 if (ch->ptrs_proc != NULL) {
515 DEBUG(sl, 2,
"Nulling pointers for %c%c%c%c", ch->id >> 24, ch->id >> 16, ch->id >> 8, ch->id);
520 DEBUG(sl, 1,
"All pointers nulled");
551 throw std::exception();
563 SlError(STR_GAME_SAVELOAD_ERROR_BROKEN_SAVEGAME, msg);
577 if (_exit_game)
return;
594 if (_save_thread != NULL) {
595 _save_thread->
Join();
607 return _sl.
reader->ReadByte();
619 static inline int SlReadUint16()
625 static inline uint32 SlReadUint32()
627 uint32 x = SlReadUint16() << 16;
628 return x | SlReadUint16();
631 static inline uint64 SlReadUint64()
633 uint32 x = SlReadUint32();
634 uint32 y = SlReadUint32();
635 return (uint64)x << 32 | y;
638 static inline void SlWriteUint16(uint16 v)
644 static inline void SlWriteUint32(uint32 v)
646 SlWriteUint16(
GB(v, 16, 16));
647 SlWriteUint16(
GB(v, 0, 16));
650 static inline void SlWriteUint64(uint64 x)
652 SlWriteUint32((uint32)(x >> 32));
653 SlWriteUint32((uint32)x);
720 if (i >= (1 << 14)) {
721 if (i >= (1 << 21)) {
722 if (i >= (1 << 28)) {
723 assert(i <= UINT32_MAX);
744 return 1 + (i >= (1 << 7)) + (i >= (1 << 14)) + (i >= (1 << 21)) + (i >= (1 << 28));
747 static inline uint SlReadSparseIndex()
752 static inline void SlWriteSparseIndex(uint index)
757 static inline uint SlReadArrayLength()
762 static inline void SlWriteArrayLength(
size_t length)
767 static inline uint SlGetArrayLength(
size_t length)
780 static const byte conv_mem_size[] = {1, 1, 1, 2, 2, 4, 4, 8, 8, 0};
781 byte length =
GB(conv, 4, 4);
783 switch (length << 4) {
788 return SlReadArrayLength();
791 assert(length <
lengthof(conv_mem_size));
792 return conv_mem_size[length];
804 static const byte conv_file_size[] = {1, 1, 2, 2, 4, 4, 8, 8, 2};
805 byte length =
GB(conv, 0, 4);
806 assert(length <
lengthof(conv_file_size));
807 return conv_file_size[length];
816 void SlSetArrayIndex(uint index)
819 _sl.array_index = index;
822 static size_t _next_offs;
837 uint length = SlReadArrayLength();
847 case CH_SPARSE_ARRAY: index = (int)SlReadSparseIndex();
break;
848 case CH_ARRAY: index = _sl.array_index++;
break;
850 DEBUG(sl, 0,
"SlIterateArray error");
854 if (length != 0)
return index;
885 assert(length < (1 << 28));
886 SlWriteUint32((uint32)((length & 0xFFFFFF) | ((length >> 24) << 28)));
891 SlWriteArrayLength(1);
893 SlWriteArrayLength(length + 1);
895 case CH_SPARSE_ARRAY:
896 SlWriteArrayLength(length + 1 + SlGetArrayLength(_sl.array_index));
897 SlWriteSparseIndex(_sl.array_index);
899 default: NOT_REACHED();
907 default: NOT_REACHED();
919 byte *p = (byte *)ptr;
924 for (; length != 0; length--) *p++ =
SlReadByte();
929 default: NOT_REACHED();
949 case SLE_VAR_BL:
return (*(
const bool *)ptr != 0);
950 case SLE_VAR_I8:
return *(
const int8 *)ptr;
951 case SLE_VAR_U8:
return *(
const byte *)ptr;
952 case SLE_VAR_I16:
return *(
const int16 *)ptr;
953 case SLE_VAR_U16:
return *(
const uint16*)ptr;
954 case SLE_VAR_I32:
return *(
const int32 *)ptr;
955 case SLE_VAR_U32:
return *(
const uint32*)ptr;
956 case SLE_VAR_I64:
return *(
const int64 *)ptr;
957 case SLE_VAR_U64:
return *(
const uint64*)ptr;
959 default: NOT_REACHED();
973 case SLE_VAR_BL: *(
bool *)ptr = (val != 0);
break;
974 case SLE_VAR_I8: *(int8 *)ptr = val;
break;
975 case SLE_VAR_U8: *(byte *)ptr = val;
break;
976 case SLE_VAR_I16: *(int16 *)ptr = val;
break;
977 case SLE_VAR_U16: *(uint16*)ptr = val;
break;
978 case SLE_VAR_I32: *(int32 *)ptr = val;
break;
979 case SLE_VAR_U32: *(uint32*)ptr = val;
break;
980 case SLE_VAR_I64: *(int64 *)ptr = val;
break;
981 case SLE_VAR_U64: *(uint64*)ptr = val;
break;
984 default: NOT_REACHED();
1004 case SLE_FILE_I8: assert(x >= -128 && x <= 127);
SlWriteByte(x);
break;
1005 case SLE_FILE_U8: assert(x >= 0 && x <= 255);
SlWriteByte(x);
break;
1006 case SLE_FILE_I16:assert(x >= -32768 && x <= 32767); SlWriteUint16(x);
break;
1008 case SLE_FILE_U16:assert(x >= 0 && x <= 65535); SlWriteUint16(x);
break;
1010 case SLE_FILE_U32: SlWriteUint32((uint32)x);
break;
1012 case SLE_FILE_U64: SlWriteUint64(x);
break;
1013 default: NOT_REACHED();
1022 case SLE_FILE_I8: x = (int8 )
SlReadByte();
break;
1023 case SLE_FILE_U8: x = (byte )
SlReadByte();
break;
1024 case SLE_FILE_I16: x = (int16 )SlReadUint16();
break;
1025 case SLE_FILE_U16: x = (uint16)SlReadUint16();
break;
1026 case SLE_FILE_I32: x = (int32 )SlReadUint32();
break;
1027 case SLE_FILE_U32: x = (uint32)SlReadUint32();
break;
1028 case SLE_FILE_I64: x = (int64 )SlReadUint64();
break;
1029 case SLE_FILE_U64: x = (uint64)SlReadUint64();
break;
1031 default: NOT_REACHED();
1040 default: NOT_REACHED();
1055 if (ptr == NULL)
return 0;
1056 return min(strlen(ptr), length - 1);
1074 default: NOT_REACHED();
1077 str = *(
const char *
const *)ptr;
1082 str = (
const char *)ptr;
1088 return len + SlGetArrayLength(len);
1097 static void SlString(
void *ptr,
size_t length, VarType conv)
1103 default: NOT_REACHED();
1110 ptr = *(
char **)ptr;
1115 SlWriteArrayLength(len);
1121 size_t len = SlReadArrayLength();
1124 default: NOT_REACHED();
1127 if (len >= length) {
1128 DEBUG(sl, 1,
"String length in savegame is bigger than buffer, truncating");
1138 free(*(
char **)ptr);
1140 *(
char **)ptr = NULL;
1143 *(
char **)ptr = MallocT<char>(len + 1);
1144 ptr = *(
char **)ptr;
1150 ((
char *)ptr)[len] =
'\0';
1161 str_validate((
char *)ptr, (
char *)ptr + len, settings);
1166 default: NOT_REACHED();
1186 void SlArray(
void *array,
size_t length, VarType conv)
1201 if (conv == SLE_INT16 || conv == SLE_UINT16 || conv == SLE_STRINGID ||
1202 conv == SLE_INT32 || conv == SLE_UINT32) {
1207 if (conv == (SLE_FILE_I32 | SLE_VAR_I64)) {
1208 for (uint i = 0; i < length; i++) {
1209 ((int64*)array)[i] = (int32)
BSWAP32(SlReadUint32());
1217 if (conv == SLE_INT8 || conv == SLE_UINT8) {
1220 byte *a = (byte*)array;
1223 for (; length != 0; length --) {
1245 if (obj == NULL)
return 0;
1260 default: NOT_REACHED();
1276 assert_compile(
sizeof(
size_t) <=
sizeof(
void *));
1341 default: NOT_REACHED();
1351 const std::list<void *> *l = (
const std::list<void *> *) list;
1356 return l->size() * type_size + type_size;
1374 typedef std::list<void *> PtrList;
1375 PtrList *l = (PtrList *)list;
1379 SlWriteUint32((uint32)l->size());
1381 PtrList::iterator iter;
1382 for (iter = l->begin(); iter != l->end(); ++iter) {
1393 for (
size_t i = 0; i < length; i++) {
1395 l->push_back((
void *)data);
1403 PtrList::iterator iter;
1404 for (iter = temp.begin(); iter != temp.end(); ++iter) {
1413 default: NOT_REACHED();
1453 for (; sld->
cmd != SL_END; sld++) {
1454 length += SlCalcObjMemberLength(
object, sld);
1459 size_t SlCalcObjMemberLength(
const void *
object,
const SaveLoad *sld)
1478 default: NOT_REACHED();
1481 case SL_WRITEBYTE:
return 1;
1484 default: NOT_REACHED();
1502 return sld->
size ==
sizeof(bool);
1505 return sld->
size ==
sizeof(int8);
1508 return sld->
size ==
sizeof(int16);
1511 return sld->
size ==
sizeof(int32);
1514 return sld->
size ==
sizeof(int64);
1516 return sld->
size ==
sizeof(
void *);
1520 return sld->
size ==
sizeof(
void *);
1533 bool SlObjectMember(
void *ptr,
const SaveLoad *sld)
1539 VarType conv =
GB(sld->
conv, 0, 8);
1565 *(
void **)ptr = NULL;
1567 default: NOT_REACHED();
1573 default: NOT_REACHED();
1589 default: NOT_REACHED();
1594 case SL_VEH_INCLUDE:
1602 default: NOT_REACHED();
1620 for (; sld->
cmd != SL_END; sld++) {
1622 SlObjectMember(ptr, sld);
1678 _sl.array_index = 0;
1682 case CH_SPARSE_ARRAY:
1687 if ((m & 0xF) == CH_RIFF) {
1689 len = (
SlReadByte() << 16) | ((m >> 4) << 24);
1690 len += SlReadUint16();
1718 _sl.array_index = 0;
1725 case CH_SPARSE_ARRAY:
1733 if ((m & 0xF) == CH_RIFF) {
1735 len = (
SlReadByte() << 16) | ((m >> 4) << 24);
1736 len += SlReadUint16();
1785 ChunkSaveLoadProc *proc = ch->
save_proc;
1788 if (proc == NULL)
return;
1790 SlWriteUint32(ch->
id);
1791 DEBUG(sl, 2,
"Saving chunk %c%c%c%c", ch->
id >> 24, ch->
id >> 16, ch->
id >> 8, ch->
id);
1793 if (ch->
flags & CH_AUTO_LENGTH) {
1800 switch (ch->
flags & CH_TYPE_MASK) {
1809 SlWriteArrayLength(0);
1811 case CH_SPARSE_ARRAY:
1814 SlWriteArrayLength(0);
1816 default: NOT_REACHED();
1849 for (
id = SlReadUint32();
id != 0;
id = SlReadUint32()) {
1850 DEBUG(sl, 2,
"Loading chunk %c%c%c%c",
id >> 24,
id >> 16,
id >> 8,
id);
1864 for (
id = SlReadUint32();
id != 0;
id = SlReadUint32()) {
1865 DEBUG(sl, 2,
"Loading chunk %c%c%c%c",
id >> 24,
id >> 16,
id >> 8,
id);
1878 DEBUG(sl, 1,
"Fixing pointers");
1881 if (ch->ptrs_proc != NULL) {
1882 DEBUG(sl, 2,
"Fixing pointers for %c%c%c%c", ch->id >> 24, ch->id >> 16, ch->id >> 8, ch->id);
1887 DEBUG(sl, 1,
"All pointers fixed");
1909 if (this->file != NULL) fclose(this->file);
1919 if (this->file == NULL)
return 0;
1921 return fread(buf, 1, size, this->file);
1926 clearerr(this->file);
1927 if (fseek(this->file, this->begin, SEEK_SET)) {
1928 DEBUG(sl, 1,
"Could not reset the file reading");
1957 if (this->file == NULL)
return;
1959 if (fwrite(buf, 1, size, this->file) != size)
SlError(STR_GAME_SAVELOAD_ERROR_FILE_NOT_WRITEABLE);
1964 if (this->file != NULL) fclose(this->file);
1974 #include <lzo/lzo1x.h> 1987 if (lzo_init() != LZO_E_OK)
SlError(STR_GAME_SAVELOAD_ERROR_BROKEN_INTERNAL_ERROR,
"cannot initialize decompressor");
1998 lzo_uint len = ssize;
2001 if (this->chain->Read((byte*)tmp,
sizeof(tmp)) !=
sizeof(tmp))
SlError(STR_GAME_SAVELOAD_ERROR_FILE_NOT_READABLE,
"File read failed");
2004 ((uint32*)out)[0] = size = tmp[1];
2007 tmp[0] = TO_BE32(tmp[0]);
2008 size = TO_BE32(size);
2014 if (this->chain->Read(out +
sizeof(uint32), size) != size)
SlError(STR_GAME_SAVELOAD_ERROR_FILE_NOT_READABLE);
2017 if (tmp[0] != lzo_adler32(0, out, size +
sizeof(uint32)))
SlErrorCorrupt(
"Bad checksum");
2020 int ret = lzo1x_decompress_safe(out +
sizeof(uint32) * 1, size, buf, &len, NULL);
2021 if (ret != LZO_E_OK)
SlError(STR_GAME_SAVELOAD_ERROR_FILE_NOT_READABLE);
2035 if (lzo_init() != LZO_E_OK)
SlError(STR_GAME_SAVELOAD_ERROR_BROKEN_INTERNAL_ERROR,
"cannot initialize compressor");
2040 const lzo_bytep in =
buf;
2043 byte wrkmem[LZO1X_1_MEM_COMPRESS];
2049 lzo1x_1_compress(in, len, out +
sizeof(uint32) * 2, &outlen, wrkmem);
2050 ((uint32*)out)[1] = TO_BE32((uint32)outlen);
2051 ((uint32*)out)[0] = TO_BE32(lzo_adler32(0, out +
sizeof(uint32), outlen +
sizeof(uint32)));
2052 this->chain->Write(out, outlen +
sizeof(uint32) * 2);
2079 return this->chain->Read(buf, size);
2096 this->chain->Write(buf, size);
2104 #if defined(WITH_ZLIB) 2118 memset(&this->z, 0,
sizeof(this->z));
2119 if (inflateInit(&this->z) != Z_OK)
SlError(STR_GAME_SAVELOAD_ERROR_BROKEN_INTERNAL_ERROR,
"cannot initialize decompressor");
2125 inflateEnd(&this->z);
2130 this->z.next_out =
buf;
2131 this->z.avail_out = (uint)size;
2135 if (this->z.avail_in == 0) {
2136 this->z.next_in = this->fread_buf;
2137 this->z.avail_in = (uint)this->chain->Read(this->fread_buf,
sizeof(this->fread_buf));
2141 int r = inflate(&this->z, 0);
2142 if (r == Z_STREAM_END)
break;
2144 if (r != Z_OK)
SlError(STR_GAME_SAVELOAD_ERROR_BROKEN_INTERNAL_ERROR,
"inflate() failed");
2145 }
while (this->z.avail_out != 0);
2147 return size - this->z.avail_out;
2162 memset(&this->z, 0,
sizeof(this->z));
2163 if (deflateInit(&this->z, compression_level) != Z_OK)
SlError(STR_GAME_SAVELOAD_ERROR_BROKEN_INTERNAL_ERROR,
"cannot initialize compressor");
2169 deflateEnd(&this->z);
2182 this->z.next_in = p;
2183 this->z.avail_in = (uInt)len;
2185 this->z.next_out =
buf;
2186 this->z.avail_out =
sizeof(
buf);
2195 int r = deflate(&this->z, mode);
2198 if ((n =
sizeof(buf) - this->z.avail_out) != 0) {
2199 this->chain->Write(buf, n);
2201 if (r == Z_STREAM_END)
break;
2203 if (r != Z_OK)
SlError(STR_GAME_SAVELOAD_ERROR_BROKEN_INTERNAL_ERROR,
"zlib returned error code");
2204 }
while (this->z.avail_in || !this->z.avail_out);
2209 this->WriteLoop(buf, size, 0);
2214 this->WriteLoop(NULL, 0, Z_FINISH);
2215 this->chain->Finish();
2225 #if defined(WITH_LZMA) 2248 if (lzma_auto_decoder(&this->lzma, 1 << 28, 0) != LZMA_OK)
SlError(STR_GAME_SAVELOAD_ERROR_BROKEN_INTERNAL_ERROR,
"cannot initialize decompressor");
2254 lzma_end(&this->lzma);
2259 this->lzma.next_out =
buf;
2260 this->lzma.avail_out = size;
2264 if (this->lzma.avail_in == 0) {
2265 this->lzma.next_in = this->fread_buf;
2266 this->lzma.avail_in = this->chain->Read(this->fread_buf,
sizeof(this->fread_buf));
2270 lzma_ret r = lzma_code(&this->lzma, LZMA_RUN);
2271 if (r == LZMA_STREAM_END)
break;
2272 if (r != LZMA_OK)
SlError(STR_GAME_SAVELOAD_ERROR_BROKEN_INTERNAL_ERROR,
"liblzma returned error code");
2273 }
while (this->lzma.avail_out != 0);
2275 return size - this->lzma.avail_out;
2290 if (lzma_easy_encoder(&this->lzma, compression_level, LZMA_CHECK_CRC32) != LZMA_OK)
SlError(STR_GAME_SAVELOAD_ERROR_BROKEN_INTERNAL_ERROR,
"cannot initialize compressor");
2296 lzma_end(&this->lzma);
2309 this->lzma.next_in = p;
2310 this->lzma.avail_in = len;
2312 this->lzma.next_out =
buf;
2313 this->lzma.avail_out =
sizeof(
buf);
2315 lzma_ret r = lzma_code(&this->lzma, action);
2318 if ((n =
sizeof(buf) - this->lzma.avail_out) != 0) {
2319 this->chain->Write(buf, n);
2321 if (r == LZMA_STREAM_END)
break;
2322 if (r != LZMA_OK)
SlError(STR_GAME_SAVELOAD_ERROR_BROKEN_INTERNAL_ERROR,
"liblzma returned error code");
2323 }
while (this->lzma.avail_in || !this->lzma.avail_out);
2328 this->WriteLoop(buf, size, LZMA_RUN);
2333 this->WriteLoop(NULL, 0, LZMA_FINISH);
2334 this->chain->Finish();
2359 #if defined(WITH_LZO) 2361 {
"lzo", TO_BE32X(
'OTTD'), CreateLoadFilter<LZOLoadFilter>, CreateSaveFilter<LZOSaveFilter>, 0, 0, 0},
2363 {
"lzo", TO_BE32X(
'OTTD'), NULL, NULL, 0, 0, 0},
2366 {
"none", TO_BE32X(
'OTTN'), CreateLoadFilter<NoCompLoadFilter>, CreateSaveFilter<NoCompSaveFilter>, 0, 0, 0},
2367 #if defined(WITH_ZLIB) 2371 {
"zlib", TO_BE32X(
'OTTZ'), CreateLoadFilter<ZlibLoadFilter>, CreateSaveFilter<ZlibSaveFilter>, 0, 6, 9},
2373 {
"zlib", TO_BE32X(
'OTTZ'), NULL, NULL, 0, 0, 0},
2375 #if defined(WITH_LZMA) 2381 {
"lzma", TO_BE32X(
'OTTX'), CreateLoadFilter<LZMALoadFilter>, CreateSaveFilter<LZMASaveFilter>, 0, 2, 9},
2383 {
"lzma", TO_BE32X(
'OTTX'), NULL, NULL, 0, 0, 0},
2403 char *complevel = strrchr(s,
':');
2404 if (complevel != NULL) *complevel =
'\0';
2406 for (
const SaveLoadFormat *slf = &_saveload_formats[0]; slf !=
endof(_saveload_formats); slf++) {
2407 if (slf->init_write != NULL && strcmp(s, slf->name) == 0) {
2408 *compression_level = slf->default_compression;
2409 if (complevel != NULL) {
2418 long level = strtol(complevel, &end, 10);
2419 if (end == complevel || level !=
Clamp(level, slf->min_compression, slf->max_compression)) {
2423 *compression_level = level;
2435 if (complevel != NULL) *complevel =
':';
2442 void InitializeGame(uint size_x, uint size_y,
bool reset_date,
bool reset_settings);
2444 extern bool LoadOldSaveGame(
const char *file);
2482 if (_game_mode != GM_MENU) _fast_forward = _sl.
ff_state;
2501 static char err_str[512];
2502 GetString(err_str, _sl.
action ==
SLA_SAVE ? STR_ERROR_GAME_SAVE_FAILED : STR_ERROR_GAME_LOAD_FAILED,
lastof(err_str));
2526 _sl.
sf->
Write((byte*)hdr,
sizeof(hdr));
2543 if (_sl.
error_str != STR_NETWORK_ERROR_LOSTCONNECTION) {
2564 void WaitTillSaved()
2566 if (_save_thread == NULL)
return;
2568 _save_thread->
Join();
2570 _save_thread = NULL;
2593 SaveViewportBeforeSaveGame();
2598 if (threaded)
DEBUG(sl, 1,
"Cannot create savegame thread, reverting to single-threaded mode...");
2619 return DoSave(writer, threaded);
2644 if (_sl.
lf->
Read((byte*)hdr,
sizeof(hdr)) !=
sizeof(hdr))
SlError(STR_GAME_SAVELOAD_ERROR_FILE_NOT_READABLE);
2650 if (fmt ==
endof(_saveload_formats)) {
2651 DEBUG(sl, 0,
"Unknown savegame type, trying to load it as the buggy format");
2659 if (fmt ==
endof(_saveload_formats)) {
2663 if (fmt->
tag == TO_BE32X(
'OTTD'))
break;
2669 if (fmt->
tag == hdr[0]) {
2691 SlError(STR_GAME_SAVELOAD_ERROR_BROKEN_INTERNAL_ERROR, err_str);
2702 InitializeGame(256, 256,
true,
true);
2774 return DoLoad(reader,
false);
2803 InitializeGame(256, 256,
true,
true);
2811 if (!LoadOldSaveGame(filename))
return SL_REINIT;
2837 default: NOT_REACHED();
2848 SlError(fop ==
SLO_SAVE ? STR_GAME_SAVELOAD_ERROR_FILE_NOT_WRITEABLE : STR_GAME_SAVELOAD_ERROR_FILE_NOT_READABLE);
2860 DEBUG(desync, 1,
"load: %s", filename);
2893 FOR_ALL_COMPANIES(c) {
2903 case 0:
SetDParam(1, STR_JUST_DATE_LONG);
break;
2904 case 1:
SetDParam(1, STR_JUST_DATE_TINY);
break;
2905 case 2:
SetDParam(1, STR_JUST_DATE_ISO);
break;
2906 default: NOT_REACHED();
2911 GetString(buf, !
Company::IsValidID(cid) ? STR_SAVEGAME_NAME_SPECTATOR : STR_SAVEGAME_NAME_DEFAULT, last);
2939 this->file_op = fop;
2940 this->detail_ftype = dft;
2941 this->abstract_ftype = aft;
2969 int GetSavegameType(
char *file)
2974 int mode = SL_OLD_LOAD;
2976 f = fopen(file,
"rb");
2977 if (fread(&hdr,
sizeof(hdr), 1, f) != 1) {
2978 DEBUG(sl, 0,
"Savegame is obsolete or invalid format");
2982 for (fmt = _saveload_formats; fmt !=
endof(_saveload_formats); fmt++) {
2983 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.
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.
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.
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).
const uint16 SAVEGAME_VERSION
Current savegame version of OpenTTD.
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)
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
uint16 _sl_version
the major savegame version identifier
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
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
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.
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.
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.
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.
uint16 version_to
save/load the variable until this savegame version
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 bool IsSavegameVersionBefore(uint16 major, byte minor=0)
Checks whether the savegame is below major.
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 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.
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.
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.
uint16 version_from
save/load the variable starting from this savegame version
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
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...