1

/* $Id$ */

     2

     3

#include "stdafx.h"

     4

#include "openttd.h"

     5

#include "debug.h"

     6

#include "functions.h"

     7

#include "table/sprites.h"

     8

#include "table/strings.h"

     9

#include "map.h"

    10

#include "window.h"

    11

#include "gui.h"

    12

#include "gfx.h"

    13

#include "vehicle.h"

    14

#include "viewport.h"

    15

#include "station.h"

    16

#include "command.h"

    17

#include "player.h"

    18

#include "engine.h"

    19

#include "vehicle_gui.h"

    20

#include "depot.h"

    21

    22

int _traininfo_vehicle_pitch = 0;

    23

    24

/**

    25

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

    26

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

    27

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

    28

 */

    29

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

    30

{

    31

	const RailVehicleInfo *rvi = RailVehInfo(engine_number);

    32

	const Engine* e = GetEngine(engine_number);

    33

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

    34

	YearMonthDay ymd;

    35

	ConvertDayToYMD(&ymd, e->intro_date);

    36

    37

	/* Purchase Cost - Engine weight */

    38

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

    39

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

    40

	DrawString(x,y, STR_PURCHASE_INFO_COST_WEIGHT, 0);

    41

	y += 10;

    42

    43

	/* Max speed - Engine power */

    44

	SetDParam(0, rvi->max_speed * 10 >> 4);

    45

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

    46

	DrawString(x,y, STR_PURCHASE_INFO_SPEED_POWER, 0);

    47

	y += 10;

    48

    49

	/* Running cost */

    50

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

    51

	DrawString(x,y, STR_PURCHASE_INFO_RUNNINGCOST, 0);

    52

	y += 10;

    53

    54

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

    55

	if (rvi->pow_wag_power != 0) {

    56

		SetDParam(0, rvi->pow_wag_power);

    57

		SetDParam(1, rvi->pow_wag_weight);

    58

		DrawString(x,y, STR_PURCHASE_INFO_PWAGPOWER_PWAGWEIGHT, 0);

    59

		y += 10;

    60

	};

    61

    62

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

    63

	SetDParam(0, STR_8838_N_A);

    64

	SetDParam(2, STR_EMPTY);

    65

	if (rvi->capacity != 0) {

    66

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

    67

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

    68

		SetDParam(2, STR_9842_REFITTABLE);

    69

	}

    70

	DrawString(x,y, STR_PURCHASE_INFO_CAPACITY, 0);

    71

	y += 10;

    72

    73

	/* Design date - Life length */

    74

	SetDParam(0, ymd.year + 1920);

    75

	SetDParam(1, e->lifelength);

    76

	DrawString(x,y, STR_PURCHASE_INFO_DESIGNED_LIFE, 0);

    77

	y += 10;

    78

    79

	/* Reliability */

    80

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

    81

	DrawString(x,y, STR_PURCHASE_INFO_RELIABILITY, 0);

    82

	y += 10;

    83

}

    84

    85

/**

    86

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

    87

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

    88

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

    89

 */

    90

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

    91

{

    92

	const RailVehicleInfo *rvi = RailVehInfo(engine_number);

    93

	bool refittable = (_engine_refit_masks[engine_number] != 0);

    94

    95

	/* Purchase cost */

    96

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

    97

	DrawString(x, y, STR_PURCHASE_INFO_COST, 0);

    98

	y += 10;

    99

   100

	/* Wagon weight - (including cargo) */

   101

	SetDParam(0, rvi->weight);

   102

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

   103

	DrawString(x, y, STR_PURCHASE_INFO_WEIGHT_CWEIGHT, 0);

   104

	y += 10;

   105

   106

	/* Cargo type + capacity */

   107

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

   108

	SetDParam(1, rvi->capacity);

   109

	SetDParam(2, refittable ? STR_9842_REFITTABLE : STR_EMPTY);

   110

	DrawString(x, y, STR_PURCHASE_INFO_CAPACITY, 0);

   111

	y += 10;

   112

}

   113

   114

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

   115

{

   116

	Vehicle *v,*found;

   117

   118

	if (!success)

   119

		return;

   120

   121

	// find a locomotive in the depot.

   122

	found = NULL;

   123

	FOR_ALL_VEHICLES(v) {

   124

		if (v->type == VEH_Train && v->subtype == TS_Front_Engine &&

   125

				v->tile == tile &&

   126

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

   127

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

   128

				return;

   129

			found = v;

   130

		}

   131

	}

   132

   133

	// if we found a loco,

   134

	if (found != NULL) {

   135

		found = GetLastVehicleInChain(found);

   136

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

   137

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

   138

		RebuildVehicleLists();

   139

	}

   140

}

   141

   142

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

   143

{

   144

	Vehicle *v;

   145

   146

	if (!success)

   147

		return;

   148

   149

	v = GetVehicle(_new_train_id);

   150

	if (tile == _backup_orders_tile) {

   151

		_backup_orders_tile = 0;

   152

		RestoreVehicleOrders(v, _backup_orders_data);

   153

	}

   154

	ShowTrainViewWindow(v);

   155

}

   156

   157

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

   158

	int *selected_id, byte railtype, byte show_max, bool is_engine)

   159

{

   160

	int i;

   161

   162

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

   163

		const Engine *e = GetEngine(i);

   164

		const RailVehicleInfo *rvi = RailVehInfo(i);

   165

   166

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

   167

				!HASBIT(e->player_avail, _local_player))

   168

			continue;

   169

   170

		if (*sel == 0)

   171

			*selected_id = i;

   172

   173

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

   174

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

   175

			DrawTrainEngine(*x + 29, *y + 6 + _traininfo_vehicle_pitch, i,

   176

				SPRITE_PALETTE(PLAYER_SPRITE_COLOR(_local_player)));

   177

			*y += 14;

   178

		}

   179

		--*sel;

   180

	}

   181

}

   182

   183

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

   184

{

   185

	switch(e->event) {

   186

	case WE_PAINT:

   187

   188

		if (w->window_number == 0)

   189

			SETBIT(w->disabled_state, 5);

   190

   191

		{

   192

			int count = 0;

   193

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

   194

			int i;

   195

   196

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

   197

				const Engine *e = GetEngine(i);

   198

				if (IsCompatibleRail(railtype, e->railtype)

   199

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

   200

					count++;

   201

			}

   202

			SetVScrollCount(w, count);

   203

		}

   204

   205

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

   206

		DrawWindowWidgets(w);

   207

   208

		{

   209

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

   210

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

   211

			int pos = w->vscroll.pos;

   212

			int x = 1;

   213

			int y = 15;

   214

			int selected_id = -1;

   215

   216

			/* Ensure that custom engines which substituted wagons

   217

			 * are sorted correctly.

   218

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

   219

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

   220

			 * then it is exit!!! */

   221

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

   222

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

   223

   224

			WP(w,buildtrain_d).sel_engine = selected_id;

   225

   226

			if (selected_id != -1) {

   227

				const RailVehicleInfo *rvi = RailVehInfo(selected_id);

   228

   229

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

   230

					/* it's an engine */

   231

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

   232

				} else {

   233

					/* it's a wagon */

   234

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

   235

				}

   236

			}

   237

		}

   238

	break;

   239

   240

	case WE_CLICK: {

   241

		switch(e->click.widget) {

   242

		case 2: {

   243

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

   244

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

   245

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

   246

				SetWindowDirty(w);

   247

			}

   248

		} break;

   249

		case 5: {

   250

			int sel_eng;

   251

			sel_eng = WP(w,buildtrain_d).sel_engine;

   252

			if (sel_eng != -1)

   253

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

   254

		}	break;

   255

		case 6: { /* rename */

   256

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

   257

			if (sel_eng != -1) {

   258

				WP(w,buildtrain_d).rename_engine = sel_eng;

   259

				ShowQueryString(GetCustomEngineName(sel_eng),

   260

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

   261

			}

   262

		} break;

   263

		}

   264

	} break;

   265

   266

	case WE_4:

   267

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

   268

			DeleteWindow(w);

   269

		}

   270

		break;

   271

   272

	case WE_ON_EDIT_TEXT: {

   273

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

   274

			_cmd_text = e->edittext.str;

   275

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

   276

				CMD_RENAME_ENGINE | CMD_MSG(STR_886B_CAN_T_RENAME_TRAIN_VEHICLE));

   277

		}

   278

	} break;

   279

   280

	case WE_RESIZE: {

   281

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

   282

			break;

   283

   284

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

   285

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

   286

	} break;

   287

	}

   288

}

   289

   290

static const Widget _new_rail_vehicle_widgets[] = {

   291

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

   292

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

   293

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

   294

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

   295

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

   296

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

   297

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

   298

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

   299

{   WIDGETS_END},

   300

};

   301

   302

static const WindowDesc _new_rail_vehicle_desc = {

   303

	-1, -1, 228, 210,

   304

	WC_BUILD_VEHICLE,0,

   305

	WDF_STD_TOOLTIPS | WDF_STD_BTN | WDF_DEF_WIDGET | WDF_UNCLICK_BUTTONS | WDF_RESIZABLE,

   306

	_new_rail_vehicle_widgets,

   307

	NewRailVehicleWndProc

   308

};

   309

   310

static void ShowBuildTrainWindow(TileIndex tile)

   311

{

   312

	Window *w;

   313

   314

	DeleteWindowById(WC_BUILD_VEHICLE, tile);

   315

   316

	w = AllocateWindowDesc(&_new_rail_vehicle_desc);

   317

	w->window_number = tile;

   318

	w->vscroll.cap = 8;

   319

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

   320

   321

	w->resize.step_height = 14;

   322

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

   323

   324

	if (tile != 0) {

   325

		w->caption_color = GetTileOwner(tile);

   326

		WP(w,buildtrain_d).railtype = _m[tile].m3 & 0xF;

   327

	} else {

   328

		w->caption_color = _local_player;

   329

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

   330

	}

   331

}

   332

   333

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

   334

{

   335

	int max_x = x + count * 29;

   336

   337

	do {

   338

		if (--skip < 0) {

   339

			int image = GetTrainImage(v, 6);

   340

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

   341

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

   342

   343

			if (x + width + 4 <= max_x) {

   344

				if (v->vehstatus & VS_CRASHED)

   345

					ormod = PALETTE_CRASH;

   346

				DrawSprite(image | ormod, x + 14, y + 6 + _traininfo_vehicle_pitch);

   347

				if (v->index == selection)

   348

					DrawFrameRect(x - 1, y - 1, x + width + 4, y + 12, 15, FR_BORDERONLY);

   349

			}

   350

			x += width + 5;

   351

		}

   352

   353

		if (!(v = v->next))

   354

			break;

   355

	} while (x < max_x);

   356

}

   357

   358

static void DrawTrainDepotWindow(Window *w)

   359

{

   360

	TileIndex tile;

   361

	Vehicle *v, *u;

   362

	int num,x,y,i, hnum;

   363

	Depot *depot;

   364

   365

	tile = w->window_number;

   366

   367

	/* setup disabled buttons */

   368

	w->disabled_state =

   369

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

   370

   371

	/* determine amount of items for scroller */

   372

	num = 0;

   373

	hnum = 1;

   374

	FOR_ALL_VEHICLES(v) {

   375

		if (v->type == VEH_Train &&

   376

			  (v->subtype == TS_Front_Engine || v->subtype == TS_Free_Car) &&

   377

				v->tile == tile &&

   378

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

   379

			num++;

   380

			// determine number of items in the X direction.

   381

			if (v->subtype == TS_Front_Engine) {

   382

				i = 0;

   383

				u = v;

   384

				do i++; while ((u = u->next) != NULL);

   385

				if (i > hnum) hnum = i;

   386

			}

   387

		}

   388

	}

   389

   390

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

   391

	num++;

   392

   393

	SetVScrollCount(w, num);

   394

	SetHScrollCount(w, hnum);

   395

   396

	/* locate the depot struct */

   397

	depot = GetDepotByTile(tile);

   398

	assert(depot != NULL);

   399

   400

	SetDParam(0, depot->town_index);

   401

	DrawWindowWidgets(w);

   402

   403

	x = 2;

   404

	y = 15;

   405

	num = w->vscroll.pos;

   406

   407

	// draw all trains

   408

	FOR_ALL_VEHICLES(v) {

   409

		if (v->type == VEH_Train && v->subtype == TS_Front_Engine &&

   410

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

   411

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

   412

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

   413

			/* Draw the train number */

   414

			SetDParam(0, v->unitnumber);

   415

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

   416

   417

			/*Draw the train counter */

   418

			i = 0;

   419

			u = v;

   420

			do {

   421

				i += u->u.rail.cached_veh_length + 1;

   422

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

   423

   424

			SetDParam(0, (i + 8) / 9);			//Set the counter

   425

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

   426

   427

			/* Draw the pretty flag */

   428

			DrawSprite(v->vehstatus&VS_STOPPED ? 0xC12 : 0xC13, x+15, y);

   429

   430

			y += 14;

   431

		}

   432

	}

   433

   434

	// draw all remaining vehicles

   435

	FOR_ALL_VEHICLES(v) {

   436

		if (v->type == VEH_Train && v->subtype == TS_Free_Car &&

   437

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

   438

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

   439

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

   440

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

   441

   442

			/*Draw the train counter */

   443

			i = 0;

   444

			u = v;

   445

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

   446

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

   447

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

   448

			y += 14;

   449

		}

   450

	}

   451

}

   452

   453

typedef struct GetDepotVehiclePtData {

   454

	Vehicle *head;

   455

	Vehicle *wagon;

   456

} GetDepotVehiclePtData;

   457

   458

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

   459

{

   460

	int row;

   461

	int skip = 0;

   462

	Vehicle *v;

   463

   464

	x = x - 23;

   465

   466

	row = (y - 14) / 14;

   467

	if ( (uint) row >= w->vscroll.cap)

   468

		return 1; /* means err */

   469

   470

	row += w->vscroll.pos;

   471

   472

	/* go through all the locomotives */

   473

	FOR_ALL_VEHICLES(v) {

   474

		if (v->type == VEH_Train &&

   475

				v->subtype == TS_Front_Engine &&

   476

				v->tile == w->window_number &&

   477

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

   478

				--row < 0) {

   479

					skip = w->hscroll.pos;

   480

					goto found_it;

   481

		}

   482

	}

   483

   484

	x -= 29; /* free wagons don't have an initial loco. */

   485

   486

	/* and then the list of free wagons */

   487

	FOR_ALL_VEHICLES(v) {

   488

		if (v->type == VEH_Train &&

   489

				v->subtype == TS_Free_Car &&

   490

				v->tile == w->window_number &&

   491

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

   492

				--row < 0)

   493

					goto found_it;

   494

	}

   495

   496

	d->head = NULL;

   497

	d->wagon = NULL;

   498

   499

	/* didn't find anything, get out */