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 *ptr;

   192

	byte *base_ptr = base;

   193

	uint i;

   194

   195

	while (chunk->type != OC_END) {

   196

		ptr = chunk->ptr;

   197

   198

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

   199

			if (ls->failed) return false;

   200

   201

			/* Handle simple types */

   202

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

   203

				switch (GetOldChunkType(chunk->type)) {

   204

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

   205

					case OC_NULL: ReadByte(ls); break;

   206

   207

					case OC_CHUNK:

   208

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

   209

						 * are going to read */

   210

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

   211

						break;

   212

   213

					case OC_ASSERT:

   214

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

   215

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

   216

					default: break;

   217

				}

   218

			} else {

   219

				uint32 res = 0;

   220

   221

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

   222

				switch (GetOldChunkFileType(chunk->type)) {

   223

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

   224

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

   225

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

   226

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

   227

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

   228

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

   229

					default: NOT_REACHED();

   230

				}

   231

   232

				/* Sanity check */

   233

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

   234

   235

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

   236

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

   237

   238

				/* Write the data */

   239

				switch (GetOldChunkVarType(chunk->type)) {

   240

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

   241

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

   242

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

   243

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

   244

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

   245

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

   246

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

   247

					default: NOT_REACHED();

   248

				}

   249

   250

				/* Increase pointer base for arrays when looping */

   251

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

   252

			}

   253

		}

   254

   255

		chunk++;

   256

	}

   257

   258

	return true;

   259

}

   260

   261

/**

   262

 *

   263

 * Initialize some data before reading

   264

 *

   265

 */

   266

static void InitLoading(LoadgameState *ls)

   267

{

   268

	ls->chunk_size   = 0;

   269

	ls->total_read   = 0;

   270

	ls->failed       = false;

   271

   272

	ls->decoding     = false;

   273

	ls->decode_char  = 0;

   274

   275

	ls->buffer_cur   = 0;

   276

	ls->buffer_count = 0;

   277

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

   278

   279

	_bump_assert_value = 0;

   280

   281

	_read_ttdpatch_flags = false;

   282

}

   283

   284

   285

/*

   286

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

   287

 */

   288

   289

extern uint32 GetOldTownName(uint32 townnameparts, byte old_town_name_type);

   290

   291

static void FixOldTowns(void)

   292

{

   293

	Town *town;

   294

   295

	/* Convert town-names if needed */

   296

	FOR_ALL_TOWNS(town) {

   297

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

   298

   299

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

   300

			town->townnametype = SPECSTR_TOWNNAME_ENGLISH + _opt.town_name;

   301

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

   302

		}

   303

	}

   304

}

   305

   306

static void FixOldStations(void)

   307

{

   308

	Station *st;

   309

   310

	FOR_ALL_STATIONS(st) {

   311

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

   312

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

   313

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

   314

		}

   315

   316

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

   317

		if (st->bus_tile_obsolete != 0) {

   318

			st->bus_stops = AllocateRoadStop();

   319

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

   320

			st->bus_stops->used = true;

   321

			st->bus_stops->status = 3;

   322

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

   323

			st->bus_stops->next = NULL;

   324

			st->bus_stops->prev = NULL;

   325

			st->bus_stops->num_vehicles = 0;

   326

		}

   327

   328

		if (st->lorry_tile_obsolete != 0) {

   329

			st->truck_stops = AllocateRoadStop();

   330

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

   331

			st->truck_stops->used = true;

   332

			st->truck_stops->status = 3;

   333

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

   334

			st->truck_stops->next = NULL;

   335

			st->truck_stops->prev = NULL;

   336

			st->truck_stops->num_vehicles = 0;

   337

		}

   338

	}

   339

}

   340

   341

static void FixOldVehicles(void)

   342

{

   343

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

   344

	Vehicle* v;

   345

   346

	FOR_ALL_VEHICLES(v) {

   347

		Vehicle *u;

   348

   349

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

   350

   351

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

   352

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

   353

   354

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

   355

			 * in both vehicles */

   356

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

   357

				v->next_shared = u;

   358

				u->prev_shared = v;

   359

				break;

   360

			}

   361

		}

   362

	}

   363

}

   364

   365

/*

   366

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

   367

 */

   368

   369

   370

/* Help:

   371

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

   372

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

   373

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

   374

 *  - OCL_END: every struct must end with this

   375

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

   376

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

   377

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

   378

 */

   379

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

   380

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

   381

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

   382

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

   383

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

   384

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

   385

   386

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

   387

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

   388

   Old Towns are 94 bytes big

   389

   Old Orders are 2 bytes big */

   390

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

   391

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

   392

   393

extern TileIndex _animated_tile_list[256];

   394

extern char _name_array[512][32];

   395

extern uint16 _custom_sprites_base;

   396

   397

static byte   _old_vehicle_multiplier;

   398

static uint8  _old_map3[OLD_MAP_SIZE * 2];

   399

static bool   _new_ttdpatch_format;

   400

static uint32 _old_town_index;

   401

static uint16 _old_string_id;

   402

static uint16 _old_string_id_2;

   403

   404

static void ReadTTDPatchFlags(void)

   405

{

   406

	int i;

   407

   408

	if (_read_ttdpatch_flags) return;

   409

   410

	_read_ttdpatch_flags = true;

   411

   412

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

   413

	_old_vehicle_multiplier = _old_map3[0];

   414

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

   415

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

   416

	if (_old_vehicle_multiplier < 2) _old_vehicle_multiplier++;

   417

   418

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

   419

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

   420

	bump the assert value so it doesn't!

   421

	(1 multipler == 850 vehicles

   422

	1 vehicle   == 128 bytes */

   423

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

   424

   425

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

   426

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

   427

   428

	/* Clean the misused places */

   429

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

   430

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

   431

   432

	if (_new_ttdpatch_format)

   433

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

   434

   435

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

   436

}

   437

   438

static const OldChunks town_chunk[] = {

   439

	OCL_SVAR(   OC_TILE, Town, xy ),

   440

	OCL_SVAR( OC_FILE_U16 | OC_VAR_U32, Town, population ),

   441

	OCL_SVAR( OC_UINT16, Town, townnametype ),

   442

	OCL_SVAR( OC_UINT32, Town, townnameparts ),

   443

	OCL_SVAR(  OC_UINT8, Town, grow_counter ),

   444

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

   445

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

   446

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

   447

	OCL_SVAR( OC_UINT16, Town, flags12 ),

   448

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

   449

   450

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

   451

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

   452

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

   453

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

   454

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

   455

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

   456

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

   457

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

   458

   459

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

   460

	nothing changed?? */

   461

	OCL_SVAR( OC_FILE_U32 | OC_VAR_U8, Town, have_ratings ),

   462

	OCL_SVAR( OC_FILE_U32 | OC_VAR_U8, Town, statues ),

   463

	OCL_SVAR( OC_UINT16, Town, num_houses ),

   464

	OCL_SVAR(  OC_UINT8, Town, time_until_rebuild ),

   465

	OCL_SVAR(  OC_UINT8, Town, growth_rate ),

   466

   467

	OCL_SVAR( OC_UINT16, Town, new_max_pass ),

   468

	OCL_SVAR( OC_UINT16, Town, new_max_mail ),

   469

	OCL_SVAR( OC_UINT16, Town, new_act_pass ),

   470

	OCL_SVAR( OC_UINT16, Town, new_act_mail ),

   471

	OCL_SVAR( OC_UINT16, Town, max_pass ),

   472

	OCL_SVAR( OC_UINT16, Town, max_mail ),

   473

	OCL_SVAR( OC_UINT16, Town, act_pass ),

   474

	OCL_SVAR( OC_UINT16, Town, act_mail ),

   475

   476

	OCL_SVAR(  OC_UINT8, Town, pct_pass_transported ),

   477

	OCL_SVAR(  OC_UINT8, Town, pct_mail_transported ),

   478

   479

	OCL_SVAR( OC_UINT16, Town, new_act_food ),

   480

	OCL_SVAR( OC_UINT16, Town, new_act_water ),

   481

	OCL_SVAR( OC_UINT16, Town, act_food ),

   482

	OCL_SVAR( OC_UINT16, Town, act_water ),

   483

   484

	OCL_SVAR(  OC_UINT8, Town, road_build_months ),

   485

	OCL_SVAR(  OC_UINT8, Town, fund_buildings_months ),

   486

   487

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

   488

   489

	OCL_END()

   490