1

#include "stdafx.h"

     2

#include "openttd.h"

     3

#include "debug.h"

     4

#include "table/strings.h"

     5

#include "map.h"

     6

#include "window.h"

     7

#include "gui.h"

     8

#include "gfx.h"

     9

#include "vehicle.h"

    10

#include "viewport.h"

    11

#include "station.h"

    12

#include "command.h"

    13

#include "player.h"

    14

#include "engine.h"

    15

#include "vehicle_gui.h"

    16

#include "depot.h"

    17

    18

int _traininfo_vehicle_pitch = 0;

    19

    20

/**

    21

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

    22

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

    23

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

    24

 */

    25

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

    26

{

    27

	const RailVehicleInfo *rvi = RailVehInfo(engine_number);

    28

	Engine *e = &_engines[engine_number];

    29

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

    30

	YearMonthDay ymd;

    31

	ConvertDayToYMD(&ymd, e->intro_date);

    32

    33

	/* Purchase Cost - Engine weight */

    34

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

    35

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

    36

	DrawString(x,y, STR_PURCHASE_INFO_COST_WEIGHT, 0);

    37

	y += 10;

    38

    39

	/* Max speed - Engine power */

    40

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

    41

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

    42

	DrawString(x,y, STR_PURCHASE_INFO_SPEED_POWER, 0);

    43

	y += 10;

    44

    45

	/* Running cost */

    46

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

    47

	DrawString(x,y, STR_PURCHASE_INFO_RUNNINGCOST, 0);

    48

	y += 10;

    49

    50

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

    51

	if (rvi->pow_wag_power != 0) {

    52

		SetDParam(0, rvi->pow_wag_power);

    53

		SetDParam(1, rvi->pow_wag_weight);

    54

		DrawString(x,y, STR_PURCHASE_INFO_PWAGPOWER_PWAGWEIGHT, 0);

    55

		y += 10;

    56

	};

    57

    58

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

    59

	SetDParam(0, STR_8838_N_A);

    60

	SetDParam(2, STR_EMPTY);

    61

	if (rvi->capacity != 0) {

    62

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

    63

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

    64

		SetDParam(2, STR_9842_REFITTABLE);

    65

	}

    66

	DrawString(x,y, STR_PURCHASE_INFO_CAPACITY, 0);

    67

	y += 10;

    68

    69

	/* Design date - Life length */

    70

	SetDParam(0, ymd.year + 1920);

    71

	SetDParam(1, e->lifelength);

    72

	DrawString(x,y, STR_PURCHASE_INFO_DESIGNED_LIFE, 0);

    73

	y += 10;

    74

    75

	/* Reliability */

    76

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

    77

	DrawString(x,y, STR_PURCHASE_INFO_RELIABILITY, 0);

    78

	y += 10;

    79

}

    80

    81

/**

    82

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

    83

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

    84

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

    85

 */

    86

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

    87

{

    88

	const RailVehicleInfo *rvi = RailVehInfo(engine_number);

    89

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

    90

    91

	/* Purchase cost */

    92

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

    93

	DrawString(x, y, STR_PURCHASE_INFO_COST, 0);

    94

	y += 10;

    95

    96

	/* Wagon weight - (including cargo) */

    97

	SetDParam(0, rvi->weight);

    98

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

    99

	DrawString(x, y, STR_PURCHASE_INFO_WEIGHT_CWEIGHT, 0);

   100

	y += 10;

   101

   102

	/* Cargo type + capacity */

   103

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

   104

	SetDParam(1, rvi->capacity);

   105

	SetDParam(2, refittable ? STR_9842_REFITTABLE : STR_EMPTY);

   106

	DrawString(x, y, STR_PURCHASE_INFO_CAPACITY, 0);

   107

	y += 10;

   108

}

   109

   110

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

   111

{

   112

	Vehicle *v,*found;

   113

   114

	if (!success)

   115

		return;

   116

   117

	// find a locomotive in the depot.

   118

	found = NULL;

   119

	FOR_ALL_VEHICLES(v) {

   120

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

   121

				v->tile == tile &&

   122

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

   123

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

   124

				return;

   125

			found = v;

   126

		}

   127

	}

   128

   129

	// if we found a loco,

   130

	if (found != NULL) {

   131

		found = GetLastVehicleInChain(found);

   132

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

   133

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

   134

		RebuildVehicleLists();

   135

	}

   136

}

   137

   138

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

   139

{

   140

	Vehicle *v;

   141

   142

	if (!success)

   143

		return;

   144

   145

	v = GetVehicle(_new_train_id);

   146

	if (tile == _backup_orders_tile) {

   147

		_backup_orders_tile = 0;

   148

		RestoreVehicleOrders(v, _backup_orders_data);

   149

	}

   150

	ShowTrainViewWindow(v);

   151

}

   152

   153

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

   154

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

   155

{

   156

	int i;

   157

   158

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

   159

		const Engine *e = DEREF_ENGINE(i);

   160

		const RailVehicleInfo *rvi = RailVehInfo(i);

   161

   162

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

   163

				!HASBIT(e->player_avail, _local_player))

   164

			continue;

   165

   166

		if (*sel == 0)

   167

			*selected_id = i;

   168

   169

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

   170

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

   171

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

   172

				SPRITE_PALETTE(PLAYER_SPRITE_COLOR(_local_player)));

   173

			*y += 14;

   174

		}

   175

		--*sel;

   176

	}

   177

}

   178

   179

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

   180

{

   181

	switch(e->event) {

   182

	case WE_PAINT:

   183

   184

		if (w->window_number == 0)

   185

			SETBIT(w->disabled_state, 5);

   186

   187

		{

   188

			int count = 0;

   189

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

   190

			int i;

   191

   192

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

   193

				const Engine *e = DEREF_ENGINE(i);

   194

				if (e->railtype == railtype

   195

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

   196

					count++;

   197

			}

   198

			SetVScrollCount(w, count);

   199

		}

   200

   201

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

   202

		DrawWindowWidgets(w);

   203

   204

		{

   205

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

   206

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

   207

			int pos = w->vscroll.pos;

   208

			int x = 1;

   209

			int y = 15;

   210

			int selected_id = -1;

   211

   212

			/* Ensure that custom engines which substituted wagons

   213

			 * are sorted correctly.

   214

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

   215

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

   216

			 * then it is exit!!! */

   217

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

   218

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

   219

   220

			WP(w,buildtrain_d).sel_engine = selected_id;

   221

   222

			if (selected_id != -1) {

   223

				const RailVehicleInfo *rvi = RailVehInfo(selected_id);

   224

   225

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

   226

					/* it's an engine */

   227

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

   228

				} else {

   229

					/* it's a wagon */

   230

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

   231

				}

   232

			}

   233

		}

   234

	break;

   235

   236

	case WE_CLICK: {

   237

		switch(e->click.widget) {

   238

		case 2: {

   239

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

   240

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

   241

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

   242

				SetWindowDirty(w);

   243

			}

   244

		} break;

   245

		case 5: {

   246

			int sel_eng;

   247

			sel_eng = WP(w,buildtrain_d).sel_engine;

   248

			if (sel_eng != -1)

   249

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

   250

		}	break;

   251

		case 6: { /* rename */

   252

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

   253

			if (sel_eng != -1) {

   254

				WP(w,buildtrain_d).rename_engine = sel_eng;

   255

				ShowQueryString(GetCustomEngineName(sel_eng),

   256

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

   257

			}

   258

		} break;

   259

		}

   260

	} break;

   261

   262

	case WE_4:

   263

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

   264

			DeleteWindow(w);

   265

		}

   266

		break;

   267

   268

	case WE_ON_EDIT_TEXT: {

   269

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

   270

			_cmd_text = e->edittext.str;

   271

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

   272

				CMD_RENAME_ENGINE | CMD_MSG(STR_886B_CAN_T_RENAME_TRAIN_VEHICLE));

   273

		}

   274

	} break;

   275

   276

	case WE_RESIZE: {

   277

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

   278

			break;

   279

   280

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

   281

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

   282

	} break;

   283

	}

   284

}

   285

   286

static const Widget _new_rail_vehicle_widgets[] = {

   287

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

   288

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

   289

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

   290

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

   291

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

   292

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

   293

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

   294

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

   295

{   WIDGETS_END},

   296

};

   297

   298

static const WindowDesc _new_rail_vehicle_desc = {

   299

	-1, -1, 228, 210,

   300

	WC_BUILD_VEHICLE,0,

   301

	WDF_STD_TOOLTIPS | WDF_STD_BTN | WDF_DEF_WIDGET | WDF_UNCLICK_BUTTONS | WDF_RESIZABLE,

   302

	_new_rail_vehicle_widgets,

   303

	NewRailVehicleWndProc

   304

};

   305

   306

static void ShowBuildTrainWindow(uint tile)

   307

{

   308

	Window *w;

   309

   310

	DeleteWindowById(WC_BUILD_VEHICLE, tile);

   311

   312

	w = AllocateWindowDesc(&_new_rail_vehicle_desc);

   313

	w->window_number = tile;

   314

	w->vscroll.cap = 8;

   315

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

   316

   317

	w->resize.step_height = 14;

   318

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

   319

   320

	if (tile != 0) {

   321

		w->caption_color = GetTileOwner(tile);

   322

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

   323

	} else {

   324

		w->caption_color = _local_player;

   325

		WP(w,buildtrain_d).railtype = DEREF_PLAYER(_local_player)->max_railtype - 1;

   326

	}

   327

}

   328

   329

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

   330

{

   331

	do {

   332

		if (--skip < 0) {

   333

			int image = GetTrainImage(v, 6);

   334

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

   335

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

   336

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

   337

			if (v->index == selection) DrawFrameRect(x-1, y-1, x+28, y+12, 15, 0x10);

   338

			x += 29;

   339

			count--;

   340

		}

   341

   342

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

   343

			break;

   344

	} while (count);

   345

}

   346

   347

static void DrawTrainDepotWindow(Window *w)

   348

{

   349

	uint tile;

   350

	Vehicle *v, *u;

   351

	int num,x,y,i, hnum;

   352

	Depot *depot;

   353

   354

	tile = w->window_number;

   355

   356

	/* setup disabled buttons */

   357

	w->disabled_state =

   358

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

   359

   360

	/* determine amount of items for scroller */

   361

	num = 0;

   362

	hnum = 1;

   363

	FOR_ALL_VEHICLES(v) {

   364

		if (v->type == VEH_Train &&

   365

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

   366

				v->tile == (TileIndex)tile &&

   367

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

   368

					num++;

   369

					// determine number of items in the X direction.

   370

					if (v->subtype == TS_Front_Engine) {

   371

						i = 0;

   372

						u = v;

   373

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

   374

						if (i > hnum) hnum = i;

   375

					}

   376

		}

   377

	}

   378

   379

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

   380

	num++;

   381

   382

	SetVScrollCount(w, num);

   383

	SetHScrollCount(w, hnum);

   384

   385

	/* locate the depot struct */

   386

	depot = GetDepotByTile(tile);

   387

	assert(depot != NULL);

   388

   389

	SetDParam(0, depot->town_index);

   390

	DrawWindowWidgets(w);

   391

   392

	x = 2;

   393

	y = 15;

   394

	num = w->vscroll.pos;

   395

   396

	// draw all trains

   397

	FOR_ALL_VEHICLES(v) {

   398

		if (v->type == VEH_Train &&

   399

				v->subtype == TS_Front_Engine &&

   400

				v->tile == (TileIndex)tile &&

   401

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

   402

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

   403

   404

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

   405

			/* Draw the train number */

   406

			SetDParam(0, v->unitnumber);

   407

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

   408

   409

			/*Draw the train counter */

   410

			i = 0;

   411

			u = v;

   412

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

   413

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

   414

			i = (w->hscroll.cap * 29) + (x + 26);		//Calculate position of text according to window size

   415

			DrawStringCentered(i, y+5, STR_TINY_BLACK, 0);	//Draw the counter

   416

   417

			/* Draw the pretty flag */

   418

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

   419

   420

			y += 14;

   421

		}

   422

	}

   423

   424

	// draw all remaining vehicles

   425

	FOR_ALL_VEHICLES(v) {

   426

		if (v->type == VEH_Train &&

   427

				v->subtype == TS_Free_Car &&

   428

				v->tile == (TileIndex)tile &&

   429

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

   430

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

   431

   432

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

   433

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

   434

   435

			/*Draw the train counter */

   436

			i = 0;

   437

			u = v;

   438

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

   439

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

   440

			i = (w->hscroll.cap * 29) + (x + 26);		//Calculate position of text according to window size

   441

			DrawStringCentered(i, y+5, STR_TINY_BLACK, 0);	//Draw the counter

   442

			y += 14;

   443

		}

   444

	}

   445

}

   446

   447

typedef struct GetDepotVehiclePtData {

   448

	Vehicle *head;

   449

	Vehicle *wagon;

   450

} GetDepotVehiclePtData;

   451

   452

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

   453

{

   454

	int area_x;

   455

	int row;

   456

	Vehicle *v;

   457

   458

	x = x - 23;

   459

	if (x < 0) {

   460

		area_x = (x >= -10) ? -2 : -1;

   461

	} else {

   462

		area_x = x / 29;

   463

	}

   464

   465

	row = (y - 14) / 14;

   466

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

   467

		return 1; /* means err */

   468

   469

	row += w->vscroll.pos;

   470

   471

	/* go through all the locomotives */

   472

	FOR_ALL_VEHICLES(v) {

   473

		if (v->type == VEH_Train &&

   474

				v->subtype == TS_Front_Engine &&

   475

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

   476

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

   477

				--row < 0) {

   478

					if (area_x >= 0) area_x += w->hscroll.pos;

   479

					goto found_it;

   480

		}

   481

	}

   482

   483

	area_x--; /* free wagons don't have an initial loco. */

   484

   485

	/* and then the list of free wagons */

   486

	FOR_ALL_VEHICLES(v) {

   487

		if (v->type == VEH_Train &&

   488

				v->subtype == TS_Free_Car &&

   489

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

   490

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

   491

				--row < 0)

   492

					goto found_it;

   493

	}

   494

   495

	d->head = NULL;

   496

	d->wagon = NULL;

   497

   498

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

   499

	return 0;

   500

   501

found_it:

   502

	d->head = d->wagon = v;