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

    25

/**

    26

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

    27

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

    28

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

    29

 */

    30

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

    31

{

    32

	const RailVehicleInfo *rvi = RailVehInfo(engine_number);

    33

	const Engine* e = GetEngine(engine_number);

    34

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

    35

	YearMonthDay ymd;

    36

	ConvertDayToYMD(&ymd, e->intro_date);

    37

    38

	/* Purchase Cost - Engine weight */

    39

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

    40

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

    41

	DrawString(x,y, STR_PURCHASE_INFO_COST_WEIGHT, 0);

    42

	y += 10;

    43

    44

	/* Max speed - Engine power */

    45

	SetDParam(0, rvi->max_speed);

    46

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

    47

	DrawString(x,y, STR_PURCHASE_INFO_SPEED_POWER, 0);

    48

	y += 10;

    49

    50

	/* Running cost */

    51

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

    52

	DrawString(x,y, STR_PURCHASE_INFO_RUNNINGCOST, 0);

    53

	y += 10;

    54

    55

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

    56

	if (rvi->pow_wag_power != 0) {

    57

		SetDParam(0, rvi->pow_wag_power);

    58

		SetDParam(1, rvi->pow_wag_weight);

    59

		DrawString(x,y, STR_PURCHASE_INFO_PWAGPOWER_PWAGWEIGHT, 0);

    60

		y += 10;

    61

	};

    62

    63

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

    64

	SetDParam(0, STR_8838_N_A);

    65

	SetDParam(2, STR_EMPTY);

    66

	if (rvi->capacity != 0) {

    67

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

    68

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

    69

		SetDParam(2, STR_9842_REFITTABLE);

    70

	}

    71

	DrawString(x,y, STR_PURCHASE_INFO_CAPACITY, 0);

    72

	y += 10;

    73

    74

	/* Design date - Life length */

    75

	SetDParam(0, ymd.year + 1920);

    76

	SetDParam(1, e->lifelength);

    77

	DrawString(x,y, STR_PURCHASE_INFO_DESIGNED_LIFE, 0);

    78

	y += 10;

    79

    80

	/* Reliability */

    81

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

    82

	DrawString(x,y, STR_PURCHASE_INFO_RELIABILITY, 0);

    83

	y += 10;

    84

    85

	/* Additional text from NewGRF */

    86

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

    87

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

    88

}

    89

    90

/**

    91

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

    92

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

    93

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

    94

 */

    95

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

    96

{

    97

	const RailVehicleInfo *rvi = RailVehInfo(engine_number);

    98

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

    99

   100

	/* Purchase cost */

   101

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

   102

	DrawString(x, y, STR_PURCHASE_INFO_COST, 0);

   103

	y += 10;

   104

   105

	/* Wagon weight - (including cargo) */

   106

	SetDParam(0, rvi->weight);

   107

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

   108

	DrawString(x, y, STR_PURCHASE_INFO_WEIGHT_CWEIGHT, 0);

   109

	y += 10;

   110

   111

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

   112

	SetDParam(0, STR_8838_N_A);

   113

	SetDParam(2, STR_EMPTY);

   114

	if (rvi->capacity != 0) {

   115

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

   116

		SetDParam(1, rvi->capacity);

   117

		SetDParam(2, refittable ? STR_9842_REFITTABLE : STR_EMPTY);

   118

	}

   119

	DrawString(x, y, STR_PURCHASE_INFO_CAPACITY, 0);

   120

	y += 10;

   121

   122

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

   123

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

   124

		SetDParam(0, rvi->max_speed);

   125

		DrawString(x,y, STR_PURCHASE_INFO_SPEED, 0);

   126

		y += 10;

   127

	}

   128

   129

	/* Additional text from NewGRF */

   130

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

   131

}

   132

   133

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

   134

{

   135

	Vehicle *v,*found;

   136

   137

	if (!success)

   138

		return;

   139

   140

	// find a locomotive in the depot.

   141

	found = NULL;

   142

	FOR_ALL_VEHICLES(v) {

   143

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

   144

				v->tile == tile &&

   145

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

   146

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

   147

				return;

   148

			found = v;

   149

		}

   150

	}

   151

   152

	// if we found a loco,

   153

	if (found != NULL) {

   154

		found = GetLastVehicleInChain(found);

   155

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

   156

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

   157

		RebuildVehicleLists();

   158

	}

   159

}

   160

   161

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

   162

{

   163

	const Vehicle* v;

   164

   165

	if (!success) return;

   166

   167

	v = GetVehicle(_new_vehicle_id);

   168

	if (tile == _backup_orders_tile) {

   169

		_backup_orders_tile = 0;

   170

		RestoreVehicleOrders(v, _backup_orders_data);

   171

	}

   172

	ShowTrainViewWindow(v);

   173

}

   174

   175

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

   176

{

   177

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

   178

}

   179

   180

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

   181

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

   182

{

   183

	EngineID j;

   184

   185

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

   186

		EngineID i = GetRailVehAtPosition(j);

   187

		const Engine *e = GetEngine(i);

   188

		const RailVehicleInfo *rvi = RailVehInfo(i);

   189

   190

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

   191

				!HASBIT(e->player_avail, _local_player))

   192

			continue;

   193

   194

		if (*sel == 0)

   195

			*selected_id = i;

   196

   197

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

   198

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

   199

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

   200

			*y += 14;

   201

		}

   202

		--*sel;

   203

	}

   204

}

   205

   206

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

   207

{

   208

	switch (e->event) {

   209

	case WE_PAINT:

   210

   211

		if (w->window_number == 0)

   212

			SETBIT(w->disabled_state, 5);

   213

   214

		{

   215

			int count = 0;

   216

			RailType railtype = WP(w,buildtrain_d).railtype;

   217

			EngineID i;

   218

   219

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

   220

				const Engine *e = GetEngine(i);

   221

				if (HasPowerOnRail(e->railtype, railtype)

   222

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

   223

					count++;

   224

			}

   225

			SetVScrollCount(w, count);

   226

		}

   227

   228

		SetDParam(0, WP(w,buildtrain_d).railtype + STR_881C_NEW_RAIL_VEHICLES);

   229

		DrawWindowWidgets(w);

   230

   231

		{

   232

			RailType railtype = WP(w,buildtrain_d).railtype;

   233

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

   234

			int pos = w->vscroll.pos;

   235

			int x = 1;

   236

			int y = 15;

   237

			EngineID selected_id = INVALID_ENGINE;

   238

   239

			/* Ensure that custom engines which substituted wagons

   240

			 * are sorted correctly.

   241

			 * XXX - DO NOT EVER DO THIS EVER AGAIN! GRRR hacking in wagons as

   242

			 * engines to get more types.. Stays here until we have our own format

   243

			 * then it is exit!!! */

   244

			engine_drawing_loop(&x, &y, &pos, &sel, &selected_id, railtype, w->vscroll.cap, true); // True engines

   245

			engine_drawing_loop(&x, &y, &pos, &sel, &selected_id, railtype, w->vscroll.cap, false); // Feeble wagons

   246

   247

			WP(w,buildtrain_d).sel_engine = selected_id;

   248

   249

			if (selected_id != INVALID_ENGINE) {

   250

				const RailVehicleInfo *rvi = RailVehInfo(selected_id);

   251

   252

				if (!(rvi->flags & RVI_WAGON)) {

   253

					/* it's an engine */

   254

					DrawTrainEnginePurchaseInfo(2, w->widget[4].top + 1,selected_id);

   255

				} else {

   256

					/* it's a wagon */

   257

					DrawTrainWagonPurchaseInfo(2, w->widget[4].top + 1, selected_id);

   258

				}

   259

			}

   260

		}

   261

	break;

   262

   263

	case WE_CLICK: {

   264

		switch (e->click.widget) {

   265

		case 2: {

   266

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

   267

			if (i < w->vscroll.cap) {

   268

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

   269

				SetWindowDirty(w);

   270

			}

   271

		} break;

   272

		case 5: {

   273

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

   274

			if (sel_eng != INVALID_ENGINE)

   275

				DoCommandP(w->window_number, sel_eng, 0, (RailVehInfo(sel_eng)->flags & RVI_WAGON) ? CcBuildWagon : CcBuildLoco, CMD_BUILD_RAIL_VEHICLE | CMD_MSG(STR_882B_CAN_T_BUILD_RAILROAD_VEHICLE));

   276

		}	break;

   277

		case 6: { /* rename */

   278

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

   279

			if (sel_eng != INVALID_ENGINE) {

   280

				WP(w,buildtrain_d).rename_engine = sel_eng;

   281

				ShowQueryString(GetCustomEngineName(sel_eng),

   282

					STR_886A_RENAME_TRAIN_VEHICLE_TYPE, 31, 160, w->window_class, w->window_number);

   283

			}

   284

		} break;

   285

		}

   286

	} break;

   287

   288

	case WE_ON_EDIT_TEXT: {

   289

		if (e->edittext.str[0] != '\0') {

   290

			_cmd_text = e->edittext.str;

   291

			DoCommandP(0, WP(w,buildtrain_d).rename_engine, 0, NULL,

   292

				CMD_RENAME_ENGINE | CMD_MSG(STR_886B_CAN_T_RENAME_TRAIN_VEHICLE));

   293

		}

   294

	} break;

   295

   296

	case WE_RESIZE: {

   297

		if (e->sizing.diff.y == 0)

   298

			break;

   299

   300

		w->vscroll.cap += e->sizing.diff.y / 14;

   301

		w->widget[2].unkA = (w->vscroll.cap << 8) + 1;

   302

	} break;

   303

	}

   304

}

   305

   306

static const Widget _new_rail_vehicle_widgets[] = {

   307

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

   308

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

   309

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

   310

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

   311

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

   312

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

   313

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

   314

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

   315

{   WIDGETS_END},

   316

};

   317

   318

static const WindowDesc _new_rail_vehicle_desc = {

   319

	-1, -1, 228, 210,

   320

	WC_BUILD_VEHICLE,0,

   321

	WDF_STD_TOOLTIPS | WDF_STD_BTN | WDF_DEF_WIDGET | WDF_UNCLICK_BUTTONS | WDF_RESIZABLE,

   322

	_new_rail_vehicle_widgets,

   323

	NewRailVehicleWndProc

   324

};

   325

   326

static void ShowBuildTrainWindow(TileIndex tile)

   327

{

   328

	Window *w;

   329

   330

	DeleteWindowById(WC_BUILD_VEHICLE, tile);

   331

   332

	w = AllocateWindowDesc(&_new_rail_vehicle_desc);

   333

	w->window_number = tile;

   334

	w->vscroll.cap = 8;

   335

	w->widget[2].unkA = (w->vscroll.cap << 8) + 1;

   336

   337

	w->resize.step_height = 14;

   338

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

   339

   340

	if (tile != 0) {

   341

		w->caption_color = GetTileOwner(tile);

   342

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

   343

	} else {

   344

		w->caption_color = _local_player;

   345

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

   346

	}

   347

}

   348

   349

/**

   350

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

   351

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

   352

 * @return Number of pixels across.

   353

 */

   354

static int WagonLengthToPixels(int len) {

   355

	return (len * _traininfo_vehicle_width) / 8;

   356

}

   357

   358

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

   359

{

   360

	DrawPixelInfo tmp_dpi, *old_dpi;

   361

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

   362

	/* Position of highlight box */

   363

	int highlight_l = 0;

   364

	int highlight_r = 0;

   365

   366

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

   367

   368

	count = (count * 8) / _traininfo_vehicle_width;

   369

   370

	old_dpi = _cur_dpi;

   371

	_cur_dpi = &tmp_dpi;

   372

   373

	do {

   374

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

   375

   376

		if (dx + width > 0) {

   377

			if (dx <= count) {

   378

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

   379

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

   380

				if (v->index == selection) {

   381

					/* Set the highlight position */

   382

					highlight_l = WagonLengthToPixels(dx) + 1;

   383

					highlight_r = WagonLengthToPixels(dx + width) + 1;

   384

				}

   385

			}

   386

		}

   387

		dx += width;

   388

   389

		v = v->next;

   390

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

   391

   392

	if (highlight_l != highlight_r) {

   393

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

   394

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

   395

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

   396

	}

   397

   398

	_cur_dpi = old_dpi;

   399

}

   400

   401

static void DrawTrainDepotWindow(Window *w)

   402

{

   403

	TileIndex tile;

   404

	Vehicle *v, *u;

   405

	int num,x,y,i, hnum;

   406

	Depot *depot;

   407

   408

	tile = w->window_number;

   409

   410

	/* setup disabled buttons */

   411

	w->disabled_state =

   412

		IsTileOwner(tile, _local_player) ? 0 : ((1 << 4) | (1 << 5) | (1 << 8) | (1<<9));

   413

   414

	/* determine amount of items for scroller */

   415

	num = 0;

   416

	hnum = 8;

   417

	FOR_ALL_VEHICLES(v) {

   418

		if (v->type == VEH_Train &&

   419

			  (IsFrontEngine(v) || IsFreeWagon(v)) &&

   420

				v->tile == tile &&

   421

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

   422

			num++;

   423

			// determine number of items in the X direction.

   424

			if (IsFrontEngine(v)) {

   425

				hnum = max(hnum, v->u.rail.cached_total_length);

   426

			}

   427

		}

   428

	}

   429

   430

	/* Always have 1 empty row, so people can change the setting of the train */

   431

	num++;

   432

   433

	SetVScrollCount(w, num);

   434

	SetHScrollCount(w, WagonLengthToPixels(hnum));

   435

   436

	/* locate the depot struct */

   437

	depot = GetDepotByTile(tile);

   438

	assert(depot != NULL);

   439

   440

	SetDParam(0, depot->town_index);

   441

	DrawWindowWidgets(w);

   442

   443

	x = 2;

   444

	y = 15;

   445

	num = w->vscroll.pos;

   446

   447

	// draw all trains

   448

	FOR_ALL_VEHICLES(v) {

   449

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

   450

				v->tile == tile && v->u.rail.track == 0x80 &&

   451

				--num < 0 && num >= -w->vscroll.cap) {

   452

			DrawTrainImage(v, x+21, y, w->hscroll.cap + 4, w->hscroll.pos, WP(w,traindepot_d).sel);

   453

			/* Draw the train number */

   454

			SetDParam(0, v->unitnumber);

   455

			DrawString(x, y, (v->max_age - 366 < v->age) ? STR_00E3 : STR_00E2, 0);

   456

   457

			// Number of wagons relative to a standard length wagon (rounded up)

   458

			SetDParam(0, (v->u.rail.cached_total_length + 7) / 8);

   459

			DrawStringRightAligned(w->widget[6].right - 1, y + 4, STR_TINY_BLACK, 0);	//Draw the counter

   460

   461

			/* Draw the pretty flag */

   462

			DrawSprite(v->vehstatus & VS_STOPPED ? SPR_FLAG_VEH_STOPPED : SPR_FLAG_VEH_RUNNING, x + 15, y);

   463

   464

			y += 14;

   465

		}

   466

	}

   467

   468

	// draw all remaining vehicles

   469

	FOR_ALL_VEHICLES(v) {

   470

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

   471

				v->tile == tile && v->u.rail.track == 0x80 &&

   472

				--num < 0 && num >= -w->vscroll.cap) {

   473

			DrawTrainImage(v, x+50, y, w->hscroll.cap - 29, 0, WP(w,traindepot_d).sel);

   474

			DrawString(x, y+2, STR_8816, 0);

   475

   476

			/*Draw the train counter */

   477

			i = 0;

   478

			u = v;

   479

			do i++; while ( (u=u->next) != NULL);		//Determine length of train

   480

			SetDParam(0, i);				//Set the counter

   481

			DrawStringRightAligned(w->widget[6].right - 1, y + 4, STR_TINY_BLACK, 0);	//Draw the counter

   482

			y += 14;

   483

		}

   484

	}

   485

}

   486

   487

typedef struct GetDepotVehiclePtData {

   488

	Vehicle *head;

   489

	Vehicle *wagon;

   490

} GetDepotVehiclePtData;

   491

   492

static int GetVehicleFromTrainDepotWndPt(const Window *w, int x, int y, GetDepotVehiclePtData *d)