1

#include "stdafx.h"

     2

#include "openttd.h"

     3

#include "table/strings.h"

     4

#include "map.h"

     5

#include "town.h"

     6

#include "industry.h"

     7

#include "station.h"

     8

#include "economy.h"

     9

#include "player.h"

    10

#include "engine.h"

    11

#include "vehicle.h"

    12

#include "signs.h"

    13

#include "debug.h"

    14

#include "depot.h"

    15

    16

enum {

    17

	HEADER_SIZE = 49,

    18

	BUFFER_SIZE = 4096,

    19

    20

	OLD_MAP_SIZE = 256 * 256

    21

};

    22

    23

typedef struct LoadgameState {

    24

	FILE *file;

    25

    26

	uint chunk_size;

    27

    28

	bool decoding;

    29

	byte decode_char;

    30

    31

	uint buffer_count;

    32

	uint buffer_cur;

    33

	byte buffer[BUFFER_SIZE];

    34

    35

	uint total_read;

    36

	bool failed;

    37

} LoadgameState;

    38

    39

typedef bool OldChunkProc(LoadgameState *ls, int num);

    40

    41

typedef struct OldChunks {

    42

	uint32 type;         //! Type of field

    43

	uint32 amount;       //! Amount of fields

    44

    45

	void *ptr;           //! Pointer where to save the data (may only be set if offset is 0)

    46

	uint offset;         //! Offset from basepointer (may only be set if ptr is NULL)

    47

	OldChunkProc *proc;  //! Pointer to function that is called with OC_CHUNK

    48

} OldChunks;

    49

    50

/* OldChunk-Type */

    51

enum {

    52

	OC_END       = 0,

    53

	OC_NULL      = 1 << 0,

    54

	OC_CHUNK     = 1 << 1,

    55

	OC_ASSERT    = 1 << 2,

    56

    57

	OC_VAR_I8    = 1 << 9,

    58

	OC_VAR_U8    = 1 << 10,

    59

	OC_VAR_I16   = 1 << 11,

    60

	OC_VAR_U16   = 1 << 12,

    61

	OC_VAR_I32   = 1 << 13,

    62

	OC_VAR_U32   = 1 << 14,

    63

	OC_VAR_I64   = 1 << 15,

    64

    65

	OC_FILE_I8   = 1 << 17,

    66

	OC_FILE_U8   = 1 << 18,

    67

	OC_FILE_I16  = 1 << 19,

    68

	OC_FILE_U16  = 1 << 20,

    69

	OC_FILE_I32  = 1 << 21,

    70

	OC_FILE_U32  = 1 << 22,

    71

    72

	OC_INT8      = OC_VAR_I8   | OC_FILE_I8,

    73

	OC_UINT8     = OC_VAR_U8   | OC_FILE_U8,

    74

	OC_INT16     = OC_VAR_I16  | OC_FILE_I16,

    75

	OC_UINT16    = OC_VAR_U16  | OC_FILE_U16,

    76

	OC_INT32     = OC_VAR_I32  | OC_FILE_I32,

    77

	OC_UINT32    = OC_VAR_U32  | OC_FILE_U32,

    78

    79

	OC_TILE      = OC_VAR_U32  | OC_FILE_U16

    80

};

    81

/* If it fails, check lines above.. */

    82

assert_compile(sizeof(TileIndex) == 4);

    83

    84

static LoadgameState _ls;

    85

static uint32 _bump_assert_value;

    86

static bool   _read_ttdpatch_flags;

    87

    88

/**

    89

 *

    90

 * Reads a byte from a file (do not call yourself, use ReadByte())

    91

 *

    92

 */

    93

static byte ReadByteFromFile(LoadgameState *ls)

    94

{

    95

	/* To avoid slow reads, we read BUFFER_SIZE of bytes per time

    96

	and just return a byte per time */

    97

	if (ls->buffer_cur >= ls->buffer_count) {

    98

		/* Read some new bytes from the file */

    99

		int count = fread(ls->buffer, 1, BUFFER_SIZE, ls->file);

   100

   101

		/* We tried to read, but there is nothing in the file anymore.. */

   102

		if (count == 0) {

   103

			DEBUG(oldloader, 1)("[OldLoader] Read past end of file, loading failed");

   104

			ls->failed = true;

   105

		}

   106

   107

		ls->buffer_count = count;

   108

		ls->buffer_cur   = 0;

   109

	}

   110

   111

	return ls->buffer[ls->buffer_cur++];

   112

}

   113

   114

/**

   115

 *

   116

 * Reads a byte from the buffer and decompress if needed

   117

 *

   118

 */

   119

static byte ReadByte(LoadgameState *ls)

   120

{

   121

	/* Old savegames have a nice compression algorithm (RLE)

   122

	which means that we have a chunk, which starts with a length

   123

	byte. If that byte is negative, we have to repeat the next byte

   124

	that many times (+1). Else, we need to read that amount of bytes.

   125

	Works pretty good if you have many zero's behind eachother */

   126

	int8 new_byte;

   127

   128

	/* Check if we are reading a chunk */

   129

	if (ls->chunk_size != 0) {

   130

		ls->total_read++;

   131

		ls->chunk_size--;

   132

   133

		/* If we are decoding, return the decode_char */

   134

		if (ls->decoding)

   135

			return ls->decode_char;

   136

   137

		/* Else return byte from file */

   138

		return ReadByteFromFile(ls);

   139

	}

   140

   141

	/* Read new chunk */

   142

	new_byte = ReadByteFromFile(ls);

   143

   144

	if (new_byte < 0) {

   145

		/* Repeat next char for new_byte times */

   146

		ls->decoding    = true;

   147

		ls->decode_char = ReadByteFromFile(ls);

   148

		ls->chunk_size  = -new_byte + 1;

   149

	} else {

   150

		ls->decoding    = false;

   151

		ls->chunk_size  = new_byte + 1;

   152

	}

   153

   154

	/* Call this function again to return a byte */

   155

	return ReadByte(ls);

   156

}

   157

   158

/**

   159

 *

   160

 * Loads a chunk from the old savegame

   161

 *

   162

 */

   163

static bool LoadChunk(LoadgameState *ls, void *base, const OldChunks *chunks)

   164

{

   165

	const OldChunks *chunk = chunks;

   166

	byte *ptr;

   167

	byte *base_ptr = base;

   168

	uint i;

   169

   170

	while (chunk->type != OC_END) {

   171

		ptr = chunk->ptr;

   172

   173

		for (i = 0; i < chunk->amount; i++) {

   174

			if (ls->failed)

   175

				return false;

   176

   177

			/* Handle simple types */

   178

			if ((chunk->type & 0xFF) != 0) {

   179

				switch (chunk->type & 0xFF) {

   180

					case OC_NULL:

   181

						/* Just read the byte and forget about it */

   182

						ReadByte(ls);

   183

						break;

   184

   185

					case OC_CHUNK:

   186

						/* Call function, with 'i' as parameter to tell which item we

   187

						are going to read */

   188

						if (!chunk->proc(ls, i))

   189

							return false;

   190

						break;

   191

   192

					case OC_ASSERT:

   193

						DEBUG(oldloader, 4)("[OldLoader] Assert point: %x / %x", ls->total_read, chunk->offset + _bump_assert_value);

   194

						if (ls->total_read != chunk->offset + _bump_assert_value)

   195

							ls->failed = true;

   196

   197

						break;

   198

   199

				}

   200

			} else {

   201

				uint32 res = 0;

   202

   203

				/* Reading from the file: bit 16 to 23 have the FILE */

   204

				switch (((chunk->type >> 16) & 0xFF) << 16) {

   205

					case OC_FILE_I8:

   206

						res = ReadByte(ls);

   207

						res = (int8)res;

   208

						break;

   209

   210

					case OC_FILE_U8:

   211

						res = ReadByte(ls);

   212

						break;

   213

   214

					case OC_FILE_U16:

   215

						res =  ReadByte(ls);

   216

						res += ReadByte(ls) << 8;

   217

						break;

   218

   219

					case OC_FILE_I16:

   220

						res =  ReadByte(ls);

   221

						res += ReadByte(ls) << 8;

   222

						res = (int16)res;

   223

						break;

   224

   225

					case OC_FILE_U32:

   226

						res =  ReadByte(ls);

   227

						res += ReadByte(ls) << 8;

   228

						res += ReadByte(ls) << 16;

   229

						res += ReadByte(ls) << 24;

   230

						break;

   231

   232

					case OC_FILE_I32:

   233

						res =  ReadByte(ls);

   234

						res += ReadByte(ls) << 8;

   235

						res += ReadByte(ls) << 16;

   236

						res += ReadByte(ls) << 24;

   237

						res = (int32)res;

   238

						break;

   239

				}

   240

   241

				/* Sanity check */

   242

				assert(base_ptr != NULL || chunk->ptr != NULL);

   243

   244

				/* Writing to the var: bit 8 till 15 have the VAR */

   245

				switch (((chunk->type >> 8) & 0xFF) << 8) {

   246

					case OC_VAR_I8:

   247

						/* Write the data */

   248

						if (chunk->ptr != NULL) {

   249

							*(int8 *)ptr = res & 0xFF;

   250

							ptr++;

   251

						} else

   252

							*(int8 *)(base_ptr + chunk->offset) = res & 0xFF;

   253

							break;

   254

   255

					case OC_VAR_U8:

   256

						/* Write the data */

   257

						if (chunk->ptr != NULL) {

   258

							*(uint8 *)ptr = res & 0xFF;

   259

							ptr++;

   260

						} else

   261

							*(uint8 *)(base_ptr + chunk->offset) = res & 0xFF;

   262

							break;

   263

   264

					case OC_VAR_U16:

   265

						/* Write the data */

   266

						if (chunk->ptr != NULL) {

   267

							*(uint16 *)ptr = res & 0xFFFF;

   268

							ptr += 2;

   269

						} else

   270

							*(uint16 *)(base_ptr + chunk->offset) = res & 0xFFFF;

   271

							break;

   272

   273

					case OC_VAR_I16:

   274

						/* Write the data */

   275

						if (chunk->ptr != NULL) {

   276

							*(int16 *)ptr = res & 0xFFFF;

   277

							ptr += 2;

   278

						} else

   279

							*(int16 *)(base_ptr + chunk->offset) = res & 0xFFFF;

   280

							break;

   281

   282

					case OC_VAR_U32:

   283

						/* Write the data */

   284

						if (chunk->ptr != NULL) {

   285

							*(uint32 *)ptr = res;

   286

							ptr += 4;

   287

						} else

   288

							*(uint32 *)(base_ptr + chunk->offset) = res;

   289

							break;

   290

   291

					case OC_VAR_I32:

   292

						/* Write the data */

   293

						if (chunk->ptr != NULL) {

   294

							*(int32 *)ptr = res;

   295

							ptr += 4;

   296

						} else

   297

							*(int32 *)(base_ptr + chunk->offset) = res;

   298

							break;

   299

   300

					case OC_VAR_I64:

   301

						/* Write the data */

   302

						if (chunk->ptr != NULL) {

   303

							*(int64 *)ptr = res;

   304

							ptr += 8;

   305

						} else

   306

							*(int64 *)(base_ptr + chunk->offset) = res;

   307

							break;

   308

				}

   309

			}

   310

		}

   311

   312

		chunk++;

   313

	}

   314

   315

	return true;

   316

}

   317

   318

/**

   319

 *

   320

 * Initialize some data before reading

   321

 *

   322

 */

   323

static void InitLoading(LoadgameState *ls)

   324

{

   325

	ls->chunk_size   = 0;

   326

	ls->total_read   = 0;

   327

	ls->failed       = false;

   328

   329

	ls->decoding     = false;

   330

	ls->decode_char  = 0;

   331

   332

	ls->buffer_cur   = 0;

   333

	ls->buffer_count = 0;

   334

	memset(ls->buffer, 0, BUFFER_SIZE);

   335

   336

	_bump_assert_value = 0;

   337

   338

	_read_ttdpatch_flags = false;

   339

}

   340

   341

   342

/*

   343

 * Begin -- Stuff to fix the savegames to be OpenTTD compatible

   344

 */

   345

   346

extern uint32 GetOldTownName(uint32 townnameparts, byte old_town_name_type);

   347

   348

static void FixOldTowns(void)

   349

{

   350

	Town *town;

   351

   352

	/* Convert town-names if needed */

   353

	FOR_ALL_TOWNS(town) {

   354

		if (town->xy == 0)

   355

			continue;

   356

   357

		if (IS_INT_INSIDE(town->townnametype, 0x20C1, 0x20C3)) {

   358

			town->townnametype = SPECSTR_TOWNNAME_ENGLISH + _opt.town_name;

   359

			town->townnameparts = GetOldTownName(town->townnameparts, _opt.town_name);

   360

		}

   361

	}

   362

}

   363

   364

static void FixOldStations(void)

   365

{

   366

	Station *st;

   367

   368

	FOR_ALL_STATIONS(st) {

   369

		/* Check if we need to swap width and height for the station */

   370

		if (st->train_tile != 0 && _m[st->train_tile].m5 & 1) {

   371

			swap_byte(&st->trainst_w, &st->trainst_h);

   372

		}

   373

   374

		/* Check if there is a bus or truck station, and convert to new format */

   375

		if (st->bus_tile_obsolete != 0) {

   376

			st->bus_stops = AllocateRoadStop();

   377

			st->bus_stops->xy = st->bus_tile_obsolete;

   378

			st->bus_stops->used = true;

   379

			st->bus_stops->status = 3;

   380

			st->bus_stops->station = st->index;

   381

			st->bus_stops->next = NULL;

   382

			st->bus_stops->prev = NULL;

   383

			st->bus_stops->slot[0] = st->bus_stops->slot[1] = INVALID_SLOT;

   384

		}

   385

   386

		if (st->lorry_tile_obsolete != 0) {

   387

			st->truck_stops = AllocateRoadStop();

   388

			st->truck_stops->xy = st->lorry_tile_obsolete;

   389

			st->truck_stops->used = true;

   390

			st->truck_stops->status = 3;

   391

			st->truck_stops->station = st->index;

   392

			st->truck_stops->next = NULL;

   393

			st->truck_stops->prev = NULL;

   394

			st->truck_stops->slot[0] = st->truck_stops->slot[1] = INVALID_SLOT;

   395

		}

   396

	}

   397

}

   398

   399

static void FixOldVehicles(void)

   400

{

   401

	/* Check for shared orders, and link them correctly */

   402

	{

   403

		Vehicle *v;

   404

   405

		FOR_ALL_VEHICLES(v) {

   406

			Vehicle *u;

   407

   408

			if (v->type == 0)

   409

				continue;

   410

   411

			FOR_ALL_VEHICLES_FROM(u, v->index + 1) {

   412

				if (u->type == 0)

   413

					continue;

   414

   415

					/* If a vehicle has the same orders, add the link to eachother

   416

				in both vehicles */

   417

				if (v->orders == u->orders) {

   418

					v->next_shared = u;

   419

					u->prev_shared = v;

   420

					break;

   421

				}

   422

			}

   423

		}

   424

	}

   425

}

   426

   427

/*

   428

 * End -- Stuff to fix the savegames to be OpenTTD compatible

   429

 */

   430

   431

   432

/* Help:

   433

 *  - OCL_SVAR: load 'type' to offset 'offset' in a struct of type 'base', which must also

   434

 *       be given via base in LoadChunk() as real pointer

   435

 *  - OCL_VAR: load 'type' to a global var

   436

 *  - OCL_END: every struct must end with this

   437

 *  - OCL_NULL: read 'amount' of bytes and send them to /dev/null or something

   438

 *  - OCL_CHUNK: load an other proc to load a part of the savegame, 'amount' times

   439

 *  - OCL_ASSERT: to check if we are really at the place we expect to be.. because old savegames are too binary to be sure ;)

   440

 */

   441

#define OCL_SVAR(type, base, offset)         { type,          1, NULL,    offsetof(base, offset), NULL }

   442

#define OCL_VAR(type, amount, pointer)       { type,     amount, pointer, 0,                      NULL }

   443

#define OCL_END()                                   { OC_END,        0, NULL,    0,                      NULL }

   444

#define OCL_NULL(amount)                            { OC_NULL,  amount, NULL,    0,                      NULL }

   445

#define OCL_CHUNK(amount, proc)                     { OC_CHUNK, amount, NULL,    0,                      proc }

   446

#define OCL_ASSERT(size)                            { OC_ASSERT,     1, NULL, size,                      NULL }

   447

   448

/* The savegames has some hard-coded pointers, because it always enters the same

   449

    piece of memory.. we don't.. so we need to remap ;)

   450

   Old Towns are 94 bytes big

   451

   Old Orders are 2 bytes big */

   452

#define REMAP_TOWN_IDX(x) ((x) - (0x0459154 - 0x0458EF0)) / 94

   453

#define REMAP_ORDER_IDX(x) ((x) - (0x045AB08 - 0x0458EF0)) / 2

   454

   455

extern TileIndex _animated_tile_list[256];

   456

extern char _name_array[512][32];

   457

extern uint16 _custom_sprites_base;

   458

   459

static byte   _old_vehicle_multipler;

   460

static uint8  _old_map3[OLD_MAP_SIZE * 2];

   461

static bool   _new_ttdpatch_format;

   462

static uint32 _old_town_index;

   463

static uint16 _old_string_id;

   464

static uint16 _old_string_id_2;

   465

   466

void ReadTTDPatchFlags(void)

   467

{

   468

	int i;

   469

   470

	if (_read_ttdpatch_flags)

   471

		return;

   472

   473

	_read_ttdpatch_flags = true;

   474

   475

	/* TTDPatch misuses _old_map3 for flags.. read them! */

   476

	_old_vehicle_multipler = _old_map3[0];

   477

	/* Somehow.... there was an error in some savegames, so 0 becomes 1

   478

	and 1 becomes 2. The rest of the values are okay */

   479

	if (_old_vehicle_multipler < 2)

   480

		_old_vehicle_multipler++;

   481

   482

	/* TTDPatch incraeses the Vehicle-part in the middle of the game,

   483

	so if the multipler is anything else but 1, the assert fails..

   484

	bump the assert value so it doesn't!

   485

	(1 multipler == 850 vehicles

   486

	1 vehicle   == 128 bytes */

   487

	_bump_assert_value = (_old_vehicle_multipler - 1) * 850 * 128;

   488

   489

	_new_ttdpatch_format   = false;

   490

   491

	/* Check if we have a modern TTDPatch savegame (has extra data all around) */

   492

	if (memcmp(&_old_map3[0x1FFFA], "TTDp", 4) == 0)

   493

		_new_ttdpatch_format = true;