1

/* $Id$ */

     2

     3

#include "stdafx.h"

     4

#include "openttd.h"

     5

#include "table/strings.h"

     6

#include "functions.h"

     7

#include "map.h"

     8

#include "town.h"

     9

#include "industry.h"

    10

#include "station.h"

    11

#include "economy.h"

    12

#include "player.h"

    13

#include "engine.h"

    14

#include "vehicle.h"

    15

#include "signs.h"

    16

#include "debug.h"

    17

#include "depot.h"

    18

    19

enum {

    20

	HEADER_SIZE = 49,

    21

	BUFFER_SIZE = 4096,

    22

    23

	OLD_MAP_SIZE = 256 * 256

    24

};

    25

    26

typedef struct LoadgameState {

    27

	FILE *file;

    28

    29

	uint chunk_size;

    30

    31

	bool decoding;

    32

	byte decode_char;

    33

    34

	uint buffer_count;

    35

	uint buffer_cur;

    36

	byte buffer[BUFFER_SIZE];

    37

    38

	uint total_read;

    39

	bool failed;

    40

} LoadgameState;

    41

    42

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

    43

    44

typedef struct OldChunks {

    45

	uint32 type;         //! Type of field

    46

	uint32 amount;       //! Amount of fields

    47

    48

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

    49

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

    50

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

    51

} OldChunks;

    52

    53

/* OldChunk-Type */

    54

enum {

    55

	OC_END       = 0,

    56

	OC_NULL      = 1 << 0,

    57

	OC_CHUNK     = 1 << 1,

    58

	OC_ASSERT    = 1 << 2,

    59

    60

	OC_VAR_I8    = 1 << 9,

    61

	OC_VAR_U8    = 1 << 10,

    62

	OC_VAR_I16   = 1 << 11,

    63

	OC_VAR_U16   = 1 << 12,

    64

	OC_VAR_I32   = 1 << 13,

    65

	OC_VAR_U32   = 1 << 14,

    66

	OC_VAR_I64   = 1 << 15,

    67

    68

	OC_FILE_I8   = 1 << 17,

    69

	OC_FILE_U8   = 1 << 18,

    70

	OC_FILE_I16  = 1 << 19,

    71

	OC_FILE_U16  = 1 << 20,

    72

	OC_FILE_I32  = 1 << 21,

    73

	OC_FILE_U32  = 1 << 22,

    74

    75

	OC_INT8      = OC_VAR_I8   | OC_FILE_I8,

    76

	OC_UINT8     = OC_VAR_U8   | OC_FILE_U8,

    77

	OC_INT16     = OC_VAR_I16  | OC_FILE_I16,

    78

	OC_UINT16    = OC_VAR_U16  | OC_FILE_U16,

    79

	OC_INT32     = OC_VAR_I32  | OC_FILE_I32,

    80

	OC_UINT32    = OC_VAR_U32  | OC_FILE_U32,

    81

    82

	OC_TILE      = OC_VAR_U32  | OC_FILE_U16

    83

};

    84

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

    85

assert_compile(sizeof(TileIndex) == 4);

    86

    87

static uint32 _bump_assert_value;

    88

static bool   _read_ttdpatch_flags;

    89

    90

/**

    91

 *

    92

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

    93

 *

    94

 */

    95

static byte ReadByteFromFile(LoadgameState *ls)

    96

{

    97

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

    98

	and just return a byte per time */

    99

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

   100

		/* Read some new bytes from the file */

   101

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

   102

   103

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

   104

		if (count == 0) {

   105

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

   106

			ls->failed = true;

   107

		}

   108

   109

		ls->buffer_count = count;

   110

		ls->buffer_cur   = 0;

   111

	}

   112

   113

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

   114

}

   115

   116

/**

   117

 *

   118

 * Reads a byte from the buffer and decompress if needed

   119

 *

   120

 */

   121

static byte ReadByte(LoadgameState *ls)

   122

{

   123

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

   124

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

   125

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

   126

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

   127

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

   128

   129

	if (ls->chunk_size == 0) {

   130

		/* Read new chunk */

   131

		int8 new_byte = ReadByteFromFile(ls);

   132

   133

		if (new_byte < 0) {

   134

			/* Repeat next char for new_byte times */

   135

			ls->decoding    = true;

   136

			ls->decode_char = ReadByteFromFile(ls);

   137

			ls->chunk_size  = -new_byte + 1;

   138

		} else {

   139

			ls->decoding    = false;

   140

			ls->chunk_size  = new_byte + 1;

   141

		}

   142

	}

   143

   144

	ls->total_read++;

   145

	ls->chunk_size--;

   146

   147

	return ls->decoding ? ls->decode_char : ReadByteFromFile(ls);

   148

}

   149

   150

/**

   151

 *

   152

 * Loads a chunk from the old savegame

   153

 *

   154

 */

   155

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

   156

{

   157

	const OldChunks *chunk = chunks;

   158

	byte *ptr;

   159

	byte *base_ptr = base;

   160

	uint i;

   161

   162

	while (chunk->type != OC_END) {

   163

		ptr = chunk->ptr;

   164

   165

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

   166

			if (ls->failed)

   167

				return false;

   168

   169

			/* Handle simple types */

   170

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

   171

				switch (chunk->type & 0xFF) {

   172

					case OC_NULL:

   173

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

   174

						ReadByte(ls);

   175

						break;

   176

   177

					case OC_CHUNK:

   178

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

   179

						are going to read */

   180

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

   181

							return false;

   182

						break;

   183

   184

					case OC_ASSERT:

   185

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

   186

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

   187

							ls->failed = true;

   188

   189

						break;

   190

   191

				}

   192

			} else {

   193

				uint32 res = 0;

   194

   195

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

   196

				switch (GB(chunk->type, 16, 8) << 16) {

   197

					case OC_FILE_I8:

   198

						res = ReadByte(ls);

   199

						res = (int8)res;

   200

						break;

   201

   202

					case OC_FILE_U8:

   203

						res = ReadByte(ls);

   204

						break;

   205

   206

					case OC_FILE_U16:

   207

						res =  ReadByte(ls);

   208

						res += ReadByte(ls) << 8;

   209

						break;

   210

   211

					case OC_FILE_I16:

   212

						res =  ReadByte(ls);

   213

						res += ReadByte(ls) << 8;

   214

						res = (int16)res;

   215

						break;

   216

   217

					case OC_FILE_U32:

   218

						res =  ReadByte(ls);

   219

						res += ReadByte(ls) << 8;

   220

						res += ReadByte(ls) << 16;

   221

						res += ReadByte(ls) << 24;

   222

						break;

   223

   224

					case OC_FILE_I32:

   225

						res =  ReadByte(ls);

   226

						res += ReadByte(ls) << 8;

   227

						res += ReadByte(ls) << 16;

   228

						res += ReadByte(ls) << 24;

   229

						res = (int32)res;

   230

						break;

   231

				}

   232

   233

				/* Sanity check */

   234

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

   235

   236

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

   237

				switch (GB(chunk->type, 8, 8) << 8) {

   238

					case OC_VAR_I8:

   239

						/* Write the data */

   240

						if (chunk->ptr != NULL) {

   241

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

   242

							ptr++;

   243

						} else

   244

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

   245

							break;

   246

   247

					case OC_VAR_U8:

   248

						/* Write the data */

   249

						if (chunk->ptr != NULL) {

   250

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

   251

							ptr++;

   252

						} else

   253

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

   254

							break;

   255

   256

					case OC_VAR_U16:

   257

						/* Write the data */

   258

						if (chunk->ptr != NULL) {

   259

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

   260

							ptr += 2;

   261

						} else

   262

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

   263

							break;

   264

   265

					case OC_VAR_I16:

   266

						/* Write the data */

   267

						if (chunk->ptr != NULL) {

   268

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

   269

							ptr += 2;

   270

						} else

   271

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

   272

							break;

   273

   274

					case OC_VAR_U32:

   275

						/* Write the data */

   276

						if (chunk->ptr != NULL) {

   277

							*(uint32 *)ptr = res;

   278

							ptr += 4;

   279

						} else

   280

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

   281

							break;

   282

   283

					case OC_VAR_I32:

   284

						/* Write the data */

   285

						if (chunk->ptr != NULL) {

   286

							*(int32 *)ptr = res;

   287

							ptr += 4;

   288

						} else

   289

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

   290

							break;

   291

   292

					case OC_VAR_I64:

   293

						/* Write the data */

   294

						if (chunk->ptr != NULL) {

   295

							*(int64 *)ptr = res;

   296

							ptr += 8;

   297

						} else

   298

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

   299

							break;

   300

				}

   301

			}

   302

		}

   303

   304

		chunk++;

   305

	}

   306

   307

	return true;

   308

}

   309

   310

/**

   311

 *

   312

 * Initialize some data before reading

   313

 *

   314

 */

   315

static void InitLoading(LoadgameState *ls)

   316

{

   317

	ls->chunk_size   = 0;

   318

	ls->total_read   = 0;

   319

	ls->failed       = false;

   320

   321

	ls->decoding     = false;

   322

	ls->decode_char  = 0;

   323

   324

	ls->buffer_cur   = 0;

   325

	ls->buffer_count = 0;

   326

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

   327

   328

	_bump_assert_value = 0;

   329

   330

	_read_ttdpatch_flags = false;

   331

}

   332

   333

   334

/*

   335

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

   336

 */

   337

   338

extern uint32 GetOldTownName(uint32 townnameparts, byte old_town_name_type);

   339

   340

static void FixOldTowns(void)

   341

{

   342

	Town *town;

   343

   344

	/* Convert town-names if needed */

   345

	FOR_ALL_TOWNS(town) {

   346

		if (town->xy == 0)

   347

			continue;

   348

   349

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

   350

			town->townnametype = SPECSTR_TOWNNAME_ENGLISH + _opt.town_name;

   351

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

   352

		}

   353

	}

   354

}

   355

   356

static void FixOldStations(void)

   357

{

   358

	Station *st;

   359

   360

	FOR_ALL_STATIONS(st) {

   361

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

   362

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

   363

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

   364

		}

   365

   366

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

   367

		if (st->bus_tile_obsolete != 0) {

   368

			st->bus_stops = AllocateRoadStop();

   369

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

   370

			st->bus_stops->used = true;

   371

			st->bus_stops->status = 3;

   372

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

   373

			st->bus_stops->next = NULL;

   374

			st->bus_stops->prev = NULL;

   375

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

   376

		}

   377

   378

		if (st->lorry_tile_obsolete != 0) {

   379

			st->truck_stops = AllocateRoadStop();

   380

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

   381

			st->truck_stops->used = true;

   382

			st->truck_stops->status = 3;

   383

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

   384

			st->truck_stops->next = NULL;

   385

			st->truck_stops->prev = NULL;

   386

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

   387

		}

   388

	}

   389

}

   390

   391

static void FixOldVehicles(void)

   392

{

   393

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

   394

	{

   395

		Vehicle *v;

   396

   397

		FOR_ALL_VEHICLES(v) {

   398

			Vehicle *u;

   399

   400

			if (v->type == 0)

   401

				continue;

   402

   403

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

   404

				if (u->type == 0)

   405

					continue;

   406

   407

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

   408

				in both vehicles */

   409

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

   410

					v->next_shared = u;

   411

					u->prev_shared = v;

   412

					break;

   413

				}

   414

			}

   415

		}

   416

	}

   417

}

   418

   419

/*

   420

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

   421

 */

   422

   423

   424

/* Help:

   425

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

   426

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

   427

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

   428

 *  - OCL_END: every struct must end with this

   429

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

   430

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

   431

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

   432

 */

   433

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

   434

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

   435

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

   436

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

   437

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

   438

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

   439

   440

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

   441

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

   442

   Old Towns are 94 bytes big

   443

   Old Orders are 2 bytes big */

   444

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

   445

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

   446

   447

extern TileIndex _animated_tile_list[256];

   448

extern char _name_array[512][32];

   449

extern uint16 _custom_sprites_base;

   450

   451

static byte   _old_vehicle_multipler;

   452

static uint8  _old_map3[OLD_MAP_SIZE * 2];

   453

static bool   _new_ttdpatch_format;

   454

static uint32 _old_town_index;

   455

static uint16 _old_string_id;

   456

static uint16 _old_string_id_2;

   457

   458

void ReadTTDPatchFlags(void)

   459

{

   460

	int i;

   461

   462

	if (_read_ttdpatch_flags)

   463

		return;

   464

   465

	_read_ttdpatch_flags = true;

   466

   467

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

   468

	_old_vehicle_multipler = _old_map3[0];

   469

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

   470

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

   471

	if (_old_vehicle_multipler < 2)

   472

		_old_vehicle_multipler++;

   473

   474

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

   475

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

   476

	bump the assert value so it doesn't!

   477

	(1 multipler == 850 vehicles

   478

	1 vehicle   == 128 bytes */

   479

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

   480

   481

	_new_ttdpatch_format   = false;

   482

   483

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

   484

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

   485

		_new_ttdpatch_format = true;

   486

   487

	/* Clean the misused places */

   488

	for (i = 0; i < 17; i++)

   489

		_old_map3[i] = 0;

   490

	for (i = 0x1FE00; i < 0x20000; i++)

   491

		_old_map3[i] = 0;

   492