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.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

    28

#include "table/strings.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

				uint64 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 (IsInsideMM(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 */

   334

		if (v->type == VEH_ROAD &&

   335

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

   336

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

   337

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

   338

		}

   339

   340

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

   341

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

   342

   343

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

   344

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

   345

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

   346

		 */

   347

		if (!IsPlayerBuildableVehicleType(v) ||

   348

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

   349

			v->current_order.MakeDummy();

   350

		}

   351

   352

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

   353

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

   354

			 * in both vehicles */

   355

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

   356

				v->next_shared = u;

   357

				u->prev_shared = v;

   358

				break;

   359

			}

   360

		}

   361

	}

   362

}

   363

   364

/*

   365

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

   366

 */

   367

   368

   369

/* Help:

   370

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

   371

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

   372

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

   373

 *  - OCL_END: every struct must end with this

   374

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

   375

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

   376

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

   377

 */

   378

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

   379

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

   380

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

   381

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

   382

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

   383

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

   384

   385

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

   386

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

   387

   Old Towns are 94 bytes big

   388

   Old Orders are 2 bytes big */

   389

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

   390

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

   391

   392

extern TileIndex *_animated_tile_list;

   393

extern uint _animated_tile_count;

   394

extern char _name_array[512][32];

   395

   396

static byte   _old_vehicle_multiplier;

   397

static uint8  _old_map3[OLD_MAP_SIZE * 2];

   398

static bool   _new_ttdpatch_format;

   399

static uint32 _old_town_index;

   400

static uint16 _old_string_id;

   401

static uint16 _old_string_id_2;

   402

static uint16 _old_extra_chunk_nums;

   403

   404

static void ReadTTDPatchFlags()

   405

{

   406

	int i;

   407

   408

	if (_read_ttdpatch_flags) return;

   409

   410

	_read_ttdpatch_flags = true;

   411

   412

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

   413

	_old_vehicle_multiplier = _old_map3[0];

   414

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

   415

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

   416

	if (_old_vehicle_multiplier < 2) _old_vehicle_multiplier++;

   417

   418

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

   419

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

   420

	bump the assert value so it doesn't!

   421

	(1 multipler == 850 vehicles

   422

	1 vehicle   == 128 bytes */

   423

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

   424

   425

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

   426

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

   427

   428

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

   429

   430

	/* Clean the misused places */

   431

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

   432

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

   433

   434

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

   435

   436

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

   437

}

   438

   439

static const OldChunks town_chunk[] = {

   440

	OCL_SVAR(   OC_TILE, Town, xy ),

   441

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

   442

	OCL_SVAR( OC_UINT16, Town, townnametype ),

   443

	OCL_SVAR( OC_UINT32, Town, townnameparts ),

   444

	OCL_SVAR(  OC_UINT8, Town, grow_counter ),

   445

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

   446

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

   447

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

   448

	OCL_SVAR( OC_UINT16, Town, flags12 ),

   449

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

   450

   451

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

   452

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

   453

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

   454

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

   455

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

   456

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

   457

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

   458

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

   459

   460

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

   461

	nothing changed ? ? */

   462

	OCL_SVAR( OC_FILE_U32 | OC_VAR_U8, Town, have_ratings ),

   463

	OCL_SVAR( OC_FILE_U32 | OC_VAR_U8, Town, statues ),

   464

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

   465

	OCL_SVAR(  OC_UINT8, Town, time_until_rebuild ),

   466

	OCL_SVAR(  OC_UINT8, Town, growth_rate ),

   467

   468

	OCL_SVAR( OC_UINT16, Town, new_max_pass ),

   469

	OCL_SVAR( OC_UINT16, Town, new_max_mail ),

   470

	OCL_SVAR( OC_UINT16, Town, new_act_pass ),

   471

	OCL_SVAR( OC_UINT16, Town, new_act_mail ),

   472

	OCL_SVAR( OC_UINT16, Town, max_pass ),

   473

	OCL_SVAR( OC_UINT16, Town, max_mail ),

   474

	OCL_SVAR( OC_UINT16, Town, act_pass ),

   475

	OCL_SVAR( OC_UINT16, Town, act_mail ),

   476

   477

	OCL_SVAR(  OC_UINT8, Town, pct_pass_transported ),

   478

	OCL_SVAR(  OC_UINT8, Town, pct_mail_transported ),

   479

   480

	OCL_SVAR( OC_UINT16, Town, new_act_food ),

   481

	OCL_SVAR( OC_UINT16, Town, new_act_water ),

   482

	OCL_SVAR( OC_UINT16, Town, act_food ),

   483

	OCL_SVAR( OC_UINT16, Town, act_water ),

   484

   485

	OCL_SVAR(  OC_UINT8, Town, road_build_months ),

   486

	OCL_SVAR(  OC_UINT8, Town, fund_buildings_months ),