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"
312 inline byte ReadByte()
323 return *this->
bufp++;
446 extern const ChunkHandler _autoreplace_chunk_handlers[];
451 extern const ChunkHandler _persistent_storage_chunk_handlers[];
455 _gamelog_chunk_handlers,
457 _misc_chunk_handlers,
458 _name_chunk_handlers,
459 _cheat_chunk_handlers,
460 _setting_chunk_handlers,
462 _waypoint_chunk_handlers,
463 _depot_chunk_handlers,
464 _order_chunk_handlers,
465 _industry_chunk_handlers,
466 _economy_chunk_handlers,
467 _subsidy_chunk_handlers,
468 _cargomonitor_chunk_handlers,
469 _goal_chunk_handlers,
470 _story_page_chunk_handlers,
471 _engine_chunk_handlers,
472 _town_chunk_handlers,
473 _sign_chunk_handlers,
474 _station_chunk_handlers,
475 _company_chunk_handlers,
477 _game_chunk_handlers,
478 _animated_tile_chunk_handlers,
479 _newgrf_chunk_handlers,
480 _group_chunk_handlers,
481 _cargopacket_chunk_handlers,
482 _autoreplace_chunk_handlers,
483 _labelmaps_chunk_handlers,
484 _linkgraph_chunk_handlers,
485 _airport_chunk_handlers,
486 _object_chunk_handlers,
487 _persistent_storage_chunk_handlers,
495 #define FOR_ALL_CHUNK_HANDLERS(ch) \
496 for (const ChunkHandler * const *chsc = _chunk_handlers; *chsc != NULL; chsc++) \
497 for (const ChunkHandler *ch = *chsc; ch != NULL; ch = (ch->flags & CH_LAST) ? NULL : ch + 1)
509 DEBUG(sl, 1,
"Nulling pointers");
512 if (ch->ptrs_proc != NULL) {
513 DEBUG(sl, 2,
"Nulling pointers for %c%c%c%c", ch->id >> 24, ch->id >> 16, ch->id >> 8, ch->id);
518 DEBUG(sl, 1,
"All pointers nulled");
549 throw std::exception();
561 SlError(STR_GAME_SAVELOAD_ERROR_BROKEN_SAVEGAME, msg);
575 if (_exit_game)
return;
576 while (_async_save_finish != NULL) CSleep(10);
578 _async_save_finish = proc;
586 if (_async_save_finish == NULL)
return;
590 _async_save_finish = NULL;
592 if (_save_thread != NULL) {
593 _save_thread->
Join();
605 return _sl.
reader->ReadByte();
617 static inline int SlReadUint16()
623 static inline uint32 SlReadUint32()
625 uint32 x = SlReadUint16() << 16;
626 return x | SlReadUint16();
629 static inline uint64 SlReadUint64()
631 uint32 x = SlReadUint32();
632 uint32 y = SlReadUint32();
633 return (uint64)x << 32 | y;
636 static inline void SlWriteUint16(uint16 v)
642 static inline void SlWriteUint32(uint32 v)
644 SlWriteUint16(
GB(v, 16, 16));
645 SlWriteUint16(
GB(v, 0, 16));
648 static inline void SlWriteUint64(uint64 x)
650 SlWriteUint32((uint32)(x >> 32));
651 SlWriteUint32((uint32)x);
718 if (i >= (1 << 14)) {
719 if (i >= (1 << 21)) {
720 if (i >= (1 << 28)) {
721 assert(i <= UINT32_MAX);
742 return 1 + (i >= (1 << 7)) + (i >= (1 << 14)) + (i >= (1 << 21)) + (i >= (1 << 28));
745 static inline uint SlReadSparseIndex()
750 static inline void SlWriteSparseIndex(uint index)
755 static inline uint SlReadArrayLength()
760 static inline void SlWriteArrayLength(
size_t length)
765 static inline uint SlGetArrayLength(
size_t length)
778 static const byte conv_mem_size[] = {1, 1, 1, 2, 2, 4, 4, 8, 8, 0};
779 byte length =
GB(conv, 4, 4);
781 switch (length << 4) {
786 return SlReadArrayLength();
789 assert(length <
lengthof(conv_mem_size));
790 return conv_mem_size[length];
802 static const byte conv_file_size[] = {1, 1, 2, 2, 4, 4, 8, 8, 2};
803 byte length =
GB(conv, 0, 4);
804 assert(length <
lengthof(conv_file_size));
805 return conv_file_size[length];
814 void SlSetArrayIndex(uint index)
817 _sl.array_index = index;
820 static size_t _next_offs;
835 uint length = SlReadArrayLength();
845 case CH_SPARSE_ARRAY: index = (int)SlReadSparseIndex();
break;
846 case CH_ARRAY: index = _sl.array_index++;
break;
848 DEBUG(sl, 0,
"SlIterateArray error");
852 if (length != 0)
return index;
883 assert(length < (1 << 28));
884 SlWriteUint32((uint32)((length & 0xFFFFFF) | ((length >> 24) << 28)));
889 SlWriteArrayLength(1);
891 SlWriteArrayLength(length + 1);
893 case CH_SPARSE_ARRAY:
894 SlWriteArrayLength(length + 1 + SlGetArrayLength(_sl.array_index));
895 SlWriteSparseIndex(_sl.array_index);
897 default: NOT_REACHED();
905 default: NOT_REACHED();
917 byte *p = (byte *)ptr;
922 for (; length != 0; length--) *p++ =
SlReadByte();
927 default: NOT_REACHED();
947 case SLE_VAR_BL:
return (*(
const bool *)ptr != 0);
948 case SLE_VAR_I8:
return *(
const int8 *)ptr;
949 case SLE_VAR_U8:
return *(
const byte *)ptr;
950 case SLE_VAR_I16:
return *(
const int16 *)ptr;
951 case SLE_VAR_U16:
return *(
const uint16*)ptr;
952 case SLE_VAR_I32:
return *(
const int32 *)ptr;
953 case SLE_VAR_U32:
return *(
const uint32*)ptr;
954 case SLE_VAR_I64:
return *(
const int64 *)ptr;
955 case SLE_VAR_U64:
return *(
const uint64*)ptr;
957 default: NOT_REACHED();
971 case SLE_VAR_BL: *(
bool *)ptr = (val != 0);
break;
972 case SLE_VAR_I8: *(int8 *)ptr = val;
break;
973 case SLE_VAR_U8: *(byte *)ptr = val;
break;
974 case SLE_VAR_I16: *(int16 *)ptr = val;
break;
975 case SLE_VAR_U16: *(uint16*)ptr = val;
break;
976 case SLE_VAR_I32: *(int32 *)ptr = val;
break;
977 case SLE_VAR_U32: *(uint32*)ptr = val;
break;
978 case SLE_VAR_I64: *(int64 *)ptr = val;
break;
979 case SLE_VAR_U64: *(uint64*)ptr = val;
break;
982 default: NOT_REACHED();
1002 case SLE_FILE_I8: assert(x >= -128 && x <= 127);
SlWriteByte(x);
break;
1003 case SLE_FILE_U8: assert(x >= 0 && x <= 255);
SlWriteByte(x);
break;
1004 case SLE_FILE_I16:assert(x >= -32768 && x <= 32767); SlWriteUint16(x);
break;
1006 case SLE_FILE_U16:assert(x >= 0 && x <= 65535); SlWriteUint16(x);
break;
1008 case SLE_FILE_U32: SlWriteUint32((uint32)x);
break;
1010 case SLE_FILE_U64: SlWriteUint64(x);
break;
1011 default: NOT_REACHED();
1020 case SLE_FILE_I8: x = (int8 )
SlReadByte();
break;
1021 case SLE_FILE_U8: x = (byte )
SlReadByte();
break;
1022 case SLE_FILE_I16: x = (int16 )SlReadUint16();
break;
1023 case SLE_FILE_U16: x = (uint16)SlReadUint16();
break;
1024 case SLE_FILE_I32: x = (int32 )SlReadUint32();
break;
1025 case SLE_FILE_U32: x = (uint32)SlReadUint32();
break;
1026 case SLE_FILE_I64: x = (int64 )SlReadUint64();
break;
1027 case SLE_FILE_U64: x = (uint64)SlReadUint64();
break;
1029 default: NOT_REACHED();
1038 default: NOT_REACHED();
1053 if (ptr == NULL)
return 0;
1054 return min(strlen(ptr), length - 1);
1072 default: NOT_REACHED();
1075 str = *(
const char *
const *)ptr;
1080 str = (
const char *)ptr;
1086 return len + SlGetArrayLength(len);
1095 static void SlString(
void *ptr,
size_t length, VarType conv)
1101 default: NOT_REACHED();
1108 ptr = *(
char **)ptr;
1113 SlWriteArrayLength(len);
1119 size_t len = SlReadArrayLength();
1122 default: NOT_REACHED();
1125 if (len >= length) {
1126 DEBUG(sl, 1,
"String length in savegame is bigger than buffer, truncating");
1136 free(*(
char **)ptr);
1138 *(
char **)ptr = NULL;
1141 *(
char **)ptr = MallocT<char>(len + 1);
1142 ptr = *(
char **)ptr;
1148 ((
char *)ptr)[len] =
'\0';
1159 str_validate((
char *)ptr, (
char *)ptr + len, settings);
1164 default: NOT_REACHED();
1184 void SlArray(
void *array,
size_t length, VarType conv)
1199 if (conv == SLE_INT16 || conv == SLE_UINT16 || conv == SLE_STRINGID ||
1200 conv == SLE_INT32 || conv == SLE_UINT32) {
1205 if (conv == (SLE_FILE_I32 | SLE_VAR_I64)) {
1206 for (uint i = 0; i < length; i++) {
1207 ((int64*)array)[i] = (int32)
BSWAP32(SlReadUint32());
1215 if (conv == SLE_INT8 || conv == SLE_UINT8) {
1218 byte *a = (byte*)array;
1221 for (; length != 0; length --) {
1243 if (obj == NULL)
return 0;
1258 default: NOT_REACHED();
1274 assert_compile(
sizeof(
size_t) <=
sizeof(
void *));
1339 default: NOT_REACHED();
1349 const std::list<void *> *l = (
const std::list<void *> *) list;
1354 return l->size() * type_size + type_size;
1372 typedef std::list<void *> PtrList;
1373 PtrList *l = (PtrList *)list;
1377 SlWriteUint32((uint32)l->size());
1379 PtrList::iterator iter;
1380 for (iter = l->begin(); iter != l->end(); ++iter) {
1391 for (
size_t i = 0; i < length; i++) {
1393 l->push_back((
void *)data);
1401 PtrList::iterator iter;
1402 for (iter = temp.begin(); iter != temp.end(); ++iter) {
1411 default: NOT_REACHED();
1451 for (; sld->
cmd != SL_END; sld++) {
1452 length += SlCalcObjMemberLength(
object, sld);
1457 size_t SlCalcObjMemberLength(
const void *
object,
const SaveLoad *sld)
1476 default: NOT_REACHED();
1479 case SL_WRITEBYTE:
return 1;
1482 default: NOT_REACHED();
1498 return sld->
size ==
sizeof(bool);
1501 return sld->
size ==
sizeof(int8);
1504 return sld->
size ==
sizeof(int16);
1507 return sld->
size ==
sizeof(int32);
1510 return sld->
size ==
sizeof(int64);
1512 return sld->
size ==
sizeof(
void *);
1516 return sld->
size ==
sizeof(
void *);
1527 bool SlObjectMember(
void *ptr,
const SaveLoad *sld)
1531 VarType conv =
GB(sld->
conv, 0, 8);
1557 *(
void **)ptr = NULL;
1559 default: NOT_REACHED();
1565 default: NOT_REACHED();
1581 default: NOT_REACHED();
1586 case SL_VEH_INCLUDE:
1594 default: NOT_REACHED();
1612 for (; sld->
cmd != SL_END; sld++) {
1614 SlObjectMember(ptr, sld);
1670 _sl.array_index = 0;
1674 case CH_SPARSE_ARRAY:
1679 if ((m & 0xF) == CH_RIFF) {
1681 len = (
SlReadByte() << 16) | ((m >> 4) << 24);
1682 len += SlReadUint16();
1710 _sl.array_index = 0;
1717 case CH_SPARSE_ARRAY:
1725 if ((m & 0xF) == CH_RIFF) {
1727 len = (
SlReadByte() << 16) | ((m >> 4) << 24);
1728 len += SlReadUint16();
1777 ChunkSaveLoadProc *proc = ch->
save_proc;
1780 if (proc == NULL)
return;
1782 SlWriteUint32(ch->
id);
1783 DEBUG(sl, 2,
"Saving chunk %c%c%c%c", ch->
id >> 24, ch->
id >> 16, ch->
id >> 8, ch->
id);
1785 if (ch->
flags & CH_AUTO_LENGTH) {
1787 _stub_save_proc = proc;
1792 switch (ch->
flags & CH_TYPE_MASK) {
1801 SlWriteArrayLength(0);
1803 case CH_SPARSE_ARRAY:
1806 SlWriteArrayLength(0);
1808 default: NOT_REACHED();
1841 for (
id = SlReadUint32();
id != 0;
id = SlReadUint32()) {
1842 DEBUG(sl, 2,
"Loading chunk %c%c%c%c",
id >> 24,
id >> 16,
id >> 8,
id);
1856 for (
id = SlReadUint32();
id != 0;
id = SlReadUint32()) {
1857 DEBUG(sl, 2,
"Loading chunk %c%c%c%c",
id >> 24,
id >> 16,
id >> 8,
id);
1870 DEBUG(sl, 1,
"Fixing pointers");
1873 if (ch->ptrs_proc != NULL) {
1874 DEBUG(sl, 2,
"Fixing pointers for %c%c%c%c", ch->id >> 24, ch->id >> 16, ch->id >> 8, ch->id);
1879 DEBUG(sl, 1,
"All pointers fixed");
1901 if (this->
file != NULL) fclose(this->
file);
1908 size_t Read(byte *buf,
size_t size)
1911 if (this->
file == NULL)
return 0;
1913 return fread(buf, 1, size, this->
file);
1918 clearerr(this->
file);
1919 if (fseek(this->
file, this->
begin, SEEK_SET)) {
1920 DEBUG(sl, 1,
"Could not reset the file reading");
1949 if (this->
file == NULL)
return;
1951 if (fwrite(buf, 1, size, this->
file) != size)
SlError(STR_GAME_SAVELOAD_ERROR_FILE_NOT_WRITEABLE);
1956 if (this->
file != NULL) fclose(this->
file);
1966 #include <lzo/lzo1x.h>
1979 if (lzo_init() != LZO_E_OK)
SlError(STR_GAME_SAVELOAD_ERROR_BROKEN_INTERNAL_ERROR,
"cannot initialize decompressor");
1982 size_t Read(byte *buf,
size_t ssize)
1984 assert(ssize >= LZO_BUFFER_SIZE);
1987 byte out[LZO_BUFFER_SIZE + LZO_BUFFER_SIZE / 16 + 64 + 3 +
sizeof(uint32) * 2];
1993 if (this->
chain->
Read((byte*)tmp,
sizeof(tmp)) !=
sizeof(tmp))
SlError(STR_GAME_SAVELOAD_ERROR_FILE_NOT_READABLE,
"File read failed");
1996 ((uint32*)out)[0] = size = tmp[1];
1999 tmp[0] = TO_BE32(tmp[0]);
2000 size = TO_BE32(size);
2006 if (this->
chain->
Read(out +
sizeof(uint32), size) != size)
SlError(STR_GAME_SAVELOAD_ERROR_FILE_NOT_READABLE);
2009 if (tmp[0] != lzo_adler32(0, out, size +
sizeof(uint32)))
SlErrorCorrupt(
"Bad checksum");
2012 lzo1x_decompress_safe(out +
sizeof(uint32) * 1, size, buf, &len, NULL);
2026 if (lzo_init() != LZO_E_OK)
SlError(STR_GAME_SAVELOAD_ERROR_BROKEN_INTERNAL_ERROR,
"cannot initialize compressor");
2031 const lzo_bytep in = buf;
2033 byte out[LZO_BUFFER_SIZE + LZO_BUFFER_SIZE / 16 + 64 + 3 +
sizeof(uint32) * 2];
2034 byte wrkmem[LZO1X_1_MEM_COMPRESS];
2039 lzo_uint len = size > LZO_BUFFER_SIZE ? LZO_BUFFER_SIZE : (lzo_uint)size;
2040 lzo1x_1_compress(in, len, out +
sizeof(uint32) * 2, &outlen, wrkmem);
2041 ((uint32*)out)[1] = TO_BE32((uint32)outlen);
2042 ((uint32*)out)[0] = TO_BE32(lzo_adler32(0, out +
sizeof(uint32), outlen +
sizeof(uint32)));
2043 this->
chain->
Write(out, outlen +
sizeof(uint32) * 2);
2068 size_t Read(byte *buf,
size_t size)
2095 #if defined(WITH_ZLIB)
2109 memset(&this->
z, 0,
sizeof(this->
z));
2110 if (inflateInit(&this->
z) != Z_OK)
SlError(STR_GAME_SAVELOAD_ERROR_BROKEN_INTERNAL_ERROR,
"cannot initialize decompressor");
2116 inflateEnd(&this->
z);
2119 size_t Read(byte *buf,
size_t size)
2121 this->
z.next_out = buf;
2122 this->
z.avail_out = (uint)size;
2126 if (this->
z.avail_in == 0) {
2128 this->
z.avail_in = (uint)this->
chain->
Read(this->fread_buf,
sizeof(this->fread_buf));
2132 int r = inflate(&this->
z, 0);
2133 if (r == Z_STREAM_END)
break;
2135 if (r != Z_OK)
SlError(STR_GAME_SAVELOAD_ERROR_BROKEN_INTERNAL_ERROR,
"inflate() failed");
2136 }
while (this->
z.avail_out != 0);
2138 return size - this->
z.avail_out;
2153 memset(&this->
z, 0,
sizeof(this->
z));
2154 if (deflateInit(&this->
z, compression_level) != Z_OK)
SlError(STR_GAME_SAVELOAD_ERROR_BROKEN_INTERNAL_ERROR,
"cannot initialize compressor");
2160 deflateEnd(&this->
z);
2173 this->
z.next_in = p;
2174 this->
z.avail_in = (uInt)len;
2176 this->
z.next_out = buf;
2177 this->
z.avail_out =
sizeof(buf);
2186 int r = deflate(&this->
z, mode);
2189 if ((n =
sizeof(buf) - this->
z.avail_out) != 0) {
2192 if (r == Z_STREAM_END)
break;
2194 if (r != Z_OK)
SlError(STR_GAME_SAVELOAD_ERROR_BROKEN_INTERNAL_ERROR,
"zlib returned error code");
2195 }
while (this->
z.avail_in || !this->z.avail_out);
2216 #if defined(WITH_LZMA)
2239 if (lzma_auto_decoder(&this->
lzma, 1 << 28, 0) != LZMA_OK)
SlError(STR_GAME_SAVELOAD_ERROR_BROKEN_INTERNAL_ERROR,
"cannot initialize decompressor");
2245 lzma_end(&this->
lzma);
2248 size_t Read(byte *buf,
size_t size)
2250 this->
lzma.next_out = buf;
2251 this->
lzma.avail_out = size;
2255 if (this->
lzma.avail_in == 0) {
2261 lzma_ret r = lzma_code(&this->
lzma, LZMA_RUN);
2262 if (r == LZMA_STREAM_END)
break;
2263 if (r != LZMA_OK)
SlError(STR_GAME_SAVELOAD_ERROR_BROKEN_INTERNAL_ERROR,
"liblzma returned error code");
2264 }
while (this->
lzma.avail_out != 0);
2266 return size - this->
lzma.avail_out;
2281 if (lzma_easy_encoder(&this->
lzma, compression_level, LZMA_CHECK_CRC32) != LZMA_OK)
SlError(STR_GAME_SAVELOAD_ERROR_BROKEN_INTERNAL_ERROR,
"cannot initialize compressor");
2287 lzma_end(&this->
lzma);
2300 this->
lzma.next_in = p;
2301 this->
lzma.avail_in = len;
2303 this->
lzma.next_out = buf;
2304 this->
lzma.avail_out =
sizeof(buf);
2306 lzma_ret r = lzma_code(&this->
lzma, action);
2309 if ((n =
sizeof(buf) - this->
lzma.avail_out) != 0) {
2312 if (r == LZMA_STREAM_END)
break;
2313 if (r != LZMA_OK)
SlError(STR_GAME_SAVELOAD_ERROR_BROKEN_INTERNAL_ERROR,
"liblzma returned error code");
2314 }
while (this->
lzma.avail_in || !this->lzma.avail_out);
2350 #if defined(WITH_LZO)
2352 {
"lzo", TO_BE32X(
'OTTD'), CreateLoadFilter<LZOLoadFilter>, CreateSaveFilter<LZOSaveFilter>, 0, 0, 0},
2354 {
"lzo", TO_BE32X(
'OTTD'), NULL, NULL, 0, 0, 0},
2357 {
"none", TO_BE32X(
'OTTN'), CreateLoadFilter<NoCompLoadFilter>, CreateSaveFilter<NoCompSaveFilter>, 0, 0, 0},
2358 #if defined(WITH_ZLIB)
2362 {
"zlib", TO_BE32X(
'OTTZ'), CreateLoadFilter<ZlibLoadFilter>, CreateSaveFilter<ZlibSaveFilter>, 0, 6, 9},
2364 {
"zlib", TO_BE32X(
'OTTZ'), NULL, NULL, 0, 0, 0},
2366 #if defined(WITH_LZMA)
2372 {
"lzma", TO_BE32X(
'OTTX'), CreateLoadFilter<LZMALoadFilter>, CreateSaveFilter<LZMASaveFilter>, 0, 2, 9},
2374 {
"lzma", TO_BE32X(
'OTTX'), NULL, NULL, 0, 0, 0},
2394 char *complevel = strrchr(s,
':');
2395 if (complevel != NULL) *complevel =
'\0';
2397 for (
const SaveLoadFormat *slf = &_saveload_formats[0]; slf !=
endof(_saveload_formats); slf++) {
2398 if (slf->init_write != NULL && strcmp(s, slf->name) == 0) {
2399 *compression_level = slf->default_compression;
2400 if (complevel != NULL) {
2409 long level = strtol(complevel, &end, 10);
2410 if (end == complevel || level !=
Clamp(level, slf->min_compression, slf->max_compression)) {
2414 *compression_level = level;
2426 if (complevel != NULL) *complevel =
':';
2433 void InitializeGame(uint size_x, uint size_y,
bool reset_date,
bool reset_settings);
2435 extern bool LoadOldSaveGame(
const char *file);
2473 if (_game_mode != GM_MENU) _fast_forward = _sl.
ff_state;
2492 static char err_str[512];
2493 GetString(err_str, _sl.
action ==
SLA_SAVE ? STR_ERROR_GAME_SAVE_FAILED : STR_ERROR_GAME_LOAD_FAILED,
lastof(err_str));
2517 _sl.
sf->
Write((byte*)hdr,
sizeof(hdr));
2534 if (_sl.
error_str != STR_NETWORK_ERROR_LOSTCONNECTION) {
2555 void WaitTillSaved()
2557 if (_save_thread == NULL)
return;
2559 _save_thread->
Join();
2561 _save_thread = NULL;
2584 SaveViewportBeforeSaveGame();
2589 if (threaded)
DEBUG(sl, 1,
"Cannot create savegame thread, reverting to single-threaded mode...");
2610 return DoSave(writer, threaded);
2635 if (_sl.
lf->
Read((byte*)hdr,
sizeof(hdr)) !=
sizeof(hdr))
SlError(STR_GAME_SAVELOAD_ERROR_FILE_NOT_READABLE);
2641 if (fmt ==
endof(_saveload_formats)) {
2642 DEBUG(sl, 0,
"Unknown savegame type, trying to load it as the buggy format");
2650 if (fmt ==
endof(_saveload_formats)) {
2654 if (fmt->
tag == TO_BE32X(
'OTTD'))
break;
2660 if (fmt->
tag == hdr[0]) {
2682 SlError(STR_GAME_SAVELOAD_ERROR_BROKEN_INTERNAL_ERROR, err_str);
2693 InitializeGame(256, 256,
true,
true);
2765 return DoLoad(reader,
false);
2794 InitializeGame(256, 256,
true,
true);
2802 if (!LoadOldSaveGame(filename))
return SL_REINIT;
2828 default: NOT_REACHED();
2839 SlError(fop ==
SLO_SAVE ? STR_GAME_SAVELOAD_ERROR_FILE_NOT_WRITEABLE : STR_GAME_SAVELOAD_ERROR_FILE_NOT_READABLE);
2851 DEBUG(desync, 1,
"load: %s", filename);
2884 FOR_ALL_COMPANIES(c) {
2894 case 0:
SetDParam(1, STR_JUST_DATE_LONG);
break;
2895 case 1:
SetDParam(1, STR_JUST_DATE_TINY);
break;
2896 case 2:
SetDParam(1, STR_JUST_DATE_ISO);
break;
2897 default: NOT_REACHED();
2902 GetString(buf, !
Company::IsValidID(cid) ? STR_SAVEGAME_NAME_SPECTATOR : STR_SAVEGAME_NAME_DEFAULT, last);
2960 int GetSavegameType(
char *file)
2965 int mode = SL_OLD_LOAD;
2967 f = fopen(file,
"rb");
2968 if (fread(&hdr,
sizeof(hdr), 1, f) != 1) {
2969 DEBUG(sl, 0,
"Savegame is obsolete or invalid format");
2973 for (fmt = _saveload_formats; fmt !=
endof(_saveload_formats); fmt++) {
2974 if (fmt->
tag == hdr) {