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;

   269

	wo->trains = trains;

   270

	wo->train_id = malloc(trains);

   271

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

   272

}

   273

   274

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

   275

{

   276

	const WagonOverrides *wos = &_engine_wagon_overrides[engine];

   277

	int i;

   278

   279

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

   280

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

   281

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

   282

	// that. --pasky

   283

   284

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

   285

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

   286

		int j;

   287

   288

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

   289

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

   290

				return wo->group;

   291

		}

   292

	}

   293

	return NULL;

   294

}

   295

   296

   297

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

   298

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

   299

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

   300

// memory. --pasky)

   301

static SpriteGroup *engine_custom_sprites[TOTAL_NUM_ENGINES][NUM_GLOBAL_CID];

   302

   303

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

   304

{

   305

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

   306

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

   307

	 * --pasky */

   308

	engine_custom_sprites[engine][cargo] = group;

   309

}

   310

   311

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

   312

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

   313

   314

static const SpriteGroup* ResolveVehicleSpriteGroup(const SpriteGroup *spritegroup,

   315

	const Vehicle *veh, uint16 callback_info, resolve_callback resolve_func)

   316

{

   317

	if (spritegroup == NULL)

   318

		return NULL;

   319

   320

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

   321

	switch (spritegroup->type) {

   322

		case SGT_REAL:

   323

		case SGT_CALLBACK:

   324

			return spritegroup;

   325

   326

		case SGT_DETERMINISTIC: {

   327

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

   328

			const SpriteGroup *target;

   329

			int value = -1;

   330

   331

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

   332

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

   333

				/* Callback ID */

   334

				value = callback_info & 0xFF;

   335

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

   336

				/* General property */

   337

				value = GetDeterministicSpriteValue(dsg->variable);

   338

			} else {

   339

				/* Vehicle-specific property. */

   340

   341

				if (veh == NULL) {

   342

					/* We are in a purchase list of something,

   343

					 * and we are checking for something undefined.

   344

					 * That means we should get the first target

   345

					 * (NOT the default one). */

   346

					if (dsg->num_ranges > 0) {

   347

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

   348

					} else {

   349

						target = dsg->default_group;

   350

					}

   351

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

   352

				}

   353

   354

				if (dsg->var_scope == VSG_SCOPE_PARENT) {

   355

					/* First engine in the vehicle chain */

   356

					if (veh->type == VEH_Train)

   357

						veh = GetFirstVehicleInChain(veh);

   358

				}

   359

   360

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

   361

					if (veh->type == VEH_Train) {

   362

						const Vehicle *u = GetFirstVehicleInChain(veh);

   363

						byte chain_before = 0, chain_after = 0;

   364

   365

						while (u != veh) {

   366

							chain_before++;

   367

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

   368

								chain_before = 0;

   369

							u = u->next;

   370

						}

   371

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

   372

							chain_after++;

   373

							u = u->next;

   374

						};

   375

   376

						value = chain_before | chain_after << 8

   377

						        | (chain_before + chain_after) << 16;

   378

					} else {

   379

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

   380

					}

   381

   382

				} else {

   383

					// TTDPatch runs on little-endian arch;

   384

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

   385

					switch (dsg->variable - 0x80) {

   386

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

   387

						veh_prop(0x00, veh->type);

   388

						veh_prop(0x01, veh->subtype);

   389

						veh_prop(0x04, veh->index);

   390

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

   391

						/* XXX? Is THIS right? */

   392

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

   393

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

   394

						veh_prop(0x0C, veh->num_orders);

   395

						veh_prop(0x0D, veh->cur_order_index);

   396

						veh_prop(0x10, veh->load_unload_time_rem);

   397

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

   398

						veh_prop(0x12, veh->date_of_last_service);

   399

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

   400

						veh_prop(0x14, veh->service_interval);

   401

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

   402

						veh_prop(0x16, veh->last_station_visited);

   403

						veh_prop(0x17, veh->tick_counter);

   404

						veh_prop(0x18, veh->max_speed);

   405

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

   406

						veh_prop(0x1F, veh->direction);

   407

						veh_prop(0x28, veh->cur_image);

   408

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

   409

						veh_prop(0x32, veh->vehstatus);

   410

						veh_prop(0x33, veh->vehstatus);

   411

						veh_prop(0x34, veh->cur_speed);

   412

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

   413

						veh_prop(0x36, veh->subspeed);

   414

						veh_prop(0x37, veh->acceleration);

   415

						veh_prop(0x39, veh->cargo_type);

   416

						veh_prop(0x3A, veh->cargo_cap);

   417

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

   418

						veh_prop(0x3C, veh->cargo_count);

   419

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

   420

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

   421

						veh_prop(0x3F, veh->cargo_days);

   422

						veh_prop(0x40, veh->age);

   423

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

   424

						veh_prop(0x42, veh->max_age);

   425

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

   426

						veh_prop(0x44, veh->build_year);

   427

						veh_prop(0x45, veh->unitnumber);

   428

						veh_prop(0x46, veh->engine_type);

   429

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

   430

						veh_prop(0x48, veh->spritenum);

   431

						veh_prop(0x49, veh->day_counter);

   432

						veh_prop(0x4A, veh->breakdowns_since_last_service);

   433

						veh_prop(0x4B, veh->breakdown_ctr);

   434

						veh_prop(0x4C, veh->breakdown_delay);

   435

						veh_prop(0x4D, veh->breakdown_chance);

   436

						veh_prop(0x4E, veh->reliability);

   437

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

   438

						veh_prop(0x50, veh->reliability_spd_dec);

   439

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

   440

						veh_prop(0x52, veh->profit_this_year);

   441

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

   442

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

   443

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

   444

						veh_prop(0x56, veh->profit_last_year);

   445

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

   446

						veh_prop(0x58, veh->profit_last_year);

   447

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

   448

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

   449

						veh_prop(0x5C, veh->value);

   450

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

   451

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

   452

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

   453

						veh_prop(0x60, veh->string_id);

   454

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

   455

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

   456

						 * aircraft: >=13h when in flight

   457

						 * train, ship: 80h=in depot

   458

						 * rv: 0feh=in depot */

   459

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

   460

   461

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

   462

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

   463

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

   464

   465

#undef veh_prop

   466

					}

   467

				}

   468

			}

   469

   470

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

   471

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

   472

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

   473

		}

   474

   475

		case SGT_RANDOMIZED: {

   476

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

   477

   478

			if (veh == NULL) {

   479

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

   480

				assert(rsg->num_groups > 0);

   481

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

   482

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

   483

			}

   484

   485

			if (rsg->var_scope == VSG_SCOPE_PARENT) {

   486

				/* First engine in the vehicle chain */

   487

				if (veh->type == VEH_Train)

   488

					veh = GetFirstVehicleInChain(veh);

   489

			}

   490

   491

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

   492

		}

   493

   494

		default:

   495

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

   496

			return NULL;

   497

	}