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

		// The magic value of 729 days below comes from the NewGRF spec. If the

   213

		// base intro date is before 1922 then the random number of days is not

   214

		// added.

   215

		r = Random();

   216

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

   217

		if (e->intro_date <= _date) {

   218

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

   219

			e->player_avail = (byte)-1;

   220

			e->flags |= ENGINE_AVAILABLE;

   221

		}

   222

   223

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

   224

		r = Random();

   225

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

   226

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

   227

   228

		r = Random();

   229

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

   230

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

   231

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

   232

   233

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

   234

   235

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

   236

		if (ei->unk2 & 0x80) {

   237

			e->age = 0xFFFF;

   238

		} else {

   239

			CalcEngineReliability(e);

   240

		}

   241

   242

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

   243

   244

		// prevent certain engines from ever appearing.

   245

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

   246

			e->flags |= ENGINE_AVAILABLE;

   247

			e->player_avail = 0;

   248

		}

   249

   250

		/* This sets up type for the engine

   251

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

   252

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

   253

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

   254

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

   255

	}

   256

   257

	AdjustAvailAircraft();

   258

}

   259

   260

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

   261

   262

typedef struct WagonOverride {

   263

	byte *train_id;

   264

	int trains;

   265

	SpriteGroup *group;

   266

} WagonOverride;

   267

   268

typedef struct WagonOverrides {

   269

	int overrides_count;

   270

	WagonOverride *overrides;

   271

} WagonOverrides;

   272

   273

static WagonOverrides _engine_wagon_overrides[TOTAL_NUM_ENGINES];

   274

   275

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

   276

	int trains)

   277

{

   278

	WagonOverrides *wos;

   279

	WagonOverride *wo;

   280

   281

	wos = &_engine_wagon_overrides[engine];

   282

	wos->overrides_count++;

   283

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

   284

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

   285

   286

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

   287

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

   288

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

   289

	 * --pasky */

   290

	wo->group = group;

   291

	group->ref_count++;

   292

	wo->trains = trains;

   293

	wo->train_id = malloc(trains);

   294

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

   295

}

   296

   297

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

   298

{

   299

	const WagonOverrides *wos = &_engine_wagon_overrides[engine];

   300

	int i;

   301

   302

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

   303

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

   304

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

   305

	// that. --pasky

   306

   307

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

   308

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

   309

		int j;

   310

   311

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

   312

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

   313

				return wo->group;

   314

		}

   315

	}

   316

	return NULL;

   317

}

   318

   319

/**

   320

 * Unload all wagon override sprite groups.

   321

 */

   322

void UnloadWagonOverrides(void)

   323

{

   324

	WagonOverrides *wos;

   325

	WagonOverride *wo;

   326

	EngineID engine;

   327

	int i;

   328

   329

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

   330

		wos = &_engine_wagon_overrides[engine];

   331

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

   332

			wo = &wos->overrides[i];

   333

			UnloadSpriteGroup(&wo->group);

   334

			free(wo->train_id);

   335

		}

   336

		free(wos->overrides);

   337

		wos->overrides_count = 0;

   338

		wos->overrides = NULL;

   339

	}

   340

}

   341

   342

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

   343

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

   344

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

   345

// memory. --pasky)

   346

static SpriteGroup *engine_custom_sprites[TOTAL_NUM_ENGINES][NUM_GLOBAL_CID];

   347

   348

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

   349

{

   350

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

   351

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

   352

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

   353

	}

   354

	engine_custom_sprites[engine][cargo] = group;

   355

	group->ref_count++;

   356

}

   357

   358

/**

   359

 * Unload all engine sprite groups.

   360

 */

   361

void UnloadCustomEngineSprites(void)

   362

{

   363

	EngineID engine;

   364

	CargoID cargo;

   365

   366

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

   367

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

   368

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

   369

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

   370

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

   371

			}

   372

		}

   373

	}

   374

}

   375

   376

static int MapOldSubType(const Vehicle *v)

   377

{

   378

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

   379

	if (IsTrainEngine(v)) return 0;

   380

	if (IsFreeWagon(v)) return 4;

   381

	return 2;

   382

}

   383

   384

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

   385

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

   386

   387

static const SpriteGroup* ResolveVehicleSpriteGroup(const SpriteGroup *spritegroup,

   388

	const Vehicle *veh, uint16 callback_info, resolve_callback resolve_func)

   389

{

   390

	if (spritegroup == NULL)

   391

		return NULL;

   392

   393

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

   394

	switch (spritegroup->type) {

   395

		case SGT_REAL:

   396

		case SGT_CALLBACK:

   397

			return spritegroup;

   398

   399

		case SGT_DETERMINISTIC: {

   400

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

   401

			const SpriteGroup *target;

   402

			int value = -1;

   403

   404

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

   405

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

   406

				/* Callback ID */

   407

				value = callback_info & 0xFF;

   408

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

   409

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

   410

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

   411

				/* General property */

   412

				value = GetDeterministicSpriteValue(dsg->variable);

   413

			} else {

   414

				/* Vehicle-specific property. */

   415

   416

				if (veh == NULL) {

   417

					/* We are in a purchase list of something,

   418

					 * and we are checking for something undefined.

   419

					 * That means we should get the first target

   420

					 * (NOT the default one). */

   421

					if (dsg->num_ranges > 0) {

   422

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

   423

					} else {

   424

						target = dsg->default_group;

   425

					}

   426

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

   427

				}

   428

   429

				if (dsg->var_scope == VSG_SCOPE_PARENT) {

   430

					/* First engine in the vehicle chain */

   431

					if (veh->type == VEH_Train)

   432

						veh = GetFirstVehicleInChain(veh);

   433

				}

   434

   435

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

   436

					if (veh->type == VEH_Train) {

   437

						const Vehicle *u = GetFirstVehicleInChain(veh);

   438

						byte chain_before = 0, chain_after = 0;

   439

   440

						while (u != veh) {

   441

							chain_before++;

   442

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

   443

								chain_before = 0;

   444

							u = u->next;

   445

						}

   446

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

   447

							chain_after++;

   448

							u = u->next;

   449

						};

   450

   451

						value = chain_before | chain_after << 8

   452

						        | (chain_before + chain_after) << 16;

   453

					} else {

   454

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

   455

					}

   456

   457

				} else {

   458

					// TTDPatch runs on little-endian arch;

   459

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

   460

					switch (dsg->variable - 0x80) {

   461

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

   462

						veh_prop(0x00, veh->type);

   463

						veh_prop(0x01, MapOldSubType(veh));

   464

						veh_prop(0x04, veh->index);

   465

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

   466

						/* XXX? Is THIS right? */

   467

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

   468

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

   469

						veh_prop(0x0C, veh->num_orders);

   470

						veh_prop(0x0D, veh->cur_order_index);

   471

						veh_prop(0x10, veh->load_unload_time_rem);

   472

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

   473

						veh_prop(0x12, veh->date_of_last_service);

   474

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

   475

						veh_prop(0x14, veh->service_interval);

   476

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

   477

						veh_prop(0x16, veh->last_station_visited);

   478

						veh_prop(0x17, veh->tick_counter);

   479

						veh_prop(0x18, veh->max_speed);

   480

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

   481

						veh_prop(0x1F, veh->direction);

   482

						veh_prop(0x28, veh->cur_image);

   483

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

   484

						veh_prop(0x32, veh->vehstatus);

   485

						veh_prop(0x33, veh->vehstatus);

   486

						veh_prop(0x34, veh->cur_speed);

   487

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

   488

						veh_prop(0x36, veh->subspeed);

   489

						veh_prop(0x37, veh->acceleration);

   490

						veh_prop(0x39, veh->cargo_type);

   491

						veh_prop(0x3A, veh->cargo_cap);

   492

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

   493

						veh_prop(0x3C, veh->cargo_count);

   494

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

   495

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

   496

						veh_prop(0x3F, veh->cargo_days);