1

/* $Id$ */

     2

     3

/** @file oldloader.cpp */

     4

     5

#include "stdafx.h"

     6

#include "openttd.h"

     7

#include "station_map.h"

     8

#include "table/strings.h"

     9

#include "functions.h"

    10

#include "map.h"

    11

#include "town.h"

    12

#include "industry.h"

    13

#include "station.h"

    14

#include "economy.h"

    15

#include "player.h"

    16

#include "engine.h"

    17

#include "vehicle.h"

    18

#include "signs.h"

    19

#include "debug.h"

    20

#include "depot.h"

    21

#include "network/network.h"

    22

#include "ai/ai.h"

    23

#include "date.h"

    24

    25

enum {

    26

	HEADER_SIZE = 49,

    27

	BUFFER_SIZE = 4096,

    28

    29

	OLD_MAP_SIZE = 256 * 256

    30

};

    31

    32

struct LoadgameState {

    33

	FILE *file;

    34

    35

	uint chunk_size;

    36

    37

	bool decoding;

    38

	byte decode_char;

    39

    40

	uint buffer_count;

    41

	uint buffer_cur;

    42

	byte buffer[BUFFER_SIZE];

    43

    44

	uint total_read;

    45

	bool failed;

    46

};

    47

    48

/* OldChunk-Type */

    49

enum OldChunkType {

    50

	OC_SIMPLE    = 0,

    51

	OC_NULL      = 1,

    52

	OC_CHUNK     = 2,

    53

	OC_ASSERT    = 3,

    54

	/* 8 bytes allocated (256 max) */

    55

    56

	OC_VAR_I8    = 1 << 8,

    57

	OC_VAR_U8    = 2 << 8,

    58

	OC_VAR_I16   = 3 << 8,

    59

	OC_VAR_U16   = 4 << 8,

    60

	OC_VAR_I32   = 5 << 8,

    61

	OC_VAR_U32   = 6 << 8,

    62

	OC_VAR_I64   = 7 << 8,

    63

	/* 8 bytes allocated (256 max) */

    64

    65

	OC_FILE_I8   = 1 << 16,

    66

	OC_FILE_U8   = 2 << 16,

    67

	OC_FILE_I16  = 3 << 16,

    68

	OC_FILE_U16  = 4 << 16,

    69

	OC_FILE_I32  = 5 << 16,

    70

	OC_FILE_U32  = 6 << 16,

    71

	/* 8 bytes allocated (256 max) */

    72

    73

	OC_INT8      = OC_VAR_I8   | OC_FILE_I8,

    74

	OC_UINT8     = OC_VAR_U8   | OC_FILE_U8,

    75

	OC_INT16     = OC_VAR_I16  | OC_FILE_I16,

    76

	OC_UINT16    = OC_VAR_U16  | OC_FILE_U16,

    77

	OC_INT32     = OC_VAR_I32  | OC_FILE_I32,

    78

	OC_UINT32    = OC_VAR_U32  | OC_FILE_U32,

    79

    80

	OC_TILE      = OC_VAR_U32  | OC_FILE_U16,

    81

    82

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

    83

};

    84

    85

DECLARE_ENUM_AS_BIT_SET(OldChunkType);

    86

    87

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

    88

    89

struct OldChunks {

    90

	OldChunkType type;   ///< Type of field

    91

	uint32 amount;       ///< Amount of fields

    92

    93

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

    94

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

    95

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

    96

};

    97

    98

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

    99

assert_compile(sizeof(TileIndex) == 4);

   100

   101

static uint32 _bump_assert_value;

   102

static bool   _read_ttdpatch_flags;

   103

   104

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

   105

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

   106

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

   107

   108

static inline byte CalcOldVarLen(OldChunkType type)

   109

{

   110

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

   111

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

   112

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

   113

	return type_mem_size[length];

   114

}

   115

   116

/**

   117

 *

   118

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

   119

 *

   120

 */

   121

static byte ReadByteFromFile(LoadgameState *ls)

   122

{

   123

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

   124

	and just return a byte per time */

   125

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

   126

		/* Read some new bytes from the file */

   127

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

   128

   129

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

   130

		if (count == 0) {

   131

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

   132

			ls->failed = true;

   133

		}

   134

   135

		ls->buffer_count = count;

   136

		ls->buffer_cur   = 0;

   137

	}

   138

   139

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

   140

}

   141

   142

/**

   143

 *

   144

 * Reads a byte from the buffer and decompress if needed

   145

 *

   146

 */

   147

static byte ReadByte(LoadgameState *ls)

   148

{

   149

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

   150

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

   151

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

   153

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

   154

   155

	if (ls->chunk_size == 0) {

   156

		/* Read new chunk */

   157

		int8 new_byte = ReadByteFromFile(ls);

   158

   159

		if (new_byte < 0) {

   160

			/* Repeat next char for new_byte times */

   161

			ls->decoding    = true;

   162

			ls->decode_char = ReadByteFromFile(ls);

   163

			ls->chunk_size  = -new_byte + 1;

   164

		} else {

   165

			ls->decoding    = false;

   166

			ls->chunk_size  = new_byte + 1;

   167

		}

   168

	}

   169

   170

	ls->total_read++;

   171

	ls->chunk_size--;

   172

   173

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

   174

}

   175

   176

static inline uint16 ReadUint16(LoadgameState *ls)

   177

{

   178

	byte x = ReadByte(ls);

   179

	return x | ReadByte(ls) << 8;

   180

}

   181

   182

static inline uint32 ReadUint32(LoadgameState *ls)

   183

{

   184

	uint16 x = ReadUint16(ls);

   185

	return x | ReadUint16(ls) << 16;

   186

}

   187

   188

/**

   189

 *

   190

 * Loads a chunk from the old savegame

   191

 *

   192

 */

   193

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

   194

{

   195

	const OldChunks *chunk = chunks;

   196

	byte *base_ptr = (byte*)base;

   197

   198

	while (chunk->type != OC_END) {

   199

		byte* ptr = (byte*)chunk->ptr;

   200

		uint i;

   201

   202

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

   203

			if (ls->failed) return false;

   204

   205

			/* Handle simple types */

   206

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

   207

				switch (GetOldChunkType(chunk->type)) {

   208

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

   209

					case OC_NULL: ReadByte(ls); break;

   210

   211

					case OC_CHUNK:

   212

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

   213

						 * are going to read */

   214

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

   215

						break;

   216

   217

					case OC_ASSERT:

   218

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

   219

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

   220

					default: break;

   221

				}

   222

			} else {

   223

				uint32 res = 0;

   224

   225

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

   226

				switch (GetOldChunkFileType(chunk->type)) {

   227

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

   228

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

   229

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

   230

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

   231

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

   232

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

   233

					default: NOT_REACHED();

   234

				}

   235

   236

				/* Sanity check */

   237

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

   238

   239

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

   240

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

   241

   242

				/* Write the data */

   243

				switch (GetOldChunkVarType(chunk->type)) {

   244

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

   245

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

   246

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

   247

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

   248

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

   249

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

   250

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

   251

					default: NOT_REACHED();

   252

				}

   253

   254

				/* Increase pointer base for arrays when looping */

   255

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

   256

			}

   257

		}

   258

   259

		chunk++;

   260

	}

   261

   262

	return true;

   263

}

   264

   265

/**

   266

 *

   267

 * Initialize some data before reading

   268

 *

   269

 */

   270

static void InitLoading(LoadgameState *ls)

   271

{

   272

	ls->chunk_size   = 0;

   273

	ls->total_read   = 0;

   274

	ls->failed       = false;

   275

   276

	ls->decoding     = false;

   277

	ls->decode_char  = 0;

   278

   279

	ls->buffer_cur   = 0;

   280

	ls->buffer_count = 0;

   281

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

   282

   283

	_bump_assert_value = 0;

   284

   285

	_read_ttdpatch_flags = false;

   286

}

   287

   288

   289

/*

   290

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

   291

 */

   292

   293

extern uint32 GetOldTownName(uint32 townnameparts, byte old_town_name_type);

   294

   295

static void FixOldTowns()

   296

{

   297

	Town *town;

   298

   299

	/* Convert town-names if needed */

   300

	FOR_ALL_TOWNS(town) {

   301

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

   302

			town->townnametype = SPECSTR_TOWNNAME_ENGLISH + _opt.town_name;

   303

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

   304

		}

   305

	}

   306

}

   307

   308

static void FixOldStations()

   309

{

   310

	Station *st;

   311

   312

	FOR_ALL_STATIONS(st) {

   313

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

   314

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

   315

			Swap(st->trainst_w, st->trainst_h);

   316

		}

   317

	}

   318

}

   319

   320

static void FixOldVehicles()

   321

{

   322

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

   323

	Vehicle* v;

   324

   325

	FOR_ALL_VEHICLES(v) {

   326

		Vehicle *u;

   327

   328

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

   329

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

   330

			 * in both vehicles */

   331

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

   332

				v->next_shared = u;

   333

				u->prev_shared = v;

   334

				break;

   335

			}

   336

		}

   337

	}

   338

}

   339

   340

/*

   341

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

   342

 */

   343

   344

   345

/* Help:

   346

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

   347

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

   348

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

   349

 *  - OCL_END: every struct must end with this

   350

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

   351

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

   352

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

   353

 */

   354

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

   355

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

   356

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

   357

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

   358

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

   359

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

   360

   361

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

   362

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

   363

   Old Towns are 94 bytes big

   364

   Old Orders are 2 bytes big */

   365

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

   366

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

   367

   368

extern TileIndex _animated_tile_list[256];

   369

extern char _name_array[512][32];

   370

   371

static byte   _old_vehicle_multiplier;

   372

static uint8  _old_map3[OLD_MAP_SIZE * 2];

   373

static bool   _new_ttdpatch_format;

   374

static uint32 _old_town_index;

   375

static uint16 _old_string_id;

   376

static uint16 _old_string_id_2;

   377

static uint16 _old_extra_chunk_nums;

   378

   379

static void ReadTTDPatchFlags()

   380

{

   381

	int i;

   382

   383

	if (_read_ttdpatch_flags) return;

   384

   385

	_read_ttdpatch_flags = true;

   386

   387

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

   388

	_old_vehicle_multiplier = _old_map3[0];

   389

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

   390

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

   391

	if (_old_vehicle_multiplier < 2) _old_vehicle_multiplier++;

   392

   393

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

   394

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

   395

	bump the assert value so it doesn't!

   396

	(1 multipler == 850 vehicles

   397

	1 vehicle   == 128 bytes */

   398

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

   399

   400

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

   401

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

   402

   403

	_old_extra_chunk_nums = _old_map3[_new_ttdpatch_format ? 0x1FFFE : 0x2];

   404

   405

	/* Clean the misused places */

   406

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

   407

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

   408

   409

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

   410

   411

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

   412

}

   413

   414

static const OldChunks town_chunk[] = {

   415

	OCL_SVAR(   OC_TILE, Town, xy ),

   416

	OCL_SVAR( OC_FILE_U16 | OC_VAR_U32, Town, population ),

   417

	OCL_SVAR( OC_UINT16, Town, townnametype ),

   418

	OCL_SVAR( OC_UINT32, Town, townnameparts ),

   419

	OCL_SVAR(  OC_UINT8, Town, grow_counter ),

   420

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

   421

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

   422

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

   423

	OCL_SVAR( OC_UINT16, Town, flags12 ),

   424

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

   425

   426

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

   427

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

   428

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

   429

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

   430

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

   431

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

   432

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

   433

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

   434

   435

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

   437

	OCL_SVAR( OC_FILE_U32 | OC_VAR_U8, Town, have_ratings ),

   438

	OCL_SVAR( OC_FILE_U32 | OC_VAR_U8, Town, statues ),

   439

	OCL_SVAR( OC_UINT16, Town, num_houses ),

   440

	OCL_SVAR(  OC_UINT8, Town, time_until_rebuild ),

   441

	OCL_SVAR(  OC_UINT8, Town, growth_rate ),

   442

   443

	OCL_SVAR( OC_UINT16, Town, new_max_pass ),

   444

	OCL_SVAR( OC_UINT16, Town, new_max_mail ),

   445

	OCL_SVAR( OC_UINT16, Town, new_act_pass ),

   446

	OCL_SVAR( OC_UINT16, Town, new_act_mail ),

   447

	OCL_SVAR( OC_UINT16, Town, max_pass ),

   448

	OCL_SVAR( OC_UINT16, Town, max_mail ),

   449

	OCL_SVAR( OC_UINT16, Town, act_pass ),

   450

	OCL_SVAR( OC_UINT16, Town, act_mail ),

   451

   452

	OCL_SVAR(  OC_UINT8, Town, pct_pass_transported ),

   453

	OCL_SVAR(  OC_UINT8, Town, pct_mail_transported ),

   454

   455

	OCL_SVAR( OC_UINT16, Town, new_act_food ),

   456

	OCL_SVAR( OC_UINT16, Town, new_act_water ),

   457

	OCL_SVAR( OC_UINT16, Town, act_food ),

   458

	OCL_SVAR( OC_UINT16, Town, act_water ),

   459

   460

	OCL_SVAR(  OC_UINT8, Town, road_build_months ),

   461

	OCL_SVAR(  OC_UINT8, Town, fund_buildings_months ),

   462

   463

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

   464

   465

	OCL_END()

   466

};

   467

static bool LoadOldTown(LoadgameState *ls, int num)

   468

{

   469

	if (!AddBlockIfNeeded(&_Town_pool, num))

   470

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

   471

   472

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

   473

}

   474

   475

static uint16 _old_order;

   476

static const OldChunks order_chunk[] = {

   477

	OCL_VAR ( OC_UINT16,   1, &_old_order ),

   478

	OCL_END()

   479

};

   480

   481

static bool LoadOldOrder(LoadgameState *ls, int num)

   482

{

   483

	if (!AddBlockIfNeeded(&_Order_pool, num))

   484

		error("Orders: failed loading savegame: too many orders");

   485

   486

	if (!LoadChunk(ls, NULL, order_chunk)) return false;

   487