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

#include "economy_new.h"

    25

    26

enum {

    27

	HEADER_SIZE = 49,

    28

	BUFFER_SIZE = 4096,

    29

    30

	OLD_MAP_SIZE = 256 * 256

    31

};

    32

    33

struct LoadgameState {

    34

	FILE *file;

    35

    36

	uint chunk_size;

    37

    38

	bool decoding;

    39

	byte decode_char;

    40

    41

	uint buffer_count;

    42

	uint buffer_cur;

    43

	byte buffer[BUFFER_SIZE];

    44

    45

	uint total_read;

    46

	bool failed;

    47

};

    48

    49

/* OldChunk-Type */

    50

enum OldChunkType {

    51

	OC_SIMPLE    = 0,

    52

	OC_NULL      = 1,

    53

	OC_CHUNK     = 2,

    54

	OC_ASSERT    = 3,

    55

	/* 8 bytes allocated (256 max) */

    56

    57

	OC_VAR_I8    = 1 << 8,

    58

	OC_VAR_U8    = 2 << 8,

    59

	OC_VAR_I16   = 3 << 8,

    60

	OC_VAR_U16   = 4 << 8,

    61

	OC_VAR_I32   = 5 << 8,

    62

	OC_VAR_U32   = 6 << 8,

    63

	OC_VAR_I64   = 7 << 8,

    64

	/* 8 bytes allocated (256 max) */

    65

    66

	OC_FILE_I8   = 1 << 16,

    67

	OC_FILE_U8   = 2 << 16,

    68

	OC_FILE_I16  = 3 << 16,

    69

	OC_FILE_U16  = 4 << 16,

    70

	OC_FILE_I32  = 5 << 16,

    71

	OC_FILE_U32  = 6 << 16,

    72

	/* 8 bytes allocated (256 max) */

    73

    74

	OC_INT8      = OC_VAR_I8   | OC_FILE_I8,

    75

	OC_UINT8     = OC_VAR_U8   | OC_FILE_U8,

    76

	OC_INT16     = OC_VAR_I16  | OC_FILE_I16,

    77

	OC_UINT16    = OC_VAR_U16  | OC_FILE_U16,

    78

	OC_INT32     = OC_VAR_I32  | OC_FILE_I32,

    79

	OC_UINT32    = OC_VAR_U32  | OC_FILE_U32,

    80

    81

	OC_TILE      = OC_VAR_U32  | OC_FILE_U16,

    82

    83

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

    84

};

    85

    86

DECLARE_ENUM_AS_BIT_SET(OldChunkType);

    87

    88

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

    89

    90

struct OldChunks {

    91

	OldChunkType type;   ///< Type of field

    92

	uint32 amount;       ///< Amount of fields

    93

    94

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

    95

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

    96

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

    97

};

    98

    99

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

   100

assert_compile(sizeof(TileIndex) == 4);

   101

   102

static uint32 _bump_assert_value;

   103

static bool   _read_ttdpatch_flags;

   104

   105

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

   106

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

   107

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

   108

   109

static inline byte CalcOldVarLen(OldChunkType type)

   110

{

   111

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

   112

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

   113

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

   114

	return type_mem_size[length];

   115

}

   116

   117

/**

   118

 *

   119

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

   120

 *

   121

 */

   122

static byte ReadByteFromFile(LoadgameState *ls)

   123

{

   124

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

   125

	and just return a byte per time */

   126

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

   127

		/* Read some new bytes from the file */

   128

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

   129

   130

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

   131

		if (count == 0) {

   132

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

   133

			ls->failed = true;

   134

		}

   135

   136

		ls->buffer_count = count;

   137

		ls->buffer_cur   = 0;

   138

	}

   139

   140

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

   141

}

   142

   143

/**

   144

 *

   145

 * Reads a byte from the buffer and decompress if needed

   146

 *

   147

 */

   148

static byte ReadByte(LoadgameState *ls)

   149

{

   150

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

   151

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

   152

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

   154

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

   155

   156

	if (ls->chunk_size == 0) {

   157

		/* Read new chunk */

   158

		int8 new_byte = ReadByteFromFile(ls);

   159

   160

		if (new_byte < 0) {

   161

			/* Repeat next char for new_byte times */

   162

			ls->decoding    = true;

   163

			ls->decode_char = ReadByteFromFile(ls);

   164

			ls->chunk_size  = -new_byte + 1;

   165

		} else {

   166

			ls->decoding    = false;

   167

			ls->chunk_size  = new_byte + 1;

   168

		}

   169

	}

   170

   171

	ls->total_read++;

   172

	ls->chunk_size--;

   173

   174

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

   175

}

   176

   177

static inline uint16 ReadUint16(LoadgameState *ls)

   178

{

   179

	byte x = ReadByte(ls);

   180

	return x | ReadByte(ls) << 8;

   181

}

   182

   183

static inline uint32 ReadUint32(LoadgameState *ls)

   184

{

   185

	uint16 x = ReadUint16(ls);

   186

	return x | ReadUint16(ls) << 16;

   187

}

   188

   189

/**

   190

 *

   191

 * Loads a chunk from the old savegame

   192

 *

   193

 */

   194

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

   195

{

   196

	const OldChunks *chunk = chunks;

   197

	byte *base_ptr = (byte*)base;

   198

   199

	while (chunk->type != OC_END) {

   200

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

   201

		uint i;

   202

   203

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

   204

			if (ls->failed) return false;

   205

   206

			/* Handle simple types */

   207

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

   208

				switch (GetOldChunkType(chunk->type)) {

   209

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

   210

					case OC_NULL: ReadByte(ls); break;

   211

   212

					case OC_CHUNK:

   213

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

   214

						 * are going to read */

   215

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

   216

						break;

   217

   218

					case OC_ASSERT:

   219

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

   220

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

   221

					default: break;

   222

				}

   223

			} else {

   224

				uint32 res = 0;

   225

   226

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

   227

				switch (GetOldChunkFileType(chunk->type)) {

   228

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

   229

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

   230

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

   231

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

   232

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

   233

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

   234

					default: NOT_REACHED();

   235

				}

   236

   237

				/* Sanity check */

   238

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

   239

   240

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

   241

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

   242

   243

				/* Write the data */

   244

				switch (GetOldChunkVarType(chunk->type)) {

   245

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

   246

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

   247

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

   248

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

   249

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

   250

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

   251

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

   252

					default: NOT_REACHED();

   253

				}

   254

   255

				/* Increase pointer base for arrays when looping */

   256

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

   257

			}

   258

		}

   259

   260

		chunk++;

   261

	}

   262

   263

	return true;

   264

}

   265

   266

/**

   267

 *

   268

 * Initialize some data before reading

   269

 *

   270

 */

   271

static void InitLoading(LoadgameState *ls)

   272

{

   273

	ls->chunk_size   = 0;

   274

	ls->total_read   = 0;

   275

	ls->failed       = false;

   276

   277

	ls->decoding     = false;

   278

	ls->decode_char  = 0;

   279

   280

	ls->buffer_cur   = 0;

   281

	ls->buffer_count = 0;

   282

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

   283

   284

	_bump_assert_value = 0;

   285

   286

	_read_ttdpatch_flags = false;

   287

}

   288

   289

   290

/*

   291

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

   292

 */

   293

   294

extern uint32 GetOldTownName(uint32 townnameparts, byte old_town_name_type);

   295

   296

static void FixOldTowns()

   297

{

   298

	Town *town;

   299

   300

	/* Convert town-names if needed */

   301

	FOR_ALL_TOWNS(town) {

   302

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

   303

			town->townnametype = SPECSTR_TOWNNAME_ENGLISH + _opt.town_name;

   304

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

   305

		}

   306

	}

   307

}

   308

   309

static void FixOldStations()

   310

{

   311

	Station *st;

   312

   313

	FOR_ALL_STATIONS(st) {

   314

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

   315

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

   316

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

   317

		}

   318

	}

   319

}

   320

   321

static void FixOldVehicles()

   322

{

   323

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

   324

	Vehicle* v;

   325

   326

	FOR_ALL_VEHICLES(v) {

   327

		Vehicle *u;

   328

   329

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

   330

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

   331

			 * in both vehicles */

   332

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

   333

				v->next_shared = u;

   334

				u->prev_shared = v;

   335

				break;

   336

			}

   337

		}

   338

	}

   339

}

   340

   341

/*

   342

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

   343

 */

   344

   345

   346

/* Help:

   347

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

   348

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

   349

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

   350

 *  - OCL_END: every struct must end with this

   351

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

   352

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

   353

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

   354

 */

   355

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

   356

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

   357

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

   358

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

   359

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

   360

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

   361

   362

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

   363

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

   364

   Old Towns are 94 bytes big

   365

   Old Orders are 2 bytes big */

   366

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

   367

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

   368

   369

extern TileIndex _animated_tile_list[256];

   370

extern char _name_array[512][32];

   371

   372

static byte   _old_vehicle_multiplier;

   373

static uint8  _old_map3[OLD_MAP_SIZE * 2];

   374

static bool   _new_ttdpatch_format;

   375

static uint32 _old_town_index;

   376

static uint16 _old_string_id;

   377

static uint16 _old_string_id_2;

   378

static uint16 _old_extra_chunk_nums;

   379

   380

static void ReadTTDPatchFlags()

   381

{

   382

	int i;

   383

   384

	if (_read_ttdpatch_flags) return;

   385

   386

	_read_ttdpatch_flags = true;

   387

   388

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

   389

	_old_vehicle_multiplier = _old_map3[0];

   390

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

   391

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

   392

	if (_old_vehicle_multiplier < 2) _old_vehicle_multiplier++;

   393

   394

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

   395

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

   396

	bump the assert value so it doesn't!

   397

	(1 multipler == 850 vehicles

   398

	1 vehicle   == 128 bytes */

   399

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

   400

   401

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

   402

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

   403

   404

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

   405

   406

	/* Clean the misused places */

   407

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

   408

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

   409

   410

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

   411

   412

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

   413

}

   414

   415

static const OldChunks town_chunk[] = {

   416

	OCL_SVAR(   OC_TILE, Town, xy ),

   417

	OCL_SVAR( OC_FILE_U16 | OC_VAR_U32, Town, population ),

   418

	OCL_SVAR( OC_UINT16, Town, townnametype ),

   419

	OCL_SVAR( OC_UINT32, Town, townnameparts ),

   420

	OCL_SVAR(  OC_UINT8, Town, grow_counter ),

   421

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

   422

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

   423

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

   424

	OCL_SVAR( OC_UINT16, Town, flags12 ),

   425

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

   426

   427

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

   428

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

   429

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

   430

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

   431

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

   432

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

   433

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

   434

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

   435

   436

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

   438

	OCL_SVAR( OC_FILE_U32 | OC_VAR_U8, Town, have_ratings ),

   439

	OCL_SVAR( OC_FILE_U32 | OC_VAR_U8, Town, statues ),

   440

	OCL_SVAR( OC_UINT16, Town, num_houses ),

   441

	OCL_SVAR(  OC_UINT8, Town, time_until_rebuild ),

   442

	OCL_SVAR(  OC_UINT8, Town, growth_rate ),

   443

   444

	OCL_SVAR( OC_UINT16, Town, new_max_pass ),

   445

	OCL_SVAR( OC_UINT16, Town, new_max_mail ),

   446

	OCL_SVAR( OC_UINT16, Town, new_act_pass ),

   447

	OCL_SVAR( OC_UINT16, Town, new_act_mail ),

   448

	OCL_SVAR( OC_UINT16, Town, max_pass ),

   449

	OCL_SVAR( OC_UINT16, Town, max_mail ),

   450

	OCL_SVAR( OC_UINT16, Town, act_pass ),

   451

	OCL_SVAR( OC_UINT16, Town, act_mail ),

   452

   453

	OCL_SVAR(  OC_UINT8, Town, pct_pass_transported ),

   454

	OCL_SVAR(  OC_UINT8, Town, pct_mail_transported ),

   455

   456

	OCL_SVAR( OC_UINT16, Town, new_act_food ),

   457

	OCL_SVAR( OC_UINT16, Town, new_act_water ),

   458

	OCL_SVAR( OC_UINT16, Town, act_food ),

   459

	OCL_SVAR( OC_UINT16, Town, act_water ),

   460

   461

	OCL_SVAR(  OC_UINT8, Town, road_build_months ),

   462

	OCL_SVAR(  OC_UINT8, Town, fund_buildings_months ),

   463

   464

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

   465

   466

	OCL_END()

   467

};

   468

static bool LoadOldTown(LoadgameState *ls, int num)

   469

{

   470

	if (!AddBlockIfNeeded(&_Town_pool, num))

   471

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

   472

   473

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

   474

}

   475

   476

static uint16 _old_order;

   477

static const OldChunks order_chunk[] = {

   478

	OCL_VAR ( OC_UINT16,   1, &_old_order ),

   479

	OCL_END()

   480

};

   481

   482

static bool LoadOldOrder(LoadgameState *ls, int num)

   483

{

   484

	if (!AddBlockIfNeeded(&_Order_pool, num))

   485

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

   486

   487

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