1

/* $Id$ */

     2

     3

#include "stdafx.h"

     4

#include "openttd.h"

     5

#include "station_map.h"

     6

#include "table/strings.h"

     7

#include "functions.h"

     8

#include "map.h"

     9

#include "town.h"

    10

#include "industry.h"

    11

#include "station.h"

    12

#include "economy.h"

    13

#include "player.h"

    14

#include "engine.h"

    15

#include "vehicle.h"

    16

#include "signs.h"

    17

#include "debug.h"

    18

#include "depot.h"

    19

#include "network/network.h"

    20

#include "ai/ai.h"

    21

#include "date.h"

    22

    23

enum {

    24

	HEADER_SIZE = 49,

    25

	BUFFER_SIZE = 4096,

    26

    27

	OLD_MAP_SIZE = 256 * 256

    28

};

    29

    30

typedef struct LoadgameState {

    31

	FILE *file;

    32

    33

	uint chunk_size;

    34

    35

	bool decoding;

    36

	byte decode_char;

    37

    38

	uint buffer_count;

    39

	uint buffer_cur;

    40

	byte buffer[BUFFER_SIZE];

    41

    42

	uint total_read;

    43

	bool failed;

    44

} LoadgameState;

    45

    46

/* OldChunk-Type */

    47

typedef enum OldChunkTypes {

    48

	OC_SIMPLE    = 0,

    49

	OC_NULL      = 1,

    50

	OC_CHUNK     = 2,

    51

	OC_ASSERT    = 3,

    52

	/* 8 bytes allocated (256 max) */

    53

    54

	OC_VAR_I8    = 1 << 8,

    55

	OC_VAR_U8    = 2 << 8,

    56

	OC_VAR_I16   = 3 << 8,

    57

	OC_VAR_U16   = 4 << 8,

    58

	OC_VAR_I32   = 5 << 8,

    59

	OC_VAR_U32   = 6 << 8,

    60

	OC_VAR_I64   = 7 << 8,

    61

	/* 8 bytes allocated (256 max) */

    62

    63

	OC_FILE_I8   = 1 << 16,

    64

	OC_FILE_U8   = 2 << 16,

    65

	OC_FILE_I16  = 3 << 16,

    66

	OC_FILE_U16  = 4 << 16,

    67

	OC_FILE_I32  = 5 << 16,

    68

	OC_FILE_U32  = 6 << 16,

    69

	/* 8 bytes allocated (256 max) */

    70

    71

	OC_INT8      = OC_VAR_I8   | OC_FILE_I8,

    72

	OC_UINT8     = OC_VAR_U8   | OC_FILE_U8,

    73

	OC_INT16     = OC_VAR_I16  | OC_FILE_I16,

    74

	OC_UINT16    = OC_VAR_U16  | OC_FILE_U16,

    75

	OC_INT32     = OC_VAR_I32  | OC_FILE_I32,

    76

	OC_UINT32    = OC_VAR_U32  | OC_FILE_U32,

    77

    78

	OC_TILE      = OC_VAR_U32  | OC_FILE_U16,

    79

    80

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

    81

} OldChunkType;

    82

    83

DECLARE_ENUM_AS_BIT_SET(OldChunkType);

    84

    85

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

    86

    87

typedef struct OldChunks {

    88

	OldChunkType type;   ///< Type of field

    89

	uint32 amount;       ///< Amount of fields

    90

    91

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

    92

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

    93

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

    94

} OldChunks;

    95

    96

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

    97

assert_compile(sizeof(TileIndex) == 4);

    98

    99

static uint32 _bump_assert_value;

   100

static bool   _read_ttdpatch_flags;

   101

   102

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

   103

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

   104

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

   105

   106

static inline byte CalcOldVarLen(OldChunkType type)

   107

{

   108

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

   109

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

   110

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

   111

	return type_mem_size[length];

   112

}

   113

   114

/**

   115

 *

   116

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

   117

 *

   118

 */

   119

static byte ReadByteFromFile(LoadgameState *ls)

   120

{

   121

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

   122

	and just return a byte per time */

   123

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

   124

		/* Read some new bytes from the file */

   125

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

   126

   127

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

   128

		if (count == 0) {

   129

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

   130

			ls->failed = true;

   131

		}

   132

   133

		ls->buffer_count = count;

   134

		ls->buffer_cur   = 0;

   135

	}

   136

   137

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

   138

}

   139

   140

/**

   141

 *

   142

 * Reads a byte from the buffer and decompress if needed

   143

 *

   144

 */

   145

static byte ReadByte(LoadgameState *ls)

   146

{

   147

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

   148

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

   149

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

   150

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

   151

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

   152

   153

	if (ls->chunk_size == 0) {

   154

		/* Read new chunk */

   155

		int8 new_byte = ReadByteFromFile(ls);

   156

   157

		if (new_byte < 0) {

   158

			/* Repeat next char for new_byte times */

   159

			ls->decoding    = true;

   160

			ls->decode_char = ReadByteFromFile(ls);

   161

			ls->chunk_size  = -new_byte + 1;

   162

		} else {

   163

			ls->decoding    = false;

   164

			ls->chunk_size  = new_byte + 1;

   165

		}

   166

	}

   167

   168

	ls->total_read++;

   169

	ls->chunk_size--;

   170

   171

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

   172

}

   173

   174

static inline uint16 ReadUint16(LoadgameState *ls)

   175

{

   176

	byte x = ReadByte(ls);

   177

	return x | ReadByte(ls) << 8;

   178

}

   179

   180

static inline uint32 ReadUint32(LoadgameState *ls)

   181

{

   182

	uint16 x = ReadUint16(ls);

   183

	return x | ReadUint16(ls) << 16;

   184

}

   185

   186

/**

   187

 *

   188

 * Loads a chunk from the old savegame

   189

 *

   190

 */

   191

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

   192

{

   193

	const OldChunks *chunk = chunks;

   194

	byte *base_ptr = (byte*)base;

   195

   196

	while (chunk->type != OC_END) {

   197

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

   198

		uint i;

   199

   200

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

   201

			if (ls->failed) return false;

   202

   203

			/* Handle simple types */

   204

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

   205

				switch (GetOldChunkType(chunk->type)) {

   206

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

   207

					case OC_NULL: ReadByte(ls); break;

   208

   209

					case OC_CHUNK:

   210

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

   211

						 * are going to read */

   212

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

   213

						break;

   214

   215

					case OC_ASSERT:

   216

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

   217

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

   218

					default: break;

   219

				}

   220

			} else {

   221

				uint32 res = 0;

   222

   223

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

   224

				switch (GetOldChunkFileType(chunk->type)) {

   225

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

   226

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

   227

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

   228

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

   229

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

   230

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

   231

					default: NOT_REACHED();

   232

				}

   233

   234

				/* Sanity check */

   235

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

   236

   237

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

   238

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

   239

   240

				/* Write the data */

   241

				switch (GetOldChunkVarType(chunk->type)) {

   242

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

   243

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

   244

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

   245

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

   246

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

   247

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

   248

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

   249

					default: NOT_REACHED();

   250

				}

   251

   252

				/* Increase pointer base for arrays when looping */

   253

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

   254

			}

   255

		}

   256

   257

		chunk++;

   258

	}

   259

   260

	return true;

   261

}

   262

   263

/**

   264

 *

   265

 * Initialize some data before reading

   266

 *

   267

 */

   268

static void InitLoading(LoadgameState *ls)

   269

{

   270

	ls->chunk_size   = 0;

   271

	ls->total_read   = 0;

   272

	ls->failed       = false;

   273

   274

	ls->decoding     = false;

   275

	ls->decode_char  = 0;

   276

   277

	ls->buffer_cur   = 0;

   278

	ls->buffer_count = 0;

   279

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

   280

   281

	_bump_assert_value = 0;

   282

   283

	_read_ttdpatch_flags = false;

   284

}

   285

   286

   287

/*

   288

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

   289

 */

   290

   291

extern uint32 GetOldTownName(uint32 townnameparts, byte old_town_name_type);

   292

   293

static void FixOldTowns(void)

   294

{

   295

	Town *town;

   296

   297

	/* Convert town-names if needed */

   298

	FOR_ALL_TOWNS(town) {

   299

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

   300

			town->townnametype = SPECSTR_TOWNNAME_ENGLISH + _opt.town_name;

   301

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

   302

		}

   303

	}

   304

}

   305

   306

static void FixOldStations(void)

   307

{

   308

	Station *st;

   309

   310

	FOR_ALL_STATIONS(st) {

   311

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

   312

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

   313

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

   314

		}

   315

	}

   316

}

   317

   318

static void FixOldVehicles(void)

   319

{

   320

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

   321

	Vehicle* v;

   322

   323

	FOR_ALL_VEHICLES(v) {

   324

		Vehicle *u;

   325

   326

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

   327

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

   328

			 * in both vehicles */

   329

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

   330

				v->next_shared = u;

   331

				u->prev_shared = v;

   332

				break;

   333

			}

   334

		}

   335

	}

   336

}

   337

   338

/*

   339

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

   340

 */

   341

   342

   343

/* Help:

   344

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

   345

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

   346

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

   347

 *  - OCL_END: every struct must end with this

   348

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

   349

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

   350

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

   351

 */

   352

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

   353

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

   354

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

   355

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

   356

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

   357

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

   358

   359

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

   360

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

   361

   Old Towns are 94 bytes big

   362

   Old Orders are 2 bytes big */

   363

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

   364

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

   365

   366

extern TileIndex _animated_tile_list[256];

   367

extern char _name_array[512][32];

   368

   369

static byte   _old_vehicle_multiplier;

   370

static uint8  _old_map3[OLD_MAP_SIZE * 2];

   371

static bool   _new_ttdpatch_format;

   372

static uint32 _old_town_index;

   373

static uint16 _old_string_id;

   374

static uint16 _old_string_id_2;

   376

   377

static void ReadTTDPatchFlags(void)

   378

{

   379

	int i;

   380

   381

	if (_read_ttdpatch_flags) return;

   382

   383

	_read_ttdpatch_flags = true;

   384

   385

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

   386

	_old_vehicle_multiplier = _old_map3[0];

   387

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

   388

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

   389

	if (_old_vehicle_multiplier < 2) _old_vehicle_multiplier++;

   390

   391

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

   392

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

   393

	bump the assert value so it doesn't!

   394

	(1 multipler == 850 vehicles

   395

	1 vehicle   == 128 bytes */

   396

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

   397

   398

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

   399

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

   400

   403

	/* Clean the misused places */

   404

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

   405

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

   406

   407

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

   408

   409

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

   410

}

   411

   412

static const OldChunks town_chunk[] = {

   413

	OCL_SVAR(   OC_TILE, Town, xy ),

   414

	OCL_SVAR( OC_FILE_U16 | OC_VAR_U32, Town, population ),

   415

	OCL_SVAR( OC_UINT16, Town, townnametype ),

   416

	OCL_SVAR( OC_UINT32, Town, townnameparts ),

   417

	OCL_SVAR(  OC_UINT8, Town, grow_counter ),

   418

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

   419

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

   420

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

   421

	OCL_SVAR( OC_UINT16, Town, flags12 ),

   422

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

   423

   424

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

   425

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

   426

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

   427

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

   428

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

   429

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

   430

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

   431

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

   432

   433

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

   434

	nothing changed?? */

   435

	OCL_SVAR( OC_FILE_U32 | OC_VAR_U8, Town, have_ratings ),

   436

	OCL_SVAR( OC_FILE_U32 | OC_VAR_U8, Town, statues ),

   437

	OCL_SVAR( OC_UINT16, Town, num_houses ),

   438

	OCL_SVAR(  OC_UINT8, Town, time_until_rebuild ),

   439

	OCL_SVAR(  OC_UINT8, Town, growth_rate ),

   440

   441

	OCL_SVAR( OC_UINT16, Town, new_max_pass ),

   442

	OCL_SVAR( OC_UINT16, Town, new_max_mail ),

   443

	OCL_SVAR( OC_UINT16, Town, new_act_pass ),

   444

	OCL_SVAR( OC_UINT16, Town, new_act_mail ),

   445

	OCL_SVAR( OC_UINT16, Town, max_pass ),

   446

	OCL_SVAR( OC_UINT16, Town, max_mail ),

   447

	OCL_SVAR( OC_UINT16, Town, act_pass ),

   448

	OCL_SVAR( OC_UINT16, Town, act_mail ),

   449

   450

	OCL_SVAR(  OC_UINT8, Town, pct_pass_transported ),

   451

	OCL_SVAR(  OC_UINT8, Town, pct_mail_transported ),

   452

   453

	OCL_SVAR( OC_UINT16, Town, new_act_food ),

   454

	OCL_SVAR( OC_UINT16, Town, new_act_water ),

   455

	OCL_SVAR( OC_UINT16, Town, act_food ),

   456

	OCL_SVAR( OC_UINT16, Town, act_water ),

   457

   458

	OCL_SVAR(  OC_UINT8, Town, road_build_months ),

   459

	OCL_SVAR(  OC_UINT8, Town, fund_buildings_months ),

   460

   461

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

   462

   463

	OCL_END()

   464

};

   465

static bool LoadOldTown(LoadgameState *ls, int num)

   466

{

   467

	if (!AddBlockIfNeeded(&_Town_pool, num))

   468

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

   469

   470

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

   471

}

   472

   473

static uint16 _old_order;

   474

static const OldChunks order_chunk[] = {

   475

	OCL_VAR ( OC_UINT16,   1, &_old_order ),

   476

	OCL_END()

   477

};

   478

   479

static bool LoadOldOrder(LoadgameState *ls, int num)

   480

{

   481

	if (!AddBlockIfNeeded(&_Order_pool, num))

   482

		error("Orders: failed loading savegame: too many orders");

   483

   484

	if (!LoadChunk(ls, NULL, order_chunk)) return false;

   485

   486

	AssignOrder(GetOrder(num), UnpackOldOrder(_old_order));

   487

   488

	/* Relink the orders to eachother (in TTD(Patch) the orders for one