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,

    30

	BUILD_TRAIN_WIDGET_SORT_ASSENDING_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_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,   239, 0x0,                    STR_NULL},

    53

	{ WWT_PUSHTXTBTN,     RESIZE_TB,    14,     0,    76,   240,   251, STR_BLACK_ENGINES,      STR_BUILD_TRAIN_ENGINES_TIP},

    54

	{ WWT_PUSHTXTBTN,     RESIZE_TB,    14,    77,   151,   240,   251, STR_BLACK_WAGONS,       STR_BUILD_TRAIN_WAGONS_TIP},

    55

	{ WWT_PUSHTXTBTN,     RESIZE_TB,    14,   152,   227,   240,   251, STR_BLACK_BOTH,         STR_BUILD_TRAIN_BOTH_TIP},

    56

	{ WWT_PUSHTXTBTN,     RESIZE_TB,    14,     0,   107,   252,   263, STR_881F_BUILD_VEHICLE, STR_8844_BUILD_THE_HIGHLIGHTED_TRAIN},

    57

	{ WWT_PUSHTXTBTN,     RESIZE_TB,    14,   108,   215,   252,   263, STR_8820_RENAME,        STR_8845_RENAME_TRAIN_VEHICLE_TYPE},

    58

	{  WWT_RESIZEBOX,     RESIZE_TB,    14,   216,   227,   252,   263, 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 = ListPositionOfEngine(va) - ListPositionOfEngine(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];

   136

	int r;

   137

   138

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

   139

   140

	if (vb != _last_engine) {

   141

		_last_engine = vb;

   142

		_bufcache[0] = '\0';

   143

   144

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

   145

	}

   146

   147

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

   148

   149

	if (r == 0) {

   150

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

   151

		return TrainEngineNumberSorter(a, b);

   152

	}

   153

   154

	return _internal_sort_order ? -r : r;

   155

}

   156

   157

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

   158

{

   159

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

   160

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

   161

   162

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

   163

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

   164

	const int r = va - vb;

   165

   166

	if (r == 0) {

   167

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

   168

		return TrainEngineNumberSorter(a, b);

   169

	}

   170

	return _internal_sort_order ? -r : r;

   171

}

   172

   173

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

   174

{

   175

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

   176

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

   177

   178

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

   179

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

   180

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

   181

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

   182

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

   183

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

   184

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

   185

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

   186

	const int r = vb - va;

   187

   188

	if (r == 0) {

   189

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

   190

		return TrainEngineNumberSorter(a, b);

   191

	}

   192

	return _internal_sort_order ? -r : r;

   193

}

   194

   195

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

   196

{

   197

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

   198

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

   199

	const int r = va - vb;

   200

   201

	if (r == 0) {

   202

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

   203

		return TrainEngineNumberSorter(a, b);

   204

	}

   205

	return _internal_sort_order ? -r : r;

   206

}

   207

   208

static VehicleSortListingTypeFunction* const _engine_sorter[] = {

   209

	&TrainEngineNumberSorter,

   210

	&TrainEngineCostSorter,

   211

	&TrainEngineSpeedSorter,

   212

	&TrainEnginePowerSorter,

   213

	&TrainEngineIntroDateSorter,

   214

	&TrainEngineNameSorter,

   215

	&TrainEngineRunningCostSorter,

   216

	&TrainEnginePowerVsRunningCostSorter,

   217

	&TrainEngineReliabilitySorter,

   218

};

   219

   220

static const StringID _engine_sort_listing[] = {

   221

	STR_ENGINE_SORT_ENGINE_ID,

   222

	STR_ENGINE_SORT_COST,

   223

	STR_SORT_BY_MAX_SPEED,

   224

	STR_ENGINE_SORT_POWER,

   225

	STR_ENGINE_SORT_INTRO_DATE,

   226

	STR_SORT_BY_DROPDOWN_NAME,

   227

	STR_ENGINE_SORT_RUNNING_COST,

   228

	STR_ENGINE_SORT_POWER_VS_RUNNING_COST,

   229

	STR_SORT_BY_RELIABILITY,

   230

	INVALID_STRING_ID

   231

};

   232

   233

/**

   234

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

   235

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

   236

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

   237

 */

   238

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

   239

{

   240

	const RailVehicleInfo *rvi = RailVehInfo(engine_number);

   241

	const Engine *e = GetEngine(engine_number);

   242

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

   243

	YearMonthDay ymd;

   244

	ConvertDateToYMD(e->intro_date, &ymd);

   245

   246

	/* Purchase Cost - Engine weight */

   247

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

   248

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

   249

	DrawString(x,y, STR_PURCHASE_INFO_COST_WEIGHT, 0);

   250

	y += 10;

   251

   252

	/* Max speed - Engine power */

   253

	SetDParam(0, rvi->max_speed);

   254

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

   255

	DrawString(x,y, STR_PURCHASE_INFO_SPEED_POWER, 0);

   256

	y += 10;

   257

   258

	/* Running cost */

   259

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

   260

	DrawString(x,y, STR_PURCHASE_INFO_RUNNINGCOST, 0);

   261

	y += 10;

   262

   263

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

   264

	if (rvi->pow_wag_power != 0) {

   265

		SetDParam(0, rvi->pow_wag_power);

   266

		SetDParam(1, rvi->pow_wag_weight);

   267

		DrawString(x,y, STR_PURCHASE_INFO_PWAGPOWER_PWAGWEIGHT, 0);

   268

		y += 10;

   269

	};

   270

   271

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

   272

	if (rvi->capacity == 0) {

   273

		SetDParam(0, CT_INVALID);

   274

		SetDParam(2, STR_EMPTY);

   275

	} else {

   276

		SetDParam(0, rvi->cargo_type);

   277

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

   278

		SetDParam(2, STR_9842_REFITTABLE);

   279

	}

   280

	DrawString(x,y, STR_PURCHASE_INFO_CAPACITY, 0);

   281

	y += 10;

   282

   283

	/* Design date - Life length */

   284

	SetDParam(0, ymd.year);

   285

	SetDParam(1, e->lifelength);

   286

	DrawString(x,y, STR_PURCHASE_INFO_DESIGNED_LIFE, 0);

   287

	y += 10;

   288

   289

	/* Reliability */

   290

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

   291

	DrawString(x,y, STR_PURCHASE_INFO_RELIABILITY, 0);

   292

	y += 10;

   293

   294

	/* Additional text from NewGRF */

   295

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

   296

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

   297

}

   298

   299

/**

   300

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

   301

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

   302

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

   303

 */

   304

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

   305

{

   306

	const RailVehicleInfo *rvi = RailVehInfo(engine_number);

   307

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

   308

   309

	/* Purchase cost */

   310

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

   311

	DrawString(x, y, STR_PURCHASE_INFO_COST, 0);

   312

	y += 10;

   313

   314

	/* Wagon weight - (including cargo) */

   315

	SetDParam(0, rvi->weight);

   316

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

   317

	DrawString(x, y, STR_PURCHASE_INFO_WEIGHT_CWEIGHT, 0);

   318

	y += 10;

   319

   320

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

   321

	if (rvi->capacity == 0) {

   322

		SetDParam(0, CT_INVALID);

   323

		SetDParam(2, STR_EMPTY);

   324

	} else {

   325

		SetDParam(0, 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, w, engine_number);

   341

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

   342

}

   343

   344

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

   345

{

   346

	Vehicle *v, *found;

   347

   348

	if (!success) return;

   349

   350

	// find a locomotive in the depot.

   351

	found = NULL;

   352

	FOR_ALL_VEHICLES(v) {

   353

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

   354

				v->tile == tile &&

   355

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

   356

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

   357

			found = v;

   358

		}

   359

	}

   360

   361

	// if we found a loco,

   362

	if (found != NULL) {

   363

		found = GetLastVehicleInChain(found);

   364

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

   365

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

   366

		RebuildVehicleLists();

   367

	}

   368

}

   369

   370

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

   371

{

   372

	const Vehicle *v;

   373

   374

	if (!success) return;

   375

   376

	v = GetVehicle(_new_vehicle_id);

   377

	if (tile == _backup_orders_tile) {

   378

		_backup_orders_tile = 0;

   379

		RestoreVehicleOrders(v, _backup_orders_data);

   380

	}

   381

	ShowTrainViewWindow(v);

   382

}

   383

   384

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

   385

{

   386

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

   387

}

   388

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

   389

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

   390

{

   391

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

   392

		EngineID i = engines[*position];

   393

   394

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

   395

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

   396

		*y += 14;

   397

	}

   398

}

   399

   400

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

   401

{

   402

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

   403

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

   404

}

   405

   406

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

   407

{

   408

	uint16 engine_length = *num_engines;

   409

	uint16 wagon_length  = *num_wagons;

   410

	EngineID j;

   411

   412

	(*num_engines) = 0;

   413

	(*num_wagons)  = 0;

   414

   415

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

   416

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

   417

   418

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

   419

		EngineID i = GetRailVehAtPosition(j); // XXX Can be removed when the wagon list is also sorted.

   420

		const Engine *e = GetEngine(i);

   421

		const RailVehicleInfo *rvi = RailVehInfo(i);

   422

   423

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

   424

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

   425

   426

		if (rvi->flags & RVI_WAGON) {

   427

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

   428

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

   429

		} else {

   430

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

   431

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

   432

		}

   433

	}

   434

   435

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

   436

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

   437

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

   438

}

   439

   440

static void SortTrainBuildList(Window *w)

   441

{

   442

	_internal_sort_order = WP(w,buildvehicle_d).decenting_sort_order;

   443

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

   444

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

   445

}

   446

   447

static void DrawTrainBuildWindow(Window *w)

   448

{

   449

	int x = 1;

   450

	int y = 27;

   451

	EngineID position = w->vscroll.pos;

   452

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

   453

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

   454

	uint16 scrollcount = 0;

   455

   456

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

   457

   458

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

   459

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

   460

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

   461

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

   462

   463

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

   464

		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);

   465

		WP(w,buildvehicle_d).data_invalidated = false;

   466

		SortTrainBuildList(w);

   467

   468

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

   469

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

   470

			int i;

   471

			bool found = false;

   472

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

   473

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

   474

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

   475

					found = true;

   476

					break;

   477

				}

   478

			}

   479

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

   480

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

   481

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

   482

					found = true;

   483

					break;

   484

				}

   485

			}

   486

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

   487

		}

   488

	}

   489