1

/* $Id$ */

     2

     3

#include "stdafx.h"

     4

#include "openttd.h"

     5

#include "variables.h"

     6

#include "debug.h"

     7

#include "functions.h"

     8

#include "engine.h"

     9

#include "train.h"

    10

#include "player.h"

    11

#include "newgrf_callbacks.h"

    12

#include "newgrf_engine.h"

    13

#include "newgrf_station.h"

    14

#include "newgrf_spritegroup.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

	wo->trains = trains;

    48

	wo->train_id = malloc(trains);

    49

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

    50

}

    51

    52

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

    53

{

    54

	const WagonOverrides *wos = &_engine_wagon_overrides[engine];

    55

	int i;

    56

    57

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

    58

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

    59

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

    60

	// that. --pasky

    61

    62

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

    63

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

    64

		int j;

    65

    66

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

    67

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

    68

				return wo->group;

    69

		}

    70

	}

    71

	return NULL;

    72

}

    73

    74

/**

    75

 * Unload all wagon override sprite groups.

    76

 */

    77

void UnloadWagonOverrides(void)

    78

{

    79

	WagonOverrides *wos;

    80

	WagonOverride *wo;

    81

	EngineID engine;

    82

	int i;

    83

    84

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

    85

		wos = &_engine_wagon_overrides[engine];

    86

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

    87

			wo = &wos->overrides[i];

    88

			wo->group = NULL;

    89

			free(wo->train_id);

    90

		}

    91

		free(wos->overrides);

    92

		wos->overrides_count = 0;

    93

		wos->overrides = NULL;

    94

	}

    95

}

    96

    97

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

    98

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

    99

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

   100

// memory. --pasky)

   101

static SpriteGroup *engine_custom_sprites[TOTAL_NUM_ENGINES][NUM_GLOBAL_CID];

   102

static uint32 _engine_grf[TOTAL_NUM_ENGINES];

   103

   104

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

   105

{

   106

	assert(engine < TOTAL_NUM_ENGINES);

   107

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

   108

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

   109

	}

   110

	engine_custom_sprites[engine][cargo] = group;

   111

}

   112

   113

/**

   114

 * Unload all engine sprite groups.

   115

 */

   116

void UnloadCustomEngineSprites(void)

   117

{

   118

	EngineID engine;

   119

	CargoID cargo;

   120

   121

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

   122

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

   123

			engine_custom_sprites[engine][cargo] = NULL;

   124

		}

   125

		_engine_grf[engine] = 0;

   126

	}

   127

}

   128

   129

void SetEngineGRF(EngineID engine, uint32 grfid)

   130

{

   131

	assert(engine < TOTAL_NUM_ENGINES);

   132

	_engine_grf[engine] = grfid;

   133

}

   134

   135

uint32 GetEngineGRFID(EngineID engine)

   136

{

   137

	assert(engine < TOTAL_NUM_ENGINES);

   138

	return _engine_grf[engine];

   139

}

   140

   141

   142

static int MapOldSubType(const Vehicle *v)

   143

{

   144

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

   145

	if (IsTrainEngine(v)) return 0;

   146

	if (IsFreeWagon(v)) return 4;

   147

	return 2;

   148

}

   149

   150

   151

/* Vehicle Resolver Functions */

   152

static inline const Vehicle *GRV(const ResolverObject *object)

   153

{

   154

	return object->scope == VSG_SCOPE_SELF ? object->vehicle.self : object->vehicle.parent;

   155

}

   156

   157

   158

static uint32 VehicleGetRandomBits(const ResolverObject *object)

   159

{

   160

	return GRV(object) == NULL ? 0 : GRV(object)->random_bits;

   161

}

   162

   163

   164

static uint32 VehicleGetTriggers(const ResolverObject *object)

   165

{

   166

	return GRV(object) == NULL ? 0 : GRV(object)->waiting_triggers;

   167

}

   168

   169

   170

static void VehicleSetTriggers(const ResolverObject *object, int triggers)

   171

{

   172

	/* Evil cast to get around const-ness. This used to be achieved by an

   173

	 * innocent looking function pointer cast... Currently I cannot see a

   174

	 * way of avoiding this without removing consts deep within gui code.

   175

	 */

   176

	Vehicle *v = (Vehicle*)GRV(object);

   177

   178

	/* This function must only be called when processing triggers -- any

   179

	 * other time is an error. */

   180

	assert(object->trigger != 0);

   181

   182

	if (v != NULL) v->waiting_triggers = triggers;

   183

}

   184

   185

   186

static uint32 VehicleGetVariable(const ResolverObject *object, byte variable, byte parameter)

   187

{

   188

	const Vehicle *v = GRV(object);

   189

   190

	if (v == NULL) {

   191

		/* Vehicle does not exist, so we're in a purchase list */

   192

		switch (variable) {

   193

			case 0x43: return _current_player; /* Owner information */

   194

			case 0x46: return 0;               /* Motion counter */

   195

			case 0xC4: return _cur_year;       /* Build year */

   196

			case 0xDA: return INVALID_VEHICLE; /* Next vehicle */

   197

			default:   return -1;

   198

		}

   199

	}

   200

   201

	/* Calculated vehicle parameters */

   202

	switch (variable) {

   203

		case 0x40: /* Get length of consist */

   204

		case 0x41: /* Get length of same consecutive wagons */

   205

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

   206

   207

			{

   208

				const Vehicle* u;

   209

				byte chain_before = 0;

   210

				byte chain_after  = 0;

   211

   212

				for (u = GetFirstVehicleInChain(v); u != v; u = u->next) {

   213

					chain_before++;

   214

					if (variable == 0x41 && u->engine_type != v->engine_type) chain_before = 0;

   215

				}

   216

   217

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

   218

					chain_after++;

   219

					u = u->next;

   220

				}

   221

   222

				return chain_before | chain_after << 8 | (chain_before + chain_after) << 16;

   223

			}

   224

   225

		case 0x43: /* Player information */

   226

			return v->owner;

   227

   228

		case 0x46: /* Motion counter */

   229

			return 0;

   230

	}

   231

   232

	/* General vehicle properties */

   233

	switch (variable - 0x80) {

   234

		case 0x00: return v->type;

   235

		case 0x01: return MapOldSubType(v);

   236

		case 0x04: return v->index;

   237

		case 0x05: return v->index & 0xFF;

   238

		case 0x0A: return PackOrder(&v->current_order);

   239

		case 0x0B: return PackOrder(&v->current_order) & 0xFF;

   240

		case 0x0C: return v->num_orders;

   241

		case 0x0D: return v->cur_order_index;

   242

		case 0x10: return v->load_unload_time_rem;

   243

		case 0x11: return v->load_unload_time_rem & 0xFF;

   244

		case 0x12: return v->date_of_last_service;

   245

		case 0x13: return v->date_of_last_service & 0xFF;

   246

		case 0x14: return v->service_interval;

   247

		case 0x15: return v->service_interval & 0xFF;

   248

		case 0x16: return v->last_station_visited;

   249

		case 0x17: return v->tick_counter;

   250

		case 0x18: return v->max_speed;

   251

		case 0x19: return v->max_speed & 0xFF;

   252

		case 0x1A: return v->x_pos;

   253

		case 0x1B: return v->x_pos & 0xFF;

   254

		case 0x1C: return v->y_pos;

   255

		case 0x1D: return v->y_pos & 0xFF;

   256

		case 0x1E: return v->z_pos;

   257

		case 0x1F: return v->direction;

   258

		case 0x28: return v->cur_image;

   259

		case 0x29: return v->cur_image & 0xFF;

   260

		case 0x32: return v->vehstatus;

   261

		case 0x33: return v->vehstatus;

   262

		case 0x34: return v->cur_speed;

   263

		case 0x35: return v->cur_speed & 0xFF;

   264

		case 0x36: return v->subspeed;

   265

		case 0x37: return v->acceleration;

   266

		case 0x39: return v->cargo_type;

   267

		case 0x3A: return v->cargo_cap;

   268

		case 0x3B: return v->cargo_cap & 0xFF;

   269

		case 0x3C: return v->cargo_count;

   270

		case 0x3D: return v->cargo_count & 0xFF;

   271

		case 0x3E: return v->cargo_source;

   272

		case 0x3F: return v->cargo_days;

   273

		case 0x40: return v->age;

   274

		case 0x41: return v->age & 0xFF;

   275

		case 0x42: return v->max_age;

   276

		case 0x43: return v->max_age & 0xFF;

   277

		case 0x44: return v->build_year;

   278

		case 0x45: return v->unitnumber;

   279

		case 0x46: return v->engine_type;

   280

		case 0x47: return v->engine_type & 0xFF;

   281

		case 0x48: return v->spritenum;

   282

		case 0x49: return v->day_counter;

   283

		case 0x4A: return v->breakdowns_since_last_service;

   284

		case 0x4B: return v->breakdown_ctr;

   285

		case 0x4C: return v->breakdown_delay;

   286

		case 0x4D: return v->breakdown_chance;

   287

		case 0x4E: return v->reliability;

   288

		case 0x4F: return v->reliability & 0xFF;

   289

		case 0x50: return v->reliability_spd_dec;

   290

		case 0x51: return v->reliability_spd_dec & 0xFF;

   291

		case 0x52: return v->profit_this_year;

   292

		case 0x53: return v->profit_this_year & 0xFFFFFF;

   293

		case 0x54: return v->profit_this_year & 0xFFFF;

   294

		case 0x55: return v->profit_this_year & 0xFF;

   295

		case 0x56: return v->profit_last_year;

   296

		case 0x57: return v->profit_last_year & 0xFF;

   297

		case 0x58: return v->profit_last_year;

   298

		case 0x59: return v->profit_last_year & 0xFF;

   299

		case 0x5A: return v->next == NULL ? INVALID_VEHICLE : v->next->index;

   300

		case 0x5C: return v->value;

   301

		case 0x5D: return v->value & 0xFFFFFF;

   302

		case 0x5E: return v->value & 0xFFFF;

   303

		case 0x5F: return v->value & 0xFF;

   304

		case 0x60: return v->string_id;

   305

		case 0x61: return v->string_id & 0xFF;

   306

		case 0x72: return 0; // XXX Refit cycle

   307

		case 0x7A: return v->random_bits;

   308

		case 0x7B: return v->waiting_triggers;

   309

	}

   310

   311

	/* Vehicle specific properties */

   312

	switch (v->type) {

   313

		case VEH_Train:

   314

			switch (variable - 0x80) {

   315

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

   316

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

   317

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

   318

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

   319

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

   320

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

   321

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

   322

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

   323

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

   324

			}

   325

			break;

   326

   327

		case VEH_Road:

   328

			switch (variable - 0x80) {

   329

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

   330

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

   331

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

   332

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

   333

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

   334

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

   335

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

   336

			}

   337

			break;

   338

   339

		case VEH_Aircraft:

   340

			switch (variable - 0x80) {

   341

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

   342

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

   343

				// case 0x66: XXX

   344

			}

   345

			break;

   346

	}

   347

   348

	DEBUG(grf, 1)("Unhandled vehicle property 0x%X, type 0x%X", variable, v->type);

   349

   350

	return -1;

   351

}

   352

   353

   354

static uint32 VehicleResolveReal(const ResolverObject *object, uint num_loaded, uint num_loading, bool *in_motion)

   355

{

   356

	const Vehicle *v = object->vehicle.self;

   357

	uint totalsets;

   358

	uint set;

   359

   360

	if (v == NULL) {

   361

		*in_motion = false;

   362

		return 0;

   363

	}

   364

   365

	if (v->type == VEH_Train) {

   366

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

   367

	} else {

   368

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

   369

	}

   370

   371

	totalsets = in_motion ? num_loaded : num_loading;

   372

   373

	if (v->cargo_count == v->cargo_cap || totalsets == 1) {

   374

		set = totalsets - 1;

   375

	} else if (v->cargo_count == 0 || totalsets == 2) {

   376

		set = 0;

   377

	} else {

   378

		set = v->cargo_count * (totalsets - 2) / max(1, v->cargo_cap) + 1;

   379

	}

   380

   381

	return set;

   382

}

   383

   384

   385

static inline void NewVehicleResolver(ResolverObject *res, const Vehicle *v)

   386

{

   387

	res->GetRandomBits = &VehicleGetRandomBits;

   388

	res->GetTriggers   = &VehicleGetTriggers;

   389

	res->SetTriggers   = &VehicleSetTriggers;

   390

	res->GetVariable   = &VehicleGetVariable;

   391

	res->ResolveReal   = &VehicleResolveReal;

   392

   393

	res->vehicle.self   = v;

   394

	res->vehicle.parent = (v != NULL && v->type == VEH_Train) ? GetFirstVehicleInChain(v) : NULL;

   395

   396

	res->callback        = 0;

   397

	res->callback_param1 = 0;

   398

	res->callback_param2 = 0;

   399

	res->last_value      = 0;

   400

	res->trigger         = 0;

   401

	res->reseed          = 0;

   402

}

   403

   404

   405

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

   406

{

   407

	const SpriteGroup *group;

   408

	ResolverObject object;

   409

	CargoID cargo = GC_PURCHASE;

   410

   411

	NewVehicleResolver(&object, v);

   412

   413

	if (v != NULL) {

   414

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

   415

		assert(cargo != GC_INVALID);

   416

	}

   417

   418

	group = engine_custom_sprites[engine][cargo];

   419

   420

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

   421

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

   422

   423

		if (overset != NULL) group = overset;

   424

	}

   425

   426

	group = Resolve(group, &object);

   427

   428

	if ((group == NULL || group->type != SGT_RESULT) && cargo != GC_DEFAULT) {

   429

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

   430

		group = Resolve(engine_custom_sprites[engine][GC_DEFAULT], &object);

   431

	}

   432

   433

	if (group == NULL || group->type != SGT_RESULT) return 0;

   434

   435

	return group->g.result.sprite + (direction % group->g.result.num_sprites);

   436

}

   437

   438

   439

/**

   440

 * Check if a wagon is currently using a wagon override

   441

 * @param v The wagon to check

   442

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

   443

 */

   444

bool UsesWagonOverride(const Vehicle* v)

   445

{

   446

	assert(v->type == VEH_Train);

   447

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

   448

}

   449

   450

/**

   451

 * Evaluate a newgrf callback for vehicles

   452

 * @param callback The callback to evalute

   453

 * @param param1   First parameter of the callback

   454

 * @param param2   Second parameter of the callback

   455

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

   456

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

   457

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

   458

 */

   459

uint16 GetVehicleCallback(byte callback, uint32 param1, uint32 param2, EngineID engine, const Vehicle *v)

   460

{

   461

	const SpriteGroup *group;

   462

	ResolverObject object;

   463

	CargoID cargo;

   464

   465

	NewVehicleResolver(&object, v);

   466

   467

	object.callback        = callback;

   468

	object.callback_param1 = param1;

   469

	object.callback_param2 = param2;

   470

   471

	cargo = (v == NULL) ? GC_PURCHASE : _global_cargo_id[_opt.landscape][v->cargo_type];

   472

   473

	group = engine_custom_sprites[engine][cargo];

   474

   475

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

   476

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

   477

   478

		if (overset != NULL) group = overset;

   479

	}

   480

   481

	group = Resolve(group, &object);

   482

   483

	if ((group == NULL || group->type != SGT_CALLBACK) && cargo != GC_DEFAULT) {

   484

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

   485

		group = Resolve(engine_custom_sprites[engine][GC_DEFAULT], &object);

   486

	}

   487

   488

	if (group == NULL || group->type != SGT_CALLBACK)

   489

		return CALLBACK_FAILED;

   490

   491