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()
325 return *this->
bufp++;
448 extern const ChunkHandler _autoreplace_chunk_handlers[];
453 extern const ChunkHandler _persistent_storage_chunk_handlers[];
457 _gamelog_chunk_handlers,
459 _misc_chunk_handlers,
460 _name_chunk_handlers,
461 _cheat_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,
470 _cargomonitor_chunk_handlers,
471 _goal_chunk_handlers,
472 _story_page_chunk_handlers,
473 _engine_chunk_handlers,
474 _town_chunk_handlers,
475 _sign_chunk_handlers,
476 _station_chunk_handlers,
477 _company_chunk_handlers,
479 _game_chunk_handlers,
480 _animated_tile_chunk_handlers,
481 _newgrf_chunk_handlers,
482 _group_chunk_handlers,
483 _cargopacket_chunk_handlers,
484 _autoreplace_chunk_handlers,
485 _labelmaps_chunk_handlers,
486 _linkgraph_chunk_handlers,
487 _airport_chunk_handlers,
488 _object_chunk_handlers,
489 _persistent_storage_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;
578 while (_async_save_finish != NULL) CSleep(10);
580 _async_save_finish = proc;
588 if (_async_save_finish == NULL)
return;
592 _async_save_finish = NULL;
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) {
1795 _stub_save_proc = proc;
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);
1916 size_t Read(byte *buf,
size_t size)
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");
1990 size_t Read(byte *buf,
size_t ssize)
1992 assert(ssize >= LZO_BUFFER_SIZE);
1995 byte out[LZO_BUFFER_SIZE + LZO_BUFFER_SIZE / 16 + 64 + 3 +
sizeof(uint32) * 2];
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;
2042 byte out[LZO_BUFFER_SIZE + LZO_BUFFER_SIZE / 16 + 64 + 3 +
sizeof(uint32) * 2];
2043 byte wrkmem[LZO1X_1_MEM_COMPRESS];
2048 lzo_uint len = size > LZO_BUFFER_SIZE ? LZO_BUFFER_SIZE : (lzo_uint)size;
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);
2077 size_t Read(byte *buf,
size_t 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);
2128 size_t Read(byte *buf,
size_t size)
2130 this->
z.next_out = buf;
2131 this->
z.avail_out = (uint)size;
2135 if (this->
z.avail_in == 0) {
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) {
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);
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);
2257 size_t Read(byte *buf,
size_t size)
2259 this->
lzma.next_out = buf;
2260 this->
lzma.avail_out = size;
2264 if (this->
lzma.avail_in == 0) {
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) {
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);
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);
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) {