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 (town->xy == 0) continue;

   298

   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_byte(&st->trainst_w, &st->trainst_h);

   314

		}

   315

   316

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

   317

		if (st->bus_tile_obsolete != 0) {

   318

			st->bus_stops = AllocateRoadStop();

   319

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

   320

			st->bus_stops->used = true;

   321

			st->bus_stops->status = 3;

   322

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

   323

			st->bus_stops->next = NULL;

   324

			st->bus_stops->prev = NULL;

   325

			st->bus_stops->num_vehicles = 0;

   326

		}

   327

   328

		if (st->lorry_tile_obsolete != 0) {

   329

			st->truck_stops = AllocateRoadStop();

   330

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

   331

			st->truck_stops->used = true;

   332

			st->truck_stops->status = 3;

   333

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

   334

			st->truck_stops->next = NULL;

   335

			st->truck_stops->prev = NULL;

   336

			st->truck_stops->num_vehicles = 0;

   337

		}

   338

	}

   339

}

   340

   341

static void FixOldVehicles(void)

   342

{

   343

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

   344

	Vehicle* v;

   345

   346

	FOR_ALL_VEHICLES(v) {

   347

		Vehicle *u;

   348

   349

		if (v->type == 0) continue;

   350

   351

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

   352

			if (u->type == 0) continue;

   353

   354

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

   355

			 * in both vehicles */

   356

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

   357

				v->next_shared = u;

   358

				u->prev_shared = v;

   359

				break;

   360

			}

   361

		}

   362

	}

   363

}

   364

   365

/*

   366

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

   367

 */

   368

   369

   370

/* Help:

   371

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

   372

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

   373

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

   374

 *  - OCL_END: every struct must end with this

   375

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

   376

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

   377

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

   378

 */

   379

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

   380

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

   381

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

   382

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

   383

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

   384

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

   385

   386

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

   387

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

   388

   Old Towns are 94 bytes big

   389

   Old Orders are 2 bytes big */

   390

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

   391

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

   392

   393

extern TileIndex _animated_tile_list[256];

   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

   403

static void ReadTTDPatchFlags(void)

   404

{

   405

	int i;

   406

   407

	if (_read_ttdpatch_flags) return;

   408

   409

	_read_ttdpatch_flags = true;

   410

   411

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

   412

	_old_vehicle_multiplier = _old_map3[0];

   413

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

   414

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

   415

	if (_old_vehicle_multiplier < 2) _old_vehicle_multiplier++;

   416

   417

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

   418

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

   419

	bump the assert value so it doesn't!

   420

	(1 multipler == 850 vehicles

   421

	1 vehicle   == 128 bytes */

   422

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

   423

   424

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

   425

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

   426

   427

	/* Clean the misused places */

   428

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

   429

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

   430

   431

	if (_new_ttdpatch_format)

   432

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

   433

   434

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

   435

}

   436

   437

static const OldChunks town_chunk[] = {

   438

	OCL_SVAR(   OC_TILE, Town, xy ),

   439

	OCL_SVAR( OC_FILE_U16 | OC_VAR_U32, Town, population ),

   440

	OCL_SVAR( OC_UINT16, Town, townnametype ),

   441

	OCL_SVAR( OC_UINT32, Town, townnameparts ),

   442

	OCL_SVAR(  OC_UINT8, Town, grow_counter ),

   443

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

   444

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

   445

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

   446

	OCL_SVAR( OC_UINT16, Town, flags12 ),

   447

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

   448

   449

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

   450

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

   451

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

   452

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

   453

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

   454

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

   455

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

   456

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

   457

   458

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

   459

	nothing changed?? */

   460

	OCL_SVAR( OC_FILE_U32 | OC_VAR_U8, Town, have_ratings ),

   461

	OCL_SVAR( OC_FILE_U32 | OC_VAR_U8, Town, statues ),

   462

	OCL_SVAR( OC_UINT16, Town, num_houses ),

   463

	OCL_SVAR(  OC_UINT8, Town, time_until_rebuild ),

   464

	OCL_SVAR(  OC_UINT8, Town, growth_rate ),

   465

   466

	OCL_SVAR( OC_UINT16, Town, new_max_pass ),

   467

	OCL_SVAR( OC_UINT16, Town, new_max_mail ),

   468

	OCL_SVAR( OC_UINT16, Town, new_act_pass ),

   469

	OCL_SVAR( OC_UINT16, Town, new_act_mail ),

   470

	OCL_SVAR( OC_UINT16, Town, max_pass ),

   471

	OCL_SVAR( OC_UINT16, Town, max_mail ),

   472

	OCL_SVAR( OC_UINT16, Town, act_pass ),

   473

	OCL_SVAR( OC_UINT16, Town, act_mail ),

   474

   475

	OCL_SVAR(  OC_UINT8, Town, pct_pass_transported ),

   476

	OCL_SVAR(  OC_UINT8, Town, pct_mail_transported ),

   477

   478

	OCL_SVAR( OC_UINT16, Town, new_act_food ),

   479

	OCL_SVAR( OC_UINT16, Town, new_act_water ),

   480

	OCL_SVAR( OC_UINT16, Town, act_food ),

   481

	OCL_SVAR( OC_UINT16, Town, act_water ),

   482

   483

	OCL_SVAR(  OC_UINT8, Town, road_build_months ),

   484

	OCL_SVAR(  OC_UINT8, Town, fund_buildings_months ),

   485

   486

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

   487

   488

	OCL_END()

   489

};