1

#include "stdafx.h"

     2

#include "ttd.h"

     3

#include "vehicle.h"

     4

#include "station.h"

     5

#include "town.h"

     6

#include "player.h"

     7

#include "saveload.h"

     8

     9

enum {

    10

	SAVEGAME_MAJOR_VERSION = 8,

    11

	SAVEGAME_MINOR_VERSION = 0,

    12

    13

	SAVEGAME_LOADABLE_VERSION = (SAVEGAME_MAJOR_VERSION << 8) + SAVEGAME_MINOR_VERSION

    14

};

    15

    16

/******************************************************/

    17

/******************************************************/

    18

/******************************************************/

    19

    20

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

    21

    22

SaverLoader _sl;

    23

    24

// fill the input buffer

    25

static void SlReadFill(void)

    26

{

    27

	uint len = _sl.read_bytes();

    28

	assert(len != 0);

    29

    30

	_sl.bufp = _sl.buf;

    31

	_sl.bufe = _sl.buf + len;

    32

	_sl.offs_base += len;

    33

}

    34

    35

static uint32 SlGetOffs(void)

    36

{

    37

	return _sl.offs_base - (_sl.bufe - _sl.bufp);

    38

}

    39

    40

// flush the output buffer

    41

static void SlWriteFill(void)

    42

{

    43

	// flush current buffer?

    44

	if (_sl.bufp != NULL) {

    45

		uint len = _sl.bufp - _sl.buf;

    46

		_sl.offs_base += len;

    47

		if (len) _sl.write_bytes(len);

    48

	}

    49

    50

	// setup next buffer

    51

	_sl.bufp = _sl.buf;

    52

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

    53

}

    54

    55

// error handler, calls longjmp to simulate an exception.

    56

static void NORETURN SlError(const char *msg)

    57

{

    58

	_sl.excpt_msg = msg;

    59

	longjmp(_sl.excpt, 0);

    60

}

    61

    62

int SlReadByte(void)

    63

{

    64

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

    65

	return *_sl.bufp++;

    66

}

    67

    68

void SlWriteByte(byte v)

    69

{

    70

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

    71

	*_sl.bufp++ = v;

    72

}

    73

    74

static int SlReadUint16(void)

    75

{

    76

	int x = SlReadByte() << 8;

    77

	return x | SlReadByte();

    78

}

    79

    80

static uint32 SlReadUint32(void)

    81

{

    82

	uint32 x = SlReadUint16() << 16;

    83

	return x | SlReadUint16();

    84

}

    85

    86

static uint64 SlReadUint64(void)

    87

{

    88

	uint32 x = SlReadUint32();

    89

	uint32 y = SlReadUint32();

    90

	return (uint64)x << 32 | y;

    91

}

    92

    93

static void SlWriteUint16(uint16 v)

    94

{

    95

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

    96

	SlWriteByte((byte)v);

    97

}

    98

    99

static void SlWriteUint32(uint32 v)

   100

{

   101

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

   102

	SlWriteUint16((uint16)v);

   103

}

   104

   105

static void SlWriteUint64(uint64 x)

   106

{

   107

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

   108

	SlWriteUint32((uint32)x);

   109

}

   110

   111

static int SlReadSimpleGamma(void)

   112

{

   113

	int x = SlReadByte();

   114

	if (x & 0x80)

   115

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

   116

	return x;

   117

}

   118

   119

static void SlWriteSimpleGamma(uint i)

   120

{

   121

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

   122

	if (i >= 0x80) {

   123

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

   124

		SlWriteByte((byte)i);

   125

	} else {

   126

		SlWriteByte(i);

   127

	}

   128

}

   129

   130

static uint SlGetGammaLength(uint i) {

   131

	return (i>=0x80) ? 2 : 1;

   132

}

   133

   134

static inline int SlReadSparseIndex(void)

   135

{

   136

	return SlReadSimpleGamma();

   137

}

   138

   139

static inline void SlWriteSparseIndex(uint index)

   140

{

   141

	SlWriteSimpleGamma(index);

   142

}

   143

   144

static inline int SlReadArrayLength(void)

   145

{

   146

	return SlReadSimpleGamma();

   147

}

   148

   149

static inline void SlWriteArrayLength(uint length)

   150

{

   151

	SlWriteSimpleGamma(length);

   152

}

   153

   154

void SlSetArrayIndex(uint index)

   155

{

   156

	_sl.need_length = NL_WANTLENGTH;

   157

	_sl.array_index = index;

   158

}

   159

   160

int SlIterateArray(void)

   161

{

   162

	int ind;

   163

	static uint32 next_offs;

   164

   165

	// Must be at end of current block.

   166

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

   167

   168

	while(true) {

   169

		uint len = SlReadArrayLength();

   170

		if (len == 0) {

   171

			next_offs = 0;

   172

			return -1;

   173

		}

   174

   175

		_sl.obj_len = --len;

   176

		next_offs = SlGetOffs() + len;

   177

   178

		switch(_sl.block_mode) {

   179

		case CH_SPARSE_ARRAY:	ind = SlReadSparseIndex(); break;

   180

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

   181

		default:

   182

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

   183

			return -1; // error

   184

		}

   185

   186

		if (len != 0)

   187

			return ind;

   188

	}

   189

}

   190

   191

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

   192

void SlSetLength(uint length)

   193

{

   194

	switch(_sl.need_length) {

   195

	case NL_WANTLENGTH:

   196

		_sl.need_length = NL_NONE;

   197

		switch(_sl.block_mode) {

   198

		case CH_RIFF:

   199

			// Really simple to write a RIFF length :)

   200

			SlWriteUint32(length);

   201

		break;

   202

		case CH_ARRAY:

   203

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

   204

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

   205

				SlWriteArrayLength(1);

   206

			SlWriteArrayLength(length + 1);

   207

			break;

   208

		case CH_SPARSE_ARRAY:

   209

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

   210

			SlWriteSparseIndex(_sl.array_index);

   211

			break;

   212

		default: NOT_REACHED();

   213

		}

   214

		break;

   215

	case NL_CALCLENGTH:

   216

		_sl.obj_len += length;

   217

		break;

   218

	}

   219

}

   220

   221

static void SlCopyBytes(void *ptr, size_t length)

   222

{

   223

	byte *p = (byte*)ptr;

   224

   225

	if (_sl.save) {

   226

		while(length) {

   227

			SlWriteByte(*p++);

   228

			length--;

   229

		}

   230

	} else {

   231

		while(length) {

   232

			// INLINED SlReadByte

   233

#if !defined(_DEBUG)

   234

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

   235

			*p++ = *_sl.bufp++;

   236

#else

   237

			*p++ = SlReadByte();

   238

#endif

   239

			length--;

   240

		}

   241

	}

   242

}

   243

   244

static void SlSkipBytes(size_t length)

   245

{

   246

	while (length) {

   247

		SlReadByte();

   248

		length--;

   249

	}

   250

}

   251

   252

uint SlGetFieldLength(void)

   253

{

   254

	return _sl.obj_len;

   255

}

   256

   257

   258

static void SlSaveLoadConv(void *ptr, uint conv)

   259

{

   260

	int64 x = 0;

   261

   262

	if (_sl.save) {

   263

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

   264

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

   265

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

   266

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

   267

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

   268

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

   269

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

   270

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

   271

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

   272

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

   273

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

   274

		default:

   275

			NOT_REACHED();

   276

		}

   277

   278

		// Write it to the file

   279

		switch(conv & 0xF) {

   280

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

   281

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

   282

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

   283

		case SLE_FILE_STRINGID:

   284

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

   285

		case SLE_FILE_I32:

   286

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

   287

		case SLE_FILE_I64:

   288

		case SLE_FILE_U64:SlWriteUint64(x);break;

   289

		default:

   290

			assert(0);

   291

			NOT_REACHED();

   292

		}

   293

	} else {

   294

   295

		// Read a value from the file

   296

		switch(conv & 0xF) {

   297

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

   298

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

   299

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

   300

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

   301

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

   302

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

   303

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

   304

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

   305

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

   306

		default:

   307

			assert(0);

   308

			NOT_REACHED();

   309

		}

   310

   311

		// Write it to the struct, these ARE endian safe.

   312

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

   313

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

   314

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

   315

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

   316

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

   317

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

   318

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

   319

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

   320

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

   321

		case SLE_VAR_NULL: break;

   322

		default:

   323

			NOT_REACHED();

   324

		}

   325

	}

   326

}

   327

   328

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

   329

   330

static uint SlCalcConvLen(uint conv, void *p)

   331

{

   332

	return _conv_lengths[conv & 0xF];

   333

}

   334

   335

static uint SlCalcArrayLen(void *array, uint length, uint conv)

   336

{

   337

	return _conv_lengths[conv & 0xF] * length;

   338

}

   339

   340

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

   341

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

   342

{

   343

	// Automatically calculate the length?

   344

	if (_sl.need_length != NL_NONE) {

   345

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

   346

		// Determine length only?

   347

		if (_sl.need_length == NL_CALCLENGTH)

   348

			return;

   349

	}

   350

   351

	// handle buggy stuff

   352

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

   353

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

   354

			length *= 2;

   355

			conv = SLE_INT8;

   356

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

   357

			length *= 4;

   358

			conv = SLE_INT8;

   359

		}

   360

	}

   361

   362

	// Optimized cases when input equals output.

   363

	switch(conv) {

   364

	case SLE_INT8:

   365

	case SLE_UINT8:SlCopyBytes(array, length);break;

   366

	default: {

   367

		// Default "slow" case.

   368

		byte *a = (byte*)array;

   369

		while (length) {

   370

			SlSaveLoadConv(a, conv);

   371

			a += _conv_mem_size[(conv >> 4)&0xf];

   372

			length--;

   373

		}

   374

		}

   375

	}

   376

}

   377

   378

// Calculate the size of an object.

   379

static size_t SlCalcObjLength(void *object, const void *desc)

   380

{

   381

	size_t length = 0;

   382

	uint cmd,conv;

   383

	const byte *d = (const byte*)desc;

   384

   385

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

   386

	while (true) {

   387

		cmd = (d[0] >> 4);

   388

		if (cmd < 8) {

   389

			conv = d[2];

   390

			d += 3;

   391

			if (cmd&4) {

   392

				d += 2;

   393

				// check if the field is of the right version

   394

				if (_sl.version < d[-2] || _sl.version > d[-1]) {

   395

					if ((cmd & 3) == 2) d++;

   396

					continue;

   397

				}

   398

			}

   399

   400

			switch(cmd&3) {

   401

			// Normal variable

   402

			case 0: length += SlCalcConvLen(conv, NULL);break;

   403

			// Reference

   404

			case 1: length += 2; break;

   405

			// Array

   406

			case 2:	length += SlCalcArrayLen(NULL, *d++, conv); break;

   407

			default:NOT_REACHED();

   408

			}

   409

		} else if (cmd == 8) {

   410

			length++;

   411

			d += 4;

   412

		} else if (cmd == 9) {

   413

			length += SlCalcObjLength(NULL, _sl.includes[d[2]]);

   414

			d += 3;

   415

		} else if (cmd == 15)

   416

			break;

   417

		else

   418

			assert(0);

   419

	}

   420

	return length;

   421

}

   422

   423

void SlObject(void *object, const void *desc)

   424

{

   425

	const byte *d = (const byte*)desc;

   426

	void *ptr;

   427

	uint cmd,conv;

   428

   429

	// Automatically calculate the length?

   430

	if (_sl.need_length != NL_NONE) {

   431

		SlSetLength(SlCalcObjLength(object, d));

   432

		if (_sl.need_length == NL_CALCLENGTH)

   433

			return;

   434

	}

   435

   436

	while (true) {

   437

		// Currently it only supports up to 4096 byte big objects

   438

		ptr = (byte*)object + (d[0] & 0xF) + (d[1] << 4);

   439

   440

		cmd = d[0] >> 4;

   441

   442

		if (cmd < 8) {

   443

			conv = d[2];

   444

			d += 3;

   445

   446

			if (cmd&4) {

   447

				d += 2;

   448

				// check if the field is of the right version

   449

				if (_sl.version < d[-2] || _sl.version > d[-1]) {

   450

					if ((cmd & 3) == 2) d++;

   451

					continue;

   452

				}

   453

			}

   454

   455

			switch(cmd&3) {

   456

			// Normal variable

   457

			case 0:	SlSaveLoadConv(ptr, conv); break;

   458

			// Reference

   459

			case 1:

   460

				if (_sl.save) {

   461

					SlWriteUint16(_sl.ref_to_int_proc(*(void**)ptr, conv));

   462

				} else {

   463

					*(void**)ptr = _sl.int_to_ref_proc(SlReadUint16(), conv);

   464

				}

   465

				break;

   466

			// Array

   467

			case 2:	SlArray(ptr, *d++, conv); break;

   468

			default:NOT_REACHED();

   469

			}

   470

   471

		// Write byte.

   472

		} else if (cmd == 8) {

   473

			if (_sl.save) {

   474

				SlWriteByte(d[3]);

   475

			} else {

   476

				*(byte*)ptr = d[2];

   477

			}

   478

			d += 4;

   479

   480

		// Include

   481

		} else if (cmd == 9) {

   482

			SlObject(ptr, _sl.includes[d[2]]);

   483

			d += 3;

   484

		}	else if (cmd == 15)

   485

			break;

   486

		else

   487

			assert(0);

   488

	}

   489

}

   490

   491

   492

static size_t SlCalcGlobListLength(const SaveLoadGlobVarList *desc)

   493

{

   494

	size_t length = 0;

   495

   496

	while (desc->address) {

   497

		if(_sl.version >= desc->from_version && _sl.version <= desc->to_version)

   498

			length += SlCalcConvLen(desc->conv, NULL);

   499

		desc++;

   500

	}

   501

	return length;

   502

}

   503

   504

// Save/Load a list of global variables

   505

void SlGlobList(const SaveLoadGlobVarList *desc)

   506

{

   507

	if (_sl.need_length != NL_NONE) {

   508

		SlSetLength(SlCalcGlobListLength(desc));

   509

		if (_sl.need_length == NL_CALCLENGTH)

   510

			return;

   511

	}

   512

	while (true) {

   513

		void *ptr = desc->address;

   514

		if (ptr == NULL)

   515

			break;

   516

		if(_sl.version >= desc->from_version && _sl.version <= desc->to_version)

   517

			SlSaveLoadConv(ptr, desc->conv);

   518

		desc++;

   519

	}

   520

}

   521

   522

   523

void SlAutolength(AutolengthProc *proc, void *arg)