1

/* $Id$ */

     2

     3

#include "stdafx.h"

     4

#include "openttd.h"

     5

#include "train.h"

     6

#include "ship.h"

     7

#include "aircraft.h"

     8

#include "debug.h"

     9

#include "functions.h"

    10

#include "table/sprites.h"

    11

#include "table/strings.h"

    12

#include "window.h"

    13

#include "gui.h"

    14

#include "vehicle.h"

    15

#include "gfx.h"

    16

#include "station.h"

    17

#include "command.h"

    18

#include "engine.h"

    19

#include "player.h"

    20

#include "depot.h"

    21

#include "airport.h"

    22

#include "vehicle_gui.h"

    23

#include "newgrf_engine.h"

    24

#include "date.h"

    25

#include "strings.h"

    26

    27

    28

enum BuildVehicleWidgets {

    29

	BUILD_VEHICLE_WIDGET_CLOSEBOX = 0,

    30

	BUILD_VEHICLE_WIDGET_CAPTION,

    31

	BUILD_VEHICLE_WIDGET_SORT_ASSENDING_DESCENDING,

    32

	BUILD_VEHICLE_WIDGET_SORT_TEXT,

    33

	BUILD_VEHICLE_WIDGET_SORT_DROPDOWN,

    34

	BUILD_VEHICLE_WIDGET_LIST,

    35

	BUILD_VEHICLE_WIDGET_SCROLLBAR,

    36

	BUILD_VEHICLE_WIDGET_PANEL,

    37

	BUILD_VEHICLE_WIDGET_BUILD,

    38

	BUILD_VEHICLE_WIDGET_RENAME,

    39

	BUILD_VEHICLE_WIDGET_RESIZE,

    40

};

    41

    42

static const Widget _build_vehicle_widgets[] = {

    43

	{   WWT_CLOSEBOX,   RESIZE_NONE,    14,     0,    10,     0,    13, STR_00C5,                STR_018B_CLOSE_WINDOW },

    44

	{    WWT_CAPTION,  RESIZE_RIGHT,    14,    11,   227,     0,    13, 0x0,                     STR_018C_WINDOW_TITLE_DRAG_THIS },

    45

	{ WWT_PUSHTXTBTN,   RESIZE_NONE,    14,     0,    80,    14,    25, STR_SORT_BY,             STR_SORT_ORDER_TIP},

    46

	{      WWT_PANEL,  RESIZE_RIGHT,    14,    81,   215,    14,    25, 0x0,                     STR_SORT_CRITERIA_TIP},

    47

	{    WWT_TEXTBTN,     RESIZE_LR,    14,   216,   227,    14,    25, STR_0225,                STR_SORT_CRITERIA_TIP},

    48

	{     WWT_MATRIX,     RESIZE_RB,    14,     0,   215,    26,   121, 0x0,                     STR_NULL },

    49

	{  WWT_SCROLLBAR,    RESIZE_LRB,    14,   216,   227,    26,   121, 0x0,                     STR_0190_SCROLL_BAR_SCROLLS_LIST },

    50

	{      WWT_PANEL,    RESIZE_RTB,    14,     0,   227,   122,   213, 0x0,                     STR_NULL },

    51

    52

	{ WWT_PUSHTXTBTN,     RESIZE_TB,    14,     0,   114,   214,   225, 0x0,                     STR_NULL },

    53

	{ WWT_PUSHTXTBTN,    RESIZE_RTB,    14,   115,   215,   214,   225, 0x0,                     STR_NULL },

    54

	{  WWT_RESIZEBOX,   RESIZE_LRTB,    14,   216,   227,   214,   225, 0x0,                     STR_RESIZE_BUTTON },

    55

	{   WIDGETS_END},

    56

};

    57

    58

static void ResizeButtons(Window *w)

    59

{

    60

	/* Make the buttons in the bottom equal in size */

    61

	w->widget[BUILD_VEHICLE_WIDGET_RENAME].right = w->widget[BUILD_VEHICLE_WIDGET_RESIZE].left - 1;

    62

	w->widget[BUILD_VEHICLE_WIDGET_RENAME].left  = w->widget[BUILD_VEHICLE_WIDGET_RENAME].right / 2;

    63

	w->widget[BUILD_VEHICLE_WIDGET_BUILD].right  = w->widget[BUILD_VEHICLE_WIDGET_RENAME].left - 1;

    64

}

    65

    66

/* Setup widget strings to fit the different types of vehicles */

    67

static void SetupWindowStrings(const Window *w, byte type)

    68

{

    69

	switch (type) {

    70

		case VEH_Train:

    71

			w->widget[BUILD_VEHICLE_WIDGET_CAPTION].data    = STR_JUST_STRING;

    72

			w->widget[BUILD_VEHICLE_WIDGET_LIST].tooltips   = STR_8843_TRAIN_VEHICLE_SELECTION;

    73

			w->widget[BUILD_VEHICLE_WIDGET_BUILD].data      = STR_881F_BUILD_VEHICLE;

    74

			w->widget[BUILD_VEHICLE_WIDGET_BUILD].tooltips  = STR_8844_BUILD_THE_HIGHLIGHTED_TRAIN;

    75

			w->widget[BUILD_VEHICLE_WIDGET_RENAME].data     = STR_8820_RENAME;

    76

			w->widget[BUILD_VEHICLE_WIDGET_RENAME].tooltips = STR_8845_RENAME_TRAIN_VEHICLE_TYPE;

    77

			break;

    78

		case VEH_Ship:

    79

			w->widget[BUILD_VEHICLE_WIDGET_CAPTION].data    = STR_9808_NEW_SHIPS;

    80

			w->widget[BUILD_VEHICLE_WIDGET_LIST].tooltips   = STR_9825_SHIP_SELECTION_LIST_CLICK;

    81

			w->widget[BUILD_VEHICLE_WIDGET_BUILD].data      = STR_9809_BUILD_SHIP;

    82

			w->widget[BUILD_VEHICLE_WIDGET_BUILD].tooltips  = STR_9826_BUILD_THE_HIGHLIGHTED_SHIP;

    83

			w->widget[BUILD_VEHICLE_WIDGET_RENAME].data     = STR_9836_RENAME;

    84

			w->widget[BUILD_VEHICLE_WIDGET_RENAME].tooltips = STR_9837_RENAME_SHIP_TYPE;

    85

			break;

    86

		case VEH_Aircraft:

    87

			w->widget[BUILD_VEHICLE_WIDGET_CAPTION].data    = STR_A005_NEW_AIRCRAFT;

    88

			w->widget[BUILD_VEHICLE_WIDGET_LIST].tooltips   = STR_A025_AIRCRAFT_SELECTION_LIST;

    89

			w->widget[BUILD_VEHICLE_WIDGET_BUILD].data      = STR_A006_BUILD_AIRCRAFT;

    90

			w->widget[BUILD_VEHICLE_WIDGET_BUILD].tooltips  = STR_A026_BUILD_THE_HIGHLIGHTED_AIRCRAFT;

    91

			w->widget[BUILD_VEHICLE_WIDGET_RENAME].data     = STR_A037_RENAME;

    92

			w->widget[BUILD_VEHICLE_WIDGET_RENAME].tooltips = STR_A038_RENAME_AIRCRAFT_TYPE;

    93

			break;

    94

	}

    95

}

    96

    97

static bool _internal_sort_order; // descending/ascending

    98

    99

static byte _last_sort_criteria[]    = {0, 0, 0, 0};

   100

static bool _last_sort_order[]       = {false, false, false, false};

   101

   102

static int CDECL EngineNumberSorter(const void *a, const void *b)

   103

{

   104

	const EngineID va = *(const EngineID*)a;

   105

	const EngineID vb = *(const EngineID*)b;

   106

	int r = va - vb;

   107

   108

	return _internal_sort_order ? -r : r;

   109

}

   110

   111

static int CDECL EngineIntroDateSorter(const void *a, const void *b)

   112

{

   113

	const int va = GetEngine(*(const EngineID*)a)->intro_date;

   114

	const int vb = GetEngine(*(const EngineID*)b)->intro_date;

   115

	const int r = va - vb;

   116

   117

	if (r == 0) {

   118

		/* Use EngineID to sort instead since we want consistent sorting */

   119

		return EngineNumberSorter(a, b);

   120

	}

   121

	return _internal_sort_order ? -r : r;

   122

}

   123

   124

static int CDECL EngineNameSorter(const void *a, const void *b)

   125

{

   126

	static EngineID last_engine[2] = { INVALID_ENGINE, INVALID_ENGINE };

   127

	static char     last_name[2][64] = { "\0", "\0" };

   128

   129

	const EngineID va = *(const EngineID*)a;

   130

	const EngineID vb = *(const EngineID*)b;

   131

	int r;

   132

   133

	if (va != last_engine[0]) {

   134

		last_engine[0] = va;

   135

		GetString(last_name[0], GetCustomEngineName(va), lastof(last_name[0]));

   136

	}

   137

   138

	if (vb != last_engine[1]) {

   139

		last_engine[1] = vb;

   140

		GetString(last_name[1], GetCustomEngineName(vb), lastof(last_name[1]));

   141

	}

   142

   143

	r = strcmp(last_name[0], last_name[1]); // sort by name

   144

   145

	if (r == 0) {

   146

		/* Use EngineID to sort instead since we want consistent sorting */

   147

		return EngineNumberSorter(a, b);

   148

	}

   149

	return _internal_sort_order ? -r : r;

   150

}

   151

   152

static int CDECL EngineReliabilitySorter(const void *a, const void *b)

   153

{

   154

	const int va = GetEngine(*(const EngineID*)a)->reliability;

   155

	const int vb = GetEngine(*(const EngineID*)b)->reliability;

   156

	const int r = va - vb;

   157

   158

	if (r == 0) {

   159

		/* Use EngineID to sort instead since we want consistent sorting */

   160

		return EngineNumberSorter(a, b);

   161

	}

   162

	return _internal_sort_order ? -r : r;

   163

}

   164

   165

/* Train sorting functions */

   166

static int CDECL TrainEngineCostSorter(const void *a, const void *b)

   167

{

   168

	int va = RailVehInfo(*(const EngineID*)a)->base_cost;

   169

	int vb = RailVehInfo(*(const EngineID*)b)->base_cost;

   170

	int r = va - vb;

   171

   172

	return _internal_sort_order ? -r : r;

   173

}

   174

   175

static int CDECL TrainEngineSpeedSorter(const void *a, const void *b)

   176

{

   177

	int va = RailVehInfo(*(const EngineID*)a)->max_speed;

   178

	int vb = RailVehInfo(*(const EngineID*)b)->max_speed;

   179

	int r = va - vb;

   180

   181

	return _internal_sort_order ? -r : r;

   182

}

   183

   184

static int CDECL TrainEnginePowerSorter(const void *a, const void *b)

   185

{

   186

	const RailVehicleInfo *rvi_a = RailVehInfo(*(const EngineID*)a);

   187

	const RailVehicleInfo *rvi_b = RailVehInfo(*(const EngineID*)b);

   188

   189

	int va = rvi_a->power << (rvi_a->flags & RVI_MULTIHEAD ? 1 : 0);

   190

	int vb = rvi_b->power << (rvi_b->flags & RVI_MULTIHEAD ? 1 : 0);

   191

	int r = va - vb;

   192

   193

	return _internal_sort_order ? -r : r;

   194

}

   195

   196

static int CDECL TrainEngineRunningCostSorter(const void *a, const void *b)

   197

{

   198

	const RailVehicleInfo *rvi_a = RailVehInfo(*(const EngineID*)a);

   199

	const RailVehicleInfo *rvi_b = RailVehInfo(*(const EngineID*)b);

   200

   201

	int va = rvi_a->running_cost_base * _price.running_rail[rvi_a->running_cost_class] * (rvi_a->flags & RVI_MULTIHEAD ? 2 : 1);

   202

	int vb = rvi_b->running_cost_base * _price.running_rail[rvi_b->running_cost_class] * (rvi_b->flags & RVI_MULTIHEAD ? 2 : 1);

   203

	int r = va - vb;

   204

   205

	return _internal_sort_order ? -r : r;

   206

}

   207

   208

static int CDECL TrainEnginePowerVsRunningCostSorter(const void *a, const void *b)

   209

{

   210

	const RailVehicleInfo *rvi_a = RailVehInfo(*(const EngineID*)a);

   211

	const RailVehicleInfo *rvi_b = RailVehInfo(*(const EngineID*)b);

   212

   213

	/* Here we are using a few tricks to get the right sort.

   214

		* We want power/running cost, but since we usually got higher running cost than power and we store the result in an int,

   215

		* we will actually calculate cunning cost/power (to make it more than 1).

   216

		* Because of this, the return value have to be reversed as well and we return b - a instead of a - b.

   217

		* Another thing is that both power and running costs should be doubled for multiheaded engines.

   218

		* Since it would be multipling with 2 in both numerator and denumerator, it will even themselves out and we skip checking for multiheaded. */

   219

	int va = (rvi_a->running_cost_base * _price.running_rail[rvi_a->running_cost_class]) / max((uint16)1, rvi_a->power);

   220

	int vb = (rvi_b->running_cost_base * _price.running_rail[rvi_b->running_cost_class]) / max((uint16)1, rvi_b->power);

   221

	int r = vb - va;

   222

   223

	return _internal_sort_order ? -r : r;

   224

}

   225

   226

static int CDECL TrainEnginesThenWagonsSorter(const void *a, const void *b)

   227

{

   228

	EngineID va = *(const EngineID*)a;

   229

	EngineID vb = *(const EngineID*)b;

   230

	int val_a = ((RailVehInfo(va)->flags & RVI_WAGON) != 0) ? 1 : 0;

   231

	int val_b = ((RailVehInfo(vb)->flags & RVI_WAGON) != 0) ? 1 : 0;

   232

	int r = val_a - val_b;

   233

   234

	/* Use EngineID to sort instead since we want consistent sorting */

   235

	if (r == 0) return EngineNumberSorter(a, b);

   236

   237

	return _internal_sort_order ? -r : r;

   238

}

   239

   240

/* Aircraft sorting functions */

   241

   242

static int CDECL AircraftEngineCostSorter(const void *a, const void *b)

   243

{

   244

	const int va = AircraftVehInfo(*(const EngineID*)a)->base_cost;

   245

	const int vb = AircraftVehInfo(*(const EngineID*)b)->base_cost;

   246

	int r = va - vb;

   247

   248

	return _internal_sort_order ? -r : r;

   249

}

   250

   251

static int CDECL AircraftEngineSpeedSorter(const void *a, const void *b)

   252

{

   253

	const int va = AircraftVehInfo(*(const EngineID*)a)->max_speed;

   254

	const int vb = AircraftVehInfo(*(const EngineID*)b)->max_speed;

   255

	const int r = va - vb;

   256

   257

	if (r == 0) {

   258

		/* Use EngineID to sort instead since we want consistent sorting */

   259

		return EngineNumberSorter(a, b);

   260

	}

   261

	return _internal_sort_order ? -r : r;

   262

}

   263

   264

static int CDECL AircraftEngineRunningCostSorter(const void *a, const void *b)

   265

{

   266

	const int va = AircraftVehInfo(*(const EngineID*)a)->running_cost;

   267

	const int vb = AircraftVehInfo(*(const EngineID*)b)->running_cost;

   268

	const int r = va - vb;

   269

   270

	if (r == 0) {

   271

		/* Use EngineID to sort instead since we want consistent sorting */

   272

		return EngineNumberSorter(a, b);

   273

	}

   274

	return _internal_sort_order ? -r : r;

   275

}

   276

   277

static int CDECL AircraftEngineCargoSorter(const void *a, const void *b)

   278

{

   279

	const int va = AircraftVehInfo(*(const EngineID*)a)->passenger_capacity;

   280

	const int vb = AircraftVehInfo(*(const EngineID*)b)->passenger_capacity;

   281

	const int r = va - vb;

   282

   283

	if (r == 0) {

   284

		/* Use EngineID to sort instead since we want consistent sorting */

   285

		return EngineNumberSorter(a, b);

   286

	}

   287

	return _internal_sort_order ? -r : r;

   288

}

   289

   291

	&EngineNumberSorter,

   292

	&TrainEngineCostSorter,

   293

	&TrainEngineSpeedSorter,

   294

	&TrainEnginePowerSorter,

   295

	&EngineIntroDateSorter,

   296

	&EngineNameSorter,

   297

	&TrainEngineRunningCostSorter,

   298

	&TrainEnginePowerVsRunningCostSorter,

   299

	&EngineReliabilitySorter,

   320

   322

	STR_ENGINE_SORT_ENGINE_ID,

   323

	STR_ENGINE_SORT_COST,

   324

	STR_SORT_BY_MAX_SPEED,

   325

	STR_ENGINE_SORT_POWER,

   326

	STR_ENGINE_SORT_INTRO_DATE,

   327

	STR_SORT_BY_DROPDOWN_NAME,

   328

	STR_ENGINE_SORT_RUNNING_COST,

   329

	STR_ENGINE_SORT_POWER_VS_RUNNING_COST,

   330

	STR_SORT_BY_RELIABILITY,

   331

	INVALID_STRING_ID

   333

	STR_ENGINE_SORT_ENGINE_ID,

   334

	STR_ENGINE_SORT_INTRO_DATE,

   335

	STR_SORT_BY_DROPDOWN_NAME,

   336

	STR_SORT_BY_RELIABILITY,

   337

	INVALID_STRING_ID

   345

	STR_ENGINE_SORT_ENGINE_ID,

   346

	STR_ENGINE_SORT_COST,

   347

	STR_SORT_BY_MAX_SPEED,

   348

	STR_ENGINE_SORT_INTRO_DATE,

   349

	STR_SORT_BY_DROPDOWN_NAME,

   350

	STR_ENGINE_SORT_RUNNING_COST,

   351

	STR_SORT_BY_RELIABILITY,

   352

	STR_ENGINE_SORT_CARGO_CAPACITY,

   353

	INVALID_STRING_ID

   355

   356

/* Draw rail wagon specific details */

   357

static int DrawVehiclePurchaseInfo(int x, int y, EngineID engine_number, const RailVehicleInfo *rvi)

   358

{

   359

	/* Purchase cost */

   360

	SetDParam(0, (rvi->base_cost * _price.build_railwagon) >> 8);

   361

	DrawString(x, y, STR_PURCHASE_INFO_COST, 0);

   362

	y += 10;

   363

   364

	/* Wagon weight - (including cargo) */

   365

	SetDParam(0, rvi->weight);

   366

	SetDParam(1, (_cargoc.weights[rvi->cargo_type] * rvi->capacity >> 4) + rvi->weight);

   367

	DrawString(x, y, STR_PURCHASE_INFO_WEIGHT_CWEIGHT, 0);

   368

	y += 10;

   369

   370

	/* Wagon speed limit, displayed if above zero */

   371

	if (rvi->max_speed > 0 && _patches.wagon_speed_limits) {

   372

		SetDParam(0, rvi->max_speed);

   373

		DrawString(x,y, STR_PURCHASE_INFO_SPEED, 0);

   374

		y += 10;

   375

	}

   376

	return y;

   377

}

   378

   379

/* Draw locomotive specific details */

   380

static int DrawVehiclePurchaseInfo(int x, int y, EngineID engine_number, const RailVehicleInfo *rvi, const Engine *e)

   381

{

   382

	int multihead = (rvi->flags&RVI_MULTIHEAD?1:0);

   383

   384

	/* Purchase Cost - Engine weight */

   385

	SetDParam(0, rvi->base_cost * (_price.build_railvehicle >> 3) >> 5);

   386

	SetDParam(1, rvi->weight << multihead);

   387

	DrawString(x,y, STR_PURCHASE_INFO_COST_WEIGHT, 0);

   388

	y += 10;

   389

   390

	/* Max speed - Engine power */

   391

	SetDParam(0, rvi->max_speed);

   392

	SetDParam(1, rvi->power << multihead);

   393

	DrawString(x,y, STR_PURCHASE_INFO_SPEED_POWER, 0);

   394

	y += 10;

   395

   396

	/* Max tractive effort - not applicable if old acceleration or maglev */

   397

	if (_patches.realistic_acceleration && e->railtype != RAILTYPE_MAGLEV) {

   398

		SetDParam(0, ((rvi->weight << multihead) * 10 * rvi->tractive_effort) / 256);

   399

		DrawString(x, y, STR_PURCHASE_INFO_MAX_TE, 0);

   400

		y += 10;

   401

	}

   402

   403

	/* Running cost */

   404

	SetDParam(0, (rvi->running_cost_base * _price.running_rail[rvi->running_cost_class] >> 8) << multihead);

   405

	DrawString(x,y, STR_PURCHASE_INFO_RUNNINGCOST, 0);

   406

	y += 10;

   407

   408

	/* Powered wagons power - Powered wagons extra weight */

   409

	if (rvi->pow_wag_power != 0) {

   410

		SetDParam(0, rvi->pow_wag_power);

   411

		SetDParam(1, rvi->pow_wag_weight);

   412

		DrawString(x,y, STR_PURCHASE_INFO_PWAGPOWER_PWAGWEIGHT, 0);

   413

		y += 10;

   414

	};

   415

   416

	return y;

   417

}

   418

   419

/* Draw ship specific details */

   420

static int DrawVehiclePurchaseInfo(int x, int y, EngineID engine_number, const ShipVehicleInfo *svi)

   421

{

   422

	/* Purchase cost - Max speed */

   423

	SetDParam(0, svi->base_cost * (_price.ship_base>>3)>>5);

   424

	SetDParam(1, svi->max_speed / 2);

   425

	DrawString(x,y, STR_PURCHASE_INFO_COST_SPEED, 0);

   426

	y += 10;

   427

   428

	/* Cargo type + capacity */

   429

	SetDParam(0, svi->cargo_type);

   430

	SetDParam(1, svi->capacity);

   431

	SetDParam(2, svi->refittable ? STR_9842_REFITTABLE : STR_EMPTY);

   432

	DrawString(x,y, STR_PURCHASE_INFO_CAPACITY, 0);

   433

	y += 10;

   434

   435

	/* Running cost */

   436

	SetDParam(0, svi->running_cost * _price.ship_running >> 8);

   437

	DrawString(x,y, STR_PURCHASE_INFO_RUNNINGCOST, 0);

   438

	y += 10;

   439

   440

	return y;

   441

}

   442

   443

/* Draw aircraft specific details */

   444

static int DrawVehiclePurchaseInfo(int x, int y, EngineID engine_number, const AircraftVehicleInfo *avi)

   445

{

   446

	CargoID cargo;

   447

   448

	/* Purchase cost - Max speed */

   449

	SetDParam(0, avi->base_cost * (_price.aircraft_base>>3)>>5);

   450

	SetDParam(1, avi->max_speed * 128 / 10);

   451

	DrawString(x, y, STR_PURCHASE_INFO_COST_SPEED, 0);

   452

	y += 10;

   453

   454

	/* Cargo capacity */

   455

	cargo = FindFirstRefittableCargo(engine_number);

   456

	if (cargo == CT_INVALID || cargo == CT_PASSENGERS) {

   457

		SetDParam(0, avi->passenger_capacity);

   458

		SetDParam(1, avi->mail_capacity);

   459

		DrawString(x, y, STR_PURCHASE_INFO_AIRCRAFT_CAPACITY, 0);

   460

	} else {

   461

		/* Note, if the default capacity is selected by the refit capacity

   462

		* callback, then the capacity shown is likely to be incorrect. */

   463

		SetDParam(0, cargo);

   464

		SetDParam(1, AircraftDefaultCargoCapacity(cargo, engine_number));

   465

		SetDParam(2, STR_9842_REFITTABLE);

   466

		DrawString(x, y, STR_PURCHASE_INFO_CAPACITY, 0);

   467

	}

   468

	y += 10;

   469

   470

	/* Running cost */

   471

	SetDParam(0, avi->running_cost * _price.aircraft_running >> 8);

   472

	DrawString(x, y, STR_PURCHASE_INFO_RUNNINGCOST, 0);

   473

	y += 10;

   474

   475

	return y;

   476

}

   477

   478

/**

   479

 * Draw the purchase info details of a vehicle at a given location.

   480

 * @param x,y location where to draw the info

   481

 * @param w how wide are the text allowed to be (size of widget/window to Draw in)

   482

 * @param engine_number the engine of which to draw the info of

   483

 */

   484

void DrawVehiclePurchaseInfo(int x, int y, uint w, EngineID engine_number)

   485

{

   486

	const Engine *e = GetEngine(engine_number);

   487

	YearMonthDay ymd;

   488

	ConvertDateToYMD(e->intro_date, &ymd);

   489

   490

	switch (e->type) {

   491

		case VEH_Train: {

   492

			const RailVehicleInfo *rvi = RailVehInfo(engine_number);

   493

   494

			if (rvi->flags & RVI_WAGON) {

   495

				y = DrawVehiclePurchaseInfo(x, y, engine_number, rvi);

   496

			} else {

   497

				y = DrawVehiclePurchaseInfo(x, y, engine_number, rvi, e);

   498

			}

   499

   500

			/* Cargo type + capacity, or N/A */

   501

			if (rvi->capacity == 0) {

   502

				SetDParam(0, CT_INVALID);

   503

				SetDParam(2, STR_EMPTY);

   504

			} else {