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

typedef 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

} BuildTrainWidget;

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

    61

{

    62

	EngineID va = *(const EngineID*)a;

    63

	EngineID vb = *(const EngineID*)b;

    64

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

    65

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

    66

	int r = val_a - val_b;

    67

	return _internal_sort_order ? -r : r;

    68

}

    69

    70

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

    71

{

    72

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

    73

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

    74

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

    75

    76

	return _internal_sort_order ? -r : r;

    77

}

    78

    79

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

    80

{

    81

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

    82

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

    83

	int r = va - vb;

    84

    85

	return _internal_sort_order ? -r : r;

    86

}

    87

    88

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

    89

{

    90

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

    91

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

    92

	const int r = va - vb;

    93

    94

	if (r == 0) {

    95

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

    96

		return TrainEngineNumberSorter(a, b);

    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

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

   107

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

   108

	const int r = va - vb;

   109

   110

	if (r == 0) {

   111

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

   112

		return TrainEngineNumberSorter(a, b);

   113

	}

   114

	return _internal_sort_order ? -r : r;

   115

}

   116

   117

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

   118

{

   119

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

   120

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

   121

	const int r = va - vb;

   122

   123

	if (r == 0) {

   124

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

   125

		return TrainEngineNumberSorter(a, b);

   126

	}

   127

	return _internal_sort_order ? -r : r;

   128

}

   129

   130

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

   131

   132

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

   133

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

   134

{

   135

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

   136

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

   137

	char buf1[64];

   138

	int r;

   139

   140

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

   141

   142

	if (vb != _last_engine) {

   143

		_last_engine = vb;

   144

		_bufcache[0] = '\0';

   145

   146

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

   147

	}

   148

   149

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

   150

   151

	if (r == 0) {

   152

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

   153

		return TrainEngineNumberSorter(a, b);

   154

	}

   155

   156

	return _internal_sort_order ? -r : r;

   157

}

   158

   159

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

   160

{

   161

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

   162

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

   163

   164

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

   165

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

   166

	const int r = va - vb;

   167

   168

	if (r == 0) {

   169

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

   170

		return TrainEngineNumberSorter(a, b);

   171

	}

   172

	return _internal_sort_order ? -r : r;

   173

}

   174

   175

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

   176

{

   177

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

   178

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

   179

   180

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

   181

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

   182

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

   183

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

   184

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

   185

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

   186

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

   187

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

   188

	const int r = vb - va;

   189

   190

	if (r == 0) {

   191

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

   192

		return TrainEngineNumberSorter(a, b);

   193

	}

   194

	return _internal_sort_order ? -r : r;

   195

}

   196

   197

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

   198

{

   199

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

   200

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

   201

	const int r = va - vb;

   202

   203

	if (r == 0) {

   204

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

   205

		return TrainEngineNumberSorter(a, b);

   206

	}

   207

	return _internal_sort_order ? -r : r;

   208

}

   209

   210

static EngList_SortTypeFunction * const _engine_sorter[] = {

   211

	&TrainEngineNumberSorter,

   212

	&TrainEngineCostSorter,

   213

	&TrainEngineSpeedSorter,

   214

	&TrainEnginePowerSorter,

   215

	&TrainEngineIntroDateSorter,

   216

	&TrainEngineNameSorter,

   217

	&TrainEngineRunningCostSorter,

   218

	&TrainEnginePowerVsRunningCostSorter,

   219

	&TrainEngineReliabilitySorter,

   220

};

   221

   222

static const StringID _engine_sort_listing[] = {

   223

	STR_ENGINE_SORT_ENGINE_ID,

   224

	STR_ENGINE_SORT_COST,

   225

	STR_SORT_BY_MAX_SPEED,

   226

	STR_ENGINE_SORT_POWER,

   227

	STR_ENGINE_SORT_INTRO_DATE,

   228

	STR_SORT_BY_DROPDOWN_NAME,

   229

	STR_ENGINE_SORT_RUNNING_COST,

   230

	STR_ENGINE_SORT_POWER_VS_RUNNING_COST,

   231

	STR_SORT_BY_RELIABILITY,

   232

	INVALID_STRING_ID

   233

};

   234

   235

/**

   236

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

   237

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

   238

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

   239

 */

   240

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

   241

{

   242

	const RailVehicleInfo *rvi = RailVehInfo(engine_number);

   243

	const Engine *e = GetEngine(engine_number);

   244

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

   245

	YearMonthDay ymd;

   246

	ConvertDateToYMD(e->intro_date, &ymd);

   247

   248

	/* Purchase Cost - Engine weight */

   249

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

   250

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

   251

	DrawString(x,y, STR_PURCHASE_INFO_COST_WEIGHT, 0);

   252

	y += 10;

   253

   254

	/* Max speed - Engine power */

   255

	SetDParam(0, rvi->max_speed);

   256

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

   257

	DrawString(x,y, STR_PURCHASE_INFO_SPEED_POWER, 0);

   258

	y += 10;

   259

   260

	/* Running cost */

   261

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

   262

	DrawString(x,y, STR_PURCHASE_INFO_RUNNINGCOST, 0);

   263

	y += 10;

   264

   265

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

   266

	if (rvi->pow_wag_power != 0) {

   267

		SetDParam(0, rvi->pow_wag_power);

   268

		SetDParam(1, rvi->pow_wag_weight);

   269

		DrawString(x,y, STR_PURCHASE_INFO_PWAGPOWER_PWAGWEIGHT, 0);

   270

		y += 10;

   271

	};

   272

   273

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

   274

	if (rvi->capacity == 0) {

   275

		SetDParam(0, CT_INVALID);

   276

		SetDParam(2, STR_EMPTY);

   277

	} else {

   278

		SetDParam(0, rvi->cargo_type);

   279

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

   280

		SetDParam(2, STR_9842_REFITTABLE);

   281

	}

   282

	DrawString(x,y, STR_PURCHASE_INFO_CAPACITY, 0);

   283

	y += 10;

   284

   285

	/* Design date - Life length */

   286

	SetDParam(0, ymd.year);

   287

	SetDParam(1, e->lifelength);

   288

	DrawString(x,y, STR_PURCHASE_INFO_DESIGNED_LIFE, 0);

   289

	y += 10;

   290

   291

	/* Reliability */

   292

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

   293

	DrawString(x,y, STR_PURCHASE_INFO_RELIABILITY, 0);

   294

	y += 10;

   295

   296

	/* Additional text from NewGRF */

   297

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

   298

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

   299

}

   300

   301

/**

   302

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

   303

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

   304

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

   305

 */

   306

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

   307

{

   308

	const RailVehicleInfo *rvi = RailVehInfo(engine_number);

   309

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

   310

   311

	/* Purchase cost */

   312

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

   313

	DrawString(x, y, STR_PURCHASE_INFO_COST, 0);

   314

	y += 10;

   315

   316

	/* Wagon weight - (including cargo) */

   317

	SetDParam(0, rvi->weight);

   318

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

   319

	DrawString(x, y, STR_PURCHASE_INFO_WEIGHT_CWEIGHT, 0);

   320

	y += 10;

   321

   322

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

   323

	if (rvi->capacity == 0) {

   324

		SetDParam(0, CT_INVALID);

   325

		SetDParam(2, STR_EMPTY);

   326

	} else {

   327

		SetDParam(0, rvi->cargo_type);

   328

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

   329

		SetDParam(2, refittable ? STR_9842_REFITTABLE : STR_EMPTY);

   330

	}

   331

	DrawString(x, y, STR_PURCHASE_INFO_CAPACITY, 0);

   332

	y += 10;

   333

   334

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

   335

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

   336

		SetDParam(0, rvi->max_speed);

   337

		DrawString(x,y, STR_PURCHASE_INFO_SPEED, 0);

   338

		y += 10;

   339

	}

   340

   341

	/* Additional text from NewGRF */

   342

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

   343

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

   344

}

   345

   346

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

   347

{

   348

	Vehicle *v, *found;

   349

   350

	if (!success) return;

   351

   352

	// find a locomotive in the depot.

   353

	found = NULL;

   354

	FOR_ALL_VEHICLES(v) {

   355

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

   356

				v->tile == tile &&

   357

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

   358

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

   359

			found = v;

   360

		}

   361

	}

   362

   363

	// if we found a loco,

   364

	if (found != NULL) {

   365

		found = GetLastVehicleInChain(found);

   366

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

   367

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

   368

		RebuildVehicleLists();

   369

	}

   370

}

   371

   372

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

   373

{

   374

	const Vehicle *v;

   375

   376

	if (!success) return;

   377

   378

	v = GetVehicle(_new_vehicle_id);

   379

	if (tile == _backup_orders_tile) {

   380

		_backup_orders_tile = 0;

   381

		RestoreVehicleOrders(v, _backup_orders_data);

   382

	}

   383

	ShowTrainViewWindow(v);

   384

}

   385

   386

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

   387

{

   388

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

   389

}

   390

   391

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

   392

{

   393

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

   394

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

   395

		EngineID id = (*engines)[position];

   396

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

   397

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

   398

	}

   399

}

   400

   401

static void GenerateBuildList(Window *w)

   402

{

   403

	EngineID id;

   404

	int num_engines = 0;

   405

	int num_wagons  = 0;

   406

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

   407

   408

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

   409

   410

	EngList_RemoveAll(&bv->eng_list);

   411

	// make list of all available cars

   412

	for (id = 0; id < NUM_TRAIN_ENGINES; id++) {

   413

		const Engine *e = GetEngine(id);

   414

		const RailVehicleInfo *rvi = RailVehInfo(id);

   415

   416

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

   417

		if (!IsEngineBuildable(id, VEH_Train)) continue;

   418

   419

		EngList_Add(&bv->eng_list, id);

   420

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

   421

			num_engines++;

   422

		} else {

   423

			num_wagons++;

   424

		}

   425

	}

   426

   427

	// make engines first, and then wagons

   428

	_internal_sort_order = false;

   429

	EngList_Sort(&bv->eng_list, TrainEnginesThenWagonsSorter);

   430

   431

	// and then sort engines

   432

	_internal_sort_order = WP(w,buildvehicle_d).descending_sort_order;

   433

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

   434

   435

	// and finally sort wagons

   436

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

   437

}

   438

   439

static void DrawTrainBuildWindow(Window *w)

   440

{

   441

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

   442

	int num_engines = EngList_Count(&bv->eng_list);

   443

	int x = 1;

   444

	int y = 27;

   445

	EngineID selected_id = bv->sel_engine;

   446

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

   447

	uint16 scrollcount = 0;

   448

   449

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

   450

   451

	/* Make sure that the selected engine is still in the list*/

   452

	if (bv->sel_engine != INVALID_ENGINE) {

   453

		int i;

   454

		bool found = false;

   455

		for (i = 0; i < num_engines; i++) {

   456

			if (bv->sel_engine != bv->eng_list[i]) continue;

   457

			found = true;

   458

			break;

   459

		}

   460

		if (!found) bv->sel_engine = INVALID_ENGINE;

   461

	}

   462

   463

	scrollcount = EngList_Count(&bv->eng_list);

   464

   465

	SetVScrollCount(w, scrollcount);

   466

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

   467

	DrawWindowWidgets(w);

   468

   469

	/* Draw the engines */

   470

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

   471

   472

	if (selected_id != INVALID_ENGINE) {

   473

		const RailVehicleInfo *rvi = RailVehInfo(selected_id);

   474

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

   475

   476

		if (rvi->flags & RVI_WAGON) {

   477

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

   478

		} else {

   479

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

   480

		}

   481

	}

   482

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

   483

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

   484

}

   485

   486

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

   487

{