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 "aircraft.h"

    19

#include "roadveh.h"

    20

#include "ship.h"

    21

#include "train.h"

    22

#include "signs.h"

    23

#include "debug.h"

    24

#include "depot.h"

    25

#include "newgrf_config.h"

    26

#include "ai/ai.h"

    27

#include "date.h"

    28

    29

enum {

    30

	HEADER_SIZE = 49,

    31

	BUFFER_SIZE = 4096,

    32

    33

	OLD_MAP_SIZE = 256 * 256

    34

};

    35

    36

struct LoadgameState {

    37

	FILE *file;

    38

    39

	uint chunk_size;

    40

    41

	bool decoding;

    42

	byte decode_char;

    43

    44

	uint buffer_count;

    45

	uint buffer_cur;

    46

	byte buffer[BUFFER_SIZE];

    47

    48

	uint total_read;

    49

	bool failed;

    50

};

    51

    52

/* OldChunk-Type */

    53

enum OldChunkType {

    54

	OC_SIMPLE    = 0,

    55

	OC_NULL      = 1,

    56

	OC_CHUNK     = 2,

    57

	OC_ASSERT    = 3,

    58

	/* 8 bytes allocated (256 max) */

    59

    60

	OC_VAR_I8    = 1 << 8,

    61

	OC_VAR_U8    = 2 << 8,

    62

	OC_VAR_I16   = 3 << 8,

    63

	OC_VAR_U16   = 4 << 8,

    64

	OC_VAR_I32   = 5 << 8,

    65

	OC_VAR_U32   = 6 << 8,

    66

	OC_VAR_I64   = 7 << 8,

    67

	/* 8 bytes allocated (256 max) */

    68

    69

	OC_FILE_I8   = 1 << 16,

    70

	OC_FILE_U8   = 2 << 16,

    71

	OC_FILE_I16  = 3 << 16,

    72

	OC_FILE_U16  = 4 << 16,

    73

	OC_FILE_I32  = 5 << 16,

    74

	OC_FILE_U32  = 6 << 16,

    75

	/* 8 bytes allocated (256 max) */

    76

    77

	OC_INT8      = OC_VAR_I8   | OC_FILE_I8,

    78

	OC_UINT8     = OC_VAR_U8   | OC_FILE_U8,

    79

	OC_INT16     = OC_VAR_I16  | OC_FILE_I16,

    80

	OC_UINT16    = OC_VAR_U16  | OC_FILE_U16,

    81

	OC_INT32     = OC_VAR_I32  | OC_FILE_I32,

    82

	OC_UINT32    = OC_VAR_U32  | OC_FILE_U32,

    83

    84

	OC_TILE      = OC_VAR_U32  | OC_FILE_U16,

    85

    86

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

    87

};

    88

    89

DECLARE_ENUM_AS_BIT_SET(OldChunkType);

    90

    91

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

    92

    93

struct OldChunks {

    94

	OldChunkType type;   ///< Type of field

    95

	uint32 amount;       ///< Amount of fields

    96

    97

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

    98

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

    99

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

   100

};

   101

   102

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

   103

assert_compile(sizeof(TileIndex) == 4);

   104

   105

static uint32 _bump_assert_value;

   106

static bool   _read_ttdpatch_flags;

   107

   108

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

   109

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

   110

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

   111

   112

static inline byte CalcOldVarLen(OldChunkType type)

   113

{

   114

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

   115

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

   116

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

   117

	return type_mem_size[length];

   118

}

   119

   120

/**

   121

 *

   122

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

   123

 *

   124

 */

   125

static byte ReadByteFromFile(LoadgameState *ls)

   126

{

   127

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

   128

	and just return a byte per time */

   129

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

   130

		/* Read some new bytes from the file */

   131

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

   132

   133

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

   134

		if (count == 0) {

   135

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

   136

			ls->failed = true;

   137

		}

   138

   139

		ls->buffer_count = count;

   140

		ls->buffer_cur   = 0;

   141

	}

   142

   143

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

   144

}

   145

   146

/**

   147

 *

   148

 * Reads a byte from the buffer and decompress if needed

   149

 *

   150

 */

   151

static byte ReadByte(LoadgameState *ls)

   152

{

   153

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

   154

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

   155

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

   156

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

   157

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

   158

   159

	if (ls->chunk_size == 0) {

   160

		/* Read new chunk */

   161

		int8 new_byte = ReadByteFromFile(ls);

   162

   163

		if (new_byte < 0) {

   164

			/* Repeat next char for new_byte times */

   165

			ls->decoding    = true;

   166

			ls->decode_char = ReadByteFromFile(ls);

   167

			ls->chunk_size  = -new_byte + 1;

   168

		} else {

   169

			ls->decoding    = false;

   170

			ls->chunk_size  = new_byte + 1;

   171

		}

   172

	}

   173

   174

	ls->total_read++;

   175

	ls->chunk_size--;

   176

   177

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

   178

}

   179

   180

static inline uint16 ReadUint16(LoadgameState *ls)

   181

{

   182

	byte x = ReadByte(ls);

   183

	return x | ReadByte(ls) << 8;

   184

}

   185

   186

static inline uint32 ReadUint32(LoadgameState *ls)

   187

{

   188

	uint16 x = ReadUint16(ls);

   189

	return x | ReadUint16(ls) << 16;

   190

}

   191

   192

/**

   193

 *

   194

 * Loads a chunk from the old savegame

   195

 *

   196

 */

   197

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

   198

{

   199

	const OldChunks *chunk = chunks;

   200

	byte *base_ptr = (byte*)base;

   201

   202

	while (chunk->type != OC_END) {

   203

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

   204

		uint i;

   205

   206

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

   207

			if (ls->failed) return false;

   208

   209

			/* Handle simple types */

   210

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

   211

				switch (GetOldChunkType(chunk->type)) {

   212

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

   213

					case OC_NULL: ReadByte(ls); break;

   214

   215

					case OC_CHUNK:

   216

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

   217

						 * are going to read */

   218

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

   219

						break;

   220

   221

					case OC_ASSERT:

   222

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

   223

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

   224

					default: break;

   225

				}

   226

			} else {

   227

				uint32 res = 0;

   228

   229

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

   230

				switch (GetOldChunkFileType(chunk->type)) {

   231

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

   232

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

   233

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

   234

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

   235

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

   236

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

   237

					default: NOT_REACHED();

   238

				}

   239

   240

				/* Sanity check */

   241

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

   242

   243

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

   244

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

   245

   246

				/* Write the data */

   247

				switch (GetOldChunkVarType(chunk->type)) {

   248

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

   249

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

   250

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

   251

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

   252

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

   253

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

   254

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

   255

					default: NOT_REACHED();

   256

				}

   257

   258

				/* Increase pointer base for arrays when looping */

   259

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

   260

			}

   261

		}

   262

   263

		chunk++;

   264

	}

   265

   266

	return true;

   267

}

   268

   269

/**

   270

 *

   271

 * Initialize some data before reading

   272

 *

   273

 */

   274

static void InitLoading(LoadgameState *ls)

   275

{

   276

	ls->chunk_size   = 0;

   277

	ls->total_read   = 0;

   278

	ls->failed       = false;

   279

   280

	ls->decoding     = false;

   281

	ls->decode_char  = 0;

   282

   283

	ls->buffer_cur   = 0;

   284

	ls->buffer_count = 0;

   285

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

   286

   287

	_bump_assert_value = 0;

   288

   289

	_read_ttdpatch_flags = false;

   290

}

   291

   292

   293

/*

   294

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

   295

 */

   296

   297

extern uint32 GetOldTownName(uint32 townnameparts, byte old_town_name_type);

   298

   299

static void FixOldTowns()

   300

{

   301

	Town *town;

   302

   303

	/* Convert town-names if needed */

   304

	FOR_ALL_TOWNS(town) {

   305

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

   306

			town->townnametype = SPECSTR_TOWNNAME_ENGLISH + _opt.town_name;

   307

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

   308

		}

   309

	}

   310

}

   311

   312

static void FixOldStations()

   313

{

   314

	Station *st;

   315

   316

	FOR_ALL_STATIONS(st) {

   317

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

   318

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

   319

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

   320

		}

   321

	}

   322

}

   323

   324

static void FixOldVehicles()

   325

{

   326

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

   327

	Vehicle* v;

   328

   329

	FOR_ALL_VEHICLES(v) {

   330

		Vehicle *u;

   331

   332

		/* We haven't used this bit for stations for ages */

   333

		if (v->type == VEH_ROAD &&

   334

				v->u.road.state != RVSB_IN_DEPOT &&

   335

				v->u.road.state != RVSB_WORMHOLE) {

   336

			CLRBIT(v->u.road.state, RVS_IS_STOPPING);

   337

		}

   338

   339

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

   340

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

   341

			 * in both vehicles */

   342

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

   343

				v->next_shared = u;

   344

				u->prev_shared = v;

   345

				break;

   346

			}

   347

		}

   348

	}

   349

}

   350

   351

/*

   352

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

   353

 */

   354

   355

   356

/* Help:

   357

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

   358

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

   359

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

   360

 *  - OCL_END: every struct must end with this

   361

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

   362

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

   363

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

   364

 */

   365

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

   366

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

   367

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

   368

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

   369

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

   370

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

   371

   372

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

   373

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

   374

   Old Towns are 94 bytes big

   375

   Old Orders are 2 bytes big */

   376

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

   377

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

   378

   379

extern TileIndex _animated_tile_list[256];

   380

extern char _name_array[512][32];

   381

   382

static byte   _old_vehicle_multiplier;

   383

static uint8  _old_map3[OLD_MAP_SIZE * 2];

   384

static bool   _new_ttdpatch_format;

   385

static uint32 _old_town_index;

   386

static uint16 _old_string_id;

   387

static uint16 _old_string_id_2;

   388

static uint16 _old_extra_chunk_nums;

   389

   390

static void ReadTTDPatchFlags()

   391

{

   392

	int i;

   393

   394

	if (_read_ttdpatch_flags) return;

   395

   396

	_read_ttdpatch_flags = true;

   397

   398

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

   399

	_old_vehicle_multiplier = _old_map3[0];

   400

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

   401

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

   402

	if (_old_vehicle_multiplier < 2) _old_vehicle_multiplier++;

   403

   404

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

   405

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

   406

	bump the assert value so it doesn't!

   407

	(1 multipler == 850 vehicles

   408

	1 vehicle   == 128 bytes */

   409

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

   410

   411

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

   412

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

   413

   414

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

   415

   416

	/* Clean the misused places */

   417

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

   418

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

   419

   420

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

   421

   422

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

   423

}

   424

   425

static const OldChunks town_chunk[] = {

   426

	OCL_SVAR(   OC_TILE, Town, xy ),

   427

	OCL_SVAR( OC_FILE_U16 | OC_VAR_U32, Town, population ),

   428

	OCL_SVAR( OC_UINT16, Town, townnametype ),

   429

	OCL_SVAR( OC_UINT32, Town, townnameparts ),

   430

	OCL_SVAR(  OC_UINT8, Town, grow_counter ),

   431

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

   432

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

   433

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

   434

	OCL_SVAR( OC_UINT16, Town, flags12 ),

   435

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

   436

   437

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

   438

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

   439

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

   440

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

   441

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

   442

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

   443

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

   444

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

   445

   446

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

   447

	nothing changed ? ? */

   448

	OCL_SVAR( OC_FILE_U32 | OC_VAR_U8, Town, have_ratings ),

   449

	OCL_SVAR( OC_FILE_U32 | OC_VAR_U8, Town, statues ),

   450

	OCL_SVAR( OC_UINT16, Town, num_houses ),

   451

	OCL_SVAR(  OC_UINT8, Town, time_until_rebuild ),

   452

	OCL_SVAR(  OC_UINT8, Town, growth_rate ),

   453

   454

	OCL_SVAR( OC_UINT16, Town, new_max_pass ),

   455

	OCL_SVAR( OC_UINT16, Town, new_max_mail ),

   456

	OCL_SVAR( OC_UINT16, Town, new_act_pass ),

   457

	OCL_SVAR( OC_UINT16, Town, new_act_mail ),

   458

	OCL_SVAR( OC_UINT16, Town, max_pass ),

   459

	OCL_SVAR( OC_UINT16, Town, max_mail ),

   460

	OCL_SVAR( OC_UINT16, Town, act_pass ),

   461

	OCL_SVAR( OC_UINT16, Town, act_mail ),

   462

   463

	OCL_SVAR(  OC_UINT8, Town, pct_pass_transported ),

   464

	OCL_SVAR(  OC_UINT8, Town, pct_mail_transported ),

   465

   466

	OCL_SVAR( OC_UINT16, Town, new_act_food ),

   467

	OCL_SVAR( OC_UINT16, Town, new_act_water ),

   468

	OCL_SVAR( OC_UINT16, Town, act_food ),

   469

	OCL_SVAR( OC_UINT16, Town, act_water ),

   470

   471

	OCL_SVAR(  OC_UINT8, Town, road_build_months ),

   472

	OCL_SVAR(  OC_UINT8, Town, fund_buildings_months ),

   473

   474

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

   475

   476

	OCL_END()

   477

};

   478

static bool LoadOldTown(LoadgameState *ls, int num)

   479

{

   480

	if (!AddBlockIfNeeded(&_Town_pool, num))

   481

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

   482

   483

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

   484

}

   485

   486

static uint16 _old_order;

   487

static const OldChunks order_chunk[] = {