1

/* $Id$ */

     2

     3

/** @file saveload.cpp

     4

 * All actions handling saving and loading goes on in this file. The general actions

     5

 * are as follows for saving a game (loading is analogous):

     6

 * <ol>

     7

 * <li>initialize the writer by creating a temporary memory-buffer for it

     8

 * <li>go through all to-be saved elements, each 'chunk' (ChunkHandler) prefixed by a label

     9

 * <li>use their description array (SaveLoad) to know what elements to save and in what version

    10

 *    of the game it was active (used when loading)

    11

 * <li>write all data byte-by-byte to the temporary buffer so it is endian-safe

    12

 * <li>when the buffer is full; flush it to the output (eg save to file) (_sl.buf, _sl.bufp, _sl.bufe)

    13

 * <li>repeat this until everything is done, and flush any remaining output to file

    14

 * </ol>

    15

 */

    16

#include "stdafx.h"

    17

#include "openttd.h"

    18

#include "debug.h"

    19

#include "station_base.h"

    20

#include "thread.h"

    21

#include "town.h"

    22

#include "saveload.h"

    23

#include "network/network.h"

    24

#include "variables.h"

    25

#include "window_func.h"

    26

#include "strings_func.h"

    27

#include "gfx_func.h"

    28

#include "core/alloc_func.hpp"

    29

#include "functions.h"

    30

#include "core/endian_func.hpp"

    31

#include "vehicle_base.h"

    32

#include "autoreplace_base.h"

    33

#include "statusbar_gui.h"

    34

#include "fileio_func.h"

    35

#include <list>

    36

#include "gamelog.h"

    37

    38

#include "table/strings.h"

    39

    40

extern const uint16 SAVEGAME_VERSION = 103;

    41

    42

SavegameType _savegame_type; ///< type of savegame we are loading

    43

    44

uint32 _ttdp_version;     ///< version of TTDP savegame (if applicable)

    45

uint16 _sl_version;       ///< the major savegame version identifier

    46

byte   _sl_minor_version; ///< the minor savegame version, DO NOT USE!

    47

    48

typedef void WriterProc(size_t len);

    49

typedef size_t ReaderProc();

    50

    51

/** The saveload struct, containing reader-writer functions, bufffer, version, etc. */

    52

static struct {

    53

	bool save;                           ///< are we doing a save or a load atm. True when saving

    54

	byte need_length;                    ///< ???

    55

	byte block_mode;                     ///< ???

    56

	bool error;                          ///< did an error occur or not

    57

    58

	size_t obj_len;                      ///< the length of the current object we are busy with

    59

	int array_index, last_array_index;   ///< in the case of an array, the current and last positions

    60

    61

	size_t offs_base;                    ///< the offset in number of bytes since we started writing data (eg uncompressed savegame size)

    62

    63

	WriterProc *write_bytes;             ///< savegame writer function

    64

	ReaderProc *read_bytes;              ///< savegame loader function

    65

    66

	const ChunkHandler* const *chs;      ///< the chunk of data that is being processed atm (vehicles, signs, etc.)

    67

    68

	/* When saving/loading savegames, they are always saved to a temporary memory-place

    69

	 * to be flushed to file (save) or to final place (load) when full. */

    70

	byte *bufp, *bufe;                   ///< bufp(ointer) gives the current position in the buffer bufe(nd) gives the end of the buffer

    71

    72

	/* these 3 may be used by compressor/decompressors. */

    73

	byte *buf;                           ///< pointer to temporary memory to read/write, initialized by SaveLoadFormat->initread/write

    74

	byte *buf_ori;                       ///< pointer to the original memory location of buf, used to free it afterwards

    75

	uint bufsize;                        ///< the size of the temporary memory *buf

    76

	FILE *fh;                            ///< the file from which is read or written to

    77

    78

	void (*excpt_uninit)();              ///< the function to execute on any encountered error

    79

	StringID error_str;                  ///< the translateable error message to show

    80

	char *extra_msg;                     ///< the error message

    81

} _sl;

    82

    83

    84

enum NeedLengthValues {NL_NONE = 0, NL_WANTLENGTH = 1, NL_CALCLENGTH = 2};

    85

    86

/** Error handler, calls longjmp to simulate an exception.

    87

 * @todo this was used to have a central place to handle errors, but it is

    88

 * pretty ugly, and seriously interferes with any multithreaded approaches */

    89

static void NORETURN SlError(StringID string, const char *extra_msg = NULL)

    90

{

    91

	_sl.error_str = string;

    92

	free(_sl.extra_msg);

    93

	_sl.extra_msg = (extra_msg == NULL) ? NULL : strdup(extra_msg);

    94

	throw std::exception();

    95

}

    96

    97

typedef void (*AsyncSaveFinishProc)();

    98

static AsyncSaveFinishProc _async_save_finish = NULL;

    99

static ThreadObject *_save_thread;

   100

   101

/**

   102

 * Called by save thread to tell we finished saving.

   103

 */

   104

static void SetAsyncSaveFinish(AsyncSaveFinishProc proc)

   105

{

   106

	if (_exit_game) return;

   107

	while (_async_save_finish != NULL) CSleep(10);

   108

   109

	_async_save_finish = proc;

   110

}

   111

   112

/**

   113

 * Handle async save finishes.

   114

 */

   115

void ProcessAsyncSaveFinish()

   116

{

   117

	if (_async_save_finish == NULL) return;

   118

   119

	_async_save_finish();

   120

   121

	_async_save_finish = NULL;

   122

   123

	if (_save_thread != NULL) {

   124

		_save_thread->Join();

   125

		delete _save_thread;

   126

		_save_thread = NULL;

   127

	}

   128

}

   129

   130

/**

   131

 * Fill the input buffer by reading from the file with the given reader

   132

 */

   133

static void SlReadFill()

   134

{

   135

	size_t len = _sl.read_bytes();

   136

	if (len == 0) SlError(STR_GAME_SAVELOAD_ERROR_BROKEN_SAVEGAME, "Unexpected end of chunk");

   137

   138

	_sl.bufp = _sl.buf;

   139

	_sl.bufe = _sl.buf + len;

   140

	_sl.offs_base += len;

   141

}

   142

   143

static inline size_t SlGetOffs() {return _sl.offs_base - (_sl.bufe - _sl.bufp);}

   144

   145

/** Return the size in bytes of a certain type of normal/atomic variable

   146

 * as it appears in memory. See VarTypes

   147

 * @param conv VarType type of variable that is used for calculating the size

   148

 * @return Return the size of this type in bytes */

   149

static inline byte SlCalcConvMemLen(VarType conv)

   150

{

   151

	static const byte conv_mem_size[] = {1, 1, 1, 2, 2, 4, 4, 8, 8, 0};

   152

	byte length = GB(conv, 4, 4);

   153

	assert(length < lengthof(conv_mem_size));

   154

	return conv_mem_size[length];

   155

}

   156

   157

/** Return the size in bytes of a certain type of normal/atomic variable

   158

 * as it appears in a saved game. See VarTypes

   159

 * @param conv VarType type of variable that is used for calculating the size

   160

 * @return Return the size of this type in bytes */

   161

static inline byte SlCalcConvFileLen(VarType conv)

   162

{

   163

	static const byte conv_file_size[] = {1, 1, 2, 2, 4, 4, 8, 8, 2};

   164

	byte length = GB(conv, 0, 4);

   165

	assert(length < lengthof(conv_file_size));

   166

	return conv_file_size[length];

   167

}

   168

   169

/** Return the size in bytes of a reference (pointer) */

   170

static inline size_t SlCalcRefLen() {return CheckSavegameVersion(69) ? 2 : 4;}

   171

   172

/** Flush the output buffer by writing to disk with the given reader.

   173

 * If the buffer pointer has not yet been set up, set it up now. Usually

   174

 * only called when the buffer is full, or there is no more data to be processed

   175

 */

   176

static void SlWriteFill()

   177

{

   178

	/* flush the buffer to disk (the writer) */

   179

	if (_sl.bufp != NULL) {

   180

		uint len = _sl.bufp - _sl.buf;

   181

		_sl.offs_base += len;

   182

		if (len) _sl.write_bytes(len);

   183

	}

   184

   185

	/* All the data from the buffer has been written away, rewind to the beginning

   186

	 * to start reading in more data */

   187

	_sl.bufp = _sl.buf;

   188

	_sl.bufe = _sl.buf + _sl.bufsize;

   189

}

   190

   191

/** Read in a single byte from file. If the temporary buffer is full,

   192

 * flush it to its final destination

   193

 * @return return the read byte from file

   194

 */

   195

static inline byte SlReadByteInternal()

   196

{

   197

	if (_sl.bufp == _sl.bufe) SlReadFill();

   198

	return *_sl.bufp++;

   199

}

   200

   201

/** Wrapper for SlReadByteInternal */

   202

byte SlReadByte() {return SlReadByteInternal();}

   203

   204

/** Write away a single byte from memory. If the temporary buffer is full,

   205

 * flush it to its destination (file)

   206

 * @param b the byte that is currently written

   207

 */

   208

static inline void SlWriteByteInternal(byte b)

   209

{

   210

	if (_sl.bufp == _sl.bufe) SlWriteFill();

   211

	*_sl.bufp++ = b;

   212

}

   213

   214

/** Wrapper for SlWriteByteInternal */

   215

void SlWriteByte(byte b) {SlWriteByteInternal(b);}

   216

   217

static inline int SlReadUint16()

   218

{

   219

	int x = SlReadByte() << 8;

   220

	return x | SlReadByte();

   221

}

   222

   223

static inline uint32 SlReadUint32()

   224

{

   225

	uint32 x = SlReadUint16() << 16;

   226

	return x | SlReadUint16();

   227

}

   228

   229

static inline uint64 SlReadUint64()

   230

{

   231

	uint32 x = SlReadUint32();

   232

	uint32 y = SlReadUint32();

   233

	return (uint64)x << 32 | y;

   234

}

   235

   236

static inline void SlWriteUint16(uint16 v)

   237

{

   238

	SlWriteByte(GB(v, 8, 8));

   239

	SlWriteByte(GB(v, 0, 8));

   240

}

   241

   242

static inline void SlWriteUint32(uint32 v)

   243

{

   244

	SlWriteUint16(GB(v, 16, 16));

   245

	SlWriteUint16(GB(v,  0, 16));

   246

}

   247

   248

static inline void SlWriteUint64(uint64 x)

   249

{

   250

	SlWriteUint32((uint32)(x >> 32));

   251

	SlWriteUint32((uint32)x);

   252

}

   253

   254

/**

   255

 * Read in the header descriptor of an object or an array.

   256

 * If the highest bit is set (7), then the index is bigger than 127

   257

 * elements, so use the next byte to read in the real value.

   258

 * The actual value is then both bytes added with the first shifted

   259

 * 8 bits to the left, and dropping the highest bit (which only indicated a big index).

   260

 * x = ((x & 0x7F) << 8) + SlReadByte();

   261

 * @return Return the value of the index

   262

 */

   263

static uint SlReadSimpleGamma()

   264

{

   265

	uint i = SlReadByte();

   266

	if (HasBit(i, 7)) {

   267

		i &= ~0x80;

   268

		if (HasBit(i, 6)) {

   269

			i &= ~0x40;

   270

			if (HasBit(i, 5)) {

   271

				i &= ~0x20;

   272

				if (HasBit(i, 4))

   273

					SlError(STR_GAME_SAVELOAD_ERROR_BROKEN_SAVEGAME, "Unsupported gamma");

   274

				i = (i << 8) | SlReadByte();

   275

			}

   276

			i = (i << 8) | SlReadByte();

   277

		}

   278

		i = (i << 8) | SlReadByte();

   279

	}

   280

	return i;

   281

}

   282

   283

/**

   284

 * Write the header descriptor of an object or an array.

   285

 * If the element is bigger than 127, use 2 bytes for saving

   286

 * and use the highest byte of the first written one as a notice

   287

 * that the length consists of 2 bytes, etc.. like this:

   288

 * 0xxxxxxx

   289

 * 10xxxxxx xxxxxxxx

   290

 * 110xxxxx xxxxxxxx xxxxxxxx

   291

 * 1110xxxx xxxxxxxx xxxxxxxx xxxxxxxx

   292

 * @param i Index being written

   293

 */

   294

   295

static void SlWriteSimpleGamma(size_t i)

   296

{

   297

	if (i >= (1 << 7)) {

   298

		if (i >= (1 << 14)) {

   299

			if (i >= (1 << 21)) {

   300

				assert(i < (1 << 28));

   301

				SlWriteByte((byte)(0xE0 | (i >> 24)));

   302

				SlWriteByte((byte)(i >> 16));

   303

			} else {

   304

				SlWriteByte((byte)(0xC0 | (i >> 16)));

   305

			}

   306

			SlWriteByte((byte)(i >> 8));

   307

		} else {

   308

			SlWriteByte((byte)(0x80 | (i >> 8)));

   309

		}

   310

	}

   311

	SlWriteByte((byte)i);

   312

}

   313

   314

/** Return how many bytes used to encode a gamma value */

   315

static inline uint SlGetGammaLength(size_t i)

   316

{

   317

	return 1 + (i >= (1 << 7)) + (i >= (1 << 14)) + (i >= (1 << 21));

   318

}

   319

   320

static inline uint SlReadSparseIndex() {return SlReadSimpleGamma();}

   321

static inline void SlWriteSparseIndex(uint index) {SlWriteSimpleGamma(index);}

   322

   323

static inline uint SlReadArrayLength() {return SlReadSimpleGamma();}

   324

static inline void SlWriteArrayLength(size_t length) {SlWriteSimpleGamma(length);}

   325

static inline uint SlGetArrayLength(size_t length) {return SlGetGammaLength(length);}

   326

   327

void SlSetArrayIndex(uint index)

   328

{

   329

	_sl.need_length = NL_WANTLENGTH;

   330

	_sl.array_index = index;

   331

}

   332

   333

static size_t _next_offs;

   334

   335

/**

   336

 * Iterate through the elements of an array and read the whole thing

   337

 * @return The index of the object, or -1 if we have reached the end of current block

   338

 */

   339

int SlIterateArray()

   340

{

   341

	int index;

   342

   343

	/* After reading in the whole array inside the loop

   344

	 * we must have read in all the data, so we must be at end of current block. */

   345

	if (_next_offs != 0 && SlGetOffs() != _next_offs) SlError(STR_GAME_SAVELOAD_ERROR_BROKEN_SAVEGAME, "Invalid chunk size");

   346

   347

	while (true) {

   348

		uint length = SlReadArrayLength();

   349

		if (length == 0) {

   350

			_next_offs = 0;

   351

			return -1;

   352

		}

   353

   354

		_sl.obj_len = --length;

   355

		_next_offs = SlGetOffs() + length;

   356

   357

		switch (_sl.block_mode) {

   358

		case CH_SPARSE_ARRAY: index = (int)SlReadSparseIndex(); break;

   359

		case CH_ARRAY:        index = _sl.array_index++; break;

   360

		default:

   361

			DEBUG(sl, 0, "SlIterateArray error");

   362

			return -1; // error

   363

		}

   364

   365

		if (length != 0) return index;

   366

	}

   367

}

   368

   369

/**

   370

 * Sets the length of either a RIFF object or the number of items in an array.

   371

 * This lets us load an object or an array of arbitrary size

   372

 * @param length The length of the sought object/array

   373

 */

   374

void SlSetLength(size_t length)

   375

{

   376

	assert(_sl.save);

   377

   378

	switch (_sl.need_length) {

   379

	case NL_WANTLENGTH:

   380

		_sl.need_length = NL_NONE;

   381

		switch (_sl.block_mode) {

   382

		case CH_RIFF:

   383

			/* Ugly encoding of >16M RIFF chunks

   384

			 * The lower 24 bits are normal

   385

			 * The uppermost 4 bits are bits 24:27 */

   386

			assert(length < (1 << 28));

   387

			SlWriteUint32((uint32)((length & 0xFFFFFF) | ((length >> 24) << 28)));

   388

			break;

   389

		case CH_ARRAY:

   390

			assert(_sl.last_array_index <= _sl.array_index);

   391

			while (++_sl.last_array_index <= _sl.array_index)

   392

				SlWriteArrayLength(1);

   393

			SlWriteArrayLength(length + 1);

   394

			break;

   395

		case CH_SPARSE_ARRAY:

   396

			SlWriteArrayLength(length + 1 + SlGetArrayLength(_sl.array_index)); // Also include length of sparse index.

   397

			SlWriteSparseIndex(_sl.array_index);

   398

			break;

   399

		default: NOT_REACHED();

   400

		} break;

   401

	case NL_CALCLENGTH:

   402

		_sl.obj_len += (int)length;

   403

		break;

   404

	}

   405

}

   406

   407

/**

   408

 * Save/Load bytes. These do not need to be converted to Little/Big Endian

   409

 * so directly write them or read them to/from file

   410

 * @param ptr The source or destination of the object being manipulated

   411

 * @param length number of bytes this fast CopyBytes lasts

   412

 */

   413

static void SlCopyBytes(void *ptr, size_t length)

   414

{

   415

	byte *p = (byte*)ptr;

   416

   417

	if (_sl.save) {

   418

		for (; length != 0; length--) {SlWriteByteInternal(*p++);}

   419

	} else {

   420

		for (; length != 0; length--) {*p++ = SlReadByteInternal();}

   421

	}

   422

}

   423

   424

/** Read in bytes from the file/data structure but don't do

   425

 * anything with them, discarding them in effect

   426

 * @param length The amount of bytes that is being treated this way

   427

 */

   428

static inline void SlSkipBytes(size_t length)

   429

{

   430

	for (; length != 0; length--) SlReadByte();

   431

}

   432

   433

/* Get the length of the current object */

   434

size_t SlGetFieldLength() {return _sl.obj_len;}

   435

   436

/** Return a signed-long version of the value of a setting

   437

 * @param ptr pointer to the variable

   438

 * @param conv type of variable, can be a non-clean

   439

 * type, eg one with other flags because it is parsed

   440

 * @return returns the value of the pointer-setting */

   441

int64 ReadValue(const void *ptr, VarType conv)

   442

{

   443

	switch (GetVarMemType(conv)) {

   444

	case SLE_VAR_BL:  return (*(bool*)ptr != 0);

   445

	case SLE_VAR_I8:  return *(int8*  )ptr;

   446

	case SLE_VAR_U8:  return *(byte*  )ptr;

   447

	case SLE_VAR_I16: return *(int16* )ptr;

   448

	case SLE_VAR_U16: return *(uint16*)ptr;

   449

	case SLE_VAR_I32: return *(int32* )ptr;

   450

	case SLE_VAR_U32: return *(uint32*)ptr;

   451

	case SLE_VAR_I64: return *(int64* )ptr;

   452

	case SLE_VAR_U64: return *(uint64*)ptr;

   453

	case SLE_VAR_NULL:return 0;

   454

	default: NOT_REACHED();

   455

	}

   456

   457

	/* useless, but avoids compiler warning this way */

   458

	return 0;

   459

}

   460

   461

/** Write the value of a setting

   462

 * @param ptr pointer to the variable

   463

 * @param conv type of variable, can be a non-clean type, eg

   464

 *             with other flags. It is parsed upon read

   465

 * @param val the new value being given to the variable */

   466

void WriteValue(void *ptr, VarType conv, int64 val)

   467

{

   468

	switch (GetVarMemType(conv)) {

   469

	case SLE_VAR_BL:  *(bool  *)ptr = (val != 0);  break;

   470

	case SLE_VAR_I8:  *(int8  *)ptr = val; break;

   471

	case SLE_VAR_U8:  *(byte  *)ptr = val; break;

   472

	case SLE_VAR_I16: *(int16 *)ptr = val; break;

   473

	case SLE_VAR_U16: *(uint16*)ptr = val; break;

   474

	case SLE_VAR_I32: *(int32 *)ptr = val; break;

   475

	case SLE_VAR_U32: *(uint32*)ptr = val; break;

   476

	case SLE_VAR_I64: *(int64 *)ptr = val; break;

   477

	case SLE_VAR_U64: *(uint64*)ptr = val; break;

   478

	case SLE_VAR_NAME: *(char**)ptr = CopyFromOldName(val); break;

   479

	case SLE_VAR_NULL: break;

   480

	default: NOT_REACHED();

   481

	}

   482

}

   483

   484

/**

   485

 * Handle all conversion and typechecking of variables here.

   486

 * In the case of saving, read in the actual value from the struct

   487

 * and then write them to file, endian safely. Loading a value

   488

 * goes exactly the opposite way

   489

 * @param ptr The object being filled/read

   490