1

/* $Id$ */

     2

     3

#include "stdafx.h"

     4

#include "openttd.h"

     5

#include "debug.h"

     6

#include "functions.h"

     7

#include "string.h"

     8

#include "strings.h"

     9

#include "engine.h"

    10

#include "newgrf_callbacks.h"

    11

#include "newgrf_engine.h"

    12

#include "sprite.h"

    13

#include "variables.h"

    14

#include "train.h"

    15

    16

// TODO: We don't support cargo-specific wagon overrides. Pretty exotic... ;-) --pasky

    17

    18

typedef struct WagonOverride {

    19

	byte *train_id;

    20

	int trains;

    21

	SpriteGroup *group;

    22

} WagonOverride;

    23

    24

typedef struct WagonOverrides {

    25

	int overrides_count;

    26

	WagonOverride *overrides;

    27

} WagonOverrides;

    28

    29

static WagonOverrides _engine_wagon_overrides[TOTAL_NUM_ENGINES];

    30

    31

void SetWagonOverrideSprites(EngineID engine, SpriteGroup *group, byte *train_id,

    32

	int trains)

    33

{

    34

	WagonOverrides *wos;

    35

	WagonOverride *wo;

    36

    37

	wos = &_engine_wagon_overrides[engine];

    38

	wos->overrides_count++;

    39

	wos->overrides = realloc(wos->overrides,

    40

		wos->overrides_count * sizeof(*wos->overrides));

    41

    42

	wo = &wos->overrides[wos->overrides_count - 1];

    43

	/* FIXME: If we are replacing an override, release original SpriteGroup

    44

	 * to prevent leaks. But first we need to refcount the SpriteGroup.

    45

	 * --pasky */

    46

	wo->group = group;

    47

	group->ref_count++;

    48

	wo->trains = trains;

    49

	wo->train_id = malloc(trains);

    50

	memcpy(wo->train_id, train_id, trains);

    51

}

    52

    53

static const SpriteGroup *GetWagonOverrideSpriteSet(EngineID engine, byte overriding_engine)

    54

{

    55

	const WagonOverrides *wos = &_engine_wagon_overrides[engine];

    56

	int i;

    57

    58

	// XXX: This could turn out to be a timesink on profiles. We could

    59

	// always just dedicate 65535 bytes for an [engine][train] trampoline

    60

	// for O(1). Or O(logMlogN) and searching binary tree or smt. like

    61

	// that. --pasky

    62

    63

	for (i = 0; i < wos->overrides_count; i++) {

    64

		const WagonOverride *wo = &wos->overrides[i];

    65

		int j;

    66

    67

		for (j = 0; j < wo->trains; j++) {

    68

			if (wo->train_id[j] == overriding_engine)

    69

				return wo->group;

    70

		}

    71

	}

    72

	return NULL;

    73

}

    74

    75

/**

    76

 * Unload all wagon override sprite groups.

    77

 */

    78

void UnloadWagonOverrides(void)

    79

{

    80

	WagonOverrides *wos;

    81

	WagonOverride *wo;

    82

	EngineID engine;

    83

	int i;

    84

    85

	for (engine = 0; engine < TOTAL_NUM_ENGINES; engine++) {

    86

		wos = &_engine_wagon_overrides[engine];

    87

		for (i = 0; i < wos->overrides_count; i++) {

    88

			wo = &wos->overrides[i];

    89

			UnloadSpriteGroup(&wo->group);

    90

			free(wo->train_id);

    91

		}

    92

		free(wos->overrides);

    93

		wos->overrides_count = 0;

    94

		wos->overrides = NULL;

    95

	}

    96

}

    97

    98

// 0 - 28 are cargos, 29 is default, 30 is the advert (purchase list)

    99

// (It isn't and shouldn't be like this in the GRF files since new cargo types

   100

// may appear in future - however it's more convenient to store it like this in

   101

// memory. --pasky)

   102

static SpriteGroup *engine_custom_sprites[TOTAL_NUM_ENGINES][NUM_GLOBAL_CID];

   103

   104

void SetCustomEngineSprites(EngineID engine, byte cargo, SpriteGroup *group)

   105

{

   106

	if (engine_custom_sprites[engine][cargo] != NULL) {

   107

		DEBUG(grf, 6)("SetCustomEngineSprites: engine `%d' cargo `%d' already has group -- removing.", engine, cargo);

   108

		UnloadSpriteGroup(&engine_custom_sprites[engine][cargo]);

   109

	}

   110

	engine_custom_sprites[engine][cargo] = group;

   111

	group->ref_count++;

   112

}

   113

   114

/**

   115

 * Unload all engine sprite groups.

   116

 */

   117

void UnloadCustomEngineSprites(void)

   118

{

   119

	EngineID engine;

   120

	CargoID cargo;

   121

   122

	for (engine = 0; engine < TOTAL_NUM_ENGINES; engine++) {

   123

		for (cargo = 0; cargo < NUM_GLOBAL_CID; cargo++) {

   124

			if (engine_custom_sprites[engine][cargo] != NULL) {

   125

				DEBUG(grf, 6)("UnloadCustomEngineSprites: Unloading group for engine `%d' cargo `%d'.", engine, cargo);

   126

				UnloadSpriteGroup(&engine_custom_sprites[engine][cargo]);

   127

			}

   128

		}

   129

	}

   130

}

   131

   132

static int MapOldSubType(const Vehicle *v)

   133

{

   134

	if (v->type != VEH_Train) return v->subtype;

   135

	if (IsTrainEngine(v)) return 0;

   136

	if (IsFreeWagon(v)) return 4;

   137

	return 2;

   138

}

   139

   140

static int VehicleSpecificProperty(const Vehicle *v, byte var) {

   141

	switch (v->type) {

   142

		case VEH_Train:

   143

			switch (var) {

   144

				case 0x62: return v->u.rail.track;

   145

				case 0x66: return v->u.rail.railtype;

   146

				case 0x73: return v->u.rail.cached_veh_length;

   147

				case 0x74: return v->u.rail.cached_power;

   148

				case 0x75: return v->u.rail.cached_power & 0xFFFFFF;

   149

				case 0x76: return v->u.rail.cached_power & 0xFFFF;

   150

				case 0x77: return v->u.rail.cached_power & 0xFF;

   151

				case 0x7C: return v->first->index;

   152

				case 0x7D: return v->first->index & 0xFF;

   153

			}

   154

			break;

   155

   156

		case VEH_Road:

   157

			switch (var) {

   158

				case 0x62: return v->u.road.state;

   159

				case 0x64: return v->u.road.blocked_ctr;

   160

				case 0x65: return v->u.road.blocked_ctr & 0xFF;

   161

				case 0x66: return v->u.road.overtaking;

   162

				case 0x67: return v->u.road.overtaking_ctr;

   163

				case 0x68: return v->u.road.crashed_ctr;

   164

				case 0x69: return v->u.road.crashed_ctr & 0xFF;

   165

			}

   166

			break;

   167

   168

		case VEH_Aircraft:

   169

			switch (var) {

   170

				// case 0x62: XXX Need to convert from ottd to ttdp state

   171

				case 0x63: return v->u.air.targetairport;

   172

				// case 0x66: XXX

   173

			}

   174

			break;

   175

	}

   176

   177

	DEBUG(grf, 1)("Unhandled vehicle property 0x%x (var 0x%x), type 0x%x", var, var + 0x80, v->type);

   178

   179

	return -1;

   180

}

   181

   182

typedef SpriteGroup *(*resolve_callback)(const SpriteGroup *spritegroup,

   183

	const Vehicle *veh, uint16 callback_info, void *resolve_func); /* XXX data pointer used as function pointer */

   184

   185

static const SpriteGroup* ResolveVehicleSpriteGroup(const SpriteGroup *spritegroup,

   186

	const Vehicle *veh, uint16 callback_info, resolve_callback resolve_func)

   187

{

   188

	if (spritegroup == NULL)

   189

		return NULL;

   190

   191

	//debug("spgt %d", spritegroup->type);

   192

	switch (spritegroup->type) {

   193

		case SGT_REAL:

   194

		case SGT_CALLBACK:

   195

			return spritegroup;

   196

   197

		case SGT_DETERMINISTIC: {

   198

			const DeterministicSpriteGroup *dsg = &spritegroup->g.determ;

   199

			const SpriteGroup *target;

   200

			int value = -1;

   201

   202

			//debug("[%p] Having fun resolving variable %x", veh, dsg->variable);

   203

			if (dsg->variable == 0x0C) {

   204

				/* Callback ID */

   205

				value = callback_info & 0xFF;

   206

			} else if (dsg->variable == 0x10) {

   207

				value = (callback_info >> 8) & 0xFF;

   208

			} else if ((dsg->variable >> 6) == 0) {

   209

				/* General property */

   210

				value = GetDeterministicSpriteValue(dsg->variable);

   211

			} else {

   212

				/* Vehicle-specific property. */

   213

   214

				if (veh == NULL) {

   215

					/* We are in a purchase list of something,

   216

					 * and we are checking for something undefined.

   217

					 * That means we should get the first target

   218

					 * (NOT the default one). */

   219

					if (dsg->num_ranges > 0) {

   220

						target = dsg->ranges[0].group;

   221

					} else {

   222

						target = dsg->default_group;

   223

					}

   224

					return resolve_func(target, NULL, callback_info, resolve_func);

   225

				}

   226

   227

				if (dsg->var_scope == VSG_SCOPE_PARENT) {

   228

					/* First engine in the vehicle chain */

   229

					if (veh->type == VEH_Train)

   230

						veh = GetFirstVehicleInChain(veh);

   231

				}

   232

   233

				if (dsg->variable == 0x40 || dsg->variable == 0x41) {

   234

					if (veh->type == VEH_Train) {

   235

						const Vehicle *u = GetFirstVehicleInChain(veh);

   236

						byte chain_before = 0, chain_after = 0;

   237

   238

						while (u != veh) {

   239

							chain_before++;

   240

							if (dsg->variable == 0x41 && u->engine_type != veh->engine_type)

   241

								chain_before = 0;

   242

							u = u->next;

   243

						}

   244

						while (u->next != NULL && (dsg->variable == 0x40 || u->next->engine_type == veh->engine_type)) {

   245

							chain_after++;

   246

							u = u->next;

   247

						};

   248

   249

						value = chain_before | chain_after << 8

   250

						        | (chain_before + chain_after) << 16;

   251

					} else {

   252

						value = 1; /* 1 vehicle in the chain */

   253

					}

   254

   255

				} else {

   256

					// TTDPatch runs on little-endian arch;

   257

					// Variable is 0x80 + offset in TTD's vehicle structure

   258

					switch (dsg->variable - 0x80) {

   259

#define veh_prop(id_, value_) case (id_): value = (value_); break

   260

						veh_prop(0x00, veh->type);

   261

						veh_prop(0x01, MapOldSubType(veh));

   262

						veh_prop(0x04, veh->index);

   263

						veh_prop(0x05, veh->index & 0xFF);

   264

						/* XXX? Is THIS right? */

   265

						veh_prop(0x0A, PackOrder(&veh->current_order));

   266

						veh_prop(0x0B, PackOrder(&veh->current_order) & 0xff);

   267

						veh_prop(0x0C, veh->num_orders);

   268

						veh_prop(0x0D, veh->cur_order_index);

   269

						veh_prop(0x10, veh->load_unload_time_rem);

   270

						veh_prop(0x11, veh->load_unload_time_rem & 0xFF);

   271

						veh_prop(0x12, veh->date_of_last_service);

   272

						veh_prop(0x13, veh->date_of_last_service & 0xFF);

   273

						veh_prop(0x14, veh->service_interval);

   274

						veh_prop(0x15, veh->service_interval & 0xFF);

   275

						veh_prop(0x16, veh->last_station_visited);

   276

						veh_prop(0x17, veh->tick_counter);

   277

						veh_prop(0x18, veh->max_speed);

   278

						veh_prop(0x19, veh->max_speed & 0xFF);

   279

						veh_prop(0x1A, veh->x_pos);

   280

						veh_prop(0x1B, veh->x_pos & 0xFF);

   281

						veh_prop(0x1C, veh->y_pos);

   282

						veh_prop(0x1D, veh->y_pos & 0xFF);

   283

						veh_prop(0x1E, veh->z_pos);

   284

						veh_prop(0x1F, veh->direction);

   285

						veh_prop(0x28, veh->cur_image);

   286

						veh_prop(0x29, veh->cur_image & 0xFF);

   287

						veh_prop(0x32, veh->vehstatus);

   288

						veh_prop(0x33, veh->vehstatus);

   289

						veh_prop(0x34, veh->cur_speed);

   290

						veh_prop(0x35, veh->cur_speed & 0xFF);

   291

						veh_prop(0x36, veh->subspeed);

   292

						veh_prop(0x37, veh->acceleration);

   293

						veh_prop(0x39, veh->cargo_type);

   294

						veh_prop(0x3A, veh->cargo_cap);

   295

						veh_prop(0x3B, veh->cargo_cap & 0xFF);

   296

						veh_prop(0x3C, veh->cargo_count);

   297

						veh_prop(0x3D, veh->cargo_count & 0xFF);

   298

						veh_prop(0x3E, veh->cargo_source); // Probably useless; so what

   299

						veh_prop(0x3F, veh->cargo_days);

   300

						veh_prop(0x40, veh->age);

   301

						veh_prop(0x41, veh->age & 0xFF);

   302

						veh_prop(0x42, veh->max_age);

   303

						veh_prop(0x43, veh->max_age & 0xFF);

   304

						veh_prop(0x44, veh->build_year);

   305

						veh_prop(0x45, veh->unitnumber);

   306

						veh_prop(0x46, veh->engine_type);

   307

						veh_prop(0x47, veh->engine_type & 0xFF);

   308

						veh_prop(0x48, veh->spritenum);

   309

						veh_prop(0x49, veh->day_counter);

   310

						veh_prop(0x4A, veh->breakdowns_since_last_service);

   311

						veh_prop(0x4B, veh->breakdown_ctr);

   312

						veh_prop(0x4C, veh->breakdown_delay);

   313

						veh_prop(0x4D, veh->breakdown_chance);

   314

						veh_prop(0x4E, veh->reliability);

   315

						veh_prop(0x4F, veh->reliability & 0xFF);

   316

						veh_prop(0x50, veh->reliability_spd_dec);

   317

						veh_prop(0x51, veh->reliability_spd_dec & 0xFF);

   318

						veh_prop(0x52, veh->profit_this_year);

   319

						veh_prop(0x53, veh->profit_this_year & 0xFFFFFF);

   320

						veh_prop(0x54, veh->profit_this_year & 0xFFFF);

   321

						veh_prop(0x55, veh->profit_this_year & 0xFF);

   322

						veh_prop(0x56, veh->profit_last_year);

   323

						veh_prop(0x57, veh->profit_last_year & 0xFF);

   324

						veh_prop(0x58, veh->profit_last_year);

   325

						veh_prop(0x59, veh->profit_last_year & 0xFF);

   326

						veh_prop(0x5A, veh->next == NULL ? INVALID_VEHICLE : veh->next->index);

   327

						veh_prop(0x5C, veh->value);

   328

						veh_prop(0x5D, veh->value & 0xFFFFFF);

   329

						veh_prop(0x5E, veh->value & 0xFFFF);

   330

						veh_prop(0x5F, veh->value & 0xFF);

   331

						veh_prop(0x60, veh->string_id);

   332

						veh_prop(0x61, veh->string_id & 0xFF);

   333

   334

						veh_prop(0x72, 0); // XXX Refit cycle currently unsupported

   335

						veh_prop(0x7A, veh->random_bits);

   336

						veh_prop(0x7B, veh->waiting_triggers);

   337

#undef veh_prop

   338

   339

						// Handle vehicle specific properties.

   340

						default: value = VehicleSpecificProperty(veh, dsg->variable - 0x80); break;

   341

					}

   342

				}

   343

			}

   344

   345

			target = value != -1 ? EvalDeterministicSpriteGroup(dsg, value) : dsg->default_group;

   346

			//debug("Resolved variable %x: %d, %p", dsg->variable, value, callback);

   347

			return resolve_func(target, veh, callback_info, resolve_func);

   348

		}

   349

   350

		case SGT_RANDOMIZED: {

   351

			const RandomizedSpriteGroup *rsg = &spritegroup->g.random;

   352

   353

			if (veh == NULL) {

   354

				/* Purchase list of something. Show the first one. */

   355

				assert(rsg->num_groups > 0);

   356

				//debug("going for %p: %d", rsg->groups[0], rsg->groups[0].type);

   357

				return resolve_func(rsg->groups[0], NULL, callback_info, resolve_func);

   358

			}

   359

   360

			if (rsg->var_scope == VSG_SCOPE_PARENT) {

   361

				/* First engine in the vehicle chain */

   362

				if (veh->type == VEH_Train)

   363

					veh = GetFirstVehicleInChain(veh);

   364

			}

   365

   366

			return resolve_func(EvalRandomizedSpriteGroup(rsg, veh->random_bits), veh, callback_info, resolve_func);

   367

		}

   368

   369

		default:

   370

			error("I don't know how to handle such a spritegroup %d!", spritegroup->type);

   371

			return NULL;

   372

	}

   373

}

   374

   375

static const SpriteGroup *GetVehicleSpriteGroup(EngineID engine, const Vehicle *v)

   376

{

   377

	const SpriteGroup *group;

   379

   380

	if (v != NULL) {

   381

		cargo = _global_cargo_id[_opt.landscape][v->cargo_type];

   382

		assert(cargo != GC_INVALID);

   383

	}

   384

   385

	group = engine_custom_sprites[engine][cargo];

   386

   387

	if (v != NULL && v->type == VEH_Train) {

   388

		const SpriteGroup *overset = GetWagonOverrideSpriteSet(engine, v->u.rail.first_engine);

   389

   390

		if (overset != NULL) group = overset;

   391

	}

   392

   393

	return group;

   394

}

   395

   396

int GetCustomEngineSprite(EngineID engine, const Vehicle* v, Direction direction)

   397

{

   398

	const SpriteGroup *group;

   399

	const RealSpriteGroup *rsg;

   400

	byte cargo = GC_PURCHASE;

   401

	byte loaded = 0;

   402

	bool in_motion = 0;

   403

	int totalsets, spriteset;

   404

	int r;

   405

   406

	if (v != NULL) {

   407

		int capacity = v->cargo_cap;

   408

   409

		cargo = _global_cargo_id[_opt.landscape][v->cargo_type];

   410

		assert(cargo != GC_INVALID);

   411

   412

		if (capacity == 0) capacity = 1;

   413

		loaded = (v->cargo_count * 100) / capacity;

   414

   415

		if (v->type == VEH_Train) {

   416

			in_motion = GetFirstVehicleInChain(v)->current_order.type != OT_LOADING;

   417

		} else {

   418

			in_motion = v->current_order.type != OT_LOADING;

   419

		}

   420

	}

   421

   422

	group = GetVehicleSpriteGroup(engine, v);

   423

	group = ResolveVehicleSpriteGroup(group, v, 0, (resolve_callback) ResolveVehicleSpriteGroup);

   424

   425

	if (group == NULL && cargo != GC_DEFAULT) {

   426

		// This group is empty but perhaps there'll be a default one.

   427

		group = ResolveVehicleSpriteGroup(engine_custom_sprites[engine][GC_DEFAULT], v, 0,

   428

		                                (resolve_callback) ResolveVehicleSpriteGroup);

   429

	}

   430

   431

	if (group == NULL)

   432

		return 0;

   433

   434

	assert(group->type == SGT_REAL);

   435

	rsg = &group->g.real;

   436

   437

	if (!rsg->sprites_per_set) {

   438

		// This group is empty. This function users should therefore

   439

		// look up the sprite number in _engine_original_sprites.

   440

		return 0;

   441

	}

   442

   443

	assert(rsg->sprites_per_set <= 8);

   444

	direction %= rsg->sprites_per_set;

   445

   446

	totalsets = in_motion ? rsg->loaded_count : rsg->loading_count;

   447

   448

	// My aim here is to make it possible to visually determine absolutely

   449

	// empty and totally full vehicles. --pasky

   450

	if (loaded == 100 || totalsets == 1) { // full

   451

		spriteset = totalsets - 1;

   452

	} else if (loaded == 0 || totalsets == 2) { // empty

   453

		spriteset = 0;

   454

	} else { // something inbetween

   455

		spriteset = loaded * (totalsets - 2) / 100 + 1;

   456

		// correct possible rounding errors

   457

		if (!spriteset)

   458

			spriteset = 1;

   459

		else if (spriteset == totalsets - 1)

   460

			spriteset--;

   461

	}

   462

   463

	r = (in_motion ? rsg->loaded[spriteset]->g.result.result : rsg->loading[spriteset]->g.result.result) + direction;

   464

	return r;

   465

}

   466

   467

/**

   468

 * Check if a wagon is currently using a wagon override

   469

 * @param v The wagon to check

   470

 * @return true if it is using an override, false otherwise

   471

 */

   472

bool UsesWagonOverride(const Vehicle* v)

   473

{

   474

	assert(v->type == VEH_Train);

   475

	return GetWagonOverrideSpriteSet(v->engine_type, v->u.rail.first_engine) != NULL;

   476

}

   477

   478

/**

   479

 * Evaluates a newgrf callback

   480

 * @param callback_info info about which callback to evaluate

   481

 *  (bit 0-7)  = CallBack id of the callback to use, see CallBackId enum

   482

 *  (bit 8-15) = Other info some callbacks need to have, callback specific, see CallBackId enum, not used yet

   483

 * @param engine Engine type of the vehicle to evaluate the callback for

   484

 * @param vehicle The vehicle to evaluate the callback for, NULL if it doesnt exist (yet)

   485

 * @return The value the callback returned, or CALLBACK_FAILED if it failed

   486

 */

   487

uint16 GetCallBackResult(uint16 callback_info, EngineID engine, const Vehicle *v)

   488

{

   489

	const SpriteGroup *group;

   490

	byte cargo = GC_DEFAULT;