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 = _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(byte 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(byte 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(byte 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

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

   318

	switch (spritegroup->type) {

   319

		case SGT_REAL:

   320

		case SGT_CALLBACK:

   321

			return spritegroup;

   322

   323

		case SGT_DETERMINISTIC: {

   324

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

   325

			const SpriteGroup *target;

   326

			int value = -1;

   327

   328

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

   329

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

   330

				/* Callback ID */

   331

				value = callback_info & 0xFF;

   332

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

   333

				/* General property */

   334

				value = GetDeterministicSpriteValue(dsg->variable);

   335

			} else {

   336

				/* Vehicle-specific property. */

   337

   338

				if (veh == NULL) {

   339

					/* We are in a purchase list of something,

   340

					 * and we are checking for something undefined.

   341

					 * That means we should get the first target

   342

					 * (NOT the default one). */

   343

					if (dsg->num_ranges > 0) {

   344

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

   345

					} else {

   346

						target = dsg->default_group;

   347

					}

   348

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

   349

				}

   350

   351

				if (dsg->var_scope == VSG_SCOPE_PARENT) {

   352

					/* First engine in the vehicle chain */

   353

					if (veh->type == VEH_Train)

   354

						veh = GetFirstVehicleInChain(veh);

   355

				}

   356

   357

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

   358

					if (veh->type == VEH_Train) {

   359

						const Vehicle *u = GetFirstVehicleInChain(veh);

   360

						byte chain_before = 0, chain_after = 0;

   361

   362

						while (u != veh) {

   363

							chain_before++;

   364

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

   365

								chain_before = 0;

   366

							u = u->next;

   367

						}

   368

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

   369

							chain_after++;

   370

							u = u->next;

   371

						};

   372

   373

						value = chain_before | chain_after << 8

   374

						        | (chain_before + chain_after) << 16;

   375

					} else {

   376

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

   377

					}

   378

   379

				} else {

   380

					// TTDPatch runs on little-endian arch;

   381

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

   382

					switch (dsg->variable - 0x80) {

   383

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

   384

						veh_prop(0x00, veh->type);

   385

						veh_prop(0x01, veh->subtype);

   386

						veh_prop(0x04, veh->index);

   387

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

   388

						/* XXX? Is THIS right? */

   389

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

   390

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

   391

						veh_prop(0x0C, veh->num_orders);

   392

						veh_prop(0x0D, veh->cur_order_index);

   393

						veh_prop(0x10, veh->load_unload_time_rem);

   394

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

   395

						veh_prop(0x12, veh->date_of_last_service);

   396

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

   397

						veh_prop(0x14, veh->service_interval);

   398

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

   399

						veh_prop(0x16, veh->last_station_visited);

   400

						veh_prop(0x17, veh->tick_counter);

   401

						veh_prop(0x18, veh->max_speed);

   402

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

   403

						veh_prop(0x1F, veh->direction);

   404

						veh_prop(0x28, veh->cur_image);

   405

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

   406

						veh_prop(0x32, veh->vehstatus);

   407

						veh_prop(0x33, veh->vehstatus);

   408

						veh_prop(0x34, veh->cur_speed);

   409

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

   410

						veh_prop(0x36, veh->subspeed);

   411

						veh_prop(0x37, veh->acceleration);

   412

						veh_prop(0x39, veh->cargo_type);

   413

						veh_prop(0x3A, veh->cargo_cap);

   414

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

   415

						veh_prop(0x3C, veh->cargo_count);

   416

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

   417

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

   418

						veh_prop(0x3F, veh->cargo_days);

   419

						veh_prop(0x40, veh->age);

   420

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

   421

						veh_prop(0x42, veh->max_age);

   422

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

   423

						veh_prop(0x44, veh->build_year);

   424

						veh_prop(0x45, veh->unitnumber);

   425

						veh_prop(0x46, veh->engine_type);

   426

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

   427

						veh_prop(0x48, veh->spritenum);

   428

						veh_prop(0x49, veh->day_counter);

   429

						veh_prop(0x4A, veh->breakdowns_since_last_service);

   430

						veh_prop(0x4B, veh->breakdown_ctr);

   431

						veh_prop(0x4C, veh->breakdown_delay);

   432

						veh_prop(0x4D, veh->breakdown_chance);

   433

						veh_prop(0x4E, veh->reliability);

   434

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

   435

						veh_prop(0x50, veh->reliability_spd_dec);

   436

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

   437

						veh_prop(0x52, veh->profit_this_year);

   438

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

   439

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

   440

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

   441

						veh_prop(0x56, veh->profit_last_year);

   442

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

   443

						veh_prop(0x58, veh->profit_last_year);

   444

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

   445

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

   446

						veh_prop(0x5C, veh->value);

   447

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

   448

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

   449

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

   450

						veh_prop(0x60, veh->string_id);

   451

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

   452

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

   453

						 * aircraft: >=13h when in flight

   454

						 * train, ship: 80h=in depot

   455

						 * rv: 0feh=in depot */

   456

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

   457

   458

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

   459

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

   460

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

   461

   462

#undef veh_prop

   463

					}

   464

				}

   465

			}

   466

   467

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

   468

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

   469

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

   470

		}

   471

   472

		case SGT_RANDOMIZED: {

   473

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

   474

   475

			if (veh == NULL) {

   476

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

   477

				assert(rsg->num_groups > 0);

   478

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

   479

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

   480

			}

   481

   482

			if (rsg->var_scope == VSG_SCOPE_PARENT) {

   483

				/* First engine in the vehicle chain */

   484

				if (veh->type == VEH_Train)

   485

					veh = GetFirstVehicleInChain(veh);

   486

			}

   487

   488

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

   489

		}

   490

   491

		default:

   492

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

   493

			return NULL;

   494

	}

   495

}

   496

   497

static const SpriteGroup *GetVehicleSpriteGroup(byte engine, const Vehicle *v)

   498