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

static const char *_cur_grffile;

    24

static int _cur_spriteid;

    25

    26

static int32 _paramlist[0x7f];

    27

static int _param_max;

    28

    33

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

    34

    35

static const int _vehshifts[4] = {

    36

	0,

    37

	ROAD_ENGINES_INDEX,

    38

	SHIP_ENGINES_INDEX,

    39

	AIRCRAFT_ENGINES_INDEX,

    40

};

    41

    42

    43

enum grfmsg_severity {

    44

	GMS_NOTICE,

    45

	GMS_WARN,

    46

	GMS_ERROR,

    47

	GMS_FATAL,

    48

};

    49

    50

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

    51

{

    52

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

    53

	char buf[1024];

    54

	va_list va;

    55

    56

	va_start(va, str);

    57

	vsprintf(buf, str, va);

    58

	va_end(va);

    59

	DEBUG(grf, 2) ("[%s][%s] %s", _cur_grffile, severitystr[severity], buf);

    60

}

    61

    62

    63

#define check_length(real, wanted, where) \

    64

do { \

    65

	if (real < wanted) { \

    66

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

    67

		return; \

    68

	} \

    69

} while (0)

    70

    71

    72

static byte INLINE grf_load_byte(byte **buf) {

    73

	return *(*buf)++;

    74

}

    75

    76

static uint16 grf_load_word(byte **buf)

    77

{

    78

	uint16 val;

    79

	byte *p = *buf;

    80

	val = p[0];

    81

	val |= p[1] << 8;

    82

	*buf = p + 2;

    83

	return val;

    84

}

    85

    86

static uint16 grf_load_dword(byte **buf)

    87

{

    88

	uint32 val;

    89

	byte *p = *buf;

    90

	val = p[0];

    91

	val |= p[1] << 8;

    92

	val |= p[2] << 16;

    93

	val |= p[3] << 24;

    94

	*buf = p + 4;

    95

	return val;

    96

}

    97

    98

    99

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

   100

   101

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

   102

   103

static void dewagonize(int condition, int engine)

   104

{

   105

	EngineInfo *ei = &_engine_info[engine];

   106

	RailVehicleInfo *rvi = &_rail_vehicle_info[engine];

   107

   108

	if (condition) {

   109

		ei->unk2 &= ~0x80;

   110

		rvi->flags &= ~2;

   111

	} else {

   112

		ei->unk2 |= 0x80;

   113

		rvi->flags |= 2;

   114

	}

   115

}

   116

   117

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

   118

{

   119

	EngineInfo *ei = &_engine_info[engine];

   120

	RailVehicleInfo *rvi = &_rail_vehicle_info[engine];

   121

	byte *buf = *bufp;

   122

	int i;

   123

	bool ret = false;

   124

   125

	switch (prop) {

   126

		case 0x05: {	/* Track type */

   127

			FOR_EACH_ENGINE {

   128

				uint8 tracktype = grf_load_byte(&buf);

   129

   130

				ei[i].railtype_climates &= 0xf;

   131

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

   132

			}

   133

		}	break;

   134

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

   135

			/* TODO */

   136

			FOR_EACH_ENGINE {

   137

				grf_load_byte(&buf);

   138

			}

   139

			ret = true;

   140

		}	break;

   141

		case 0x09: {	/* Speed */

   142

			FOR_EACH_ENGINE {

   143

				uint16 speed = grf_load_word(&buf);

   144

   145

				rvi[i].max_speed = speed;

   146

				dewagonize(speed, engine + i);

   147

			}

   148

		}	break;

   149

		case 0x0B: {	/* Power */

   150

			FOR_EACH_ENGINE {

   151

				uint16 power = grf_load_word(&buf);

   152

   153

				rvi[i].power = power;

   154

				dewagonize(power, engine + i);

   155

			}

   156

		}	break;

   157

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

   158

			FOR_EACH_ENGINE {

   159

				uint8 runcostfact = grf_load_byte(&buf);

   160

   161

				rvi[i].running_cost_base = runcostfact;

   162

				dewagonize(runcostfact, engine + i);

   163

			}

   164

		}	break;

   165

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

   166

			FOR_EACH_ENGINE {

   167

				uint32 base = grf_load_dword(&buf);

   168

   169

				switch (base) {

   170

				case 0x4C30:

   171

					rvi[i].engclass = 0;

   172

					break;

   173

				case 0x4C36:

   174

					rvi[i].engclass = 1;

   175

					break;

   176

				case 0x4C3C:

   177

					rvi[i].engclass = 2;

   178

					break;

   179

				}

   180

				dewagonize(base, engine + i);

   181

			}

   182

		}	break;

   183

		case 0x12: {	/* Sprite ID */

   184

			FOR_EACH_ENGINE {

   185

				uint8 spriteid = grf_load_byte(&buf);

   186

   187

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

   188

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

   189

				rvi[i].image_index = spriteid;

   190

			}

   191

		}	break;

   192

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

   193

			FOR_EACH_ENGINE {

   194

				uint8 dual = grf_load_byte(&buf);

   195

   196

				if (dual) {

   197

					rvi[i].flags |= 1;

   198

				} else {

   199

					rvi[i].flags &= ~1;

   200

				}

   201

			}

   202

		}	break;

   203

		case 0x14: {	/* Cargo capacity */

   204

			FOR_EACH_ENGINE {

   205

				uint8 capacity = grf_load_byte(&buf);

   206

   207

				rvi[i].capacity = capacity;

   208

			}

   209

		}	break;

   210

		case 0x15: {	/* Cargo type */

   211

			FOR_EACH_ENGINE {

   212

				uint8 ctype = grf_load_byte(&buf);

   213

   214

				rvi[i].cargo_type = ctype;

   215

			}

   216

		}	break;

   217

		case 0x16: {	/* Weight */

   218

			FOR_EACH_ENGINE {

   219

				uint8 weight = grf_load_byte(&buf);

   220

   221

				rvi[i].weight = weight;

   222

			}

   223

		}	break;

   224

		case 0x17: {	/* Cost factor */

   225

			FOR_EACH_ENGINE {

   226

				uint8 cfactor = grf_load_byte(&buf);

   227

   228

				rvi[i].base_cost = cfactor;

   229

			}

   230

		}	break;

   231

		case 0x18: {	/* AI rank */

   232

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

   233

			FOR_EACH_ENGINE {

   234

				grf_load_byte(&buf);

   235

			}

   236

			ret = true;

   237

		}	break;

   238

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

   239

			/* TODO: What do the individual numbers mean?

   240

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

   241

			FOR_EACH_ENGINE {

   242

				uint8 traction = grf_load_byte(&buf);

   243

				int engclass;

   244

   245

				if (traction <= 0x07)

   246

					engclass = 0;

   247

				else if (traction <= 0x27)

   248

					engclass = 1;

   249

				else if (traction <= 0x31)

   250

					engclass = 2;

   251

				else

   252

					break;

   253

   254

				rvi[i].engclass = engclass;

   255

			}

   256

		}	break;

   257

   258

		/* TODO */

   259

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

   260

		case 0x1D:	/* Refit cargo */

   261

			FOR_EACH_ENGINE {

   262

				grf_load_word(&buf);

   263

			}

   264

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

   265

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

   266

			FOR_EACH_ENGINE {

   267

				grf_load_byte(&buf);

   268

			}

   269

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

   270

		case 0x1A:	/* Sort order */

   271

		case 0x1C:	/* Refit cost */

   272

		case 0x1E:	/* Callback */

   273

		case 0x1F:	/* Tractive effort */

   274

		case 0x21:	/* Shorter tenders */

   275

		case 0x22:	/* Visual */

   276

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

   277

			/* TODO */

   278

			FOR_EACH_ENGINE {

   279

				grf_load_byte(&buf);

   280

			}

   281

			ret = true;

   282

		}	break;

   283

		default:

   284

			ret = true;

   285

	}

   286

	*bufp = buf;

   287

	return ret;

   288

}

   289

   290

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

   291

{

   292

	ShipVehicleInfo *svi = &_ship_vehicle_info[engine];

   293

	byte *buf = *bufp;

   294

	int i;

   295

	bool ret = false;

   296

   297

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

   298

	switch (prop) {

   299

		case 0x08: {	/* Sprite ID */

   300

			FOR_EACH_ENGINE {

   301

				uint8 spriteid = grf_load_byte(&buf);

   302

   303

				if (spriteid == 0xFF)

   304

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

   305

   306

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

   307

				// in not having it here for the future.

   308

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

   309

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

   310

   311

				svi[i].image_index = spriteid;

   312

			}

   313

		}	break;

   314

		case 0x09: {	/* Refittable */

   315

			FOR_EACH_ENGINE {

   316

				uint8 refittable = grf_load_byte(&buf);

   317

   318

				svi[i].refittable = refittable;

   319

			}

   320

		}	break;

   321

		case 0x0A: {	/* Cost factor */

   322

			FOR_EACH_ENGINE {

   323

				uint8 cost_factor = grf_load_byte(&buf);

   324

   325

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

   326

			}

   327

		}	break;

   328

		case 0x0B: {	/* Speed */

   329

			FOR_EACH_ENGINE {

   330

				uint8 speed = grf_load_byte(&buf);

   331

   332

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

   333

			}

   334

		}	break;

   335

		case 0x0C: { /* Cargo type */

   336

			FOR_EACH_ENGINE {

   337

				uint8 cargo = grf_load_byte(&buf);

   338

   339

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

   340

#if 0

   341

				// Documentation claims this is already the

   342

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

   343

				// assume otherwise.

   344

				cargo = local_cargo_id_ctype[cargo];

   345

#endif

   346

				svi[i].cargo_type = cargo;

   347

			}

   348

		}	break;

   349

		case 0x0D: {	/* Cargo capacity */

   350

			FOR_EACH_ENGINE {

   351

				uint16 capacity = grf_load_word(&buf);

   352

   353

				svi[i].capacity = capacity;

   354

			}

   355

		}	break;

   356

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

   357

			FOR_EACH_ENGINE {

   358

				uint8 runcost = grf_load_byte(&buf);

   359

   360

				svi[i].running_cost = runcost;

   361

			}

   362

		} break;

   363

		case 0x10: {	/* SFX */

   364

			FOR_EACH_ENGINE {

   365

				uint8 sfx = grf_load_byte(&buf);

   366

   367

				svi[i].sfx = sfx;

   368

			}

   369

		}	break;

   370

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

   371

			FOR_EACH_ENGINE {

   372

				uint32 refit_mask = grf_load_dword(&buf);

   373

   374

				_engine_refit_masks[SHIP_ENGINES_INDEX + engine + i] = refit_mask;

   375

			}

   376

		}	break;

   377

		case 0x12: { /* Callback TODO */

   378

			ret = true;

   379

		}	break;

   380

		default:

   381

			ret = true;

   382

	}

   383

   384

	*bufp = buf;

   385

	return ret;

   386

}

   387

   388

#undef shift_buf

   389

   390

/* Action 0x00 */

   391

static void VehicleChangeInfo(byte *buf, int len)

   392

{

   393

	byte *bufend = buf + len;

   394

	int i;

   395

   396

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

   397

	 *

   398

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

   399

	 *                 4 for defining new train station sets

   400

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

   401

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

   402

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

   403

	 *                 greater than one, this one and the following

   404

	 *                 vehicles/stations will be changed

   405

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

   406

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

   407

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

   408

   409

	static const VCI_Handler handler[5] = {

   410

		RailVehicleChangeInfo,

   411

		NULL,

   412

		ShipVehicleChangeInfo,

   413

		NULL,

   414

		NULL,

   415

	};

   416

   417

	uint8 feature;

   418

	uint8 numprops;

   419

	uint8 numinfo;

   420

	byte engine;

   421

	EngineInfo *ei;

   422

   423

	check_length(len, 6, "VehicleChangeInfo");

   424

	feature = buf[1];

   425

	numprops = buf[2];

   426

	numinfo = buf[3];

   427

	engine = buf[4];

   428

   429

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

   430

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

   431

		return;

   432

	}

   433

   434

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

   435

   436

	buf += 5;

   437

   438

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

   439

		uint8 prop = grf_load_byte(&buf);

   440

   441

		switch (prop) {

   442

		case 0x00: { /* Introduction date */

   443

			FOR_EACH_ENGINE {

   444

				uint16 date = grf_load_word(&buf);

   445

   446

				ei[i].base_intro = date;

   447

			}

   448

		}	break;

   449

		case 0x02: { /* Decay speed */

   450

			FOR_EACH_ENGINE {

   451

				uint8 decay = grf_load_byte(&buf);

   452

   453

				ei[i].unk2 &= 0x80;

   454

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

   455

			}

   456

		}	break;

   457

		case 0x03: { /* Vehicle life */

   458

			FOR_EACH_ENGINE {

   459

				uint8 life = grf_load_byte(&buf);

   460

   461

				ei[i].lifelength = life;

   462

			}

   463

		}	break;

   464

		case 0x04: { /* Model life */

   465

			FOR_EACH_ENGINE {

   466

				uint8 life = grf_load_byte(&buf);

   467

   468

				ei[i].base_life = life;

   469

			}

   470

		}	break;

   471

		case 0x06: { /* Climates available */

   472

			FOR_EACH_ENGINE {

   473

				uint8 climates = grf_load_byte(&buf);

   474

   475

				ei[i].railtype_climates &= 0xf0;

   476

				ei[i].railtype_climates |= climates;

   477

			}

   478

		}	break;

   479

		case 0x07: { /* Loading spee */

   480

			/* TODO */

   481

			/* Hyronymus explained me what does

   482

			 * this mean and insists on having a

   483

			 * credit ;-). --pasky */

   484

			/* TODO: This needs to be supported by

   485

			 * LoadUnloadVehicle() first. */

   486

			FOR_EACH_ENGINE {

   487

				grf_load_byte(&buf);

   488

			}

   489

			goto ignoring;

   490

		}

   491

		default: {

   492

			if (handler[feature](engine, numinfo, prop, &buf, bufend - buf)) {

   493

ignoring:

   494

				grfmsg(GMS_NOTICE, "VehicleChangeInfo: Ignoring property %x (not implemented).", prop);

   495

			}

   496

			break;

   497

		}

   498

		}

   499

	}

   500

#undef shift_buf

   501

}

   502

   503

   504

/* A sprite superset contains all sprites of a given vehicle (or multiple

   505

 * vehicles) when carrying given cargo. It consists of several sprite sets.

   506

 * Superset ids are refered as "cargo id"s by TTDPatch documentation,