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"

    26

#include "ai/ai.h"

    27

#include "date.h"

    28

#include "economy_new.h"

    29

    30

enum {

    31

	HEADER_SIZE = 49,

    32

	BUFFER_SIZE = 4096,

    33

    34

	OLD_MAP_SIZE = 256 * 256

    35

};

    36

    37

struct LoadgameState {

    38

	FILE *file;

    39

    40

	uint chunk_size;

    41

    42

	bool decoding;

    43

	byte decode_char;

    44

    45

	uint buffer_count;

    46

	uint buffer_cur;

    47

	byte buffer[BUFFER_SIZE];

    48

    49

	uint total_read;

    50

	bool failed;

    51

};

    52

    53

/* OldChunk-Type */

    54

enum OldChunkType {

    55

	OC_SIMPLE    = 0,

    56

	OC_NULL      = 1,

    57

	OC_CHUNK     = 2,

    58

	OC_ASSERT    = 3,

    59

	/* 8 bytes allocated (256 max) */

    60

    61

	OC_VAR_I8    = 1 << 8,

    62

	OC_VAR_U8    = 2 << 8,

    63

	OC_VAR_I16   = 3 << 8,

    64

	OC_VAR_U16   = 4 << 8,

    65

	OC_VAR_I32   = 5 << 8,

    66

	OC_VAR_U32   = 6 << 8,

    67

	OC_VAR_I64   = 7 << 8,

    68

	/* 8 bytes allocated (256 max) */

    69

    70

	OC_FILE_I8   = 1 << 16,

    71

	OC_FILE_U8   = 2 << 16,

    72

	OC_FILE_I16  = 3 << 16,

    73

	OC_FILE_U16  = 4 << 16,

    74

	OC_FILE_I32  = 5 << 16,

    75

	OC_FILE_U32  = 6 << 16,

    76

	/* 8 bytes allocated (256 max) */

    77

    78

	OC_INT8      = OC_VAR_I8   | OC_FILE_I8,

    79

	OC_UINT8     = OC_VAR_U8   | OC_FILE_U8,

    80

	OC_INT16     = OC_VAR_I16  | OC_FILE_I16,

    81

	OC_UINT16    = OC_VAR_U16  | OC_FILE_U16,

    82

	OC_INT32     = OC_VAR_I32  | OC_FILE_I32,

    83

	OC_UINT32    = OC_VAR_U32  | OC_FILE_U32,

    84

    85

	OC_TILE      = OC_VAR_U32  | OC_FILE_U16,

    86

    87

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

    88

};

    89

    90

DECLARE_ENUM_AS_BIT_SET(OldChunkType);

    91

    92

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

    93

    94

struct OldChunks {

    95

	OldChunkType type;   ///< Type of field

    96

	uint32 amount;       ///< Amount of fields

    97

    98

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

    99

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

   100

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

   101

};

   102

   103

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

   104

assert_compile(sizeof(TileIndex) == 4);

   105

   106

static uint32 _bump_assert_value;

   107

static bool   _read_ttdpatch_flags;

   108

   109

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

   110

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

   111

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

   112

   113

static inline byte CalcOldVarLen(OldChunkType type)

   114

{

   115

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

   116

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

   117

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

   118

	return type_mem_size[length];

   119

}

   120

   121

/**

   122

 *

   123

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

   124

 *

   125

 */

   126

static byte ReadByteFromFile(LoadgameState *ls)

   127

{

   128

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

   129

	and just return a byte per time */

   130

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

   131

		/* Read some new bytes from the file */

   132

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

   133

   134

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

   135

		if (count == 0) {

   136

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

   137

			ls->failed = true;

   138

		}

   139

   140

		ls->buffer_count = count;

   141

		ls->buffer_cur   = 0;

   142

	}

   143

   144

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

   145

}

   146

   147

/**

   148

 *

   149

 * Reads a byte from the buffer and decompress if needed

   150

 *

   151

 */

   152

static byte ReadByte(LoadgameState *ls)

   153

{

   154

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

   155

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

   156

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

   157

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

   158

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

   159

   160

	if (ls->chunk_size == 0) {

   161

		/* Read new chunk */

   162

		int8 new_byte = ReadByteFromFile(ls);

   163

   164

		if (new_byte < 0) {

   165

			/* Repeat next char for new_byte times */

   166

			ls->decoding    = true;

   167

			ls->decode_char = ReadByteFromFile(ls);

   168

			ls->chunk_size  = -new_byte + 1;

   169

		} else {

   170

			ls->decoding    = false;

   171

			ls->chunk_size  = new_byte + 1;

   172

		}

   173

	}

   174

   175

	ls->total_read++;

   176

	ls->chunk_size--;

   177

   178

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

   179

}

   180

   181

static inline uint16 ReadUint16(LoadgameState *ls)

   182

{

   183

	byte x = ReadByte(ls);

   184

	return x | ReadByte(ls) << 8;

   185

}

   186

   187

static inline uint32 ReadUint32(LoadgameState *ls)

   188

{

   189

	uint16 x = ReadUint16(ls);

   190

	return x | ReadUint16(ls) << 16;

   191

}

   192

   193

/**

   194

 *

   195

 * Loads a chunk from the old savegame

   196

 *

   197

 */

   198

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

   199

{

   200

	const OldChunks *chunk = chunks;

   201

	byte *base_ptr = (byte*)base;

   202

   203

	while (chunk->type != OC_END) {

   204

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

   205

		uint i;

   206

   207

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

   208

			if (ls->failed) return false;

   209

   210

			/* Handle simple types */

   211

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

   212

				switch (GetOldChunkType(chunk->type)) {

   213

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

   214

					case OC_NULL: ReadByte(ls); break;

   215

   216

					case OC_CHUNK:

   217

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

   218

						 * are going to read */

   219

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

   220

						break;

   221

   222

					case OC_ASSERT:

   223

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

   224

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

   225

					default: break;

   226

				}

   227

			} else {

   228

				uint32 res = 0;

   229

   230

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

   231

				switch (GetOldChunkFileType(chunk->type)) {

   232

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

   233

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

   234

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

   235

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

   236

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

   237

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

   238

					default: NOT_REACHED();

   239

				}

   240

   241

				/* Sanity check */

   242

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

   243

   244

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

   245

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

   246

   247

				/* Write the data */

   248

				switch (GetOldChunkVarType(chunk->type)) {

   249

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

   250

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

   251

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

   252

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

   253

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

   254

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

   255

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

   256

					default: NOT_REACHED();

   257

				}

   258

   259

				/* Increase pointer base for arrays when looping */

   260

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

   261

			}

   262

		}

   263

   264

		chunk++;

   265

	}

   266

   267

	return true;

   268

}

   269

   270

/**

   271

 *

   272

 * Initialize some data before reading

   273

 *

   274

 */

   275

static void InitLoading(LoadgameState *ls)

   276

{

   277

	ls->chunk_size   = 0;

   278

	ls->total_read   = 0;

   279

	ls->failed       = false;

   280

   281

	ls->decoding     = false;

   282

	ls->decode_char  = 0;

   283

   284

	ls->buffer_cur   = 0;

   285

	ls->buffer_count = 0;

   286

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

   287

   288

	_bump_assert_value = 0;

   289

   290

	_read_ttdpatch_flags = false;

   291

}

   292

   293

   294

/*

   295

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

   296

 */

   297

   298

extern uint32 GetOldTownName(uint32 townnameparts, byte old_town_name_type);

   299

   300

static void FixOldTowns()

   301

{

   302

	Town *town;

   303

   304

	/* Convert town-names if needed */

   305

	FOR_ALL_TOWNS(town) {

   306

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

   307

			town->townnametype = SPECSTR_TOWNNAME_ENGLISH + _opt.town_name;

   308

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

   309

		}

   310

	}

   311

}

   312

   313

static void FixOldStations()

   314

{

   315

	Station *st;

   316

   317

	FOR_ALL_STATIONS(st) {

   318

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

   319

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

   320

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

   321

		}

   322

	}

   323

}

   324

   325

static void FixOldVehicles()

   326

{

   327

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

   328

	Vehicle* v;

   329

   330

	FOR_ALL_VEHICLES(v) {

   331

		Vehicle *u;

   332

   333

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

   339

   340

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

   341

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

   342

			 * in both vehicles */

   343

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

   344

				v->next_shared = u;

   345

				u->prev_shared = v;

   346

				break;

   347

			}

   348

		}

   349

	}

   350

}

   351

   352

/*

   353

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

   354

 */

   355

   356

   357

/* Help:

   358

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

   359

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

   360

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

   361

 *  - OCL_END: every struct must end with this

   362

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

   363

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

   364

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

   365

 */

   366

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

   367

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

   368

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

   369

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

   370

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

   371

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

   372

   373

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

   374

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

   375

   Old Towns are 94 bytes big

   376

   Old Orders are 2 bytes big */

   377

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

   378

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

   379

   380

extern TileIndex _animated_tile_list[256];

   381

extern char _name_array[512][32];

   382

   383

static byte   _old_vehicle_multiplier;

   384

static uint8  _old_map3[OLD_MAP_SIZE * 2];

   385

static bool   _new_ttdpatch_format;

   386

static uint32 _old_town_index;

   387

static uint16 _old_string_id;

   388

static uint16 _old_string_id_2;

   389

static uint16 _old_extra_chunk_nums;

   390

   391

static void ReadTTDPatchFlags()

   392

{

   393

	int i;

   394

   395

	if (_read_ttdpatch_flags) return;

   396

   397

	_read_ttdpatch_flags = true;

   398

   399

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

   400

	_old_vehicle_multiplier = _old_map3[0];

   401

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

   402

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

   403

	if (_old_vehicle_multiplier < 2) _old_vehicle_multiplier++;

   404

   405

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

   406

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

   407

	bump the assert value so it doesn't!

   408

	(1 multipler == 850 vehicles

   409

	1 vehicle   == 128 bytes */

   410

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

   411

   412

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

   413

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

   414

   415

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

   416

   417

	/* Clean the misused places */

   418

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

   419

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

   420

   421

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

   422

   423

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

   424

}

   425

   426

static const OldChunks town_chunk[] = {

   427

	OCL_SVAR(   OC_TILE, Town, xy ),

   428

	OCL_SVAR( OC_FILE_U16 | OC_VAR_U32, Town, population ),

   429

	OCL_SVAR( OC_UINT16, Town, townnametype ),

   430

	OCL_SVAR( OC_UINT32, Town, townnameparts ),

   431

	OCL_SVAR(  OC_UINT8, Town, grow_counter ),

   432

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

   433

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

   434

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

   435

	OCL_SVAR( OC_UINT16, Town, flags12 ),

   436

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

   437

   438

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

   439

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

   440

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

   441

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

   442

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

   443

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

   444

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

   445

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

   446

   447

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

   448

	nothing changed ? ? */

   449

	OCL_SVAR( OC_FILE_U32 | OC_VAR_U8, Town, have_ratings ),

   450

	OCL_SVAR( OC_FILE_U32 | OC_VAR_U8, Town, statues ),

   451

	OCL_SVAR( OC_UINT16, Town, num_houses ),

   452

	OCL_SVAR(  OC_UINT8, Town, time_until_rebuild ),

   453

	OCL_SVAR(  OC_UINT8, Town, growth_rate ),

   454

   455

	OCL_SVAR( OC_UINT16, Town, new_max_pass ),

   456

	OCL_SVAR( OC_UINT16, Town, new_max_mail ),

   457

	OCL_SVAR( OC_UINT16, Town, new_act_pass ),

   458

	OCL_SVAR( OC_UINT16, Town, new_act_mail ),

   459

	OCL_SVAR( OC_UINT16, Town, max_pass ),

   460

	OCL_SVAR( OC_UINT16, Town, max_mail ),

   461

	OCL_SVAR( OC_UINT16, Town, act_pass ),

   462

	OCL_SVAR( OC_UINT16, Town, act_mail ),

   463

   464

	OCL_SVAR(  OC_UINT8, Town, pct_pass_transported ),

   465

	OCL_SVAR(  OC_UINT8, Town, pct_mail_transported ),

   466

   467

	OCL_SVAR( OC_UINT16, Town, new_act_food ),

   468

	OCL_SVAR( OC_UINT16, Town, new_act_water ),

   469

	OCL_SVAR( OC_UINT16, Town, act_food ),

   470

	OCL_SVAR( OC_UINT16, Town, act_water ),

   471

   472

	OCL_SVAR(  OC_UINT8, Town, road_build_months ),

   473

	OCL_SVAR(  OC_UINT8, Town, fund_buildings_months ),

   474

   475

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

   476

   477

	OCL_END()

   478

};

   479

static bool LoadOldTown(LoadgameState *ls, int num)

   480

{

   481

	if (!AddBlockIfNeeded(&_Town_pool, num))

   482

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

   483

   484

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

   485

}

   486

   487

static uint16 _old_order;