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 "table/strings.h"

    10

#include "engine.h"

    11

#include "table/engines.h"

    12

#include "gfx.h"

    13

#include "player.h"

    14

#include "command.h"

    15

#include "vehicle.h"

    16

#include "news.h"

    17

#include "saveload.h"

    18

#include "sprite.h"

    19

#include "variables.h"

    20

    21

enum {

    22

	ENGINE_AVAILABLE = 1,

    23

	ENGINE_INTRODUCING = 2,

    24

	ENGINE_PREVIEWING = 4,

    25

};

    26

    27

/** TRANSLATE FROM LOCAL CARGO TO GLOBAL CARGO ID'S.

    28

 * This maps the per-landscape cargo ID's to globally unique cargo ID's usable ie. in

    29

 * the custom GRF  files. It is basically just a transcribed table from TTDPatch's newgrf.txt.

    30

 */

    31

const CargoID _global_cargo_id[NUM_LANDSCAPE][NUM_CARGO] = {

    32

	/* LT_NORMAL */ {GC_PASSENGERS, GC_COAL,  GC_MAIL, GC_OIL, GC_LIVESTOCK, GC_GOODS, GC_GRAIN, GC_WOOD, GC_IRON_ORE,    GC_STEEL,  GC_VALUABLES, GC_PAPER_TEMP},

    33

	/* LT_HILLY */  {GC_PASSENGERS, GC_COAL,  GC_MAIL, GC_OIL, GC_LIVESTOCK, GC_GOODS, GC_GRAIN, GC_WOOD, GC_INVALID,     GC_PAPER,  GC_VALUABLES, GC_FOOD },

    34

	/* LT_DESERT */ {GC_PASSENGERS, GC_RUBBER,GC_MAIL, GC_OIL, GC_FRUIT,     GC_GOODS, GC_GRAIN, GC_WOOD, GC_COPPER_ORE,  GC_WATER,  GC_VALUABLES, GC_FOOD },

    35

	/* LT_CANDY */  {GC_PASSENGERS, GC_SUGAR, GC_MAIL, GC_TOYS,GC_BATTERIES, GC_CANDY, GC_TOFFEE,GC_COLA, GC_COTTON_CANDY,GC_BUBBLES,GC_PLASTIC,   GC_FIZZY_DRINKS },

    36

	/**

    37

	 * - GC_INVALID (255) means that  cargo is not available for that climate

    38

	 * - GC_PAPER_TEMP (27) is paper in  temperate climate in TTDPatch

    39

	 * Following can  be renumbered:

    40

	 * - GC_DEFAULT (29) is the defa ult cargo for the purpose of spritesets

    41

	 * - GC_PURCHASE (30) is the purchase list image (the equivalent of 0xff) for the purpose of spritesets

    42

	 */

    43

};

    44

    45

/** BEGIN --- TRANSLATE FROM GLOBAL CARGO TO LOCAL CARGO ID'S **/

    46

/** Map global cargo ID's to local-cargo ID's */

    47

const CargoID _local_cargo_id_ctype[NUM_GLOBAL_CID] = {

    48

	CT_PASSENGERS,CT_COAL,   CT_MAIL,        CT_OIL,      CT_LIVESTOCK,CT_GOODS,  CT_GRAIN,      CT_WOOD,         /*  0- 7 */

    49

	CT_IRON_ORE,  CT_STEEL,  CT_VALUABLES,   CT_PAPER,    CT_FOOD,     CT_FRUIT,  CT_COPPER_ORE, CT_WATER,        /*  8-15 */

    50

	CT_RUBBER,    CT_SUGAR,  CT_TOYS,        CT_BATTERIES,CT_CANDY,    CT_TOFFEE, CT_COLA,       CT_COTTON_CANDY, /* 16-23 */

    51

	CT_BUBBLES,   CT_PLASTIC,CT_FIZZY_DRINKS,CT_PAPER     /* unsup. */,CT_HILLY_UNUSED,                           /* 24-28 */

    52

	CT_INVALID,   CT_INVALID                                                                                      /* 29-30 */

    53

};

    54

    55

#define MC(cargo) (1 << cargo)

    56

/** Bitmasked value where the global cargo ID is available in landscape

    57

 * 0: LT_NORMAL, 1: LT_HILLY, 2: LT_DESERT, 3: LT_CANDY */

    58

const uint32 _landscape_global_cargo_mask[NUM_LANDSCAPE] =

    59

{ /* LT_NORMAL: temperate */

    60

	MC(GC_PASSENGERS)|MC(GC_COAL)|MC(GC_MAIL)|MC(GC_OIL)|MC(GC_LIVESTOCK)|MC(GC_GOODS)|MC(GC_GRAIN)|MC(GC_WOOD)|

    61

	MC(GC_IRON_ORE)|MC(GC_STEEL)|MC(GC_VALUABLES)|MC(GC_FOOD)|MC(GC_UNDEFINED),

    62

	/* LT_HILLY: arctic */

    63

	MC(GC_PASSENGERS)|MC(GC_COAL)|MC(GC_MAIL)|MC(GC_OIL)|MC(GC_LIVESTOCK)|MC(GC_GOODS)|

    64

	MC(GC_GRAIN)|MC(GC_WOOD)|MC(GC_VALUABLES)|MC(GC_PAPER)|MC(GC_FOOD)|MC(GC_UNDEFINED),

    65

	/* LT_DESERT: rainforest/desert */

    66

	MC(GC_PASSENGERS)|MC(GC_MAIL)|MC(GC_OIL)|MC(GC_GOODS)|MC(GC_GRAIN)|MC(GC_WOOD)|

    67

	MC(GC_VALUABLES)|MC(GC_FOOD)|MC(GC_FRUIT)|MC(GC_COPPER_ORE)|MC(GC_WATER)|MC(GC_RUBBER),

    68

	/* LT_CANDY: toyland */

    69

	MC(GC_PASSENGERS)|MC(GC_MAIL)|MC(GC_SUGAR)|MC(GC_TOYS)|MC(GC_BATTERIES)|MC(GC_CANDY)|

    70

	MC(GC_TOFFEE)|MC(GC_COLA)|MC(GC_COTTON_CANDY)|MC(GC_BUBBLES)|MC(GC_PLASTIC)|MC(GC_FIZZY_DRINKS)

    71

};

    72

/** END   --- TRANSLATE FROM GLOBAL CARGO TO LOCAL CARGO ID'S **/

    73

    74

/** Bitmasked values of what type of cargo is refittable for the given vehicle-type.

    75

 * This coupled with the landscape information (_landscape_global_cargo_mask) gives

    76

 * us exactly what is refittable and what is not */

    77

const uint32 _default_refitmasks[NUM_VEHICLE_TYPES] = {

    78

	/* Trains */

    79

	MC(GC_PASSENGERS)|MC(GC_COAL)|MC(GC_MAIL)|MC(GC_LIVESTOCK)|MC(GC_GOODS)|MC(GC_GRAIN)|MC(GC_WOOD)|MC(GC_IRON_ORE)|

    80

	MC(GC_STEEL)|MC(GC_VALUABLES)|MC(GC_PAPER)|MC(GC_FOOD)|MC(GC_FRUIT)|MC(GC_COPPER_ORE)|MC(GC_WATER)|MC(GC_SUGAR)|

    81

	MC(GC_TOYS)|MC(GC_CANDY)|MC(GC_TOFFEE)|MC(GC_COLA)|MC(GC_COTTON_CANDY)|MC(GC_BUBBLES)|MC(GC_PLASTIC)|MC(GC_FIZZY_DRINKS),

    82

	/* Road vehicles (not refittable by default) */

    83

	0,

    84

	/* Ships */

    85

	MC(GC_COAL)|MC(GC_MAIL)|MC(GC_LIVESTOCK)|MC(GC_GOODS)|MC(GC_GRAIN)|MC(GC_WOOD)|MC(GC_IRON_ORE)|MC(GC_STEEL)|MC(GC_VALUABLES)|

    86

	MC(GC_PAPER)|MC(GC_FOOD)|MC(GC_FRUIT)|MC(GC_COPPER_ORE)|MC(GC_WATER)|MC(GC_RUBBER)|MC(GC_SUGAR)|MC(GC_TOYS)|MC(GC_BATTERIES)|

    87

	MC(GC_CANDY)|MC(GC_TOFFEE)|MC(GC_COLA)|MC(GC_COTTON_CANDY)|MC(GC_BUBBLES)|MC(GC_PLASTIC)|MC(GC_FIZZY_DRINKS),

    88

	/* Aircraft */

    89

	MC(GC_PASSENGERS)|MC(GC_MAIL)|MC(GC_GOODS)|MC(GC_VALUABLES)|MC(GC_FOOD)|MC(GC_FRUIT)|MC(GC_SUGAR)|MC(GC_TOYS)|

    90

	MC(GC_BATTERIES)|MC(GC_CANDY)|MC(GC_TOFFEE)|MC(GC_COLA)|MC(GC_COTTON_CANDY)|MC(GC_BUBBLES)|MC(GC_PLASTIC)|MC(GC_FIZZY_DRINKS),

    91

	/* Special/Disaster */

    92

	0,0

    93

};

    94

#undef MC

    95

    96

void ShowEnginePreviewWindow(EngineID engine);

    97

    98

void DeleteCustomEngineNames(void)

    99

{

   100

	uint i;

   101

	StringID old;

   102

   103

	for (i = 0; i != TOTAL_NUM_ENGINES; i++) {

   104

		old = _engine_name_strings[i];

   105

		_engine_name_strings[i] = i + STR_8000_KIRBY_PAUL_TANK_STEAM;

   106

		DeleteName(old);

   107

	}

   108

   109

	_vehicle_design_names &= ~1;

   110

}

   111

   112

void LoadCustomEngineNames(void)

   113

{

   114

	// XXX: not done */

   115

	DEBUG(misc, 1) ("LoadCustomEngineNames: not done");

   116

}

   117

   118

static void SetupEngineNames(void)

   119

{

   120

	StringID *name;

   121

   122

	for (name = _engine_name_strings; name != endof(_engine_name_strings); name++)

   123

		*name = STR_SV_EMPTY;

   124

   125

	DeleteCustomEngineNames();

   126

	LoadCustomEngineNames();

   127

}

   128

   129

static void AdjustAvailAircraft(void)

   130

{

   131

	uint16 date = _date;

   132

	byte avail = 0;

   133

	if (date >= 12784) avail |= 2; // big airport

   134

	if (date < 14610 || _patches.always_small_airport) avail |= 1;  // small airport

   135

	if (date >= 15706) avail |= 4; // enable heliport

   136

   137

	if (avail != _avail_aircraft) {

   138

		_avail_aircraft = avail;

   139

		InvalidateWindow(WC_BUILD_STATION, 0);

   140

	}

   141

}

   142

   143

static void CalcEngineReliability(Engine *e)

   144

{

   145

	uint age = e->age;

   146

   147

	if (age < e->duration_phase_1) {

   148

		uint start = e->reliability_start;

   149

		e->reliability = age * (e->reliability_max - start) / e->duration_phase_1 + start;

   150

	} else if ((age -= e->duration_phase_1) < e->duration_phase_2) {

   151

		e->reliability = e->reliability_max;

   152

	} else if ((age -= e->duration_phase_2) < e->duration_phase_3) {

   153

		uint max = e->reliability_max;

   154

		e->reliability = (int)age * (int)(e->reliability_final - max) / e->duration_phase_3 + max;

   155

	} else {

   156

		// time's up for this engine

   157

		// make it either available to all players (if never_expire_vehicles is enabled and if it was available earlier)

   158

		// or disable this engine completely

   159

		e->player_avail = (_patches.never_expire_vehicles && e->player_avail)? -1 : 0;

   160

		e->reliability = e->reliability_final;

   161

	}

   162

}

   163

   164

void AddTypeToEngines(void)

   165

{

   166

	Engine* e = _engines;

   167

   168

	do e->type = VEH_Train;    while (++e < &_engines[ROAD_ENGINES_INDEX]);

   169

	do e->type = VEH_Road;     while (++e < &_engines[SHIP_ENGINES_INDEX]);

   170

	do e->type = VEH_Ship;     while (++e < &_engines[AIRCRAFT_ENGINES_INDEX]);

   171

	do e->type = VEH_Aircraft; while (++e < &_engines[TOTAL_NUM_ENGINES]);

   172

	do e->type = VEH_Special;  while (++e < endof(_engines));

   173

}

   174

   175

void StartupEngines(void)

   176

{

   177

	Engine *e;

   178

	const EngineInfo *ei;

   179

   180

	SetupEngineNames();

   181

   182

	for (e = _engines, ei = _engine_info; e != endof(_engines); e++, ei++) {

   183

		uint32 r;

   184

   185

		e->age = 0;

   186

		e->railtype = ei->railtype_climates >> 4;

   187

		e->flags = 0;

   188

		e->player_avail = 0;

   189

   190

		r = Random();

   191

		e->intro_date = GB(r, 0, 9) + ei->base_intro;

   192

		if (e->intro_date <= _date) {

   193

			e->age = (_date - e->intro_date) >> 5;

   194

			e->player_avail = (byte)-1;

   195

			e->flags |= ENGINE_AVAILABLE;

   196

		}

   197

   198

		e->reliability_start = GB(r, 16, 14) + 0x7AE0;

   199

		r = Random();

   200

		e->reliability_max   = GB(r,  0, 14) + 0xBFFF;

   201

		e->reliability_final = GB(r, 16, 14) + 0x3FFF;

   202

   203

		r = Random();

   204

		e->duration_phase_1 = GB(r, 0, 5) + 7;

   205

		e->duration_phase_2 = GB(r, 5, 4) + ei->base_life * 12 - 96;

   206

		e->duration_phase_3 = GB(r, 9, 7) + 120;

   207

   208

		e->reliability_spd_dec = (ei->unk2&0x7F) << 2;

   209

   210

		/* my invented flag for something that is a wagon */

   211

		if (ei->unk2 & 0x80) {

   212

			e->age = 0xFFFF;

   213

		} else {

   214

			CalcEngineReliability(e);

   215

		}

   216

   217

		e->lifelength = ei->lifelength + _patches.extend_vehicle_life;

   218

   219

		// prevent certain engines from ever appearing.

   220

		if (!HASBIT(ei->railtype_climates, _opt.landscape)) {

   221

			e->flags |= ENGINE_AVAILABLE;

   222

			e->player_avail = 0;

   223

		}

   224

   225

		/* This sets up type for the engine

   226

		   It is needed if you want to ask the engine what type it is

   227

		   It should hopefully be the same as when you ask a vehicle what it is

   228

		   but using this, you can ask what type an engine number is

   229

		   even if it is not a vehicle (yet)*/

   230

	}

   231

   232

	AdjustAvailAircraft();

   233

}

   234

   235

uint32 _engine_refit_masks[TOTAL_NUM_ENGINES];

   236

   237

   238

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

   239

   240

typedef struct WagonOverride {

   241

	byte *train_id;

   242

	int trains;

   243

	SpriteGroup *group;

   244

} WagonOverride;

   245

   246

typedef struct WagonOverrides {

   247

	int overrides_count;

   248

	WagonOverride *overrides;

   249

} WagonOverrides;

   250

   251

static WagonOverrides _engine_wagon_overrides[TOTAL_NUM_ENGINES];

   252

   253

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

   254

	int trains)

   255

{

   256

	WagonOverrides *wos;

   257

	WagonOverride *wo;

   258

   259

	wos = &_engine_wagon_overrides[engine];

   260

	wos->overrides_count++;

   261

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

   262

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

   263

   264

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

   265

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

   266

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

   267

	 * --pasky */

   268

	wo->group = group;

   270

	wo->trains = trains;

   271

	wo->train_id = malloc(trains);

   272

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

   273

}

   274

   275

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

   276

{

   277

	const WagonOverrides *wos = &_engine_wagon_overrides[engine];

   278

	int i;

   279

   280

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

   281

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

   282

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

   283

	// that. --pasky

   284

   285

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

   286

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

   287

		int j;

   288

   289

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

   290

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

   291

				return wo->group;

   292

		}

   293

	}

   294

	return NULL;

   295

}

   296

   297

   298

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

   299

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

   300

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

   301

// memory. --pasky)

   302

static SpriteGroup *engine_custom_sprites[TOTAL_NUM_ENGINES][NUM_GLOBAL_CID];

   303

   304

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

   305

{

   306

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

   307

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

   308

	 * --pasky */

   309

	engine_custom_sprites[engine][cargo] = group;

   311

}

   312

   313

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

   314

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

   315

   316

static const SpriteGroup* ResolveVehicleSpriteGroup(const SpriteGroup *spritegroup,

   317

	const Vehicle *veh, uint16 callback_info, resolve_callback resolve_func)

   318

{

   319

	if (spritegroup == NULL)

   320

		return NULL;

   321

   322

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

   323

	switch (spritegroup->type) {

   324

		case SGT_REAL:

   325

		case SGT_CALLBACK:

   326

			return spritegroup;

   327

   328

		case SGT_DETERMINISTIC: {

   329

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

   330

			const SpriteGroup *target;

   331

			int value = -1;

   332

   333

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

   334

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

   335

				/* Callback ID */

   336

				value = callback_info & 0xFF;

   337

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

   338

				/* General property */

   339

				value = GetDeterministicSpriteValue(dsg->variable);

   340

			} else {

   341

				/* Vehicle-specific property. */

   342

   343

				if (veh == NULL) {

   344

					/* We are in a purchase list of something,

   345

					 * and we are checking for something undefined.

   346

					 * That means we should get the first target

   347

					 * (NOT the default one). */

   348

					if (dsg->num_ranges > 0) {

   349

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

   350

					} else {

   351

						target = dsg->default_group;

   352

					}

   353

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

   354

				}

   355

   356

				if (dsg->var_scope == VSG_SCOPE_PARENT) {

   357

					/* First engine in the vehicle chain */

   358

					if (veh->type == VEH_Train)

   359

						veh = GetFirstVehicleInChain(veh);

   360

				}

   361

   362

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

   363

					if (veh->type == VEH_Train) {

   364

						const Vehicle *u = GetFirstVehicleInChain(veh);

   365

						byte chain_before = 0, chain_after = 0;

   366

   367

						while (u != veh) {

   368

							chain_before++;

   369

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

   370

								chain_before = 0;

   371

							u = u->next;

   372

						}

   373

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

   374

							chain_after++;

   375

							u = u->next;

   376

						};

   377

   378

						value = chain_before | chain_after << 8

   379

						        | (chain_before + chain_after) << 16;

   380

					} else {

   381

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

   382

					}

   383

   384

				} else {

   385

					// TTDPatch runs on little-endian arch;

   386

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

   387

					switch (dsg->variable - 0x80) {

   388

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

   389

						veh_prop(0x00, veh->type);

   390

						veh_prop(0x01, veh->subtype);

   391

						veh_prop(0x04, veh->index);

   392

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

   393

						/* XXX? Is THIS right? */

   394

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

   395

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

   396

						veh_prop(0x0C, veh->num_orders);

   397

						veh_prop(0x0D, veh->cur_order_index);

   398

						veh_prop(0x10, veh->load_unload_time_rem);

   399

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

   400

						veh_prop(0x12, veh->date_of_last_service);

   401

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

   402

						veh_prop(0x14, veh->service_interval);

   403

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

   404

						veh_prop(0x16, veh->last_station_visited);

   405

						veh_prop(0x17, veh->tick_counter);

   406

						veh_prop(0x18, veh->max_speed);

   407

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

   408

						veh_prop(0x1F, veh->direction);

   409

						veh_prop(0x28, veh->cur_image);

   410

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

   411

						veh_prop(0x32, veh->vehstatus);

   412

						veh_prop(0x33, veh->vehstatus);

   413

						veh_prop(0x34, veh->cur_speed);

   414

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

   415

						veh_prop(0x36, veh->subspeed);

   416

						veh_prop(0x37, veh->acceleration);

   417

						veh_prop(0x39, veh->cargo_type);

   418

						veh_prop(0x3A, veh->cargo_cap);

   419

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

   420

						veh_prop(0x3C, veh->cargo_count);

   421

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

   422

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

   423

						veh_prop(0x3F, veh->cargo_days);

   424

						veh_prop(0x40, veh->age);

   425

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

   426

						veh_prop(0x42, veh->max_age);

   427

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

   428

						veh_prop(0x44, veh->build_year);

   429

						veh_prop(0x45, veh->unitnumber);

   430

						veh_prop(0x46, veh->engine_type);

   431

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

   432

						veh_prop(0x48, veh->spritenum);

   433

						veh_prop(0x49, veh->day_counter);

   434

						veh_prop(0x4A, veh->breakdowns_since_last_service);

   435

						veh_prop(0x4B, veh->breakdown_ctr);

   436

						veh_prop(0x4C, veh->breakdown_delay);

   437

						veh_prop(0x4D, veh->breakdown_chance);

   438

						veh_prop(0x4E, veh->reliability);

   439

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

   440

						veh_prop(0x50, veh->reliability_spd_dec);

   441

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

   442

						veh_prop(0x52, veh->profit_this_year);

   443

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

   444

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

   445

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

   446

						veh_prop(0x56, veh->profit_last_year);

   447

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

   448

						veh_prop(0x58, veh->profit_last_year);

   449

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

   450

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

   451

						veh_prop(0x5C, veh->value);

   452

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

   453

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

   454

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

   455

						veh_prop(0x60, veh->string_id);

   456

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

   457

						/* 00h..07h=sub image? 40h=in tunnel; actually some kind of status

   458

						 * aircraft: >=13h when in flight

   459

						 * train, ship: 80h=in depot

   460

						 * rv: 0feh=in depot */

   461

						/* TODO veh_prop(0x62, veh->???); */

   462

   463

						/* TODO: The rest is per-vehicle, I hope no GRF file looks so far.

   464

						 * But they won't let us have an easy ride so surely *some* GRF

   465

						 * file does. So someone needs to do this too. --pasky */

   466

   467

#undef veh_prop

   468

					}

   469

				}

   470

			}

   471

   472

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

   473

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

   474

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

   475

		}

   476

   477

		case SGT_RANDOMIZED: {

   478

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

   479

   480

			if (veh == NULL) {

   481

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

   482

				assert(rsg->num_groups > 0);

   483

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

   484

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

   485

			}

   486

   487

			if (rsg->var_scope == VSG_SCOPE_PARENT) {

   488

				/* First engine in the vehicle chain */

   489

				if (veh->type == VEH_Train)

   490

					veh = GetFirstVehicleInChain(veh);

   491

			}

   492

   493

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

   494

		}

   495

   496

		default:

   497

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