1

/* $Id$ */

     2

     3

#include "stdafx.h"

     4

#include "openttd.h"

     5

#include "station_map.h"

     6

#include "table/strings.h"

     7

#include "functions.h"

     8

#include "map.h"

     9

#include "town.h"

    10

#include "industry.h"

    11

#include "station.h"

    12

#include "economy.h"

    13

#include "player.h"

    14

#include "engine.h"

    15

#include "vehicle.h"

    16

#include "signs.h"

    17

#include "debug.h"

    18

#include "depot.h"

    19

#include "network.h"

    20

#include "ai/ai.h"

    21

    22

enum {

    23

	HEADER_SIZE = 49,

    24

	BUFFER_SIZE = 4096,

    25

    26

	OLD_MAP_SIZE = 256 * 256

    27

};

    28

    29

typedef struct LoadgameState {

    30

	FILE *file;

    31

    32

	uint chunk_size;

    33

    34

	bool decoding;

    35

	byte decode_char;

    36

    37

	uint buffer_count;

    38

	uint buffer_cur;

    39

	byte buffer[BUFFER_SIZE];

    40

    41

	uint total_read;

    42

	bool failed;

    43

} LoadgameState;

    44

    45

/* OldChunk-Type */

    46

typedef enum OldChunkTypes {

    47

	OC_SIMPLE    = 0,

    48

	OC_NULL      = 1,

    49

	OC_CHUNK     = 2,

    50

	OC_ASSERT    = 3,

    51

	/* 8 bytes allocated (256 max) */

    52

    53

	OC_VAR_I8    = 1 << 8,

    54

	OC_VAR_U8    = 2 << 8,

    55

	OC_VAR_I16   = 3 << 8,

    56

	OC_VAR_U16   = 4 << 8,

    57

	OC_VAR_I32   = 5 << 8,

    58

	OC_VAR_U32   = 6 << 8,

    59

	OC_VAR_I64   = 7 << 8,

    60

	/* 8 bytes allocated (256 max) */

    61

    62

	OC_FILE_I8   = 1 << 16,

    63

	OC_FILE_U8   = 2 << 16,

    64

	OC_FILE_I16  = 3 << 16,

    65

	OC_FILE_U16  = 4 << 16,

    66

	OC_FILE_I32  = 5 << 16,

    67

	OC_FILE_U32  = 6 << 16,

    68

	/* 8 bytes allocated (256 max) */

    69

    70

	OC_INT8      = OC_VAR_I8   | OC_FILE_I8,

    71

	OC_UINT8     = OC_VAR_U8   | OC_FILE_U8,

    72

	OC_INT16     = OC_VAR_I16  | OC_FILE_I16,

    73

	OC_UINT16    = OC_VAR_U16  | OC_FILE_U16,

    74

	OC_INT32     = OC_VAR_I32  | OC_FILE_I32,

    75

	OC_UINT32    = OC_VAR_U32  | OC_FILE_U32,

    76

    77

	OC_TILE      = OC_VAR_U32  | OC_FILE_U16,

    78

    79

	OC_END       = 0 ///< End of the whole chunk, all 32bits set to zero

    80

} OldChunkType;

    81

    82

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

    83

    84

typedef struct OldChunks {

    85

	OldChunkType type;   ///< Type of field

    86

	uint32 amount;       ///< Amount of fields

    87

    88

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

    89

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

    90

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

    91

} OldChunks;

    92

    93

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

    94

assert_compile(sizeof(TileIndex) == 4);

    95

    96

static uint32 _bump_assert_value;

    97

static bool   _read_ttdpatch_flags;

    98

    99

static OldChunkType GetOldChunkType(OldChunkType type)     {return GB(type, 0, 8);}

   100

static OldChunkType GetOldChunkVarType(OldChunkType type)  {return GB(type, 8, 8) << 8;}

   101

static OldChunkType GetOldChunkFileType(OldChunkType type) {return GB(type, 16, 8) << 16;}

   102

   103

static inline byte CalcOldVarLen(OldChunkType type)

   104

{

   105

	static const byte type_mem_size[] = {0, 1, 1, 2, 2, 4, 4, 8};

   106

	byte length = GB(type, 8, 8);

   107

	assert(length != 0 && length < lengthof(type_mem_size));

   108

	return type_mem_size[length];

   109

}

   110

   111

/**

   112

 *

   113

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

   114

 *

   115

 */

   116

static byte ReadByteFromFile(LoadgameState *ls)

   117

{

   118

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

   119

	and just return a byte per time */

   120

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

   121

		/* Read some new bytes from the file */

   122

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

   123

   124

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

   125

		if (count == 0) {

   126

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

   127

			ls->failed = true;

   128

		}

   129

   130

		ls->buffer_count = count;

   131

		ls->buffer_cur   = 0;

   132

	}

   133

   134

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

   135

}

   136

   137

/**

   138

 *

   139

 * Reads a byte from the buffer and decompress if needed

   140

 *

   141

 */

   142

static byte ReadByte(LoadgameState *ls)

   143

{

   144

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

   145

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

   146

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

   147

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

   148

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

   149

   150

	if (ls->chunk_size == 0) {

   151

		/* Read new chunk */

   152

		int8 new_byte = ReadByteFromFile(ls);

   153

   154

		if (new_byte < 0) {

   155

			/* Repeat next char for new_byte times */

   156

			ls->decoding    = true;

   157

			ls->decode_char = ReadByteFromFile(ls);

   158

			ls->chunk_size  = -new_byte + 1;

   159

		} else {

   160

			ls->decoding    = false;

   161

			ls->chunk_size  = new_byte + 1;

   162

		}

   163

	}

   164

   165

	ls->total_read++;

   166

	ls->chunk_size--;

   167

   168

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

   169

}

   170

   171

static inline uint16 ReadUint16(LoadgameState *ls)

   172

{

   173

	byte x = ReadByte(ls);

   174

	return x | ReadByte(ls) << 8;

   175

}

   176

   177

static inline uint32 ReadUint32(LoadgameState *ls)

   178

{

   179

	uint16 x = ReadUint16(ls);

   180

	return x | ReadUint16(ls) << 16;

   181

}

   182

   183

/**

   184

 *

   185

 * Loads a chunk from the old savegame

   186

 *

   187

 */

   188

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

   189

{

   190

	const OldChunks *chunk = chunks;

   191

	byte *base_ptr = base;

   192

   193

	while (chunk->type != OC_END) {

   194

		byte* ptr = chunk->ptr;

   195

		uint i;

   196

   197

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

   198

			if (ls->failed) return false;

   199

   200

			/* Handle simple types */

   201

			if (GetOldChunkType(chunk->type) != 0) {

   202

				switch (GetOldChunkType(chunk->type)) {

   203

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

   204

					case OC_NULL: ReadByte(ls); break;

   205

   206

					case OC_CHUNK:

   207

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

   208

						 * are going to read */

   209

						if (!chunk->proc(ls, i)) return false;

   210

						break;

   211

   212

					case OC_ASSERT:

   213

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

   214

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

   215

					default: break;

   216

				}

   217

			} else {

   218

				uint32 res = 0;

   219

   220

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

   221

				switch (GetOldChunkFileType(chunk->type)) {

   222

					case OC_FILE_I8:  res = (int8)ReadByte(ls); break;

   223

					case OC_FILE_U8:  res = ReadByte(ls); break;

   224

					case OC_FILE_I16: res = (int16)ReadUint16(ls); break;

   225

					case OC_FILE_U16: res = ReadUint16(ls); break;

   226

					case OC_FILE_I32: res = (int32)ReadUint32(ls); break;

   227

					case OC_FILE_U32: res = ReadUint32(ls); break;

   228

					default: NOT_REACHED();

   229

				}

   230

   231

				/* Sanity check */

   232

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

   233

   234

				/* Writing to the var: bits 8 to 15 have the VAR type */

   235

				if (chunk->ptr == NULL) ptr = base_ptr + chunk->offset;

   236

   237

				/* Write the data */

   238

				switch (GetOldChunkVarType(chunk->type)) {

   239

					case OC_VAR_I8: *(int8  *)ptr = GB(res, 0, 8); break;

   240

					case OC_VAR_U8: *(uint8 *)ptr = GB(res, 0, 8); break;

   241

					case OC_VAR_I16:*(int16 *)ptr = GB(res, 0, 16); break;

   242

					case OC_VAR_U16:*(uint16*)ptr = GB(res, 0, 16); break;

   243

					case OC_VAR_I32:*(int32 *)ptr = res; break;

   244

					case OC_VAR_U32:*(uint32*)ptr = res; break;

   245

					case OC_VAR_I64:*(int64 *)ptr = res; break;

   246

					default: NOT_REACHED();

   247

				}

   248

   249

				/* Increase pointer base for arrays when looping */

   250

				if (chunk->amount > 1 && chunk->ptr != NULL) ptr += CalcOldVarLen(chunk->type);

   251

			}

   252

		}

   253

   254

		chunk++;

   255

	}

   256

   257

	return true;

   258

}

   259

   260

/**

   261

 *

   262

 * Initialize some data before reading

   263

 *

   264

 */

   265

static void InitLoading(LoadgameState *ls)

   266

{

   267

	ls->chunk_size   = 0;

   268

	ls->total_read   = 0;

   269

	ls->failed       = false;

   270

   271

	ls->decoding     = false;

   272

	ls->decode_char  = 0;

   273

   274

	ls->buffer_cur   = 0;

   275

	ls->buffer_count = 0;

   276

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

   277

   278

	_bump_assert_value = 0;

   279

   280

	_read_ttdpatch_flags = false;

   281

}

   282

   283

   284

/*

   285

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

   286

 */

   287

   288

extern uint32 GetOldTownName(uint32 townnameparts, byte old_town_name_type);

   289

   290

static void FixOldTowns(void)

   291

{

   292

	Town *town;

   293

   294

	/* Convert town-names if needed */

   295

	FOR_ALL_TOWNS(town) {

   296

		if (town->xy == 0) continue;

   297

   298

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

   299

			town->townnametype = SPECSTR_TOWNNAME_ENGLISH + _opt.town_name;

   300

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

   301

		}

   302

	}

   303

}

   304

   305

static void FixOldStations(void)

   306

{

   307

	Station *st;

   308

   309

	FOR_ALL_STATIONS(st) {

   310

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

   311

		if (st->train_tile != 0 && GetRailStationAxis(st->train_tile) != AXIS_X) {

   312

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

   313

		}

   314

   315

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

   316

		if (st->bus_tile_obsolete != 0) {

   317

			st->bus_stops = AllocateRoadStop();

   318

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

   319

			st->bus_stops->used = true;

   320

			st->bus_stops->status = 3;

   321

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

   322

			st->bus_stops->next = NULL;

   323

			st->bus_stops->prev = NULL;

   324

			st->bus_stops->num_vehicles = 0;

   325

		}

   326

   327

		if (st->lorry_tile_obsolete != 0) {

   328

			st->truck_stops = AllocateRoadStop();

   329

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

   330

			st->truck_stops->used = true;

   331

			st->truck_stops->status = 3;

   332

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

   333

			st->truck_stops->next = NULL;

   334

			st->truck_stops->prev = NULL;

   335

			st->truck_stops->num_vehicles = 0;

   336

		}

   337

	}

   338

}

   339

   340

static void FixOldVehicles(void)

   341

{

   342

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

   343

	Vehicle* v;

   344

   345

	FOR_ALL_VEHICLES(v) {

   346

		Vehicle *u;

   347

   348

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

   349

   350

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

   351

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

   352

   353

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

   354

			 * in both vehicles */

   355

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

   356

				v->next_shared = u;

   357

				u->prev_shared = v;

   358

				break;

   359

			}

   360

		}

   361

	}

   362

}

   363

   364

/*

   365

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

   366

 */

   367

   368

   369

/* Help:

   370

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

   371

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

   372

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

   373

 *  - OCL_END: every struct must end with this

   374

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

   375

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

   376

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

   377

 */

   378

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

   379

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

   380

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

   381

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

   382

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

   383

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

   384

   385

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

   386

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

   387

   Old Towns are 94 bytes big

   388

   Old Orders are 2 bytes big */

   389

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

   390

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

   391

   392

extern TileIndex _animated_tile_list[256];

   393

extern char _name_array[512][32];

   394

   395

static byte   _old_vehicle_multiplier;

   396

static uint8  _old_map3[OLD_MAP_SIZE * 2];

   397

static bool   _new_ttdpatch_format;

   398

static uint32 _old_town_index;

   399

static uint16 _old_string_id;

   400

static uint16 _old_string_id_2;

   401

   402

static void ReadTTDPatchFlags(void)

   403

{

   404

	int i;

   405

   406

	if (_read_ttdpatch_flags) return;

   407

   408

	_read_ttdpatch_flags = true;

   409

   410

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

   411

	_old_vehicle_multiplier = _old_map3[0];

   412

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

   413

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

   414

	if (_old_vehicle_multiplier < 2) _old_vehicle_multiplier++;

   415

   416

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

   417

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

   418

	bump the assert value so it doesn't!

   419

	(1 multipler == 850 vehicles

   420

	1 vehicle   == 128 bytes */

   421

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

   422

   423

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

   424

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

   425

   426

	/* Clean the misused places */

   427

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

   428

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

   429

   430

	if (_new_ttdpatch_format)

   431

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

   432

   433

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

   434

}

   435

   436

static const OldChunks town_chunk[] = {

   437

	OCL_SVAR(   OC_TILE, Town, xy ),

   438

	OCL_SVAR( OC_FILE_U16 | OC_VAR_U32, Town, population ),

   439

	OCL_SVAR( OC_UINT16, Town, townnametype ),

   440

	OCL_SVAR( OC_UINT32, Town, townnameparts ),

   441

	OCL_SVAR(  OC_UINT8, Town, grow_counter ),

   442

	OCL_NULL( 1 ),         // sort_index,        no longer in use

   443

	OCL_NULL( 4 ),         // sign-coordinates,  no longer in use

   444

	OCL_NULL( 2 ),         // namewidth,         no longer in use

   445

	OCL_SVAR( OC_UINT16, Town, flags12 ),

   446

	OCL_NULL( 10 ),        // radius,            no longer in use

   447

   448

	OCL_SVAR( OC_UINT16, Town, ratings[0] ),

   449

	OCL_SVAR( OC_UINT16, Town, ratings[1] ),

   450

	OCL_SVAR( OC_UINT16, Town, ratings[2] ),

   451

	OCL_SVAR( OC_UINT16, Town, ratings[3] ),

   452

	OCL_SVAR( OC_UINT16, Town, ratings[4] ),

   453

	OCL_SVAR( OC_UINT16, Town, ratings[5] ),

   454

	OCL_SVAR( OC_UINT16, Town, ratings[6] ),

   455

	OCL_SVAR( OC_UINT16, Town, ratings[7] ),

   456

   457

	/* XXX - This is pretty odd.. we read 32bit, but only write 8bit.. sure there is

   458

	nothing changed?? */

   459

	OCL_SVAR( OC_FILE_U32 | OC_VAR_U8, Town, have_ratings ),

   460

	OCL_SVAR( OC_FILE_U32 | OC_VAR_U8, Town, statues ),

   461

	OCL_SVAR( OC_UINT16, Town, num_houses ),

   462

	OCL_SVAR(  OC_UINT8, Town, time_until_rebuild ),

   463

	OCL_SVAR(  OC_UINT8, Town, growth_rate ),

   464

   465

	OCL_SVAR( OC_UINT16, Town, new_max_pass ),

   466

	OCL_SVAR( OC_UINT16, Town, new_max_mail ),

   467

	OCL_SVAR( OC_UINT16, Town, new_act_pass ),

   468

	OCL_SVAR( OC_UINT16, Town, new_act_mail ),

   469

	OCL_SVAR( OC_UINT16, Town, max_pass ),

   470

	OCL_SVAR( OC_UINT16, Town, max_mail ),

   471

	OCL_SVAR( OC_UINT16, Town, act_pass ),

   472

	OCL_SVAR( OC_UINT16, Town, act_mail ),

   473

   474

	OCL_SVAR(  OC_UINT8, Town, pct_pass_transported ),

   475

	OCL_SVAR(  OC_UINT8, Town, pct_mail_transported ),

   476

   477

	OCL_SVAR( OC_UINT16, Town, new_act_food ),

   478

	OCL_SVAR( OC_UINT16, Town, new_act_water ),

   479

	OCL_SVAR( OC_UINT16, Town, act_food ),

   480

	OCL_SVAR( OC_UINT16, Town, act_water ),

   481

   482

	OCL_SVAR(  OC_UINT8, Town, road_build_months ),

   483

	OCL_SVAR(  OC_UINT8, Town, fund_buildings_months ),

   484

   485

	OCL_NULL( 8 ),         // some junk at the end of the record

   486

   487

	OCL_END()

   488

};

   489

static bool LoadOldTown(LoadgameState *ls, int num)

   490