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

#include "network.h"

    19

#include "ai/ai.h"

    20

    21

enum {

    22

	HEADER_SIZE = 49,

    23

	BUFFER_SIZE = 4096,

    24

    25

	OLD_MAP_SIZE = 256 * 256

    26

};

    27

    28

typedef struct LoadgameState {

    29

	FILE *file;

    30

    31

	uint chunk_size;

    32

    33

	bool decoding;

    34

	byte decode_char;

    35

    36

	uint buffer_count;

    37

	uint buffer_cur;

    38

	byte buffer[BUFFER_SIZE];

    39

    40

	uint total_read;

    41

	bool failed;

    42

} LoadgameState;

    43

    44

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

    45

    46

typedef struct OldChunks {

    47

	uint32 type;         //! Type of field

    48

	uint32 amount;       //! Amount of fields

    49

    50

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

    51

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

    52

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

    53

} OldChunks;

    54

    55

/* OldChunk-Type */

    56

enum {

    57

	OC_END       = 0,

    58

	OC_NULL      = 1 << 0,

    59

	OC_CHUNK     = 1 << 1,

    60

	OC_ASSERT    = 1 << 2,

    61

    62

	OC_VAR_I8    = 1 << 9,

    63

	OC_VAR_U8    = 1 << 10,

    64

	OC_VAR_I16   = 1 << 11,

    65

	OC_VAR_U16   = 1 << 12,

    66

	OC_VAR_I32   = 1 << 13,

    67

	OC_VAR_U32   = 1 << 14,

    68

	OC_VAR_I64   = 1 << 15,

    69

    70

	OC_FILE_I8   = 1 << 17,

    71

	OC_FILE_U8   = 1 << 18,

    72

	OC_FILE_I16  = 1 << 19,

    73

	OC_FILE_U16  = 1 << 20,

    74

	OC_FILE_I32  = 1 << 21,

    75

	OC_FILE_U32  = 1 << 22,

    76

    77

	OC_INT8      = OC_VAR_I8   | OC_FILE_I8,

    78

	OC_UINT8     = OC_VAR_U8   | OC_FILE_U8,

    79

	OC_INT16     = OC_VAR_I16  | OC_FILE_I16,

    80

	OC_UINT16    = OC_VAR_U16  | OC_FILE_U16,

    81

	OC_INT32     = OC_VAR_I32  | OC_FILE_I32,

    82

	OC_UINT32    = OC_VAR_U32  | OC_FILE_U32,

    83

    84

	OC_TILE      = OC_VAR_U32  | OC_FILE_U16

    85

};

    86

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

    87

assert_compile(sizeof(TileIndex) == 4);

    88

    89

static uint32 _bump_assert_value;

    90

static bool   _read_ttdpatch_flags;

    91

    92

/**

    93

 *

    94

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

    95

 *

    96

 */

    97

static byte ReadByteFromFile(LoadgameState *ls)

    98

{

    99

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

   100

	and just return a byte per time */

   101

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

   102

		/* Read some new bytes from the file */

   103

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

   104

   105

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

   106

		if (count == 0) {

   107

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

   108

			ls->failed = true;

   109

		}

   110

   111

		ls->buffer_count = count;

   112

		ls->buffer_cur   = 0;

   113

	}

   114

   115

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

   116

}

   117

   118

/**

   119

 *

   120

 * Reads a byte from the buffer and decompress if needed

   121

 *

   122

 */

   123

static byte ReadByte(LoadgameState *ls)

   124

{

   125

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

   126

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

   127

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

   128

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

   129

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

   130

   131

	if (ls->chunk_size == 0) {

   132

		/* Read new chunk */

   133

		int8 new_byte = ReadByteFromFile(ls);

   134

   135

		if (new_byte < 0) {

   136

			/* Repeat next char for new_byte times */

   137

			ls->decoding    = true;

   138

			ls->decode_char = ReadByteFromFile(ls);

   139

			ls->chunk_size  = -new_byte + 1;

   140

		} else {

   141

			ls->decoding    = false;

   142

			ls->chunk_size  = new_byte + 1;

   143

		}

   144

	}

   145

   146

	ls->total_read++;

   147

	ls->chunk_size--;

   148

   149

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

   150

}

   151

   152

/**

   153

 *

   154

 * Loads a chunk from the old savegame

   155

 *

   156

 */

   157

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

   158

{

   159

	const OldChunks *chunk = chunks;

   160

	byte *ptr;

   161

	byte *base_ptr = base;

   162

	uint i;

   163

   164

	while (chunk->type != OC_END) {

   165

		ptr = chunk->ptr;

   166

   167

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

   168

			if (ls->failed)

   169

				return false;

   170

   171

			/* Handle simple types */

   172

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

   173

				switch (chunk->type & 0xFF) {

   174

					case OC_NULL:

   175

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

   176

						ReadByte(ls);

   177

						break;

   178

   179

					case OC_CHUNK:

   180

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

   181

						are going to read */

   182

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

   183

							return false;

   184

						break;

   185

   186

					case OC_ASSERT:

   187

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

   188

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

   189

							ls->failed = true;

   190

   191

						break;

   192

   193

				}

   194

			} else {

   195

				uint32 res = 0;

   196

   197

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

   198

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

   199

					case OC_FILE_I8:

   200

						res = ReadByte(ls);

   201

						res = (int8)res;

   202

						break;

   203

   204

					case OC_FILE_U8:

   205

						res = ReadByte(ls);

   206

						break;

   207

   208

					case OC_FILE_U16:

   209

						res =  ReadByte(ls);

   210

						res += ReadByte(ls) << 8;

   211

						break;

   212

   213

					case OC_FILE_I16:

   214

						res =  ReadByte(ls);

   215

						res += ReadByte(ls) << 8;

   216

						res = (int16)res;

   217

						break;

   218

   219

					case OC_FILE_U32:

   220

						res =  ReadByte(ls);

   221

						res += ReadByte(ls) << 8;

   222

						res += ReadByte(ls) << 16;

   223

						res += ReadByte(ls) << 24;

   224

						break;

   225

   226

					case OC_FILE_I32:

   227

						res =  ReadByte(ls);

   228

						res += ReadByte(ls) << 8;

   229

						res += ReadByte(ls) << 16;

   230

						res += ReadByte(ls) << 24;

   231

						res = (int32)res;

   232

						break;

   233

				}

   234

   235

				/* Sanity check */

   236

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

   237

   238

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

   239

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

   240

					case OC_VAR_I8:

   241

						/* Write the data */

   242

						if (chunk->ptr != NULL) {

   243

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

   244

							ptr++;

   245

						} else

   246

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

   247

							break;

   248

   249

					case OC_VAR_U8:

   250

						/* Write the data */

   251

						if (chunk->ptr != NULL) {

   252

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

   253

							ptr++;

   254

						} else

   255

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

   256

							break;

   257

   258

					case OC_VAR_U16:

   259

						/* Write the data */

   260

						if (chunk->ptr != NULL) {

   261

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

   262

							ptr += 2;

   263

						} else

   264

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

   265

							break;

   266

   267

					case OC_VAR_I16:

   268

						/* Write the data */

   269

						if (chunk->ptr != NULL) {

   270

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

   271

							ptr += 2;

   272

						} else

   273

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

   274

							break;

   275

   276

					case OC_VAR_U32:

   277

						/* Write the data */

   278

						if (chunk->ptr != NULL) {

   279

							*(uint32 *)ptr = res;

   280

							ptr += 4;

   281

						} else

   282

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

   283

							break;

   284

   285

					case OC_VAR_I32:

   286

						/* Write the data */

   287

						if (chunk->ptr != NULL) {

   288

							*(int32 *)ptr = res;

   289

							ptr += 4;

   290

						} else

   291

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

   292

							break;

   293

   294

					case OC_VAR_I64:

   295

						/* Write the data */

   296

						if (chunk->ptr != NULL) {

   297

							*(int64 *)ptr = res;

   298

							ptr += 8;

   299

						} else

   300

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

   301

							break;

   302

				}

   303

			}

   304

		}

   305

   306

		chunk++;

   307

	}

   308

   309

	return true;

   310

}

   311

   312

/**

   313

 *

   314

 * Initialize some data before reading

   315

 *

   316

 */

   317

static void InitLoading(LoadgameState *ls)

   318

{

   319

	ls->chunk_size   = 0;

   320

	ls->total_read   = 0;

   321

	ls->failed       = false;

   322

   323

	ls->decoding     = false;

   324

	ls->decode_char  = 0;

   325

   326

	ls->buffer_cur   = 0;

   327

	ls->buffer_count = 0;

   328

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

   329

   330

	_bump_assert_value = 0;

   331

   332

	_read_ttdpatch_flags = false;

   333

}

   334

   335

   336

/*

   337

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

   338

 */

   339

   340

extern uint32 GetOldTownName(uint32 townnameparts, byte old_town_name_type);

   341

   342

static void FixOldTowns(void)

   343

{

   344

	Town *town;

   345

   346

	/* Convert town-names if needed */

   347

	FOR_ALL_TOWNS(town) {

   348

		if (town->xy == 0)

   349

			continue;

   350

   351

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

   352

			town->townnametype = SPECSTR_TOWNNAME_ENGLISH + _opt.town_name;

   353

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

   354

		}

   355

	}

   356

}

   357

   358

static void FixOldStations(void)

   359

{

   360

	Station *st;

   361

   362

	FOR_ALL_STATIONS(st) {

   363

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

   364

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

   365

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

   366

		}

   367

   368

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

   369

		if (st->bus_tile_obsolete != 0) {

   370

			st->bus_stops = AllocateRoadStop();

   371

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

   372

			st->bus_stops->used = true;

   373

			st->bus_stops->status = 3;

   374

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

   375

			st->bus_stops->next = NULL;

   376

			st->bus_stops->prev = NULL;

   377

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

   378

		}

   379

   380

		if (st->lorry_tile_obsolete != 0) {

   381

			st->truck_stops = AllocateRoadStop();

   382

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

   383

			st->truck_stops->used = true;

   384

			st->truck_stops->status = 3;

   385

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

   386

			st->truck_stops->next = NULL;

   387

			st->truck_stops->prev = NULL;

   388

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

   389

		}

   390

	}

   391

}

   392

   393

static void FixOldVehicles(void)

   394

{

   395

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

   396

	{

   397

		Vehicle *v;

   398

   399

		FOR_ALL_VEHICLES(v) {

   400

			Vehicle *u;

   401

   402

			if (v->type == 0)

   403

				continue;

   404

   405

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

   406

				if (u->type == 0)

   407

					continue;

   408

   409

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

   410

				in both vehicles */

   411

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

   412

					v->next_shared = u;

   413

					u->prev_shared = v;

   414

					break;

   415

				}

   416

			}

   417

		}

   418

	}

   419

}

   420

   421

/*

   422

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

   423

 */

   424

   425

   426

/* Help:

   427

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

   428

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

   429

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

   430

 *  - OCL_END: every struct must end with this

   431

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

   432

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

   433

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

   434

 */

   435

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

   436

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

   437

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

   438

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

   439

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

   440

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

   441

   442

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

   443

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

   444

   Old Towns are 94 bytes big

   445

   Old Orders are 2 bytes big */

   446

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

   447

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

   448

   449

extern TileIndex _animated_tile_list[256];

   450

extern char _name_array[512][32];

   451

extern uint16 _custom_sprites_base;

   452

   453

static byte   _old_vehicle_multipler;

   454

static uint8  _old_map3[OLD_MAP_SIZE * 2];

   455

static bool   _new_ttdpatch_format;

   456

static uint32 _old_town_index;

   457

static uint16 _old_string_id;

   458

static uint16 _old_string_id_2;

   459

   460

static void ReadTTDPatchFlags(void)

   461

{

   462

	int i;

   463

   464

	if (_read_ttdpatch_flags)

   465

		return;

   466

   467

	_read_ttdpatch_flags = true;

   468

   469

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

   470

	_old_vehicle_multipler = _old_map3[0];

   471

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

   472

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

   473

	if (_old_vehicle_multipler < 2)

   474

		_old_vehicle_multipler++;

   475

   476

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

   477

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

   478

	bump the assert value so it doesn't!

   479

	(1 multipler == 850 vehicles

   480

	1 vehicle   == 128 bytes */

   481

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

   482

   483

	_new_ttdpatch_format   = false;

   484

   485

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

   486

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

   487

		_new_ttdpatch_format = true;

   488

   489

	/* Clean the misused places */

   490

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

   491

		_old_map3[i] = 0;

   492

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