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

    11

#include "player_func.h"

    12

#include "player_base.h"

    13

#include "engine.h"

    14

#include "aircraft.h"

    15

#include "roadveh.h"

    16

#include "ship.h"

    17

#include "train.h"

    18

#include "signs.h"

    19

#include "debug.h"

    20

#include "depot.h"

    21

#include "newgrf_config.h"

    22

#include "ai/ai.h"

    23

#include "ai/default/default.h"

    24

#include "zoom_func.h"

    25

#include "functions.h"

    26

#include "date_func.h"

    27

#include "vehicle_func.h"

    28

#include "variables.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

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

    90

};

    91

    92

DECLARE_ENUM_AS_BIT_SET(OldChunkType);

    93

    94

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

    95

    96

struct OldChunks {

    97

	OldChunkType type;   ///< Type of field

    98

	uint32 amount;       ///< Amount of fields

    99

   100

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

   101

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

   102

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

   103

};

   104

   105

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

   106

assert_compile(sizeof(TileIndex) == 4);

   107

   108

static uint32 _bump_assert_value;

   109

static bool   _read_ttdpatch_flags;

   110

   111

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

   112

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

   113

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

   114

   115

static inline byte CalcOldVarLen(OldChunkType type)

   116

{

   117

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

   118

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

   119

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

   120

	return type_mem_size[length];

   121

}

   122

   123

/**

   124

 *

   125

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

   126

 *

   127

 */

   128

static byte ReadByteFromFile(LoadgameState *ls)

   129

{

   130

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

   131

	and just return a byte per time */

   132

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

   133

		/* Read some new bytes from the file */

   134

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

   135

   136

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

   137

		if (count == 0) {

   138

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

   139

			ls->failed = true;

   140

		}

   141

   142

		ls->buffer_count = count;

   143

		ls->buffer_cur   = 0;

   144

	}

   145

   146

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

   147

}

   148

   149

/**

   150

 *

   151

 * Reads a byte from the buffer and decompress if needed

   152

 *

   153

 */

   154

static byte ReadByte(LoadgameState *ls)

   155

{

   156

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

   157

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

   158

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

   159

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

   160

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

   161

   162

	if (ls->chunk_size == 0) {

   163

		/* Read new chunk */

   164

		int8 new_byte = ReadByteFromFile(ls);

   165

   166

		if (new_byte < 0) {

   167

			/* Repeat next char for new_byte times */

   168

			ls->decoding    = true;

   169

			ls->decode_char = ReadByteFromFile(ls);

   170

			ls->chunk_size  = -new_byte + 1;

   171

		} else {

   172

			ls->decoding    = false;

   173

			ls->chunk_size  = new_byte + 1;

   174

		}

   175

	}

   176

   177

	ls->total_read++;

   178

	ls->chunk_size--;

   179

   180

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

   181

}

   182

   183

static inline uint16 ReadUint16(LoadgameState *ls)

   184

{

   185

	byte x = ReadByte(ls);

   186

	return x | ReadByte(ls) << 8;

   187

}

   188

   189

static inline uint32 ReadUint32(LoadgameState *ls)

   190

{

   191

	uint16 x = ReadUint16(ls);

   192

	return x | ReadUint16(ls) << 16;

   193

}

   194

   195

/**

   196

 *

   197

 * Loads a chunk from the old savegame

   198

 *

   199

 */

   200

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

   201

{

   202

	const OldChunks *chunk = chunks;

   203

	byte *base_ptr = (byte*)base;

   204

   205

	while (chunk->type != OC_END) {

   206

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

   207

		uint i;

   208

   209

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

   210

			if (ls->failed) return false;

   211

   212

			/* Handle simple types */

   213

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

   214

				switch (GetOldChunkType(chunk->type)) {

   215

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

   216

					case OC_NULL: ReadByte(ls); break;

   217

   218

					case OC_CHUNK:

   219

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

   220

						 * are going to read */

   221

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

   222

						break;

   223

   224

					case OC_ASSERT:

   225

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

   226

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

   227

					default: break;

   228

				}

   229

			} else {

   230

				uint64 res = 0;

   231

   232

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

   233

				switch (GetOldChunkFileType(chunk->type)) {

   234

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

   235

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

   236

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

   237

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

   238

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

   239

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

   240

					default: NOT_REACHED();

   241

				}

   242

   243

				/* Sanity check */

   244

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

   245

   246

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

   247

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

   248

   249

				/* Write the data */

   250

				switch (GetOldChunkVarType(chunk->type)) {

   251

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

   252

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

   253

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

   254

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

   255

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

   256

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

   257

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

   258

					default: NOT_REACHED();

   259

				}

   260

   261

				/* Increase pointer base for arrays when looping */

   262

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

   263

			}

   264

		}

   265

   266

		chunk++;

   267

	}

   268

   269

	return true;

   270

}

   271

   272

/**

   273

 *

   274

 * Initialize some data before reading

   275

 *

   276

 */

   277

static void InitLoading(LoadgameState *ls)

   278

{

   279

	ls->chunk_size   = 0;

   280

	ls->total_read   = 0;

   281

	ls->failed       = false;

   282

   283

	ls->decoding     = false;

   284

	ls->decode_char  = 0;

   285

   286

	ls->buffer_cur   = 0;

   287

	ls->buffer_count = 0;

   288

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

   289

   290

	_bump_assert_value = 0;

   291

   292

	_read_ttdpatch_flags = false;

   293

}

   294

   295

   296

/*

   297

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

   298

 */

   299

   300

extern uint32 GetOldTownName(uint32 townnameparts, byte old_town_name_type);

   301

   302

static void FixOldTowns()

   303

{

   304

	Town *town;

   305

   306

	/* Convert town-names if needed */

   307

	FOR_ALL_TOWNS(town) {

   308

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

   309

			town->townnametype = SPECSTR_TOWNNAME_ENGLISH + _opt.town_name;

   310

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

   311

		}

   312

	}

   313

}

   314

   315

static void FixOldStations()

   316

{

   317

	Station *st;

   318

   319

	FOR_ALL_STATIONS(st) {

   320

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

   321

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

   322

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

   323

		}

   324

	}

   325

}

   326

   327

static void FixOldVehicles()

   328

{

   329

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

   330

	Vehicle* v;

   331

   332

	FOR_ALL_VEHICLES(v) {

   333

		Vehicle *u;

   334

   335

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

   336

		if (v->type == VEH_ROAD &&

   337

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

   338

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

   339

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

   340

		}

   341

   342

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

   343

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

   344

			 * in both vehicles */

   345

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

   346

				v->next_shared = u;

   347

				u->prev_shared = v;

   348

				break;

   349

			}

   350

		}

   351

	}

   352

}

   353

   354

/*

   355

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

   356

 */

   357

   358

   359

/* Help:

   360

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

   361

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

   362

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

   363

 *  - OCL_END: every struct must end with this

   364

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

   365

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

   366

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

   367

 */

   368

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

   369

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

   370

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

   371

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

   372

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

   373

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

   374

   375

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

   376

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

   377

   Old Towns are 94 bytes big

   378

   Old Orders are 2 bytes big */

   379

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

   380

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

   381

   382

extern TileIndex *_animated_tile_list;

   383

extern uint _animated_tile_count;

   384

extern char _name_array[512][32];

   385

   386

static byte   _old_vehicle_multiplier;

   387

static uint8  _old_map3[OLD_MAP_SIZE * 2];

   388

static bool   _new_ttdpatch_format;

   389

static uint32 _old_town_index;

   390

static uint16 _old_string_id;

   391

static uint16 _old_string_id_2;

   392

static uint16 _old_extra_chunk_nums;

   393

   394

static void ReadTTDPatchFlags()

   395

{

   396

	int i;

   397

   398

	if (_read_ttdpatch_flags) return;

   399

   400

	_read_ttdpatch_flags = true;

   401

   402

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

   403

	_old_vehicle_multiplier = _old_map3[0];

   404

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

   405

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

   406

	if (_old_vehicle_multiplier < 2) _old_vehicle_multiplier++;

   407

   408

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

   409

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

   410

	bump the assert value so it doesn't!

   411

	(1 multipler == 850 vehicles

   412

	1 vehicle   == 128 bytes */

   413

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

   414

   415

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

   416

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

   417

   418

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

   419

   420

	/* Clean the misused places */

   421

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

   422

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

   423

   424

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

   425

   426

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

   427

}

   428

   429

static const OldChunks town_chunk[] = {

   430

	OCL_SVAR(   OC_TILE, Town, xy ),

   431

	OCL_SVAR( OC_FILE_U16 | OC_VAR_U32, Town, population ),

   432

	OCL_SVAR( OC_UINT16, Town, townnametype ),

   433

	OCL_SVAR( OC_UINT32, Town, townnameparts ),

   434

	OCL_SVAR(  OC_UINT8, Town, grow_counter ),

   435

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

   436

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

   437

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

   438

	OCL_SVAR( OC_UINT16, Town, flags12 ),

   439

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

   440

   441

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

   442

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

   443

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

   444

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

   445

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

   446

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

   447

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

   448

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

   449

   450

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

   451

	nothing changed ? ? */

   452

	OCL_SVAR( OC_FILE_U32 | OC_VAR_U8, Town, have_ratings ),

   453

	OCL_SVAR( OC_FILE_U32 | OC_VAR_U8, Town, statues ),

   454

	OCL_SVAR( OC_UINT16, Town, num_houses ),

   455

	OCL_SVAR(  OC_UINT8, Town, time_until_rebuild ),

   456

	OCL_SVAR(  OC_UINT8, Town, growth_rate ),

   457

   458

	OCL_SVAR( OC_UINT16, Town, new_max_pass ),

   459

	OCL_SVAR( OC_UINT16, Town, new_max_mail ),

   460

	OCL_SVAR( OC_UINT16, Town, new_act_pass ),

   461

	OCL_SVAR( OC_UINT16, Town, new_act_mail ),

   462

	OCL_SVAR( OC_UINT16, Town, max_pass ),

   463

	OCL_SVAR( OC_UINT16, Town, max_mail ),

   464

	OCL_SVAR( OC_UINT16, Town, act_pass ),

   465

	OCL_SVAR( OC_UINT16, Town, act_mail ),

   466

   467

	OCL_SVAR(  OC_UINT8, Town, pct_pass_transported ),

   468

	OCL_SVAR(  OC_UINT8, Town, pct_mail_transported ),

   469

   470

	OCL_SVAR( OC_UINT16, Town, new_act_food ),

   471

	OCL_SVAR( OC_UINT16, Town, new_act_water ),

   472

	OCL_SVAR( OC_UINT16, Town, act_food ),

   473

	OCL_SVAR( OC_UINT16, Town, act_water ),

   474

   475

	OCL_SVAR(  OC_UINT8, Town, road_build_months ),

   476

	OCL_SVAR(  OC_UINT8, Town, fund_buildings_months ),

   477

   478

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

   479

   480

	OCL_END()

   481

};

   482

static bool LoadOldTown(LoadgameState *ls, int num)

   483

{

   484

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

   485

}

   486