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

    11

#include "company_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 bits 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 bits 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 bits 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 32 bits 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.game_creation.town_name;

   323

			town->townnameparts = GetOldTownName(town->townnameparts, _settings_game.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 StringID *_old_vehicle_names = NULL;

   341

   342

static void FixOldVehicles()

   343

{

   344

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

   345

	Vehicle* v;

   346

   347

	FOR_ALL_VEHICLES(v) {

   348

		Vehicle *u;

   349

   350

		v->name = CopyFromOldName(_old_vehicle_names[v->index]);

   351

   352

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

   353

		if (v->type == VEH_ROAD &&

   354

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

   355

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

   356

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

   357

		}

   358

   359

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

   360

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

   361

   362

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

   363

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

   364

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

   365

		 */

   366

		if (!IsCompanyBuildableVehicleType(v) ||

   367

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

   368

			v->current_order.MakeDummy();

   369

		}

   370

   371

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

   372

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

   373

			 * in both vehicles */

   374

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

   375

				u->AddToShared(v);

   376

				break;

   377

			}

   378

		}

   379

	}

   380

}

   381

   382

/*

   383

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

   384

 */

   385

   386

   387

/* Help:

   388

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

   389

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

   390

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

   391

 *  - OCL_END: every struct must end with this

   392

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

   393

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

   394

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

   395

 */

   396

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

   397

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

   398

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

   399

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

   400

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

   401

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

   402

   403

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

   404

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

   405

   Old Towns are 94 bytes big

   406

   Old Orders are 2 bytes big */

   407

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

   408

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

   409

   410

extern TileIndex *_animated_tile_list;

   411

extern uint _animated_tile_count;

   412

extern char *_old_name_array;

   413

   414

static byte   _old_vehicle_multiplier;

   415

static uint8  *_old_map3;

   416

static uint32 _old_town_index;

   417

static uint16 _old_string_id;

   418

static uint16 _old_string_id_2;

   419

static uint16 _old_extra_chunk_nums;

   420

   421

static void ReadTTDPatchFlags()

   422

{

   423

	if (_read_ttdpatch_flags) return;

   424

   425

	_read_ttdpatch_flags = true;

   426

   427

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

   428

	_old_vehicle_multiplier = _old_map3[0];

   429

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

   430

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

   431

	if (_old_vehicle_multiplier < 2) _old_vehicle_multiplier++;

   432

   433

	_old_vehicle_names = MallocT<StringID>(_old_vehicle_multiplier * 850);

   434

   435

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

   436

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

   437

	bump the assert value so it doesn't!

   438

	(1 multipler == 850 vehicles

   439

	1 vehicle   == 128 bytes */

   440

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

   441

   442

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

   443

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

   444

	}

   445

   446

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

   447

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

   448

   449

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

   450

   451

	/* Clean the misused places */

   452

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

   453

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

   454

   455

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

   456

   457

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

   458

}

   459

   460

static const OldChunks town_chunk[] = {

   461

	OCL_SVAR(   OC_TILE, Town, xy ),

   462

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

   463

	OCL_SVAR( OC_UINT16, Town, townnametype ),

   464

	OCL_SVAR( OC_UINT32, Town, townnameparts ),

   465

	OCL_SVAR(  OC_UINT8, Town, grow_counter ),

   466

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

   467

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

   468

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

   469

	OCL_SVAR( OC_UINT16, Town, flags12 ),

   470

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

   471

   472

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

   473

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

   474

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

   475

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

   476

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

   477

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

   478

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

   479

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

   480

   481

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

   482

	nothing changed ? ? */

   483

	OCL_SVAR( OC_FILE_U32 | OC_VAR_U8, Town, have_ratings ),

   484

	OCL_SVAR( OC_FILE_U32 | OC_VAR_U8, Town, statues ),

   485

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