1

/* $Id$ */

     2

     3

#include "stdafx.h"

     4

#include "openttd.h"

     5

#include "train.h"

     6

#include "roadveh.h"

     7

#include "ship.h"

     8

#include "aircraft.h"

     9

#include "debug.h"

    10

#include "functions.h"

    11

#include "table/sprites.h"

    12

#include "table/strings.h"

    13

#include "window.h"

    14

#include "gui.h"

    15

#include "vehicle.h"

    16

#include "gfx.h"

    17

#include "station.h"

    18

#include "command.h"

    19

#include "engine.h"

    20

#include "player.h"

    21

#include "depot.h"

    22

#include "airport.h"

    23

#include "vehicle_gui.h"

    24

#include "newgrf_engine.h"

    25

#include "date.h"

    26

#include "strings.h"

    27

    28

    29

enum BuildVehicleWidgets {

    30

	BUILD_VEHICLE_WIDGET_CLOSEBOX = 0,

    31

	BUILD_VEHICLE_WIDGET_CAPTION,

    32

	BUILD_VEHICLE_WIDGET_SORT_ASSENDING_DESCENDING,

    33

	BUILD_VEHICLE_WIDGET_SORT_TEXT,

    34

	BUILD_VEHICLE_WIDGET_SORT_DROPDOWN,

    35

	BUILD_VEHICLE_WIDGET_LIST,

    36

	BUILD_VEHICLE_WIDGET_SCROLLBAR,

    37

	BUILD_VEHICLE_WIDGET_PANEL,

    38

	BUILD_VEHICLE_WIDGET_BUILD,

    39

	BUILD_VEHICLE_WIDGET_RENAME,

    40

	BUILD_VEHICLE_WIDGET_RESIZE,

    41

};

    42

    43

static const Widget _build_vehicle_widgets[] = {

    44

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

    45

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

    46

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

    47

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

    48

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

    49

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

    50

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

    51

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

    52

    53

	{ WWT_PUSHTXTBTN,     RESIZE_TB,    14,     0,   114,   224,   235, 0x0,                     STR_NULL },

    54

	{ WWT_PUSHTXTBTN,    RESIZE_RTB,    14,   115,   215,   224,   235, 0x0,                     STR_NULL },

    55

	{  WWT_RESIZEBOX,   RESIZE_LRTB,    14,   216,   227,   224,   235, 0x0,                     STR_RESIZE_BUTTON },

    56

	{   WIDGETS_END},

    57

};

    58

    59

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

    60

static void SetupWindowStrings(Window *w, byte type)

    61

{

    62

	switch (type) {

    63

		case VEH_Train:

    64

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

    65

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

    66

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

    67

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

    68

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

    69

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

    70

			break;

    71

		case VEH_Road:

    72

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

    73

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

    74

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

    75

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

    76

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

    77

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

    78

			break;

    79

		case VEH_Ship:

    80

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

    81

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

    82

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

    83

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

    84

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

    85

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

    86

			break;

    87

		case VEH_Aircraft:

    88

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

    89

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

    90

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

    91

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

    92

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

    93

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

    94

			break;

    95

	}

    96

}

    97

    98

static bool _internal_sort_order; // descending/ascending

    99

   100

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

   101

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

   102

   103

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

   104

{

   105

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

   106

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

   107

	int r = va - vb;

   108

   109

	return _internal_sort_order ? -r : r;

   110

}

   111

   112

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

   113

{

   114

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

   115

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

   116

	const int r = va - vb;

   117

   118

	if (r == 0) {

   119

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

   120

		return EngineNumberSorter(a, b);

   121

	}

   122

	return _internal_sort_order ? -r : r;

   123

}

   124

   125

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

   126

{

   127

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

   128

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

   129

   130

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

   131

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

   132

	int r;

   133

   134

	if (va != last_engine[0]) {

   135

		last_engine[0] = va;

   136

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

   137

	}

   138

   139

	if (vb != last_engine[1]) {

   140

		last_engine[1] = vb;

   141

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

   142

	}

   143

   144

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

   145

   146

	if (r == 0) {

   147

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

   148

		return EngineNumberSorter(a, b);

   149

	}

   150

	return _internal_sort_order ? -r : r;

   151

}

   152

   153

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

   154

{

   155

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

   156

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

   157

	const int r = va - vb;

   158

   159

	if (r == 0) {

   160

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

   161

		return EngineNumberSorter(a, b);

   162

	}

   163

	return _internal_sort_order ? -r : r;

   164

}

   165

   166

/* Train sorting functions */

   167

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

   168

{

   169

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

   170

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

   171

	int r = va - vb;

   172

   173

	return _internal_sort_order ? -r : r;

   174

}

   175

   176

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

   177

{

   178

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

   179

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

   180

	int r = va - vb;

   181

   182

	return _internal_sort_order ? -r : r;

   183

}

   184

   185

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

   186

{

   187

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

   188

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

   189

   190

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

   191

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

   192

	int r = va - vb;

   193

   194

	return _internal_sort_order ? -r : r;

   195

}

   196

   197

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

   198

{

   199

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

   200

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

   201

   202

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

   203

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

   204

	int r = va - vb;

   205

   206

	return _internal_sort_order ? -r : r;

   207

}

   208

   209

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

   210

{

   211

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

   212

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

   213

   214

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

   215

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

   216

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

   217

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

   218

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

   219

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

   220

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

   221

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

   222

	int r = vb - va;

   223

   224

	return _internal_sort_order ? -r : r;

   225

}

   226

   227

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

   228

{

   229

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

   230

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

   231

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

   232

   233

	return _internal_sort_order ? -r : r;

   234

}

   235

   236

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

   237

{

   238

	EngineID va = *(const EngineID*)a;

   239

	EngineID vb = *(const EngineID*)b;

   240

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

   241

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

   242

	int r = val_a - val_b;

   243

   244

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

   245

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

   246

   247

	return _internal_sort_order ? -r : r;

   248

}

   249

   250

/* Aircraft sorting functions */

   251

   252

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

   253

{

   254

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

   255

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

   256

	int r = va - vb;

   257

   258

	return _internal_sort_order ? -r : r;

   259

}

   260

   261

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

   262

{

   263

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

   264

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

   265

	const int r = va - vb;

   266

   267

	if (r == 0) {

   268

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

   269

		return EngineNumberSorter(a, b);

   270

	}

   271

	return _internal_sort_order ? -r : r;

   272

}

   273

   274

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

   275

{

   276

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

   277

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

   278

	const int r = va - vb;

   279

   280

	if (r == 0) {

   281

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

   282

		return EngineNumberSorter(a, b);

   283

	}

   284

	return _internal_sort_order ? -r : r;

   285

}

   286

   287

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

   288

{

   289

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

   290

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

   291

	const int r = va - vb;

   292

   293

	if (r == 0) {

   294

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

   295

		return EngineNumberSorter(a, b);

   296

	}

   297

	return _internal_sort_order ? -r : r;

   298

}

   299

   300

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

   301

	/* Trains */

   302

	&TrainEngineNumberSorter,

   303

	&TrainEngineCostSorter,

   304

	&TrainEngineSpeedSorter,

   305

	&TrainEnginePowerSorter,

   306

	&EngineIntroDateSorter,

   307

	&EngineNameSorter,

   308

	&TrainEngineRunningCostSorter,

   309

	&TrainEnginePowerVsRunningCostSorter,

   310

	&EngineReliabilitySorter,

   311

},{

   312

	/* Road vehicles */

   313

	&EngineNumberSorter,

   314

	&EngineIntroDateSorter,

   315

	&EngineNameSorter,

   316

	&EngineReliabilitySorter,

   317

},{

   318

	/* Ships */

   319

	&EngineNumberSorter,

   320

	&EngineIntroDateSorter,

   321

	&EngineNameSorter,

   322

	&EngineReliabilitySorter,

   323

},{

   324

	/* Aircraft */

   325

	&EngineNumberSorter,

   326

	&AircraftEngineCostSorter,

   327

	&AircraftEngineSpeedSorter,

   328

	&EngineIntroDateSorter,

   329

	&EngineNameSorter,

   330

	&AircraftEngineRunningCostSorter,

   331

	&EngineReliabilitySorter,

   332

	&AircraftEngineCargoSorter,

   333

}};

   334

   335

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

   336

	/* Trains */

   337

	STR_ENGINE_SORT_ENGINE_ID,

   338

	STR_ENGINE_SORT_COST,

   339

	STR_SORT_BY_MAX_SPEED,

   340

	STR_ENGINE_SORT_POWER,

   341

	STR_ENGINE_SORT_INTRO_DATE,

   342

	STR_SORT_BY_DROPDOWN_NAME,

   343

	STR_ENGINE_SORT_RUNNING_COST,

   344

	STR_ENGINE_SORT_POWER_VS_RUNNING_COST,

   345

	STR_SORT_BY_RELIABILITY,

   346

	INVALID_STRING_ID

   347

},{

   348

	/* Road vehicles */

   349

	STR_ENGINE_SORT_ENGINE_ID,

   350

	STR_ENGINE_SORT_INTRO_DATE,

   351

	STR_SORT_BY_DROPDOWN_NAME,

   352

	STR_SORT_BY_RELIABILITY,

   353

	INVALID_STRING_ID

   354

},{

   355

	/* Ships */

   356

	STR_ENGINE_SORT_ENGINE_ID,

   357

	STR_ENGINE_SORT_INTRO_DATE,

   358

	STR_SORT_BY_DROPDOWN_NAME,

   359

	STR_SORT_BY_RELIABILITY,

   360

	INVALID_STRING_ID

   361

},{

   362

	/* Aircraft */

   363

	STR_ENGINE_SORT_ENGINE_ID,

   364

	STR_ENGINE_SORT_COST,

   365

	STR_SORT_BY_MAX_SPEED,

   366

	STR_ENGINE_SORT_INTRO_DATE,

   367

	STR_SORT_BY_DROPDOWN_NAME,

   368

	STR_ENGINE_SORT_RUNNING_COST,

   369

	STR_SORT_BY_RELIABILITY,

   370

	STR_ENGINE_SORT_CARGO_CAPACITY,

   371

	INVALID_STRING_ID

   372

}};

   373

   374

/* Draw rail wagon specific details */

   375

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

   376

{

   377

	/* Purchase cost */

   378

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

   379

	DrawString(x, y, STR_PURCHASE_INFO_COST, 0);

   380

	y += 10;

   381

   382

	/* Wagon weight - (including cargo) */

   383

	SetDParam(0, rvi->weight);

   384

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

   385

	DrawString(x, y, STR_PURCHASE_INFO_WEIGHT_CWEIGHT, 0);

   386

	y += 10;

   387

   388

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

   389

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

   390

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

   391

		DrawString(x,y, STR_PURCHASE_INFO_SPEED, 0);

   392

		y += 10;

   393

	}

   394

	return y;

   395

}

   396

   397

/* Draw locomotive specific details */

   398

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

   399

{

   400

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

   401

   402

	/* Purchase Cost - Engine weight */

   403

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

   404

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

   405

	DrawString(x,y, STR_PURCHASE_INFO_COST_WEIGHT, 0);

   406

	y += 10;

   407

   408

	/* Max speed - Engine power */

   409

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

   410

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

   411

	DrawString(x,y, STR_PURCHASE_INFO_SPEED_POWER, 0);

   412

	y += 10;

   413

   414

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

   415

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

   416

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

   417

		DrawString(x, y, STR_PURCHASE_INFO_MAX_TE, 0);

   418

		y += 10;

   419

	}

   420

   421

	/* Running cost */

   422

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

   423

	DrawString(x,y, STR_PURCHASE_INFO_RUNNINGCOST, 0);

   424

	y += 10;

   425

   426

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

   427

	if (rvi->pow_wag_power != 0) {

   428

		SetDParam(0, rvi->pow_wag_power);

   429

		SetDParam(1, rvi->pow_wag_weight);

   430

		DrawString(x,y, STR_PURCHASE_INFO_PWAGPOWER_PWAGWEIGHT, 0);

   431

		y += 10;

   432

	};

   433

   434

	return y;

   435

}

   436

   437

/* Draw road vehicle specific details */

   438

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

   439

{

   440

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

   441

   442

	/* Purchase cost - Max speed */

   443

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

   444

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

   445

	DrawString(x, y, STR_PURCHASE_INFO_COST_SPEED, 0);

   446

	y += 10;

   447

   448

	/* Running cost */

   449

	SetDParam(0, rvi->running_cost * _price.roadveh_running >> 8);

   450

	DrawString(x, y, STR_PURCHASE_INFO_RUNNINGCOST, 0);

   451

	y += 10;

   452

   453

	/* Cargo type + capacity */

   454

	SetDParam(0, rvi->cargo_type);

   455

	SetDParam(1, rvi->capacity);

   456

	SetDParam(2, refittable ? STR_9842_REFITTABLE : STR_EMPTY);

   457

	DrawString(x, y, STR_PURCHASE_INFO_CAPACITY, 0);

   458

	y += 10;

   459

   460

	return y;

   461

}

   462

   463

/* Draw ship specific details */

   464

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

   465

{

   466

	/* Purchase cost - Max speed */

   467

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

   468

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

   469

	DrawString(x,y, STR_PURCHASE_INFO_COST_SPEED, 0);

   470

	y += 10;

   471

   472

	/* Cargo type + capacity */

   473

	SetDParam(0, svi->cargo_type);

   474

	SetDParam(1, svi->capacity);

   475

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

   476

	DrawString(x,y, STR_PURCHASE_INFO_CAPACITY, 0);

   477

	y += 10;

   478

   479

	/* Running cost */

   480

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

   481

	DrawString(x,y, STR_PURCHASE_INFO_RUNNINGCOST, 0);

   482

	y += 10;

   483

   484

	return y;

   485

}

   486

   487

/* Draw aircraft specific details */

   488

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

   489

{

   490

	CargoID cargo;

   491

   492

	/* Purchase cost - Max speed */

   493

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

   494

	SetDParam(1, avi->max_speed * 8);

   495

	DrawString(x, y, STR_PURCHASE_INFO_COST_SPEED, 0);

   496

	y += 10;

   497

   498

	/* Cargo capacity */

   499

	cargo = FindFirstRefittableCargo(engine_number);

   500

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