3

#include "stdafx.h"

     4

#include "openttd.h"

     5

#include "debug.h"

     6

#include "functions.h"

     7

#include "table/strings.h"

     8

#include "engine.h"

     9

#include "table/engines.h"

    10

#include "gfx.h"

    11

#include "player.h"

    12

#include "command.h"

    13

#include "vehicle.h"

    14

#include "news.h"

    15

#include "saveload.h"

    16

#include "sprite.h"

    17

#include "variables.h"

    18

    19

enum {

    20

	ENGINE_AVAILABLE = 1,

    21

	ENGINE_INTRODUCING = 2,

    22

	ENGINE_PREVIEWING = 4,

    23

};

    24

    25

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

    26

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

    27

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

    28

 */

    29

const CargoID _global_cargo_id[NUM_LANDSCAPE][NUM_CARGO] = {

    30

	/* 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},

    31

	/* 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 },

    32

	/* 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 },

    33

	/* 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 },

    34

	/**

    35

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

    36

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

    37

	 * Following can  be renumbered:

    38

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

    39

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

    40

	 */

    41

};

    42

    43

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

    44

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

    45

const CargoID _local_cargo_id_ctype[NUM_GLOBAL_CID] = {

    46

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

    47

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

    48

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

    49

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

    50

	CT_INVALID,   CT_INVALID                                                                                      /* 29-30 */

    51

};

    52

    53

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

    54

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

    55

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

    56

const uint32 _landscape_global_cargo_mask[NUM_LANDSCAPE] =

    57

{ /* LT_NORMAL: temperate */

    58

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

    59

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

    60

	/* LT_HILLY: arctic */

    61

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

    62

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

    63

	/* LT_DESERT: rainforest/desert */

    64

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

    65

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

    66

	/* LT_CANDY: toyland */

    67

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

    68

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

    69

};

    70

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

    71

    72

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

    73

 * This coupled with the landscape information (_landscape_global_cargo_mask) gives

    74

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

    75

const uint32 _default_refitmasks[NUM_VEHICLE_TYPES] = {

    76

	/* Trains */

    77

	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)|

    78

	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)|

    79

	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),

    80

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

    81

	0,

    82

	/* Ships */

    83

	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)|

    84

	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)|

    85

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

    86

	/* Aircraft */

    87

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

    88

	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),

    89

	/* Special/Disaster */

    90

	0,0

    91

};

    92

#undef MC

    93

    94

void ShowEnginePreviewWindow(int engine);

    95

    96

void DeleteCustomEngineNames(void)

    97

{

    98

	uint i;

    99

	StringID old;

   100

   101

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

   102

		old = _engine_name_strings[i];

   103

		_engine_name_strings[i] = i + STR_8000_KIRBY_PAUL_TANK_STEAM;

   104

		DeleteName(old);

   105

	}

   106

   107

	_vehicle_design_names &= ~1;

   108

}

   109

   110

void LoadCustomEngineNames(void)

   111

{

   112

	// XXX: not done */

   113

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

   114

}

   115

   116

static void SetupEngineNames(void)

   117

{

   118

	StringID *name;

   119

   120

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

   121

		*name = STR_SV_EMPTY;

   122

   123

	DeleteCustomEngineNames();

   124

	LoadCustomEngineNames();

   125

}

   126

   127

static void AdjustAvailAircraft(void)

   128

{

   129

	uint16 date = _date;

   130

	byte avail = 0;

   131

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

   132

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

   133

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

   134

   135

	if (avail != _avail_aircraft) {

   136

		_avail_aircraft = avail;

   137

		InvalidateWindow(WC_BUILD_STATION, 0);

   138

	}

   139

}

   140

   141

static void CalcEngineReliability(Engine *e)

   142

{

   143

	uint age = e->age;

   144

   145

	if (age < e->duration_phase_1) {

   146

		uint start = e->reliability_start;

   147

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

   148

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

   149

		e->reliability = e->reliability_max;

   150

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

   151

		uint max = e->reliability_max;

   152

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

   153

	} else {

   154

		// time's up for this engine

   155

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

   156

		// or disable this engine completely

   157

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

   158

		e->reliability = e->reliability_final;

   159

	}

   160

}

   161

   162

void AddTypeToEngines(void)

   163

{

   164

	Engine *e;

   165

	uint32 counter = 0;

   166

   167

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

   168

   169

		e->type = VEH_Train;

   170

		if 	(counter >= ROAD_ENGINES_INDEX) {

   171

			e->type = VEH_Road;

   172

			if 	(counter >= SHIP_ENGINES_INDEX) {

   173

				e->type = VEH_Ship;

   174

				if 	(counter >= AIRCRAFT_ENGINES_INDEX) {

   175

					e->type = VEH_Aircraft;

   176

					if 	(counter >= TOTAL_NUM_ENGINES) {

   177

						e->type = VEH_Special;

   178

					}

   179

				}

   180

			}

   181

		}

   182

	}

   183

}

   184

   185

void StartupEngines(void)

   186

{

   187

	Engine *e;

   188

	const EngineInfo *ei;

   189

	uint32 r, counter = 0;

   190

   191

	SetupEngineNames();

   192

   193

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

   194

   195

		e->age = 0;

   196

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

   197

		e->flags = 0;

   198

		e->player_avail = 0;

   199

   200

		r = Random();

   201

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

   202

		if (e->intro_date <= _date) {

   203

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

   204

			e->player_avail = (byte)-1;

   205

			e->flags |= ENGINE_AVAILABLE;

   206

		}

   207

   208

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

   209

		r = Random();

   210

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

   211

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

   212

   213

		r = Random();

   214

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

   215

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

   216

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

   217

   218

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

   219

   220

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

   221

		if (ei->unk2 & 0x80) {

   222

			e->age = 0xFFFF;

   223

		} else {

   224

			CalcEngineReliability(e);

   225

		}

   226

   227

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

   228

   229

		// prevent certain engines from ever appearing.

   230

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

   231

			e->flags |= ENGINE_AVAILABLE;

   232

			e->player_avail = 0;

   233

		}

   234

   235

		/* This sets up type for the engine

   236

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

   237

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

   238

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

   239

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

   240

	}

   241

   242

	AdjustAvailAircraft();

   243

}

   244

   245

uint32 _engine_refit_masks[TOTAL_NUM_ENGINES];

   246

   247

   248

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

   249

   250

typedef struct WagonOverride {

   251

	byte *train_id;

   252

	int trains;

   253

	SpriteGroup group;

   254

} WagonOverride;

   255

   256

typedef struct WagonOverrides {

   257

	int overrides_count;

   258

	WagonOverride *overrides;

   259

} WagonOverrides;

   260

   261

static WagonOverrides _engine_wagon_overrides[TOTAL_NUM_ENGINES];

   262

   263

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

   264

	int trains)

   265

{

   266

	WagonOverrides *wos;

   267

	WagonOverride *wo;

   268

   269

	wos = &_engine_wagon_overrides[engine];

   270

	wos->overrides_count++;

   271

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

   272

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

   273

   274

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

   275

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

   276

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

   277

	 * --pasky */

   278

	wo->group = *group;

   279

	wo->trains = trains;

   280

	wo->train_id = malloc(trains);

   281

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

   282

}

   283

   284

static SpriteGroup *GetWagonOverrideSpriteSet(byte engine, byte overriding_engine)

   285

{

   286

	WagonOverrides *wos = &_engine_wagon_overrides[engine];

   287

	int i;

   288

   289

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

   290

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

   291

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

   292

	// that. --pasky

   293

   294

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

   295

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

   296

		int j;

   297

   298

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

   299

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

   300

				return &wo->group;

   301

		}

   302

	}

   303

	return NULL;

   304

}

   305

   306

   307

byte _engine_original_sprites[TOTAL_NUM_ENGINES];

   308

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

   309

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

   310

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

   311

// memory. --pasky)

   312

static SpriteGroup _engine_custom_sprites[TOTAL_NUM_ENGINES][NUM_GLOBAL_CID];

   313

   314

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

   315

{

   316

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

   317

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

   318

	 * --pasky */

   319

	_engine_custom_sprites[engine][cargo] = *group;

   320

}

   321

   322

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

   323

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

   324

   325

static SpriteGroup* ResolveVehicleSpriteGroup(SpriteGroup *spritegroup,

   326

	const Vehicle *veh, uint16 callback_info, resolve_callback resolve_func)

   327

{

   328

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

   329

	switch (spritegroup->type) {

   330

		case SGT_REAL:

   331

		case SGT_CALLBACK:

   332

			return spritegroup;

   333

   334

		case SGT_DETERMINISTIC: {

   335

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

   336

			SpriteGroup *target;

   337

			int value = -1;

   338

   339

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

   340

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

   341

				/* Callback ID */

   342

				value = callback_info & 0xFF;

   343

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

   344

				/* General property */

   345

				value = GetDeterministicSpriteValue(dsg->variable);

   346

			} else {

   347

				/* Vehicle-specific property. */

   348

   349

				if (veh == NULL) {

   350

					/* We are in a purchase list of something,

   351

					 * and we are checking for something undefined.

   352

					 * That means we should get the first target

   353

					 * (NOT the default one). */

   354

					if (dsg->num_ranges > 0) {

   355

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

   356

					} else {

   357

						target = dsg->default_group;

   358

					}

   359

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

   360

				}

   361

   362

				if (dsg->var_scope == VSG_SCOPE_PARENT) {

   363

					/* First engine in the vehicle chain */

   364

					if (veh->type == VEH_Train)

   365

						veh = GetFirstVehicleInChain(veh);

   366

				}

   367

   368

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

   369

					if (veh->type == VEH_Train) {

   370

						Vehicle *u = GetFirstVehicleInChain(veh);

   371

						byte chain_before = 0, chain_after = 0;

   372

   373

						while (u != veh) {

   374

							chain_before++;

   375

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

   376

								chain_before = 0;

   377

							u = u->next;

   378

						}

   379

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

   380

							chain_after++;

   381

							u = u->next;

   382

						};

   383

   384

						value = chain_before | chain_after << 8

   385

						        | (chain_before + chain_after) << 16;

   386

					} else {

   387

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

   388

					}

   389

   390

				} else {

   391

					// TTDPatch runs on little-endian arch;

   392

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

   393

					switch (dsg->variable - 0x80) {

   394

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

   395

						veh_prop(0x00, veh->type);

   396

						veh_prop(0x01, veh->subtype);

   397

						veh_prop(0x04, veh->index);

   398

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

   399

						/* XXX? Is THIS right? */

   400

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

   401

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

   402

						veh_prop(0x0C, veh->num_orders);

   403

						veh_prop(0x0D, veh->cur_order_index);

   404

						veh_prop(0x10, veh->load_unload_time_rem);

   405

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

   406

						veh_prop(0x12, veh->date_of_last_service);

   407

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

   408

						veh_prop(0x14, veh->service_interval);

   409

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

   410

						veh_prop(0x16, veh->last_station_visited);

   411

						veh_prop(0x17, veh->tick_counter);

   412

						veh_prop(0x18, veh->max_speed);

   413

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

   414

						veh_prop(0x1F, veh->direction);

   415

						veh_prop(0x28, veh->cur_image);

   416

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

   417

						veh_prop(0x32, veh->vehstatus);

   418

						veh_prop(0x33, veh->vehstatus);

   419

						veh_prop(0x34, veh->cur_speed);

   420

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

   421

						veh_prop(0x36, veh->subspeed);

   422

						veh_prop(0x37, veh->acceleration);

   423

						veh_prop(0x39, veh->cargo_type);

   424

						veh_prop(0x3A, veh->cargo_cap);

   425

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

   426

						veh_prop(0x3C, veh->cargo_count);

   427

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

   428

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

   429

						veh_prop(0x3F, veh->cargo_days);

   430

						veh_prop(0x40, veh->age);

   431

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

   432

						veh_prop(0x42, veh->max_age);

   433

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

   434

						veh_prop(0x44, veh->build_year);

   435

						veh_prop(0x45, veh->unitnumber);

   436

						veh_prop(0x46, veh->engine_type);

   437

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

   438

						veh_prop(0x48, veh->spritenum);

   439

						veh_prop(0x49, veh->day_counter);

   440

						veh_prop(0x4A, veh->breakdowns_since_last_service);

   441

						veh_prop(0x4B, veh->breakdown_ctr);

   442

						veh_prop(0x4C, veh->breakdown_delay);

   443

						veh_prop(0x4D, veh->breakdown_chance);

   444

						veh_prop(0x4E, veh->reliability);

   445

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

   446

						veh_prop(0x50, veh->reliability_spd_dec);

   447

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

   448

						veh_prop(0x52, veh->profit_this_year);

   449

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

   450

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

   451

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

   452

						veh_prop(0x56, veh->profit_last_year);

   453

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

   454

						veh_prop(0x58, veh->profit_last_year);

   455

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

   456

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

   457

						veh_prop(0x5C, veh->value);

   458

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

   459

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

   460

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

   461

						veh_prop(0x60, veh->string_id);

   462

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

   463

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

   464

						 * aircraft: >=13h when in flight

   465

						 * train, ship: 80h=in depot

   466

						 * rv: 0feh=in depot */

   467

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

   468

   469

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

   470

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

   471

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

   472

   473

#undef veh_prop

   474

					}

   475

				}

   476

			}

   477

   478

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

   479

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

   480

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

   481

		}

   482

   483

		case SGT_RANDOMIZED: {

   484

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

   485

   486

			if (veh == NULL) {

   487

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

   488

				assert(rsg->num_groups > 0);

   489

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

   490

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

   491

			}

   492

   493

			if (rsg->var_scope == VSG_SCOPE_PARENT) {

   494

				/* First engine in the vehicle chain */

   495

				if (veh->type == VEH_Train)

   496

					veh = GetFirstVehicleInChain(veh);

   497

			}

   498