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

    20

#include "ai/ai.h"

    21

#include "date.h"

    22

#include "bridge_map.h"

    23

    24

enum {

    25

	HEADER_SIZE = 49,

    26

	BUFFER_SIZE = 4096,

    27

    28

	OLD_MAP_SIZE = 256 * 256

    29

};

    30

    31

typedef struct LoadgameState {

    32

	FILE *file;

    33

    34

	uint chunk_size;

    35

    36

	bool decoding;

    37

	byte decode_char;

    38

    39

	uint buffer_count;

    40

	uint buffer_cur;

    41

	byte buffer[BUFFER_SIZE];

    42

    43

	uint total_read;

    44

	bool failed;

    45

} LoadgameState;

    46

    47

/* OldChunk-Type */

    48

typedef enum OldChunkTypes {

    49

	OC_SIMPLE    = 0,

    50

	OC_NULL      = 1,

    51

	OC_CHUNK     = 2,

    52

	OC_ASSERT    = 3,

    53

	/* 8 bytes allocated (256 max) */

    54

    55

	OC_VAR_I8    = 1 << 8,

    56

	OC_VAR_U8    = 2 << 8,

    57

	OC_VAR_I16   = 3 << 8,

    58

	OC_VAR_U16   = 4 << 8,

    59

	OC_VAR_I32   = 5 << 8,

    60

	OC_VAR_U32   = 6 << 8,

    61

	OC_VAR_I64   = 7 << 8,

    62

	/* 8 bytes allocated (256 max) */

    63

    64

	OC_FILE_I8   = 1 << 16,

    65

	OC_FILE_U8   = 2 << 16,

    66

	OC_FILE_I16  = 3 << 16,

    67

	OC_FILE_U16  = 4 << 16,

    68

	OC_FILE_I32  = 5 << 16,

    69

	OC_FILE_U32  = 6 << 16,

    70

	/* 8 bytes allocated (256 max) */

    71

    72

	OC_INT8      = OC_VAR_I8   | OC_FILE_I8,

    73

	OC_UINT8     = OC_VAR_U8   | OC_FILE_U8,

    74

	OC_INT16     = OC_VAR_I16  | OC_FILE_I16,

    75

	OC_UINT16    = OC_VAR_U16  | OC_FILE_U16,

    76

	OC_INT32     = OC_VAR_I32  | OC_FILE_I32,

    77

	OC_UINT32    = OC_VAR_U32  | OC_FILE_U32,

    78

    79

	OC_TILE      = OC_VAR_U32  | OC_FILE_U16,

    80

    81

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

    82

} OldChunkType;

    83

    84

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

    85

    86

typedef struct OldChunks {

    87

	OldChunkType type;   ///< Type of field

    88

	uint32 amount;       ///< Amount of fields

    89

    90

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

    91

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

    92

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

    93

} OldChunks;

    94

    95

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

    96

assert_compile(sizeof(TileIndex) == 4);

    97

    98

static uint32 _bump_assert_value;

    99

static bool   _read_ttdpatch_flags;

   100

   101

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

   102

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

   103

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

   104

   105

static inline byte CalcOldVarLen(OldChunkType type)

   106

{

   107

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

   108

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

   109

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

   110

	return type_mem_size[length];

   111

}

   112

   113

/**

   114

 *

   115

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

   116

 *

   117

 */

   118

static byte ReadByteFromFile(LoadgameState *ls)

   119

{

   120

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

   121

	and just return a byte per time */

   122

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

   123

		/* Read some new bytes from the file */

   124

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

   125

   126

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

   127

		if (count == 0) {

   128

			DEBUG(oldloader, 1)("[OldLoader] Read past end of file, loading failed");

   129

			ls->failed = true;

   130

		}

   131

   132

		ls->buffer_count = count;

   133

		ls->buffer_cur   = 0;

   134

	}

   135

   136

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

   137

}

   138

   139

/**

   140

 *

   141

 * Reads a byte from the buffer and decompress if needed

   142

 *

   143

 */

   144

static byte ReadByte(LoadgameState *ls)

   145

{

   146

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

   147

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

   148

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

   149

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

   150

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

   151

   152

	if (ls->chunk_size == 0) {

   153

		/* Read new chunk */

   154

		int8 new_byte = ReadByteFromFile(ls);

   155

   156

		if (new_byte < 0) {

   157

			/* Repeat next char for new_byte times */

   158

			ls->decoding    = true;

   159

			ls->decode_char = ReadByteFromFile(ls);

   160

			ls->chunk_size  = -new_byte + 1;

   161

		} else {

   162

			ls->decoding    = false;

   163

			ls->chunk_size  = new_byte + 1;

   164

		}

   165

	}

   166

   167

	ls->total_read++;

   168

	ls->chunk_size--;

   169

   170

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

   171

}

   172

   173

static inline uint16 ReadUint16(LoadgameState *ls)

   174

{

   175

	byte x = ReadByte(ls);

   176

	return x | ReadByte(ls) << 8;

   177

}

   178

   179

static inline uint32 ReadUint32(LoadgameState *ls)

   180

{

   181

	uint16 x = ReadUint16(ls);

   182

	return x | ReadUint16(ls) << 16;

   183

}

   184

   185

/**

   186

 *

   187

 * Loads a chunk from the old savegame

   188

 *

   189

 */

   190

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

   191

{

   192

	const OldChunks *chunk = chunks;

   193

	byte *base_ptr = base;

   194

   195

	while (chunk->type != OC_END) {

   196

		byte* ptr = chunk->ptr;

   197

		uint i;

   198

   199

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

   200

			if (ls->failed) return false;

   201

   202

			/* Handle simple types */

   203

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

   204

				switch (GetOldChunkType(chunk->type)) {

   205

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

   206

					case OC_NULL: ReadByte(ls); break;

   207

   208

					case OC_CHUNK:

   209

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

   210

						 * are going to read */

   211

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

   212

						break;

   213

   214

					case OC_ASSERT:

   215

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

   216

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

   217

					default: break;

   218

				}

   219

			} else {

   220

				uint32 res = 0;

   221

   222

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

   223

				switch (GetOldChunkFileType(chunk->type)) {

   224

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

   225

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

   226

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

   227

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

   228

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

   229

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

   230

					default: NOT_REACHED();

   231

				}

   232

   233

				/* Sanity check */

   234

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

   235

   236

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

   237

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

   238

   239

				/* Write the data */

   240

				switch (GetOldChunkVarType(chunk->type)) {

   241

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

   242

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

   243

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

   244

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

   245

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

   246

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

   247

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

   248

					default: NOT_REACHED();

   249

				}

   250

   251

				/* Increase pointer base for arrays when looping */

   252

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

   253

			}

   254

		}

   255

   256

		chunk++;

   257

	}

   258

   259

	return true;

   260

}

   261

   262

/**

   263

 *

   264

 * Initialize some data before reading

   265

 *

   266

 */

   267

static void InitLoading(LoadgameState *ls)

   268

{

   269

	ls->chunk_size   = 0;

   270

	ls->total_read   = 0;

   271

	ls->failed       = false;

   272

   273

	ls->decoding     = false;

   274

	ls->decode_char  = 0;

   275

   276

	ls->buffer_cur   = 0;

   277

	ls->buffer_count = 0;

   278

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

   279

   280

	_bump_assert_value = 0;

   281

   282

	_read_ttdpatch_flags = false;

   283

}

   284

   285

   286

/*

   287

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

   288

 */

   289

   290

extern uint32 GetOldTownName(uint32 townnameparts, byte old_town_name_type);

   291

   292

static void FixOldTowns(void)

   293

{

   294

	Town *town;

   295

   296

	/* Convert town-names if needed */

   297

	FOR_ALL_TOWNS(town) {

   298

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

   299

			town->townnametype = SPECSTR_TOWNNAME_ENGLISH + _opt.town_name;

   300

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

   301

		}

   302

	}

   303

}

   304

   305

static void FixOldStations(void)

   306

{

   307

	Station *st;

   308

   309

	FOR_ALL_STATIONS(st) {

   310

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

   311

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

   312

			swap_byte(&st->trainst_w, &st->trainst_h);

   313

		}

   314

   315

		/* Check if there is a bus or truck station, and convert to new format */

   316

		if (st->bus_tile_obsolete != 0) {

   317

			st->bus_stops = AllocateRoadStop();

   318

			st->bus_stops->xy = st->bus_tile_obsolete;

   319

			st->bus_stops->used = true;

   320

			st->bus_stops->status = 3;

   321

			st->bus_stops->station = st->index;

   322

			st->bus_stops->next = NULL;

   323

			st->bus_stops->prev = NULL;

   324

			st->bus_stops->num_vehicles = 0;

   325

		}

   326

   327

		if (st->lorry_tile_obsolete != 0) {

   328

			st->truck_stops = AllocateRoadStop();

   329

			st->truck_stops->xy = st->lorry_tile_obsolete;

   330

			st->truck_stops->used = true;

   331

			st->truck_stops->status = 3;

   332

			st->truck_stops->station = st->index;

   333

			st->truck_stops->next = NULL;

   334

			st->truck_stops->prev = NULL;

   335

			st->truck_stops->num_vehicles = 0;

   336

		}

   337

	}

   338

}

   339

   340

static void FixOldVehicles(void)

   341

{

   342

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

   343

	Vehicle* v;

   344

   345

	FOR_ALL_VEHICLES(v) {

   346

		Vehicle *u;

   347

   348

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

   349

		if (v->type == VEH_Road) CLRBIT(v->u.road.state, 2);

   350

   351

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

   352

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

   353

			 * in both vehicles */

   354

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

   355

				v->next_shared = u;

   356

				u->prev_shared = v;

   357

				break;

   358

			}

   359

		}

   360

	}

   361

}

   362

   363

/*

   364

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

   365

 */

   366

   367

   368

/* Help:

   369

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

   370

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

   371

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

   372

 *  - OCL_END: every struct must end with this

   373

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

   374

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

   375

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

   376

 */

   377

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

   378

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

   379

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

   380

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

   381

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

   382

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

   383

   384

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

   385

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

   386

   Old Towns are 94 bytes big

   387

   Old Orders are 2 bytes big */

   388

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

   389

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

   390

   391

extern TileIndex _animated_tile_list[256];

   392

extern char _name_array[512][32];

   393

   394

static byte   _old_vehicle_multiplier;

   395

static uint8  _old_map3[OLD_MAP_SIZE * 2];

   396

static bool   _new_ttdpatch_format;

   397

static uint32 _old_town_index;

   398

static uint16 _old_string_id;

   399

static uint16 _old_string_id_2;

   400

   401

static void ReadTTDPatchFlags(void)

   402

{

   403

	int i;

   404

   405

	if (_read_ttdpatch_flags) return;

   406

   407

	_read_ttdpatch_flags = true;

   408

   409

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

   410

	_old_vehicle_multiplier = _old_map3[0];

   411

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

   412

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

   413

	if (_old_vehicle_multiplier < 2) _old_vehicle_multiplier++;

   414

   415

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

   416

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

   417

	bump the assert value so it doesn't!

   418

	(1 multipler == 850 vehicles

   419

	1 vehicle   == 128 bytes */

   420

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

   421

   422

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

   423

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

   424

   425

	/* Clean the misused places */

   426

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

   427

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

   428

   429

	if (_new_ttdpatch_format)

   430

		DEBUG(oldloader, 1)("[OldLoader] Found TTDPatch game");

   431

   432

	DEBUG(oldloader, 1)("[OldLoader] Vehicle-multiplier is set to %d (%d vehicles)", _old_vehicle_multiplier, _old_vehicle_multiplier * 850);

   433

}

   434

   435

static const OldChunks town_chunk[] = {

   436

	OCL_SVAR(   OC_TILE, Town, xy ),

   437

	OCL_SVAR( OC_FILE_U16 | OC_VAR_U32, Town, population ),

   438

	OCL_SVAR( OC_UINT16, Town, townnametype ),

   439

	OCL_SVAR( OC_UINT32, Town, townnameparts ),

   440

	OCL_SVAR(  OC_UINT8, Town, grow_counter ),

   441

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

   442

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

   443

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

   444

	OCL_SVAR( OC_UINT16, Town, flags12 ),

   445

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

   446

   447

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

   448

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

   449

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

   450

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

   451

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

   452

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

   453

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

   454

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

   455

   456

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

   457

	nothing changed?? */

   458

	OCL_SVAR( OC_FILE_U32 | OC_VAR_U8, Town, have_ratings ),

   459

	OCL_SVAR( OC_FILE_U32 | OC_VAR_U8, Town, statues ),

   460

	OCL_SVAR( OC_UINT16, Town, num_houses ),

   461

	OCL_SVAR(  OC_UINT8, Town, time_until_rebuild ),

   462

	OCL_SVAR(  OC_UINT8, Town, growth_rate ),

   463

   464

	OCL_SVAR( OC_UINT16, Town, new_max_pass ),

   465

	OCL_SVAR( OC_UINT16, Town, new_max_mail ),

   466

	OCL_SVAR( OC_UINT16, Town, new_act_pass ),

   467

	OCL_SVAR( OC_UINT16, Town, new_act_mail ),

   468

	OCL_SVAR( OC_UINT16, Town, max_pass ),

   469

	OCL_SVAR( OC_UINT16, Town, max_mail ),

   470

	OCL_SVAR( OC_UINT16, Town, act_pass ),

   471

	OCL_SVAR( OC_UINT16, Town, act_mail ),

   472

   473

	OCL_SVAR(  OC_UINT8, Town, pct_pass_transported ),

   474

	OCL_SVAR(  OC_UINT8, Town, pct_mail_transported ),

   475

   476

	OCL_SVAR( OC_UINT16, Town, new_act_food ),

   477

	OCL_SVAR( OC_UINT16, Town, new_act_water ),

   478

	OCL_SVAR( OC_UINT16, Town, act_food ),

   479

	OCL_SVAR( OC_UINT16, Town, act_water ),

   480

   481

	OCL_SVAR(  OC_UINT8, Town, road_build_months ),

   482

	OCL_SVAR(  OC_UINT8, Town, fund_buildings_months ),

   483

   484

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

   485

   486

	OCL_END()

   487

};

   488

static bool LoadOldTown(LoadgameState *ls, int num)

   489

{