1

/** @file

     2

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

     3

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

     4

 * <ol>

     5

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

     6

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

     7

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

     8

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

     9

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

    10

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

    11

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

    12

 * </ol>

    13

 * @see ChunkHandler

    14

 * @see SaveLoad

    15

 */

    16

#include "stdafx.h"

    18

#include "debug.h"

    19

#include "vehicle.h"

    20

#include "station.h"

    21

#include "town.h"

    22

#include "player.h"

    23

#include "saveload.h"

    24

    25

enum {

    26

	SAVEGAME_MAJOR_VERSION = 13,

    27

	SAVEGAME_MINOR_VERSION = 0x1,

    28

    29

	SAVEGAME_LOADABLE_VERSION = (SAVEGAME_MAJOR_VERSION << 8) + SAVEGAME_MINOR_VERSION

    30

};

    31

    32

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

    33

    34

SaverLoader _sl;

    35

    36

/**

    37

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

    38

 */

    39

static void SlReadFill(void)

    40

{

    41

	uint len = _sl.read_bytes();

    42

	assert(len != 0);

    43

    44

	_sl.bufp = _sl.buf;

    45

	_sl.bufe = _sl.buf + len;

    46

	_sl.offs_base += len;

    47

}

    48

    49

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

    50

    51

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

    52

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

    53

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

    54

 */

    55

static void SlWriteFill(void)

    56

{

    57

	// flush the buffer to disk (the writer)

    58

	if (_sl.bufp != NULL) {

    59

		uint len = _sl.bufp - _sl.buf;

    60

		_sl.offs_base += len;

    61

		if (len) _sl.write_bytes(len);

    62

	}

    63

    64

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

    65

	* to start reading in more data */

    66

	_sl.bufp = _sl.buf;

    67

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

    68

}

    69

    70

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

    71

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

    72

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

    73

static void NORETURN SlError(const char *msg)

    74

{

    75

	_sl.excpt_msg = msg;

    76

	longjmp(_sl.excpt, 0);

    77

}

    78

    79

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

    80

 * flush it to its final destination

    81

 * @return return the read byte from file

    82

 */

    83

static inline int SlReadByteInternal(void)

    84

{

    85

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

    86

	return *_sl.bufp++;

    87

}

    88

    89

/** Wrapper for SlReadByteInternal */

    90

int SlReadByte(void) {return SlReadByteInternal();}

    91

    92

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

    93

 * flush it to its destination (file)

    94

 * @param b the byte that is currently written

    95

 */

    96

static inline void SlWriteByteInternal(byte b)

    97

{

    98

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

    99

	*_sl.bufp++ = b;

   100

}

   101

   102

/** Wrapper for SlWriteByteInternal */

   103

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

   104

   105

static inline int SlReadUint16(void)

   106

{

   107

	int x = SlReadByte() << 8;

   108

	return x | SlReadByte();

   109

}

   110

   111

static inline uint32 SlReadUint32(void)

   112

{

   113

	uint32 x = SlReadUint16() << 16;

   114

	return x | SlReadUint16();

   115

}

   116

   117

static inline uint64 SlReadUint64(void)

   118

{

   119

	uint32 x = SlReadUint32();

   120

	uint32 y = SlReadUint32();

   121

	return (uint64)x << 32 | y;

   122

}

   123

   124

static inline void SlWriteUint16(VarType v)

   125

{

   126

	SlWriteByte((byte)(v >> 8));

   127

	SlWriteByte((byte)v);

   128

}

   129

   130

static inline void SlWriteUint32(uint32 v)

   131

{

   132

	SlWriteUint16((uint16)(v >> 16));

   133

	SlWriteUint16((uint16)v);

   134

}

   135

   136

static inline void SlWriteUint64(uint64 x)

   137

{

   138

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

   139

	SlWriteUint32((uint32)x);

   140

}

   141

   142

/**

   143

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

   144

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

   145

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

   146

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

   147

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

   148

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

   149

 * @return Return the value of the index

   150

 */

   151

static uint SlReadSimpleGamma(void)

   152

{

   153

	uint i = SlReadByte();

   154

	if (HASBIT(i, 7)) {

   155

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

   156

		CLRBIT(i, 15);

   157

	}

   158

	return i;

   159

}

   160

   161

/**

   162

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

   163

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

   164

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

   165

 * that the length consists of 2 bytes. The length is fixed to a

   166

 * maximum of 16384 since any higher value will have bit 15 set

   167

 * and the notice, would obfuscate the real value

   168

 * @param i Index being written

   169

 * @todo the maximum of 16384 can easily be reached with vehicles, so raise this artificial limit

   170

 */

   171

static void SlWriteSimpleGamma(uint i)

   172

{

   173

	assert(i < (1 << 14));

   174

   175

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

   176

		SlWriteByte((byte)((1 << 7) | (i >> 8)));

   177

		SlWriteByte((byte)i);

   178

	} else

   179

		SlWriteByte(i);

   180

}

   181

   182

/** Return if the length will use up 1 or two bytes in a savegame */

   183

static inline uint SlGetGammaLength(uint i) {return (i >= (1 << 7)) ? 2 : 1;}

   184

   185

static inline int SlReadSparseIndex(void) {return SlReadSimpleGamma();}

   186

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

   187

   188

static inline int SlReadArrayLength(void) {return SlReadSimpleGamma();}

   189

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

   190

   191

void SlSetArrayIndex(uint index)

   192

{

   193

	_sl.need_length = NL_WANTLENGTH;

   194

	_sl.array_index = index;

   195

}

   196

   197

/**

   198

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

   199

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

   200

 */

   201

int SlIterateArray(void)

   202

{

   203

	int index;

   204

	static uint32 next_offs;

   205

   206

	/* After reading in the whole array inside the loop

   207

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

   208

	assert(next_offs == 0 || SlGetOffs() == next_offs);

   209

   210

	while (true) {

   211

		uint length = SlReadArrayLength();

   212

		if (length == 0) {

   213

			next_offs = 0;

   214

			return -1;

   215

		}

   216

   217

		_sl.obj_len = --length;

   218

		next_offs = SlGetOffs() + length;

   219

   220

		switch (_sl.block_mode) {

   221

		case CH_SPARSE_ARRAY:	index = SlReadSparseIndex(); break;

   222

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

   223

		default:

   224

			DEBUG(misc, 0) ("SlIterateArray: error");

   225

			return -1; // error

   226

		}

   227

   228

		if (length != 0) return index;

   229

	}

   230

}

   231

   232

/**

   233

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

   234

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

   235

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

   236

 */

   237

void SlSetLength(size_t length)

   238

{

   239

	switch (_sl.need_length) {

   240

	case NL_WANTLENGTH:

   241

		_sl.need_length = NL_NONE;

   242

		switch (_sl.block_mode) {

   243

		case CH_RIFF:

   244

			// Really simple to write a RIFF length :)

   245

			SlWriteUint32(length);

   246

			break;

   247

		case CH_ARRAY:

   248

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

   249

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

   250

				SlWriteArrayLength(1);

   251

			SlWriteArrayLength(length + 1);

   252

			break;

   253

		case CH_SPARSE_ARRAY:

   254

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

   255

			SlWriteSparseIndex(_sl.array_index);

   256

			break;

   257

		default: NOT_REACHED();

   258

		} break;

   259

	case NL_CALCLENGTH:

   260

		_sl.obj_len += length;

   261

		break;

   262

	}

   263

}

   264

   265

/**

   266

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

   267

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

   268

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

   269

 * @param length number of bytes this fast CopyBytes lasts

   270

 */

   271

static void SlCopyBytes(void *ptr, size_t length)

   272

{

   273

	byte *p = (byte*)ptr;

   274

   275

	if (_sl.save) {

   276

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

   277

	} else {

   278

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

   279

	}

   280

}

   281

   282

#if 0

   283

/**

   284

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

   285

 * anything with them

   286

 * NOTICE: currently unused

   287

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

   288

 */

   289

static inline void SlSkipBytes(size_t length)

   290

{

   291

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

   292

		SlReadByte();

   293

}

   294

#endif

   295

   296

/* Get the length of the current object */

   297

uint SlGetFieldLength(void) {return _sl.obj_len;}

   298

   299

/**

   300

 * Handle all conversion and typechecking of variables here.

   301

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

   302

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

   303

 * goes exactly the opposite way

   304

 * @param ptr The object being filled/read

   305

 * @param conv @VarType type of the current element of the struct

   306

 */

   307

static void SlSaveLoadConv(void *ptr, VarType conv)

   308

{

   309

	int64 x = 0;

   310

   311

	if (_sl.save) { /* SAVE values */

   312

		/* Read a value from the struct. These ARE endian safe. */

   313

		switch ((conv >> 4) & 0xF) {

   314

		case SLE_VAR_I8   >> 4: x = *(int8*)ptr; break;

   315

		case SLE_VAR_U8   >> 4: x = *(byte*)ptr; break;

   316

		case SLE_VAR_I16  >> 4: x = *(int16*)ptr; break;

   317

		case SLE_VAR_U16  >> 4: x = *(uint16*)ptr; break;

   318

		case SLE_VAR_I32  >> 4: x = *(int32*)ptr; break;

   319

		case SLE_VAR_U32  >> 4: x = *(uint32*)ptr; break;

   320

		case SLE_VAR_I64  >> 4: x = *(int64*)ptr; break;

   321

		case SLE_VAR_U64  >> 4: x = *(uint64*)ptr; break;

   322

		case SLE_VAR_NULL >> 4: x = 0; break;

   323

		default: NOT_REACHED();

   324

		}

   325

   326

		// Write the value to the file and check if its value is in the desired range

   327

		switch (conv & 0xF) {

   328

		case SLE_FILE_I8: assert(x >= -128 && x <= 127);     SlWriteByte(x);break;

   329

		case SLE_FILE_U8:	assert(x >= 0 && x <= 255);        SlWriteByte(x);break;

   330

		case SLE_FILE_I16:assert(x >= -32768 && x <= 32767); SlWriteUint16(x);break;

   331

		case SLE_FILE_STRINGID:

   332

		case SLE_FILE_U16:assert(x >= 0 && x <= 65535);      SlWriteUint16(x);break;

   333

		case SLE_FILE_I32: case SLE_FILE_U32:                SlWriteUint32((uint32)x);break;

   334

		case SLE_FILE_I64: case SLE_FILE_U64:                SlWriteUint64(x);break;

   335

		default: NOT_REACHED();

   336

		}

   337

	} else { /* LOAD values */

   338

   339

		// Read a value from the file

   340

		switch (conv & 0xF) {

   341

		case SLE_FILE_I8:  x = (int8)SlReadByte(); break;

   342

		case SLE_FILE_U8:  x = (byte)SlReadByte(); break;

   343

		case SLE_FILE_I16: x = (int16)SlReadUint16(); break;

   344

		case SLE_FILE_U16: x = (uint16)SlReadUint16(); break;

   345

		case SLE_FILE_I32: x = (int32)SlReadUint32(); break;

   346

		case SLE_FILE_U32: x = (uint32)SlReadUint32(); break;

   347

		case SLE_FILE_I64: x = (int64)SlReadUint64(); break;

   348

		case SLE_FILE_U64: x = (uint64)SlReadUint64(); break;

   349

		case SLE_FILE_STRINGID: x = RemapOldStringID((uint16)SlReadUint16()); break;

   350

		default: NOT_REACHED();

   351

		}

   352

   353

		/* Write The value to the struct. These ARE endian safe. */

   354

		switch ((conv >> 4) & 0xF) {

   355

		case SLE_VAR_I8   >> 4:  *(int8*)ptr = x; break;

   356

		case SLE_VAR_U8   >> 4:  *(byte*)ptr = x; break;

   357

		case SLE_VAR_I16  >> 4: *(int16*)ptr = x; break;

   358

		case SLE_VAR_U16  >> 4: *(uint16*)ptr = x; break;

   359

		case SLE_VAR_I32  >> 4: *(int32*)ptr = x; break;

   360

		case SLE_VAR_U32  >> 4: *(uint32*)ptr = x; break;

   361

		case SLE_VAR_I64  >> 4: *(int64*)ptr = x; break;

   362

		case SLE_VAR_U64  >> 4: *(uint64*)ptr = x; break;

   363

		case SLE_VAR_NULL >> 4: break;

   364

		default: NOT_REACHED();

   365

		}

   366

	}

   367

}

   368

   369

/* Length in bytes of the various datatypes in a savefile. These

   370

 * sizes are guaranteed by assert_compiles in stdafx.h */

   371

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

   372

   373

/**

   374

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

   375

 * @param var The variable the size is being asked of (NOTICE: unused)

   376

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

   377

 * @return Return the size of this type in byes

   378

 */

   379

static inline size_t SlCalcConvLen(const void *var, VarType conv) {return _conv_lengths[conv & 0xF];}

   380

   381

/**

   382

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

   383

 */

   384

static inline size_t SlCalcRefLen(void) {return 2;}

   385

   386

/**

   387

 * Return the size in bytes of a certain type of atomic array

   388

 * @param array The variable the size is being asked of (NOTICE: unused)

   389

 * @param length The length of the array counted in elements

   390

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

   391

 */

   392

static inline size_t SlCalcArrayLen(const void *array, uint length, VarType conv) {return _conv_lengths[conv & 0xF] * length;}

   393

   394

/**

   395

 * Save/Load an array.

   396

 * @param array The array being manipulated

   397

 * @param length The length of the array in elements

   398

 * @param conv @VarType type of the atomic array (int, byte, uint64, etc.)

   399

 */

   400

void SlArray(void *array, uint length, VarType conv)

   401

{

   402

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

   403

   404

	// Automatically calculate the length?

   405

	if (_sl.need_length != NL_NONE) {

   406

		SlSetLength(SlCalcArrayLen(array, length, conv));

   407

		// Determine length only?

   408

		if (_sl.need_length == NL_CALCLENGTH)

   409

			return;

   410

	}

   411

   412

	/* NOTICE - handle some buggy stuff, in really old versions everything was saved

   413

	 * as a byte-type. So detect this, and adjust array size accordingly */

   414

	if (!_sl.save && _sl.version == 0) {

   415

		if (conv == SLE_INT16 || conv == SLE_UINT16 || conv == SLE_STRINGID) {

   416

			length *= 2; // int16, uint16 and StringID are 2 bytes in size

   417

			conv = SLE_INT8;

   418

		} else if (conv == SLE_INT32 || conv == SLE_UINT32) {

   419

			length *= 4; // int32 and uint32 are 4 bytes in size

   420

			conv = SLE_INT8;

   421

		}

   422

	}

   423

   424

	/* If the size of elements is 1 byte, no special conversion is needed,

   425

	 * use specialized copy-to-copy function to speed up things */

   426

	if (conv == SLE_INT8 || conv == SLE_UINT8) {

   427

		SlCopyBytes(array, length);

   428

	} else {

   429

		byte *a = (byte*)array;

   430

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

   431

			SlSaveLoadConv(a, conv);

   432

			a += conv_mem_size[(conv >> 4) & 0xF]; // get size

   433

		}

   434

	}

   435

}

   436

   437

/**

   438

 * Calculate the size of an object.

   439

 * @param object Object that needs its length calculated

   440

 * @param sld The @SaveLoad description of the object so we know how to manipulate it

   441

 */

   442

static size_t SlCalcObjLength(void *object, const SaveLoad *sld)

   443

{

   444

	size_t length = 0;

   445

   446

	// Need to determine the length and write a length tag.

   447

	for (; sld->cmd != SL_END; sld++) {

   448

		if (sld->cmd < SL_WRITEBYTE) {

   449

			if (HASBIT(sld->cmd, 2)) {

   450

				// check if the field is used in the current savegame version

   451

				if (_sl.version < sld->version_from || _sl.version > sld->version_to)

   452

					continue;

   453

			}

   454

   455

			switch (sld->cmd) {

   456

			case SL_VAR: case SL_CONDVAR: /* Normal Variable */

   457

				length += SlCalcConvLen(NULL, sld->type); break;

   458

			case SL_REF: case SL_CONDREF:  /* Reference variable */

   459

				length += SlCalcRefLen(); break;

   460

			case SL_ARR: case SL_CONDARR: /* Array */

   461

				length += SlCalcArrayLen(NULL, sld->length, sld->type); break;

   462

			default: NOT_REACHED();

   463

			}

   464

		} else if (sld->cmd == SL_WRITEBYTE) {

   465

			length++; // a byte is logically of size 1

   466

		} else if (sld->cmd == SL_INCLUDE) {

   467

			length += SlCalcObjLength(NULL, _sl.includes[sld->version_from]);

   468

		}	else

   469

			assert(sld->cmd == SL_END);

   470

	}

   471

	return length;

   472

}

   473

   474

/**

   475

 * Main SaveLoad function.

   476

 * @param object The object that is being saved or loaded

   477

 * @param sld The @SaveLoad description of the object so we know how to manipulate it

   478

 */

   479

void SlObject(void *object, const SaveLoad *sld)

   480

{

   481

	// Automatically calculate the length?

   482

	if (_sl.need_length != NL_NONE) {

   483

		SlSetLength(SlCalcObjLength(object, sld));

   484

		if (_sl.need_length == NL_CALCLENGTH)

   485

			return;

   486

	}

   487

   488

	for (; sld->cmd != SL_END; sld++) {

   489

		void *ptr = (byte*)object + sld->offset;

   490

   491

		if (sld->cmd < SL_WRITEBYTE) {

   492

			/* CONDITIONAL saveload types depend on the savegame version */

   493

			if (HASBIT(sld->cmd, 2)) {

   494

				// check if the field is of the right version, if not, proceed to next one

   495

				if (_sl.version < sld->version_from || _sl.version > sld->version_to)

   496

					continue;

   497

			}

   498

   499

			switch (sld->cmd) {