1

/* $Id$ */

     2

     3

/** @file oldloader.cpp */

     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"

    28

    29

#include "table/strings.h"

    30

    31

enum {

    32

	HEADER_SIZE = 49,

    33

	BUFFER_SIZE = 4096,

    34

    35

	OLD_MAP_SIZE = 256 * 256

    36

};

    37

    38

struct LoadgameState {

    39

	FILE *file;

    40

    41

	uint chunk_size;

    42

    43

	bool decoding;

    44

	byte decode_char;

    45

    46

	uint buffer_count;

    47

	uint buffer_cur;

    48

	byte buffer[BUFFER_SIZE];

    49

    50

	uint total_read;

    51

	bool failed;

    52

};

    53

    54

/* OldChunk-Type */

    55

enum OldChunkType {

    56

	OC_SIMPLE    = 0,

    57

	OC_NULL      = 1,

    58

	OC_CHUNK     = 2,

    59

	OC_ASSERT    = 3,

    60

	/* 8 bytes allocated (256 max) */

    61

    62

	OC_VAR_I8    = 1 << 8,

    63

	OC_VAR_U8    = 2 << 8,

    64

	OC_VAR_I16   = 3 << 8,

    65

	OC_VAR_U16   = 4 << 8,

    66

	OC_VAR_I32   = 5 << 8,

    67

	OC_VAR_U32   = 6 << 8,

    68

	OC_VAR_I64   = 7 << 8,

    69

	/* 8 bytes allocated (256 max) */

    70

    71

	OC_FILE_I8   = 1 << 16,

    72

	OC_FILE_U8   = 2 << 16,

    73

	OC_FILE_I16  = 3 << 16,

    74

	OC_FILE_U16  = 4 << 16,

    75

	OC_FILE_I32  = 5 << 16,

    76

	OC_FILE_U32  = 6 << 16,

    77

	/* 8 bytes allocated (256 max) */

    78

    79

	OC_INT8      = OC_VAR_I8   | OC_FILE_I8,

    80

	OC_UINT8     = OC_VAR_U8   | OC_FILE_U8,

    81

	OC_INT16     = OC_VAR_I16  | OC_FILE_I16,

    82

	OC_UINT16    = OC_VAR_U16  | OC_FILE_U16,

    83

	OC_INT32     = OC_VAR_I32  | OC_FILE_I32,

    84

	OC_UINT32    = OC_VAR_U32  | OC_FILE_U32,

    85

    86

	OC_TILE      = OC_VAR_U32  | OC_FILE_U16,

    87

    94

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

    95

};

    96

    97

DECLARE_ENUM_AS_BIT_SET(OldChunkType);

    98

    99

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

   100

   101

struct OldChunks {

   102

	OldChunkType type;   ///< Type of field

   103

	uint32 amount;       ///< Amount of fields

   104

   105

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

   106

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

   107

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

   108

};

   109

   110

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

   111

assert_compile(sizeof(TileIndex) == 4);

   112

   113

static uint32 _bump_assert_value;

   114

static bool   _read_ttdpatch_flags;

   115

   116

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

   117

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

   118

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

   119

   120

static inline byte CalcOldVarLen(OldChunkType type)

   121

{

   122

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

   123

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

   124

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

   125

	return type_mem_size[length];

   126

}

   127

   128

/**

   129

 *

   130

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

   131

 *

   132

 */

   133

static byte ReadByteFromFile(LoadgameState *ls)

   134

{

   135

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

   136

	and just return a byte per time */

   137

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

   138

		/* Read some new bytes from the file */

   139

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

   140

   141

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

   142

		if (count == 0) {

   143

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

   144

			ls->failed = true;

   145

		}

   146

   147

		ls->buffer_count = count;

   148

		ls->buffer_cur   = 0;

   149

	}

   150

   151

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

   152

}

   153

   154

/**

   155

 *

   156

 * Reads a byte from the buffer and decompress if needed

   157

 *

   158

 */

   159

static byte ReadByte(LoadgameState *ls)

   160

{

   161

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

   162

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

   163

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

   164

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

   165

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

   166

   167

	if (ls->chunk_size == 0) {

   168

		/* Read new chunk */

   169

		int8 new_byte = ReadByteFromFile(ls);

   170

   171

		if (new_byte < 0) {

   172

			/* Repeat next char for new_byte times */

   173

			ls->decoding    = true;

   174

			ls->decode_char = ReadByteFromFile(ls);

   175

			ls->chunk_size  = -new_byte + 1;

   176

		} else {

   177

			ls->decoding    = false;

   178

			ls->chunk_size  = new_byte + 1;

   179

		}

   180

	}

   181

   182

	ls->total_read++;

   183

	ls->chunk_size--;

   184

   185

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

   186

}

   187

   188

static inline uint16 ReadUint16(LoadgameState *ls)

   189

{

   190

	byte x = ReadByte(ls);

   191

	return x | ReadByte(ls) << 8;

   192

}

   193

   194

static inline uint32 ReadUint32(LoadgameState *ls)

   195

{

   196

	uint16 x = ReadUint16(ls);

   197

	return x | ReadUint16(ls) << 16;

   198

}

   199

   200

/**

   201

 *

   202

 * Loads a chunk from the old savegame

   203

 *

   204

 */

   205

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

   206

{

   207

	const OldChunks *chunk = chunks;

   208

	byte *base_ptr = (byte*)base;

   209

   210

	while (chunk->type != OC_END) {

   213

   215

			if (ls->failed) return false;

   216

   217

			/* Handle simple types */

   218

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

   219

				switch (GetOldChunkType(chunk->type)) {

   220

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

   221

					case OC_NULL: ReadByte(ls); break;

   222

   223

					case OC_CHUNK:

   224

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

   225

						 * are going to read */

   226

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

   227

						break;

   228

   229

					case OC_ASSERT:

   230

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

   231

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

   232

					default: break;

   233

				}

   234

			} else {

   235

				uint64 res = 0;

   236

   237

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

   238

				switch (GetOldChunkFileType(chunk->type)) {

   239

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

   240

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

   241

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

   242

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

   243

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

   244

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

   245

					default: NOT_REACHED();

   246

				}

   247

   248

				/* Sanity check */

   249

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

   250

   251

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

   252

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

   253

   254

				/* Write the data */

   255

				switch (GetOldChunkVarType(chunk->type)) {

   256

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

   257

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

   258

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

   259

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

   260

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

   261

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

   262

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

   263

					default: NOT_REACHED();

   264

				}

   265

   266

				/* Increase pointer base for arrays when looping */

   267

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

   268

			}

   269

		}

   270

   271

		chunk++;

   272

	}

   273

   274

	return true;

   275

}

   276

   277

/**

   278

 *

   279

 * Initialize some data before reading

   280

 *

   281

 */

   282

static void InitLoading(LoadgameState *ls)

   283

{

   284

	ls->chunk_size   = 0;

   285

	ls->total_read   = 0;

   286

	ls->failed       = false;

   287

   288

	ls->decoding     = false;

   289

	ls->decode_char  = 0;

   290

   291

	ls->buffer_cur   = 0;

   292

	ls->buffer_count = 0;

   293

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

   294

   295

	_bump_assert_value = 0;

   296

   297

	_read_ttdpatch_flags = false;

   298

}

   299

   300

   301

/*

   302

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

   303

 */

   304

   305

extern uint32 GetOldTownName(uint32 townnameparts, byte old_town_name_type);

   306

   307

static void FixOldTowns()

   308

{

   309

	Town *town;

   310

   311

	/* Convert town-names if needed */

   312

	FOR_ALL_TOWNS(town) {

   313

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

   314

			town->townnametype = SPECSTR_TOWNNAME_ENGLISH + _opt.town_name;

   315

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

   316

		}

   317

	}

   318

}

   319

   320

static void FixOldStations()

   321

{

   322

	Station *st;

   323

   324

	FOR_ALL_STATIONS(st) {

   325

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

   326

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

   327

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

   328

		}

   329

	}

   330

}

   331

   332

static void FixOldVehicles()

   333

{

   334

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

   335

	Vehicle* v;

   336

   337

	FOR_ALL_VEHICLES(v) {

   338

		Vehicle *u;

   339

   340

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

   341

		if (v->type == VEH_ROAD &&

   342

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

   343

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

   344

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

   345

		}

   346

   347

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

   348

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

   349

   350

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

   351

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

   352

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

   353

		 */

   354

		if (!IsPlayerBuildableVehicleType(v) ||

   355

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

   356

			v->current_order.MakeDummy();

   357

		}

   358

   359

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

   360

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

   361

			 * in both vehicles */

   362

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

   363

				v->next_shared = u;

   364

				u->prev_shared = v;

   365

				break;

   366

			}

   367

		}

   368

	}

   369

}

   370

   371

/*

   372

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

   373

 */

   374

   375

   376

/* Help:

   377

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

   378

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

   379

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

   380

 *  - OCL_END: every struct must end with this

   381

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

   382

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

   383

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

   384

 */

   385

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

   386

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

   387

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

   388

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

   389

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

   390

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

   391

   392

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

   393

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

   394

   Old Towns are 94 bytes big

   395

   Old Orders are 2 bytes big */

   396

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

   397

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

   398

   399

extern TileIndex *_animated_tile_list;

   400

extern uint _animated_tile_count;

   402

   403

static byte   _old_vehicle_multiplier;

   405

static bool   _new_ttdpatch_format;

   406

static uint32 _old_town_index;

   407

static uint16 _old_string_id;

   408

static uint16 _old_string_id_2;

   409

static uint16 _old_extra_chunk_nums;

   410

   411

static void ReadTTDPatchFlags()

   412

{

   413

	int i;

   414

   415

	if (_read_ttdpatch_flags) return;

   416

   417

	_read_ttdpatch_flags = true;

   418

   419

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

   420

	_old_vehicle_multiplier = _old_map3[0];

   421

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

   422

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

   423

	if (_old_vehicle_multiplier < 2) _old_vehicle_multiplier++;

   424

   425

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

   426

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

   427

	bump the assert value so it doesn't!

   428

	(1 multipler == 850 vehicles

   429

	1 vehicle   == 128 bytes */

   430

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

   431

   432

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

   433

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

   434

   435

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

   436

   437

	/* Clean the misused places */

   438

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

   439

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

   440

   441

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

   442

   443

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

   444

}

   445

   446

static const OldChunks town_chunk[] = {

   447

	OCL_SVAR(   OC_TILE, Town, xy ),

   448

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

   449

	OCL_SVAR( OC_UINT16, Town, townnametype ),

   450

	OCL_SVAR( OC_UINT32, Town, townnameparts ),

   451

	OCL_SVAR(  OC_UINT8, Town, grow_counter ),

   452

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

   453

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

   454

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

   455

	OCL_SVAR( OC_UINT16, Town, flags12 ),

   456

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

   457

   458

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

   459

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

   460

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

   461

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

   462

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

   463

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

   464

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

   465

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

   466

   467

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

   468

	nothing changed ? ? */

   469

	OCL_SVAR( OC_FILE_U32 | OC_VAR_U8, Town, have_ratings ),

   470

	OCL_SVAR( OC_FILE_U32 | OC_VAR_U8, Town, statues ),

   471

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

   472

	OCL_SVAR(  OC_UINT8, Town, time_until_rebuild ),

   473

	OCL_SVAR(  OC_UINT8, Town, growth_rate ),

   474

   475

	OCL_SVAR( OC_UINT16, Town, new_max_pass ),

   476

	OCL_SVAR( OC_UINT16, Town, new_max_mail ),

   477

	OCL_SVAR( OC_UINT16, Town, new_act_pass ),

   478

	OCL_SVAR( OC_UINT16, Town, new_act_mail ),

   479

	OCL_SVAR( OC_UINT16, Town, max_pass ),

   480

	OCL_SVAR( OC_UINT16, Town, max_mail ),

   481

	OCL_SVAR( OC_UINT16, Town, act_pass ),

   482

	OCL_SVAR( OC_UINT16, Town, act_mail ),

   483

   484

	OCL_SVAR(  OC_UINT8, Town, pct_pass_transported ),

   485

	OCL_SVAR(  OC_UINT8, Town, pct_mail_transported ),

   486