1

/* $Id$ */

     2

     3

#include "stdafx.h"

     4

#include "openttd.h"

     5

#include "debug.h"

     6

#include "functions.h"

     7

#include "rail_map.h"

     8

#include "table/sprites.h"

     9

#include "table/strings.h"

    10

#include "map.h"

    11

#include "engine.h"

    12

#include "window.h"

    13

#include "gui.h"

    14

#include "gfx.h"

    15

#include "vehicle.h"

    16

#include "viewport.h"

    17

#include "station.h"

    18

#include "command.h"

    19

#include "player.h"

    20

#include "vehicle_gui.h"

    21

#include "depot.h"

    22

#include "train.h"

    23

#include "newgrf_engine.h"

    24

#include "date.h"

    25

#include "strings.h"

    26

    27

enum BuildTrainWidgets {

    28

	BUILD_TRAIN_WIDGET_CLOSEBOX = 0,

    29

	BUILD_TRAIN_WIDGET_CAPTION,

    30

	BUILD_TRAIN_WIDGET_SORT_ASCENDING_DESCENDING,

    31

	BUILD_TRAIN_WIDGET_SORT_TEXT,

    32

	BUILD_TRAIN_WIDGET_SORT_DROPDOWN,

    33

	BUILD_TRAIN_WIDGET_LIST,

    34

	BUILD_TRAIN_WIDGET_SCROLLBAR,

    35

	BUILD_TRAIN_WIDGET_PANEL,

    36

	BUILD_TRAIN_WIDGET_BUILD,

    37

	BUILD_TRAIN_WIDGET_RENAME,

    38

	BUILD_TRAIN_WIDGET_RESIZE,

    39

};

    40

    41

static const Widget _new_rail_vehicle_widgets[] = {

    42

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

    43

	{    WWT_CAPTION,   RESIZE_NONE,    14,    11,   227,     0,    13, STR_JUST_STRING,        STR_018C_WINDOW_TITLE_DRAG_THIS},

    44

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

    45

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

    46

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

    47

	{     WWT_MATRIX, RESIZE_BOTTOM,    14,     0,   215,    26,   137, 0x801,                  STR_8843_TRAIN_VEHICLE_SELECTION},

    48

	{  WWT_SCROLLBAR, RESIZE_BOTTOM,    14,   216,   227,    26,   137, 0x0,                    STR_0190_SCROLL_BAR_SCROLLS_LIST},

    49

	{      WWT_PANEL,     RESIZE_TB,    14,     0,   227,   138,   239, 0x0,                    STR_NULL},

    50

	{ WWT_PUSHTXTBTN,     RESIZE_TB,    14,     0,   107,   240,   251, STR_881F_BUILD_VEHICLE, STR_8844_BUILD_THE_HIGHLIGHTED_TRAIN},

    51

	{ WWT_PUSHTXTBTN,     RESIZE_TB,    14,   108,   215,   240,   251, STR_8820_RENAME,        STR_8845_RENAME_TRAIN_VEHICLE_TYPE},

    52

	{  WWT_RESIZEBOX,     RESIZE_TB,    14,   216,   227,   240,   251, 0x0,                    STR_RESIZE_BUTTON},

    53

	{   WIDGETS_END},

    54

};

    55

    56

static bool _internal_sort_order; // false = ascending, true = descending

    57

static byte _last_sort_criteria = 0;

    58

static bool _last_sort_order = false;

    59

    60

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

    61

{

    62

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

    63

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

    64

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

    65

    66

	return _internal_sort_order ? -r : r;

    67

}

    68

    69

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

    70

{

    71

	EngineID va = *(const EngineID*)a;

    72

	EngineID vb = *(const EngineID*)b;

    73

	int val_a = ((RailVehInfo(va)->flags & RVI_WAGON) != 0) ? 1 : 0;

    74

	int val_b = ((RailVehInfo(vb)->flags & RVI_WAGON) != 0) ? 1 : 0;

    75

	int r = val_a - val_b;

    76

    77

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

    78

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

    79

    80

	return _internal_sort_order ? -r : r;

    81

}

    82

    83

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

    84

{

    85

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

    86

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

    87

	int r = va - vb;

    88

    89

	return _internal_sort_order ? -r : r;

    90

}

    91

    92

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

    93

{

    94

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

    95

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

    96

	int r = va - vb;

    97

    98

	return _internal_sort_order ? -r : r;

    99

}

   100

   101

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

   102

{

   103

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

   104

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

   105

   106

	int va = rvi_a->power << (rvi_a->flags & RVI_MULTIHEAD ? 1 : 0);

   107

	int vb = rvi_b->power << (rvi_b->flags & RVI_MULTIHEAD ? 1 : 0);

   108

	int r = va - vb;

   109

   110

	return _internal_sort_order ? -r : r;

   111

}

   112

   113

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

   114

{

   115

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

   116

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

   117

	int r = va - vb;

   118

   119

	return _internal_sort_order ? -r : r;

   120

}

   121

   122

static EngineID _last_engine; // cached vehicle to hopefully speed up name-sorting

   123

   124

static char _bufcache[64]; // used together with _last_vehicle to hopefully speed up stringsorting

   125

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

   126

{

   127

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

   128

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

   129

	char buf1[64];

   130

	int r;

   131

   132

	GetString(buf1, GetCustomEngineName(va), lastof(buf1));

   133

   134

	if (vb != _last_engine) {

   135

		_last_engine = vb;

   136

		_bufcache[0] = '\0';

   137

   138

		GetString(_bufcache, GetCustomEngineName(vb), lastof(_bufcache));

   139

	}

   140

   141

	r =  strcasecmp(buf1, _bufcache); // sort by name

   142

   143

	return _internal_sort_order ? -r : r;

   144

}

   145

   146

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

   147

{

   148

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

   149

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

   150

   151

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

   152

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

   153

	int r = va - vb;

   154

   155

	return _internal_sort_order ? -r : r;

   156

}

   157

   158

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

   159

{

   160

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

   161

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

   162

   163

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

   164

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

   165

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

   166

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

   167

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

   168

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

   169

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

   170

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

   171

	int r = vb - va;

   172

   173

	return _internal_sort_order ? -r : r;

   174

}

   175

   176

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

   177

{

   178

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

   179

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

   180

	int r = va - vb;

   181

   182

	return _internal_sort_order ? -r : r;

   183

}

   184

   185

static EngList_SortTypeFunction * const _engine_sorter[] = {

   186

	&TrainEngineNumberSorter,

   187

	&TrainEngineCostSorter,

   188

	&TrainEngineSpeedSorter,

   189

	&TrainEnginePowerSorter,

   190

	&TrainEngineIntroDateSorter,

   191

	&TrainEngineNameSorter,

   192

	&TrainEngineRunningCostSorter,

   193

	&TrainEnginePowerVsRunningCostSorter,

   194

	&TrainEngineReliabilitySorter,

   195

};

   196

   197

static const StringID _engine_sort_listing[] = {

   198

	STR_ENGINE_SORT_ENGINE_ID,

   199

	STR_ENGINE_SORT_COST,

   200

	STR_SORT_BY_MAX_SPEED,

   201

	STR_ENGINE_SORT_POWER,

   202

	STR_ENGINE_SORT_INTRO_DATE,

   203

	STR_SORT_BY_DROPDOWN_NAME,

   204

	STR_ENGINE_SORT_RUNNING_COST,

   205

	STR_ENGINE_SORT_POWER_VS_RUNNING_COST,

   206

	STR_SORT_BY_RELIABILITY,

   207

	INVALID_STRING_ID

   208

};

   209

   210

/**

   211

 * Draw the purchase info details of train engine at a given location.

   212

 * @param x,y location where to draw the info

   213

 * @param engine_number the engine of which to draw the info of

   214

 */

   215

void DrawTrainEnginePurchaseInfo(int x, int y, uint w, EngineID engine_number)

   216

{

   217

	const RailVehicleInfo *rvi = RailVehInfo(engine_number);

   218

	const Engine *e = GetEngine(engine_number);

   219

	int multihead = (rvi->flags&RVI_MULTIHEAD?1:0);

   220

	YearMonthDay ymd;

   221

	ConvertDateToYMD(e->intro_date, &ymd);

   222

   223

	/* Purchase Cost - Engine weight */

   224

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

   225

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

   226

	DrawString(x,y, STR_PURCHASE_INFO_COST_WEIGHT, 0);

   227

	y += 10;

   228

   229

	/* Max speed - Engine power */

   230

	SetDParam(0, rvi->max_speed);

   231

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

   232

	DrawString(x,y, STR_PURCHASE_INFO_SPEED_POWER, 0);

   233

	y += 10;

   234

   235

	/* Running cost */

   236

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

   237

	DrawString(x,y, STR_PURCHASE_INFO_RUNNINGCOST, 0);

   238

	y += 10;

   239

   240

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

   241

	if (rvi->pow_wag_power != 0) {

   242

		SetDParam(0, rvi->pow_wag_power);

   243

		SetDParam(1, rvi->pow_wag_weight);

   244

		DrawString(x,y, STR_PURCHASE_INFO_PWAGPOWER_PWAGWEIGHT, 0);

   245

		y += 10;

   246

	};

   247

   248

	/* Cargo type + capacity, or N/A */

   249

	if (rvi->capacity == 0) {

   250

		SetDParam(0, CT_INVALID);

   251

		SetDParam(2, STR_EMPTY);

   252

	} else {

   253

		SetDParam(0, rvi->cargo_type);

   254

		SetDParam(1, (rvi->capacity * (CountArticulatedParts(engine_number) + 1)) << multihead);

   255

		SetDParam(2, STR_9842_REFITTABLE);

   256

	}

   257

	DrawString(x,y, STR_PURCHASE_INFO_CAPACITY, 0);

   258

	y += 10;

   259

   260

	/* Design date - Life length */

   261

	SetDParam(0, ymd.year);

   262

	SetDParam(1, e->lifelength);

   263

	DrawString(x,y, STR_PURCHASE_INFO_DESIGNED_LIFE, 0);

   264

	y += 10;

   265

   266

	/* Reliability */

   267

	SetDParam(0, e->reliability * 100 >> 16);

   268

	DrawString(x,y, STR_PURCHASE_INFO_RELIABILITY, 0);

   269

	y += 10;

   270

   271

	/* Additional text from NewGRF */

   272

	y += ShowAdditionalText(x, y, w, engine_number);

   273

	if (rvi->capacity > 0) y += ShowRefitOptionsList(x, y, w, engine_number);

   274

}

   275

   276

/**

   277

 * Draw the purchase info details of a train wagon at a given location.

   278

 * @param x,y location where to draw the info

   279

 * @param engine_number the engine of which to draw the info of

   280

 */

   281

void DrawTrainWagonPurchaseInfo(int x, int y, uint w, EngineID engine_number)

   282

{

   283

	const RailVehicleInfo *rvi = RailVehInfo(engine_number);

   284

	bool refittable = (EngInfo(engine_number)->refit_mask != 0);

   285

   286

	/* Purchase cost */

   287

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

   288

	DrawString(x, y, STR_PURCHASE_INFO_COST, 0);

   289

	y += 10;

   290

   291

	/* Wagon weight - (including cargo) */

   292

	SetDParam(0, rvi->weight);

   293

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

   294

	DrawString(x, y, STR_PURCHASE_INFO_WEIGHT_CWEIGHT, 0);

   295

	y += 10;

   296

   297

	/* Cargo type + capacity, or N/A */

   298

	if (rvi->capacity == 0) {

   299

		SetDParam(0, CT_INVALID);

   300

		SetDParam(2, STR_EMPTY);

   301

	} else {

   302

		SetDParam(0, rvi->cargo_type);

   303

		SetDParam(1, rvi->capacity * (CountArticulatedParts(engine_number) + 1));

   304

		SetDParam(2, refittable ? STR_9842_REFITTABLE : STR_EMPTY);

   305

	}

   306

	DrawString(x, y, STR_PURCHASE_INFO_CAPACITY, 0);

   307

	y += 10;

   308

   309

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

   310

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

   311

		SetDParam(0, rvi->max_speed);

   312

		DrawString(x,y, STR_PURCHASE_INFO_SPEED, 0);

   313

		y += 10;

   314

	}

   315

   316

	/* Additional text from NewGRF */

   317

	y += ShowAdditionalText(x, y, w, engine_number);

   318

	y += ShowRefitOptionsList(x, y, w, engine_number);

   319

}

   320

   321

void CcBuildWagon(bool success, TileIndex tile, uint32 p1, uint32 p2)

   322

{

   323

	Vehicle *v, *found;

   324

   325

	if (!success) return;

   326

   327

	// find a locomotive in the depot.

   328

	found = NULL;

   329

	FOR_ALL_VEHICLES(v) {

   330

		if (v->type == VEH_Train && IsFrontEngine(v) &&

   331

				v->tile == tile &&

   332

				v->u.rail.track == 0x80) {

   333

			if (found != NULL) return; // must be exactly one.

   334

			found = v;

   335

		}

   336

	}

   337

   338

	// if we found a loco,

   339

	if (found != NULL) {

   340

		found = GetLastVehicleInChain(found);

   341

		// put the new wagon at the end of the loco.

   342

		DoCommandP(0, _new_vehicle_id | (found->index << 16), 0, NULL, CMD_MOVE_RAIL_VEHICLE);

   343

		RebuildVehicleLists();

   344

	}

   345

}

   346

   347

void CcBuildLoco(bool success, TileIndex tile, uint32 p1, uint32 p2)

   348

{

   349

	const Vehicle *v;

   350

   351

	if (!success) return;

   352

   353

	v = GetVehicle(_new_vehicle_id);

   354

	if (tile == _backup_orders_tile) {

   355

		_backup_orders_tile = 0;

   356

		RestoreVehicleOrders(v, _backup_orders_data);

   357

	}

   358

	ShowTrainViewWindow(v);

   359

}

   360

   361

void CcCloneTrain(bool success, TileIndex tile, uint32 p1, uint32 p2)

   362

{

   363

	if (success) ShowTrainViewWindow(GetVehicle(_new_vehicle_id));

   364

}

   365

   366

static void engine_drawing_loop(const EngineList *engines, int x, int *y, EngineID sel, EngineID position, int16 show_max)

   367

{

   368

	int count = min(EngList_Count(engines), show_max);

   369

	for (; position < count; *y += 14, position++) {

   370

		EngineID id = (*engines)[position];

   371

		DrawString(x + 59, *y + 2, GetCustomEngineName(id), sel == id ? 0xC : 0x10);

   372

		DrawTrainEngine(x + 29, *y + 6, id, GetEnginePalette(id, _local_player));

   373

	}

   374

}

   375

   376

static void GenerateBuildList(Window *w)

   377

{

   378

	EngineID eid, sel_id;

   379

	int num_engines = 0;

   380

	int num_wagons  = 0;

   381

	buildvehicle_d *bv = &WP(w, buildvehicle_d);

   382

   383

	bv->filter.railtype = (w->window_number == 0) ? RAILTYPE_END : GetRailType(w->window_number);

   384

   385

	EngList_RemoveAll(&bv->eng_list);

   386

   387

	/* Make list of all available train engines and wagons.

   388

	 * Also check to see if the previously selected engine is still available,

   389

	 * and if not, reset selection to INVALID_ENGINE. This could be the case

   390

	 * when engines become obsolete and are removed */

   391

	for (sel_id = INVALID_ENGINE, eid = 0; eid < NUM_TRAIN_ENGINES; eid++) {

   392

		const Engine *e = GetEngine(eid);

   393

		const RailVehicleInfo *rvi = RailVehInfo(eid);

   394

   395

		if (bv->filter.railtype != RAILTYPE_END && !HasPowerOnRail(e->railtype, bv->filter.railtype)) continue;

   396

		if (!IsEngineBuildable(eid, VEH_Train, _local_player)) continue;

   397

   398

		EngList_Add(&bv->eng_list, eid);

   399

		if ((rvi->flags & RVI_WAGON) == 0) {

   400

			num_engines++;

   401

		} else {

   402

			num_wagons++;

   403

		}

   404

   405

		if (eid == bv->sel_engine) sel_id = eid;

   406

	}

   407

   408

	bv->sel_engine = sel_id;

   409

   410

	// make engines first, and then wagons, sorted by ListPositionOfEngine()

   411

	_internal_sort_order = false;

   412

	EngList_Sort(&bv->eng_list, TrainEnginesThenWagonsSorter);

   413

   414

	// and then sort engines

   415

	_internal_sort_order = bv->descending_sort_order;

   416

	EngList_SortPartial(&bv->eng_list, _engine_sorter[bv->sort_criteria], 0, num_engines);

   417

   418

	// and finally sort wagons

   419

	EngList_SortPartial(&bv->eng_list, _engine_sorter[bv->sort_criteria], num_engines, num_wagons);

   420

}

   421

   422

static void DrawTrainBuildWindow(Window *w)

   423

{

   424

	const buildvehicle_d *bv = &WP(w, buildvehicle_d);

   425

	int x = 1;

   426

	int y = 27;

   427

	EngineID selected_id = bv->sel_engine;

   428

	int max = w->vscroll.pos + w->vscroll.cap;

   429

   430

	SetWindowWidgetDisabledState(w, BUILD_TRAIN_WIDGET_BUILD, w->window_number == 0); // Disable unless we got a depot to build in

   431

   432

	SetVScrollCount(w, EngList_Count(&bv->eng_list));

   433

	SetDParam(0, bv->filter.railtype + STR_881C_NEW_RAIL_VEHICLES);

   434

	DrawWindowWidgets(w);

   435

   436

	/* Draw the engines */

   437

	engine_drawing_loop(&bv->eng_list, x, &y, selected_id, w->vscroll.pos, max);

   438

   439

	if (selected_id != INVALID_ENGINE) {

   440

		const RailVehicleInfo *rvi = RailVehInfo(selected_id);

   441

		const Widget *wi = &w->widget[BUILD_TRAIN_WIDGET_PANEL];

   442

   443

		if (rvi->flags & RVI_WAGON) {

   444

			DrawTrainWagonPurchaseInfo(2, wi->top + 1, wi->right - wi->left - 2, selected_id);

   445

		} else {

   446

			DrawTrainEnginePurchaseInfo(2, wi->top + 1, wi->right - wi->left - 2, selected_id);

   447

		}

   448

	}

   449

	DrawString(85, 15, _engine_sort_listing[bv->sort_criteria], 0x10);

   450

	DoDrawString(bv->descending_sort_order ? DOWNARROW : UPARROW, 69, 15, 0x10);

   451

}

   452

   453

static void NewRailVehicleWndProc(Window *w, WindowEvent *e)

   454

{

   455

	buildvehicle_d *bv = &WP(w, buildvehicle_d);

   456

	switch (e->event) {

   457

		case WE_CREATE:

   458

			EngList_Create(&bv->eng_list);

   459

			bv->sel_engine            = INVALID_ENGINE;

   460

			bv->sort_criteria         = _last_sort_criteria;

   461

			bv->descending_sort_order = _last_sort_order;

   462

			GenerateBuildList(w);

   463

			/* Select the first engine in the list as default when opening the window */

   464

			if (EngList_Count(&bv->eng_list) > 0) bv->sel_engine = bv->eng_list[0];

   465

			break;

   466

   467

		case WE_INVALIDATE_DATA:

   468

			GenerateBuildList(w);

   469

			break;

   470

   471

		case WE_DESTROY:

   472

			EngList_Destroy(&bv->eng_list);

   473

			break;

   474

   475

		case WE_PAINT:

   476

			DrawTrainBuildWindow(w);

   477

			break;

   478

   479

		case WE_CLICK: {

   480

			switch (e->we.click.widget) {

   481

				case BUILD_TRAIN_WIDGET_SORT_ASCENDING_DESCENDING:

   482

					bv->descending_sort_order ^= true;

   483

					_last_sort_order = bv->descending_sort_order;

   484

					GenerateBuildList(w);

   485

					SetWindowDirty(w);