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

    15

#include "engine.h"

    16

#include "vehicle.h"

    17

#include "aircraft.h"

    18

#include "roadveh.h"

    19

#include "ship.h"

    20

#include "train.h"

    21

#include "signs.h"

    22

#include "debug.h"

    23

#include "depot.h"

    24

#include "newgrf_config.h"

    25

#include "ai/ai.h"

    26

#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

				uint64 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 (IsInsideMM(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;

   380

extern uint _animated_tile_count;

   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

	return LoadChunk(ls, new (num) Town(), town_chunk);

   482

}

   483

   484

static uint16 _old_order;

   485

static const OldChunks order_chunk[] = {

   486

	OCL_VAR ( OC_UINT16,   1, &_old_order ),

   487

	OCL_END()