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(int 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;

   167

	uint32 counter = 0;

   168

   169

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

   170

   171

		e->type = VEH_Train;

   172

		if 	(counter >= ROAD_ENGINES_INDEX) {

   173

			e->type = VEH_Road;

   174

			if 	(counter >= SHIP_ENGINES_INDEX) {

   175

				e->type = VEH_Ship;

   176

				if 	(counter >= AIRCRAFT_ENGINES_INDEX) {

   177

					e->type = VEH_Aircraft;

   178

					if 	(counter >= TOTAL_NUM_ENGINES) {

   179

						e->type = VEH_Special;

   180

					}

   181

				}

   182

			}

   183

		}

   184

	}

   185

}

   186

   187

void StartupEngines(void)

   188

{

   189

	Engine *e;

   190

	const EngineInfo *ei;

   191

	uint32 r, counter = 0;

   192

   193

	SetupEngineNames();

   194

   195

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

   196

   197

		e->age = 0;

   198

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

   199

		e->flags = 0;

   200

		e->player_avail = 0;

   201

   202

		r = Random();

   203

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

   204

		if (e->intro_date <= _date) {

   205

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

   206

			e->player_avail = (byte)-1;

   207

			e->flags |= ENGINE_AVAILABLE;

   208

		}

   209

   210

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

   211

		r = Random();

   212

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

   213

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

   214

   215

		r = Random();

   216

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

   217

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

   218

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

   219

   220

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

   221

   222

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

   223

		if (ei->unk2 & 0x80) {

   224

			e->age = 0xFFFF;

   225

		} else {

   226

			CalcEngineReliability(e);

   227

		}

   228

   229

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

   230

   231

		// prevent certain engines from ever appearing.

   232

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

   233

			e->flags |= ENGINE_AVAILABLE;

   234

			e->player_avail = 0;

   235

		}

   236

   237

		/* This sets up type for the engine

   238

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

   239

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

   240

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

   241

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

   242

	}

   243

   244

	AdjustAvailAircraft();

   245

}

   246

   247

uint32 _engine_refit_masks[TOTAL_NUM_ENGINES];

   248

   249

   250

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

   251

   252

typedef struct WagonOverride {

   253

	byte *train_id;

   254

	int trains;

   255

	SpriteGroup group;

   256

} WagonOverride;

   257

   258

typedef struct WagonOverrides {

   259

	int overrides_count;

   260

	WagonOverride *overrides;

   261

} WagonOverrides;

   262

   263

static WagonOverrides _engine_wagon_overrides[TOTAL_NUM_ENGINES];

   264

   265

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

   266

	int trains)

   267

{

   268

	WagonOverrides *wos;

   269

	WagonOverride *wo;

   270

   271

	wos = &_engine_wagon_overrides[engine];

   272

	wos->overrides_count++;

   273

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

   274

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

   275

   276

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

   277

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

   278

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

   279

	 * --pasky */

   280

	wo->group = *group;

   281

	wo->trains = trains;

   282

	wo->train_id = malloc(trains);

   283

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

   284

}

   285

   286

static SpriteGroup *GetWagonOverrideSpriteSet(byte engine, byte overriding_engine)

   287

{

   288

	WagonOverrides *wos = &_engine_wagon_overrides[engine];

   289

	int i;

   290

   291

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

   292

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

   293

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

   294

	// that. --pasky

   295

   296

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

   297

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

   298

		int j;

   299

   300

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

   301

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

   302

				return &wo->group;

   303

		}

   304

	}

   305

	return NULL;

   306

}

   307

   308

   309

byte _engine_original_sprites[TOTAL_NUM_ENGINES];

   310

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

   311

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

   312

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

   313

// memory. --pasky)

   314

static SpriteGroup _engine_custom_sprites[TOTAL_NUM_ENGINES][NUM_GLOBAL_CID];

   315

   316

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

   317

{

   318

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

   319

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

   320

	 * --pasky */

   321

	_engine_custom_sprites[engine][cargo] = *group;

   322

}

   323

   324

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

   325

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

   326

   327

static SpriteGroup* ResolveVehicleSpriteGroup(SpriteGroup *spritegroup,

   328

	const Vehicle *veh, uint16 callback_info, resolve_callback resolve_func)

   329

{

   330

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

   331

	switch (spritegroup->type) {

   332

		case SGT_REAL:

   333

		case SGT_CALLBACK:

   334

			return spritegroup;

   335

   336

		case SGT_DETERMINISTIC: {

   337

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

   338

			SpriteGroup *target;

   339

			int value = -1;

   340

   341

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

   342

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

   343

				/* Callback ID */

   344

				value = callback_info & 0xFF;

   345

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

   346

				/* General property */

   347

				value = GetDeterministicSpriteValue(dsg->variable);

   348

			} else {

   349

				/* Vehicle-specific property. */

   350

   351

				if (veh == NULL) {

   352

					/* We are in a purchase list of something,

   353

					 * and we are checking for something undefined.

   354

					 * That means we should get the first target

   355

					 * (NOT the default one). */

   356

					if (dsg->num_ranges > 0) {

   357

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

   358

					} else {

   359

						target = dsg->default_group;

   360

					}

   361

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

   362

				}

   363

   364

				if (dsg->var_scope == VSG_SCOPE_PARENT) {

   365

					/* First engine in the vehicle chain */

   366

					if (veh->type == VEH_Train)

   367

						veh = GetFirstVehicleInChain(veh);

   368

				}

   369

   370

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

   371

					if (veh->type == VEH_Train) {

   372

						Vehicle *u = GetFirstVehicleInChain(veh);

   373

						byte chain_before = 0, chain_after = 0;

   374

   375

						while (u != veh) {

   376

							chain_before++;

   377

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

   378

								chain_before = 0;

   379

							u = u->next;

   380

						}

   381

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

   382

							chain_after++;

   383

							u = u->next;

   384

						};

   385

   386

						value = chain_before | chain_after << 8

   387

						        | (chain_before + chain_after) << 16;

   388

					} else {

   389

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

   390

					}

   391

   392

				} else {

   393

					// TTDPatch runs on little-endian arch;

   394

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

   395

					switch (dsg->variable - 0x80) {

   396

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

   397

						veh_prop(0x00, veh->type);

   398

						veh_prop(0x01, veh->subtype);

   399

						veh_prop(0x04, veh->index);

   400

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

   401

						/* XXX? Is THIS right? */

   402

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

   403

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

   404

						veh_prop(0x0C, veh->num_orders);

   405

						veh_prop(0x0D, veh->cur_order_index);

   406

						veh_prop(0x10, veh->load_unload_time_rem);

   407

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

   408

						veh_prop(0x12, veh->date_of_last_service);

   409

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

   410

						veh_prop(0x14, veh->service_interval);

   411

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

   412

						veh_prop(0x16, veh->last_station_visited);

   413

						veh_prop(0x17, veh->tick_counter);

   414

						veh_prop(0x18, veh->max_speed);

   415

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

   416

						veh_prop(0x1F, veh->direction);

   417

						veh_prop(0x28, veh->cur_image);

   418

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

   419

						veh_prop(0x32, veh->vehstatus);

   420

						veh_prop(0x33, veh->vehstatus);

   421

						veh_prop(0x34, veh->cur_speed);

   422

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

   423

						veh_prop(0x36, veh->subspeed);

   424

						veh_prop(0x37, veh->acceleration);

   425

						veh_prop(0x39, veh->cargo_type);

   426

						veh_prop(0x3A, veh->cargo_cap);

   427

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

   428

						veh_prop(0x3C, veh->cargo_count);

   429

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

   430

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

   431

						veh_prop(0x3F, veh->cargo_days);

   432

						veh_prop(0x40, veh->age);

   433

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

   434

						veh_prop(0x42, veh->max_age);

   435

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

   436

						veh_prop(0x44, veh->build_year);

   437

						veh_prop(0x45, veh->unitnumber);

   438

						veh_prop(0x46, veh->engine_type);

   439

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

   440

						veh_prop(0x48, veh->spritenum);

   441

						veh_prop(0x49, veh->day_counter);

   442

						veh_prop(0x4A, veh->breakdowns_since_last_service);

   443

						veh_prop(0x4B, veh->breakdown_ctr);

   444

						veh_prop(0x4C, veh->breakdown_delay);

   445

						veh_prop(0x4D, veh->breakdown_chance);

   446

						veh_prop(0x4E, veh->reliability);

   447

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

   448

						veh_prop(0x50, veh->reliability_spd_dec);

   449

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

   450

						veh_prop(0x52, veh->profit_this_year);

   451

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

   452

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

   453

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

   454

						veh_prop(0x56, veh->profit_last_year);

   455

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

   456

						veh_prop(0x58, veh->profit_last_year);

   457

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

   458

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

   459

						veh_prop(0x5C, veh->value);

   460

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

   461

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

   462

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

   463

						veh_prop(0x60, veh->string_id);

   464

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

   465

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

   466

						 * aircraft: >=13h when in flight

   467

						 * train, ship: 80h=in depot

   468

						 * rv: 0feh=in depot */

   469

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

   470

   471

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

   472

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

   473

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

   474

   475

#undef veh_prop

   476

					}

   477

				}

   478

			}

   479

   480

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

   481

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

   482

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

   483

		}

   484

   485

		case SGT_RANDOMIZED: {

   486

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

   487

   488

			if (veh == NULL) {

   489

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

   490

				assert(rsg->num_groups > 0);

   491

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

   492

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

   493

			}

   494

   495

			if (rsg->var_scope == VSG_SCOPE_PARENT) {

   496

				/* First engine in the vehicle chain */

   497

				if (veh->type == VEH_Train)

   498

					veh = GetFirstVehicleInChain(veh);