1

#include "stdafx.h"

     2

#include "ttd.h"

     3

#include "table/strings.h"

     4

#include "map.h"

     5

#include "town.h"

     6

#include "industry.h"

     7

#include "station.h"

     8

#include "economy.h"

     9

#include "player.h"

    10

#include "engine.h"

    11

#include "vehicle.h"

    12

#include "signs.h"

    13

#include "debug.h"

    14

#include "depot.h"

    15

    16

enum {

    17

	HEADER_SIZE = 49,

    18

	BUFFER_SIZE = 4096,

    19

    20

	OLD_MAP_SIZE = 256 * 256

    21

};

    22

    23

typedef struct LoadgameState {

    24

	FILE *file;

    25

    26

	uint chunk_size;

    27

    28

	bool decoding;

    29

	byte decode_char;

    30

    31

	uint buffer_count;

    32

	uint buffer_cur;

    33

	byte buffer[BUFFER_SIZE];

    34

    35

	uint total_read;

    36

	bool failed;

    37

} LoadgameState;

    38

    39

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

    40

    41

typedef struct OldChunks {

    42

	uint32 type;         //! Type of field

    43

	uint32 amount;       //! Amount of fields

    44

    45

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

    46

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

    47

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

    48

} OldChunks;

    49

    50

/* OldChunk-Type */

    51

enum {

    52

	OC_END       = 0,

    53

	OC_NULL      = 1 << 0,

    54

	OC_CHUNK     = 1 << 1,

    55

	OC_ASSERT    = 1 << 2,

    56

    57

	OC_VAR_I8    = 1 << 9,

    58

	OC_VAR_U8    = 1 << 10,

    59

	OC_VAR_I16   = 1 << 11,

    60

	OC_VAR_U16   = 1 << 12,

    61

	OC_VAR_I32   = 1 << 13,

    62

	OC_VAR_U32   = 1 << 14,

    63

	OC_VAR_I64   = 1 << 15,

    64

    65

	OC_FILE_I8   = 1 << 17,

    66

	OC_FILE_U8   = 1 << 18,

    67

	OC_FILE_I16  = 1 << 19,

    68

	OC_FILE_U16  = 1 << 20,

    69

	OC_FILE_I32  = 1 << 21,

    70

	OC_FILE_U32  = 1 << 22,

    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

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

    82

assert_compile(sizeof(TileIndex) == 4);

    83

    84

static LoadgameState _ls;

    85

static uint32 _bump_assert_value;

    86

static bool   _read_ttdpatch_flags;

    87

    88

/**

    89

 *

    90

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

    91

 *

    92

 */

    93

static byte ReadByteFromFile(LoadgameState *ls)

    94

{

    95

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

    96

	and just return a byte per time */

    97

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

    98

		/* Read some new bytes from the file */

    99

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

   100

   101

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

   102

		if (count == 0) {

   103

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

   104

			ls->failed = true;

   105

		}

   106

   107

		ls->buffer_count = count;

   108

		ls->buffer_cur   = 0;

   109

	}

   110

   111

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

   112

}

   113

   114

/**

   115

 *

   116

 * Reads a byte from the buffer and decompress if needed

   117

 *

   118

 */

   119

static byte ReadByte(LoadgameState *ls)

   120

{

   121

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

   122

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

   123

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

   124

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

   125

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

   126

	int8 new_byte;

   127

   128

	/* Check if we are reading a chunk */

   129

	if (ls->chunk_size != 0) {

   130

		ls->total_read++;

   131

		ls->chunk_size--;

   132

   133

		/* If we are decoding, return the decode_char */

   134

		if (ls->decoding)

   135

			return ls->decode_char;

   136

   137

		/* Else return byte from file */

   138

		return ReadByteFromFile(ls);

   139

	}

   140

   141

	/* Read new chunk */

   142

	new_byte = ReadByteFromFile(ls);

   143

   144

	if (new_byte < 0) {

   145

		/* Repeat next char for new_byte times */

   146

		ls->decoding    = true;

   147

		ls->decode_char = ReadByteFromFile(ls);

   148

		ls->chunk_size  = -new_byte + 1;

   149

	} else {

   150

		ls->decoding    = false;

   151

		ls->chunk_size  = new_byte + 1;

   152

	}

   153

   154

	/* Call this function again to return a byte */

   155

	return ReadByte(ls);

   156

}

   157

   158

/**

   159

 *

   160

 * Loads a chunk from the old savegame

   161

 *

   162

 */

   163

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

   164

{

   165

	const OldChunks *chunk = chunks;

   166

	byte *ptr;

   167

	byte *base_ptr = base;

   168

	uint i;

   169

   170

	while (chunk->type != OC_END) {

   171

		ptr = chunk->ptr;

   172

   173

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

   174

			if (ls->failed)

   175

				return false;

   176

   177

			/* Handle simple types */

   178

			if ((chunk->type & 0xFF) != 0) {

   179

				switch (chunk->type & 0xFF) {

   180

					case OC_NULL:

   181

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

   182

						ReadByte(ls);

   183

						break;

   184

   185

					case OC_CHUNK:

   186

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

   187

						are going to read */

   188

						if (!chunk->proc(ls, i))

   189

							return false;

   190

						break;

   191

   192

					case OC_ASSERT:

   193

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

   194

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

   195

							ls->failed = true;

   196

   197

						break;

   198

   199

				}

   200

			} else {

   201

				uint32 res = 0;

   202

   203

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

   204

				switch (((chunk->type >> 16) & 0xFF) << 16) {

   205

					case OC_FILE_I8:

   206

						res = ReadByte(ls);

   207

						res = (int8)res;

   208

						break;

   209

   210

					case OC_FILE_U8:

   211

						res = ReadByte(ls);

   212

						break;

   213

   214

					case OC_FILE_U16:

   215

						res =  ReadByte(ls);

   216

						res += ReadByte(ls) << 8;

   217

						break;

   218

   219

					case OC_FILE_I16:

   220

						res =  ReadByte(ls);

   221

						res += ReadByte(ls) << 8;

   222

						res = (int16)res;

   223

						break;

   224

   225

					case OC_FILE_U32:

   226

						res =  ReadByte(ls);

   227

						res += ReadByte(ls) << 8;

   228

						res += ReadByte(ls) << 16;

   229

						res += ReadByte(ls) << 24;

   230

						break;

   231

   232

					case OC_FILE_I32:

   233

						res =  ReadByte(ls);

   234

						res += ReadByte(ls) << 8;

   235

						res += ReadByte(ls) << 16;

   236

						res += ReadByte(ls) << 24;

   237

						res = (int32)res;

   238

						break;

   239

				}

   240

   241

				/* Sanity check */

   242

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

   243

   244

				/* Writing to the var: bit 8 till 15 have the VAR */

   245

				switch (((chunk->type >> 8) & 0xFF) << 8) {

   246

					case OC_VAR_I8:

   247

						/* Write the data */

   248

						if (chunk->ptr != NULL) {

   249

							*(int8 *)ptr = res & 0xFF;

   250

							ptr++;

   251

						} else

   252

							*(int8 *)(base_ptr + chunk->offset) = res & 0xFF;

   253

							break;

   254

   255

					case OC_VAR_U8:

   256

						/* Write the data */

   257

						if (chunk->ptr != NULL) {

   258

							*(uint8 *)ptr = res & 0xFF;

   259

							ptr++;

   260

						} else

   261

							*(uint8 *)(base_ptr + chunk->offset) = res & 0xFF;

   262

							break;

   263

   264

					case OC_VAR_U16:

   265

						/* Write the data */

   266

						if (chunk->ptr != NULL) {

   267

							*(uint16 *)ptr = res & 0xFFFF;

   268

							ptr += 2;

   269

						} else

   270

							*(uint16 *)(base_ptr + chunk->offset) = res & 0xFFFF;

   271

							break;

   272

   273

					case OC_VAR_I16:

   274

						/* Write the data */

   275

						if (chunk->ptr != NULL) {

   276

							*(int16 *)ptr = res & 0xFFFF;

   277

							ptr += 2;

   278

						} else

   279

							*(int16 *)(base_ptr + chunk->offset) = res & 0xFFFF;

   280

							break;

   281

   282

					case OC_VAR_U32:

   283

						/* Write the data */

   284

						if (chunk->ptr != NULL) {

   285

							*(uint32 *)ptr = res;

   286

							ptr += 4;

   287

						} else

   288

							*(uint32 *)(base_ptr + chunk->offset) = res;

   289

							break;

   290

   291

					case OC_VAR_I32:

   292

						/* Write the data */

   293

						if (chunk->ptr != NULL) {

   294

							*(int32 *)ptr = res;

   295

							ptr += 4;

   296

						} else

   297

							*(int32 *)(base_ptr + chunk->offset) = res;

   298

							break;

   299

   300

					case OC_VAR_I64:

   301

						/* Write the data */

   302

						if (chunk->ptr != NULL) {

   303

							*(int64 *)ptr = res;

   304

							ptr += 8;

   305

						} else

   306

							*(int64 *)(base_ptr + chunk->offset) = res;

   307

							break;

   308

				}

   309

			}

   310

		}

   311

   312

		chunk++;

   313

	}

   314

   315

	return true;

   316

}

   317

   318

/**

   319

 *

   320

 * Initialize some data before reading

   321

 *

   322

 */

   323

static void InitLoading(LoadgameState *ls)

   324

{

   325

	ls->chunk_size   = 0;

   326

	ls->total_read   = 0;

   327

	ls->failed       = false;

   328

   329

	ls->decoding     = false;

   330

	ls->decode_char  = 0;

   331

   332

	ls->buffer_cur   = 0;

   333

	ls->buffer_count = 0;

   334

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

   335

   336

	_bump_assert_value = 0;

   337

   338

	_read_ttdpatch_flags = false;

   339

}

   340

   341

   342

/*

   343

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

   344

 */

   345

   346

extern uint32 GetOldTownName(uint32 townnameparts, byte old_town_name_type);

   347

   348

static void FixOldTowns(void)

   349

{

   350

	Town *town;

   351

   352

	/* Convert town-names if needed */

   353

	FOR_ALL_TOWNS(town) {

   354

		if (town->xy == 0)

   355

			continue;

   356

   357

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

   358

			town->townnametype = SPECSTR_TOWNNAME_ENGLISH + _opt.town_name;

   359

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

   360

		}

   361

	}

   362

}

   363

   364

static void FixOldStations(void)

   365

{

   366

	Station *st;

   367

   368

	FOR_ALL_STATIONS(st) {

   369

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

   370

		if (st->train_tile) {

   371

			if (_map5[st->train_tile] & 1) {

   372

				int w = st->trainst_w;

   373

				int h = st->trainst_h;

   374

				intswap(w, h);

   375

				st->trainst_w = w;

   376

				st->trainst_h = h;

   377

			}

   378

		}

   379

   380

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

   381

		if (st->bus_tile_obsolete != 0) {

   382

			st->bus_stops = AllocateRoadStop();

   383

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

   384

			st->bus_stops->used = true;

   385

			st->bus_stops->status = 3;

   386

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

   387

			st->bus_stops->next = NULL;

   388

			st->bus_stops->prev = NULL;

   389

			st->bus_stops->slot[0] = st->bus_stops->slot[1] = INVALID_SLOT;

   390

		}

   391

   392

		if (st->lorry_tile_obsolete != 0) {

   393

			st->truck_stops = AllocateRoadStop();

   394

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

   395

			st->truck_stops->used = true;

   396

			st->truck_stops->status = 3;

   397

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

   398

			st->truck_stops->next = NULL;

   399

			st->truck_stops->prev = NULL;

   400

			st->truck_stops->slot[0] = st->truck_stops->slot[1] = INVALID_SLOT;

   401

		}

   402

	}

   403

}

   404

   405

static void FixOldVehicles(void)

   406

{

   407

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

   408

	{

   409

		Vehicle *v;

   410

   411

		FOR_ALL_VEHICLES(v) {

   412

			Vehicle *u;

   413

   414

			if (v->type == 0)

   415

				continue;

   416

   417

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

   418

				if (u->type == 0)

   419

					continue;

   420

   421

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

   422

				in both vehicles */

   423

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

   424

					v->next_shared = u;

   425

					u->prev_shared = v;

   426

					break;

   427

				}

   428

			}

   429

		}

   430

	}

   431

   432

	if (_vehicle_id_ctr_day > GetVehiclePoolSize())

   433

		_vehicle_id_ctr_day = 0;

   434

}

   435

   436

/*

   437

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

   438

 */

   439

   440

   441

/* Help:

   442

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

   443

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

   444

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

   445

 *  - OCL_END: every struct must end with this

   446

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

   447

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

   448

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

   449

 */

   450

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

   451

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

   452

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

   453

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

   454

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

   455

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

   456

   457

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

   458

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

   459

   Old Towns are 94 bytes big

   460

   Old Orders are 2 bytes big */

   461

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

   462

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

   463

   464

extern TileIndex _animated_tile_list[256];

   465

extern char _name_array[512][32];

   466

extern uint16 _custom_sprites_base;

   467

   468

static byte   _old_vehicle_multipler;

   469

static uint8  _old_map3[OLD_MAP_SIZE * 2];

   470

static bool   _new_ttdpatch_format;

   471

static uint32 _old_town_index;

   472

static uint16 _old_string_id;

   473

static uint16 _old_string_id_2;

   474

   475

void ReadTTDPatchFlags(void)

   476

{

   477

	int i;

   478

   479

	if (_read_ttdpatch_flags)

   480

		return;

   481

   482

	_read_ttdpatch_flags = true;

   483

   484

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

   485

	_old_vehicle_multipler = _old_map3[0];

   486

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

   487

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

   488

	if (_old_vehicle_multipler < 2)

   489

		_old_vehicle_multipler++;

   490

   491

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

   492

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

   493

	bump the assert value so it doesn't!