1

#include "stdafx.h"

     2

#include "openttd.h"

     3

#include "debug.h"

     4

#include "table/strings.h"

     5

#include "engine.h"

     6

#include "table/engines.h"

     7

#include "gfx.h"

     8

#include "player.h"

     9

#include "command.h"

    10

#include "vehicle.h"

    11

#include "news.h"

    12

#include "saveload.h"

    13

#include "sprite.h"

    14

    15

#define UPDATE_PLAYER_RAILTYPE(e,p) if ((byte)(e->railtype + 1) > p->max_railtype) p->max_railtype = e->railtype + 1;

    16

    17

enum {

    18

	ENGINE_AVAILABLE = 1,

    19

	ENGINE_INTRODUCING = 2,

    20

	ENGINE_PREVIEWING = 4,

    21

};

    22

    23

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

    24

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

    25

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

    26

 */

    27

const CargoID _global_cargo_id[NUM_LANDSCAPE][NUM_CARGO] = {

    28

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

    29

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

    30

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

    31

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

    32

	/**

    33

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

    34

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

    35

	 * Following can  be renumbered:

    36

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

    37

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

    38

	 */

    39

};

    40

    41

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

    42

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

    43

const CargoID _local_cargo_id_ctype[NUM_GLOBAL_CID] = {

    44

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

    45

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

    46

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

    47

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

    48

	CT_INVALID,   CT_INVALID                                                                                      /* 29-30 */

    49

};

    50

    51

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

    52

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

    53

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

    54

const uint32 _landscape_global_cargo_mask[NUM_LANDSCAPE] =

    55

{ /* LT_NORMAL: temperate */

    56

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

    57

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

    58

	/* LT_HILLY: arctic */

    59

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

    60

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

    61

	/* LT_DESERT: rainforest/desert */

    62

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

    63

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

    64

	/* LT_CANDY: toyland */

    65

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

    66

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

    67

};

    68

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

    69

    70

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

    71

 * This coupled with the landscape information (_landscape_global_cargo_mask) gives

    72

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

    73

const uint32 _default_refitmasks[NUM_VEHICLE_TYPES] = {

    74

	/* Trains */

    75

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

    76

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

    77

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

    78

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

    79

	0,

    80

	/* Ships */

    81

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

    82

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

    83

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

    84

	/* Aircraft */

    85

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

    86

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

    87

	/* Special/Disaster */

    88

	0,0

    89

};

    90

#undef MC

    91

    92

void ShowEnginePreviewWindow(int engine);

    93

    94

void DeleteCustomEngineNames(void)

    95

{

    96

	uint i;

    97

	StringID old;

    98

    99

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

   100

		old = _engine_name_strings[i];

   101

		_engine_name_strings[i] = i + STR_8000_KIRBY_PAUL_TANK_STEAM;

   102

		DeleteName(old);

   103

	}

   104

   105

	_vehicle_design_names &= ~1;

   106

}

   107

   108

void LoadCustomEngineNames(void)

   109

{

   110

	// XXX: not done */

   111

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

   112

}

   113

   114

static void SetupEngineNames(void)

   115

{

   116

	StringID *name;

   117

   118

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

   119

		*name = STR_SV_EMPTY;

   120

   121

	DeleteCustomEngineNames();

   122

	LoadCustomEngineNames();

   123

}

   124

   125

static void AdjustAvailAircraft(void)

   126

{

   127

	uint16 date = _date;

   128

	byte avail = 0;

   129

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

   130

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

   131

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

   132

   133

	if (avail != _avail_aircraft) {

   134

		_avail_aircraft = avail;

   135

		InvalidateWindow(WC_BUILD_STATION, 0);

   136

	}

   137

}

   138

   139

static void CalcEngineReliability(Engine *e)

   140

{

   141

	uint age = e->age;

   142

   143

	if (age < e->duration_phase_1) {

   144

		uint start = e->reliability_start;

   145

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

   146

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

   147

		e->reliability = e->reliability_max;

   148

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

   149

		uint max = e->reliability_max;

   150

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

   151

	} else {

   152

		// time's up for this engine

   153

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

   154

		// or disable this engine completely

   155

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

   156

		e->reliability = e->reliability_final;

   157

	}

   158

}

   159

   160

void AddTypeToEngines(void)

   161

{

   162

	Engine *e;

   163

	uint32 counter = 0;

   164

   165

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

   166

   167

		e->type = VEH_Train;

   168

		if 	(counter >= ROAD_ENGINES_INDEX) {

   169

			e->type = VEH_Road;

   170

			if 	(counter >= SHIP_ENGINES_INDEX) {

   171

				e->type = VEH_Ship;

   172

				if 	(counter >= AIRCRAFT_ENGINES_INDEX) {

   173

					e->type = VEH_Aircraft;

   174

					if 	(counter >= TOTAL_NUM_ENGINES) {

   175

						e->type = VEH_Special;

   176

					}

   177

				}

   178

			}

   179

		}

   180

	}

   181

}

   182

   183

void StartupEngines(void)

   184

{

   185

	Engine *e;

   186

	const EngineInfo *ei;

   187

	uint32 r, counter = 0;

   188

   189

	SetupEngineNames();

   190

   191

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

   192

   193

		e->age = 0;

   194

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

   195

		e->flags = 0;

   196

		e->player_avail = 0;

   197

   198

		r = Random();

   199

		e->intro_date = (uint16)((r & 0x1FF) + ei->base_intro);

   200

		if (e->intro_date <= _date) {

   201

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

   202

			e->player_avail = (byte)-1;

   203

			e->flags |= ENGINE_AVAILABLE;

   204

		}

   205

   206

		e->reliability_start = (uint16)(((r >> 16) & 0x3fff) + 0x7AE0);

   207

		r = Random();

   208

		e->reliability_max = (uint16)((r & 0x3fff) + 0xbfff);

   209

		e->reliability_final = (uint16)(((r>>16) & 0x3fff) + 0x3fff);

   210

   211

		r = Random();

   212

		e->duration_phase_1 = (uint16)((r & 0x1F) + 7);

   213

		e->duration_phase_2 = (uint16)(((r >> 5) & 0xF) + ei->base_life * 12 - 96);

   214

		e->duration_phase_3 = (uint16)(((r >> 9) & 0x7F) + 120);

   215

   216

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

   217

   218

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

   219

		if (ei->unk2 & 0x80) {

   220

			e->age = 0xFFFF;

   221

		} else {

   222

			CalcEngineReliability(e);

   223

		}

   224

   225

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

   226

   227

		// prevent certain engines from ever appearing.

   228

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

   229

			e->flags |= ENGINE_AVAILABLE;

   230

			e->player_avail = 0;

   231

		}

   232

   233

		/* This sets up type for the engine

   234

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

   235

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

   236

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

   237

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

   238

	}

   239

   240

	AdjustAvailAircraft();

   241

}

   242

   243

uint32 _engine_refit_masks[TOTAL_NUM_ENGINES];

   244

   245

   246

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

   247

   248

typedef struct WagonOverride {

   249

	byte *train_id;

   250

	int trains;

   251

	SpriteGroup group;

   252

} WagonOverride;

   253

   254

typedef struct WagonOverrides {

   255

	int overrides_count;

   256

	WagonOverride *overrides;

   257

} WagonOverrides;

   258

   259

static WagonOverrides _engine_wagon_overrides[TOTAL_NUM_ENGINES];

   260

   261

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

   262

	int trains)

   263

{

   264

	WagonOverrides *wos;

   265

	WagonOverride *wo;

   266

   267

	wos = &_engine_wagon_overrides[engine];

   268

	wos->overrides_count++;

   269

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

   270

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

   271

   272

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

   273

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

   274

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

   275

	 * --pasky */

   276

	wo->group = *group;

   277

	wo->trains = trains;

   278

	wo->train_id = malloc(trains);

   279

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

   280

}

   281

   282

static SpriteGroup *GetWagonOverrideSpriteSet(byte engine, byte overriding_engine)

   283

{

   284

	WagonOverrides *wos = &_engine_wagon_overrides[engine];

   285

	int i;

   286

   287

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

   288

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

   289

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

   290

	// that. --pasky

   291

   292

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

   293

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

   294

		int j;

   295

   296

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

   297

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

   298

				return &wo->group;

   299

		}

   300

	}

   301

	return NULL;

   302

}

   303

   304

   305

byte _engine_original_sprites[TOTAL_NUM_ENGINES];

   306

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

   307

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

   308

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

   309

// memory. --pasky)

   310

static SpriteGroup _engine_custom_sprites[TOTAL_NUM_ENGINES][NUM_GLOBAL_CID];

   311

   312

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

   313

{

   314

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

   315

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

   316

	 * --pasky */

   317

	_engine_custom_sprites[engine][cargo] = *group;

   318

}

   319

   320

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

   321

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

   322

   323

static SpriteGroup* ResolveVehicleSpriteGroup(SpriteGroup *spritegroup,

   324

	const Vehicle *veh, uint16 callback_info, resolve_callback resolve_func)

   325

{

   326

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

   327

	switch (spritegroup->type) {

   328

		case SGT_REAL:

   329

		case SGT_CALLBACK:

   330

			return spritegroup;

   331

   332

		case SGT_DETERMINISTIC: {

   333

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

   334

			SpriteGroup *target;

   335

			int value = -1;

   336

   337

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

   338

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

   339

				/* Callback ID */

   340

				value = callback_info & 0xFF;

   341

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

   342

				/* General property */

   343

				value = GetDeterministicSpriteValue(dsg->variable);

   344

			} else {

   345

				/* Vehicle-specific property. */

   346

   347

				if (veh == NULL) {

   348

					/* We are in a purchase list of something,

   349

					 * and we are checking for something undefined.

   350

					 * That means we should get the first target

   351

					 * (NOT the default one). */

   352

					if (dsg->num_ranges > 0) {

   353

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

   354

					} else {

   355

						target = dsg->default_group;

   356

					}

   357

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

   358

				}

   359

   360

				if (dsg->var_scope == VSG_SCOPE_PARENT) {

   361

					/* First engine in the vehicle chain */

   362

					if (veh->type == VEH_Train)

   363

						veh = GetFirstVehicleInChain(veh);

   364

				}

   365

   366

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

   367

					if (veh->type == VEH_Train) {

   368

						Vehicle *u = GetFirstVehicleInChain(veh);

   369

						byte chain_before = 0, chain_after = 0;

   370

   371

						while (u != veh) {

   372

							chain_before++;

   373

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

   374

								chain_before = 0;

   375

							u = u->next;

   376

						}

   377

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

   378

							chain_after++;

   379

							u = u->next;

   380

						};

   381

   382

						value = chain_before | chain_after << 8

   383

						        | (chain_before + chain_after) << 16;

   384

					} else {

   385

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

   386

					}

   387

   388

				} else {

   389

					// TTDPatch runs on little-endian arch;

   390

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

   391

					switch (dsg->variable - 0x80) {

   392

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

   393

						veh_prop(0x00, veh->type);

   394

						veh_prop(0x01, veh->subtype);

   395

						veh_prop(0x04, veh->index);

   396

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

   397

						/* XXX? Is THIS right? */

   398

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

   399

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

   400

						veh_prop(0x0C, veh->num_orders);

   401

						veh_prop(0x0D, veh->cur_order_index);

   402

						veh_prop(0x10, veh->load_unload_time_rem);

   403

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

   404

						veh_prop(0x12, veh->date_of_last_service);

   405

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

   406

						veh_prop(0x14, veh->service_interval);

   407

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

   408

						veh_prop(0x16, veh->last_station_visited);

   409

						veh_prop(0x17, veh->tick_counter);

   410

						veh_prop(0x18, veh->max_speed);

   411

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

   412

						veh_prop(0x1F, veh->direction);

   413

						veh_prop(0x28, veh->cur_image);

   414

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

   415

						veh_prop(0x32, veh->vehstatus);

   416

						veh_prop(0x33, veh->vehstatus);

   417

						veh_prop(0x34, veh->cur_speed);

   418

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

   419

						veh_prop(0x36, veh->subspeed);

   420

						veh_prop(0x37, veh->acceleration);

   421

						veh_prop(0x39, veh->cargo_type);

   422

						veh_prop(0x3A, veh->cargo_cap);

   423

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

   424

						veh_prop(0x3C, veh->cargo_count);

   425

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

   426

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

   427

						veh_prop(0x3F, veh->cargo_days);

   428

						veh_prop(0x40, veh->age);

   429

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

   430

						veh_prop(0x42, veh->max_age);

   431

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

   432

						veh_prop(0x44, veh->build_year);

   433

						veh_prop(0x45, veh->unitnumber);

   434

						veh_prop(0x46, veh->engine_type);

   435

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

   436

						veh_prop(0x48, veh->spritenum);

   437

						veh_prop(0x49, veh->day_counter);

   438

						veh_prop(0x4A, veh->breakdowns_since_last_service);

   439

						veh_prop(0x4B, veh->breakdown_ctr);

   440

						veh_prop(0x4C, veh->breakdown_delay);

   441

						veh_prop(0x4D, veh->breakdown_chance);

   442

						veh_prop(0x4E, veh->reliability);

   443

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

   444

						veh_prop(0x50, veh->reliability_spd_dec);

   445

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

   446

						veh_prop(0x52, veh->profit_this_year);

   447

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

   448

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

   449

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

   450

						veh_prop(0x56, veh->profit_last_year);

   451

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

   452

						veh_prop(0x58, veh->profit_last_year);

   453

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

   454

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

   455

						veh_prop(0x5C, veh->value);

   456

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

   457

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

   458

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

   459

						veh_prop(0x60, veh->string_id);

   460

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

   461

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

   462

						 * aircraft: >=13h when in flight

   463

						 * train, ship: 80h=in depot

   464

						 * rv: 0feh=in depot */

   465

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

   466

   467

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

   468

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

   469

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

   470

   471

#undef veh_prop

   472

					}

   473

				}

   474

			}

   475

   476

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

   477

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

   478

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

   479

		}

   480

   481

		case SGT_RANDOMIZED: {

   482

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

   483

   484

			if (veh == NULL) {

   485

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

   486

				assert(rsg->num_groups > 0);

   487

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

   488

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

   489

			}

   490

   491

			if (rsg->var_scope == VSG_SCOPE_PARENT) {

   492

				/* First engine in the vehicle chain */

   493

				if (veh->type == VEH_Train)

   494

					veh = GetFirstVehicleInChain(veh);

   495

			}

   496

   497

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

   498

		}

   499