1

/* $Id$ */

     2

     3

/** @file build_vehicle_gui.cpp */

     4

     5

#include "stdafx.h"

     6

#include "openttd.h"

     7

#include "train.h"

     8

#include "roadveh.h"

     9

#include "ship.h"

    10

#include "aircraft.h"

    11

#include "debug.h"

    12

#include "functions.h"

    13

#include "table/sprites.h"

    14

#include "table/strings.h"

    15

#include "window.h"

    16

#include "gui.h"

    17

#include "vehicle.h"

    18

#include "gfx.h"

    19

#include "station.h"

    20

#include "command.h"

    21

#include "engine.h"

    22

#include "player.h"

    23

#include "depot.h"

    24

#include "airport.h"

    25

#include "vehicle_gui.h"

    26

#include "newgrf_engine.h"

    27

#include "date.h"

    28

#include "strings.h"

    29

#include "cargotype.h"

    31

    32

    33

enum BuildVehicleWidgets {

    34

	BUILD_VEHICLE_WIDGET_CLOSEBOX = 0,

    35

	BUILD_VEHICLE_WIDGET_CAPTION,

    36

	BUILD_VEHICLE_WIDGET_SORT_ASSENDING_DESCENDING,

    37

	BUILD_VEHICLE_WIDGET_SORT_TEXT,

    38

	BUILD_VEHICLE_WIDGET_SORT_DROPDOWN,

    39

	BUILD_VEHICLE_WIDGET_LIST,

    40

	BUILD_VEHICLE_WIDGET_SCROLLBAR,

    41

	BUILD_VEHICLE_WIDGET_PANEL,

    42

	BUILD_VEHICLE_WIDGET_BUILD,

    43

	BUILD_VEHICLE_WIDGET_RENAME,

    44

	BUILD_VEHICLE_WIDGET_RESIZE,

    45

	BUILD_VEHICLE_WIDGET_END

    46

};

    47

    48

static const Widget _build_vehicle_widgets[] = {

    49

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

    50

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

    51

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

    52

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

    53

	{    WWT_TEXTBTN,     RESIZE_LR,    14,   228,   239,    14,    25, STR_0225,                STR_SORT_CRITERIA_TIP},

    54

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

    55

	{  WWT_SCROLLBAR,    RESIZE_LRB,    14,   228,   239,    26,   121, 0x0,                     STR_0190_SCROLL_BAR_SCROLLS_LIST },

    56

	{      WWT_PANEL,    RESIZE_RTB,    14,     0,   239,   122,   243, 0x0,                     STR_NULL },

    57

    58

	{ WWT_PUSHTXTBTN,     RESIZE_TB,    14,     0,   114,   244,   255, 0x0,                     STR_NULL },

    59

	{ WWT_PUSHTXTBTN,    RESIZE_RTB,    14,   115,   227,   244,   255, 0x0,                     STR_NULL },

    60

	{  WWT_RESIZEBOX,   RESIZE_LRTB,    14,   228,   239,   244,   255, 0x0,                     STR_RESIZE_BUTTON },

    61

	{   WIDGETS_END},

    62

};

    63

    64

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

    65

static void SetupWindowStrings(Window *w, byte type)

    66

{

    67

	switch (type) {

    68

		case VEH_TRAIN:

    69

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

    70

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

    71

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

    72

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

    73

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

    74

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

    75

			break;

    76

		case VEH_ROAD:

    77

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

    78

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

    79

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

    80

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

    81

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

    82

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

    83

			break;

    84

		case VEH_SHIP:

    85

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

    86

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

    87

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

    88

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

    89

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

    90

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

    91

			break;

    92

		case VEH_AIRCRAFT:

    93

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

    94

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

    95

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

    96

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

    97

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

    98

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

    99

			break;

   100

	}

   101

}

   102

   103

static bool _internal_sort_order; // descending/ascending

   104

   105

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

   106

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

   107

   108

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

   109

{

   110

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

   111

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

   112

	int r = va - vb;

   113

   114

	return _internal_sort_order ? -r : r;

   115

}

   116

   117

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

   118

{

   119

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

   120

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

   121

	const int r = va - vb;

   122

   123

	if (r == 0) {

   124

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

   125

		return EngineNumberSorter(a, b);

   126

	}

   127

	return _internal_sort_order ? -r : r;

   128

}

   129

   130

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

   131

{

   132

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

   133

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

   134

   135

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

   136

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

   137

	int r;

   138

   139

	if (va != last_engine[0]) {

   140

		last_engine[0] = va;

   141

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

   142

	}

   143

   144

	if (vb != last_engine[1]) {

   145

		last_engine[1] = vb;

   146

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

   147

	}

   148

   149

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

   150

   151

	if (r == 0) {

   152

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

   153

		return EngineNumberSorter(a, b);

   154

	}

   155

	return _internal_sort_order ? -r : r;

   156

}

   157

   158

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

   159

{

   160

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

   161

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

   162

	const int r = va - vb;

   163

   164

	if (r == 0) {

   165

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

   166

		return EngineNumberSorter(a, b);

   167

	}

   168

	return _internal_sort_order ? -r : r;

   169

}

   170

   171

/* Train sorting functions */

   172

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

   173

{

   174

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

   175

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

   176

	int r = va - vb;

   177

   178

	return _internal_sort_order ? -r : r;

   179

}

   180

   181

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

   182

{

   183

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

   184

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

   185

	int r = va - vb;

   186

   187

	return _internal_sort_order ? -r : r;

   188

}

   189

   190

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

   191

{

   192

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

   193

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

   194

   195

	int va = rvi_a->power << (rvi_a->railveh_type == RAILVEH_MULTIHEAD ? 1 : 0);

   196

	int vb = rvi_b->power << (rvi_b->railveh_type == RAILVEH_MULTIHEAD ? 1 : 0);

   197

	int r = va - vb;

   198

   199

	return _internal_sort_order ? -r : r;

   200

}

   201

   202

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

   203

{

   204

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

   205

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

   206

	uint32 cost_class_a, cost_class_b;

   207

   208

	switch (rvi_a->running_cost_class) {

   209

		default:

   210

		case 0: cost_class_a = _eco->GetPrice(CEconomy::RUNNING_RAIL0); break;

   211

		case 1: cost_class_a = _eco->GetPrice(CEconomy::RUNNING_RAIL1); break;

   212

		case 2: cost_class_a = _eco->GetPrice(CEconomy::RUNNING_RAIL2); break;

   213

	}

   214

   215

	switch (rvi_b->running_cost_class) {

   216

		default:

   217

		case 0: cost_class_b = _eco->GetPrice(CEconomy::RUNNING_RAIL0); break;

   218

		case 1: cost_class_b = _eco->GetPrice(CEconomy::RUNNING_RAIL1); break;

   219

		case 2: cost_class_b = _eco->GetPrice(CEconomy::RUNNING_RAIL2); break;

   220

	}

   221

   222

	int va = rvi_a->running_cost_base * cost_class_a * (rvi_a->railveh_type == RAILVEH_MULTIHEAD ? 2 : 1);

   223

	int vb = rvi_b->running_cost_base * cost_class_b * (rvi_b->railveh_type == RAILVEH_MULTIHEAD ? 2 : 1);

   224

	int r = va - vb;

   225

   226

	return _internal_sort_order ? -r : r;

   227

}

   228

   229

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

   230

{

   231

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

   232

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

   233

	uint32 cost_class_a, cost_class_b;

   234

   235

	switch (rvi_a->running_cost_class) {

   236

		default:

   237

		case 0: cost_class_a = _eco->GetPrice(CEconomy::RUNNING_RAIL0); break;

   238

		case 1: cost_class_a = _eco->GetPrice(CEconomy::RUNNING_RAIL1); break;

   239

		case 2: cost_class_a = _eco->GetPrice(CEconomy::RUNNING_RAIL2); break;

   240

	}

   241

   242

	switch (rvi_b->running_cost_class) {

   243

		default:

   244

		case 0: cost_class_b = _eco->GetPrice(CEconomy::RUNNING_RAIL0); break;

   245

		case 1: cost_class_b = _eco->GetPrice(CEconomy::RUNNING_RAIL1); break;

   246

		case 2: cost_class_b = _eco->GetPrice(CEconomy::RUNNING_RAIL2); break;

   247

	}

   248

   249

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

   250

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

   251

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

   252

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

   253

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

   254

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

   255

	int va = rvi_a->running_cost_base * cost_class_a / max((uint16)1, rvi_a->power);

   256

	int vb = rvi_b->running_cost_base * cost_class_b / max((uint16)1, rvi_b->power);

   257

	int r = vb - va;

   258

   259

	return _internal_sort_order ? -r : r;

   260

}

   261

   262

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

   263

{

   264

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

   265

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

   266

	int r = ListPositionOfEngine(va) - ListPositionOfEngine(vb);

   267

   268

	return _internal_sort_order ? -r : r;

   269

}

   270

   271

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

   272

{

   273

	EngineID va = *(const EngineID*)a;

   274

	EngineID vb = *(const EngineID*)b;

   275

	int val_a = (RailVehInfo(va)->railveh_type == RAILVEH_WAGON ? 1 : 0);

   276

	int val_b = (RailVehInfo(vb)->railveh_type == RAILVEH_WAGON ? 1 : 0);

   277

	int r = val_a - val_b;

   278

   279

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

   280

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

   281

   282

	return _internal_sort_order ? -r : r;

   283

}

   284

   285

/* Aircraft sorting functions */

   286

   287

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

   288

{

   289

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

   290

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

   291

	int r = va - vb;

   292

   293

	return _internal_sort_order ? -r : r;

   294

}

   295

   296

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

   297

{

   298

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

   299

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

   300

	const int r = va - vb;

   301

   302

	if (r == 0) {

   303

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

   304

		return EngineNumberSorter(a, b);

   305

	}

   306

	return _internal_sort_order ? -r : r;

   307

}

   308

   309

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

   310

{

   311

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

   312

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

   313

	const int r = va - vb;

   314

   315

	if (r == 0) {

   316

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

   317

		return EngineNumberSorter(a, b);

   318

	}

   319

	return _internal_sort_order ? -r : r;

   320

}

   321

   322

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

   323

{

   324

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

   325

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

   326

	const int r = va - vb;

   327

   328

	if (r == 0) {

   329

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

   330

		return EngineNumberSorter(a, b);

   331

	}

   332

	return _internal_sort_order ? -r : r;

   333

}

   334

   335

static EngList_SortTypeFunction * const _sorter[][9] = {{

   336

	/* Trains */

   337

	&TrainEngineNumberSorter,

   338

	&TrainEngineCostSorter,

   339

	&TrainEngineSpeedSorter,

   340

	&TrainEnginePowerSorter,

   341

	&EngineIntroDateSorter,

   342

	&EngineNameSorter,

   343

	&TrainEngineRunningCostSorter,

   344

	&TrainEnginePowerVsRunningCostSorter,

   345

	&EngineReliabilitySorter,

   346

}, {

   347

	/* Road vehicles */

   348

	&EngineNumberSorter,

   349

	&EngineIntroDateSorter,

   350

	&EngineNameSorter,

   351

	&EngineReliabilitySorter,

   352

}, {

   353

	/* Ships */

   354

	&EngineNumberSorter,

   355

	&EngineIntroDateSorter,

   356

	&EngineNameSorter,

   357

	&EngineReliabilitySorter,

   358

}, {

   359

	/* Aircraft */

   360

	&EngineNumberSorter,

   361

	&AircraftEngineCostSorter,

   362

	&AircraftEngineSpeedSorter,

   363

	&EngineIntroDateSorter,

   364

	&EngineNameSorter,

   365

	&AircraftEngineRunningCostSorter,

   366

	&EngineReliabilitySorter,

   367

	&AircraftEngineCargoSorter,

   368

}};

   369

   370

static const StringID _sort_listing[][10] = {{

   371

	/* Trains */

   372

	STR_ENGINE_SORT_ENGINE_ID,

   373

	STR_ENGINE_SORT_COST,

   374

	STR_SORT_BY_MAX_SPEED,

   375

	STR_ENGINE_SORT_POWER,

   376

	STR_ENGINE_SORT_INTRO_DATE,

   377

	STR_SORT_BY_DROPDOWN_NAME,

   378

	STR_ENGINE_SORT_RUNNING_COST,

   379

	STR_ENGINE_SORT_POWER_VS_RUNNING_COST,

   380

	STR_SORT_BY_RELIABILITY,

   381

	INVALID_STRING_ID

   382

}, {

   383

	/* Road vehicles */

   384

	STR_ENGINE_SORT_ENGINE_ID,

   385

	STR_ENGINE_SORT_INTRO_DATE,

   386

	STR_SORT_BY_DROPDOWN_NAME,

   387

	STR_SORT_BY_RELIABILITY,

   388

	INVALID_STRING_ID

   389

}, {

   390

	/* Ships */

   391

	STR_ENGINE_SORT_ENGINE_ID,

   392

	STR_ENGINE_SORT_INTRO_DATE,

   393

	STR_SORT_BY_DROPDOWN_NAME,

   394

	STR_SORT_BY_RELIABILITY,

   395

	INVALID_STRING_ID

   396

}, {

   397

	/* Aircraft */

   398

	STR_ENGINE_SORT_ENGINE_ID,

   399

	STR_ENGINE_SORT_COST,

   400

	STR_SORT_BY_MAX_SPEED,

   401

	STR_ENGINE_SORT_INTRO_DATE,

   402

	STR_SORT_BY_DROPDOWN_NAME,

   403

	STR_ENGINE_SORT_RUNNING_COST,

   404

	STR_SORT_BY_RELIABILITY,

   405

	STR_ENGINE_SORT_CARGO_CAPACITY,

   406

	INVALID_STRING_ID

   407

}};

   408

   409

/* Draw rail wagon specific details */

   410

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

   411

{

   412

	/* Purchase cost */

   414

	DrawString(x, y, STR_PURCHASE_INFO_COST, 0);

   415

	y += 10;

   416

   417

	/* Wagon weight - (including cargo) */

   421

	DrawString(x, y, STR_PURCHASE_INFO_WEIGHT_CWEIGHT, 0);

   422

	y += 10;

   423

   424

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

   432

	}

   433

	return y;

   434

}

   435

   436

/* Draw locomotive specific details */

   437

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

   438

{

   439

	int multihead = (rvi->railveh_type == RAILVEH_MULTIHEAD ? 1 : 0);

   441

   442

	/* Purchase Cost - Engine weight */

   445

	DrawString(x, y, STR_PURCHASE_INFO_COST_WEIGHT, 0);

   446

	y += 10;

   447

   448

	/* Max speed - Engine power */

   451

	DrawString(x, y, STR_PURCHASE_INFO_SPEED_POWER, 0);

   452

	y += 10;

   453

   454

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

   455

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

   457

		DrawString(x, y, STR_PURCHASE_INFO_MAX_TE, 0);

   458

		y += 10;

   459

	}

   460

   461

	uint32 cost_class;

   462

   463

	switch (rvi->running_cost_class) {

   464

		default:

   465

		case 0: cost_class = _eco->GetPrice(CEconomy::RUNNING_RAIL0); break;

   466

		case 1: cost_class = _eco->GetPrice(CEconomy::RUNNING_RAIL1); break;

   467

		case 2: cost_class = _eco->GetPrice(CEconomy::RUNNING_RAIL2); break;

   468

	}

   469

   470

	/* Running cost */

   472

	DrawString(x, y, STR_PURCHASE_INFO_RUNNINGCOST, 0);

   473

	y += 10;

   474

   475

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

   476

	if (rvi->pow_wag_power != 0) {

   477

		SetDParam(0, rvi->pow_wag_power);

   478

		SetDParam(1, rvi->pow_wag_weight);

   479

		DrawString(x, y, STR_PURCHASE_INFO_PWAGPOWER_PWAGWEIGHT, 0);

   480

		y += 10;

   481

	};

   482

   483

	return y;

   484

}

   485

   486

/* Draw road vehicle specific details */

   487

static int DrawRoadVehPurchaseInfo(int x, int y, EngineID engine_number, const RoadVehicleInfo *rvi)

   488

{

   489

	bool refittable = (_engine_info[engine_number].refit_mask != 0);

   490

   491

	/* Purchase cost - Max speed */

   493

	SetDParam(1, rvi->max_speed * 10 / 32);

   494

	DrawString(x, y, STR_PURCHASE_INFO_COST_SPEED, 0);

   495

	y += 10;

   496

   497

	/* Running cost */

   498

	SetDParam(0, rvi->running_cost * _eco->GetPrice(CEconomy::ROADVEH_RUNNING) >> 8);