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;

    22

    23

static const char *_cur_grffile;

    24

static int _cur_spriteid;

    25

    26

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

    27

    28

static const int _vehshifts[4] = {

    29

	0,

    30

	ROAD_ENGINES_INDEX,

    31

	SHIP_ENGINES_INDEX,

    32

	AIRCRAFT_ENGINES_INDEX,

    33

};

    34

    35

    36

enum grfmsg_severity {

    37

	GMS_NOTICE,

    38

	GMS_WARN,

    39

	GMS_ERROR,

    40

	GMS_FATAL,

    41

};

    42

    43

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

    44

{

    45

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

    46

	char buf[1024];

    47

	va_list va;

    48

    49

	va_start(va, str);

    50

	vsprintf(buf, str, va);

    51

	va_end(va);

    52

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

    53

}

    54

    55

    56

#define check_length(real, wanted, where) \

    57

do { \

    58

	if (real < wanted) { \

    59

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

    60

		return; \

    61

	} \

    62

} while (0)

    63

    64

    65

static byte INLINE grf_load_byte(byte **buf) {

    66

	return *(*buf)++;

    67

}

    68

    69

static uint16 grf_load_word(byte **buf)

    70

{

    71

	uint16 val;

    72

	byte *p = *buf;

    73

	val = p[0];

    74

	val |= p[1] << 8;

    75

	*buf = p + 2;

    76

	return val;

    77

}

    78

    79

static uint16 grf_load_dword(byte **buf)

    80

{

    81

	uint32 val;

    82

	byte *p = *buf;

    83

	val = p[0];

    84

	val |= p[1] << 8;

    85

	val |= p[2] << 16;

    86

	val |= p[3] << 24;

    87

	*buf = p + 4;

    88

	return val;

    89

}

    90

    91

    92

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

    93

    94

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

    95

    96

static void dewagonize(int condition, int engine)

    97

{

    98

	EngineInfo *ei = &_engine_info[engine];

    99

	RailVehicleInfo *rvi = &_rail_vehicle_info[engine];

   100

   101

	if (condition) {

   102

		ei->unk2 &= ~0x80;

   103

		rvi->flags &= ~2;

   104

	} else {

   105

		ei->unk2 |= 0x80;

   106

		rvi->flags |= 2;

   107

	}

   108

}

   109

   110

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

   111

{

   112

	EngineInfo *ei = &_engine_info[engine];

   113

	RailVehicleInfo *rvi = &_rail_vehicle_info[engine];

   114

	byte *buf = *bufp;

   115

	int i;

   116

	bool ret = false;

   117

   118

	switch (prop) {

   119

		case 0x05: {	/* Track type */

   120

			FOR_EACH_ENGINE {

   121

				uint8 tracktype = grf_load_byte(&buf);

   122

   123

				ei[i].railtype_climates &= 0xf;

   124

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

   125

			}

   126

		}	break;

   127

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

   128

			/* TODO */

   129

			FOR_EACH_ENGINE {

   130

				grf_load_byte(&buf);

   131

			}

   132

			ret = true;

   133

		}	break;

   134

		case 0x09: {	/* Speed */

   135

			FOR_EACH_ENGINE {

   136

				uint16 speed = grf_load_word(&buf);

   137

   138

				rvi[i].max_speed = speed;

   139

				dewagonize(speed, engine + i);

   140

			}

   141

		}	break;

   142

		case 0x0B: {	/* Power */

   143

			FOR_EACH_ENGINE {

   144

				uint16 power = grf_load_word(&buf);

   145

   146

				rvi[i].power = power;

   147

				dewagonize(power, engine + i);

   148

			}

   149

		}	break;

   150

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

   151

			FOR_EACH_ENGINE {

   152

				uint8 runcostfact = grf_load_byte(&buf);

   153

   154

				rvi[i].running_cost_base = runcostfact;

   155

				dewagonize(runcostfact, engine + i);

   156

			}

   157

		}	break;

   158

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

   159

			FOR_EACH_ENGINE {

   160

				uint32 base = grf_load_dword(&buf);

   161

   162

				switch (base) {

   163

				case 0x4C30:

   164

					rvi[i].engclass = 0;

   165

					break;

   166

				case 0x4C36:

   167

					rvi[i].engclass = 1;

   168

					break;

   169

				case 0x4C3C:

   170

					rvi[i].engclass = 2;

   171

					break;

   172

				}

   173

				dewagonize(base, engine + i);

   174

			}

   175

		}	break;

   176

		case 0x12: {	/* Sprite ID */

   177

			FOR_EACH_ENGINE {

   178

				uint8 spriteid = grf_load_byte(&buf);

   179

   180

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

   181

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

   182

				rvi[i].image_index = spriteid;

   183

			}

   184

		}	break;

   185

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

   186

			FOR_EACH_ENGINE {

   187

				uint8 dual = grf_load_byte(&buf);

   188

   189

				if (dual) {

   190

					rvi[i].flags |= 1;

   191

				} else {

   192

					rvi[i].flags &= ~1;

   193

				}

   194

			}

   195

		}	break;

   196

		case 0x14: {	/* Cargo capacity */

   197

			FOR_EACH_ENGINE {

   198

				uint8 capacity = grf_load_byte(&buf);

   199

   200

				rvi[i].capacity = capacity;

   201

			}

   202

		}	break;

   203

		case 0x15: {	/* Cargo type */

   204

			FOR_EACH_ENGINE {

   205

				uint8 ctype = grf_load_byte(&buf);

   206

   207

				rvi[i].cargo_type = ctype;

   208

			}

   209

		}	break;

   210

		case 0x16: {	/* Weight */

   211

			FOR_EACH_ENGINE {

   212

				uint8 weight = grf_load_byte(&buf);

   213

   214

				rvi[i].weight = weight;

   215

			}

   216

		}	break;

   217

		case 0x17: {	/* Cost factor */

   218

			FOR_EACH_ENGINE {

   219

				uint8 cfactor = grf_load_byte(&buf);

   220

   221

				rvi[i].base_cost = cfactor;

   222

			}

   223

		}	break;

   224

		case 0x18: {	/* AI rank */

   225

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

   226

			FOR_EACH_ENGINE {

   227

				grf_load_byte(&buf);

   228

			}

   229

			ret = true;

   230

		}	break;

   231

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

   232

			/* TODO: What do the individual numbers mean?

   233

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

   234

			FOR_EACH_ENGINE {

   235

				uint8 traction = grf_load_byte(&buf);

   236

				int engclass;

   237

   238

				if (traction <= 0x07)

   239

					engclass = 0;

   240

				else if (traction <= 0x27)

   241

					engclass = 1;

   242

				else if (traction <= 0x31)

   243

					engclass = 2;

   244

				else

   245

					break;

   246

   247

				rvi[i].engclass = engclass;

   248

			}

   249

		}	break;

   250

   251

		/* TODO */

   252

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

   253

		case 0x1D:	/* Refit cargo */

   254

			FOR_EACH_ENGINE {

   255

				grf_load_word(&buf);

   256

			}

   257

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

   258

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

   259

			FOR_EACH_ENGINE {

   260

				grf_load_byte(&buf);

   261

			}

   262

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

   263

		case 0x1A:	/* Sort order */

   264

		case 0x1C:	/* Refit cost */

   265

		case 0x1E:	/* Callback */

   266

		case 0x1F:	/* Tractive effort */

   267

		case 0x21:	/* Shorter tenders */

   268

		case 0x22:	/* Visual */

   269

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

   270

			/* TODO */

   271

			FOR_EACH_ENGINE {

   272

				grf_load_byte(&buf);

   273

			}

   274

			ret = true;

   275

		}	break;

   276

		default:

   277

			ret = true;

   278

	}

   279

	*bufp = buf;

   280

	return ret;

   281

}

   282

   283

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

   284

{

   285

	ShipVehicleInfo *svi = &_ship_vehicle_info[engine];

   286

	byte *buf = *bufp;

   287

	int i;

   288

	bool ret = false;

   289

   290

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

   291

	switch (prop) {

   292

		case 0x08: {	/* Sprite ID */

   293

			FOR_EACH_ENGINE {

   294

				uint8 spriteid = grf_load_byte(&buf);

   295

   296

				if (spriteid == 0xFF)

   297

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

   298

   299

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

   300

				// in not having it here for the future.

   301

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

   302

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

   303

   304

				svi[i].image_index = spriteid;

   305

			}

   306

		}	break;

   307

		case 0x09: {	/* Refittable */

   308

			FOR_EACH_ENGINE {

   309

				uint8 refittable = grf_load_byte(&buf);

   310

   311

				svi[i].refittable = refittable;

   312

			}

   313

		}	break;

   314

		case 0x0A: {	/* Cost factor */

   315

			FOR_EACH_ENGINE {

   316

				uint8 cost_factor = grf_load_byte(&buf);

   317

   318

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

   319

			}

   320

		}	break;

   321

		case 0x0B: {	/* Speed */

   322

			FOR_EACH_ENGINE {

   323

				uint8 speed = grf_load_byte(&buf);

   324

   325

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

   326

			}

   327

		}	break;

   328

		case 0x0C: { /* Cargo type */

   329

			FOR_EACH_ENGINE {

   330

				uint8 cargo = grf_load_byte(&buf);

   331

   332

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

   333

#if 0

   334

				// Documentation claims this is already the

   335

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

   336

				// assume otherwise.

   337

				cargo = local_cargo_id_ctype[cargo];

   338

#endif

   339

				svi[i].cargo_type = cargo;

   340

			}

   341

		}	break;

   342

		case 0x0D: {	/* Cargo capacity */

   343

			FOR_EACH_ENGINE {

   344

				uint16 capacity = grf_load_word(&buf);

   345

   346

				svi[i].capacity = capacity;

   347

			}

   348

		}	break;

   349

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

   350

			FOR_EACH_ENGINE {

   351

				uint8 runcost = grf_load_byte(&buf);

   352

   353

				svi[i].running_cost = runcost;

   354

			}

   355

		} break;

   356

		case 0x10: {	/* SFX */

   357

			FOR_EACH_ENGINE {

   358

				uint8 sfx = grf_load_byte(&buf);

   359

   360

				svi[i].sfx = sfx;

   361

			}

   362

		}	break;

   363

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

   364

			FOR_EACH_ENGINE {

   365

				uint32 refit_mask = grf_load_dword(&buf);

   366

   367

				_engine_refit_masks[SHIP_ENGINES_INDEX + engine + i] = refit_mask;

   368

			}

   369

		}	break;

   370

		case 0x12: { /* Callback TODO */

   371

			ret = true;

   372

		}	break;

   373

		default:

   374

			ret = true;

   375

	}

   376

   377

	*bufp = buf;

   378

	return ret;

   379

}

   380

   381

#undef shift_buf

   382

   383

/* Action 0x00 */

   384

static void VehicleChangeInfo(byte *buf, int len)

   385

{

   386

	byte *bufend = buf + len;

   387

	int i;

   388

   389

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

   390

	 *

   391

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

   392

	 *                 4 for defining new train station sets

   393

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

   394

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

   395

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

   396

	 *                 greater than one, this one and the following

   397

	 *                 vehicles/stations will be changed

   398

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

   399

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

   400

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

   401

   402

	static const VCI_Handler handler[5] = {

   403

		RailVehicleChangeInfo,

   404

		NULL,

   405

		ShipVehicleChangeInfo,

   406

		NULL,

   407

		NULL,

   408

	};

   409

   410

	uint8 feature;

   411

	uint8 numprops;

   412

	uint8 numinfo;

   413

	byte engine;

   414

	EngineInfo *ei;

   415

   416

	check_length(len, 6, "VehicleChangeInfo");

   417

	feature = buf[1];

   418

	numprops = buf[2];

   419

	numinfo = buf[3];

   420

	engine = buf[4];

   421

   422

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

   423

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

   424

		return;

   425

	}

   426

   427

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

   428

   429

	buf += 5;

   430

   431

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

   432

		uint8 prop = grf_load_byte(&buf);

   433

   434

		switch (prop) {

   435

		case 0x00: { /* Introduction date */

   436

			FOR_EACH_ENGINE {

   437

				uint16 date = grf_load_word(&buf);

   438

   439

				ei[i].base_intro = date;

   440

			}

   441

		}	break;

   442

		case 0x02: { /* Decay speed */

   443

			FOR_EACH_ENGINE {

   444

				uint8 decay = grf_load_byte(&buf);

   445

   446

				ei[i].unk2 &= 0x80;

   447

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

   448

			}

   449

		}	break;

   450

		case 0x03: { /* Vehicle life */

   451

			FOR_EACH_ENGINE {

   452

				uint8 life = grf_load_byte(&buf);

   453

   454

				ei[i].lifelength = life;

   455

			}

   456

		}	break;

   457

		case 0x04: { /* Model life */

   458

			FOR_EACH_ENGINE {

   459

				uint8 life = grf_load_byte(&buf);

   460

   461

				ei[i].base_life = life;

   462

			}

   463

		}	break;

   464

		case 0x06: { /* Climates available */

   465

			FOR_EACH_ENGINE {

   466

				uint8 climates = grf_load_byte(&buf);

   467

   468

				ei[i].railtype_climates &= 0xf0;

   469

				ei[i].railtype_climates |= climates;

   470

			}

   471

		}	break;

   472

		case 0x07: { /* Loading spee */

   473

			/* TODO */

   474

			/* Hyronymus explained me what does

   475

			 * this mean and insists on having a

   476

			 * credit ;-). --pasky */

   477

			/* TODO: This needs to be supported by

   478

			 * LoadUnloadVehicle() first. */

   479

			FOR_EACH_ENGINE {

   480

				grf_load_byte(&buf);

   481

			}

   482

			goto ignoring;

   483

		}

   484

		default: {

   485

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

   486

ignoring:

   487

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

   488

			}

   489

			break;

   490

		}

   491

		}

   492

	}

   493

#undef shift_buf

   494

}

   495

   496

   497

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

   498

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

   499

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

   500

 * contributing to the global confusion.

   501

 *

   502

 * A sprite set contains all sprites of a given vehicle carrying given cargo at

   503

 * a given *stage* - that is usually its load stage. Ie. you can have a

   504

 * spriteset for an empty wagon, wagon full of coal, half-filled wagon etc.

   505

 * Each spriteset contains eight sprites (one per direction) or four sprites if

   506

 * the vehicle is symmetric. */

   507