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 LoadgameState _ls;

    88

static uint32 _bump_assert_value;

    89

static bool   _read_ttdpatch_flags;

    90

    91

/**

    92

 *

    93

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

    94

 *

    95

 */

    96

static byte ReadByteFromFile(LoadgameState *ls)

    97

{

    98

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

    99

	and just return a byte per time */

   100

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

   101

		/* Read some new bytes from the file */

   102

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

   103

   104

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

   105

		if (count == 0) {

   106

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

   107

			ls->failed = true;

   108

		}

   109

   110

		ls->buffer_count = count;

   111

		ls->buffer_cur   = 0;

   112

	}

   113

   114

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

   115

}

   116

   117

/**

   118

 *

   119

 * Reads a byte from the buffer and decompress if needed

   120

 *

   121

 */

   122

static byte ReadByte(LoadgameState *ls)

   123

{

   124

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

   125

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

   126

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

   127

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

   128

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

   129

	int8 new_byte;

   130

   131

	/* Check if we are reading a chunk */

   132

	if (ls->chunk_size != 0) {

   133

		ls->total_read++;

   134

		ls->chunk_size--;

   135

   136

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

   137

		if (ls->decoding)

   138

			return ls->decode_char;

   139

   140

		/* Else return byte from file */

   141

		return ReadByteFromFile(ls);

   142

	}

   143

   144

	/* Read new chunk */

   145

	new_byte = ReadByteFromFile(ls);

   146

   147

	if (new_byte < 0) {

   148

		/* Repeat next char for new_byte times */

   149

		ls->decoding    = true;

   150

		ls->decode_char = ReadByteFromFile(ls);

   151

		ls->chunk_size  = -new_byte + 1;

   152

	} else {

   153

		ls->decoding    = false;

   154

		ls->chunk_size  = new_byte + 1;

   155

	}

   156

   157

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

   158

	return ReadByte(ls);

   159

}

   160

   161

/**

   162

 *

   163

 * Loads a chunk from the old savegame

   164

 *

   165

 */

   166

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

   167

{

   168

	const OldChunks *chunk = chunks;

   169

	byte *ptr;

   170

	byte *base_ptr = base;

   171

	uint i;

   172

   173

	while (chunk->type != OC_END) {

   174

		ptr = chunk->ptr;

   175

   176

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

   177

			if (ls->failed)

   178

				return false;

   179

   180

			/* Handle simple types */

   181

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

   182

				switch (chunk->type & 0xFF) {

   183

					case OC_NULL:

   184

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

   185

						ReadByte(ls);

   186

						break;

   187

   188

					case OC_CHUNK:

   189

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

   190

						are going to read */

   191

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

   192

							return false;

   193

						break;

   194

   195

					case OC_ASSERT:

   196

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

   197

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

   198

							ls->failed = true;

   199

   200

						break;

   201

   202

				}

   203

			} else {

   204

				uint32 res = 0;

   205

   206

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

   207

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

   208

					case OC_FILE_I8:

   209

						res = ReadByte(ls);

   210

						res = (int8)res;

   211

						break;

   212

   213

					case OC_FILE_U8:

   214

						res = ReadByte(ls);

   215

						break;

   216

   217

					case OC_FILE_U16:

   218

						res =  ReadByte(ls);

   219

						res += ReadByte(ls) << 8;

   220

						break;

   221

   222

					case OC_FILE_I16:

   223

						res =  ReadByte(ls);

   224

						res += ReadByte(ls) << 8;

   225

						res = (int16)res;

   226

						break;

   227

   228

					case OC_FILE_U32:

   229

						res =  ReadByte(ls);

   230

						res += ReadByte(ls) << 8;

   231

						res += ReadByte(ls) << 16;

   232

						res += ReadByte(ls) << 24;

   233

						break;

   234

   235

					case OC_FILE_I32:

   236

						res =  ReadByte(ls);

   237

						res += ReadByte(ls) << 8;

   238

						res += ReadByte(ls) << 16;

   239

						res += ReadByte(ls) << 24;

   240

						res = (int32)res;

   241

						break;

   242

				}

   243

   244

				/* Sanity check */

   245

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

   246

   247

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

   248

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

   249

					case OC_VAR_I8:

   250

						/* Write the data */

   251

						if (chunk->ptr != NULL) {

   252

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

   253

							ptr++;

   254

						} else

   255

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

   256

							break;

   257

   258

					case OC_VAR_U8:

   259

						/* Write the data */

   260

						if (chunk->ptr != NULL) {

   261

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

   262

							ptr++;

   263

						} else

   264

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

   265

							break;

   266

   267

					case OC_VAR_U16:

   268

						/* Write the data */

   269

						if (chunk->ptr != NULL) {

   270

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

   271

							ptr += 2;

   272

						} else

   273

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

   274

							break;

   275

   276

					case OC_VAR_I16:

   277

						/* Write the data */

   278

						if (chunk->ptr != NULL) {

   279

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

   280

							ptr += 2;

   281

						} else

   282

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

   283

							break;

   284

   285

					case OC_VAR_U32:

   286

						/* Write the data */

   287

						if (chunk->ptr != NULL) {

   288

							*(uint32 *)ptr = res;

   289

							ptr += 4;

   290

						} else

   291

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

   292

							break;

   293

   294

					case OC_VAR_I32:

   295

						/* Write the data */

   296

						if (chunk->ptr != NULL) {

   297

							*(int32 *)ptr = res;

   298

							ptr += 4;

   299

						} else

   300

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

   301

							break;

   302

   303

					case OC_VAR_I64:

   304

						/* Write the data */

   305

						if (chunk->ptr != NULL) {

   306

							*(int64 *)ptr = res;

   307

							ptr += 8;

   308

						} else

   309

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

   310

							break;

   311

				}

   312

			}

   313

		}

   314

   315

		chunk++;

   316

	}

   317

   318

	return true;

   319

}

   320

   321

/**

   322

 *

   323

 * Initialize some data before reading

   324

 *

   325

 */

   326

static void InitLoading(LoadgameState *ls)

   327

{

   328

	ls->chunk_size   = 0;

   329

	ls->total_read   = 0;

   330

	ls->failed       = false;

   331

   332

	ls->decoding     = false;

   333

	ls->decode_char  = 0;

   334

   335

	ls->buffer_cur   = 0;

   336

	ls->buffer_count = 0;

   337

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

   338

   339

	_bump_assert_value = 0;

   340

   341

	_read_ttdpatch_flags = false;

   342

}

   343

   344

   345

/*

   346

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

   347

 */

   348

   349

extern uint32 GetOldTownName(uint32 townnameparts, byte old_town_name_type);

   350

   351

static void FixOldTowns(void)

   352

{

   353

	Town *town;

   354

   355

	/* Convert town-names if needed */

   356

	FOR_ALL_TOWNS(town) {

   357

		if (town->xy == 0)

   358

			continue;

   359

   360

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

   361

			town->townnametype = SPECSTR_TOWNNAME_ENGLISH + _opt.town_name;

   362

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

   363

		}

   364

	}

   365

}

   366

   367

static void FixOldStations(void)

   368

{

   369

	Station *st;

   370

   371

	FOR_ALL_STATIONS(st) {

   372

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

   373

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

   374

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

   375

		}

   376

   377

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

   378

		if (st->bus_tile_obsolete != 0) {

   379

			st->bus_stops = AllocateRoadStop();

   380

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

   381

			st->bus_stops->used = true;

   382

			st->bus_stops->status = 3;

   383

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

   384

			st->bus_stops->next = NULL;

   385

			st->bus_stops->prev = NULL;

   386

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

   387

		}

   388

   389

		if (st->lorry_tile_obsolete != 0) {

   390

			st->truck_stops = AllocateRoadStop();

   391

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

   392

			st->truck_stops->used = true;

   393

			st->truck_stops->status = 3;

   394

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

   395

			st->truck_stops->next = NULL;

   396

			st->truck_stops->prev = NULL;

   397

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

   398

		}

   399

	}

   400

}

   401

   402

static void FixOldVehicles(void)

   403

{

   404

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

   405

	{

   406

		Vehicle *v;

   407

   408

		FOR_ALL_VEHICLES(v) {

   409

			Vehicle *u;

   410

   411

			if (v->type == 0)

   412

				continue;

   413

   414

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

   415

				if (u->type == 0)

   416

					continue;

   417

   418

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

   419

				in both vehicles */

   420

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

   421

					v->next_shared = u;

   422

					u->prev_shared = v;

   423

					break;

   424

				}

   425

			}

   426

		}

   427

	}

   428

}

   429

   430

/*

   431

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

   432

 */

   433

   434

   435

/* Help:

   436

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

   437

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

   438

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

   439

 *  - OCL_END: every struct must end with this

   440

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

   441

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

   442

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

   443

 */

   444

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

   445

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

   446

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

   447

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

   448

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

   449

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

   450

   451

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

   452

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

   453

   Old Towns are 94 bytes big

   454

   Old Orders are 2 bytes big */

   455

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

   456

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

   457

   458

extern TileIndex _animated_tile_list[256];

   459

extern char _name_array[512][32];

   460

extern uint16 _custom_sprites_base;

   461

   462

static byte   _old_vehicle_multipler;

   463

static uint8  _old_map3[OLD_MAP_SIZE * 2];

   464

static bool   _new_ttdpatch_format;

   465

static uint32 _old_town_index;

   466

static uint16 _old_string_id;

   467

static uint16 _old_string_id_2;

   468

   469

void ReadTTDPatchFlags(void)

   470

{

   471

	int i;

   472

   473

	if (_read_ttdpatch_flags)

   474

		return;

   475

   476

	_read_ttdpatch_flags = true;

   477

   478

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

   479

	_old_vehicle_multipler = _old_map3[0];

   480

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

   481

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

   482

	if (_old_vehicle_multipler < 2)

   483

		_old_vehicle_multipler++;

   484

   485

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

   486

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

   487

	bump the assert value so it doesn't!

   488

	(1 multipler == 850 vehicles

   489

	1 vehicle   == 128 bytes */

   490

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

   491

   492

	_new_ttdpatch_format   = false;

   493