1

#include "stdafx.h"

     2

#include "ttd.h"

     3

#include "window.h"

     4

#include "gui.h"

     5

#include "vehicle.h"

     6

#include "gfx.h"

     7

#include "station.h"

     8

#include "command.h"

     9

#include "engine.h"

    10

#include "viewport.h"

    11

#include "player.h"

    12

    13

extern const byte _aircraft_cost_table[NUM_AIRCRAFT_ENGINES];

    14

extern const byte _aircraft_speed[NUM_AIRCRAFT_ENGINES];

    15

extern const uint16 _aircraft_num_pass[NUM_AIRCRAFT_ENGINES];

    16

extern const byte _aircraft_num_mail[NUM_AIRCRAFT_ENGINES];

    17

extern const byte _aircraft_running_cost[NUM_AIRCRAFT_ENGINES];

    18

    19

    20

static void DrawAircraftImage(Vehicle *v, int x, int y, VehicleID selection)

    21

{

    22

	int image = GetAircraftImage(v, 6);

    23

	uint32 ormod = SPRITE_PALETTE(PLAYER_SPRITE_COLOR(v->owner));

    24

	if (v->vehstatus & VS_CRASHED) ormod = 0x3248000;

    25

	DrawSprite(image | ormod, x+25, y+10);

    26

	if (v->subtype == 0)

    27

		DrawSprite(0xF3D, x+25, y+5);

    28

	if (v->index == selection) {

    29

		DrawFrameRect(x-1, y-1, x+58, y+21, 0xF, 0x10);

    30

	}

    31

}

    32

    33

static void CcBuildAircraft(bool success, uint tile, uint32 p1, uint32 p2)

    34

{

    35

	Vehicle *v;

    36

    37

	if (success) {

    38

		v = &_vehicles[_new_aircraft_id];

    39

		if (v->tile == _backup_orders_tile) {

    40

			_backup_orders_tile = 0;

    41

			RestoreVehicleOrders(v, _backup_orders_data);

    42

		}

    43

		ShowAircraftViewWindow(v);

    44

	}

    45

}

    46

    47

    48

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

    49

{

    50

	YearMonthDay ymd;

    51

    52

	switch(e->event) {

    53

    54

	case WE_PAINT: {

    55

		if (w->window_number == 0)

    56

			SETBIT(w->disabled_state, 5);

    57

    58

		{

    59

			int count = 0;

    60

			int num = NUM_AIRCRAFT_ENGINES;

    61

			Engine *e = &_engines[AIRCRAFT_ENGINES_INDEX];

    62

			do {

    63

				if (HASBIT(e->player_avail, _local_player))

    64

					count++;

    65

			} while (++e,--num);

    66

			SetVScrollCount(w, count);

    67

		}

    68

    69

		DrawWindowWidgets(w);

    70

    71

		{

    72

			int num = NUM_AIRCRAFT_ENGINES;

    73

			Engine *e = &_engines[AIRCRAFT_ENGINES_INDEX];

    74

			int x = 2;

    75

			int y = 15;

    76

			int sel = WP(w,buildtrain_d).sel_index;

    77

			int pos = w->vscroll.pos;

    78

			int engine_id = AIRCRAFT_ENGINES_INDEX;

    79

			int selected_id = -1;

    80

    81

			do {

    82

				if (HASBIT(e->player_avail, _local_player)) {

    83

					if (sel==0) selected_id = engine_id;

    84

					if (IS_INT_INSIDE(--pos, -4, 0)) {

    85

						DrawString(x+62, y+7, GetCustomEngineName(engine_id), sel==0 ? 0xC : 0x10);

    86

						DrawAircraftEngine(x+29, y+10, engine_id, SPRITE_PALETTE(PLAYER_SPRITE_COLOR(_local_player)));

    87

						y += 24;

    88

					}

    89

					sel--;

    90

				}

    91

			} while (++engine_id, ++e,--num);

    92

    93

			WP(w,buildtrain_d).sel_engine = selected_id;

    94

    95

			if (selected_id != -1) {

    96

				Engine *e;

    97

    98

				SET_DPARAM32(0, _aircraft_cost_table[selected_id - AIRCRAFT_ENGINES_INDEX] * (_price.aircraft_base>>3)>>5);

    99

				SET_DPARAM16(1, _aircraft_speed[selected_id - AIRCRAFT_ENGINES_INDEX] * 8);

   100

				SET_DPARAM16(2, _aircraft_num_pass[selected_id - AIRCRAFT_ENGINES_INDEX]);

   101

				SET_DPARAM16(3, _aircraft_num_mail[selected_id - AIRCRAFT_ENGINES_INDEX]);

   102

				SET_DPARAM32(4,_aircraft_running_cost[selected_id - AIRCRAFT_ENGINES_INDEX] * _price.aircraft_running >> 8);

   103

   104

				e = &_engines[selected_id];

   105

				SET_DPARAM16(6, e->lifelength);

   106

				SET_DPARAM8(7, e->reliability * 100 >> 16);

   107

				ConvertDayToYMD(&ymd, e->intro_date);

   108

				SET_DPARAM16(5, ymd.year + 1920);

   109

   110

				DrawString(2, 111, STR_A007_COST_SPEED_CAPACITY_PASSENGERS, 0);

   111

			}

   112

		}

   113

	} break;

   114

   115

	case WE_CLICK:

   116

		switch(e->click.widget) {

   117

		case 2: { /* listbox */

   118

			uint i = (e->click.pt.y - 14) / 24;

   119

			if (i < 4) {

   120

				WP(w,buildtrain_d).sel_index = i + w->vscroll.pos;

   121

				SetWindowDirty(w);

   122

			}

   123

		} break;

   124

   125

		case 5: { /* build */

   126

			int sel_eng = WP(w,buildtrain_d).sel_engine;

   127

			if (sel_eng != -1)

   128

				DoCommandP(w->window_number, sel_eng, 0, CcBuildAircraft, CMD_BUILD_AIRCRAFT | CMD_MSG(STR_A008_CAN_T_BUILD_AIRCRAFT));

   129

		} break;

   130

   131

		case 6:	/* rename */

   132

			WP(w,buildtrain_d).rename_engine = WP(w,buildtrain_d).sel_engine;

   133

			ShowQueryString(

   134

				GetCustomEngineName(WP(w,buildtrain_d).sel_engine),

   135

				STR_A039_RENAME_AIRCRAFT_TYPE,

   136

				31,

   137

				160,

   138

				w->window_class,

   139

				w->window_number);

   140

			break;

   141

		}

   142

		break;

   143

   144

	case WE_4:

   145

		if (w->window_number != 0 && !FindWindowById(WC_VEHICLE_DEPOT, w->window_number)) {

   146

			DeleteWindow(w);

   147

		}

   148

		break;

   149

   150

	case WE_ON_EDIT_TEXT: {

   151

		byte *b = e->edittext.str;

   152

		if (*b == 0)

   153

			return;

   154

		memcpy(_decode_parameters, b, 32);

   155

		DoCommandP(0, WP(w,buildtrain_d).rename_engine, 0, NULL, CMD_RENAME_ENGINE | CMD_MSG(STR_A03A_CAN_T_RENAME_AIRCRAFT_TYPE));

   156

	} break;

   157

	}

   158

}

   159

   160

static const Widget _new_aircraft_widgets[] = {

   161

{    WWT_TEXTBTN,    14,     0,    10,     0,    13, STR_00C5, STR_018B_CLOSE_WINDOW},

   162

{    WWT_CAPTION,    14,    11,   239,     0,    13, STR_A005_NEW_AIRCRAFT, STR_018C_WINDOW_TITLE_DRAG_THIS},

   163

{     WWT_MATRIX,    14,     0,   228,    14,   109, 0x401, STR_A025_AIRCRAFT_SELECTION_LIST},

   164

{  WWT_SCROLLBAR,    14,   229,   239,    14,   109, 0x0, STR_0190_SCROLL_BAR_SCROLLS_LIST},

   165

{     WWT_IMGBTN,    14,     0,   239,   110,   161, 0x0, 0},

   166

{ WWT_PUSHTXTBTN,    14,     0,   119,   162,   173, STR_A006_BUILD_AIRCRAFT, STR_A026_BUILD_THE_HIGHLIGHTED_AIRCRAFT},

   167

{ WWT_PUSHTXTBTN,    14,   120,   239,   162,   173, STR_A037_RENAME, STR_A038_RENAME_AIRCRAFT_TYPE},

   168

{      WWT_LAST},

   169

};

   170

   171

static const WindowDesc _new_aircraft_desc = {

   172

	-1, -1, 240, 174,

   173

	WC_BUILD_VEHICLE,0,

   174

	WDF_STD_TOOLTIPS | WDF_STD_BTN | WDF_DEF_WIDGET | WDF_UNCLICK_BUTTONS,

   175

	_new_aircraft_widgets,

   176

	NewAircraftWndProc

   177

};

   178

   179

static void ShowBuildAircraftWindow(uint tile)

   180

{

   181

	Window *w;

   182

   183

	DeleteWindowById(WC_BUILD_VEHICLE, tile);

   184

   185

	w = AllocateWindowDesc(&_new_aircraft_desc);

   186

	w->window_number = tile;

   187

	w->vscroll.cap = 4;

   188

   189

	if (tile != 0) {

   190

		w->caption_color = _map_owner[tile];

   191

	} else {

   192

		w->caption_color = _local_player;

   193

	}

   194

}

   195

   196

const byte _aircraft_refit_normal[] = { 0,1,4,5,6,7,8,9,10,0xFF };

   197

const byte _aircraft_refit_arctic[] = { 0,1,4,5,6,7,9,11,10,0xFF };

   198

const byte _aircraft_refit_desert[] = { 0,4,5,8,6,7,9,10,0xFF };

   199

const byte _aircraft_refit_candy[] = { 0,1,3,5,7,8,9,6,4,10,11,0xFF };

   200

   201

const byte * const _aircraft_refit_types[4] = {

   202

	_aircraft_refit_normal, _aircraft_refit_arctic, _aircraft_refit_desert, _aircraft_refit_candy

   203

};

   204

   205

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

   206

{

   207

	switch(e->event) {

   208

	case WE_PAINT: {

   209

		Vehicle *v = &_vehicles[w->window_number];

   210

		const byte *b;

   211

		int sel;

   212

		int x,y;

   213

		byte color;

   214

		int cargo;

   215

   216

		SET_DPARAM16(0, v->string_id);

   217

		SET_DPARAM16(1, v->unitnumber);

   218

		DrawWindowWidgets(w);

   219

   220

		DrawString(1, 15, STR_A040_SELECT_CARGO_TYPE_TO_CARRY, 0);

   221

   222

		cargo = -1;

   223

		x = 6;

   224

		y = 25;

   225

		sel = WP(w,refit_d).sel;

   226

		b = _aircraft_refit_types[_opt.landscape];

   227

		do {

   228

			color = 16;

   229

			if (sel == 0) {

   230

				cargo = *b;

   231

				color = 12;

   232

			}

   233

			sel--;

   234

			DrawString(x,y,_cargoc.names_s[*b], color);

   235

			y += 10;

   236

		} while (*++b != 0xFF);

   237

   238

		WP(w,refit_d).cargo = cargo;

   239

   240

		if (cargo != -1) {

   241

			int32 cost = DoCommandByTile(v->tile, v->index, cargo, DC_QUERY_COST, CMD_REFIT_AIRCRAFT);

   242

			if (cost != CMD_ERROR) {

   243

				SET_DPARAM32(2, cost);

   244

				SET_DPARAM16(0, _cargoc.names_long_p[cargo]);

   245

				SET_DPARAM16(1, _aircraft_refit_capacity);

   246

				DrawString(1, 137, STR_A041_NEW_CAPACITY_COST_OF_REFIT, 0);

   247

			}

   248

		}

   249

   250

		break;

   251

	}

   252

   253

	case WE_CLICK:

   254

		switch(e->click.widget) {

   255

		case 2: { /* listbox */

   256

				int y = e->click.pt.y - 25;

   257

				if (y >= 0) {

   258

					WP(w,refit_d).sel = y / 10;

   259

					SetWindowDirty(w);

   260

				}

   261

			} break;

   262

		case 4: /* refit button */

   263

			if (WP(w,refit_d).cargo != 0xFF) {

   264

				Vehicle *v = &_vehicles[w->window_number];

   265

				if (DoCommandP(v->tile, v->index, WP(w,refit_d).cargo, NULL, CMD_REFIT_AIRCRAFT | CMD_MSG(STR_A042_CAN_T_REFIT_AIRCRAFT)))

   266

					DeleteWindow(w);

   267

			}

   268

		  break;

   269

		}

   270

		break;

   271

	}

   272

}

   273

   274

static const Widget _aircraft_refit_widgets[] = {

   275

{    WWT_TEXTBTN,    14,     0,    10,     0,    13, STR_00C5, STR_018B_CLOSE_WINDOW},

   276

{    WWT_CAPTION,    14,    11,   239,     0,    13, STR_A03C_REFIT, STR_018C_WINDOW_TITLE_DRAG_THIS},

   277

{     WWT_IMGBTN,    14,     0,   239,    14,   135, 0x0, STR_A03E_SELECT_TYPE_OF_CARGO_FOR},

   278

{     WWT_IMGBTN,    14,     0,   239,   136,   157, 0x0},

   279

{ WWT_PUSHTXTBTN,    14,     0,   239,   158,   169, STR_A03D_REFIT_AIRCRAFT, STR_A03F_REFIT_AIRCRAFT_TO_CARRY},

   280

{      WWT_LAST},

   281

};

   282

   283

static const WindowDesc _aircraft_refit_desc = {

   284

	-1,-1, 240, 170,

   285

	WC_VEHICLE_REFIT,WC_VEHICLE_VIEW,

   286

	WDF_STD_TOOLTIPS | WDF_STD_BTN | WDF_DEF_WIDGET | WDF_UNCLICK_BUTTONS,

   287

	_aircraft_refit_widgets,

   288

	AircraftRefitWndProc

   289

};

   290

   291

static void ShowAircraftRefitWindow(Vehicle *v)

   292

{

   293

	Window *w;

   294

   295

	DeleteWindowById(WC_VEHICLE_REFIT, v->index);

   296

   297

	_alloc_wnd_parent_num = v->index;

   298

	w = AllocateWindowDesc(&_aircraft_refit_desc);

   299

	w->window_number = v->index;

   300

	w->caption_color = v->owner;

   301

	WP(w,refit_d).sel = -1;

   302

}

   303

   304

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

   305

{

   306

	int mod;

   307

	Vehicle *v = &_vehicles[w->window_number], *u;

   308

   309

	switch(e->event) {

   310

	case WE_PAINT:

   311

		w->disabled_state = v->owner == _local_player ? 0 : (1 << 2);

   312

		if (!_patches.servint_aircraft) // disable service-scroller when interval is set to disabled

   313

			w->disabled_state |= (1 << 5) | (1 << 6);

   314

   315

		SET_DPARAM16(0, v->string_id);

   316

		SET_DPARAM16(1, v->unitnumber);

   317

		DrawWindowWidgets(w);

   318

   319

		/* Draw running cost */

   320

		{

   321

			int year = v->age / 366;

   322

			StringID str;

   323

   324

			SET_DPARAM16(1, year);

   325

   326

			str = STR_0199_YEAR;

   327

			if (year != 1) {

   328

				str++;

   329

				if (v->max_age - 366 < v->age)

   330

					str++;

   331

			}

   332

			SET_DPARAM16(0, str);

   333

			SET_DPARAM16(2, v->max_age / 366);

   334

			SET_DPARAM32(3, _price.aircraft_running * _aircraft_running_cost[v->engine_type - AIRCRAFT_ENGINES_INDEX] >> 8);

   335

			DrawString(2, 15, STR_A00D_AGE_RUNNING_COST_YR, 0);

   336

		}

   337

   338

		/* Draw max speed */

   339

		{

   340

			SET_DPARAM16(0, v->max_speed * 8);

   341

			DrawString(2, 25, STR_A00E_MAX_SPEED, 0);

   342

		}

   343

   344

		/* Draw profit */

   345

		{

   346

			SET_DPARAM32(0, v->profit_this_year);

   347

			SET_DPARAM32(1, v->profit_last_year);

   348

			DrawString(2, 35, STR_A00F_PROFIT_THIS_YEAR_LAST_YEAR, 0);

   349

		}

   350

   351

		/* Draw breakdown & reliability */

   352

		{

   353

			SET_DPARAM8(0, v->reliability * 100 >> 16);

   354

			SET_DPARAM16(1, v->breakdowns_since_last_service);

   355

			DrawString(2, 45, STR_A010_RELIABILITY_BREAKDOWNS, 0);

   356

		}

   357

   358

		/* Draw service interval text */

   359

		{

   360

			SET_DPARAM16(0, v->service_interval);

   361

			SET_DPARAM16(1, v->date_of_last_service);

   362

			DrawString(13, 103, _patches.servint_ispercent?STR_SERVICING_INTERVAL_PERCENT:STR_883C_SERVICING_INTERVAL_DAYS, 0);

   363

		}

   364

   365

		DrawAircraftImage(v, 3, 57, INVALID_VEHICLE);

   366

   367

		{

   368

			int y = 57;

   369

   370

			do {

   371

				if (v->subtype <= 2) {

   372

					SET_DPARAM16(0, GetCustomEngineName(v->engine_type));

   373

					SET_DPARAM16(1, 1920 + v->build_year);

   374

					SET_DPARAM32(2, v->value);

   375

					DrawString(60, y, STR_A011_BUILT_VALUE, 0);

   376

					y += 10;

   377

   378

					SET_DPARAM16(0, _cargoc.names_long_p[v->cargo_type]);

   379

					SET_DPARAM16(1, v->cargo_cap);

   380

					u = v->next;

   381

					SET_DPARAM16(2, _cargoc.names_long_p[u->cargo_type]);

   382

					SET_DPARAM16(3, u->cargo_cap);

   383

					DrawString(60, y, STR_A019_CAPACITY + (u->cargo_cap == 0), 0);

   384

					y += 14;

   385

				}

   386

   387

				if (v->cargo_count != 0) {

   388

   389

					/* Cargo names (fix pluralness) */

   390

					SET_DPARAM8(0, v->cargo_type);

   391

					SET_DPARAM16(1, v->cargo_count);

   392

					SET_DPARAM16(2, v->cargo_source);

   393

					DrawString(60, y, STR_8813_FROM, 0);

   394

   395

					y += 10;

   396

				}

   397

			} while ( (v=v->next) != NULL);

   398

		}

   399

		break;

   400

   401

	case WE_CLICK:

   402

		switch(e->click.widget) {

   403

		case 2: /* rename */

   404

			SET_DPARAM16(0, v->unitnumber);

   405

			ShowQueryString(v->string_id, STR_A030_NAME_AIRCRAFT, 31, 150, w->window_class, w->window_number);

   406

			break;

   407

   408

		case 5: /* increase int */

   409

			mod = _ctrl_pressed? 5 : 10;

   410

			goto change_int;

   411

		case 6: /* decrease int */

   412

			mod = _ctrl_pressed?- 5 : -10;

   413

change_int:

   414

			mod += v->service_interval;

   415

   416

			/*	%-based service interval max 5%-90%

   417

					day-based service interval max 30-800 days */

   418

			mod = _patches.servint_ispercent ? clamp(mod, MIN_SERVINT_PERCENT, MAX_SERVINT_PERCENT) : clamp(mod, MIN_SERVINT_DAYS, MAX_SERVINT_DAYS+1);

   419

			if (mod == v->service_interval)

   420

				return;

   421

   422

			DoCommandP(v->tile, v->index, mod, NULL,

   423

				CMD_CHANGE_AIRCRAFT_SERVICE_INT | CMD_MSG(STR_018A_CAN_T_CHANGE_SERVICING));

   424

			break;

   425

		}

   426

		break;

   427

   428

	case WE_4:

   429

		if (FindWindowById(WC_VEHICLE_VIEW, w->window_number) == NULL)

   430

			DeleteWindow(w);

   431

		break;

   432

   433

	case WE_ON_EDIT_TEXT: {

   434

		byte *b = e->edittext.str;

   435

		if (*b == 0)

   436

			return;

   437

		memcpy(_decode_parameters, b, 32);

   438

		DoCommandP(0, w->window_number, 0, NULL, CMD_NAME_VEHICLE | CMD_MSG(STR_A031_CAN_T_NAME_AIRCRAFT));

   439

	} break;

   440

   441

	}

   442

}

   443

   444

   445

static const Widget _aircraft_details_widgets[] = {

   446

{    WWT_TEXTBTN,    14,     0,    10,     0,    13, STR_00C5, STR_018B_CLOSE_WINDOW},

   447

{    WWT_CAPTION,    14,    11,   349,     0,    13, STR_A00C_DETAILS, STR_018C_WINDOW_TITLE_DRAG_THIS},

   448

{ WWT_PUSHTXTBTN,    14,   350,   389,     0,    13, STR_01AA_NAME, STR_A032_NAME_AIRCRAFT},

   449

{     WWT_IMGBTN,    14,     0,   389,    14,    55, 0x0},

   450

{     WWT_IMGBTN,    14,     0,   389,    56,   101, 0x0},

   451

{ WWT_PUSHTXTBTN,    14,     0,    10,   102,   107, STR_0188, STR_884D_INCREASE_SERVICING_INTERVAL},

   452

{ WWT_PUSHTXTBTN,    14,     0,    10,   108,   113, STR_0189, STR_884E_DECREASE_SERVICING_INTERVAL},

   453

{     WWT_IMGBTN,    14,    11,   389,   102,   113, 0x0},

   454

{      WWT_LAST},

   455

};

   456

   457

static const WindowDesc _aircraft_details_desc = {

   458

	-1,-1, 390, 114,

   459

	WC_VEHICLE_DETAILS,WC_VEHICLE_VIEW,

   460

	WDF_STD_TOOLTIPS | WDF_STD_BTN | WDF_DEF_WIDGET | WDF_UNCLICK_BUTTONS,

   461

	_aircraft_details_widgets,

   462

	AircraftDetailsWndProc

   463

};

   464

   465

   466

static void ShowAircraftDetailsWindow(Vehicle *v)

   467

{

   468

	Window *w;

   469

	VehicleID veh = v->index;

   470

   471

	DeleteWindowById(WC_VEHICLE_ORDERS, veh);

   472

	DeleteWindowById(WC_VEHICLE_DETAILS, veh);

   473

   474

	_alloc_wnd_parent_num = veh;

   475

	w = AllocateWindowDesc(&_aircraft_details_desc);

   476

	w->window_number = veh;

   477

	w->caption_color = v->owner;

   478

//	w->vscroll.cap = 6;

   479

//	w->traindetails_d.tab = 0;

   480

}

   481

   482

   483

static const Widget _aircraft_view_widgets[] = {

   484

{    WWT_TEXTBTN,    14,     0,    10,     0,    13, STR_00C5, STR_018B_CLOSE_WINDOW},

   485

{    WWT_CAPTION,    14,    11,   249,     0,    13, STR_A00A, STR_018C_WINDOW_TITLE_DRAG_THIS},

   486

{     WWT_IMGBTN,    14,     0,   231,    14,   103, 0x0, 0},

   487

{          WWT_6,    14,     2,   229,    16,   101, 0x0, 0},

   488

{ WWT_PUSHIMGBTN,    14,     0,   249,   104,   115, 0x0, STR_A027_CURRENT_AIRCRAFT_ACTION},

   489

{ WWT_PUSHIMGBTN,    14,   232,   249,    14,    31, 0x2AB, STR_A029_CENTER_MAIN_VIEW_ON_AIRCRAFT},

   490

{ WWT_PUSHIMGBTN,    14,   232,   249,    32,    49, 0x2AF, STR_A02A_SEND_AIRCRAFT_TO_HANGAR},

   491

{ WWT_PUSHIMGBTN,    14,   232,   249,    50,    67, 0x2B4, STR_A03B_REFIT_AIRCRAFT_TO_CARRY},

   492

{ WWT_PUSHIMGBTN,    14,   232,   249,    68,    85, 0x2B2, STR_A028_SHOW_AIRCRAFT_S_ORDERS},

   493

{ WWT_PUSHIMGBTN,    14,   232,   249,    86,   103, 0x2B3, STR_A02B_SHOW_AIRCRAFT_DETAILS},

   494

{      WWT_LAST},

   495

};

   496

   497

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

   498

{

   499

	switch(e->event) {

   500

	case WE_PAINT: {

   501

		Vehicle *v = &_vehicles[w->window_number];

   502

		uint32 disabled = 1<<7;

   503

		StringID str;

   504

   505

		{

   506

			uint tile = v->tile;

   507

			if (IS_TILETYPE(tile, MP_STATION) &&

   508

					(_map5[tile] == 32 || _map5[tile] == 65) &&

   509

					v->vehstatus&VS_STOPPED)

   510

						disabled = 0;

   511

		}

   512

   513

		if (v->owner != _local_player)

   514

			disabled |= 1<<7 | 1<<6;

   515

		w->disabled_state = disabled;

   516

   517

		/* draw widgets & caption */

   518

		SET_DPARAM16(0, v->string_id);

   519

		SET_DPARAM16(1, v->unitnumber);

   520

		DrawWindowWidgets(w);

   521

   522

		/* draw the flag */

   523

		DrawSprite((v->vehstatus & VS_STOPPED) ? 0xC12  : 0xC13, 2, 105);

   524

   525

		if (v->vehstatus & VS_CRASHED) {

   526

			str = STR_8863_CRASHED;

   527

		} else if (v->vehstatus & VS_STOPPED) {

   528

			str = STR_8861_STOPPED;