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

   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;

   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;

   387

		}

   388

	}

   389

}

   390

   391

static void FixOldVehicles(void)

   392

{

   393

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

   394

	Vehicle* v;

   395

   396

	FOR_ALL_VEHICLES(v) {

   397

		Vehicle* u;

   398

   399

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

   400

   401

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

   402

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

   403

   404

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

   405

			 * in both vehicles */

   406

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

   407

				v->next_shared = u;

   408

				u->prev_shared = v;

   409

				break;

   410

			}

   411

		}

   412

	}

   413

}

   414

   415

/*

   416

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

   417

 */

   418

   419

   420

/* Help:

   421

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

   422

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

   423

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

   424

 *  - OCL_END: every struct must end with this

   425

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

   426

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

   427

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

   428

 */

   429

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

   430

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

   431

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

   432

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

   433

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

   434

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

   435

   436

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

   437

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

   438

   Old Towns are 94 bytes big

   439

   Old Orders are 2 bytes big */

   440

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

   441

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

   442

   443

extern TileIndex _animated_tile_list[256];

   444

extern char _name_array[512][32];

   445

extern uint16 _custom_sprites_base;

   446

   447

static byte   _old_vehicle_multipler;

   448

static uint8  _old_map3[OLD_MAP_SIZE * 2];

   449

static bool   _new_ttdpatch_format;

   450

static uint32 _old_town_index;

   451

static uint16 _old_string_id;

   452

static uint16 _old_string_id_2;

   453

   454

static void ReadTTDPatchFlags(void)

   455

{

   456

	int i;

   457

   458

	if (_read_ttdpatch_flags) return;

   459

   460

	_read_ttdpatch_flags = true;

   461

   462

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

   463

	_old_vehicle_multipler = _old_map3[0];

   464

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

   465

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

   466

	if (_old_vehicle_multipler < 2) _old_vehicle_multipler++;

   467

   468

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

   469

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

   470

	bump the assert value so it doesn't!

   471

	(1 multipler == 850 vehicles

   472

	1 vehicle   == 128 bytes */

   473

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

   474

   475

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

   476

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

   477

   478

	/* Clean the misused places */

   479

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

   480

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

   481

   482

	if (_new_ttdpatch_format)

   483

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

   484

   485

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

   486

}

   487

   488

static const OldChunks town_chunk[] = {

   489

	OCL_SVAR(   OC_TILE, Town, xy ),

   490

	OCL_SVAR( OC_FILE_U16 | OC_VAR_U32, Town, population ),