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

    38

/**

    39

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

    40

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

    41

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

    42

 */

    43

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

    44

{

    45

	const RailVehicleInfo *rvi = RailVehInfo(engine_number);

    46

	const Engine *e = GetEngine(engine_number);

    47

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

    48

	YearMonthDay ymd;

    49

	ConvertDateToYMD(e->intro_date, &ymd);

    50

    51

	/* Purchase Cost - Engine weight */

    52

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

    53

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

    54

	DrawString(x,y, STR_PURCHASE_INFO_COST_WEIGHT, 0);

    55

	y += 10;

    56

    57

	/* Max speed - Engine power */

    58

	SetDParam(0, rvi->max_speed);

    59

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

    60

	DrawString(x,y, STR_PURCHASE_INFO_SPEED_POWER, 0);

    61

	y += 10;

    62

    63

	/* Running cost */

    64

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

    65

	DrawString(x,y, STR_PURCHASE_INFO_RUNNINGCOST, 0);

    66

	y += 10;

    67

    68

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

    69

	if (rvi->pow_wag_power != 0) {

    70

		SetDParam(0, rvi->pow_wag_power);

    71

		SetDParam(1, rvi->pow_wag_weight);

    72

		DrawString(x,y, STR_PURCHASE_INFO_PWAGPOWER_PWAGWEIGHT, 0);

    73

		y += 10;

    74

	};

    75

    76

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

    77

	SetDParam(0, STR_8838_N_A);

    78

	SetDParam(2, STR_EMPTY);

    79

	if (rvi->capacity != 0) {

    80

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

    81

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

    82

		SetDParam(2, STR_9842_REFITTABLE);

    83

	}

    84

	DrawString(x,y, STR_PURCHASE_INFO_CAPACITY, 0);

    85

	y += 10;

    86

    87

	/* Design date - Life length */

    88

	SetDParam(0, ymd.year);

    89

	SetDParam(1, e->lifelength);

    90

	DrawString(x,y, STR_PURCHASE_INFO_DESIGNED_LIFE, 0);

    91

	y += 10;

    92

    93

	/* Reliability */

    94

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

    95

	DrawString(x,y, STR_PURCHASE_INFO_RELIABILITY, 0);

    96

	y += 10;

    97

    98

	/* Additional text from NewGRF */

    99

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

   100

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

   101

}

   102

   103

/**

   104

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

   105

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

   106

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

   107

 */

   108

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

   109

{

   110

	const RailVehicleInfo *rvi = RailVehInfo(engine_number);

   111

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

   112

   113

	/* Purchase cost */

   114

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

   115

	DrawString(x, y, STR_PURCHASE_INFO_COST, 0);

   116

	y += 10;

   117

   118

	/* Wagon weight - (including cargo) */

   119

	SetDParam(0, rvi->weight);

   120

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

   121

	DrawString(x, y, STR_PURCHASE_INFO_WEIGHT_CWEIGHT, 0);

   122

	y += 10;

   123

   124

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

   125

	SetDParam(0, STR_8838_N_A);

   126

	SetDParam(2, STR_EMPTY);

   127

	if (rvi->capacity != 0) {

   128

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

   129

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

   130

		SetDParam(2, refittable ? STR_9842_REFITTABLE : STR_EMPTY);

   131

	}

   132

	DrawString(x, y, STR_PURCHASE_INFO_CAPACITY, 0);

   133

	y += 10;

   134

   135

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

   136

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

   137

		SetDParam(0, rvi->max_speed);

   138

		DrawString(x,y, STR_PURCHASE_INFO_SPEED, 0);

   139

		y += 10;

   140

	}

   141

   142

	/* Additional text from NewGRF */

   143

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

   144

}

   145

   146

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

   147

{

   148

	Vehicle *v, *found;

   149

   150

	if (!success) return;

   151

   152

	// find a locomotive in the depot.

   153

	found = NULL;

   154

	FOR_ALL_VEHICLES(v) {

   155

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

   156

				v->tile == tile &&

   157

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

   158

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

   159

			found = v;

   160

		}

   161

	}

   162

   163

	// if we found a loco,

   164

	if (found != NULL) {

   165

		found = GetLastVehicleInChain(found);

   166

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

   167

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

   168

		RebuildVehicleLists();

   169

	}

   170

}

   171

   172

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

   173

{

   174

	const Vehicle *v;

   175

   176

	if (!success) return;

   177

   178

	v = GetVehicle(_new_vehicle_id);

   179

	if (tile == _backup_orders_tile) {

   180

		_backup_orders_tile = 0;

   181

		RestoreVehicleOrders(v, _backup_orders_data);

   182

	}

   183

	ShowTrainViewWindow(v);

   184

}

   185

   186

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

   187

{

   188

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

   189

}

   190

   191

static void engine_drawing_loop(int *x, int *y, int *pos, int *sel,

   192

	EngineID *selected_id, RailType railtype, byte show_max, bool is_engine)

   193

{

   194

	EngineID j;

   195

   196

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

   197

		EngineID i = GetRailVehAtPosition(j);

   198

		const Engine *e = GetEngine(i);

   199

		const RailVehicleInfo *rvi = RailVehInfo(i);

   200

   201

		if (!HasPowerOnRail(e->railtype, railtype) || !(rvi->flags & RVI_WAGON) != is_engine ||

   202

				!HASBIT(e->player_avail, _local_player))

   203

			continue;

   204

   205

		if (*sel == 0) *selected_id = i;

   206

   207

		if (IS_INT_INSIDE(--*pos, -show_max, 0)) {

   208

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

   209

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

   210

			*y += 14;

   211

		}

   212

		--*sel;

   213

	}

   214

}

   215

   216

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

   217

{

   218

	switch (e->event) {

   220

   222

   269

				}

   270

			}

   272

   282

   288

   297

			}

   298

		} break;

   305

			}

   306

		} break;

   307

   310

   314

	}

   315

}

   316

   317

static const Widget _new_rail_vehicle_widgets[] = {

   318

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

   319

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

   320

{     WWT_MATRIX, RESIZE_BOTTOM,    14,     0,   215,    14,   125, 0x801,                  STR_8843_TRAIN_VEHICLE_SELECTION},

   321

{  WWT_SCROLLBAR, RESIZE_BOTTOM,    14,   216,   227,    14,   125, 0x0,                    STR_0190_SCROLL_BAR_SCROLLS_LIST},

   322

{      WWT_PANEL,     RESIZE_TB,    14,     0,   227,   126,   197, 0x0,                    STR_NULL},

   323

{ WWT_PUSHTXTBTN,     RESIZE_TB,    14,     0,   107,   198,   209, STR_881F_BUILD_VEHICLE, STR_8844_BUILD_THE_HIGHLIGHTED_TRAIN},

   324

{ WWT_PUSHTXTBTN,     RESIZE_TB,    14,   108,   215,   198,   209, STR_8820_RENAME,        STR_8845_RENAME_TRAIN_VEHICLE_TYPE},

   325

{  WWT_RESIZEBOX,     RESIZE_TB,    14,   216,   227,   198,   209, 0x0,                    STR_RESIZE_BUTTON},

   326

{   WIDGETS_END},

   327

};

   328

   329

static const WindowDesc _new_rail_vehicle_desc = {

   330

	-1, -1, 228, 210,

   331

	WC_BUILD_VEHICLE,0,

   332

	WDF_STD_TOOLTIPS | WDF_STD_BTN | WDF_DEF_WIDGET | WDF_UNCLICK_BUTTONS | WDF_RESIZABLE,

   333

	_new_rail_vehicle_widgets,

   334

	NewRailVehicleWndProc

   335

};

   336

   337

void ShowBuildTrainWindow(TileIndex tile)

   338

{

   339

	Window *w;

   340

   341

	DeleteWindowById(WC_BUILD_VEHICLE, tile);

   342

   343

	w = AllocateWindowDesc(&_new_rail_vehicle_desc);

   344

	w->window_number = tile;

   345

	w->vscroll.cap = 8;

   347

   348

	w->resize.step_height = 14;

   349

	w->resize.height = w->height - 14 * 4; // Minimum of 4 vehicles in the display

   350

   351

	if (tile != 0) {

   352

		w->caption_color = GetTileOwner(tile);

   353

		WP(w,buildtrain_d).railtype = GetRailType(tile);

   354

	} else {

   355

		w->caption_color = _local_player;

   356

		WP(w,buildtrain_d).railtype = GetBestRailtype(GetPlayer(_local_player));

   357

	}

   358

}

   359

   360

/**

   361

 * Get the number of pixels for the given wagon length.

   362

 * @param len Length measured in 1/8ths of a standard wagon.

   363

 * @return Number of pixels across.

   364

 */

   365

int WagonLengthToPixels(int len) {

   366

	return (len * _traininfo_vehicle_width) / 8;

   367

}

   368

   369

void DrawTrainImage(const Vehicle *v, int x, int y, int count, int skip, VehicleID selection)

   370

{

   371

	DrawPixelInfo tmp_dpi, *old_dpi;

   372

	int dx = -(skip * 8) / _traininfo_vehicle_width;

   373

	/* Position of highlight box */

   374

	int highlight_l = 0;

   375

	int highlight_r = 0;

   376

   377

	if (!FillDrawPixelInfo(&tmp_dpi, x - 2, y - 1, count + 1, 14)) return;

   378

   379

	count = (count * 8) / _traininfo_vehicle_width;

   380

   381

	old_dpi = _cur_dpi;

   382

	_cur_dpi = &tmp_dpi;

   383

   384

	do {

   385

		int width = v->u.rail.cached_veh_length;

   386

   387

		if (dx + width > 0) {

   388

			if (dx <= count) {

   389

				PalSpriteID pal = (v->vehstatus & VS_CRASHED) ? PALETTE_CRASH : GetVehiclePalette(v);

   390

				DrawSprite(GetTrainImage(v, DIR_W) | pal, 16 + WagonLengthToPixels(dx), 7 + (is_custom_sprite(RailVehInfo(v->engine_type)->image_index) ? _traininfo_vehicle_pitch : 0));

   391

				if (v->index == selection) {

   392

					/* Set the highlight position */

   393

					highlight_l = WagonLengthToPixels(dx) + 1;

   394

					highlight_r = WagonLengthToPixels(dx + width) + 1;

   395

				}

   396

			}

   397

		}

   398

		dx += width;

   399

   400

		v = v->next;

   401

	} while (dx < count && v != NULL);

   402

   403

	if (highlight_l != highlight_r) {

   404

		/* Draw the highlight. Now done after drawing all the engines, as

   405

		 * the next engine after the highlight could overlap it. */

   406

		DrawFrameRect(highlight_l, 0, highlight_r, 13, 15, FR_BORDERONLY);

   407

	}

   408

   409

	_cur_dpi = old_dpi;

   410

}

   411

   412

static const Widget _train_view_widgets[] = {

   413

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

   414

{    WWT_CAPTION, RESIZE_RIGHT, 14,  11, 237,   0,  13, STR_882E,        STR_018C_WINDOW_TITLE_DRAG_THIS },

   415

{  WWT_STICKYBOX,    RESIZE_LR, 14, 238, 249,   0,  13, 0x0,             STR_STICKY_BUTTON },

   416

{      WWT_PANEL,    RESIZE_RB, 14,   0, 231,  14, 121, 0x0,             STR_NULL },

   417

{          WWT_6,    RESIZE_RB, 14,   2, 229,  16, 119, 0x0,             STR_NULL },

   418

{ WWT_PUSHIMGBTN,   RESIZE_RTB, 14,   0, 237, 122, 133, 0x0,             STR_8846_CURRENT_TRAIN_ACTION_CLICK },

   419

{ WWT_PUSHIMGBTN,    RESIZE_LR, 14, 232, 249,  14,  31, 0x2AB,           STR_8848_CENTER_MAIN_VIEW_ON_TRAIN },

   420

{ WWT_PUSHIMGBTN,    RESIZE_LR, 14, 232, 249,  32,  49, 0x2AD,           STR_8849_SEND_TRAIN_TO_DEPOT },

   421

{ WWT_PUSHIMGBTN,    RESIZE_LR, 14, 232, 249,  50,  67, 0x2B1,           STR_884A_FORCE_TRAIN_TO_PROCEED },

   422

{ WWT_PUSHIMGBTN,    RESIZE_LR, 14, 232, 249,  68,  85, 0x2CB,           STR_884B_REVERSE_DIRECTION_OF_TRAIN },

   423

{ WWT_PUSHIMGBTN,    RESIZE_LR, 14, 232, 249,  86, 103, 0x2B2,           STR_8847_SHOW_TRAIN_S_ORDERS },

   424

{ WWT_PUSHIMGBTN,    RESIZE_LR, 14, 232, 249, 104, 121, 0x2B3,           STR_884C_SHOW_TRAIN_DETAILS },

   425

{ WWT_PUSHIMGBTN,    RESIZE_LR, 14, 232, 249,  68,  85, 0x2B4,           STR_RAIL_REFIT_VEHICLE_TO_CARRY },

   426

{ WWT_PUSHIMGBTN,    RESIZE_LR, 14, 232, 249,  32,  49, SPR_CLONE_TRAIN, STR_CLONE_TRAIN_INFO },

   427

{      WWT_PANEL,   RESIZE_LRB, 14, 232, 249, 122, 121, 0x0,             STR_NULL },

   428

{  WWT_RESIZEBOX,  RESIZE_LRTB, 14, 238, 249, 122, 133, 0x0,             STR_NULL },

   429

{ WIDGETS_END }

   430

};

   431

   432

static void ShowTrainDetailsWindow(const Vehicle *v);

   433

   434

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

   435

{

   436

	switch (e->event) {

   437

	case WE_PAINT: {

   438

		const Vehicle *v, *u;

   439

		StringID str;

   440

		bool is_localplayer;

   441

   442

		v = GetVehicle(w->window_number);

   443

   444

		is_localplayer = v->owner == _local_player;

   445

		SetWindowWidgetDisabledState(w,  7, !is_localplayer);

   446

		SetWindowWidgetDisabledState(w,  8, !is_localplayer);

   447

		SetWindowWidgetDisabledState(w,  9, !is_localplayer);

   448

		SetWindowWidgetDisabledState(w, 12, !is_localplayer);

   449

		SetWindowWidgetDisabledState(w, 13, !is_localplayer);

   450

   451

		if (is_localplayer) {

   452

			/* See if any vehicle can be refitted */

   453

			for (u = v; u != NULL; u = u->next) {

   454

				if (EngInfo(u->engine_type)->refit_mask != 0 ||

   455

						(!(RailVehInfo(v->engine_type)->flags & RVI_WAGON) && v->cargo_cap != 0)) {

   456

					EnableWindowWidget(w, 12);

   457

					/* We have a refittable carriage, bail out */

   458

					break;

   459

				}

   460

			}

   461

		}

   462

   463

		/* draw widgets & caption */

   464

		SetDParam(0, v->string_id);

   465

		SetDParam(1, v->unitnumber);

   466

		DrawWindowWidgets(w);

   467

   468

		if (v->u.rail.crash_anim_pos != 0) {

   469

			str = STR_8863_CRASHED;

   470

		} else if (v->breakdown_ctr == 1) {

   471

			str = STR_885C_BROKEN_DOWN;

   472

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

   473

			if (v->u.rail.last_speed == 0) {

   474

				if (v->u.rail.cached_power == 0) {

   475

					str = STR_TRAIN_NO_POWER;

   476

				} else {

   477

					str = STR_8861_STOPPED;

   478

				}

   479

			} else {

   480

				SetDParam(0, v->u.rail.last_speed);

   481

				str = STR_TRAIN_STOPPING + _patches.vehicle_speed;

   482

			}

   483

		} else {

   484

			switch (v->current_order.type) {

   485

			case OT_GOTO_STATION: {

   486

				str = STR_HEADING_FOR_STATION + _patches.vehicle_speed;

   487

				SetDParam(0, v->current_order.dest);

   488

				SetDParam(1, v->u.rail.last_speed);

   489

			} break;

   490