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

    22

#include "functions.h"

    23

#include "date_func.h"

    24

#include "vehicle_func.h"

    25

#include "variables.h"

    26

#include "saveload.h"

    27

#include "strings_func.h"

    28

#include "effectvehicle_base.h"

    29

    30

#include "table/strings.h"

    31

    32

enum {

    33

	HEADER_SIZE = 49,

    34

	BUFFER_SIZE = 4096,

    35

    36

	OLD_MAP_SIZE = 256 * 256

    37

};

    38

    39

struct LoadgameState {

    40

	FILE *file;

    41

    42

	uint chunk_size;

    43

    44

	bool decoding;

    45

	byte decode_char;

    46

    47

	uint buffer_count;

    48

	uint buffer_cur;

    49

	byte buffer[BUFFER_SIZE];

    50

    51

	uint total_read;

    52

	bool failed;

    53

};

    54

    55

/* OldChunk-Type */

    56

enum OldChunkType {

    57

	OC_SIMPLE    = 0,

    58

	OC_NULL      = 1,

    59

	OC_CHUNK     = 2,

    60

	OC_ASSERT    = 3,

    61

	/* 8 bytes allocated (256 max) */

    62

    63

	OC_VAR_I8    = 1 << 8,

    64

	OC_VAR_U8    = 2 << 8,

    65

	OC_VAR_I16   = 3 << 8,

    66

	OC_VAR_U16   = 4 << 8,

    67

	OC_VAR_I32   = 5 << 8,

    68

	OC_VAR_U32   = 6 << 8,

    69

	OC_VAR_I64   = 7 << 8,

    70

	/* 8 bytes allocated (256 max) */

    71

    72

	OC_FILE_I8   = 1 << 16,

    73

	OC_FILE_U8   = 2 << 16,

    74

	OC_FILE_I16  = 3 << 16,

    75

	OC_FILE_U16  = 4 << 16,

    76

	OC_FILE_I32  = 5 << 16,

    77

	OC_FILE_U32  = 6 << 16,

    78

	/* 8 bytes allocated (256 max) */

    79

    80

	OC_INT8      = OC_VAR_I8   | OC_FILE_I8,

    81

	OC_UINT8     = OC_VAR_U8   | OC_FILE_U8,

    82

	OC_INT16     = OC_VAR_I16  | OC_FILE_I16,

    83

	OC_UINT16    = OC_VAR_U16  | OC_FILE_U16,

    84

	OC_INT32     = OC_VAR_I32  | OC_FILE_I32,

    85

	OC_UINT32    = OC_VAR_U32  | OC_FILE_U32,

    86

    87

	OC_TILE      = OC_VAR_U32  | OC_FILE_U16,

    88

    89

	/**

    90

	 * Dereference the pointer once before writing to it,

    91

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

    92

	 */

    93

	OC_DEREFERENCE_POINTER = 1 << 31,

    94

    95

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

    96

};

    97

    98

DECLARE_ENUM_AS_BIT_SET(OldChunkType);

    99

   100

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

   101

   102

struct OldChunks {

   103

	OldChunkType type;   ///< Type of field

   104

	uint32 amount;       ///< Amount of fields

   105

   106

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

   107

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

   108

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

   109

};

   110

   111

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

   112

assert_compile(sizeof(TileIndex) == 4);

   113

   114

extern SavegameType _savegame_type;

   115

extern uint32 _ttdp_version;

   116

   117

static uint32 _bump_assert_value;

   118

static bool   _read_ttdpatch_flags;

   119

   120

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

   121

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

   122

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

   123

   124

static inline byte CalcOldVarLen(OldChunkType type)

   125

{

   126

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

   127

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

   128

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

   129

	return type_mem_size[length];

   130

}

   131

   132

/**

   133

 *

   134

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

   135

 *

   136

 */

   137

static byte ReadByteFromFile(LoadgameState *ls)

   138

{

   139

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

   140

	and just return a byte per time */

   141

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

   142

		/* Read some new bytes from the file */

   143

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

   144

   145

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

   146

		if (count == 0) {

   147

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

   148

			ls->failed = true;

   149

		}

   150

   151

		ls->buffer_count = count;

   152

		ls->buffer_cur   = 0;

   153

	}

   154

   155

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

   156

}

   157

   158

/**

   159

 *

   160

 * Reads a byte from the buffer and decompress if needed

   161

 *

   162

 */

   163

static byte ReadByte(LoadgameState *ls)

   164

{

   165

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

   166

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

   167

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

   168

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

   169

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

   170

   171

	if (ls->chunk_size == 0) {

   172

		/* Read new chunk */

   173

		int8 new_byte = ReadByteFromFile(ls);

   174

   175

		if (new_byte < 0) {

   176

			/* Repeat next char for new_byte times */

   177

			ls->decoding    = true;

   178

			ls->decode_char = ReadByteFromFile(ls);

   179

			ls->chunk_size  = -new_byte + 1;

   180

		} else {

   181

			ls->decoding    = false;

   182

			ls->chunk_size  = new_byte + 1;

   183

		}

   184

	}

   185

   186

	ls->total_read++;

   187

	ls->chunk_size--;

   188

   189

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

   190

}

   191

   192

static inline uint16 ReadUint16(LoadgameState *ls)

   193

{

   194

	byte x = ReadByte(ls);

   195

	return x | ReadByte(ls) << 8;

   196

}

   197

   198

static inline uint32 ReadUint32(LoadgameState *ls)

   199

{

   200

	uint16 x = ReadUint16(ls);

   201

	return x | ReadUint16(ls) << 16;

   202

}

   203

   204

/**

   205

 *

   206

 * Loads a chunk from the old savegame

   207

 *

   208

 */

   209

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

   210

{

   211

	const OldChunks *chunk = chunks;

   212

	byte *base_ptr = (byte*)base;

   213

   214

	while (chunk->type != OC_END) {

   215

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

   216

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

   217

   218

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

   219

			if (ls->failed) return false;

   220

   221

			/* Handle simple types */

   222

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

   223

				switch (GetOldChunkType(chunk->type)) {

   224

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

   225

					case OC_NULL: ReadByte(ls); break;

   226

   227

					case OC_CHUNK:

   228

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

   229

						 * are going to read */

   230

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

   231

						break;

   232

   233

					case OC_ASSERT:

   234

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

   235

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

   236

					default: break;

   237

				}

   238

			} else {

   239

				uint64 res = 0;

   240

   241

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

   242

				switch (GetOldChunkFileType(chunk->type)) {

   243

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

   244

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

   245

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

   246

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

   247

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

   248

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

   249

					default: NOT_REACHED();

   250

				}

   251

   252

				/* Sanity check */

   253

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

   254

   255

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

   256

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

   257

   258

				/* Write the data */

   259

				switch (GetOldChunkVarType(chunk->type)) {

   260

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

   261

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

   262

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

   263

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

   264

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

   265

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

   266

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

   267

					default: NOT_REACHED();

   268

				}

   269

   270

				/* Increase pointer base for arrays when looping */

   271

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

   272

			}

   273

		}

   274

   275

		chunk++;

   276

	}

   277

   278

	return true;

   279

}

   280

   281

/**

   282

 *

   283

 * Initialize some data before reading

   284

 *

   285

 */

   286

static void InitLoading(LoadgameState *ls)

   287

{

   288

	ls->chunk_size   = 0;

   289

	ls->total_read   = 0;

   290

	ls->failed       = false;

   291

   292

	ls->decoding     = false;

   293

	ls->decode_char  = 0;

   294

   295

	ls->buffer_cur   = 0;

   296

	ls->buffer_count = 0;

   297

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

   298

   299

	_bump_assert_value = 0;

   300

   301

	_savegame_type   = SGT_TTD;

   302

	_ttdp_version    = 0;

   303

   304

	_read_ttdpatch_flags = false;

   305

}

   306

   307

   308

/*

   309

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

   310

 */

   311

   312

extern uint32 GetOldTownName(uint32 townnameparts, byte old_town_name_type);

   313

   314

static void FixOldTowns()

   315

{

   316

	Town *town;

   317

   318

	/* Convert town-names if needed */

   319

	FOR_ALL_TOWNS(town) {

   320

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

   321

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

   322

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

   323

		}

   324

	}

   325

}

   326

   327

static void FixOldStations()

   328

{

   329

	Station *st;

   330

   331

	FOR_ALL_STATIONS(st) {

   332

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

   333

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

   334

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

   335

		}

   336

	}

   337

}

   338

   339

static void FixOldVehicles()

   340

{

   341

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

   342

	Vehicle* v;

   343

   344

	FOR_ALL_VEHICLES(v) {

   345

		Vehicle *u;

   346

   347

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

   348

		if (v->type == VEH_ROAD &&

   349

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

   350

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

   351

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

   352

		}

   353

   354

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

   355

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

   356

   357

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

   358

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

   359

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

   360

		 */

   361

		if (!IsPlayerBuildableVehicleType(v) ||

   362

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

   363

			v->current_order.MakeDummy();

   364

		}

   365

   366

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

   367

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

   368

			 * in both vehicles */

   369

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

   370

				v->next_shared = u;

   371

				u->prev_shared = v;

   372

				break;

   373

			}

   374

		}

   375

	}

   376

}

   377

   378

/*

   379

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

   380

 */

   381

   382

   383

/* Help:

   384

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

   385

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

   386

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

   387

 *  - OCL_END: every struct must end with this

   388

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

   389

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

   390

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

   391

 */

   392

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

   393

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

   394

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

   395

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

   396

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

   397

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

   398

   399

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

   400

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

   401

   Old Towns are 94 bytes big

   402

   Old Orders are 2 bytes big */

   403

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

   404

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

   405

   406

extern TileIndex *_animated_tile_list;

   407

extern uint _animated_tile_count;

   408

extern char *_old_name_array;

   409

   410

static byte   _old_vehicle_multiplier;

   411

static uint8  *_old_map3;

   412

static uint32 _old_town_index;

   413

static uint16 _old_string_id;

   414

static uint16 _old_string_id_2;

   415

static uint16 _old_extra_chunk_nums;

   416

   417

static void ReadTTDPatchFlags()

   418

{

   419

	if (_read_ttdpatch_flags) return;

   420

   421

	_read_ttdpatch_flags = true;

   422

   423

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

   424

	_old_vehicle_multiplier = _old_map3[0];

   425

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

   426

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

   427

	if (_old_vehicle_multiplier < 2) _old_vehicle_multiplier++;

   428

   429

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

   430

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

   431

	bump the assert value so it doesn't!

   432

	(1 multipler == 850 vehicles

   433

	1 vehicle   == 128 bytes */

   434

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

   435

   436

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

   437

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

   438

	}

   439

   440

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

   441

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

   442

   443

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

   444

   445

	/* Clean the misused places */

   446

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

   447

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

   448

   449

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

   450

   451

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

   452

}

   453

   454

static const OldChunks town_chunk[] = {

   455

	OCL_SVAR(   OC_TILE, Town, xy ),

   456

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

   457

	OCL_SVAR( OC_UINT16, Town, townnametype ),

   458

	OCL_SVAR( OC_UINT32, Town, townnameparts ),

   459

	OCL_SVAR(  OC_UINT8, Town, grow_counter ),

   460

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

   461

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

   462

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

   463

	OCL_SVAR( OC_UINT16, Town, flags12 ),

   464

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

   465

   466

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

   467

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

   468

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

   469

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

   470

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

   471

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

   472

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

   473

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

   474

   475

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

   476

	nothing changed ? ? */

   477

	OCL_SVAR( OC_FILE_U32 | OC_VAR_U8, Town, have_ratings ),

   478

	OCL_SVAR( OC_FILE_U32 | OC_VAR_U8, Town, statues ),

   479

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

   480

	OCL_SVAR(  OC_UINT8, Town, time_until_rebuild ),

   481

	OCL_SVAR(  OC_UINT8, Town, growth_rate ),

   482

   483

	OCL_SVAR( OC_UINT16, Town, new_max_pass ),

   484

	OCL_SVAR( OC_UINT16, Town, new_max_mail ),

   485

	OCL_SVAR( OC_UINT16, Town, new_act_pass ),