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

#include "train.h"

    21

    22

EngineInfo _engine_info[TOTAL_NUM_ENGINES];

    23

RailVehicleInfo _rail_vehicle_info[NUM_TRAIN_ENGINES];

    24

ShipVehicleInfo _ship_vehicle_info[NUM_SHIP_ENGINES];

    25

AircraftVehicleInfo _aircraft_vehicle_info[NUM_AIRCRAFT_ENGINES];

    26

RoadVehicleInfo _road_vehicle_info[NUM_ROAD_ENGINES];

    27

    28

enum {

    29

	ENGINE_AVAILABLE = 1,

    30

	ENGINE_INTRODUCING = 2,

    31

	ENGINE_PREVIEWING = 4,

    32

};

    33

    34

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

    35

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

    36

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

    37

 */

    38

const CargoID _global_cargo_id[NUM_LANDSCAPE][NUM_CARGO] = {

    39

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

    40

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

    41

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

    42

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

    43

	/**

    44

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

    45

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

    46

	 * Following can  be renumbered:

    47

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

    48

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

    49

	 */

    50

};

    51

    52

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

    53

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

    54

const CargoID _local_cargo_id_ctype[NUM_GLOBAL_CID] = {

    55

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

    56

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

    57

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

    58

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

    59

	CT_INVALID,   CT_INVALID                                                                                      /* 29-30 */

    60

};

    61

    62

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

    63

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

    64

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

    65

const uint32 _landscape_global_cargo_mask[NUM_LANDSCAPE] =

    66

{ /* LT_NORMAL: temperate */

    67

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

    68

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

    69

	/* LT_HILLY: arctic */

    70

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

    71

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

    72

	/* LT_DESERT: rainforest/desert */

    73

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

    74

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

    75

	/* LT_CANDY: toyland */

    76

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

    77

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

    78

};

    79

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

    80

    81

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

    82

 * This coupled with the landscape information (_landscape_global_cargo_mask) gives

    83

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

    84

const uint32 _default_refitmasks[NUM_VEHICLE_TYPES] = {

    85

	/* Trains */

    86

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

    87

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

    88

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

    89

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

    90

	0,

    91

	/* Ships */

    92

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

    93

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

    94

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

    95

	/* Aircraft */

    96

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

    97

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

    98

	/* Special/Disaster */

    99

	0,0

   100

};

   101

   102

/**

   103

 * Bitmask of classes for cargo types.

   104

 */

   105

const uint32 cargo_classes[16] = {

   106

	/* Passengers */ MC(GC_PASSENGERS),

   107

	/* Mail       */ MC(GC_MAIL),

   108

	/* Express    */ MC(GC_GOODS)|MC(GC_FOOD)|MC(GC_CANDY),

   109

	/* Armoured   */ MC(GC_VALUABLES),

   110

	/* Bulk       */ MC(GC_COAL)|MC(GC_GRAIN)|MC(GC_IRON_ORE)|MC(GC_COPPER_ORE)|MC(GC_FRUIT)|MC(GC_SUGAR)|MC(GC_TOFFEE)|MC(GC_COTTON_CANDY),

   111

	/* Piece      */ MC(GC_LIVESTOCK)|MC(GC_WOOD)|MC(GC_STEEL)|MC(GC_PAPER)|MC(GC_TOYS)|MC(GC_BATTERIES)|MC(GC_BUBBLES)|MC(GC_FIZZY_DRINKS),

   112

	/* Liquids    */ MC(GC_OIL)|MC(GC_WATER)|MC(GC_RUBBER)|MC(GC_COLA)|MC(GC_PLASTIC),

   113

	/* Chilled    */ MC(GC_FOOD)|MC(GC_FRUIT),

   114

	/* Undefined  */ 0, 0, 0, 0, 0, 0, 0, 0

   115

};

   116

#undef MC

   117

   118

void ShowEnginePreviewWindow(EngineID engine);

   119

   120

void DeleteCustomEngineNames(void)

   121

{

   122

	uint i;

   123

	StringID old;

   124

   125

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

   126

		old = _engine_name_strings[i];

   127

		_engine_name_strings[i] = i + STR_8000_KIRBY_PAUL_TANK_STEAM;

   128

		DeleteName(old);

   129

	}

   130

   131

	_vehicle_design_names &= ~1;

   132

}

   133

   134

void LoadCustomEngineNames(void)

   135

{

   136

	// XXX: not done */

   137

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

   138

}

   139

   140

static void SetupEngineNames(void)

   141

{

   142

	StringID *name;

   143

   144

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

   145

		*name = STR_SV_EMPTY;

   146

   147

	DeleteCustomEngineNames();

   148

	LoadCustomEngineNames();

   149

}

   150

   151

static void AdjustAvailAircraft(void)

   152

{

   153

	uint16 date = _date;

   154

	byte avail = 0;

   155

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

   156

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

   157

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

   158

   159

	if (avail != _avail_aircraft) {

   160

		_avail_aircraft = avail;

   161

		InvalidateWindow(WC_BUILD_STATION, 0);

   162

	}

   163

}

   164

   165

static void CalcEngineReliability(Engine *e)

   166

{

   167

	uint age = e->age;

   168

   169

	if (age < e->duration_phase_1) {

   170

		uint start = e->reliability_start;

   171

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

   172

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

   173

		e->reliability = e->reliability_max;

   174

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

   175

		uint max = e->reliability_max;

   176

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

   177

	} else {

   178

		// time's up for this engine

   179

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

   180

		// or disable this engine completely

   181

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

   182

		e->reliability = e->reliability_final;

   183

	}

   184

}

   185

   186

void AddTypeToEngines(void)

   187

{

   188

	Engine* e = _engines;

   189

   190

	do e->type = VEH_Train;    while (++e < &_engines[ROAD_ENGINES_INDEX]);

   191

	do e->type = VEH_Road;     while (++e < &_engines[SHIP_ENGINES_INDEX]);

   192

	do e->type = VEH_Ship;     while (++e < &_engines[AIRCRAFT_ENGINES_INDEX]);

   193

	do e->type = VEH_Aircraft; while (++e < &_engines[TOTAL_NUM_ENGINES]);

   194

	do e->type = VEH_Special;  while (++e < endof(_engines));

   195

}

   196

   197

void StartupEngines(void)

   198

{

   199

	Engine *e;

   200

	const EngineInfo *ei;

   201

   202

	SetupEngineNames();

   203

   204

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

   205

		uint32 r;

   206

   207

		e->age = 0;

   208

		e->railtype = ei->railtype;

   209

		e->flags = 0;

   210

		e->player_avail = 0;

   211

   212

		r = Random();

   213

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

   214

		if (e->intro_date <= _date) {

   215

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

   216

			e->player_avail = (byte)-1;

   217

			e->flags |= ENGINE_AVAILABLE;

   218

		}

   219

   220

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

   221

		r = Random();

   222

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

   223

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

   224

   225

		r = Random();

   226

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

   227

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

   228

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

   229

   230

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

   231

   232

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

   233

		if (ei->unk2 & 0x80) {

   234

			e->age = 0xFFFF;

   235

		} else {

   236

			CalcEngineReliability(e);

   237

		}

   238

   239

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

   240

   241

		// prevent certain engines from ever appearing.

   242

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

   243

			e->flags |= ENGINE_AVAILABLE;

   244

			e->player_avail = 0;

   245

		}

   246

   247

		/* This sets up type for the engine

   248

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

   249

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

   250

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

   251

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

   252

	}

   253

   254

	AdjustAvailAircraft();

   255

}

   256

   257

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

   258

   259

typedef struct WagonOverride {

   260

	byte *train_id;

   261

	int trains;

   262

	SpriteGroup *group;

   263

} WagonOverride;

   264

   265

typedef struct WagonOverrides {

   266

	int overrides_count;

   267

	WagonOverride *overrides;

   268

} WagonOverrides;

   269

   270

static WagonOverrides _engine_wagon_overrides[TOTAL_NUM_ENGINES];

   271

   272

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

   273

	int trains)

   274

{

   275

	WagonOverrides *wos;

   276

	WagonOverride *wo;

   277

   278

	wos = &_engine_wagon_overrides[engine];

   279

	wos->overrides_count++;

   280

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

   281

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

   282

   283

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

   284

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

   285

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

   286

	 * --pasky */

   287

	wo->group = group;

   288

	group->ref_count++;

   289

	wo->trains = trains;

   290

	wo->train_id = malloc(trains);

   291

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

   292

}

   293

   294

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

   295

{

   296

	const WagonOverrides *wos = &_engine_wagon_overrides[engine];

   297

	int i;

   298

   299

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

   300

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

   301

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

   302

	// that. --pasky

   303

   304

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

   305

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

   306

		int j;

   307

   308

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

   309

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

   310

				return wo->group;

   311

		}

   312

	}

   313

	return NULL;

   314

}

   315

   316

/**

   317

 * Unload all wagon override sprite groups.

   318

 */

   319

void UnloadWagonOverrides(void)

   320

{

   321

	WagonOverrides *wos;

   322

	WagonOverride *wo;

   323

	EngineID engine;

   324

	int i;

   325

   326

	for (engine = 0; engine < TOTAL_NUM_ENGINES; engine++) {

   327

		wos = &_engine_wagon_overrides[engine];

   328

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

   329

			wo = &wos->overrides[i];

   330

			UnloadSpriteGroup(&wo->group);

   331

			free(wo->train_id);

   332

		}

   333

		free(wos->overrides);

   334

		wos->overrides_count = 0;

   335

		wos->overrides = NULL;

   336

	}

   337

}

   338

   339

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

   340

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

   341

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

   342

// memory. --pasky)

   343

static SpriteGroup *engine_custom_sprites[TOTAL_NUM_ENGINES][NUM_GLOBAL_CID];

   344

   345

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

   346

{

   347

	if (engine_custom_sprites[engine][cargo] != NULL) {

   348

		DEBUG(grf, 6)("SetCustomEngineSprites: engine `%d' cargo `%d' already has group -- removing.", engine, cargo);

   349

		UnloadSpriteGroup(&engine_custom_sprites[engine][cargo]);

   350

	}

   351

	engine_custom_sprites[engine][cargo] = group;

   352

	group->ref_count++;

   353

}

   354

   355

/**

   356

 * Unload all engine sprite groups.

   357

 */

   358

void UnloadCustomEngineSprites(void)

   359

{

   360

	EngineID engine;

   361

	CargoID cargo;

   362

   363

	for (engine = 0; engine < TOTAL_NUM_ENGINES; engine++) {

   364

		for (cargo = 0; cargo < NUM_GLOBAL_CID; cargo++) {

   365

			if (engine_custom_sprites[engine][cargo] != NULL) {

   366

				DEBUG(grf, 6)("UnloadCustomEngineSprites: Unloading group for engine `%d' cargo `%d'.", engine, cargo);

   367

				UnloadSpriteGroup(&engine_custom_sprites[engine][cargo]);

   368

			}

   369

		}

   370

	}

   371

}

   372

   373

static int MapOldSubType(const Vehicle *v)

   374

{

   375

	if (v->type != VEH_Train) return v->subtype;

   376

	if (IsTrainEngine(v)) return 0;

   377

	if (IsFreeWagon(v)) return 4;

   378

	return 2;

   379

}

   380

   381

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

   382

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

   383

   384

static const SpriteGroup* ResolveVehicleSpriteGroup(const SpriteGroup *spritegroup,

   385

	const Vehicle *veh, uint16 callback_info, resolve_callback resolve_func)

   386

{

   387

	if (spritegroup == NULL)

   388

		return NULL;

   389

   390

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

   391

	switch (spritegroup->type) {

   392

		case SGT_REAL:

   393

		case SGT_CALLBACK:

   394

			return spritegroup;

   395

   396

		case SGT_DETERMINISTIC: {

   397

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

   398

			const SpriteGroup *target;

   399

			int value = -1;

   400

   401

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

   402

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

   403

				/* Callback ID */

   404

				value = callback_info & 0xFF;

   405

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

   406

				value = (callback_info >> 8) & 0xFF;

   407

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

   408

				/* General property */

   409

				value = GetDeterministicSpriteValue(dsg->variable);

   410

			} else {

   411

				/* Vehicle-specific property. */

   412

   413

				if (veh == NULL) {

   414

					/* We are in a purchase list of something,

   415

					 * and we are checking for something undefined.

   416

					 * That means we should get the first target

   417

					 * (NOT the default one). */

   418

					if (dsg->num_ranges > 0) {

   419

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

   420

					} else {

   421

						target = dsg->default_group;

   422

					}

   423

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

   424

				}

   425

   426

				if (dsg->var_scope == VSG_SCOPE_PARENT) {

   427

					/* First engine in the vehicle chain */

   428

					if (veh->type == VEH_Train)

   429

						veh = GetFirstVehicleInChain(veh);

   430

				}

   431

   432

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

   433

					if (veh->type == VEH_Train) {

   434

						const Vehicle *u = GetFirstVehicleInChain(veh);

   435

						byte chain_before = 0, chain_after = 0;

   436

   437

						while (u != veh) {

   438

							chain_before++;

   439

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

   440

								chain_before = 0;

   441

							u = u->next;

   442

						}

   443

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

   444

							chain_after++;

   445

							u = u->next;

   446

						};

   447

   448

						value = chain_before | chain_after << 8

   449

						        | (chain_before + chain_after) << 16;

   450

					} else {

   451

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

   452

					}

   453

   454

				} else {

   455

					// TTDPatch runs on little-endian arch;

   456

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

   457

					switch (dsg->variable - 0x80) {

   458

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

   459

						veh_prop(0x00, veh->type);

   460

						veh_prop(0x01, MapOldSubType(veh));

   461

						veh_prop(0x04, veh->index);

   462

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

   463

						/* XXX? Is THIS right? */

   464

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

   465

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

   466

						veh_prop(0x0C, veh->num_orders);

   467

						veh_prop(0x0D, veh->cur_order_index);

   468

						veh_prop(0x10, veh->load_unload_time_rem);

   469

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

   470

						veh_prop(0x12, veh->date_of_last_service);

   471

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

   472

						veh_prop(0x14, veh->service_interval);

   473

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

   474

						veh_prop(0x16, veh->last_station_visited);

   475

						veh_prop(0x17, veh->tick_counter);

   476

						veh_prop(0x18, veh->max_speed);

   477

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

   478

						veh_prop(0x1F, veh->direction);

   479

						veh_prop(0x28, veh->cur_image);

   480

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

   481

						veh_prop(0x32, veh->vehstatus);

   482

						veh_prop(0x33, veh->vehstatus);

   483

						veh_prop(0x34, veh->cur_speed);

   484

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

   485

						veh_prop(0x36, veh->subspeed);

   486

						veh_prop(0x37, veh->acceleration);

   487

						veh_prop(0x39, veh->cargo_type);

   488

						veh_prop(0x3A, veh->cargo_cap);

   489

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

   490

						veh_prop(0x3C, veh->cargo_count);

   491

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

   492

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

   493

						veh_prop(0x3F, veh->cargo_days);

   494

						veh_prop(0x40, veh->age);

   495

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

   496

						veh_prop(0x42, veh->max_age);