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

#include "date.h"

    22

    23

enum {

    24

	HEADER_SIZE = 49,

    25

	BUFFER_SIZE = 4096,

    26

    27

	OLD_MAP_SIZE = 256 * 256

    28

};

    29

    30

typedef struct LoadgameState {

    31

	FILE *file;

    32

    33

	uint chunk_size;

    34

    35

	bool decoding;

    36

	byte decode_char;

    37

    38

	uint buffer_count;

    39

	uint buffer_cur;

    40

	byte buffer[BUFFER_SIZE];

    41

    42

	uint total_read;

    43

	bool failed;

    44

} LoadgameState;

    45

    46

/* OldChunk-Type */

    47

typedef enum OldChunkTypes {

    48

	OC_SIMPLE    = 0,

    49

	OC_NULL      = 1,

    50

	OC_CHUNK     = 2,

    51

	OC_ASSERT    = 3,

    52

	/* 8 bytes allocated (256 max) */

    53

    54

	OC_VAR_I8    = 1 << 8,

    55

	OC_VAR_U8    = 2 << 8,

    56

	OC_VAR_I16   = 3 << 8,

    57

	OC_VAR_U16   = 4 << 8,

    58

	OC_VAR_I32   = 5 << 8,

    59

	OC_VAR_U32   = 6 << 8,

    60

	OC_VAR_I64   = 7 << 8,

    61

	/* 8 bytes allocated (256 max) */

    62

    63

	OC_FILE_I8   = 1 << 16,

    64

	OC_FILE_U8   = 2 << 16,

    65

	OC_FILE_I16  = 3 << 16,

    66

	OC_FILE_U16  = 4 << 16,

    67

	OC_FILE_I32  = 5 << 16,

    68

	OC_FILE_U32  = 6 << 16,

    69

	/* 8 bytes allocated (256 max) */

    70

    71

	OC_INT8      = OC_VAR_I8   | OC_FILE_I8,

    72

	OC_UINT8     = OC_VAR_U8   | OC_FILE_U8,

    73

	OC_INT16     = OC_VAR_I16  | OC_FILE_I16,

    74

	OC_UINT16    = OC_VAR_U16  | OC_FILE_U16,

    75

	OC_INT32     = OC_VAR_I32  | OC_FILE_I32,

    76

	OC_UINT32    = OC_VAR_U32  | OC_FILE_U32,

    77

    78

	OC_TILE      = OC_VAR_U32  | OC_FILE_U16,

    79

    80

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

    81

} OldChunkType;

    82

    83

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

    84

    85

typedef struct OldChunks {

    86

	OldChunkType type;   ///< Type of field

    87

	uint32 amount;       ///< Amount of fields

    88

    89

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

    90

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

    91

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

    92

} OldChunks;

    93

    94

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

    95

assert_compile(sizeof(TileIndex) == 4);

    96

    97

static uint32 _bump_assert_value;

    98

static bool   _read_ttdpatch_flags;

    99

   100

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

   101

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

   102

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

   103

   104

static inline byte CalcOldVarLen(OldChunkType type)

   105

{

   106

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

   107

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

   108

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

   109

	return type_mem_size[length];

   110

}

   111

   112

/**

   113

 *

   114

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

   115

 *

   116

 */

   117

static byte ReadByteFromFile(LoadgameState *ls)

   118

{

   119

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

   120

	and just return a byte per time */

   121

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

   122

		/* Read some new bytes from the file */

   123

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

   124

   125

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

   126

		if (count == 0) {

   127

			DEBUG(oldloader, 0, "Read past end of file, loading failed");

   128

			ls->failed = true;

   129

		}

   130

   131

		ls->buffer_count = count;

   132

		ls->buffer_cur   = 0;

   133

	}

   134

   135

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

   136

}

   137

   138

/**

   139

 *

   140

 * Reads a byte from the buffer and decompress if needed

   141

 *

   142

 */

   143

static byte ReadByte(LoadgameState *ls)

   144

{

   145

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

   146

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

   147

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

   148

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

   149

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

   150

   151

	if (ls->chunk_size == 0) {

   152

		/* Read new chunk */

   153

		int8 new_byte = ReadByteFromFile(ls);

   154

   155

		if (new_byte < 0) {

   156

			/* Repeat next char for new_byte times */

   157

			ls->decoding    = true;

   158

			ls->decode_char = ReadByteFromFile(ls);

   159

			ls->chunk_size  = -new_byte + 1;

   160

		} else {

   161

			ls->decoding    = false;

   162

			ls->chunk_size  = new_byte + 1;

   163

		}

   164

	}

   165

   166

	ls->total_read++;

   167

	ls->chunk_size--;

   168

   169

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

   170

}

   171

   172

static inline uint16 ReadUint16(LoadgameState *ls)

   173

{

   174

	byte x = ReadByte(ls);

   175

	return x | ReadByte(ls) << 8;

   176

}

   177

   178

static inline uint32 ReadUint32(LoadgameState *ls)

   179

{

   180

	uint16 x = ReadUint16(ls);

   181

	return x | ReadUint16(ls) << 16;

   182

}

   183

   184

/**

   185

 *

   186

 * Loads a chunk from the old savegame

   187

 *

   188

 */

   189

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

   190

{

   191

	const OldChunks *chunk = chunks;

   192

	byte *base_ptr = base;

   193

   194

	while (chunk->type != OC_END) {

   195

		byte* ptr = chunk->ptr;

   196

		uint i;

   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, "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 (IS_INT_INSIDE(town->townnametype, 0x20C1, 0x20C3)) {

   298

			town->townnametype = SPECSTR_TOWNNAME_ENGLISH + _opt.town_name;

   299

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

   300

		}

   301

	}

   302

}

   303

   304

static void FixOldStations(void)

   305

{

   306

	Station *st;

   307

   308

	FOR_ALL_STATIONS(st) {

   309

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

   310

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

   311

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

   312

		}

   313

   314

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

   315

		if (st->bus_tile_obsolete != 0) {

   316

			st->bus_stops = AllocateRoadStop();

   317

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

   318

			st->bus_stops->used = true;

   319

			st->bus_stops->status = 3;

   320

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

   321

			st->bus_stops->next = NULL;

   322

			st->bus_stops->prev = NULL;

   323

			st->bus_stops->num_vehicles = 0;

   324

		}

   325

   326

		if (st->lorry_tile_obsolete != 0) {

   327

			st->truck_stops = AllocateRoadStop();

   328

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

   329

			st->truck_stops->used = true;

   330

			st->truck_stops->status = 3;

   331

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

   332

			st->truck_stops->next = NULL;

   333

			st->truck_stops->prev = NULL;

   334

			st->truck_stops->num_vehicles = 0;

   335

		}

   336

	}

   337

}

   338

   339

static void FixOldVehicles(void)

   340

{

   341

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

   342

	Vehicle* v;

   343

   344

	FOR_ALL_VEHICLES(v) {

   345

		Vehicle *u;

   346

   347

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

   348

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

   349

			 * in both vehicles */

   350

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

   351

				v->next_shared = u;

   352

				u->prev_shared = v;

   353

				break;

   354

			}

   355

		}

   356

	}

   357

}

   358

   359

/*

   360

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

   361

 */

   362

   363

   364

/* Help:

   365

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

   366

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

   367

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

   368

 *  - OCL_END: every struct must end with this

   369

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

   370

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

   371

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

   372

 */

   373

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

   374

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

   375

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

   376

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

   377

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

   378

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

   379

   380

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

   381

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

   382

   Old Towns are 94 bytes big

   383

   Old Orders are 2 bytes big */

   384

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

   385

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

   386

   387

extern TileIndex _animated_tile_list[256];

   388

extern char _name_array[512][32];

   389

   390

static byte   _old_vehicle_multiplier;

   391

static uint8  _old_map3[OLD_MAP_SIZE * 2];

   392

static bool   _new_ttdpatch_format;

   393

static uint32 _old_town_index;

   394

static uint16 _old_string_id;

   395

static uint16 _old_string_id_2;

   396

   397

static void ReadTTDPatchFlags(void)

   398

{

   399

	int i;

   400

   401

	if (_read_ttdpatch_flags) return;

   402

   403

	_read_ttdpatch_flags = true;

   404

   405

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

   406

	_old_vehicle_multiplier = _old_map3[0];

   407

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

   408

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

   409

	if (_old_vehicle_multiplier < 2) _old_vehicle_multiplier++;

   410

   411

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

   412

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

   413

	bump the assert value so it doesn't!

   414

	(1 multipler == 850 vehicles

   415

	1 vehicle   == 128 bytes */

   416

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

   417

   418

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

   419

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

   420

   421

	/* Clean the misused places */

   422

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

   423

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

   424

   425

	if (_new_ttdpatch_format) DEBUG(oldloader, 1, "Found TTDPatch game");

   426

   427

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

   428

}

   429

   430

static const OldChunks town_chunk[] = {

   431

	OCL_SVAR(   OC_TILE, Town, xy ),

   432

	OCL_SVAR( OC_FILE_U16 | OC_VAR_U32, Town, population ),

   433

	OCL_SVAR( OC_UINT16, Town, townnametype ),

   434

	OCL_SVAR( OC_UINT32, Town, townnameparts ),

   435

	OCL_SVAR(  OC_UINT8, Town, grow_counter ),

   436

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

   437

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

   438

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

   439

	OCL_SVAR( OC_UINT16, Town, flags12 ),

   440

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

   441

   442

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

   443

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

   444

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

   445

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

   446

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

   447

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

   448

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

   449

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

   450

   451

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

   452

	nothing changed?? */

   453

	OCL_SVAR( OC_FILE_U32 | OC_VAR_U8, Town, have_ratings ),

   454

	OCL_SVAR( OC_FILE_U32 | OC_VAR_U8, Town, statues ),

   455

	OCL_SVAR( OC_UINT16, Town, num_houses ),

   456

	OCL_SVAR(  OC_UINT8, Town, time_until_rebuild ),

   457

	OCL_SVAR(  OC_UINT8, Town, growth_rate ),

   458

   459

	OCL_SVAR( OC_UINT16, Town, new_max_pass ),

   460

	OCL_SVAR( OC_UINT16, Town, new_max_mail ),

   461

	OCL_SVAR( OC_UINT16, Town, new_act_pass ),

   462

	OCL_SVAR( OC_UINT16, Town, new_act_mail ),

   463

	OCL_SVAR( OC_UINT16, Town, max_pass ),

   464

	OCL_SVAR( OC_UINT16, Town, max_mail ),

   465

	OCL_SVAR( OC_UINT16, Town, act_pass ),

   466

	OCL_SVAR( OC_UINT16, Town, act_mail ),

   467

   468

	OCL_SVAR(  OC_UINT8, Town, pct_pass_transported ),

   469

	OCL_SVAR(  OC_UINT8, Town, pct_mail_transported ),

   470

   471

	OCL_SVAR( OC_UINT16, Town, new_act_food ),

   472

	OCL_SVAR( OC_UINT16, Town, new_act_water ),

   473

	OCL_SVAR( OC_UINT16, Town, act_food ),

   474

	OCL_SVAR( OC_UINT16, Town, act_water ),

   475

   476

	OCL_SVAR(  OC_UINT8, Town, road_build_months ),

   477

	OCL_SVAR(  OC_UINT8, Town, fund_buildings_months ),

   478

   479

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

   480

   481

	OCL_END()

   482

};

   483

static bool LoadOldTown(LoadgameState *ls, int num)

   484

{

   485

	if (!AddBlockIfNeeded(&_Town_pool, num))

   486

		error("Towns: failed loading savegame: too many towns");

   487

   488

	return LoadChunk(ls, GetTown(num), town_chunk);

   489

}