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)) return false;

   183

						break;

   184

   185

					case OC_ASSERT:

   186

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

   187

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

   188

							ls->failed = true;

   189

						}

   190

						break;

   191

   192

				}

   193

			} else {

   194

				uint32 res = 0;

   195

   196

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

   197

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

   198

					case OC_FILE_I8:

   199

						res = ReadByte(ls);

   200

						res = (int8)res;

   201

						break;

   202

   203

					case OC_FILE_U8:

   204

						res = ReadByte(ls);

   205

						break;

   206

   207

					case OC_FILE_U16:

   208

						res =  ReadByte(ls);

   209

						res += ReadByte(ls) << 8;

   210

						break;

   211

   212

					case OC_FILE_I16:

   213

						res =  ReadByte(ls);

   214

						res += ReadByte(ls) << 8;

   215

						res = (int16)res;

   216

						break;

   217

   218

					case OC_FILE_U32:

   219

						res =  ReadByte(ls);

   220

						res += ReadByte(ls) << 8;

   221

						res += ReadByte(ls) << 16;

   222

						res += ReadByte(ls) << 24;

   223

						break;

   224

   225

					case OC_FILE_I32:

   226

						res =  ReadByte(ls);

   227

						res += ReadByte(ls) << 8;

   228

						res += ReadByte(ls) << 16;

   229

						res += ReadByte(ls) << 24;

   230

						res = (int32)res;

   231

						break;

   232

				}

   233

   234

				/* Sanity check */

   235

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

   236

   237

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

   238

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

   239

					case OC_VAR_I8:

   240

						/* Write the data */

   241

						if (chunk->ptr != NULL) {

   242

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

   243

							ptr++;

   244

						} else

   245

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

   246

							break;

   247

   248

					case OC_VAR_U8:

   249

						/* Write the data */

   250

						if (chunk->ptr != NULL) {

   251

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

   252

							ptr++;

   253

						} else

   254

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

   255

							break;

   256

   257

					case OC_VAR_U16:

   258

						/* Write the data */

   259

						if (chunk->ptr != NULL) {

   260

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

   261

							ptr += 2;

   262

						} else

   263

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

   264

							break;

   265

   266

					case OC_VAR_I16:

   267

						/* Write the data */

   268

						if (chunk->ptr != NULL) {

   269

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

   270

							ptr += 2;

   271

						} else

   272

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

   273

							break;

   274

   275

					case OC_VAR_U32:

   276

						/* Write the data */

   277

						if (chunk->ptr != NULL) {

   278

							*(uint32 *)ptr = res;

   279

							ptr += 4;

   280

						} else

   281

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

   282

							break;

   283

   284

					case OC_VAR_I32:

   285

						/* Write the data */

   286

						if (chunk->ptr != NULL) {

   287

							*(int32 *)ptr = res;

   288

							ptr += 4;

   289

						} else

   290

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

   291

							break;

   292

   293

					case OC_VAR_I64:

   294

						/* Write the data */

   295

						if (chunk->ptr != NULL) {

   296

							*(int64 *)ptr = res;

   297

							ptr += 8;

   298

						} else

   299

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

   300

							break;

   301

				}

   302

			}

   303

		}

   304

   305

		chunk++;

   306

	}

   307

   308

	return true;

   309

}

   310

   311

/**

   312

 *

   313

 * Initialize some data before reading

   314

 *

   315

 */

   316

static void InitLoading(LoadgameState *ls)

   317

{

   318

	ls->chunk_size   = 0;

   319

	ls->total_read   = 0;

   320

	ls->failed       = false;

   321

   322

	ls->decoding     = false;

   323

	ls->decode_char  = 0;

   324

   325

	ls->buffer_cur   = 0;

   326

	ls->buffer_count = 0;

   327

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

   328

   329

	_bump_assert_value = 0;

   330

   331

	_read_ttdpatch_flags = false;

   332

}

   333

   334

   335

/*

   336

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

   337

 */

   338

   339

extern uint32 GetOldTownName(uint32 townnameparts, byte old_town_name_type);

   340

   341

static void FixOldTowns(void)

   342

{

   343

	Town *town;

   344

   345

	/* Convert town-names if needed */

   346

	FOR_ALL_TOWNS(town) {

   347

		if (town->xy == 0) 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

	int i;

   360

   361

	FOR_ALL_STATIONS(st) {

   362

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

   363

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

   364

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

   365

		}

   366

   367

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

   368

		if (st->bus_tile_obsolete != 0) {

   369

			st->bus_stops = AllocateRoadStop();

   370

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

   371

			st->bus_stops->used = true;

   372

			st->bus_stops->status = 3;

   373

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

   374

			st->bus_stops->next = NULL;

   375

			st->bus_stops->prev = NULL;

   376

			for (i = 0; i < NUM_SLOTS; i++) st->bus_stops->slot[i] = INVALID_VEHICLE;

   377

		}

   378

   379

		if (st->lorry_tile_obsolete != 0) {

   380

			st->truck_stops = AllocateRoadStop();

   381

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

   382

			st->truck_stops->used = true;

   383

			st->truck_stops->status = 3;

   384

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

   385

			st->truck_stops->next = NULL;

   386

			st->truck_stops->prev = NULL;

   387

			for (i = 0; i < NUM_SLOTS; i++) st->truck_stops->slot[i] = INVALID_VEHICLE;

   388

		}

   389

	}

   390

}

   391

   392

static void FixOldVehicles(void)

   393

{

   394

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

   395

	Vehicle* v;

   396

   397

	FOR_ALL_VEHICLES(v) {

   398

		Vehicle* u;

   399

   400

		if (v->type == 0) continue;

   401

   402

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

   403

			if (u->type == 0) continue;

   404

   405

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

   406

			 * in both vehicles */

   407

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

   408

				v->next_shared = u;

   409

				u->prev_shared = v;

   410

				break;

   411

			}

   412

		}

   413

	}

   414

}

   415

   416

/*

   417

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

   418

 */

   419

   420

   421

/* Help:

   422

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

   423

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

   424

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

   425

 *  - OCL_END: every struct must end with this

   426

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

   427

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

   428

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

   429

 */

   430

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

   431

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

   432

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

   433

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

   434

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

   435

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

   436

   437

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

   438

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

   439

   Old Towns are 94 bytes big

   440

   Old Orders are 2 bytes big */

   441

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

   442

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

   443

   444

extern TileIndex _animated_tile_list[256];

   445

extern char _name_array[512][32];

   446

extern uint16 _custom_sprites_base;

   447

   448

static byte   _old_vehicle_multipler;

   449

static uint8  _old_map3[OLD_MAP_SIZE * 2];

   450

static bool   _new_ttdpatch_format;

   451

static uint32 _old_town_index;

   452

static uint16 _old_string_id;

   453

static uint16 _old_string_id_2;

   454

   455

static void ReadTTDPatchFlags(void)

   456

{

   457

	int i;

   458

   459

	if (_read_ttdpatch_flags) return;

   460

   461

	_read_ttdpatch_flags = true;

   462

   463

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

   464

	_old_vehicle_multipler = _old_map3[0];

   465

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

   466

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

   467

	if (_old_vehicle_multipler < 2) _old_vehicle_multipler++;

   468

   469

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

   470

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

   471

	bump the assert value so it doesn't!

   472

	(1 multipler == 850 vehicles

   473

	1 vehicle   == 128 bytes */

   474

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

   475

   476

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

   477

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

   478

   479

	/* Clean the misused places */

   480

	for (i = 0;       i < 17;      i++) _old_map3[i] = 0;

   481

	for (i = 0x1FE00; i < 0x20000; i++) _old_map3[i] = 0;

   482

   483

	if (_new_ttdpatch_format)

   484

		DEBUG(oldloader, 1)("[OldLoader] Found TTDPatch game");

   485

   486

	DEBUG(oldloader, 1)("[OldLoader] Vehicle-multipler is set to %d (%d vehicles)", _old_vehicle_multipler, _old_vehicle_multipler * 850);

   487

}

   488

   489

static const OldChunks town_chunk[] = {

   490

	OCL_SVAR(   OC_TILE, Town, xy ),