1

/* $Id$ */

     2

     3

/** @file oldloader.cpp Loading of old TTD(patch) savegames. */

     4

     5

#include "stdafx.h"

     6

#include "openttd.h"

     7

#include "station_map.h"

     8

#include "town.h"

     9

#include "industry.h"

    10

#include "player_func.h"

    11

#include "player_base.h"

    12

#include "aircraft.h"

    13

#include "roadveh.h"

    14

#include "ship.h"

    15

#include "train.h"

    16

#include "signs_base.h"

    17

#include "debug.h"

    18

#include "depot_base.h"

    19

#include "newgrf_config.h"

    20

#include "ai/ai.h"

    21

#include "ai/default/default.h"

    22

#include "zoom_func.h"

    23

#include "functions.h"

    24

#include "date_func.h"

    25

#include "vehicle_func.h"

    26

#include "variables.h"

    27

#include "saveload.h"

    28

#include "strings_func.h"

    29

#include "effectvehicle_base.h"

    30

    31

#include "table/strings.h"

    32

    33

enum {

    34

	HEADER_SIZE = 49,

    35

	BUFFER_SIZE = 4096,

    36

    37

	OLD_MAP_SIZE = 256 * 256

    38

};

    39

    40

struct LoadgameState {

    41

	FILE *file;

    42

    43

	uint chunk_size;

    44

    45

	bool decoding;

    46

	byte decode_char;

    47

    48

	uint buffer_count;

    49

	uint buffer_cur;

    50

	byte buffer[BUFFER_SIZE];

    51

    52

	uint total_read;

    53

	bool failed;

    54

};

    55

    56

/* OldChunk-Type */

    57

enum OldChunkType {

    58

	OC_SIMPLE    = 0,

    59

	OC_NULL      = 1,

    60

	OC_CHUNK     = 2,

    61

	OC_ASSERT    = 3,

    62

	/* 8 bytes allocated (256 max) */

    63

    64

	OC_VAR_I8    = 1 << 8,

    65

	OC_VAR_U8    = 2 << 8,

    66

	OC_VAR_I16   = 3 << 8,

    67

	OC_VAR_U16   = 4 << 8,

    68

	OC_VAR_I32   = 5 << 8,

    69

	OC_VAR_U32   = 6 << 8,

    70

	OC_VAR_I64   = 7 << 8,

    71

	/* 8 bytes allocated (256 max) */

    72

    73

	OC_FILE_I8   = 1 << 16,

    74

	OC_FILE_U8   = 2 << 16,

    75

	OC_FILE_I16  = 3 << 16,

    76

	OC_FILE_U16  = 4 << 16,

    77

	OC_FILE_I32  = 5 << 16,

    78

	OC_FILE_U32  = 6 << 16,

    79

	/* 8 bytes allocated (256 max) */

    80

    81

	OC_INT8      = OC_VAR_I8   | OC_FILE_I8,

    82

	OC_UINT8     = OC_VAR_U8   | OC_FILE_U8,

    83

	OC_INT16     = OC_VAR_I16  | OC_FILE_I16,

    84

	OC_UINT16    = OC_VAR_U16  | OC_FILE_U16,

    85

	OC_INT32     = OC_VAR_I32  | OC_FILE_I32,

    86

	OC_UINT32    = OC_VAR_U32  | OC_FILE_U32,

    87

    88

	OC_TILE      = OC_VAR_U32  | OC_FILE_U16,

    89

    90

	/**

    91

	 * Dereference the pointer once before writing to it,

    92

	 * so we do not have to use big static arrays.

    93

	 */

    94

	OC_DEREFERENCE_POINTER = 1 << 31,

    95

    96

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

    97

};

    98

    99

DECLARE_ENUM_AS_BIT_SET(OldChunkType);

   100

   101

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

   102

   103

struct OldChunks {

   104

	OldChunkType type;   ///< Type of field

   105

	uint32 amount;       ///< Amount of fields

   106

   107

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

   108

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

   109

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

   110

};

   111

   112

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

   113

assert_compile(sizeof(TileIndex) == 4);

   114

   115

extern SavegameType _savegame_type;

   116

extern uint32 _ttdp_version;

   117

   118

static uint32 _bump_assert_value;

   119

static bool   _read_ttdpatch_flags;

   120

   121

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

   122

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

   123

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

   124

   125

static inline byte CalcOldVarLen(OldChunkType type)

   126

{

   127

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

   128

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

   129

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

   130

	return type_mem_size[length];

   131

}

   132

   133

/**

   134

 *

   135

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

   136

 *

   137

 */

   138

static byte ReadByteFromFile(LoadgameState *ls)

   139

{

   140

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

   141

	and just return a byte per time */

   142

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

   143

		/* Read some new bytes from the file */

   144

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

   145

   146

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

   147

		if (count == 0) {

   148

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

   149

			ls->failed = true;

   150

		}

   151

   152

		ls->buffer_count = count;

   153

		ls->buffer_cur   = 0;

   154

	}

   155

   156

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

   157

}

   158

   159

/**

   160

 *

   161

 * Reads a byte from the buffer and decompress if needed

   162

 *

   163

 */

   164

static byte ReadByte(LoadgameState *ls)

   165

{

   166

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

   167

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

   168

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

   169

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

   170

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

   171

   172

	if (ls->chunk_size == 0) {

   173

		/* Read new chunk */

   174

		int8 new_byte = ReadByteFromFile(ls);

   175

   176

		if (new_byte < 0) {

   177

			/* Repeat next char for new_byte times */

   178

			ls->decoding    = true;

   179

			ls->decode_char = ReadByteFromFile(ls);

   180

			ls->chunk_size  = -new_byte + 1;

   181

		} else {

   182

			ls->decoding    = false;

   183

			ls->chunk_size  = new_byte + 1;

   184

		}

   185

	}

   186

   187

	ls->total_read++;

   188

	ls->chunk_size--;

   189

   190

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

   191

}

   192

   193

static inline uint16 ReadUint16(LoadgameState *ls)

   194

{

   195

	byte x = ReadByte(ls);

   196

	return x | ReadByte(ls) << 8;

   197

}

   198

   199

static inline uint32 ReadUint32(LoadgameState *ls)

   200

{

   201

	uint16 x = ReadUint16(ls);

   202

	return x | ReadUint16(ls) << 16;

   203

}

   204

   205

/**

   206

 *

   207

 * Loads a chunk from the old savegame

   208

 *

   209

 */

   210

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

   211

{

   212

	const OldChunks *chunk = chunks;

   213

	byte *base_ptr = (byte*)base;

   214

   215

	while (chunk->type != OC_END) {

   216

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

   217

		if ((chunk->type & OC_DEREFERENCE_POINTER) != 0) ptr = *(byte**)ptr;

   218

   219

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

   220

			if (ls->failed) return false;

   221

   222

			/* Handle simple types */

   223

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

   224

				switch (GetOldChunkType(chunk->type)) {

   225

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

   226

					case OC_NULL: ReadByte(ls); break;

   227

   228

					case OC_CHUNK:

   229

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

   230

						 * are going to read */

   231

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

   232

						break;

   233

   234

					case OC_ASSERT:

   235

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

   236

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

   237

					default: break;

   238

				}

   239

			} else {

   240

				uint64 res = 0;

   241

   242

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

   243

				switch (GetOldChunkFileType(chunk->type)) {

   244

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

   245

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

   246

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

   247

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

   248

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

   249

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

   250

					default: NOT_REACHED();

   251

				}

   252

   253

				/* Sanity check */

   254

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

   255

   256

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

   257

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

   258

   259

				/* Write the data */

   260

				switch (GetOldChunkVarType(chunk->type)) {

   261

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

   262

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

   263

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

   264

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

   265

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

   266

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

   267

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

   268

					default: NOT_REACHED();

   269

				}

   270

   271

				/* Increase pointer base for arrays when looping */

   272

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

   273

			}

   274

		}

   275

   276

		chunk++;

   277

	}

   278

   279

	return true;

   280

}

   281

   282

/**

   283

 *

   284

 * Initialize some data before reading

   285

 *

   286

 */

   287

static void InitLoading(LoadgameState *ls)

   288

{

   289

	ls->chunk_size   = 0;

   290

	ls->total_read   = 0;

   291

	ls->failed       = false;

   292

   293

	ls->decoding     = false;

   294

	ls->decode_char  = 0;

   295

   296

	ls->buffer_cur   = 0;

   297

	ls->buffer_count = 0;

   298

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

   299

   300

	_bump_assert_value = 0;

   301

   302

	_savegame_type   = SGT_TTD;

   303

	_ttdp_version    = 0;

   304

   305

	_read_ttdpatch_flags = false;

   306

}

   307

   308

   309

/*

   310

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

   311

 */

   312

   313

extern uint32 GetOldTownName(uint32 townnameparts, byte old_town_name_type);

   314

   315

static void FixOldTowns()

   316

{

   317

	Town *town;

   318

   319

	/* Convert town-names if needed */

   320

	FOR_ALL_TOWNS(town) {

   321

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

   322

			town->townnametype = SPECSTR_TOWNNAME_ENGLISH + _settings.game_creation.town_name;

   323

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

   324

		}

   325

	}

   326

}

   327

   328

static void FixOldStations()

   329

{

   330

	Station *st;

   331

   332

	FOR_ALL_STATIONS(st) {

   333

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

   334

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

   335

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

   336

		}

   337

	}

   338

}

   339

   340

static void FixOldVehicles()

   341

{

   342

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

   343

	Vehicle* v;

   344

   345

	FOR_ALL_VEHICLES(v) {

   346

		Vehicle *u;

   347

   348

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

   349

		if (v->type == VEH_ROAD &&

   350

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

   351

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

   352

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

   353

		}

   354

   355

		/* The subtype should be 0, but it sometimes isn't :( */

   356

		if (v->type == VEH_ROAD) v->subtype = 0;

   357

   358

		/* Sometimes primary vehicles would have a nothing (invalid) order

   359

		 * or vehicles that could not have an order would still have a

   360

		 * (loading) order which causes assertions and the like later on.

   361

		 */

   362

		if (!IsPlayerBuildableVehicleType(v) ||

   363

				(v->IsPrimaryVehicle() && v->current_order.IsType(OT_NOTHING))) {

   364

			v->current_order.MakeDummy();

   365

		}

   366

   367

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

   368

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

   369

			 * in both vehicles */

   370

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

   371

				v->next_shared = u;

   372

				u->prev_shared = v;

   373

				break;

   374

			}

   375

		}

   376

	}

   377

}

   378

   379

/*

   380

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

   381

 */

   382

   383

   384

/* Help:

   385

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

   386

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

   387

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

   388

 *  - OCL_END: every struct must end with this

   389

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

   390

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

   391

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

   392

 */

   393

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

   394

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

   395

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

   396

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

   397

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

   398

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

   399

   400

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

   401

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

   402

   Old Towns are 94 bytes big

   403

   Old Orders are 2 bytes big */

   404

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

   405

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

   406

   407

extern TileIndex *_animated_tile_list;

   408

extern uint _animated_tile_count;

   409

extern char *_old_name_array;

   410

   411

static byte   _old_vehicle_multiplier;

   412

static uint8  *_old_map3;

   413

static uint32 _old_town_index;

   414

static uint16 _old_string_id;

   415

static uint16 _old_string_id_2;

   416

static uint16 _old_extra_chunk_nums;

   417

   418

static void ReadTTDPatchFlags()

   419

{

   420

	if (_read_ttdpatch_flags) return;

   421

   422

	_read_ttdpatch_flags = true;

   423

   424

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

   425

	_old_vehicle_multiplier = _old_map3[0];

   426

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

   427

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

   428

	if (_old_vehicle_multiplier < 2) _old_vehicle_multiplier++;

   429

   430

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

   431

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

   432

	bump the assert value so it doesn't!

   433

	(1 multipler == 850 vehicles

   434

	1 vehicle   == 128 bytes */

   435

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

   436

   437

	for (uint i = 0; i < 17; i++) { // check tile 0, too

   438

		if (_old_map3[i] != 0) _savegame_type = SGT_TTDP1;

   439

	}

   440

   441

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

   442

	if (memcmp(&_old_map3[0x1FFFA], "TTDp", 4) == 0) _savegame_type = SGT_TTDP2;

   443

   444

	_old_extra_chunk_nums = _old_map3[_savegame_type == SGT_TTDP2 ? 0x1FFFE : 0x2];

   445

   446

	/* Clean the misused places */

   447

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

   448

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

   449

   450

	if (_savegame_type == SGT_TTDP2) DEBUG(oldloader, 2, "Found TTDPatch game");

   451

   452

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

   453

}

   454

   455

static const OldChunks town_chunk[] = {

   456

	OCL_SVAR(   OC_TILE, Town, xy ),

   457

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

   458

	OCL_SVAR( OC_UINT16, Town, townnametype ),

   459

	OCL_SVAR( OC_UINT32, Town, townnameparts ),

   460

	OCL_SVAR(  OC_UINT8, Town, grow_counter ),

   461

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

   462

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

   463

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

   464

	OCL_SVAR( OC_UINT16, Town, flags12 ),

   465

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

   466

   467

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

   468

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

   469

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

   470

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

   471

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

   472

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

   473

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

   474

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

   475

   476

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

   477

	nothing changed ? ? */

   478

	OCL_SVAR( OC_FILE_U32 | OC_VAR_U8, Town, have_ratings ),

   479

	OCL_SVAR( OC_FILE_U32 | OC_VAR_U8, Town, statues ),

   480

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

   481

	OCL_SVAR(  OC_UINT8, Town, time_until_rebuild ),

   482

	OCL_SVAR(  OC_UINT8, Town, growth_rate ),

   483

   484

	OCL_SVAR( OC_UINT16, Town, new_max_pass ),

   485

	OCL_SVAR( OC_UINT16, Town, new_max_mail ),