1

#include "stdafx.h"

     2

#include "ttd.h"

     3

#include "table/strings.h"

     4

#include "window.h"

     5

#include "gui.h"

     6

#include "gfx.h"

     7

#include "vehicle.h"

     8

#include "viewport.h"

     9

#include "station.h"

    10

#include "command.h"

    11

#include "player.h"

    12

#include "engine.h"

    13

    14

    15

int _traininfo_vehicle_pitch = 0;

    16

    17

    18

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

    19

{

    20

	Vehicle *v,*found;

    21

    22

	if (!success)

    23

		return;

    24

    25

	// find a locomotive in the depot.

    26

	found = NULL;

    27

	FOR_ALL_VEHICLES(v) {

    28

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

    29

				v->tile == tile &&

    30

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

    31

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

    32

				return;

    33

			found = v;

    34

		}

    35

	}

    36

    37

	// if we found a loco,

    38

	if (found != NULL) {

    39

		found = GetLastVehicleInChain(found);

    40

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

    41

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

    42

		_vehicle_sort_dirty[VEHTRAIN] = true;

    43

	}

    44

}

    45

    46

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

    47

{

    48

	Vehicle *v;

    49

    50

	if (!success)

    51

		return;

    52

    53

	v = &_vehicles[_new_train_id];

    54

	if (tile == _backup_orders_tile) {

    55

		_backup_orders_tile = 0;

    56

		RestoreVehicleOrders(v, _backup_orders_data);

    57

	}

    58

	ShowTrainViewWindow(v);

    59

}

    60

    61

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

    62

	int *selected_id, byte railtype, bool is_engine)

    63

{

    64

	int i;

    65

    66

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

    67

		const Engine *e = DEREF_ENGINE(i);

    68

		const RailVehicleInfo *rvi = RailVehInfo(i);

    69

    70

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

    71

				!HASBIT(e->player_avail, _local_player))

    72

			continue;

    73

    74

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

    75

    76

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

    77

			DrawString(*x + 59, *y + 2, GetCustomEngineName(i),

    78

				*sel == 0 ? 0xC : 0x10);

    79

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

    80

				SPRITE_PALETTE(PLAYER_SPRITE_COLOR(_local_player)));

    81

			*y += 14;

    82

		}

    83

		--*sel;

    84

	}

    85

}

    86

    87

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

    88

{

    89

	switch(e->event) {

    90

	case WE_PAINT:

    91

    92

		if (w->window_number == 0)

    93

			SETBIT(w->disabled_state, 5);

    94

    95

		{

    96

			int count = 0;

    97

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

    98

			int i;

    99

   100

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

   101

				const Engine *e = DEREF_ENGINE(i);

   102

				if (e->railtype == railtype

   103

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

   104

					count++;

   105

			}

   106

			SetVScrollCount(w, count);

   107

		}

   108

   109

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

   110

		DrawWindowWidgets(w);

   111

   112

		{

   113

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

   114

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

   115

			int pos = w->vscroll.pos;

   116

			int x = 1;

   117

			int y = 15;

   118

			int selected_id = -1;

   119

   120

			/* Ensure that custom engines which substituted wagons

   121

			 * are sorted correctly.

   122

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

   123

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

   124

			 * then it is exit!!! */

   125

			engine_drawing_loop(&x, &y, &pos, &sel, &selected_id, railtype, true); // True engines

   126

			engine_drawing_loop(&x, &y, &pos, &sel, &selected_id, railtype, false); // Feeble wagons

   127

   128

			WP(w,buildtrain_d).sel_engine = selected_id;

   129

   130

			if (selected_id != -1) {

   131

				const RailVehicleInfo *rvi = RailVehInfo(selected_id);

   132

				Engine *e;

   133

				YearMonthDay ymd;

   134

   135

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

   136

					/* it's an engine */

   137

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

   138

   139

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

   140

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

   141

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

   142

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

   143

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

   144

   145

					SetDParam(5, STR_8838_N_A);

   146

					if (rvi->capacity != 0) {

   147

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

   148

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

   149

					}

   150

   151

					e = &_engines[selected_id];

   152

   153

					SetDParam(8, e->lifelength);

   154

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

   155

					ConvertDayToYMD(&ymd, e->intro_date);

   156

					SetDParam(7, ymd.year + 1920);

   157

   158

					DrawString(2, 0x7F, STR_8817_COST_WEIGHT_T_SPEED_POWER, 0);

   159

				} else {

   160

					/* it's a wagon */

   161

   162

					SetDParam(0,

   163

						DoCommandByTile(w->window_number, selected_id, 0, DC_QUERY_COST, CMD_BUILD_RAIL_VEHICLE)

   164

					);

   165

					SetDParam(4, rvi->capacity);

   166

					SetDParam(1, rvi->weight);

   167

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

   168

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

   169

					DrawString(2, 0x7F, STR_8821_COST_WEIGHT_T_T_CAPACITY, 0);

   170

				}

   171

			}

   172

		}

   173

	break;

   174

   175

	case WE_CLICK: {

   176

		switch(e->click.widget) {

   177

		case 2: {

   178

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

   179

			if (i < 8) {

   180

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

   181

				SetWindowDirty(w);

   182

			}

   183

		} break;

   184

		case 5: {

   185

			int sel_eng;

   186

			sel_eng = WP(w,buildtrain_d).sel_engine;

   187

			if (sel_eng != -1)

   188

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

   189

		}	break;

   190

		case 6:

   191

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

   192

			ShowQueryString(

   193

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

   194

				STR_886A_RENAME_TRAIN_VEHICLE_TYPE,

   195

				31,

   196

				160,

   197

				w->window_class,

   198

				w->window_number);

   199

			break;

   200

		}

   201

	} break;

   202

   203

	case WE_4:

   204

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

   205

			DeleteWindow(w);

   206

		}

   207

		break;

   208

   209

	case WE_ON_EDIT_TEXT: {

   210

		byte *b = e->edittext.str;

   211

		if (*b == 0)

   212

			return;

   213

   214

		memcpy(_decode_parameters, b, 32);

   215

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

   216

	} break;

   217

	}

   218

}

   219

   220

static const Widget _new_rail_vehicle_widgets[] = {

   221

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

   222

{    WWT_CAPTION,    14,    11,   227,     0,    13, STR_0315,	STR_018C_WINDOW_TITLE_DRAG_THIS},

   223

{     WWT_MATRIX,    14,     0,   216,    14,   125, 0x801,			STR_8843_TRAIN_VEHICLE_SELECTION},

   224

{  WWT_SCROLLBAR,    14,   217,   227,    14,   125, 0x0,				STR_0190_SCROLL_BAR_SCROLLS_LIST},

   225

{      WWT_PANEL,    14,     0,   227,   126,   187, 0x0,				STR_NULL},

   226

{ WWT_PUSHTXTBTN,    14,     0,   113,   188,   199, STR_881F_BUILD_VEHICLE,	STR_8844_BUILD_THE_HIGHLIGHTED_TRAIN},

   227

{ WWT_PUSHTXTBTN,    14,   114,   227,   188,   199, STR_8820_RENAME,					STR_8845_RENAME_TRAIN_VEHICLE_TYPE},

   228

{   WIDGETS_END},

   229

};

   230

   231

static const WindowDesc _new_rail_vehicle_desc = {

   232

	-1, -1, 228, 200,

   233

	WC_BUILD_VEHICLE,0,

   234

	WDF_STD_TOOLTIPS | WDF_STD_BTN | WDF_DEF_WIDGET | WDF_UNCLICK_BUTTONS,

   235

	_new_rail_vehicle_widgets,

   236

	NewRailVehicleWndProc

   237

};

   238

   239

static void ShowBuildTrainWindow(uint tile)

   240

{

   241

	Window *w;

   242

   243

	DeleteWindowById(WC_BUILD_VEHICLE, tile);

   244

   245

	w = AllocateWindowDesc(&_new_rail_vehicle_desc);

   246

	w->window_number = tile;

   247

	w->vscroll.cap = 8;

   248

   249

	if (tile != 0) {

   250

		w->caption_color = _map_owner[tile];

   251

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

   252

	} else {

   253

		w->caption_color = _local_player;

   254

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

   255

	}

   256

}

   257

   258

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

   259

{

   260

	do {

   261

		if (--skip < 0) {

   262

			int image = GetTrainImage(v, 6);

   263

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

   264

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

   265

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

   266

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

   267

			x += 29;

   268

			count--;

   269

		}

   270

   271

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

   272

			break;

   273

	} while (count);

   274

}

   275

   276

static void DrawTrainDepotWindow(Window *w)

   277

{

   278

	uint tile;

   279

	Vehicle *v, *u;

   280

	int num,x,y,i, hnum;

   281

	Depot *d;

   282

   283

	tile = w->window_number;

   284

   285

	/* setup disabled buttons */

   286

	w->disabled_state = (_map_owner[tile]==_local_player) ? 0 : ((1<<3)|(1<<4)|(1<<6));

   287

   288

	/* determine amount of items for scroller */

   289

	num = 1;

   290

	hnum = 0;

   291

	FOR_ALL_VEHICLES(v) {

   292

		if (v->type == VEH_Train &&

   293

				  (v->subtype == 0 || v->subtype == 4) &&

   294

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

   295

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

   296

					num++;

   297

					// determine number of items in the X direction.

   298

					if (v->subtype == 0) {

   299

						i = -1;

   300

						u = v;

   301

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

   302

						if (i > hnum) hnum = i;

   303

					}

   304

		}

   305

	}

   306

	SetVScrollCount(w, num);

   307

	SetHScrollCount(w, hnum);

   308

   309

	/* locate the depot struct */

   310

	for(d=_depots; d->xy != (TileIndex)tile; d++) {}

   311

   312

	SetDParam(0,d->town_index);

   313

	DrawWindowWidgets(w);

   314

   315

	x = 2;

   316

	y = 15;

   317

	num = w->vscroll.pos;

   318

   319

	// draw all trains

   320

	FOR_ALL_VEHICLES(v) {

   321

		if (v->type == VEH_Train &&

   322

				v->subtype == 0 &&

   323

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

   324

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

   325

				--num < 0 && num >= -6) {

   326

   327

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

   328

			/* Draw the train number */

   329

			SetDParam(0, v->unitnumber);

   330

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

   331

			/* Draw the pretty flag */

   332

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

   333

   334

			y += 14;

   335

		}

   336

	}

   337

   338

	// draw all remaining vehicles

   339

	FOR_ALL_VEHICLES(v) {

   340

		if (v->type == VEH_Train &&

   341

				v->subtype == 4 &&

   342

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

   343

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

   344

				--num < 0 && num >= -6) {

   345

   346

			DrawTrainImage(v, x+50, y, 9, 0, WP(w,traindepot_d).sel);

   347

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

   348

			y += 14;

   349

		}

   350

	}

   351

}

   352

   353

typedef struct GetDepotVehiclePtData {

   354

	Vehicle *head;

   355

	Vehicle *wagon;

   356

} GetDepotVehiclePtData;

   357

   358

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

   359

{

   360

	int area_x;

   361

	int row;

   362

	Vehicle *v;

   363

   364

	x = x - 23;

   365

	if (x < 0) {

   366

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

   367

	} else {

   368

		area_x = x / 29;

   369

	}

   370

   371

	row = (y - 14) / 14;

   372

	if ( (uint) row >= 6)

   373

		return 1; /* means err */

   374

   375

	row += w->vscroll.pos;

   376

   377

	/* go through all the locomotives */

   378

	FOR_ALL_VEHICLES(v) {

   379

		if (v->type == VEH_Train &&

   380

				v->subtype == 0 &&

   381

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

   382

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

   383

				--row < 0) {

   384

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

   385

					goto found_it;

   386

		}

   387

	}

   388

   389

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

   390

   391

	/* and then the list of free wagons */

   392

	FOR_ALL_VEHICLES(v) {

   393

		if (v->type == VEH_Train &&

   394

				v->subtype == 4 &&

   395

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

   396

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

   397

				--row < 0)

   398

					goto found_it;

   399

	}

   400

   401

	d->head = NULL;

   402

	d->wagon = NULL;

   403

   404

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

   405

	return 0;

   406

   407

found_it:

   408

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

   409

   410

	/* either pressed the flag or the number, but only when it's a loco */

   411

	if (area_x < 0 && v->subtype==0)

   412

		return area_x;

   413

   414

	/* find the vehicle in this row that was clicked */

   415

	while (--area_x >= 0) {

   416

		v = v->next;

   417

		if (v == NULL) break;

   418

	}

   419

   420

	d->wagon = v;

   421

   422

	return 0;

   423

}

   424

   425

static void TrainDepotMoveVehicle(Vehicle *wagon, int sel, Vehicle *head)

   426

{

   427

	Vehicle *v;

   428

   429

	v = &_vehicles[sel];

   430

   431

	if (/*v->subtype == 0 ||*/ v == wagon)

   432

		return;

   433

   434

	if (wagon == NULL) {

   435

		if (head != NULL)

   436

			wagon = GetLastVehicleInChain(head);

   437

	} else  {

   438

		wagon = GetPrevVehicleInChain(wagon);

   439

		if (wagon == NULL)

   440

			return;

   441

	}

   442

   443

	if (wagon == v)

   444

		return;

   445

   446

	DoCommandP(v->tile, v->index + ((wagon==NULL ? (uint32)-1 : wagon->index) << 16), _ctrl_pressed ? 1 : 0, NULL, CMD_MOVE_RAIL_VEHICLE | CMD_MSG(STR_8837_CAN_T_MOVE_VEHICLE));

   447

}

   448

   449

static void TrainDepotClickTrain(Window *w, int x, int y)

   450

{

   451

	GetDepotVehiclePtData gdvp;

   452

	int mode, sel;

   453

	Vehicle *v;

   454

   455

	mode = GetVehicleFromTrainDepotWndPt(w, x, y, &gdvp);

   456

   457

	// share / copy orders

   458

	if (_thd.place_mode && mode <= 0) { _place_clicked_vehicle = gdvp.head; return; }

   459

   460

	v = gdvp.wagon;

   461

   462

	switch(mode) {

   463

	case 0: // start dragging of vehicle

   464

		sel = (int16)WP(w,traindepot_d).sel;

   465

		if (sel != -1) {

   466

			WP(w,traindepot_d).sel = INVALID_VEHICLE;

   467

			TrainDepotMoveVehicle(v, sel, gdvp.head);

   468

		} else if (v != NULL) {

   469

			WP(w,traindepot_d).sel = v->index;

   470

			SetObjectToPlaceWnd( SPRITE_PALETTE(PLAYER_SPRITE_COLOR(v->owner)) + GetTrainImage(v, 6), 4, w);

   471

			SetWindowDirty(w);

   472

		}

   473

		break;

   474

   475

	case -1: // show info window

   476

		ShowTrainViewWindow(v);

   477

		break;

   478

   479

	case -2: // click start/stop flag

   480

		DoCommandP(v->tile, v->index, 0, NULL, CMD_START_STOP_TRAIN | CMD_MSG(STR_883B_CAN_T_STOP_START_TRAIN));

   481

		break;

   482

	}

   483

}

   484

   485

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

   486

{

   487

	switch(e->event) {

   488

	case WE_PAINT:

   489

		DrawTrainDepotWindow(w);

   490

		break;

   491

   492

	case WE_CLICK: {

   493

		switch(e->click.widget) {

   494

		case 6:

   495

			ShowBuildTrainWindow(w->window_number);

   496

			break;

   497

		case 7:

   498

			ScrollMainWindowToTile(w->window_number);

   499

			break;

   500

		case 2:

   501

			TrainDepotClickTrain(w, e->click.pt.x, e->click.pt.y);

   502

			break;

   503

		}

   504

	} break;

   505

   506

	case WE_DESTROY:

   507

		DeleteWindowById(WC_BUILD_VEHICLE, w->window_number);

   508

		break;

   509

   510

	case WE_DRAGDROP: {

   511

		switch(e->click.widget) {

   512

		case 4:

   513

		case 3: {

   514

			Vehicle *v;

   515

			int sell_cmd;

   516

   517