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"

    21

    22

enum {

    23

	ENGINE_AVAILABLE = 1,

    24

	ENGINE_INTRODUCING = 2,

    25

	ENGINE_PREVIEWING = 4,

    26

};

    27

    28

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

    29

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

    30

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

    31

 */

    32

const CargoID _global_cargo_id[NUM_LANDSCAPE][NUM_CARGO] = {

    33

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

    34

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

    35

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

    36

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

    37

	/**

    38

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

    39

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

    40

	 * Following can  be renumbered:

    41

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

    42

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

    43

	 */

    44

};

    45

    46

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

    47

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

    48

const CargoID _local_cargo_id_ctype[NUM_GLOBAL_CID] = {

    49

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

    50

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

    51

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

    52

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

    53

	CT_INVALID,   CT_INVALID                                                                                      /* 29-30 */

    54

};

    55

    56

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

    57

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

    58

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

    59

const uint32 _landscape_global_cargo_mask[NUM_LANDSCAPE] =

    60

{ /* LT_NORMAL: temperate */

    61

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

    62

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

    63

	/* LT_HILLY: arctic */

    64

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

    65

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

    66

	/* LT_DESERT: rainforest/desert */

    67

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

    68

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

    69

	/* LT_CANDY: toyland */

    70

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

    71

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

    72

};

    73

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

    74

    75

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

    76

 * This coupled with the landscape information (_landscape_global_cargo_mask) gives

    77

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

    78

const uint32 _default_refitmasks[NUM_VEHICLE_TYPES] = {

    79

	/* Trains */

    80

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

    81

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

    82

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

    83

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

    84

	0,

    85

	/* Ships */

    86

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

    87

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

    88

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

    89

	/* Aircraft */

    90

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

    91

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

    92

	/* Special/Disaster */

    93

	0,0

    94

};

    95

    96

/**

    97

 * Bitmask of classes for cargo types.

    98

 */

    99

const uint32 cargo_classes[16] = {

   100

	/* Passengers */ MC(GC_PASSENGERS),

   101

	/* Mail       */ MC(GC_MAIL),

   102

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

   103

	/* Armoured   */ MC(GC_VALUABLES),

   104

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

   105

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

   106

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

   107

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

   108

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

   109

};

   110

#undef MC

   111

   112

void ShowEnginePreviewWindow(EngineID engine);

   113

   114

void DeleteCustomEngineNames(void)

   115

{

   116

	uint i;

   117

	StringID old;

   118

   119

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

   120

		old = _engine_name_strings[i];

   121

		_engine_name_strings[i] = i + STR_8000_KIRBY_PAUL_TANK_STEAM;

   122

		DeleteName(old);

   123

	}

   124

   125

	_vehicle_design_names &= ~1;

   126

}

   127

   128

void LoadCustomEngineNames(void)

   129

{

   130

	// XXX: not done */

   131

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

   132

}

   133

   134

static void SetupEngineNames(void)

   135

{

   136

	StringID *name;

   137

   138

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

   139

		*name = STR_SV_EMPTY;

   140

   141

	DeleteCustomEngineNames();

   142

	LoadCustomEngineNames();

   143

}

   144

   145

static void AdjustAvailAircraft(void)

   146

{

   147

	uint16 date = _date;

   148

	byte avail = 0;

   149

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

   150

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

   151

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

   152

   153

	if (avail != _avail_aircraft) {

   154

		_avail_aircraft = avail;

   155

		InvalidateWindow(WC_BUILD_STATION, 0);

   156

	}

   157

}

   158

   159

static void CalcEngineReliability(Engine *e)

   160

{

   161

	uint age = e->age;

   162

   163

	if (age < e->duration_phase_1) {

   164

		uint start = e->reliability_start;

   165

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

   166

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

   167

		e->reliability = e->reliability_max;

   168

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

   169

		uint max = e->reliability_max;

   170

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

   171

	} else {

   172

		// time's up for this engine

   173

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

   174

		// or disable this engine completely

   175

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

   176

		e->reliability = e->reliability_final;

   177

	}

   178

}

   179

   180

void AddTypeToEngines(void)

   181

{

   182

	Engine* e = _engines;

   183

   184

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

   185

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

   186

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

   187

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

   188

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

   189

}

   190

   191

void StartupEngines(void)

   192

{

   193

	Engine *e;

   194

	const EngineInfo *ei;

   195

   196

	SetupEngineNames();

   197

   198

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

   199

		uint32 r;

   200

   201

		e->age = 0;

   202

		e->railtype = ei->railtype;

   203

		e->flags = 0;

   204

		e->player_avail = 0;

   205

   206

		r = Random();

   207

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

   208

		if (e->intro_date <= _date) {

   209

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

   210

			e->player_avail = (byte)-1;

   211

			e->flags |= ENGINE_AVAILABLE;

   212

		}

   213

   214

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

   215

		r = Random();

   216

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

   217

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

   218

   219

		r = Random();

   220

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

   221

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

   222

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

   223

   224

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

   225

   226

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

   227

		if (ei->unk2 & 0x80) {

   228

			e->age = 0xFFFF;

   229

		} else {

   230

			CalcEngineReliability(e);

   231

		}

   232

   233

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

   234

   235

		// prevent certain engines from ever appearing.

   236

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

   237

			e->flags |= ENGINE_AVAILABLE;

   238

			e->player_avail = 0;

   239

		}

   240

   241

		/* This sets up type for the engine

   242

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

   243

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

   244

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

   245

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

   246

	}

   247

   248

	AdjustAvailAircraft();

   249

}

   250

   251

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

   252

   253

typedef struct WagonOverride {

   254

	byte *train_id;

   255

	int trains;

   256

	SpriteGroup *group;

   257

} WagonOverride;

   258

   259

typedef struct WagonOverrides {

   260

	int overrides_count;

   261

	WagonOverride *overrides;

   262

} WagonOverrides;

   263

   264

static WagonOverrides _engine_wagon_overrides[TOTAL_NUM_ENGINES];

   265

   266

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

   267

	int trains)

   268

{

   269

	WagonOverrides *wos;

   270

	WagonOverride *wo;

   271

   272

	wos = &_engine_wagon_overrides[engine];

   273

	wos->overrides_count++;

   274

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

   275

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

   276

   277

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

   278

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

   279

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

   280

	 * --pasky */

   281

	wo->group = group;

   282

	group->ref_count++;

   283

	wo->trains = trains;

   284

	wo->train_id = malloc(trains);

   285

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

   286

}

   287

   288

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

   289

{

   290

	const WagonOverrides *wos = &_engine_wagon_overrides[engine];

   291

	int i;

   292

   293

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

   294

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

   295

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

   296

	// that. --pasky

   297

   298

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

   299

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

   300

		int j;

   301

   302

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

   303

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

   304

				return wo->group;

   305

		}

   306

	}

   307

	return NULL;

   308

}

   309

   310

/**

   311

 * Unload all wagon override sprite groups.

   312

 */

   313

void UnloadWagonOverrides(void)

   314

{

   315

	WagonOverrides *wos;

   316

	WagonOverride *wo;

   317

	EngineID engine;

   318

	int i;

   319

   320

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

   321

		wos = &_engine_wagon_overrides[engine];

   322

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

   323

			wo = &wos->overrides[i];

   324

			UnloadSpriteGroup(&wo->group);

   325

			free(wo->train_id);

   326

		}

   327

		free(wos->overrides);

   328

		wos->overrides_count = 0;

   329

		wos->overrides = NULL;

   330

	}

   331

}

   332

   333

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

   334

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

   335

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

   336

// memory. --pasky)

   337

static SpriteGroup *engine_custom_sprites[TOTAL_NUM_ENGINES][NUM_GLOBAL_CID];

   338

   339

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

   340

{

   341

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

   342

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

   343

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

   344

	}

   345

	engine_custom_sprites[engine][cargo] = group;

   346

	group->ref_count++;

   347

}

   348

   349

/**

   350

 * Unload all engine sprite groups.

   351

 */

   352

void UnloadCustomEngineSprites(void)

   353

{

   354

	EngineID engine;

   355

	CargoID cargo;

   356

   357

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

   358

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

   359

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

   360

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

   361

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

   362

			}

   363

		}

   364

	}

   365

}

   366

   375

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

   376

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

   377

   378

static const SpriteGroup* ResolveVehicleSpriteGroup(const SpriteGroup *spritegroup,

   379

	const Vehicle *veh, uint16 callback_info, resolve_callback resolve_func)

   380

{

   381

	if (spritegroup == NULL)

   382

		return NULL;

   383

   384

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

   385

	switch (spritegroup->type) {

   386

		case SGT_REAL:

   387

		case SGT_CALLBACK:

   388

			return spritegroup;

   389

   390

		case SGT_DETERMINISTIC: {

   391

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

   392

			const SpriteGroup *target;

   393

			int value = -1;

   394

   395

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

   396

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

   397

				/* Callback ID */

   398

				value = callback_info & 0xFF;

   399

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

   400

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

   401

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

   402

				/* General property */

   403

				value = GetDeterministicSpriteValue(dsg->variable);

   404

			} else {

   405

				/* Vehicle-specific property. */

   406

   407

				if (veh == NULL) {

   408

					/* We are in a purchase list of something,

   409

					 * and we are checking for something undefined.

   410

					 * That means we should get the first target

   411

					 * (NOT the default one). */

   412

					if (dsg->num_ranges > 0) {

   413

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

   414

					} else {

   415

						target = dsg->default_group;

   416

					}

   417

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

   418

				}

   419

   420

				if (dsg->var_scope == VSG_SCOPE_PARENT) {

   421

					/* First engine in the vehicle chain */

   422

					if (veh->type == VEH_Train)

   423

						veh = GetFirstVehicleInChain(veh);

   424

				}

   425

   426

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

   427

					if (veh->type == VEH_Train) {

   428

						const Vehicle *u = GetFirstVehicleInChain(veh);

   429

						byte chain_before = 0, chain_after = 0;

   430

   431

						while (u != veh) {

   432

							chain_before++;

   433

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

   434

								chain_before = 0;

   435

							u = u->next;

   436

						}

   437

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

   438

							chain_after++;

   439

							u = u->next;

   440

						};

   441

   442

						value = chain_before | chain_after << 8

   443

						        | (chain_before + chain_after) << 16;

   444

					} else {

   445

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

   446

					}

   447

   448

				} else {

   449

					// TTDPatch runs on little-endian arch;

   450

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

   451

					switch (dsg->variable - 0x80) {

   452

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

   453

						veh_prop(0x00, veh->type);

   455

						veh_prop(0x04, veh->index);

   456

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

   457

						/* XXX? Is THIS right? */

   458

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

   459

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

   460

						veh_prop(0x0C, veh->num_orders);

   461

						veh_prop(0x0D, veh->cur_order_index);

   462

						veh_prop(0x10, veh->load_unload_time_rem);

   463

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

   464

						veh_prop(0x12, veh->date_of_last_service);

   465

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

   466

						veh_prop(0x14, veh->service_interval);

   467

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

   468

						veh_prop(0x16, veh->last_station_visited);

   469

						veh_prop(0x17, veh->tick_counter);

   470

						veh_prop(0x18, veh->max_speed);

   471

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

   472

						veh_prop(0x1F, veh->direction);

   473

						veh_prop(0x28, veh->cur_image);

   474

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

   475

						veh_prop(0x32, veh->vehstatus);

   476

						veh_prop(0x33, veh->vehstatus);

   477

						veh_prop(0x34, veh->cur_speed);

   478

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

   479

						veh_prop(0x36, veh->subspeed);

   480

						veh_prop(0x37, veh->acceleration);

   481

						veh_prop(0x39, veh->cargo_type);

   482

						veh_prop(0x3A, veh->cargo_cap);

   483

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

   484

						veh_prop(0x3C, veh->cargo_count);

   485

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

   486

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

   487

						veh_prop(0x3F, veh->cargo_days);

   488

						veh_prop(0x40, veh->age);

   489

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

   490

						veh_prop(0x42, veh->max_age);

   491

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

   492

						veh_prop(0x44, veh->build_year);

   493

						veh_prop(0x45, veh->unitnumber);

   494

						veh_prop(0x46, veh->engine_type);

   495

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

   496

						veh_prop(0x48, veh->spritenum);