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

    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

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

    84

    85

typedef struct OldChunks {

    86

	OldChunkType type;   ///< Type of field

    87

	uint32 amount;       ///< Amount of fields

    88

    89

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

    90

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

    91

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

    92

} OldChunks;

    93

    94

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

    95

assert_compile(sizeof(TileIndex) == 4);

    96

    97

static uint32 _bump_assert_value;

    98

static bool   _read_ttdpatch_flags;

    99

   100

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

   101

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

   102

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

   103

   104

static inline byte CalcOldVarLen(OldChunkType type)

   105

{

   106

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

   107

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

   108

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

   109

	return type_mem_size[length];

   110

}

   111

   112

/**

   113

 *

   114

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

   115

 *

   116

 */

   117

static byte ReadByteFromFile(LoadgameState *ls)

   118

{

   119

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

   120

	and just return a byte per time */

   121

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

   122

		/* Read some new bytes from the file */

   123

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

   124

   125

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

   126

		if (count == 0) {

   127

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

   128

			ls->failed = true;

   129

		}

   130

   131

		ls->buffer_count = count;

   132

		ls->buffer_cur   = 0;

   133

	}

   134

   135

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

   136

}

   137

   138

/**

   139

 *

   140

 * Reads a byte from the buffer and decompress if needed

   141

 *

   142

 */

   143

static byte ReadByte(LoadgameState *ls)

   144

{

   145

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

   146

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

   147

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

   148

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

   149

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

   150

   151

	if (ls->chunk_size == 0) {

   152

		/* Read new chunk */

   153

		int8 new_byte = ReadByteFromFile(ls);

   154

   155

		if (new_byte < 0) {

   156

			/* Repeat next char for new_byte times */

   157

			ls->decoding    = true;

   158

			ls->decode_char = ReadByteFromFile(ls);

   159

			ls->chunk_size  = -new_byte + 1;

   160

		} else {

   161

			ls->decoding    = false;

   162

			ls->chunk_size  = new_byte + 1;

   163

		}

   164

	}

   165

   166

	ls->total_read++;

   167

	ls->chunk_size--;

   168

   169

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

   170

}

   171

   172

static inline uint16 ReadUint16(LoadgameState *ls)

   173

{

   174

	byte x = ReadByte(ls);

   175

	return x | ReadByte(ls) << 8;

   176

}

   177

   178

static inline uint32 ReadUint32(LoadgameState *ls)

   179

{

   180

	uint16 x = ReadUint16(ls);

   181

	return x | ReadUint16(ls) << 16;

   182

}

   183

   184

/**

   185

 *

   186

 * Loads a chunk from the old savegame

   187

 *

   188

 */

   189

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

   190

{

   191

	const OldChunks *chunk = chunks;

   192

	byte *base_ptr = base;

   193

   194

	while (chunk->type != OC_END) {

   195

		byte* ptr = chunk->ptr;

   196

		uint i;

   197

   198

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

   199

			if (ls->failed) return false;

   200

   201

			/* Handle simple types */

   202

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

   203

				switch (GetOldChunkType(chunk->type)) {

   204

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

   205

					case OC_NULL: ReadByte(ls); break;

   206

   207

					case OC_CHUNK:

   208

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

   209

						 * are going to read */

   210

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

   211

						break;

   212

   213

					case OC_ASSERT:

   214

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

   215

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

   216

					default: break;

   217

				}

   218

			} else {

   219

				uint32 res = 0;

   220

   221

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

   222

				switch (GetOldChunkFileType(chunk->type)) {

   223

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

   224

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

   225

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

   226

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

   227

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

   228

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

   229

					default: NOT_REACHED();

   230

				}

   231

   232

				/* Sanity check */

   233

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

   234

   235

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

   236

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

   237

   238

				/* Write the data */

   239

				switch (GetOldChunkVarType(chunk->type)) {

   240

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

   241

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

   242

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

   243

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

   244

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

   245

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

   246

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

   247

					default: NOT_REACHED();

   248

				}

   249

   250

				/* Increase pointer base for arrays when looping */

   251

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

   252

			}

   253

		}

   254

   255

		chunk++;

   256

	}

   257

   258

	return true;

   259

}

   260

   261

/**

   262

 *

   263

 * Initialize some data before reading

   264

 *

   265

 */

   266

static void InitLoading(LoadgameState *ls)

   267

{

   268

	ls->chunk_size   = 0;

   269

	ls->total_read   = 0;

   270

	ls->failed       = false;

   271

   272

	ls->decoding     = false;

   273

	ls->decode_char  = 0;

   274

   275

	ls->buffer_cur   = 0;

   276

	ls->buffer_count = 0;

   277

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

   278

   279

	_bump_assert_value = 0;

   280

   281

	_read_ttdpatch_flags = false;

   282

}

   283

   284

   285

/*

   286

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

   287

 */

   288

   289

extern uint32 GetOldTownName(uint32 townnameparts, byte old_town_name_type);

   290

   291

static void FixOldTowns(void)

   292

{

   293

	Town *town;

   294

   295

	/* Convert town-names if needed */

   296

	FOR_ALL_TOWNS(town) {

   297

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

   298

			town->townnametype = SPECSTR_TOWNNAME_ENGLISH + _opt.town_name;

   299

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

   300

		}

   301

	}

   302

}

   303

   304

static void FixOldStations(void)

   305

{

   306

	Station *st;

   307

   308

	FOR_ALL_STATIONS(st) {

   309

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

   310

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

   311

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

   312

		}

   313

   314

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

   315

		if (st->bus_tile_obsolete != 0) {

   316

			st->bus_stops = AllocateRoadStop();

   317

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

   318

			st->bus_stops->used = true;

   319

			st->bus_stops->status = 3;

   320

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

   321

			st->bus_stops->next = NULL;

   322

			st->bus_stops->prev = NULL;

   323

			st->bus_stops->num_vehicles = 0;

   324

		}

   325

   326

		if (st->lorry_tile_obsolete != 0) {

   327

			st->truck_stops = AllocateRoadStop();

   328

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

   329

			st->truck_stops->used = true;

   330

			st->truck_stops->status = 3;

   331

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

   332

			st->truck_stops->next = NULL;

   333

			st->truck_stops->prev = NULL;

   334

			st->truck_stops->num_vehicles = 0;

   335

		}

   336

	}

   337

}

   338

   339

static void FixOldVehicles(void)

   340

{

   341

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

   342

	Vehicle* v;

   343

   344

	FOR_ALL_VEHICLES(v) {

   345

		Vehicle *u;

   346

   347

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

   348

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

   349

   350

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

   351

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

   352

			 * in both vehicles */

   353

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

   354

				v->next_shared = u;

   355

				u->prev_shared = v;

   356

				break;

   357

			}

   358

		}

   359

	}

   360

}

   361

   362

/*

   363

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

   364

 */

   365

   366

   367

/* Help:

   368

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

   369

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

   370

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

   371

 *  - OCL_END: every struct must end with this

   372

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

   373

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

   374

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

   375

 */

   376

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

   377

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

   378

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

   379

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

   380

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

   381

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

   382

   383

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

   384

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

   385

   Old Towns are 94 bytes big

   386

   Old Orders are 2 bytes big */

   387

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

   388

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

   389

   390

extern TileIndex _animated_tile_list[256];

   391

extern char _name_array[512][32];

   392

   393

static byte   _old_vehicle_multiplier;

   394

static uint8  _old_map3[OLD_MAP_SIZE * 2];

   395

static bool   _new_ttdpatch_format;

   396

static uint32 _old_town_index;

   397

static uint16 _old_string_id;

   398

static uint16 _old_string_id_2;

   399

   400

static void ReadTTDPatchFlags(void)

   401

{

   402

	int i;

   403

   404

	if (_read_ttdpatch_flags) return;

   405

   406

	_read_ttdpatch_flags = true;

   407

   408

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

   409

	_old_vehicle_multiplier = _old_map3[0];

   410

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

   411

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

   412

	if (_old_vehicle_multiplier < 2) _old_vehicle_multiplier++;

   413

   414

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

   415

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

   416

	bump the assert value so it doesn't!

   417

	(1 multipler == 850 vehicles

   418

	1 vehicle   == 128 bytes */

   419

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

   420

   421

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

   422

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

   423

   424

	/* Clean the misused places */

   425

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

   426

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

   427

   428

	if (_new_ttdpatch_format)

   429

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

   430

   431

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

   432

}

   433

   434

static const OldChunks town_chunk[] = {

   435

	OCL_SVAR(   OC_TILE, Town, xy ),

   436

	OCL_SVAR( OC_FILE_U16 | OC_VAR_U32, Town, population ),

   437

	OCL_SVAR( OC_UINT16, Town, townnametype ),

   438

	OCL_SVAR( OC_UINT32, Town, townnameparts ),

   439

	OCL_SVAR(  OC_UINT8, Town, grow_counter ),

   440

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

   441

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

   442

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

   443

	OCL_SVAR( OC_UINT16, Town, flags12 ),

   444

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

   445

   446

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

   447

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

   448

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

   449

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

   450

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

   451

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

   452

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

   453

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

   454

   455

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

   456

	nothing changed?? */

   457

	OCL_SVAR( OC_FILE_U32 | OC_VAR_U8, Town, have_ratings ),

   458

	OCL_SVAR( OC_FILE_U32 | OC_VAR_U8, Town, statues ),

   459

	OCL_SVAR( OC_UINT16, Town, num_houses ),

   460

	OCL_SVAR(  OC_UINT8, Town, time_until_rebuild ),

   461

	OCL_SVAR(  OC_UINT8, Town, growth_rate ),

   462

   463

	OCL_SVAR( OC_UINT16, Town, new_max_pass ),

   464

	OCL_SVAR( OC_UINT16, Town, new_max_mail ),

   465

	OCL_SVAR( OC_UINT16, Town, new_act_pass ),

   466

	OCL_SVAR( OC_UINT16, Town, new_act_mail ),

   467

	OCL_SVAR( OC_UINT16, Town, max_pass ),

   468

	OCL_SVAR( OC_UINT16, Town, max_mail ),

   469

	OCL_SVAR( OC_UINT16, Town, act_pass ),

   470

	OCL_SVAR( OC_UINT16, Town, act_mail ),

   471

   472

	OCL_SVAR(  OC_UINT8, Town, pct_pass_transported ),

   473

	OCL_SVAR(  OC_UINT8, Town, pct_mail_transported ),

   474

   475

	OCL_SVAR( OC_UINT16, Town, new_act_food ),

   476

	OCL_SVAR( OC_UINT16, Town, new_act_water ),

   477

	OCL_SVAR( OC_UINT16, Town, act_food ),

   478

	OCL_SVAR( OC_UINT16, Town, act_water ),

   479

   480

	OCL_SVAR(  OC_UINT8, Town, road_build_months ),

   481

	OCL_SVAR(  OC_UINT8, Town, fund_buildings_months ),

   482

   483

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

   484

   485

	OCL_END()

   486

};

   487

static bool LoadOldTown(LoadgameState *ls, int num)

   488

{

   489

	if (!AddBlockIfNeeded(&_Town_pool, num))