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 "table/sprites.h"

    13

#include "table/strings.h"

    14

#include "gui.h"

    15

#include "vehicle.h"

    16

#include "articulated_vehicles.h"

    17

#include "textbuf_gui.h"

    18

#include "station.h"

    19

#include "command_func.h"

    20

#include "engine.h"

    21

#include "player.h"

    22

#include "depot.h"

    23

#include "airport.h"

    24

#include "vehicle_gui.h"

    25

#include "newgrf_engine.h"

    26

#include "date.h"

    27

#include "cargotype.h"

    28

#include "group.h"

    29

#include "road_map.h"

    30

#include "strings_func.h"

    32

    33

    34

enum BuildVehicleWidgets {

    35

	BUILD_VEHICLE_WIDGET_CLOSEBOX = 0,

    36

	BUILD_VEHICLE_WIDGET_CAPTION,

    37

	BUILD_VEHICLE_WIDGET_SORT_ASSENDING_DESCENDING,

    38

	BUILD_VEHICLE_WIDGET_SORT_TEXT,

    39

	BUILD_VEHICLE_WIDGET_SORT_DROPDOWN,

    40

	BUILD_VEHICLE_WIDGET_LIST,

    41

	BUILD_VEHICLE_WIDGET_SCROLLBAR,

    42

	BUILD_VEHICLE_WIDGET_PANEL,

    43

	BUILD_VEHICLE_WIDGET_BUILD,

    44

	BUILD_VEHICLE_WIDGET_RENAME,

    45

	BUILD_VEHICLE_WIDGET_RESIZE,

    46

	BUILD_VEHICLE_WIDGET_END

    47

};

    48

    49

static const Widget _build_vehicle_widgets[] = {

    50

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

    51

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

    52

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

    53

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

    54

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

    55

	{     WWT_MATRIX,     RESIZE_RB,    14,     0,   227,    26,    39, 0x101,                   STR_NULL },

    56

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

    57

	{      WWT_PANEL,    RESIZE_RTB,    14,     0,   239,    40,   161, 0x0,                     STR_NULL },

    58

    59

	{ WWT_PUSHTXTBTN,     RESIZE_TB,    14,     0,   114,   162,   173, 0x0,                     STR_NULL },

    60

	{ WWT_PUSHTXTBTN,    RESIZE_RTB,    14,   115,   227,   162,   173, 0x0,                     STR_NULL },

    61

	{  WWT_RESIZEBOX,   RESIZE_LRTB,    14,   228,   239,   162,   173, 0x0,                     STR_RESIZE_BUTTON },

    62

	{   WIDGETS_END},

    63

};

    64

    65

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

    66

static void SetupWindowStrings(Window *w, byte type)

    67

{

    68

	switch (type) {

    69

		case VEH_TRAIN:

    70

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

    71

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

    72

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

    73

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

    74

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

    75

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

    76

			break;

    77

		case VEH_ROAD:

    78

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

    79

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

    80

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

    81

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

    82

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

    83

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

    84

			break;

    85

		case VEH_SHIP:

    86

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

    87

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

    88

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

    89

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

    90

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

    91

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

    92

			break;

    93

		case VEH_AIRCRAFT:

    94

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

    95

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

    96

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

    97

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

    98

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

    99

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

   100

			break;

   101

	}

   102

}

   103

   104

static bool _internal_sort_order; // descending/ascending

   105

   106

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

   107

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

   108

   109

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

   110

{

   111

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

   112

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

   113

	int r = va - vb;

   114

   115

	return _internal_sort_order ? -r : r;

   116

}

   117

   118

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

   119

{

   120

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

   121

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

   122

	const int r = va - vb;

   123

   124

	if (r == 0) {

   125

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

   126

		return EngineNumberSorter(a, b);

   127

	}

   128

	return _internal_sort_order ? -r : r;

   129

}

   130

   131

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

   132

{

   133

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

   134

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

   135

   136

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

   137

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

   138

	int r;

   139

   140

	if (va != last_engine[0]) {

   141

		last_engine[0] = va;

   142

		SetDParam(0, va);

   143

		GetString(last_name[0], STR_ENGINE_NAME, lastof(last_name[0]));

   144

	}

   145

   146

	if (vb != last_engine[1]) {

   147

		last_engine[1] = vb;

   148

		SetDParam(0, vb);

   149

		GetString(last_name[1], STR_ENGINE_NAME, lastof(last_name[1]));

   150

	}

   151

   152

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

   153

   154

	if (r == 0) {

   155

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

   156

		return EngineNumberSorter(a, b);

   157

	}

   158

	return _internal_sort_order ? -r : r;

   159

}

   160

   161

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

   162

{

   163

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

   164

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

   165

	const int r = va - vb;

   166

   167

	if (r == 0) {

   168

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

   169

		return EngineNumberSorter(a, b);

   170

	}

   171

	return _internal_sort_order ? -r : r;

   172

}

   173

   174

/* Train sorting functions */

   175

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

   176

{

   177

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

   178

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

   179

	int r = va - vb;

   180

   181

	return _internal_sort_order ? -r : r;

   182

}

   183

   184

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

   185

{

   186

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

   187

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

   188

	int r = va - vb;

   189

   190

	return _internal_sort_order ? -r : r;

   191

}

   192

   193

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

   194

{

   195

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

   196

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

   197

   198

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

   199

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

   200

	int r = va - vb;

   201

   202

	return _internal_sort_order ? -r : r;

   203

}

   204

   205

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

   206

{

   207

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

   208

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

   209

   210

	Money va = rvi_a->running_cost_base * _price.running_rail[rvi_a->running_cost_class] * (rvi_a->railveh_type == RAILVEH_MULTIHEAD ? 2 : 1);

   211

	Money vb = rvi_b->running_cost_base * _price.running_rail[rvi_b->running_cost_class] * (rvi_b->railveh_type == RAILVEH_MULTIHEAD ? 2 : 1);

   212

	int r = ClampToI32(va - vb);

   213

   214

	return _internal_sort_order ? -r : r;

   215

}

   216

   217

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

   218

{

   219

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

   220

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

   221

   222

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

   223

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

   224

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

   225

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

   226

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

   227

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

   228

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

   229

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

   230

	int r = ClampToI32(vb - va);

   231

   232

	return _internal_sort_order ? -r : r;

   233

}

   234

   235

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

   236

{

   237

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

   238

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

   239

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

   240

   241

	return _internal_sort_order ? -r : r;

   242

}

   243

   244

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

   245

{

   246

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

   247

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

   248

	int r = va - vb;

   249

   250

	if (r == 0) {

   251

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

   252

		return EngineNumberSorter(a, b);

   253

	}

   254

	return _internal_sort_order ? -r : r;

   255

}

   256

   257

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

   258

{

   259

	EngineID va = *(const EngineID*)a;

   260

	EngineID vb = *(const EngineID*)b;

   261

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

   262

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

   263

	int r = val_a - val_b;

   264

   265

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

   266

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

   267

   268

	return _internal_sort_order ? -r : r;

   269

}

   270

   271

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

   272

{

   273

	int va = RoadVehInfo(*(const EngineID*)a)->capacity;

   274

	int vb = RoadVehInfo(*(const EngineID*)b)->capacity;

   275

	int r = va - vb;

   276

   277

	if (r == 0) {

   278

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

   279

		return EngineNumberSorter(a, b);

   280

	}

   281

	return _internal_sort_order ? -r : r;

   282

}

   283

   284

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

   285

{

   286

	int va = ShipVehInfo(*(const EngineID*)a)->capacity;

   287

	int vb = ShipVehInfo(*(const EngineID*)b)->capacity;

   288

	int r = va - vb;

   289

   290

	if (r == 0) {

   291

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

   292

		return EngineNumberSorter(a, b);

   293

	}

   294

	return _internal_sort_order ? -r : r;

   295

}

   296

   297

/* Aircraft sorting functions */

   298

   299

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

   300

{

   301

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

   302

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

   303

	int r = va - vb;

   304

   305

	return _internal_sort_order ? -r : r;

   306

}

   307

   308

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

   309

{

   310

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

   311

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

   312

	const int r = va - vb;

   313

   314

	if (r == 0) {

   315

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

   316

		return EngineNumberSorter(a, b);

   317

	}

   318

	return _internal_sort_order ? -r : r;

   319

}

   320

   321

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

   322

{

   323

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

   324

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

   325

	const int r = va - vb;

   326

   327

	if (r == 0) {

   328

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

   329

		return EngineNumberSorter(a, b);

   330

	}

   331

	return _internal_sort_order ? -r : r;

   332

}

   333

   334

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

   335

{

   336

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

   337

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

   338

	int r = va - vb;

   339

   340

	if (r == 0) {

   341

		/* The planes has the same passenger capacity. Check mail capacity instead */

   342

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

   343

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

   344

		r = va - vb;

   345

   346

		if (r == 0) {

   347

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

   348

			return EngineNumberSorter(a, b);

   349

		}

   350

	}

   351

	return _internal_sort_order ? -r : r;

   352

}

   353

   354

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

   355

	/* Trains */

   356

	&TrainEngineNumberSorter,

   357

	&TrainEngineCostSorter,

   358

	&TrainEngineSpeedSorter,

   359

	&TrainEnginePowerSorter,

   360

	&EngineIntroDateSorter,

   361

	&EngineNameSorter,

   362

	&TrainEngineRunningCostSorter,

   363

	&TrainEnginePowerVsRunningCostSorter,

   364

	&EngineReliabilitySorter,

   365

	&TrainEngineCapacitySorter,

   366

}, {

   367

	/* Road vehicles */

   368

	&EngineNumberSorter,

   369

	&EngineIntroDateSorter,

   370

	&EngineNameSorter,

   371

	&EngineReliabilitySorter,

   372

	&RoadVehEngineCapacitySorter,

   373

}, {

   374

	/* Ships */

   375

	&EngineNumberSorter,

   376

	&EngineIntroDateSorter,

   377

	&EngineNameSorter,

   378

	&EngineReliabilitySorter,

   379

	&ShipEngineCapacitySorter,

   380

}, {

   381

	/* Aircraft */

   382

	&EngineNumberSorter,

   383

	&AircraftEngineCostSorter,

   384

	&AircraftEngineSpeedSorter,

   385

	&EngineIntroDateSorter,

   386

	&EngineNameSorter,

   387

	&AircraftEngineRunningCostSorter,

   388

	&EngineReliabilitySorter,

   389

	&AircraftEngineCargoSorter,

   390

}};

   391

   392

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

   393

	/* Trains */

   394

	STR_ENGINE_SORT_ENGINE_ID,

   395

	STR_ENGINE_SORT_COST,

   396

	STR_SORT_BY_MAX_SPEED,

   397

	STR_ENGINE_SORT_POWER,

   398

	STR_ENGINE_SORT_INTRO_DATE,

   399

	STR_SORT_BY_DROPDOWN_NAME,

   400

	STR_ENGINE_SORT_RUNNING_COST,

   401

	STR_ENGINE_SORT_POWER_VS_RUNNING_COST,

   402

	STR_SORT_BY_RELIABILITY,

   403

	STR_ENGINE_SORT_CARGO_CAPACITY,

   404

	INVALID_STRING_ID

   405

}, {

   406

	/* Road vehicles */

   407

	STR_ENGINE_SORT_ENGINE_ID,

   408

	STR_ENGINE_SORT_INTRO_DATE,

   409

	STR_SORT_BY_DROPDOWN_NAME,

   410

	STR_SORT_BY_RELIABILITY,

   411

	STR_ENGINE_SORT_CARGO_CAPACITY,

   412

	INVALID_STRING_ID

   413

}, {

   414

	/* Ships */

   415

	STR_ENGINE_SORT_ENGINE_ID,

   416

	STR_ENGINE_SORT_INTRO_DATE,

   417

	STR_SORT_BY_DROPDOWN_NAME,

   418

	STR_SORT_BY_RELIABILITY,

   419

	STR_ENGINE_SORT_CARGO_CAPACITY,

   420

	INVALID_STRING_ID

   421

}, {

   422

	/* Aircraft */

   423

	STR_ENGINE_SORT_ENGINE_ID,

   424

	STR_ENGINE_SORT_COST,

   425

	STR_SORT_BY_MAX_SPEED,

   426

	STR_ENGINE_SORT_INTRO_DATE,

   427

	STR_SORT_BY_DROPDOWN_NAME,

   428

	STR_ENGINE_SORT_RUNNING_COST,

   429

	STR_SORT_BY_RELIABILITY,

   430

	STR_ENGINE_SORT_CARGO_CAPACITY,

   431

	INVALID_STRING_ID

   432

}};

   433

   434

/* Draw rail wagon specific details */

   435

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

   436

{

   437

	/* Purchase cost */

   438

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

   439

	DrawString(x, y, STR_PURCHASE_INFO_COST, TC_FROMSTRING);

   440

	y += 10;

   441

   442

	/* Wagon weight - (including cargo) */

   443

	uint weight = GetEngineProperty(engine_number, 0x16, rvi->weight);

   444

	SetDParam(0, weight);

   445

	SetDParam(1, (GetCargo(rvi->cargo_type)->weight * GetEngineProperty(engine_number, 0x14, rvi->capacity) >> 4) + weight);

   446

	DrawString(x, y, STR_PURCHASE_INFO_WEIGHT_CWEIGHT, TC_FROMSTRING);

   447

	y += 10;

   448

   449

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

   450

	if (_patches.wagon_speed_limits) {

   451

		uint max_speed = GetEngineProperty(engine_number, 0x09, rvi->max_speed);

   452

		if (max_speed > 0) {

   453

			SetDParam(0, max_speed * 10 / 16);

   454

			DrawString(x, y, STR_PURCHASE_INFO_SPEED, TC_FROMSTRING);

   455

			y += 10;

   456

		}

   457

	}

   458

	return y;

   459

}

   460

   461

/* Draw locomotive specific details */

   462

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

   463

{

   464

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

   465

	uint weight = GetEngineProperty(engine_number, 0x16, rvi->weight);

   466

   467

	/* Purchase Cost - Engine weight */

   468

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

   469

	SetDParam(1, weight << multihead);

   470

	DrawString(x, y, STR_PURCHASE_INFO_COST_WEIGHT, TC_FROMSTRING);

   471

	y += 10;

   472

   473

	/* Max speed - Engine power */

   474

	SetDParam(0, GetEngineProperty(engine_number, 0x09, rvi->max_speed) * 10 / 16);

   475

	SetDParam(1, GetEngineProperty(engine_number, 0x0B, rvi->power) << multihead);

   476

	DrawString(x, y, STR_PURCHASE_INFO_SPEED_POWER, TC_FROMSTRING);

   477

	y += 10;

   478

   479

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

   480

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

   481

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

   482

		DrawString(x, y, STR_PURCHASE_INFO_MAX_TE, TC_FROMSTRING);

   483

		y += 10;

   484

	}

   485

   486

	/* Running cost */

   487

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

   488

	DrawString(x, y, STR_PURCHASE_INFO_RUNNINGCOST, TC_FROMSTRING);

   489

	y += 10;

   490

   491

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

   492

	if (rvi->pow_wag_power != 0) {

   493

		SetDParam(0, rvi->pow_wag_power);

   494

		SetDParam(1, rvi->pow_wag_weight);

   495

		DrawString(x, y, STR_PURCHASE_INFO_PWAGPOWER_PWAGWEIGHT, TC_FROMSTRING);

   496

		y += 10;