23 #include "../stdafx.h"
25 #include "../station_base.h"
26 #include "../thread.h"
28 #include "../network/network.h"
29 #include "../window_func.h"
30 #include "../strings_func.h"
31 #include "../core/endian_func.hpp"
32 #include "../vehicle_base.h"
33 #include "../company_func.h"
34 #include "../timer/timer_game_economy.h"
35 #include "../autoreplace_base.h"
36 #include "../roadstop_base.h"
37 #include "../linkgraph/linkgraph.h"
38 #include "../linkgraph/linkgraphjob.h"
39 #include "../statusbar_gui.h"
40 #include "../fileio_func.h"
41 #include "../gamelog.h"
42 #include "../string_func.h"
47 # include <emscripten.h>
50 #include "table/strings.h"
55 #include "../safeguards.h"
102 inline uint8_t ReadByte()
104 if (this->bufp == this->bufe) {
105 size_t len = this->reader->Read(this->buf,
lengthof(this->buf));
109 this->bufp = this->
buf;
110 this->bufe = this->buf + len;
113 return *this->bufp++;
122 return this->read - (this->bufe - this->
bufp);
129 std::vector<std::unique_ptr<uint8_t[]>>
blocks{};
140 if (this->buf == this->bufe) {
152 void Flush(std::shared_ptr<SaveFilter> writer)
160 writer->Write(this->
blocks[i++].get(), to_write);
173 return this->
blocks.size() * MEMORY_CHUNK_SIZE - (this->bufe - this->
buf);
189 std::shared_ptr<SaveFilter>
sf;
192 std::shared_ptr<LoadFilter>
lf;
244 _gamelog_chunk_handlers,
246 _misc_chunk_handlers,
247 _name_chunk_handlers,
248 _cheat_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,
257 _cargomonitor_chunk_handlers,
258 _goal_chunk_handlers,
259 _story_page_chunk_handlers,
260 _league_chunk_handlers,
261 _engine_chunk_handlers,
262 _town_chunk_handlers,
263 _sign_chunk_handlers,
264 _station_chunk_handlers,
265 _company_chunk_handlers,
267 _game_chunk_handlers,
268 _animated_tile_chunk_handlers,
269 _newgrf_chunk_handlers,
270 _group_chunk_handlers,
271 _cargopacket_chunk_handlers,
272 _autoreplace_chunk_handlers,
273 _labelmaps_chunk_handlers,
274 _linkgraph_chunk_handlers,
275 _airport_chunk_handlers,
276 _object_chunk_handlers,
277 _persistent_storage_chunk_handlers,
278 _water_region_chunk_handlers,
279 _randomizer_chunk_handlers,
282 static std::vector<ChunkHandlerRef> _chunk_handlers;
284 if (_chunk_handlers.empty()) {
285 for (
auto &chunk_handler_table : _chunk_handler_tables) {
286 for (
auto &chunk_handler : chunk_handler_table) {
287 _chunk_handlers.push_back(chunk_handler);
292 return _chunk_handlers;
306 Debug(sl, 3,
"Nulling pointers for {}", ch.GetName());
341 throw std::exception();
353 SlError(STR_GAME_SAVELOAD_ERROR_BROKEN_SAVEGAME, msg);
367 if (_exit_game)
return;
379 if (proc ==
nullptr)
return;
406 static inline int SlReadUint16()
412 static inline uint32_t SlReadUint32()
414 uint32_t x = SlReadUint16() << 16;
415 return x | SlReadUint16();
418 static inline uint64_t SlReadUint64()
420 uint32_t x = SlReadUint32();
421 uint32_t y = SlReadUint32();
422 return (uint64_t)x << 32 | y;
425 static inline void SlWriteUint16(uint16_t v)
431 static inline void SlWriteUint32(uint32_t v)
433 SlWriteUint16(
GB(v, 16, 16));
434 SlWriteUint16(
GB(v, 0, 16));
437 static inline void SlWriteUint64(uint64_t x)
439 SlWriteUint32((uint32_t)(x >> 32));
440 SlWriteUint32((uint32_t)x);
497 if (i >= (1 << 14)) {
498 if (i >= (1 << 21)) {
499 if (i >= (1 << 28)) {
500 assert(i <= UINT32_MAX);
521 return 1 + (i >= (1 << 7)) + (i >= (1 << 14)) + (i >= (1 << 21)) + (i >= (1 << 28));
524 static inline uint SlReadSparseIndex()
529 static inline void SlWriteSparseIndex(uint index)
534 static inline uint SlReadArrayLength()
539 static inline void SlWriteArrayLength(
size_t length)
544 static inline uint SlGetArrayLength(
size_t length)
577 default: NOT_REACHED();
590 case SLE_VAR_BL:
return sizeof(bool);
591 case SLE_VAR_I8:
return sizeof(int8_t);
592 case SLE_VAR_U8:
return sizeof(uint8_t);
593 case SLE_VAR_I16:
return sizeof(int16_t);
594 case SLE_VAR_U16:
return sizeof(uint16_t);
595 case SLE_VAR_I32:
return sizeof(int32_t);
596 case SLE_VAR_U32:
return sizeof(uint32_t);
597 case SLE_VAR_I64:
return sizeof(int64_t);
598 case SLE_VAR_U64:
return sizeof(uint64_t);
603 return SlReadArrayLength();
621 case SLE_FILE_I8:
return sizeof(int8_t);
622 case SLE_FILE_U8:
return sizeof(uint8_t);
623 case SLE_FILE_I16:
return sizeof(int16_t);
624 case SLE_FILE_U16:
return sizeof(uint16_t);
625 case SLE_FILE_I32:
return sizeof(int32_t);
626 case SLE_FILE_U32:
return sizeof(uint32_t);
627 case SLE_FILE_I64:
return sizeof(int64_t);
628 case SLE_FILE_U64:
return sizeof(uint64_t);
631 case SLE_FILE_STRING:
632 return SlReadArrayLength();
634 case SLE_FILE_STRUCT:
646 void SlSetArrayIndex(uint index)
649 _sl.array_index = index;
652 static size_t _next_offs;
662 if (_next_offs != 0 &&
_sl.
reader->GetSize() != _next_offs) {
663 SlErrorCorruptFmt(
"Invalid chunk size iterating array - expected to be at position {}, actually at {}", _next_offs,
_sl.
reader->GetSize());
667 uint length = SlReadArrayLength();
675 _next_offs =
_sl.
reader->GetSize() + length;
684 case CH_SPARSE_TABLE:
685 case CH_SPARSE_ARRAY: index = (int)SlReadSparseIndex();
break;
687 case CH_ARRAY: index =
_sl.array_index++;
break;
689 Debug(sl, 0,
"SlIterateArray error");
693 if (length != 0)
return index;
721 SlWriteArrayLength(length + 1);
730 assert(length < (1 << 28));
731 SlWriteUint32((uint32_t)((length & 0xFFFFFF) | ((length >> 24) << 28)));
737 SlWriteArrayLength(1);
739 SlWriteArrayLength(length + 1);
741 case CH_SPARSE_TABLE:
742 case CH_SPARSE_ARRAY:
743 SlWriteArrayLength(length + 1 + SlGetArrayLength(
_sl.array_index));
744 SlWriteSparseIndex(
_sl.array_index);
746 default: NOT_REACHED();
754 default: NOT_REACHED();
766 uint8_t *p = (uint8_t *)ptr;
771 for (; length != 0; length--) *p++ =
SlReadByte();
776 default: NOT_REACHED();
796 case SLE_VAR_BL:
return (*(
const bool *)ptr != 0);
797 case SLE_VAR_I8:
return *(
const int8_t *)ptr;
798 case SLE_VAR_U8:
return *(
const uint8_t *)ptr;
799 case SLE_VAR_I16:
return *(
const int16_t *)ptr;
800 case SLE_VAR_U16:
return *(
const uint16_t*)ptr;
801 case SLE_VAR_I32:
return *(
const int32_t *)ptr;
802 case SLE_VAR_U32:
return *(
const uint32_t*)ptr;
803 case SLE_VAR_I64:
return *(
const int64_t *)ptr;
804 case SLE_VAR_U64:
return *(
const uint64_t*)ptr;
806 default: NOT_REACHED();
820 case SLE_VAR_BL: *(
bool *)ptr = (val != 0);
break;
821 case SLE_VAR_I8: *(int8_t *)ptr = val;
break;
822 case SLE_VAR_U8: *(uint8_t *)ptr = val;
break;
823 case SLE_VAR_I16: *(int16_t *)ptr = val;
break;
824 case SLE_VAR_U16: *(uint16_t*)ptr = val;
break;
825 case SLE_VAR_I32: *(int32_t *)ptr = val;
break;
826 case SLE_VAR_U32: *(uint32_t*)ptr = val;
break;
827 case SLE_VAR_I64: *(int64_t *)ptr = val;
break;
828 case SLE_VAR_U64: *(uint64_t*)ptr = val;
break;
831 default: NOT_REACHED();
851 case SLE_FILE_I8: assert(x >= -128 && x <= 127);
SlWriteByte(x);
break;
852 case SLE_FILE_U8: assert(x >= 0 && x <= 255);
SlWriteByte(x);
break;
853 case SLE_FILE_I16:assert(x >= -32768 && x <= 32767); SlWriteUint16(x);
break;
855 case SLE_FILE_U16:assert(x >= 0 && x <= 65535); SlWriteUint16(x);
break;
857 case SLE_FILE_U32: SlWriteUint32((uint32_t)x);
break;
859 case SLE_FILE_U64: SlWriteUint64(x);
break;
860 default: NOT_REACHED();
869 case SLE_FILE_I8: x = (int8_t )
SlReadByte();
break;
870 case SLE_FILE_U8: x = (uint8_t )
SlReadByte();
break;
871 case SLE_FILE_I16: x = (int16_t )SlReadUint16();
break;
872 case SLE_FILE_U16: x = (uint16_t)SlReadUint16();
break;
873 case SLE_FILE_I32: x = (int32_t )SlReadUint32();
break;
874 case SLE_FILE_U32: x = (uint32_t)SlReadUint32();
break;
875 case SLE_FILE_I64: x = (int64_t )SlReadUint64();
break;
876 case SLE_FILE_U64: x = (uint64_t)SlReadUint64();
break;
878 default: NOT_REACHED();
887 default: NOT_REACHED();
900 const std::string *str =
reinterpret_cast<const std::string *
>(ptr);
902 size_t len = str->length();
903 return len + SlGetArrayLength(len);
916 for (
size_t i = 0; i < str.size(); ) {
918 if (len == 0 || i + len > str.size())
break;
922 if (c == 0xE028 || c == 0xE02A)
Utf8Encode(&str[i], SCC_ENCODED);
934 std::string *str =
reinterpret_cast<std::string *
>(ptr);
938 size_t len = str->length();
939 SlWriteArrayLength(len);
940 SlCopyBytes(
const_cast<void *
>(
static_cast<const void *
>(str->c_str())), len);
946 size_t len = SlReadArrayLength();
968 default: NOT_REACHED();
992 if (conv == SLE_INT16 || conv == SLE_UINT16 || conv == SLE_STRINGID ||
993 conv == SLE_INT32 || conv == SLE_UINT32) {
998 if (conv == (SLE_FILE_I32 | SLE_VAR_I64)) {
999 for (uint i = 0; i < length; i++) {
1000 ((int64_t*)
object)[i] = (int32_t)
BSWAP32(SlReadUint32());
1008 if (conv == SLE_INT8 || conv == SLE_UINT8) {
1011 uint8_t *a = (uint8_t*)
object;
1014 for (; length != 0; length --) {
1029 void SlCopy(
void *
object,
size_t length, VarType conv)
1059 static void SlArray(
void *array,
size_t length, VarType conv)
1063 SlWriteArrayLength(length);
1070 size_t sv_length = SlReadArrayLength();
1074 }
else if (sv_length != length) {
1109 if (obj ==
nullptr)
return 0;
1124 default: NOT_REACHED();
1140 static_assert(
sizeof(
size_t) <=
sizeof(
void *));
1205 default: NOT_REACHED();
1228 *(
void **)ptr =
nullptr;
1230 default: NOT_REACHED();
1237 template <
template<
typename,
typename>
typename Tstorage,
typename Tvar,
typename Tallocator = std::allocator<Tvar>>
1239 typedef Tstorage<Tvar, Tallocator> SlStorageT;
1251 const SlStorageT *list =
static_cast<const SlStorageT *
>(storage);
1253 int type_size = SlGetArrayLength(list->size());
1255 return list->size() * item_size + type_size;
1258 static void SlSaveLoadMember(
SaveLoadType cmd, Tvar *item, VarType conv)
1279 SlStorageT *list =
static_cast<SlStorageT *
>(storage);
1283 SlWriteArrayLength(list->size());
1285 for (
auto &item : *list) {
1286 SlSaveLoadMember(cmd, &item, conv);
1296 case SL_STDSTR: length = SlReadArrayLength();
break;
1297 default: NOT_REACHED();
1301 if constexpr (std::is_same_v<SlStorageT, std::vector<Tvar, Tallocator>>) {
1302 list->reserve(length);
1306 for (
size_t i = 0; i < length; i++) {
1307 Tvar &data = list->emplace_back();
1308 SlSaveLoadMember(cmd, &data, conv);
1314 for (
auto &item : *list) {
1315 SlSaveLoadMember(cmd, &item, conv);
1323 default: NOT_REACHED();
1378 default: NOT_REACHED();
1409 default: NOT_REACHED();
1421 case SLE_VAR_BL: NOT_REACHED();
1436 default: NOT_REACHED();
1448 case SLE_VAR_BL: NOT_REACHED();
1467 default: NOT_REACHED();
1486 for (
auto &sld : slt) {
1495 for (
auto &sld : slt) {
1516 for (
auto &sld : slt) {
1517 length += SlCalcObjMemberLength(
object, sld);
1522 size_t SlCalcObjMemberLength(
const void *
object,
const SaveLoad &sld)
1550 sld.
handler->Save(
const_cast<void *
>(
object));
1557 length += SlGetArrayLength(1);
1563 default: NOT_REACHED();
1568 static bool SlObjectMember(
void *
object,
const SaveLoad &sld)
1572 VarType conv =
GB(sld.
conv, 0, 8);
1591 default: NOT_REACHED();
1608 default: NOT_REACHED();
1622 default: NOT_REACHED();
1643 sld.
handler->LoadCheck(
object);
1656 sld.
handler->FixPointers(
object);
1660 default: NOT_REACHED();
1664 default: NOT_REACHED();
1681 SlWriteArrayLength(length);
1691 size_t length = SlReadArrayLength();
1710 for (
auto &sld : slt) {
1711 SlObjectMember(
object, sld);
1720 void Save(
void *)
const override
1725 void Load(
void *
object)
const override
1728 for (; length > 0; length--) {
1733 void LoadCheck(
void *
object)
const override
1763 std::vector<SaveLoad> saveloads;
1766 std::map<std::string, const SaveLoad *> key_lookup;
1767 for (
auto &sld : slt) {
1771 assert(key_lookup.find(sld.
name) == key_lookup.end());
1772 key_lookup[sld.
name] = &sld;
1783 auto sld_it = key_lookup.find(key);
1784 if (sld_it == key_lookup.end()) {
1788 std::shared_ptr<SaveLoadHandler> handler =
nullptr;
1791 case SLE_FILE_STRING:
1796 case SLE_FILE_STRUCT:
1799 handler = std::make_shared<SlSkipHandler>();
1818 if (correct_type != type) {
1819 Debug(sl, 1,
"Field type for '{}' was expected to be 0x{:02x} but 0x{:02x} was found", key, correct_type, type);
1822 saveloads.push_back(*sld_it->second);
1825 for (
auto &sld : saveloads) {
1841 for (
auto &sld : slt) {
1844 assert(!sld.
name.empty());
1858 for (
auto &sld : slt) {
1874 default: NOT_REACHED();
1877 return std::vector<SaveLoad>();
1899 std::vector<SaveLoad> saveloads;
1902 std::map<std::string, std::vector<const SaveLoad *>> key_lookup;
1903 for (
auto &sld : slt) {
1905 assert(!sld.
name.empty());
1907 key_lookup[sld.
name].push_back(&sld);
1910 for (
auto &slc : slct) {
1911 if (slc.name.empty()) {
1917 auto sld_it = key_lookup.find(slc.name);
1921 if (sld_it == key_lookup.end()) {
1924 Debug(sl, 0,
"internal error: saveload compatibility field '{}' not found", slc.name);
1927 for (
auto &sld : sld_it->second) {
1928 saveloads.push_back(*sld);
1933 for (
auto &sld : saveloads) {
1970 size_t start_pos =
_sl.
dumper->GetSize();
1971 size_t expected_offs = start_pos +
_sl.
obj_len;
1976 if (expected_offs !=
_sl.
dumper->GetSize()) {
1977 SlErrorCorruptFmt(
"Invalid chunk size when writing autolength block, expected {}, got {}",
_sl.
obj_len,
_sl.
dumper->GetSize() - start_pos);
1985 case CH_SPARSE_TABLE:
1989 case CH_SPARSE_ARRAY:
2021 _sl.array_index = 0;
2025 case CH_SPARSE_TABLE:
2026 case CH_SPARSE_ARRAY:
2032 size_t len = (
SlReadByte() << 16) | ((m >> 4) << 24);
2033 len += SlReadUint16();
2035 size_t start_pos =
_sl.
reader->GetSize();
2036 size_t endoffs = start_pos + len;
2040 SlErrorCorruptFmt(
"Invalid chunk size in RIFF in {} - expected {}, got {}", ch.GetName(), len,
_sl.
reader->GetSize() - start_pos);
2074 _sl.array_index = 0;
2077 case CH_SPARSE_TABLE:
2078 case CH_SPARSE_ARRAY:
2083 size_t len = (
SlReadByte() << 16) | ((m >> 4) << 24);
2084 len += SlReadUint16();
2086 size_t start_pos =
_sl.
reader->GetSize();
2087 size_t endoffs = start_pos + len;
2091 SlErrorCorruptFmt(
"Invalid chunk size in RIFF in {} - expected {}, got {}", ch.GetName(), len,
_sl.
reader->GetSize() - start_pos);
2112 SlWriteUint32(ch.
id);
2113 Debug(sl, 2,
"Saving chunk {}", ch.GetName());
2129 SlWriteArrayLength(0);
2131 case CH_SPARSE_TABLE:
2132 case CH_SPARSE_ARRAY:
2135 SlWriteArrayLength(0);
2137 default: NOT_REACHED();
2172 for (
id = SlReadUint32();
id != 0;
id = SlReadUint32()) {
2173 Debug(sl, 2,
"Loading chunk {:c}{:c}{:c}{:c}",
id >> 24,
id >> 16,
id >> 8,
id);
2187 for (
id = SlReadUint32();
id != 0;
id = SlReadUint32()) {
2188 Debug(sl, 2,
"Loading chunk {:c}{:c}{:c}{:c}",
id >> 24,
id >> 16,
id >> 8,
id);
2202 Debug(sl, 3,
"Fixing pointers for {}", ch.GetName());
2226 if (this->file.has_value()) {
2231 size_t Read(uint8_t *buf,
size_t size)
override
2234 if (!this->file.has_value())
return 0;
2236 return fread(buf, 1, size, *this->file);
2241 clearerr(*this->file);
2242 if (fseek(*this->file, this->begin, SEEK_SET)) {
2243 Debug(sl, 1,
"Could not reset the file reading");
2266 void Write(uint8_t *buf,
size_t size)
override
2269 if (!this->file.has_value())
return;
2271 if (fwrite(buf, 1, size, *this->file) != size)
SlError(STR_GAME_SAVELOAD_ERROR_FILE_NOT_WRITEABLE);
2276 if (this->file.has_value()) {
2288 #include <lzo/lzo1x.h>
2301 if (lzo_init() != LZO_E_OK)
SlError(STR_GAME_SAVELOAD_ERROR_BROKEN_INTERNAL_ERROR,
"cannot initialize decompressor");
2304 size_t Read(uint8_t *buf,
size_t ssize)
override
2312 lzo_uint len = ssize;
2315 if (this->
chain->Read((uint8_t*)tmp,
sizeof(tmp)) !=
sizeof(tmp))
SlError(STR_GAME_SAVELOAD_ERROR_FILE_NOT_READABLE,
"File read failed");
2318 ((uint32_t*)out)[0] = size = tmp[1];
2321 tmp[0] = TO_BE32(tmp[0]);
2322 size = TO_BE32(size);
2328 if (this->
chain->Read(out +
sizeof(uint32_t), size) != size)
SlError(STR_GAME_SAVELOAD_ERROR_FILE_NOT_READABLE);
2331 if (tmp[0] != lzo_adler32(0, out, size +
sizeof(uint32_t)))
SlErrorCorrupt(
"Bad checksum");
2334 int ret = lzo1x_decompress_safe(out +
sizeof(uint32_t) * 1, size, buf, &len,
nullptr);
2335 if (ret != LZO_E_OK)
SlError(STR_GAME_SAVELOAD_ERROR_FILE_NOT_READABLE);
2348 if (lzo_init() != LZO_E_OK)
SlError(STR_GAME_SAVELOAD_ERROR_BROKEN_INTERNAL_ERROR,
"cannot initialize compressor");
2351 void Write(uint8_t *buf,
size_t size)
override
2353 const lzo_bytep in = buf;
2356 uint8_t wrkmem[LZO1X_1_MEM_COMPRESS];
2362 lzo1x_1_compress(in, len, out +
sizeof(uint32_t) * 2, &outlen, wrkmem);
2363 ((uint32_t*)out)[1] = TO_BE32((uint32_t)outlen);
2364 ((uint32_t*)out)[0] = TO_BE32(lzo_adler32(0, out +
sizeof(uint32_t), outlen +
sizeof(uint32_t)));
2365 this->
chain->Write(out, outlen +
sizeof(uint32_t) * 2);
2390 size_t Read(uint8_t *buf,
size_t size)
override
2392 return this->
chain->Read(buf, size);
2406 void Write(uint8_t *buf,
size_t size)
override
2408 this->
chain->Write(buf, size);
2416 #if defined(WITH_ZLIB)
2430 memset(&this->z, 0,
sizeof(this->z));
2431 if (inflateInit(&this->z) != Z_OK)
SlError(STR_GAME_SAVELOAD_ERROR_BROKEN_INTERNAL_ERROR,
"cannot initialize decompressor");
2437 inflateEnd(&this->z);
2440 size_t Read(uint8_t *buf,
size_t size)
override
2442 this->z.next_out = buf;
2443 this->z.avail_out = (uint)size;
2447 if (this->z.avail_in == 0) {
2449 this->z.avail_in = (uint)this->
chain->Read(this->fread_buf,
sizeof(this->fread_buf));
2453 int r = inflate(&this->z, 0);
2454 if (r == Z_STREAM_END)
break;
2456 if (r != Z_OK)
SlError(STR_GAME_SAVELOAD_ERROR_BROKEN_INTERNAL_ERROR,
"inflate() failed");
2457 }
while (this->z.avail_out != 0);
2459 return size - this->z.avail_out;
2475 memset(&this->z, 0,
sizeof(this->z));
2476 if (deflateInit(&this->z, compression_level) != Z_OK)
SlError(STR_GAME_SAVELOAD_ERROR_BROKEN_INTERNAL_ERROR,
"cannot initialize compressor");
2482 deflateEnd(&this->z);
2494 this->z.next_in = p;
2495 this->z.avail_in = (uInt)len;
2498 this->z.avail_out =
sizeof(this->
fwrite_buf);
2507 int r = deflate(&this->z, mode);
2510 if ((n =
sizeof(this->fwrite_buf) - this->z.avail_out) != 0) {
2511 this->
chain->Write(this->fwrite_buf, n);
2513 if (r == Z_STREAM_END)
break;
2515 if (r != Z_OK)
SlError(STR_GAME_SAVELOAD_ERROR_BROKEN_INTERNAL_ERROR,
"zlib returned error code");
2516 }
while (this->z.avail_in || !this->z.avail_out);
2519 void Write(uint8_t *buf,
size_t size)
override
2527 this->
chain->Finish();
2537 #if defined(WITH_LIBLZMA)
2560 if (lzma_auto_decoder(&this->lzma, 1 << 28, 0) != LZMA_OK)
SlError(STR_GAME_SAVELOAD_ERROR_BROKEN_INTERNAL_ERROR,
"cannot initialize decompressor");
2566 lzma_end(&this->lzma);
2569 size_t Read(uint8_t *buf,
size_t size)
override
2571 this->lzma.next_out = buf;
2572 this->lzma.avail_out = size;
2576 if (this->lzma.avail_in == 0) {
2578 this->lzma.avail_in = this->
chain->Read(this->fread_buf,
sizeof(this->fread_buf));
2582 lzma_ret r = lzma_code(&this->lzma, LZMA_RUN);
2583 if (r == LZMA_STREAM_END)
break;
2584 if (r != LZMA_OK)
SlError(STR_GAME_SAVELOAD_ERROR_BROKEN_INTERNAL_ERROR,
"liblzma returned error code");
2585 }
while (this->lzma.avail_out != 0);
2587 return size - this->lzma.avail_out;
2603 if (lzma_easy_encoder(&this->lzma, compression_level, LZMA_CHECK_CRC32) != LZMA_OK)
SlError(STR_GAME_SAVELOAD_ERROR_BROKEN_INTERNAL_ERROR,
"cannot initialize compressor");
2609 lzma_end(&this->lzma);
2621 this->lzma.next_in = p;
2622 this->lzma.avail_in = len;
2625 this->lzma.avail_out =
sizeof(this->
fwrite_buf);
2627 lzma_ret r = lzma_code(&this->lzma, action);
2630 if ((n =
sizeof(this->fwrite_buf) - this->lzma.avail_out) != 0) {
2631 this->
chain->Write(this->fwrite_buf, n);
2633 if (r == LZMA_STREAM_END)
break;
2634 if (r != LZMA_OK)
SlError(STR_GAME_SAVELOAD_ERROR_BROKEN_INTERNAL_ERROR,
"liblzma returned error code");
2635 }
while (this->lzma.avail_in || !this->lzma.avail_out);
2638 void Write(uint8_t *buf,
size_t size)
override
2645 this->
WriteLoop(
nullptr, 0, LZMA_FINISH);
2646 this->
chain->Finish();
2661 std::shared_ptr<LoadFilter> (*
init_load)(std::shared_ptr<LoadFilter> chain);
2662 std::shared_ptr<SaveFilter> (*
init_write)(std::shared_ptr<SaveFilter> chain, uint8_t compression);
2669 static const uint32_t SAVEGAME_TAG_LZO = TO_BE32X(
'OTTD');
2670 static const uint32_t SAVEGAME_TAG_NONE = TO_BE32X(
'OTTN');
2671 static const uint32_t SAVEGAME_TAG_ZLIB = TO_BE32X(
'OTTZ');
2672 static const uint32_t SAVEGAME_TAG_LZMA = TO_BE32X(
'OTTX');
2676 #if defined(WITH_LZO)
2678 {
"lzo", SAVEGAME_TAG_LZO, CreateLoadFilter<LZOLoadFilter>, CreateSaveFilter<LZOSaveFilter>, 0, 0, 0},
2680 {
"lzo", SAVEGAME_TAG_LZO,
nullptr,
nullptr, 0, 0, 0},
2683 {
"none", SAVEGAME_TAG_NONE, CreateLoadFilter<NoCompLoadFilter>, CreateSaveFilter<NoCompSaveFilter>, 0, 0, 0},
2684 #if defined(WITH_ZLIB)
2688 {
"zlib", SAVEGAME_TAG_ZLIB, CreateLoadFilter<ZlibLoadFilter>, CreateSaveFilter<ZlibSaveFilter>, 0, 6, 9},
2690 {
"zlib", SAVEGAME_TAG_ZLIB,
nullptr,
nullptr, 0, 0, 0},
2692 #if defined(WITH_LIBLZMA)
2698 {
"lzma", SAVEGAME_TAG_LZMA, CreateLoadFilter<LZMALoadFilter>, CreateSaveFilter<LZMASaveFilter>, 0, 2, 9},
2700 {
"lzma", SAVEGAME_TAG_LZMA,
nullptr,
nullptr, 0, 0, 0},
2714 if (it == std::rend(
_saveload_formats))
SlError(STR_GAME_SAVELOAD_ERROR_BROKEN_INTERNAL_ERROR,
"no writeable savegame formats");
2718 if (!full_name.empty()) {
2720 size_t separator = full_name.find(
':');
2721 bool has_comp_level = separator != std::string::npos;
2722 const std::string name(full_name, 0, has_comp_level ? separator : full_name.size());
2725 if (slf.init_write !=
nullptr && name.compare(slf.name) == 0) {
2726 if (has_comp_level) {
2727 const std::string complevel(full_name, separator + 1);
2731 long level = std::stol(complevel, &processed, 10);
2732 if (processed == 0 || level !=
Clamp(level, slf.min_compression, slf.max_compression)) {
2736 return {slf, ClampTo<uint8_t>(level)};
2739 return {slf, slf.default_compression};
2751 void InitializeGame(uint size_x, uint size_y,
bool reset_date,
bool reset_settings);
2753 extern bool LoadOldSaveGame(
const std::string &file);
2760 ResetTempEngineData();
2762 ResetOldWaypoints();
2793 #ifdef __EMSCRIPTEN__
2794 EM_ASM(
if (window[
"openttd_syncfs"]) openttd_syncfs());
2807 return _sl.
action ==
SLA_SAVE ? STR_ERROR_GAME_SAVE_FAILED : STR_ERROR_GAME_LOAD_FAILED;
2835 _sl.
sf->Write((uint8_t*)hdr,
sizeof(hdr));
2837 _sl.
sf = fmt.init_write(
_sl.
sf, compression);
2852 if (
_sl.
error_str != STR_NETWORK_ERROR_LOSTCONNECTION) {
2867 void WaitTillSaved()
2889 _sl.
dumper = std::make_unique<MemoryDumper>();
2894 SaveViewportBeforeSaveGame();
2900 if (threaded)
Debug(sl, 1,
"Cannot create savegame thread, reverting to single-threaded mode...");
2921 return DoSave(writer, threaded);
2955 Debug(sl, 0,
"Unknown savegame type, trying to load it as the buggy format");
2989 if (
_sl.
lf->Read((uint8_t*)hdr,
sizeof(hdr)) !=
sizeof(hdr))
SlError(STR_GAME_SAVELOAD_ERROR_FILE_NOT_READABLE);
2996 SlError(STR_GAME_SAVELOAD_ERROR_BROKEN_INTERNAL_ERROR, fmt::format(
"Loader for '{}' is not available.", fmt->
name));
3009 InitializeGame(256, 256,
true,
true);
3081 return DoLoad(reader,
false);
3112 InitializeGame(256, 256,
true,
true);
3120 if (!LoadOldSaveGame(filename))
return SL_REINIT;
3146 default: NOT_REACHED();
3156 if (!fh.has_value()) {
3157 SlError(fop ==
SLO_SAVE ? STR_GAME_SAVELOAD_ERROR_FILE_NOT_WRITEABLE : STR_GAME_SAVELOAD_ERROR_FILE_NOT_READABLE);
3164 return DoSave(std::make_shared<FileWriter>(std::move(*fh)), threaded);
3169 Debug(desync, 1,
"load: {}", filename);
3170 return DoLoad(std::make_shared<FileReader>(std::move(*fh)), fop ==
SLO_CHECK);
3190 std::string filename;
3198 Debug(sl, 2,
"Autosaving to '{}'", filename);
3233 SetDParam(1, STR_SAVEGAME_DURATION_REALTIME);
3239 case 0:
SetDParam(1, STR_JUST_DATE_LONG);
break;
3240 case 1:
SetDParam(1, STR_JUST_DATE_TINY);
break;
3241 case 2:
SetDParam(1, STR_JUST_DATE_ISO);
break;
3242 default: NOT_REACHED();
3289 this->
name = item.name;
3290 this->
title = item.title;
3295 assert(this->load_description.has_value());
3296 return *this->load_description;
constexpr debug_inline bool HasBit(const T x, const uint8_t y)
Checks if a bit in a value is set.
static uint32_t BSWAP32(uint32_t x)
Perform a 32 bits endianness bitswap on x.
constexpr static debug_inline uint GB(const T x, const uint8_t s, const uint8_t n)
Fetch n bits from x, started at bit s.
void StartAction(GamelogActionType at)
Stores information about new action, but doesn't allocate it Action is allocated only when there is a...
void Reset()
Resets and frees all memory allocated - used before loading or starting a new game.
void StopAction()
Stops logging of any changes.
Class for calculation jobs to be run on link graphs.
A connected component of a link graph.
Handler for saving/loading an object to/from disk.
SaveLoadTable GetLoadDescription() const
Get the description for how to load the chunk.
Handler that is assigned when there is a struct read in the savegame which is not known to the code.
virtual SaveLoadTable GetDescription() const override
Get the description of the fields in the savegame.
virtual SaveLoadCompatTable GetCompatDescription() const override
Get the pre-header description of the fields in the savegame.
Template class to help with list-like types.
static void SlSaveLoad(void *storage, VarType conv, SaveLoadType cmd=SL_VAR)
Internal templated helper to save/load a list-like type.
static size_t SlCalcLen(const void *storage, VarType conv, SaveLoadType cmd=SL_VAR)
Internal templated helper to return the size in bytes of a list-like type.
static constexpr TimerGameTick::Ticks TICKS_PER_SECOND
Estimation of how many ticks fit in a single second.
static Date date
Current date in days (day counter).
static bool UsingWallclockUnits(bool newgame=false)
Check if we are using wallclock units.
static DateFract date_fract
Fractional part of the day.
static TickCounter counter
Monotonic counter, in ticks, since start of game.
CompanyID _local_company
Company controlled by the human player at this client. Can also be COMPANY_SPECTATOR.
Owner
Enum for all companies/owners.
#define Debug(category, level, format_string,...)
Ouptut a line of debugging information.
void ShowErrorMessage(StringID summary_msg, int x, int y, CommandCost cc)
Display an error message in a window.
@ WL_ERROR
Errors (eg. saving/loading failed)
@ WL_CRITICAL
Critical errors, the MessageBox is shown in all cases.
void SanitizeFilename(std::string &filename)
Sanitizes a filename, i.e.
std::optional< FileHandle > FioFOpenFile(const std::string &filename, const char *mode, Subdirectory subdir, size_t *filesize)
Opens a OpenTTD file somewhere in a personal or global directory.
DetailedFileType GetDetailedFileType(FiosType fios_type)
Extract the detailed file type from a FiosType.
AbstractFileType GetAbstractFileType(FiosType fios_type)
Extract the abstract file type from a FiosType.
AbstractFileType
The different abstract types of files that the system knows about.
@ FT_INVALID
Invalid or unknown file type.
FiosType
Elements of a file system that are recognized.
SaveLoadOperation
Operation performed on the file.
@ SLO_CHECK
Load file for checking and/or preview.
@ SLO_SAVE
File is being saved.
@ SLO_LOAD
File is being loaded.
@ SLO_INVALID
Unknown file operation.
DetailedFileType
Kinds of files in each AbstractFileType.
@ DFT_GAME_FILE
Save game or scenario file.
@ DFT_INVALID
Unknown or invalid file.
@ DFT_OLD_GAME_FILE
Old save game or scenario file.
Subdirectory
The different kinds of subdirectories OpenTTD uses.
@ SCENARIO_DIR
Base directory for all scenarios.
@ BASE_DIR
Base directory for all subdirectories.
@ SAVE_DIR
Base directory for all savegames.
@ AUTOSAVE_DIR
Subdirectory of save for autosaves.
LoadCheckData _load_check_data
Data loaded from save during SL_LOAD_CHECK.
fluid_settings_t * settings
FluidSynth settings handle.
Gamelog _gamelog
Gamelog instance.
void SetMouseCursorBusy(bool busy)
Set or unset the ZZZ cursor.
GameSessionStats _game_session_stats
Statistics about the current session.
constexpr T Clamp(const T a, const T min, const T max)
Clamp a value between an interval.
void ClearGRFConfigList(GRFConfig **config)
Clear a GRF Config list, freeing all nodes.
GRFConfig * _grfconfig
First item in list of current GRF set up.
GRFListCompatibility IsGoodGRFConfigList(GRFConfig *grfconfig)
Check if all GRFs in the GRF config from a savegame can be loaded.
static const uint LZO_BUFFER_SIZE
Buffer size for the LZO compressor.
void SlError(StringID string, const std::string &extra_msg)
Error handler.
static uint8_t GetSavegameFileType(const SaveLoad &sld)
Return the type as saved/loaded inside the savegame.
static SaveOrLoadResult DoSave(std::shared_ptr< SaveFilter > writer, bool threaded)
Actually perform the saving of the savegame.
static std::pair< const SaveLoadFormat &, uint8_t > GetSavegameFormat(const std::string &full_name)
Return the savegameformat of the game.
void ProcessAsyncSaveFinish()
Handle async save finishes.
static const lzma_stream _lzma_init
Have a copy of an initialised LZMA stream.
uint32_t _ttdp_version
version of TTDP savegame (if applicable)
static const SaveLoadFormat _saveload_formats[]
The different saveload formats known/understood by OpenTTD.
std::string _savegame_format
how to compress savegames
static const SaveLoadFormat * DetermineSaveLoadFormat(uint32_t tag, uint32_t raw_version)
Determines the SaveLoadFormat that is connected to the given tag.
static void SaveFileDone()
Update the gui accordingly when saving is done and release locks on saveload.
StringID GetSaveLoadErrorMessage()
Return the description of the error.
SaveLoadVersion _sl_version
the major savegame version identifier
uint8_t _sl_minor_version
the minor savegame version, DO NOT USE!
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...
SaveOrLoadResult LoadWithFilter(std::shared_ptr< LoadFilter > reader)
Load the game using a (reader) filter.
static SaveOrLoadResult SaveFileToDisk(bool threaded)
We have written the whole game into memory, _memory_savegame, now find and appropriate compressor and...
static void ResetSaveloadData()
Clear temporary data that is passed between various saveload phases.
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,...
SaveOrLoadResult SaveWithFilter(std::shared_ptr< SaveFilter > writer, bool threaded)
Save the game using a (writer) filter.
static void SlWriteSimpleGamma(size_t i)
Write the header descriptor of an object or an array.
static size_t SlCalcTableHeader(const SaveLoadTable &slt)
Calculate the size of the table header.
static void ClearSaveLoadState()
Clear/free saveload state.
bool _do_autosave
are we doing an autosave at the moment?
StringID GetSaveLoadErrorType()
Return the appropriate initial string for an error depending on whether we are saving or loading.
static std::atomic< AsyncSaveFinishProc > _async_save_finish
Callback to call when the savegame loading is finished.
static std::thread _save_thread
The thread we're using to compress and write a savegame.
static uint SlCalcConvMemLen(VarType conv)
Return the size in bytes of a certain type of normal/atomic variable as it appears in memory.
void SlWriteByte(uint8_t b)
Wrapper for writing a byte to the dumper.
size_t SlGetStructListLength(size_t limit)
Get the length of this list; if it exceeds the limit, error out.
SaveLoadAction
What are we currently doing?
@ SLA_NULL
null all pointers (on loading error)
@ SLA_LOAD_CHECK
partial loading into _load_check_data
@ SLA_PTRS
fixing pointers
static size_t SlCalcArrayLen(size_t length, VarType conv)
Return the size in bytes of a certain type of atomic array.
void WriteValue(void *ptr, VarType conv, int64_t val)
Write the value of a setting.
void(* AsyncSaveFinishProc)()
Callback for when the savegame loading is finished.
int SlIterateArray()
Iterate through the elements of an array and read the whole thing.
static const ChunkHandler * SlFindChunkHandler(uint32_t id)
Find the ChunkHandler that will be used for processing the found chunk in the savegame or in memory.
SaveOrLoadResult SaveOrLoad(const std::string &filename, SaveLoadOperation fop, DetailedFileType dft, Subdirectory sb, bool threaded)
Main Save or Load function where the high-level saveload functions are handled.
static void SetAsyncSaveFinish(AsyncSaveFinishProc proc)
Called by save thread to tell we finished saving.
void SetSaveLoadError(StringID str)
Set the error message from outside of the actual loading/saving of the game (AfterLoadGame and friend...
void SlCopy(void *object, size_t length, VarType conv)
Copy a list of SL_VARs to/from a savegame.
size_t SlGetFieldLength()
Get the length of the current object.
void DoAutoOrNetsave(FiosNumberedSaveName &counter)
Create an autosave or netsave.
static size_t SlCalcRefLen()
Return the size in bytes of a reference (pointer)
static void SaveFileStart()
Update the gui accordingly when starting saving and set locks on saveload.
static void SlNullPointers()
Null all pointers (convert index -> nullptr)
static void SlStdString(void *ptr, VarType conv)
Save/Load a std::string.
static SaveOrLoadResult DoLoad(std::shared_ptr< LoadFilter > reader, bool load_check)
Actually perform the loading of a "non-old" savegame.
static size_t SlCalcRefListLen(const void *list, VarType conv)
Return the size in bytes of a list.
static bool SlIsObjectValidInSavegame(const SaveLoad &sld)
Are we going to save this object or not?
void SlSaveLoadRef(void *ptr, VarType conv)
Handle conversion for references.
static void SlFixPointers()
Fix all pointers (convert index -> pointer)
void SlErrorCorrupt(const std::string &msg)
Error handler for corrupt savegames.
void SlSkipArray()
Skip an array or sparse array.
static void SlLoadChunk(const ChunkHandler &ch)
Load a chunk of data (eg vehicles, stations, etc.)
static void SlLoadCheckChunks()
Load all chunks for savegame checking.
std::vector< SaveLoad > SlCompatTableHeader(const SaveLoadTable &slt, const SaveLoadCompatTable &slct)
Load a table header in a savegame compatible way.
static size_t SlCalcStdStringLen(const void *ptr)
Calculate the gross length of the string that it will occupy in the savegame.
static uint SlReadSimpleGamma()
Read in the header descriptor of an object or an array.
std::vector< SaveLoad > SlTableHeader(const SaveLoadTable &slt)
Save or Load a table header.
static void SlCopyBytes(void *ptr, size_t length)
Save/Load bytes.
@ NL_WANTLENGTH
writing length and data
@ NL_NONE
not working in NeedLength mode
@ NL_CALCLENGTH
need to calculate the length
static void SlCopyInternal(void *object, size_t length, VarType conv)
Internal function to save/Load a list of SL_VARs.
static void SlArray(void *array, size_t length, VarType conv)
Save/Load the length of the array followed by the array of SL_VAR elements.
SavegameType _savegame_type
type of savegame we are loading
static void SlSaveLoadConv(void *ptr, VarType conv)
Handle all conversion and typechecking of variables here.
FileToSaveLoad _file_to_saveload
File to save or load in the openttd loop.
static void SlLoadCheckChunk(const ChunkHandler &ch)
Load a chunk of data for checking savegames.
void SlSetLength(size_t length)
Sets the length of either a RIFF object or the number of items in an array.
uint8_t SlReadByte()
Wrapper for reading a byte from the buffer.
static SaveLoadParams _sl
Parameters used for/at saveload.
void DoExitSave()
Do a save when exiting the game (_settings_client.gui.autosave_on_exit)
static void SlLoadChunks()
Load all chunks.
static void SlDeque(void *deque, VarType conv)
Save/load a std::deque.
static uint8_t SlCalcConvFileLen(VarType conv)
Return the size in bytes of a certain type of normal/atomic variable as it appears in a saved game.
static void SlSaveChunk(const ChunkHandler &ch)
Save a chunk of data (eg.
const SaveLoadVersion SAVEGAME_VERSION
Current savegame version of OpenTTD.
size_t SlCalcObjLength(const void *object, const SaveLoadTable &slt)
Calculate the size of an object.
void SlObject(void *object, const SaveLoadTable &slt)
Main SaveLoad function.
static const std::vector< ChunkHandlerRef > & ChunkHandlers()
bool AfterLoadGame()
Perform a (large) amount of savegame conversion magic in order to load older savegames and to fill th...
int64_t ReadValue(const void *ptr, VarType conv)
Return a signed-long version of the value of a setting.
static void SlVector(void *vector, VarType conv)
Save/load a std::vector.
static void SaveFileError()
Show a gui message when saving has failed.
void SlGlobList(const SaveLoadTable &slt)
Save or Load (a list of) global variables.
static void SlSaveChunks()
Save all chunks.
std::string GenerateDefaultSaveName()
Get the default name for a savegame or screenshot.
static const size_t MEMORY_CHUNK_SIZE
Save in chunks of 128 KiB.
void SlAutolength(AutolengthProc *proc, int arg)
Do something of which I have no idea what it is :P.
static void FixSCCEncoded(std::string &str)
Scan the string for old values of SCC_ENCODED and fix it to it's new, value.
void SlSetStructListLength(size_t length)
Set the length of this list.
static uint SlGetGammaLength(size_t i)
Return how many bytes used to encode a gamma value.
static size_t SlCalcVectorLen(const void *vector, VarType conv)
Return the size in bytes of a std::vector.
static void SlRefList(void *list, VarType conv)
Save/Load a list.
static size_t SlCalcDequeLen(const void *deque, VarType conv)
Return the size in bytes of a std::deque.
@ SLE_VAR_NULL
useful to write zeros in savegame.
@ SLE_FILE_END
Used to mark end-of-header in tables.
@ SLE_FILE_TYPE_MASK
Mask to get the file-type (and not any flags).
@ SLE_FILE_HAS_LENGTH_FIELD
Bit stored in savegame to indicate field has a length field for each entry.
@ SLF_ALLOW_NEWLINE
Allow new lines in the strings.
@ SLF_ALLOW_CONTROL
Allow control codes in the strings.
@ SLE_VAR_STR
string pointer
@ SLE_VAR_NAME
old custom name to be converted to a char pointer
@ SLE_VAR_STRQ
string pointer enclosed in quotes
@ SLE_FILE_STRINGID
StringID offset into strings-array.
void * GetVariableAddress(const void *object, const SaveLoad &sld)
Get the address of the variable.
SaveOrLoadResult
Save or load result codes.
@ SL_ERROR
error that was caught before internal structures were modified
@ SL_OK
completed successfully
@ SL_REINIT
error that was caught in the middle of updating game state, need to clear it. (can only happen during...
@ CH_TYPE_MASK
All ChunkType values have to be within this mask.
@ CH_READONLY
Chunk is never saved.
void SlSkipBytes(size_t length)
Read in bytes from the file/data structure but don't do anything with them, discarding them in effect...
SavegameType
Types of save games.
constexpr VarType GetVarFileType(VarType type)
Get the FileType of a setting.
std::span< const ChunkHandlerRef > ChunkHandlerTable
A table of ChunkHandler entries.
SaveLoadType
Type of data saved.
@ SL_NULL
Save null-bytes and load to nowhere.
@ SL_STRUCTLIST
Save/load a list of structs.
@ SL_STDSTR
Save/load a std::string.
@ SL_REF
Save/load a reference.
@ SL_SAVEBYTE
Save (but not load) a byte.
@ SL_DEQUE
Save/load a deque of SL_VAR elements.
@ SL_STRUCT
Save/load a struct.
@ SL_VECTOR
Save/load a vector of SL_VAR elements.
@ SL_REFLIST
Save/load a list of SL_REF elements.
@ SL_ARR
Save/load a fixed-size array of SL_VAR elements.
@ SL_VAR
Save/load a variable.
std::span< const struct SaveLoadCompat > SaveLoadCompatTable
A table of SaveLoadCompat entries.
bool IsSavegameVersionBefore(SaveLoadVersion major, uint8_t minor=0)
Checks whether the savegame is below major.
constexpr VarType GetVarMemType(VarType type)
Get the NumberType of a setting.
SaveLoadVersion
SaveLoad versions Previous savegame versions, the trunk revision where they were introduced and the r...
@ SLV_4
4.0 1 4.1 122 0.3.3, 0.3.4 4.2 1222 0.3.5 4.3 1417 4.4 1426
@ SLV_SAVELOAD_LIST_LENGTH
293 PR#9374 Consistency in list length with SL_STRUCT / SL_STRUCTLIST / SL_DEQUE / SL_REFLIST.
@ SLV_START_PATCHPACKS
220 First known patchpack to use a version just above ours.
@ SL_MAX_VERSION
Highest possible saveload version.
@ SL_MIN_VERSION
First savegame version.
@ SLV_END_PATCHPACKS
286 Last known patchpack to use a version just above ours.
@ SLV_5
5.0 1429 5.1 1440 5.2 1525 0.3.6
SLRefType
Type of reference (SLE_REF, SLE_CONDREF).
@ REF_VEHICLE_OLD
Load/save an old-style reference to a vehicle (for pre-4.4 savegames).
@ REF_LINK_GRAPH_JOB
Load/save a reference to a link graph job.
@ REF_TOWN
Load/save a reference to a town.
@ REF_LINK_GRAPH
Load/save a reference to a link graph.
@ REF_CARGO_PACKET
Load/save a reference to a cargo packet.
@ REF_ENGINE_RENEWS
Load/save a reference to an engine renewal (autoreplace).
@ REF_STATION
Load/save a reference to a station.
@ REF_ORDER
Load/save a reference to an order.
@ REF_ORDERLIST
Load/save a reference to an orderlist.
@ REF_STORAGE
Load/save a reference to a persistent storage.
@ REF_VEHICLE
Load/save a reference to a vehicle.
@ REF_ROADSTOPS
Load/save a reference to a bus/truck stop.
std::span< const struct SaveLoad > SaveLoadTable
A table of SaveLoad entries.
Declaration of filters used for saving and loading savegames.
Declaration of functions used in more save/load files.
StringID RemapOldStringID(StringID s)
Remap a string ID from the old format to the new format.
std::string CopyFromOldName(StringID id)
Copy and convert old custom names to UTF-8.
ClientSettings _settings_client
The current settings for this game.
@ SBI_SAVELOAD_FINISH
finished saving
@ SBI_SAVELOAD_START
started saving
#define lengthof(array)
Return the length of an fixed size array.
static void StrMakeValid(T &dst, const char *str, const char *last, StringValidationSettings settings)
Copies the valid (UTF-8) characters from str up to last to the dst.
size_t Utf8Decode(char32_t *c, const char *s)
Decode and consume the next UTF-8 encoded character.
size_t Utf8Encode(T buf, char32_t c)
Encode a unicode character and place it in the buffer.
int8_t Utf8EncodedCharLen(char c)
Return the length of an UTF-8 encoded value based on a single char.
StringValidationSettings
Settings for the string validation.
@ SVS_ALLOW_CONTROL_CODE
Allow the special control codes.
@ SVS_ALLOW_NEWLINE
Allow newlines; replaces '\r ' with ' ' during processing.
@ SVS_REPLACE_WITH_QUESTION_MARK
Replace the unknown/bad bits with question marks.
void SetDParam(size_t n, uint64_t v)
Set a string parameter v at index n in the global string parameter array.
std::string GetString(StringID string)
Resolve the given StringID into a std::string with all the associated DParam lookups and formatting.
void SetDParamStr(size_t n, const char *str)
This function is used to "bind" a C string to a OpenTTD dparam slot.
uint32_t StringID
Numeric value that represents a string, independent of the selected language.
static const StringID INVALID_STRING_ID
Constant representing an invalid string (16bit in case it is used in savegames)
Container for cargo from the same location and time.
Handlers and description of chunk.
ChunkType type
Type of the chunk.
virtual void LoadCheck(size_t len=0) const
Load the chunk for game preview.
virtual void Load() const =0
Load the chunk.
uint32_t id
Unique ID (4 letters).
virtual void Save() const
Save the chunk.
GUISettings gui
settings related to the GUI
Struct to store engine replacements.
Yes, simply reading from a file.
~FileReader()
Make sure everything is cleaned up.
size_t Read(uint8_t *buf, size_t size) override
Read a given number of bytes from the savegame.
void Reset() override
Reset this filter to read from the beginning of the file.
FileReader(FileHandle &&file)
Create the file reader, so it reads from a specific file.
long begin
The begin of the file.
std::optional< FileHandle > file
The file to read from.
Deals with the type of the savegame, independent of extension.
AbstractFileType abstract_ftype
Abstract type of file (scenario, heightmap, etc).
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...
DetailedFileType detail_ftype
Concrete file type (PNG, BMP, old save, etc).
std::string title
Internal name of the game.
SaveLoadOperation file_op
File operation to perform.
std::string name
Name of the file.
void Set(const FiosItem &item)
Set the title of the file.
Yes, simply writing to a file.
std::optional< FileHandle > file
The file to write to.
FileWriter(FileHandle &&file)
Create the file writer, so it writes to a specific file.
void Finish() override
Prepare everything to finish writing the savegame.
~FileWriter()
Make sure everything is cleaned up.
void Write(uint8_t *buf, size_t size) override
Write a given number of bytes into the savegame.
Deals with finding savegames.
A savegame name automatically numbered.
std::string Filename()
Generate a savegame name and number according to _settings_client.gui.max_num_autosaves.
std::string Extension()
Generate an extension for a savegame name.
bool keep_all_autosave
name the autosave in a different way
uint8_t date_format_in_default_names
should the default savegame/screenshot name use long dates (31th Dec 2008), short dates (31-12-2008) ...
bool threaded_saves
should we do threaded saves?
std::optional< size_t > savegame_size
Size of the last saved savegame in bytes, or std::nullopt if not saved yet.
Filter without any compression.
~LZMALoadFilter()
Clean everything up.
lzma_stream lzma
Stream state that we are reading from.
size_t Read(uint8_t *buf, size_t size) override
Read a given number of bytes from the savegame.
uint8_t fread_buf[MEMORY_CHUNK_SIZE]
Buffer for reading from the file.
LZMALoadFilter(std::shared_ptr< LoadFilter > chain)
Initialise this filter.
Filter using LZMA compression.
void Write(uint8_t *buf, size_t size) override
Write a given number of bytes into the savegame.
void Finish() override
Prepare everything to finish writing the savegame.
void WriteLoop(uint8_t *p, size_t len, lzma_action action)
Helper loop for writing the data.
LZMASaveFilter(std::shared_ptr< SaveFilter > chain, uint8_t compression_level)
Initialise this filter.
lzma_stream lzma
Stream state that we are writing to.
uint8_t fwrite_buf[MEMORY_CHUNK_SIZE]
Buffer for writing to the file.
~LZMASaveFilter()
Clean up what we allocated.
Filter using LZO compression.
LZOLoadFilter(std::shared_ptr< LoadFilter > chain)
Initialise this filter.
size_t Read(uint8_t *buf, size_t ssize) override
Read a given number of bytes from the savegame.
Filter using LZO compression.
void Write(uint8_t *buf, size_t size) override
Write a given number of bytes into the savegame.
LZOSaveFilter(std::shared_ptr< SaveFilter > chain, uint8_t)
Initialise this filter.
bool checkable
True if the savegame could be checked by SL_LOAD_CHECK. (Old savegames are not checkable....
std::string error_msg
Data to pass to SetDParamStr when displaying error.
StringID error
Error message from loading. INVALID_STRING_ID if no error.
GRFConfig * grfconfig
NewGrf configuration from save.
void Clear()
Reset read data.
GRFListCompatibility grf_compatibility
Summary state of NewGrfs, whether missing files or only compatible found.
Interface for filtering a savegame till it is loaded.
std::shared_ptr< LoadFilter > chain
Chained to the (savegame) filters.
Container for dumping the savegame (quickly) to memory.
uint8_t * buf
Buffer we're going to write to.
void WriteByte(uint8_t b)
Write a single byte into the dumper.
std::vector< std::unique_ptr< uint8_t[]> > blocks
Buffer with blocks of allocated memory.
uint8_t * bufe
End of the buffer we write to.
size_t GetSize() const
Get the size of the memory dump made so far.
void Flush(std::shared_ptr< SaveFilter > writer)
Flush this dumper into a writer.
Filter without any compression.
NoCompLoadFilter(std::shared_ptr< LoadFilter > chain)
Initialise this filter.
size_t Read(uint8_t *buf, size_t size) override
Read a given number of bytes from the savegame.
Filter without any compression.
NoCompSaveFilter(std::shared_ptr< SaveFilter > chain, uint8_t)
Initialise this filter.
void Write(uint8_t *buf, size_t size) override
Write a given number of bytes into the savegame.
Shared order list linking together the linked list of orders and the list of vehicles sharing this or...
Class for pooled persistent storage of data.
static Titem * Get(size_t index)
Returns Titem with given index.
static bool IsValidID(size_t index)
Tests whether given index can be used to get valid (non-nullptr) Titem.
static Pool::IterateWrapper< Titem > Iterate(size_t from=0)
Returns an iterable ensemble of all valid Titem.
A buffer for reading (and buffering) savegame data.
uint8_t * bufp
Location we're at reading the buffer.
ReadBuffer(std::shared_ptr< LoadFilter > reader)
Initialise our variables.
size_t read
The amount of read bytes so far from the filter.
size_t GetSize() const
Get the size of the memory dump made so far.
std::shared_ptr< LoadFilter > reader
The filter used to actually read.
uint8_t buf[MEMORY_CHUNK_SIZE]
Buffer we're going to read from.
uint8_t * bufe
End of the buffer we can read from.
A Stop for a Road Vehicle.
Interface for filtering a savegame till it is written.
std::shared_ptr< SaveFilter > chain
Chained to the (savegame) filters.
The saveload struct, containing reader-writer functions, buffer, version, etc.
std::unique_ptr< ReadBuffer > reader
Savegame reading buffer.
std::shared_ptr< SaveFilter > sf
Filter to write the savegame to.
std::unique_ptr< MemoryDumper > dumper
Memory dumper to write the savegame to.
StringID error_str
the translatable error message to show
SaveLoadAction action
are we doing a save or a load atm.
std::string extra_msg
the error message
NeedLength need_length
working in NeedLength (Autolength) mode?
bool saveinprogress
Whether there is currently a save in progress.
std::shared_ptr< LoadFilter > lf
Filter to read the savegame from.
bool expect_table_header
In the case of a table, if the header is saved/loaded.
size_t obj_len
the length of the current object we are busy with
bool error
did an error occur or not
int last_array_index
in the case of an array, the current and last positions
uint16_t length
(Conditional) length of the variable (eg. arrays) (max array size is 65536 elements).
std::shared_ptr< SaveLoadHandler > handler
Custom handler for Save/Load procs.
SaveLoadVersion version_to
Save/load the variable before this savegame version.
SaveLoadType cmd
The action to take with the saved/loaded type, All types need different action.
std::string name
Name of this field (optional, used for tables).
VarType conv
Type of the variable to be saved; this field combines both FileVarType and MemVarType.
SaveLoadVersion version_from
Save/load the variable starting from this savegame version.
static Station * Get(size_t index)
Gets station with given index.
static bool IsValidID(size_t index)
Tests whether given index is a valid index for station of this type.
Filter using Zlib compression.
size_t Read(uint8_t *buf, size_t size) override
Read a given number of bytes from the savegame.
ZlibLoadFilter(std::shared_ptr< LoadFilter > chain)
Initialise this filter.
uint8_t fread_buf[MEMORY_CHUNK_SIZE]
Buffer for reading from the file.
~ZlibLoadFilter()
Clean everything up.
z_stream z
Stream state we are reading from.
Filter using Zlib compression.
void WriteLoop(uint8_t *p, size_t len, int mode)
Helper loop for writing the data.
z_stream z
Stream state we are writing to.
uint8_t fwrite_buf[MEMORY_CHUNK_SIZE]
Buffer for writing to the file.
void Finish() override
Prepare everything to finish writing the savegame.
~ZlibSaveFilter()
Clean up what we allocated.
ZlibSaveFilter(std::shared_ptr< SaveFilter > chain, uint8_t compression_level)
Initialise this filter.
void Write(uint8_t *buf, size_t size) override
Write a given number of bytes into the savegame.
void CSleep(int milliseconds)
Sleep on the current thread for a defined time.
bool StartNewThread(std::thread *thr, const char *name, TFn &&_Fx, TArgs &&... _Ax)
Start a new thread.
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-...
@ WC_STATUS_BAR
Statusbar (at the bottom of your screen); Window numbers: