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

    12

#include "gui.h"

    13

#include "gfx.h"

    14

#include "vehicle.h"

    15

#include "viewport.h"

    16

#include "station.h"

    17

#include "command.h"

    18

#include "player.h"

    19

#include "engine.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,

    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_ENGINES,

    37

	BUILD_TRAIN_WIDGET_WAGONS,

    38

	BUILD_TRAIN_WIDGET_BOTH,

    39

	BUILD_TRAIN_WIDGET_BUILD,

    40

	BUILD_TRAIN_WIDGET_RENAME,

    41

	BUILD_TRAIN_WIDGET_RESIZE,

    42

} BuildTrainWidget;

    43

    44

static const Widget _new_rail_vehicle_widgets[] = {

    45

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

    46

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

    47

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

    48

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

    49

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

    50

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

    51

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

    52

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

    53

	{ WWT_PUSHTXTBTN,     RESIZE_TB,    14,     0,    76,   210,   221, STR_BLACK_ENGINES,      STR_BUILD_TRAIN_ENGINES_TIP},

    54

	{ WWT_PUSHTXTBTN,     RESIZE_TB,    14,    77,   151,   210,   221, STR_BLACK_WAGONS,       STR_BUILD_TRAIN_WAGONS_TIP},

    55

	{ WWT_PUSHTXTBTN,     RESIZE_TB,    14,   152,   227,   210,   221, STR_BLACK_BOTH,         STR_BUILD_TRAIN_BOTH_TIP},

    56

	{ WWT_PUSHTXTBTN,     RESIZE_TB,    14,     0,   107,   222,   233, STR_881F_BUILD_VEHICLE, STR_8844_BUILD_THE_HIGHLIGHTED_TRAIN},

    57

	{ WWT_PUSHTXTBTN,     RESIZE_TB,    14,   108,   215,   222,   233, STR_8820_RENAME,        STR_8845_RENAME_TRAIN_VEHICLE_TYPE},

    58

	{  WWT_RESIZEBOX,     RESIZE_TB,    14,   216,   227,   222,   233, 0x0,                    STR_RESIZE_BUTTON},

    59

	{   WIDGETS_END},

    60

};

    61

    62

static bool _internal_sort_order; // descending/ascending

    63

static byte _last_sort_criteria = 0;

    64

static bool _last_sort_order = false;

    65

    66

typedef int CDECL VehicleSortListingTypeFunction(const void*, const void*);

    67

    68

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

    69

{

    70

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

    71

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

    72

	int r = va - vb;

    73

    74

	return _internal_sort_order ? -r : r;

    75

}

    76

    77

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

    78

{

    79

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

    80

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

    81

	int r = va - vb;

    82

    83

	return _internal_sort_order ? -r : r;

    84

}

    85

    86

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

    87

{

    88

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

    89

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

    90

	const int r = va - vb;

    91

    92

	if (r == 0) {

    93

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

    94

		return TrainEngineNumberSorter(a, b);

    95

	}

    96

	return _internal_sort_order ? -r : r;

    97

}

    98

    99

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

   100

{

   101

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

   102

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

   103

   104

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

   105

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

   106

	const int r = va - vb;

   107

   108

	if (r == 0) {

   109

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

   110

		return TrainEngineNumberSorter(a, b);

   111

	}

   112

	return _internal_sort_order ? -r : r;

   113

}

   114

   115

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

   116

{

   117

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

   118

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

   119

	const int r = va - vb;

   120

   121

	if (r == 0) {

   122

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

   123

		return TrainEngineNumberSorter(a, b);

   124

	}

   125

	return _internal_sort_order ? -r : r;

   126

}

   127

   128

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

   129

   130

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

   131

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

   132

{

   133

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

   134

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

   135

	char buf1[64] = "\0";

   136

	int r;

   137

   138

	SetDParam(0, GetCustomEngineName(va));

   139

	GetString(buf1, STR_JUST_STRING);

   140

   141

	if (vb != _last_engine) {

   142

		_last_engine = vb;

   143

		_bufcache[0] = '\0';

   144

   145

		SetDParam(0, GetCustomEngineName(vb));

   146

		GetString(_bufcache, STR_JUST_STRING);

   147

	}

   148

   149

	r =  strcmp(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 & 1) ? -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]) / rvi_a->power;

   187

	const int vb = (rvi_b->running_cost_base * _price.running_rail[rvi_b->running_cost_class]) / 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 VehicleSortListingTypeFunction* 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, 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

	SetDParam(0, STR_8838_N_A);

   275

	SetDParam(2, STR_EMPTY);

   276

	if (rvi->capacity != 0) {

   277

		SetDParam(0, _cargoc.names_long[rvi->cargo_type]);

   278

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

   279

		SetDParam(2, STR_9842_REFITTABLE);

   280

	}

   281

	DrawString(x,y, STR_PURCHASE_INFO_CAPACITY, 0);

   282

	y += 10;

   283

   284

	/* Design date - Life length */

   285

	SetDParam(0, ymd.year);

   286

	SetDParam(1, e->lifelength);

   287

	DrawString(x,y, STR_PURCHASE_INFO_DESIGNED_LIFE, 0);

   288

	y += 10;

   289

   290

	/* Reliability */

   291

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

   292

	DrawString(x,y, STR_PURCHASE_INFO_RELIABILITY, 0);

   293

	y += 10;

   294

   295

	/* Additional text from NewGRF */

   296

	// XXX 227 will become a calculated width...

   297

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

   298

}

   299

   300

/**

   301

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

   302

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

   303

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

   304

 */

   305

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

   306

{

   307

	const RailVehicleInfo *rvi = RailVehInfo(engine_number);

   308

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

   309

   310

	/* Purchase cost */

   311

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

   312

	DrawString(x, y, STR_PURCHASE_INFO_COST, 0);

   313

	y += 10;

   314

   315

	/* Wagon weight - (including cargo) */

   316

	SetDParam(0, rvi->weight);

   317

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

   318

	DrawString(x, y, STR_PURCHASE_INFO_WEIGHT_CWEIGHT, 0);

   319

	y += 10;

   320

   321

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

   322

	SetDParam(0, STR_8838_N_A);

   323

	SetDParam(2, STR_EMPTY);

   324

	if (rvi->capacity != 0) {

   325

		SetDParam(0, _cargoc.names_long[rvi->cargo_type]);

   326

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

   327

		SetDParam(2, refittable ? STR_9842_REFITTABLE : STR_EMPTY);

   328

	}

   329

	DrawString(x, y, STR_PURCHASE_INFO_CAPACITY, 0);

   330

	y += 10;

   331

   332

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

   333

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

   334

		SetDParam(0, rvi->max_speed);

   335

		DrawString(x,y, STR_PURCHASE_INFO_SPEED, 0);

   336

		y += 10;

   337

	}

   338

   339

	/* Additional text from NewGRF */

   340

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

   341

}

   342

   343

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

   344

{

   345

	Vehicle *v, *found;

   346

   347

	if (!success) return;

   348

   349

	// find a locomotive in the depot.

   350

	found = NULL;

   351

	FOR_ALL_VEHICLES(v) {

   352

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

   353

				v->tile == tile &&

   354

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

   355

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

   356

			found = v;

   357

		}

   358

	}

   359

   360

	// if we found a loco,

   361

	if (found != NULL) {

   362

		found = GetLastVehicleInChain(found);

   363

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

   364

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

   365

		RebuildVehicleLists();

   366

	}

   367

}

   368

   369

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

   370

{

   371

	const Vehicle *v;

   372

   373

	if (!success) return;

   374

   375

	v = GetVehicle(_new_vehicle_id);

   376

	if (tile == _backup_orders_tile) {

   377

		_backup_orders_tile = 0;

   378

		RestoreVehicleOrders(v, _backup_orders_data);

   379

	}

   380

	ShowTrainViewWindow(v);

   381

}

   382

   383

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

   384

{

   385

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

   386

}

   387

static void engine_drawing_loop(const EngineID *engines, const uint16 engine_count,

   388

								const int x, int *y, const EngineID sel, EngineID *position, const int16 show_max)

   389

{

   390

	for (; (*position) < min(engine_count, show_max); (*position)++) {

   391

		EngineID i = engines[*position];

   392

   393

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

   394

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

   395

		*y += 14;

   396

	}

   397

}

   398

   399

static inline void ExtendEngineListSize(const EngineID **engine_list, uint16 *engine_list_length, uint16 step_size)

   400

{

   401

	*engine_list_length = min(*engine_list_length + step_size, NUM_TRAIN_ENGINES);

   402

	*engine_list = realloc((void*)*engine_list, (*engine_list_length) * sizeof((*engine_list)[0]));

   403

}

   404

   405

static void GenerateBuildList(EngineID **engines, uint16 *num_engines, EngineID **wagons, uint16 *num_wagons, RailType railtype)

   406

{

   407

	uint16 engine_length = *num_engines;

   408

	uint16 wagon_length  = *num_wagons;

   409

	EngineID j;

   410

   411

	(*num_engines) = 0;

   412

	(*num_wagons)  = 0;

   413

   414

	if (engines == NULL) ExtendEngineListSize((const EngineID**)engines, &engine_length, 25);

   415

	if (wagons  == NULL) ExtendEngineListSize((const EngineID**)wagons,  &wagon_length,  25);

   416

   417

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

   418

		EngineID i = GetRailVehAtPosition(j);

   419

		const Engine *e = GetEngine(i);

   420

		const RailVehicleInfo *rvi = RailVehInfo(i);

   421

   422

		if (!HasPowerOnRail(e->railtype, railtype)) continue;

   423

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

   424

   425

		if (rvi->flags & RVI_WAGON) {

   426

			if (*num_wagons == wagon_length) ExtendEngineListSize((const EngineID**)wagons, &wagon_length, 5);

   427

			(*wagons)[(*num_wagons)++] = i;

   428

		} else {

   429

			if (*num_engines == engine_length) ExtendEngineListSize((const EngineID**)engines, &engine_length, 5);

   430

			(*engines)[(*num_engines)++] = i;

   431

		}

   432

	}

   433

   434

	/* Reduce array sizes if they are too big */

   435

	if (*num_engines != engine_length) *engines = realloc((void*)*engines, (*num_engines) * sizeof((*engines)[0]));

   436

	if (*num_wagons  != wagon_length)  *wagons  = realloc((void*)*wagons,  (*num_wagons)  * sizeof((*wagons)[0]));

   437

}

   438

   439

static void SortTrainBuildList(Window *w)

   440

{

   441

	_internal_sort_order = WP(w,buildvehicle_d).decenting_sort_order;

   442

	qsort((void*)WP(w, buildvehicle_d).list_a, WP(w, buildvehicle_d).list_a_length, sizeof(WP(w, buildvehicle_d).list_a[0]),

   443

		  _engine_sorter[WP(w,buildvehicle_d).sort_criteria]);

   444

}

   445

   446

static void DrawTrainBuildWindow(Window *w)

   447

{

   448

	int x = 1;

   449

	int y = 27;

   450

	EngineID position = w->vscroll.pos;

   451

	EngineID selected_id = WP(w,buildvehicle_d).sel_engine;

   452

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

   453

	uint16 scrollcount = 0;

   454

   455

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

   456

   457

	/* Draw the clicked engine/wagon/both button pressed and unpress the other two */

   458

	SetWindowWidgetLoweredState(w, BUILD_TRAIN_WIDGET_ENGINES, WP(w,buildvehicle_d).show_engine_button == 1);

   459

	SetWindowWidgetLoweredState(w, BUILD_TRAIN_WIDGET_WAGONS,  WP(w,buildvehicle_d).show_engine_button == 2);

   460

	SetWindowWidgetLoweredState(w, BUILD_TRAIN_WIDGET_BOTH,    WP(w,buildvehicle_d).show_engine_button == 3);

   461

   462

	if (WP(w,buildvehicle_d).data_invalidated) {

   463

		GenerateBuildList(&WP(w, buildvehicle_d).list_a, &WP(w, buildvehicle_d).list_a_length, &WP(w, buildvehicle_d).list_b, &WP(w, buildvehicle_d).list_b_length, WP(w,buildvehicle_d).railtype);

   464

		WP(w,buildvehicle_d).data_invalidated = false;

   465

		SortTrainBuildList(w);

   466

   467

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

   468

		if (WP(w,buildvehicle_d).sel_engine != INVALID_ENGINE) {

   469

			int i;

   470

			bool found = false;

   471

			if (HASBIT(WP(w,buildvehicle_d).show_engine_button, 0)) {

   472

				for (i = 0; i < WP(w, buildvehicle_d).list_a_length; i++) {

   473

					if (WP(w,buildvehicle_d).sel_engine != WP(w, buildvehicle_d).list_a[i]) continue;

   474

					found = true;

   475

					break;

   476

				}

   477

			}

   478

			if (!found && HASBIT(WP(w,buildvehicle_d).show_engine_button, 1)) {

   479

				for (i = 0; i < WP(w, buildvehicle_d).list_b_length; i++) {

   480

					if (WP(w,buildvehicle_d).sel_engine != WP(w, buildvehicle_d).list_b[i]) continue;

   481

					found = true;

   482

					break;

   483

				}

   484

			}

   485

			if (!found) WP(w,buildvehicle_d).sel_engine = INVALID_ENGINE;

   486

		}

   487

	}

   488

   489

	if (HASBIT(WP(w,buildvehicle_d).show_engine_button, 0)) scrollcount += WP(w, buildvehicle_d).list_a_length;

   490

	if (HASBIT(WP(w,buildvehicle_d).show_engine_button, 1)) scrollcount += WP(w, buildvehicle_d).list_b_length;