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(EngineID 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(EngineID 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

	group->ref_count++;

   270

	wo->trains = trains;

   271

	wo->train_id = malloc(trains);

   272

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

   273

}

   274

   275

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

   276

{

   277

	const WagonOverrides *wos = &_engine_wagon_overrides[engine];

   278

	int i;

   279

   280

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

   281

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

   282

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

   283

	// that. --pasky

   284

   285

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

   286

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

   287

		int j;

   288

   289

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

   290

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

   291

				return wo->group;

   292

		}

   293

	}

   294

	return NULL;

   295

}

   296

   319

   320

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

   321

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

   322

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

   323

// memory. --pasky)

   324

static SpriteGroup *engine_custom_sprites[TOTAL_NUM_ENGINES][NUM_GLOBAL_CID];

   325

   326

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

   327

{

   332

	engine_custom_sprites[engine][cargo] = group;

   333

	group->ref_count++;

   334

}

   335

   354

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

   355

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

   356

   357

static const SpriteGroup* ResolveVehicleSpriteGroup(const SpriteGroup *spritegroup,

   358

	const Vehicle *veh, uint16 callback_info, resolve_callback resolve_func)

   359

{

   360

	if (spritegroup == NULL)

   361

		return NULL;

   362

   363

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

   364

	switch (spritegroup->type) {

   365

		case SGT_REAL:

   366

		case SGT_CALLBACK:

   367

			return spritegroup;

   368

   369

		case SGT_DETERMINISTIC: {

   370

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

   371

			const SpriteGroup *target;

   372

			int value = -1;

   373

   374

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

   375

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

   376

				/* Callback ID */

   377

				value = callback_info & 0xFF;

   378

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

   379

				/* General property */

   380

				value = GetDeterministicSpriteValue(dsg->variable);

   381

			} else {

   382

				/* Vehicle-specific property. */

   383

   384

				if (veh == NULL) {

   385

					/* We are in a purchase list of something,

   386

					 * and we are checking for something undefined.

   387

					 * That means we should get the first target

   388

					 * (NOT the default one). */

   389

					if (dsg->num_ranges > 0) {

   390

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

   391

					} else {

   392

						target = dsg->default_group;

   393

					}

   394

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

   395

				}

   396

   397

				if (dsg->var_scope == VSG_SCOPE_PARENT) {

   398

					/* First engine in the vehicle chain */

   399

					if (veh->type == VEH_Train)

   400

						veh = GetFirstVehicleInChain(veh);

   401

				}

   402

   403

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

   404

					if (veh->type == VEH_Train) {

   405

						const Vehicle *u = GetFirstVehicleInChain(veh);

   406

						byte chain_before = 0, chain_after = 0;

   407

   408

						while (u != veh) {

   409

							chain_before++;

   410

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

   411

								chain_before = 0;

   412

							u = u->next;

   413

						}

   414

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

   415

							chain_after++;

   416

							u = u->next;

   417

						};

   418

   419

						value = chain_before | chain_after << 8

   420

						        | (chain_before + chain_after) << 16;

   421

					} else {

   422

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

   423

					}

   424

   425

				} else {

   426

					// TTDPatch runs on little-endian arch;

   427

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

   428

					switch (dsg->variable - 0x80) {

   429

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

   430

						veh_prop(0x00, veh->type);

   431

						veh_prop(0x01, veh->subtype);

   432

						veh_prop(0x04, veh->index);

   433

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

   434

						/* XXX? Is THIS right? */

   435

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

   436

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

   437

						veh_prop(0x0C, veh->num_orders);

   438

						veh_prop(0x0D, veh->cur_order_index);

   439

						veh_prop(0x10, veh->load_unload_time_rem);

   440

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

   441

						veh_prop(0x12, veh->date_of_last_service);

   442

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

   443

						veh_prop(0x14, veh->service_interval);

   444

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

   445

						veh_prop(0x16, veh->last_station_visited);

   446

						veh_prop(0x17, veh->tick_counter);

   447

						veh_prop(0x18, veh->max_speed);

   448

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

   449

						veh_prop(0x1F, veh->direction);

   450

						veh_prop(0x28, veh->cur_image);

   451

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

   452

						veh_prop(0x32, veh->vehstatus);

   453

						veh_prop(0x33, veh->vehstatus);

   454

						veh_prop(0x34, veh->cur_speed);

   455

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

   456

						veh_prop(0x36, veh->subspeed);

   457

						veh_prop(0x37, veh->acceleration);

   458

						veh_prop(0x39, veh->cargo_type);

   459

						veh_prop(0x3A, veh->cargo_cap);

   460

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

   461

						veh_prop(0x3C, veh->cargo_count);

   462

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

   463

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

   464

						veh_prop(0x3F, veh->cargo_days);

   465

						veh_prop(0x40, veh->age);

   466

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

   467

						veh_prop(0x42, veh->max_age);

   468

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

   469

						veh_prop(0x44, veh->build_year);

   470

						veh_prop(0x45, veh->unitnumber);

   471

						veh_prop(0x46, veh->engine_type);

   472

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

   473

						veh_prop(0x48, veh->spritenum);

   474

						veh_prop(0x49, veh->day_counter);

   475

						veh_prop(0x4A, veh->breakdowns_since_last_service);

   476

						veh_prop(0x4B, veh->breakdown_ctr);

   477

						veh_prop(0x4C, veh->breakdown_delay);

   478

						veh_prop(0x4D, veh->breakdown_chance);

   479

						veh_prop(0x4E, veh->reliability);

   480

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

   481

						veh_prop(0x50, veh->reliability_spd_dec);

   482

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

   483

						veh_prop(0x52, veh->profit_this_year);

   484

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

   485

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

   486

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

   487

						veh_prop(0x56, veh->profit_last_year);

   488

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

   489

						veh_prop(0x58, veh->profit_last_year);

   490

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

   491

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

   492

						veh_prop(0x5C, veh->value);

   493

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

   494

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

   495

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

   496

						veh_prop(0x60, veh->string_id);

   497

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