1

#include "stdafx.h"

     2

     3

#include <stdarg.h>

     4

     5

#include "ttd.h"

     6

#include "gfx.h"

     7

#include "fileio.h"

     8

#include "engine.h"

     9

    10

/* TTDPatch extended GRF format codec

    11

 * (c) Petr Baudis 2004 (GPL'd)

    12

 * Changes by Florian octo Forster are (c) by the OpenTTD development team.

    13

 *

    14

 * Contains portions of documentation by TTDPatch team.

    15

 * Thanks especially to Josef Drexler for the documentation as well as a lot

    16

 * of help at #tycoon. Also thanks to Michael Blunck for is GRF files which

    17

 * served as subject to the initial testing of this codec. */

    18

    19

extern int _skip_sprites;

    20

extern int _replace_sprites_count[16];

    21

extern int _replace_sprites_offset[16];

    22

    23

struct GRFFile {

    24

	char *filename;

    25

	uint32 grfid;

    26

	uint16 flags;

    27

	uint16 sprite_offset;

    28

	struct GRFFile *next;

    29

};

    30

    31

static struct GRFFile *_cur_grffile, *_first_grffile;

    32

static int _cur_spriteid;

    33

static int _cur_stage;

    34

    35

static int32 _paramlist[0x7f];

    36

static int _param_max;

    37

    38

/* 32 * 8 = 256 flags. Apparently TTDPatch uses this many.. */

    39

static uint32 _ttdpatch_flags[8];

    40

    41

    42

typedef void (*SpecialSpriteHandler)(byte *buf, int len);

    43

    51

static const int _vehshifts[4] = {

    52

	0,

    53

	ROAD_ENGINES_INDEX,

    54

	SHIP_ENGINES_INDEX,

    55

	AIRCRAFT_ENGINES_INDEX,

    56

};

    57

    58

    59

enum grfmsg_severity {

    60

	GMS_NOTICE,

    61

	GMS_WARN,

    62

	GMS_ERROR,

    63

	GMS_FATAL,

    64

};

    65

    66

static void CDECL grfmsg(enum grfmsg_severity severity, const char *str, ...)

    67

{

    68

	static const char * const severitystr[4] = { "Notice", "Warning", "Error", "Fatal" };

    70

	char buf[1024];

    71

	va_list va;

    72

    73

	va_start(va, str);

    74

	vsprintf(buf, str, va);

    75

	va_end(va);

    79

}

    80

    81

    82

#define check_length(real, wanted, where) \

    83

do { \

    84

	if (real < wanted) { \

    85

		grfmsg(GMS_ERROR, "%s: Invalid special sprite length %d (expected %d)!", where, real, wanted); \

    86

		return; \

    87

	} \

    88

} while (0)

    89

    90

    91

static byte INLINE grf_load_byte(byte **buf)

    92

{

    93

	return *(*buf)++;

    94

}

    95

    96

static uint16 grf_load_word(byte **buf)

    97

{

    98

	uint16 val;

    99

	byte *p = *buf;

   100

	val = p[0];

   101

	val |= p[1] << 8;

   102

	*buf = p + 2;

   103

	return val;

   104

}

   105

   106

static uint16 grf_load_dword(byte **buf)

   107

{

   108

	uint32 val;

   109

	byte *p = *buf;

   110

	val = p[0];

   111

	val |= p[1] << 8;

   112

	val |= p[2] << 16;

   113

	val |= p[3] << 24;

   114

	*buf = p + 4;

   115

	return val;

   116

}

   117

   118

   119

static struct GRFFile *GetFileByGRFID(uint32 grfid)

   120

{

   121

	struct GRFFile *file;

   122

   123

	file = _first_grffile;

   124

	while ((file != NULL) && (file->grfid != grfid))

   125

		file = file->next;

   126

   127

	return file;

   128

}

   129

   130

static struct GRFFile *GetFileByFilename(const char *filename)

   131

{

   132

	struct GRFFile *file;

   133

   134

	file = _first_grffile;

   135

	while ((file != NULL) && strcmp(file->filename, filename))

   136

		file = file->next;

   137

   138

	return file;

   139

}

   140

   141

   142

typedef bool (*VCI_Handler)(uint engine, int numinfo, int prop, byte **buf, int len);

   143

   144

#define FOR_EACH_ENGINE for (i = 0; i < numinfo; i++)

   145

   146

static void dewagonize(int condition, int engine)

   147

{

   148

	EngineInfo *ei = &_engine_info[engine];

   149

	RailVehicleInfo *rvi = &_rail_vehicle_info[engine];

   150

   152

		ei->unk2 &= ~0x80;

   153

		rvi->flags &= ~2;

   154

	} else {

   155

		ei->unk2 |= 0x80;

   156

		rvi->flags |= 2;

   157

	}

   158

}

   159

   160

static bool RailVehicleChangeInfo(uint engine, int numinfo, int prop, byte **bufp, int len)

   161

{

   162

	EngineInfo *ei = &_engine_info[engine];

   163

	RailVehicleInfo *rvi = &_rail_vehicle_info[engine];

   164

	byte *buf = *bufp;

   165

	int i;

   166

	bool ret = false;

   167

   168

	switch (prop) {

   169

		case 0x05: {	/* Track type */

   170

			FOR_EACH_ENGINE {

   171

				uint8 tracktype = grf_load_byte(&buf);

   172

   173

				ei[i].railtype_climates &= 0xf;

   174

				ei[i].railtype_climates |= tracktype << 4;

   175

			}

   176

		}	break;

   177

		case 0x08: {	/* AI passenger service */

   178

			/* TODO */

   179

			FOR_EACH_ENGINE {

   180

				grf_load_byte(&buf);

   181

			}

   182

			ret = true;

   183

		}	break;

   184

		case 0x09: {	/* Speed */

   185

			FOR_EACH_ENGINE {

   186

				uint16 speed = grf_load_word(&buf);

   187

   188

				rvi[i].max_speed = speed;

   189

				dewagonize(speed, engine + i);

   190

			}

   191

		}	break;

   192

		case 0x0B: {	/* Power */

   193

			FOR_EACH_ENGINE {

   194

				uint16 power = grf_load_word(&buf);

   195

   196

				rvi[i].power = power;

   197

				dewagonize(power, engine + i);

   198

			}

   199

		}	break;

   200

		case 0x0D: {	/* Running cost factor */

   201

			FOR_EACH_ENGINE {

   202

				uint8 runcostfact = grf_load_byte(&buf);

   203

   204

				rvi[i].running_cost_base = runcostfact;

   205

				dewagonize(runcostfact, engine + i);

   206

			}

   207

		}	break;

   208

		case 0x0E: {	/* Running cost base */

   209

			FOR_EACH_ENGINE {

   210

				uint32 base = grf_load_dword(&buf);

   211

   212

				switch (base) {

   213

				case 0x4C30:

   214

					rvi[i].engclass = 0;

   215

					break;

   216

				case 0x4C36:

   217

					rvi[i].engclass = 1;

   218

					break;

   219

				case 0x4C3C:

   220

					rvi[i].engclass = 2;

   221

					break;

   222

				}

   223

				dewagonize(base, engine + i);

   224

			}

   225

		}	break;

   226

		case 0x12: {	/* Sprite ID */

   227

			FOR_EACH_ENGINE {

   228

				uint8 spriteid = grf_load_byte(&buf);

   229

   230

				if (spriteid == 0xFD && rvi[i].image_index != 0xFD)

   231

					_engine_original_sprites[engine + i] = rvi[i].image_index;

   232

				rvi[i].image_index = spriteid;

   233

			}

   234

		}	break;

   235

		case 0x13: {	/* Dual-headed */

   236

			FOR_EACH_ENGINE {

   237

				uint8 dual = grf_load_byte(&buf);

   238

   240

					rvi[i].flags |= 1;

   241

				} else {

   242

					rvi[i].flags &= ~1;

   243

				}

   244

			}

   245

		}	break;

   246

		case 0x14: {	/* Cargo capacity */

   247

			FOR_EACH_ENGINE {

   248

				uint8 capacity = grf_load_byte(&buf);

   249

   250

				rvi[i].capacity = capacity;

   251

			}

   252

		}	break;

   253

		case 0x15: {	/* Cargo type */

   254

			FOR_EACH_ENGINE {

   255

				uint8 ctype = grf_load_byte(&buf);

   256

   257

				rvi[i].cargo_type = ctype;

   258

			}

   259

		}	break;

   260

		case 0x16: {	/* Weight */

   261

			FOR_EACH_ENGINE {

   262

				uint8 weight = grf_load_byte(&buf);

   263

   264

				rvi[i].weight = weight;

   265

			}

   266

		}	break;

   267

		case 0x17: {	/* Cost factor */

   268

			FOR_EACH_ENGINE {

   269

				uint8 cfactor = grf_load_byte(&buf);

   270

   271

				rvi[i].base_cost = cfactor;

   272

			}

   273

		}	break;

   274

		case 0x18: {	/* AI rank */

   275

			/* TODO: _railveh_score should be merged to _rail_vehicle_info. */

   276

			FOR_EACH_ENGINE {

   277

				grf_load_byte(&buf);

   278

			}

   279

			ret = true;

   280

		}	break;

   281

		case 0x19: { /* Engine traction type */

   282

			/* TODO: What do the individual numbers mean?

   283

			 * XXX: And in what base are they, in fact? --pasky */

   284

			FOR_EACH_ENGINE {

   285

				uint8 traction = grf_load_byte(&buf);

   286

				int engclass;

   287

   288

				if (traction <= 0x07)

   289

					engclass = 0;

   290

				else if (traction <= 0x27)

   291

					engclass = 1;

   292

				else if (traction <= 0x31)

   293

					engclass = 2;

   294

				else

   295

					break;

   296

   297

				rvi[i].engclass = engclass;

   298

			}

   299

		}	break;

   300

   301

		/* TODO */

   302

		/* Fall-through for unimplemented four bytes long properties. */

   303

		case 0x1D:	/* Refit cargo */

   304

			FOR_EACH_ENGINE {

   305

				grf_load_word(&buf);

   306

			}

   307

		/* Fall-through for unimplemented two bytes long properties. */

   308

		case 0x1B:	/* Powered wagons power bonus */

   309

			FOR_EACH_ENGINE {

   310

				grf_load_byte(&buf);

   311

			}

   312

		/* Fall-through for unimplemented one byte long properties. */

   313

		case 0x1A:	/* Sort order */

   314

		case 0x1C:	/* Refit cost */

   315

		case 0x1E:	/* Callback */

   316

		case 0x1F:	/* Tractive effort */

   317

		case 0x21:	/* Shorter tenders */

   318

		case 0x22:	/* Visual */

   319

		case 0x23: {/* Powered wagons weight bonus */

   320

			/* TODO */

   321

			FOR_EACH_ENGINE {

   322

				grf_load_byte(&buf);

   323

			}

   324

			ret = true;

   325

		}	break;

   326

		default:

   327

			ret = true;

   328

	}

   329

	*bufp = buf;

   330

	return ret;

   331

}

   332

   333

static bool ShipVehicleChangeInfo(uint engine, int numinfo, int prop, byte **bufp, int len)

   334

{

   335

	ShipVehicleInfo *svi = &_ship_vehicle_info[engine];

   336

	byte *buf = *bufp;

   337

	int i;

   338

	bool ret = false;

   339

   340

	//printf("e %x prop %x?\n", engine, prop);

   341

	switch (prop) {

   342

		case 0x08: {	/* Sprite ID */

   343

			FOR_EACH_ENGINE {

   344

				uint8 spriteid = grf_load_byte(&buf);

   345

   346

				if (spriteid == 0xFF)

   347

					spriteid = 0xFD; // ships have different custom id in the GRF file

   348

   349

				// This is currently not used but there's no reason

   350

				// in not having it here for the future.

   351

				if (spriteid == 0xFD && svi[i].image_index != 0xFD)

   352

					_engine_original_sprites[SHIP_ENGINES_INDEX + engine + i] = svi[i].image_index;

   353

   354

				svi[i].image_index = spriteid;

   355

			}

   356

		}	break;

   357

		case 0x09: {	/* Refittable */

   358

			FOR_EACH_ENGINE {

   359

				uint8 refittable = grf_load_byte(&buf);

   360

   361

				svi[i].refittable = refittable;

   362

			}

   363

		}	break;

   364

		case 0x0A: {	/* Cost factor */

   365

			FOR_EACH_ENGINE {

   366

				uint8 cost_factor = grf_load_byte(&buf);

   367

   368

				svi[i].base_cost = cost_factor; // ?? is it base_cost?

   369

			}

   370

		}	break;

   371

		case 0x0B: {	/* Speed */

   372

			FOR_EACH_ENGINE {

   373

				uint8 speed = grf_load_byte(&buf);

   374

   375

				svi[i].max_speed = speed; // ?? units

   376

			}

   377

		}	break;

   378

		case 0x0C: { /* Cargo type */

   379

			FOR_EACH_ENGINE {

   380

				uint8 cargo = grf_load_byte(&buf);

   381

   382

				// XXX: Need to consult this with patchman yet.

   383

#if 0

   384

				// Documentation claims this is already the

   385

				// per-landscape cargo type id, but newships.grf

   386

				// assume otherwise.

   387

				cargo = local_cargo_id_ctype[cargo];

   388

#endif

   389

				svi[i].cargo_type = cargo;

   390

			}

   391

		}	break;

   392

		case 0x0D: {	/* Cargo capacity */

   393

			FOR_EACH_ENGINE {

   394

				uint16 capacity = grf_load_word(&buf);

   395

   396

				svi[i].capacity = capacity;

   397

			}

   398

		}	break;

   399

		case 0x0F: {	/* Running cost factor */

   400

			FOR_EACH_ENGINE {

   401

				uint8 runcost = grf_load_byte(&buf);

   402

   403

				svi[i].running_cost = runcost;

   404

			}

   405

		} break;

   406

		case 0x10: {	/* SFX */

   407

			FOR_EACH_ENGINE {

   408

				uint8 sfx = grf_load_byte(&buf);

   409

   410

				svi[i].sfx = sfx;

   411

			}

   412

		}	break;

   413

		case 0x11: {	/* Cargos available for refitting */

   414

			FOR_EACH_ENGINE {

   415

				uint32 refit_mask = grf_load_dword(&buf);

   416

   417

				_engine_refit_masks[SHIP_ENGINES_INDEX + engine + i] = refit_mask;

   418

			}

   419

		}	break;

   420

		case 0x12: { /* Callback TODO */

   421

			ret = true;

   422

		}	break;

   423

		default:

   424

			ret = true;

   425

	}

   426

   427

	*bufp = buf;

   428

	return ret;

   429

}

   430

   431

#undef shift_buf

   432

   433

/* Action 0x00 */

   434

static void VehicleChangeInfo(byte *buf, int len)

   435

{

   436

	byte *bufend = buf + len;

   437

	int i;

   438

   439

	/* <00> <feature> <num-props> <num-info> <id> (<property <new-info>)...

   440

	 *

   441

	 * B feature       0, 1, 2 or 3 for trains, road vehicles, ships or planes

   442

	 *                 4 for defining new train station sets

   443

	 * B num-props     how many properties to change per vehicle/station

   444

	 * B num-info      how many vehicles/stations to change

   445

	 * B id            ID of first vehicle/station to change, if num-info is

   446

	 *                 greater than one, this one and the following

   447

	 *                 vehicles/stations will be changed

   448

	 * B property      what property to change, depends on the feature

   449

	 * V new-info      new bytes of info (variable size; depends on properties) */

   450

	/* TODO: Only trains and ships are supported for now. */

   451

   452

	static const VCI_Handler handler[5] = {

   453

		RailVehicleChangeInfo,

   454

		NULL,

   455

		ShipVehicleChangeInfo,

   456

		NULL,

   457

		NULL,

   458

	};

   459

   460

	uint8 feature;

   461

	uint8 numprops;

   462

	uint8 numinfo;

   463

	byte engine;

   464

	EngineInfo *ei;

   465

   466

	check_length(len, 6, "VehicleChangeInfo");

   467

	feature = buf[1];

   468

	numprops = buf[2];

   469

	numinfo = buf[3];

   470

	engine = buf[4];

   471

   472

	if (feature != 0 && feature != 2) {

   473

		grfmsg(GMS_WARN, "VehicleChangeInfo: Unsupported vehicle type %x, skipping.", feature);

   474

		return;

   475

	}

   476

   477

	ei = &_engine_info[engine + _vehshifts[feature]];

   478

   479

	buf += 5;

   480

   481

	while (numprops-- && buf < bufend) {

   482

		uint8 prop = grf_load_byte(&buf);

   483

   484

		switch (prop) {

   485

		case 0x00: { /* Introduction date */

   486

			FOR_EACH_ENGINE {

   487

				uint16 date = grf_load_word(&buf);

   488

   489

				ei[i].base_intro = date;

   490

			}

   491

		}	break;

   492

		case 0x02: { /* Decay speed */

   493

			FOR_EACH_ENGINE {

   494

				uint8 decay = grf_load_byte(&buf);

   495

   496

				ei[i].unk2 &= 0x80;

   497

				ei[i].unk2 |= decay & 0x7f;

   498

			}

   499

		}	break;

   500

		case 0x03: { /* Vehicle life */

   501

			FOR_EACH_ENGINE {

   502

				uint8 life = grf_load_byte(&buf);

   503

   504

				ei[i].lifelength = life;

   505

			}