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 "gui.h"

    13

#include "articulated_vehicles.h"

    14

#include "textbuf_gui.h"

    15

#include "station.h"

    16

#include "command_func.h"

    17

#include "engine.h"

    18

#include "player_func.h"

    19

#include "depot.h"

    20

#include "airport.h"

    21

#include "vehicle_gui.h"

    22

#include "newgrf_engine.h"

    23

#include "cargotype.h"

    24

#include "group.h"

    25

#include "road_map.h"

    26

#include "strings_func.h"

    27

#include "window_func.h"

    28

#include "date_func.h"

    29

#include "vehicle_func.h"

    30

#include "settings_type.h"

    31

#include "gfx_func.h"

    32

#include "widgets/dropdown_func.h"

    33

    34

#include "table/sprites.h"

    35

#include "table/strings.h"

    36

    37

struct buildvehicle_d {

    38

	VehicleType vehicle_type;

    39

	union {

    40

		RailTypeByte railtype;

    41

		AirportFTAClass::Flags flags;

    42

		RoadTypes roadtypes;

    43

	} filter;

    44

	byte sel_index;  ///< deprecated value, used for 'unified' ship and road

    45

	bool descending_sort_order;

    46

	byte sort_criteria;

    47

	bool regenerate_list;

    48

	EngineID sel_engine;

    49

	EngineID rename_engine;

    50

	EngineList eng_list;

    51

};

    52

assert_compile(WINDOW_CUSTOM_SIZE >= sizeof(buildvehicle_d));

    53

    54

enum BuildVehicleWidgets {

    55

	BUILD_VEHICLE_WIDGET_CLOSEBOX = 0,

    56

	BUILD_VEHICLE_WIDGET_CAPTION,

    57

	BUILD_VEHICLE_WIDGET_SORT_ASSENDING_DESCENDING,

    58

	BUILD_VEHICLE_WIDGET_SORT_TEXT,

    59

	BUILD_VEHICLE_WIDGET_SORT_DROPDOWN,

    60

	BUILD_VEHICLE_WIDGET_LIST,

    61

	BUILD_VEHICLE_WIDGET_SCROLLBAR,

    62

	BUILD_VEHICLE_WIDGET_PANEL,

    63

	BUILD_VEHICLE_WIDGET_BUILD,

    64

	BUILD_VEHICLE_WIDGET_RENAME,

    65

	BUILD_VEHICLE_WIDGET_RESIZE,

    66

	BUILD_VEHICLE_WIDGET_END

    67

};

    68

    69

static const Widget _build_vehicle_widgets[] = {

    70

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

    71

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

    72

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

    73

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

    74

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

    75

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

    76

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

    77

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

    78

    79

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

    80

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

    81

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

    82

	{   WIDGETS_END},

    83

};

    84

    85

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

    86

static void SetupWindowStrings(Window *w, byte type)

    87

{

    88

	switch (type) {

    89

		case VEH_TRAIN:

    90

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

    91

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

    92

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

    93

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

    94

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

    95

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

    96

			break;

    97

		case VEH_ROAD:

    98

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

    99

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

   100

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

   101

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

   102

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

   103

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

   104

			break;

   105

		case VEH_SHIP:

   106

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

   107

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

   108

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

   109

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

   110

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

   111

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

   112

			break;

   113

		case VEH_AIRCRAFT:

   114

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

   115

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

   116

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

   117

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

   118

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

   119

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

   120

			break;

   121

	}

   122

}

   123

   124

static bool _internal_sort_order; // descending/ascending

   125

   126

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

   127

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

   128

   129

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

   130

{

   131

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

   132

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

   133

	int r = va - vb;

   134

   135

	return _internal_sort_order ? -r : r;

   136

}

   137

   138

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

   139

{

   140

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

   141

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

   142

	const int r = va - vb;

   143

   144

	if (r == 0) {

   145

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

   146

		return EngineNumberSorter(a, b);

   147

	}

   148

	return _internal_sort_order ? -r : r;

   149

}

   150

   151

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

   152

{

   153

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

   154

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

   155

   156

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

   157

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

   158

	int r;

   159

   160

	if (va != last_engine[0]) {

   161

		last_engine[0] = va;

   162

		SetDParam(0, va);

   163

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

   164

	}

   165

   166

	if (vb != last_engine[1]) {

   167

		last_engine[1] = vb;

   168

		SetDParam(0, vb);

   169

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

   170

	}

   171

   172

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

   173

   174

	if (r == 0) {

   175

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

   176

		return EngineNumberSorter(a, b);

   177

	}

   178

	return _internal_sort_order ? -r : r;

   179

}

   180

   181

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

   182

{

   183

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

   184

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

   185

	const int r = va - vb;

   186

   187

	if (r == 0) {

   188

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

   189

		return EngineNumberSorter(a, b);

   190

	}

   191

	return _internal_sort_order ? -r : r;

   192

}

   193

   194

/* Train sorting functions */

   195

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

   196

{

   197

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

   198

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

   199

	int r = va - vb;

   200

   201

	return _internal_sort_order ? -r : r;

   202

}

   203

   204

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

   205

{

   206

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

   207

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

   208

	int r = va - vb;

   209

   210

	return _internal_sort_order ? -r : r;

   211

}

   212

   213

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

   214

{

   215

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

   216

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

   217

   218

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

   219

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

   220

	int r = va - vb;

   221

   222

	return _internal_sort_order ? -r : r;

   223

}

   224

   225

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

   226

{

   227

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

   228

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

   229

   230

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

   231

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

   232

	int r = ClampToI32(va - vb);

   233

   234

	return _internal_sort_order ? -r : r;

   235

}

   236

   237

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

   238

{

   239

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

   240

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

   241

   242

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

   243

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

   244

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

   245

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

   246

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

   247

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

   248

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

   249

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

   250

	int r = ClampToI32(vb - va);

   251

   252

	return _internal_sort_order ? -r : r;

   253

}

   254

   255

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

   256

{

   257

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

   258

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

   259

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

   260

   261

	return _internal_sort_order ? -r : r;

   262

}

   263

   264

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

   265

{

   266

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

   267

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

   268

	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 TrainEnginesThenWagonsSorter(const void *a, const void *b)

   278

{

   279

	EngineID va = *(const EngineID*)a;

   280

	EngineID vb = *(const EngineID*)b;

   281

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

   282

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

   283

	int r = val_a - val_b;

   284

   285

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

   286

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

   287

   288

	return _internal_sort_order ? -r : r;

   289

}

   290

   291

/* Road vehicle sorting functions */

   292

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

   293

{

   294

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

   295

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

   296

	int r = va - vb;

   297

   298

	return _internal_sort_order ? -r : r;

   299

}

   300

   301

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

   302

{

   303

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

   304

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

   305

	int r = va - vb;

   306

   307

	return _internal_sort_order ? -r : r;

   308

}

   309

   310

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

   311

{

   312

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

   313

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

   314

	const int r = va - vb;

   315

   316

	if (r == 0) {

   317

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

   318

		return EngineNumberSorter(a, b);

   319

	}

   320

	return _internal_sort_order ? -r : r;

   321

}

   322

   323

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

   324

{

   325

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

   326

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

   327

	int r = va - vb;

   328

   329

	if (r == 0) {

   330

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

   331

		return EngineNumberSorter(a, b);

   332

	}

   333

	return _internal_sort_order ? -r : r;

   334

}

   335

   336

/* Road vehicle sorting functions */

   337

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

   338

{

   339

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

   340

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

   341

	int r = va - vb;

   342

   343

	return _internal_sort_order ? -r : r;

   344

}

   345

   346

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

   347

{

   348

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

   349

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

   350

	int r = va - vb;

   351

   352

	return _internal_sort_order ? -r : r;

   353

}

   354

   355

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

   356

{

   357

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

   358

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

   359

	const int r = va - vb;

   360

   361

	if (r == 0) {

   362

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

   363

		return EngineNumberSorter(a, b);

   364

	}

   365

	return _internal_sort_order ? -r : r;

   366

}

   367

   368

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

   369

{

   370

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

   371

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

   372

	int r = va - vb;

   373

   374

	if (r == 0) {

   375

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

   376

		return EngineNumberSorter(a, b);

   377

	}

   378

	return _internal_sort_order ? -r : r;

   379

}

   380

   381

/* Aircraft sorting functions */

   382

   383

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

   384

{

   385

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

   386

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

   387

	int r = va - vb;

   388

   389

	return _internal_sort_order ? -r : r;

   390

}

   391

   392

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

   393

{

   394

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

   395

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

   396

	const int r = va - vb;

   397

   398

	if (r == 0) {

   399

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

   400

		return EngineNumberSorter(a, b);

   401

	}

   402

	return _internal_sort_order ? -r : r;

   403

}

   404

   405

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

   406

{

   407

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

   408

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

   409

	const int r = va - vb;

   410

   411

	if (r == 0) {

   412

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

   413

		return EngineNumberSorter(a, b);

   414

	}

   415

	return _internal_sort_order ? -r : r;

   416

}

   417

   418

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

   419

{

   420

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

   421

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

   422

	int r = va - vb;

   423

   424

	if (r == 0) {

   425

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

   426

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

   427

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

   428

		r = va - vb;

   429

   430

		if (r == 0) {

   431

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

   432

			return EngineNumberSorter(a, b);

   433

		}

   434

	}

   435

	return _internal_sort_order ? -r : r;

   436

}

   437

   438

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

   439

	/* Trains */

   440

	&TrainEngineNumberSorter,

   441

	&TrainEngineCostSorter,

   442

	&TrainEngineSpeedSorter,

   443

	&TrainEnginePowerSorter,

   444

	&EngineIntroDateSorter,

   445

	&EngineNameSorter,

   446

	&TrainEngineRunningCostSorter,

   447

	&TrainEnginePowerVsRunningCostSorter,

   448

	&EngineReliabilitySorter,

   449

	&TrainEngineCapacitySorter,

   450

}, {

   451

	/* Road vehicles */

   452

	&EngineNumberSorter,

   453

	&RoadVehEngineCostSorter,

   454

	&RoadVehEngineSpeedSorter,

   455

	&EngineIntroDateSorter,

   456

	&EngineNameSorter,

   457

	&RoadVehEngineRunningCostSorter,

   458

	&EngineReliabilitySorter,

   459

	&RoadVehEngineCapacitySorter,

   460

}, {

   461

	/* Ships */

   462

	&EngineNumberSorter,

   463

	&ShipEngineCostSorter,

   464

	&ShipEngineSpeedSorter,

   465

	&EngineIntroDateSorter,

   466

	&EngineNameSorter,

   467

	&ShipEngineRunningCostSorter,

   468

	&EngineReliabilitySorter,

   469

	&ShipEngineCapacitySorter,

   470

}, {

   471

	/* Aircraft */

   472

	&EngineNumberSorter,

   473

	&AircraftEngineCostSorter,

   474

	&AircraftEngineSpeedSorter,

   475

	&EngineIntroDateSorter,

   476

	&EngineNameSorter,

   477

	&AircraftEngineRunningCostSorter,

   478

	&EngineReliabilitySorter,

   479

	&AircraftEngineCargoSorter,

   480

}};

   481

   482

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

   483

	/* Trains */

   484

	STR_ENGINE_SORT_ENGINE_ID,

   485

	STR_ENGINE_SORT_COST,

   486

	STR_SORT_BY_MAX_SPEED,

   487

	STR_ENGINE_SORT_POWER,

   488

	STR_ENGINE_SORT_INTRO_DATE,

   489

	STR_SORT_BY_DROPDOWN_NAME,

   490

	STR_ENGINE_SORT_RUNNING_COST,

   491

	STR_ENGINE_SORT_POWER_VS_RUNNING_COST,

   492

	STR_SORT_BY_RELIABILITY,

   493

	STR_ENGINE_SORT_CARGO_CAPACITY,

   494

	INVALID_STRING_ID

   495

}, {

   496

	/* Road vehicles */

   497

	STR_ENGINE_SORT_ENGINE_ID,