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"

    19

#include "gfx.h"

    20

#include "station.h"

    21

#include "command.h"

    22

#include "engine.h"

    23

#include "player.h"

    24

#include "depot.h"

    25

#include "airport.h"

    26

#include "vehicle_gui.h"

    27

#include "newgrf_engine.h"

    28

#include "date.h"

    29

#include "strings.h"

    30

#include "cargotype.h"

    31

#include "group.h"

    33

    34

    35

enum BuildVehicleWidgets {

    36

	BUILD_VEHICLE_WIDGET_CLOSEBOX = 0,

    37

	BUILD_VEHICLE_WIDGET_CAPTION,

    38

	BUILD_VEHICLE_WIDGET_SORT_ASSENDING_DESCENDING,

    39

	BUILD_VEHICLE_WIDGET_SORT_TEXT,

    40

	BUILD_VEHICLE_WIDGET_SORT_DROPDOWN,

    41

	BUILD_VEHICLE_WIDGET_LIST,

    42

	BUILD_VEHICLE_WIDGET_SCROLLBAR,

    43

	BUILD_VEHICLE_WIDGET_PANEL,

    44

	BUILD_VEHICLE_WIDGET_BUILD,

    45

	BUILD_VEHICLE_WIDGET_RENAME,

    46

	BUILD_VEHICLE_WIDGET_RESIZE,

    47

	BUILD_VEHICLE_WIDGET_END

    48

};

    49

    50

static const Widget _build_vehicle_widgets[] = {

    51

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

    52

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

    53

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

    54

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

    55

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

    56

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

    57

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

    58

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

    59

    60

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

    61

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

    62

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

    63

	{   WIDGETS_END},

    64

};

    65

    66

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

    67

static void SetupWindowStrings(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_ROAD:

    79

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

    80

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

    81

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

    82

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

    83

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

    84

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

    85

			break;

    86

		case VEH_SHIP:

    87

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

    88

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

    89

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

    90

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

    91

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

    92

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

    93

			break;

    94

		case VEH_AIRCRAFT:

    95

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

    96

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

    97

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

    98

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

    99

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

   100

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

   101

			break;

   102

	}

   103

}

   104

   105

static bool _internal_sort_order; // descending/ascending

   106

   107

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

   108

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

   109

   110

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

   111

{

   112

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

   113

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

   114

	int r = va - vb;

   115

   116

	return _internal_sort_order ? -r : r;

   117

}

   118

   119

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

   120

{

   121

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

   122

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

   123

	const int r = va - vb;

   124

   125

	if (r == 0) {

   126

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

   127

		return EngineNumberSorter(a, b);

   128

	}

   129

	return _internal_sort_order ? -r : r;

   130

}

   131

   132

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

   133

{

   134

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

   135

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

   136

   137

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

   138

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

   139

	int r;

   140

   141

	if (va != last_engine[0]) {

   142

		last_engine[0] = va;

   143

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

   144

	}

   145

   146

	if (vb != last_engine[1]) {

   147

		last_engine[1] = vb;

   148

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

   149

	}

   150

   151

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

   152

   153

	if (r == 0) {

   154

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

   155

		return EngineNumberSorter(a, b);

   156

	}

   157

	return _internal_sort_order ? -r : r;

   158

}

   159

   160

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

   161

{

   162

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

   163

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

   164

	const int r = va - vb;

   165

   166

	if (r == 0) {

   167

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

   168

		return EngineNumberSorter(a, b);

   169

	}

   170

	return _internal_sort_order ? -r : r;

   171

}

   172

   173

/* Train sorting functions */

   174

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

   175

{

   176

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

   177

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

   178

	int r = va - vb;

   179

   180

	return _internal_sort_order ? -r : r;

   181

}

   182

   183

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

   184

{

   185

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

   186

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

   187

	int r = va - vb;

   188

   189

	return _internal_sort_order ? -r : r;

   190

}

   191

   192

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

   193

{

   194

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

   195

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

   196

   197

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

   198

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

   199

	int r = va - vb;

   200

   201

	return _internal_sort_order ? -r : r;

   202

}

   203

   204

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

   205

{

   206

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

   207

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

   208

	uint32 cost_class_a, cost_class_b;

   209

   210

	switch (rvi_a->running_cost_class) {

   211

		default:

   212

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

   213

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

   214

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

   215

	}

   216

   217

	switch (rvi_b->running_cost_class) {

   218

		default:

   219

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

   220

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

   221

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

   222

	}

   223

   224

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

   225

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

   226

	int r = va - vb;

   227

   228

	return _internal_sort_order ? -r : r;

   229

}

   230

   231

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

   232

{

   233

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

   234

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

   235

	uint32 cost_class_a, cost_class_b;

   236

   237

	switch (rvi_a->running_cost_class) {

   238

		default:

   239

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

   240

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

   241

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

   242

	}

   243

   244

	switch (rvi_b->running_cost_class) {

   245

		default:

   246

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

   247

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

   248

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

   249

	}

   250

   251

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

   252

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

   253

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

   254

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

   255

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

   256

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

   257

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

   258

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

   259

	int r = vb - va;

   260

   261

	return _internal_sort_order ? -r : r;

   262

}

   263

   264

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

   265

{

   266

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

   267

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

   268

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

   269

   270

	return _internal_sort_order ? -r : r;

   271

}

   272

   286

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

   287

{

   288

	EngineID va = *(const EngineID*)a;

   289

	EngineID vb = *(const EngineID*)b;

   290

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

   291

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

   292

	int r = val_a - val_b;

   293

   294

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

   295

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

   296

   297

	return _internal_sort_order ? -r : r;

   298

}

   299

   326

/* Aircraft sorting functions */

   327

   328

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

   329

{

   330

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

   331

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

   332

	int r = va - vb;

   333

   334

	return _internal_sort_order ? -r : r;

   335

}

   336

   337

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

   338

{

   339

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

   340

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

   341

	const int r = va - vb;

   342

   343

	if (r == 0) {

   344

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

   345

		return EngineNumberSorter(a, b);

   346

	}

   347

	return _internal_sort_order ? -r : r;

   348

}

   349

   350

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

   351

{

   352

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

   353

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

   354

	const int r = va - vb;

   355

   356

	if (r == 0) {

   357

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

   358

		return EngineNumberSorter(a, b);

   359

	}

   360

	return _internal_sort_order ? -r : r;

   361

}

   362

   363

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

   364

{

   368

   369

	if (r == 0) {

   379

	}

   380

	return _internal_sort_order ? -r : r;

   381

}

   382

   384

	/* Trains */

   385

	&TrainEngineNumberSorter,

   386

	&TrainEngineCostSorter,

   387

	&TrainEngineSpeedSorter,

   388

	&TrainEnginePowerSorter,

   389

	&EngineIntroDateSorter,

   390

	&EngineNameSorter,

   391

	&TrainEngineRunningCostSorter,

   392

	&TrainEnginePowerVsRunningCostSorter,

   393

	&EngineReliabilitySorter,

   395

}, {

   396

	/* Road vehicles */

   397

	&EngineNumberSorter,

   398

	&EngineIntroDateSorter,

   399

	&EngineNameSorter,

   400

	&EngineReliabilitySorter,

   402

}, {

   403

	/* Ships */

   404

	&EngineNumberSorter,

   405

	&EngineIntroDateSorter,

   406

	&EngineNameSorter,

   407

	&EngineReliabilitySorter,

   409

}, {

   410

	/* Aircraft */

   411

	&EngineNumberSorter,

   412

	&AircraftEngineCostSorter,

   413

	&AircraftEngineSpeedSorter,

   414

	&EngineIntroDateSorter,

   415

	&EngineNameSorter,

   416

	&AircraftEngineRunningCostSorter,

   417

	&EngineReliabilitySorter,

   418

	&AircraftEngineCargoSorter,

   419

}};

   420

   422

	/* Trains */

   423

	STR_ENGINE_SORT_ENGINE_ID,

   424

	STR_ENGINE_SORT_COST,

   425

	STR_SORT_BY_MAX_SPEED,

   426

	STR_ENGINE_SORT_POWER,

   427

	STR_ENGINE_SORT_INTRO_DATE,

   428

	STR_SORT_BY_DROPDOWN_NAME,

   429

	STR_ENGINE_SORT_RUNNING_COST,

   430

	STR_ENGINE_SORT_POWER_VS_RUNNING_COST,

   431

	STR_SORT_BY_RELIABILITY,

   433

	INVALID_STRING_ID

   434

}, {

   435

	/* Road vehicles */

   436

	STR_ENGINE_SORT_ENGINE_ID,

   437

	STR_ENGINE_SORT_INTRO_DATE,

   438

	STR_SORT_BY_DROPDOWN_NAME,

   439

	STR_SORT_BY_RELIABILITY,

   441

	INVALID_STRING_ID

   442

}, {

   443

	/* Ships */

   444

	STR_ENGINE_SORT_ENGINE_ID,

   445

	STR_ENGINE_SORT_INTRO_DATE,

   446

	STR_SORT_BY_DROPDOWN_NAME,

   447

	STR_SORT_BY_RELIABILITY,

   449

	INVALID_STRING_ID

   450

}, {

   451

	/* Aircraft */

   452

	STR_ENGINE_SORT_ENGINE_ID,

   453

	STR_ENGINE_SORT_COST,

   454

	STR_SORT_BY_MAX_SPEED,

   455

	STR_ENGINE_SORT_INTRO_DATE,

   456

	STR_SORT_BY_DROPDOWN_NAME,

   457

	STR_ENGINE_SORT_RUNNING_COST,

   458

	STR_SORT_BY_RELIABILITY,

   459

	STR_ENGINE_SORT_CARGO_CAPACITY,

   460

	INVALID_STRING_ID

   461

}};

   462

   463

/* Draw rail wagon specific details */

   464

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

   465

{

   466

	/* Purchase cost */

   467

	SetDParam(0, (GetEngineProperty(engine_number, 0x17, rvi->base_cost) * _eco->GetPrice(CEconomy::BUILD_RAILWAGON)) >> 8);

   468

	DrawString(x, y, STR_PURCHASE_INFO_COST, 0);

   469

	y += 10;

   470

   471

	/* Wagon weight - (including cargo) */

   472

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

   473

	SetDParam(0, weight);

   474

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

   475

	DrawString(x, y, STR_PURCHASE_INFO_WEIGHT_CWEIGHT, 0);

   476

	y += 10;

   477

   478

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

   479

	if (_patches.wagon_speed_limits) {

   480

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

   481

		if (max_speed > 0) {

   482

			SetDParam(0, max_speed * 10 / 16);

   483

			DrawString(x, y, STR_PURCHASE_INFO_SPEED, 0);

   484

			y += 10;

   485

		}

   486

	}

   487

	return y;

   488

}

   489

   490

/* Draw locomotive specific details */

   491

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

   492

{

   493

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

   494

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

   495

   496

	/* Purchase Cost - Engine weight */

   497

	SetDParam(0, GetEngineProperty(engine_number, 0x17, rvi->base_cost) * (_eco->GetPrice(CEconomy::BUILD_RAILVEHICLE) >> 3) >> 5);

   498

	SetDParam(1, weight << multihead);