1

#include "stdafx.h"

     2

#include "ttd.h"

     3

#include "table/strings.h"

     4

#include "map.h"

     5

#include "window.h"

     6

#include "gui.h"

     7

#include "gfx.h"

     8

#include "vehicle.h"

     9

#include "viewport.h"

    10

#include "station.h"

    11

#include "command.h"

    12

#include "player.h"

    13

#include "engine.h"

    14

#include "vehicle_gui.h"

    15

    16

    17

int _traininfo_vehicle_pitch = 0;

    18

    19

void Set_DPARAM_Train_Engine_Build_Window(uint16 engine_number)

    20

{

    21

	const RailVehicleInfo *rvi = RailVehInfo(engine_number);

    22

	Engine *e;

    23

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

    24

	YearMonthDay ymd;

    25

    26

    27

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

    28

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

    29

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

    30

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

    31

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

    32

    33

	SetDParam(5, STR_8838_N_A);

    34

	if (rvi->capacity != 0) {

    35

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

    36

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

    37

	}

    38

    39

	e = &_engines[engine_number];

    40

    41

	SetDParam(8, e->lifelength);

    42

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

    43

	ConvertDayToYMD(&ymd, e->intro_date);

    44

	SetDParam(7, ymd.year + 1920);

    45

}

    46

    47

void Set_DPARAM_Train_Car_Build_Window(Window *w, uint16 engine_number)

    48

{

    49

	const RailVehicleInfo *rvi = RailVehInfo(engine_number);

    50

    51

	SetDParam(0, DoCommandByTile(w->window_number, engine_number, 0, DC_QUERY_COST, CMD_BUILD_RAIL_VEHICLE) );

    52

	SetDParam(4, rvi->capacity);

    53

	SetDParam(1, rvi->weight);

    54

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

    55

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

    56

}

    57

    58

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

    59

{

    60

	Vehicle *v,*found;

    61

    62

	if (!success)

    63

		return;

    64

    65

	// find a locomotive in the depot.

    66

	found = NULL;

    67

	FOR_ALL_VEHICLES(v) {

    68

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

    69

				v->tile == tile &&

    70

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

    71

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

    72

				return;

    73

			found = v;

    74

		}

    75

	}

    76

    77

	// if we found a loco,

    78

	if (found != NULL) {

    79

		found = GetLastVehicleInChain(found);

    80

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

    81

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

    82

		RebuildVehicleLists();

    83

	}

    84

}

    85

    86

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

    87

{

    88

	Vehicle *v;

    89

    90

	if (!success)

    91

		return;

    92

    93

	v = &_vehicles[_new_train_id];

    94

	if (tile == _backup_orders_tile) {

    95

		_backup_orders_tile = 0;

    96

		RestoreVehicleOrders(v, _backup_orders_data);

    97

	}

    98

	ShowTrainViewWindow(v);

    99

}

   100

   101

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

   102

	int *selected_id, byte railtype, bool is_engine)

   103

{

   104

	int i;

   105

   106

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

   107

		const Engine *e = DEREF_ENGINE(i);

   108

		const RailVehicleInfo *rvi = RailVehInfo(i);

   109

   110

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

   111

				!HASBIT(e->player_avail, _local_player))

   112

			continue;

   113

   114

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

   115

   116

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

   117

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

   118

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

   119

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

   120

				SPRITE_PALETTE(PLAYER_SPRITE_COLOR(_local_player)));

   121

			*y += 14;

   122

		}

   123

		--*sel;

   124

	}

   125

}

   126

   127

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

   128

{

   129

	switch(e->event) {

   130

	case WE_PAINT:

   131

   132

		if (w->window_number == 0)

   133

			SETBIT(w->disabled_state, 5);

   134

   135

		{

   136

			int count = 0;

   137

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

   138

			int i;

   139

   140

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

   141

				const Engine *e = DEREF_ENGINE(i);

   142

				if (e->railtype == railtype

   143

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

   144

					count++;

   145

			}

   146

			SetVScrollCount(w, count);

   147

		}

   148

   149

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

   150

		DrawWindowWidgets(w);

   151

   152

		{

   153

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

   154

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

   155

			int pos = w->vscroll.pos;

   156

			int x = 1;

   157

			int y = 15;

   158

			int selected_id = -1;

   159

   160

			/* Ensure that custom engines which substituted wagons

   161

			 * are sorted correctly.

   162

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

   163

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

   164

			 * then it is exit!!! */

   165

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

   166

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

   167

   168

			WP(w,buildtrain_d).sel_engine = selected_id;

   169

   170

			if (selected_id != -1) {

   171

				const RailVehicleInfo *rvi = RailVehInfo(selected_id);

   172

   173

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

   174

					/* it's an engine */

   175

					Set_DPARAM_Train_Engine_Build_Window(selected_id);

   176

   177

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

   178

				} else {

   179

					/* it's a wagon */

   180

					Set_DPARAM_Train_Car_Build_Window(w, selected_id);

   181

   182

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

   183

				}

   184

			}

   185

		}

   186

	break;

   187

   188

	case WE_CLICK: {

   189

		switch(e->click.widget) {

   190

		case 2: {

   191

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

   192

			if (i < 8) {

   193

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

   194

				SetWindowDirty(w);

   195

			}

   196

		} break;

   197

		case 5: {

   198

			int sel_eng;

   199

			sel_eng = WP(w,buildtrain_d).sel_engine;

   200

			if (sel_eng != -1)

   201

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

   202

		}	break;

   203

		case 6:

   204

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

   205

			ShowQueryString(

   206

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

   207

				STR_886A_RENAME_TRAIN_VEHICLE_TYPE,

   208

				31,

   209

				160,

   210

				w->window_class,

   211

				w->window_number);

   212

			break;

   213

		}

   214

	} break;

   215

   216

	case WE_4:

   217

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

   218

			DeleteWindow(w);

   219

		}

   220

		break;

   221

   222

	case WE_ON_EDIT_TEXT: {

   223

		byte *b = e->edittext.str;

   224

		if (*b == 0)

   225

			return;

   226

   227

		memcpy(_decode_parameters, b, 32);

   228

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

   229

	} break;

   230

	}

   231

}

   232

   233

static const Widget _new_rail_vehicle_widgets[] = {

   234

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

   235

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

   236

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

   237

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

   238

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

   239

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

   240

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

   241

{   WIDGETS_END},

   242

};

   243

   244

static const WindowDesc _new_rail_vehicle_desc = {

   245

	-1, -1, 228, 200,

   246

	WC_BUILD_VEHICLE,0,

   247

	WDF_STD_TOOLTIPS | WDF_STD_BTN | WDF_DEF_WIDGET | WDF_UNCLICK_BUTTONS,

   248

	_new_rail_vehicle_widgets,

   249

	NewRailVehicleWndProc

   250

};

   251

   252

static void ShowBuildTrainWindow(uint tile)

   253

{

   254

	Window *w;

   255

   256

	DeleteWindowById(WC_BUILD_VEHICLE, tile);

   257

   258

	w = AllocateWindowDesc(&_new_rail_vehicle_desc);

   259

	w->window_number = tile;

   260

	w->vscroll.cap = 8;

   261

   262

	if (tile != 0) {

   263

		w->caption_color = _map_owner[tile];

   264

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

   265

	} else {

   266

		w->caption_color = _local_player;

   267

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

   268

	}

   269

}

   270

   271

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

   272

{

   273

	do {

   274

		if (--skip < 0) {

   275

			int image = GetTrainImage(v, 6);

   276

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

   277

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

   278

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

   279

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

   280

			x += 29;

   281

			count--;

   282

		}

   283

   284

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

   285

			break;

   286

	} while (count);

   287

}

   288

   289

static void DrawTrainDepotWindow(Window *w)

   290

{

   291

	uint tile;

   292

	Vehicle *v, *u;

   293

	int num,x,y,i, hnum;

   294

	Depot *d;

   295

   296

	tile = w->window_number;

   297

   298

	/* setup disabled buttons */

   299

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

   300

   301

	/* determine amount of items for scroller */

   302

	num = 1;

   303

	hnum = 0;

   304

	FOR_ALL_VEHICLES(v) {

   305

		if (v->type == VEH_Train &&

   306

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

   307

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

   308

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

   309

					num++;

   310

					// determine number of items in the X direction.

   311

					if (v->subtype == 0) {

   312

						i = -1;

   313

						u = v;

   314

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

   315

						if (i > hnum) hnum = i;

   316

					}

   317

		}

   318

	}

   319

	SetVScrollCount(w, num);

   320

	SetHScrollCount(w, hnum);

   321

   322

	/* locate the depot struct */

   323

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

   324

   325

	SetDParam(0,d->town_index);

   326

	DrawWindowWidgets(w);

   327

   328

	x = 2;

   329

	y = 15;

   330

	num = w->vscroll.pos;

   331

   332

	// draw all trains

   333

	FOR_ALL_VEHICLES(v) {

   334

		if (v->type == VEH_Train &&

   335

				v->subtype == 0 &&

   336

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

   337

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

   338

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

   339

   340

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

   341

			/* Draw the train number */

   342

			SetDParam(0, v->unitnumber);

   343

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

   344

			/* Draw the pretty flag */

   345

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

   346

   347

			y += 14;

   348

		}

   349

	}

   350

   351

	// draw all remaining vehicles

   352

	FOR_ALL_VEHICLES(v) {

   353

		if (v->type == VEH_Train &&

   354

				v->subtype == 4 &&

   355

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

   356

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

   357

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

   358

   359

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

   360

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

   361

			y += 14;

   362

		}

   363

	}

   364

}

   365

   366

typedef struct GetDepotVehiclePtData {

   367

	Vehicle *head;

   368

	Vehicle *wagon;

   369

} GetDepotVehiclePtData;

   370

   371

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

   372

{

   373

	int area_x;

   374

	int row;

   375

	Vehicle *v;

   376

   377

	x = x - 23;

   378

	if (x < 0) {

   379

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

   380

	} else {

   381

		area_x = x / 29;

   382

	}

   383

   384

	row = (y - 14) / 14;

   385

	if ( (uint) row >= 6)

   386

		return 1; /* means err */

   387

   388

	row += w->vscroll.pos;

   389

   390

	/* go through all the locomotives */

   391

	FOR_ALL_VEHICLES(v) {

   392

		if (v->type == VEH_Train &&

   393

				v->subtype == 0 &&

   394

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

   395

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

   396

				--row < 0) {

   397

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

   398

					goto found_it;

   399

		}

   400

	}

   401

   402

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

   403

   404

	/* and then the list of free wagons */

   405

	FOR_ALL_VEHICLES(v) {

   406

		if (v->type == VEH_Train &&

   407

				v->subtype == 4 &&

   408

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

   409

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

   410

				--row < 0)

   411

					goto found_it;

   412

	}

   413

   414

	d->head = NULL;

   415

	d->wagon = NULL;

   416

   417

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

   418

	return 0;

   419

   420

found_it:

   421

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

   422

   423

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

   424

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

   425

		return area_x;

   426

   427

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

   428

	while (--area_x >= 0) {

   429

		v = v->next;

   430

		if (v == NULL) break;

   431

	}

   432

   433

	d->wagon = v;

   434

   435

	return 0;

   436

}

   437

   438

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

   439

{

   440

	Vehicle *v;

   441

   442

	v = &_vehicles[sel];

   443

   444

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

   445

		return;

   446

   447

	if (wagon == NULL) {

   448

		if (head != NULL)

   449

			wagon = GetLastVehicleInChain(head);

   450

	} else  {

   451

		wagon = GetPrevVehicleInChain(wagon);

   452

		if (wagon == NULL)

   453

			return;

   454

	}

   455

   456

	if (wagon == v)

   457

		return;

   458

   459

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

   460

}

   461

   462

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

   463

{

   464

	GetDepotVehiclePtData gdvp;

   465

	int mode, sel;

   466

	Vehicle *v;

   467

   468

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

   469

   470

	// share / copy orders

   471

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

   472

   473

	v = gdvp.wagon;

   474

   475

	switch(mode) {

   476

	case 0: // start dragging of vehicle

   477

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

   478

		if (sel != -1) {

   479

			WP(w,traindepot_d).sel = INVALID_VEHICLE;

   480

			TrainDepotMoveVehicle(v, sel, gdvp.head);

   481

		} else if (v != NULL) {

   482

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

   483

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

   484

			SetWindowDirty(w);

   485

		}

   486

		break;

   487

   488

	case -1: // show info window

   489

		ShowTrainViewWindow(v);

   490

		break;

   491

   492

	case -2: // click start/stop flag

   493

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

   494

		break;

   495

	}

   496

}

   497

   498

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

   499

{

   500

	switch(e->event) {

   501

	case WE_PAINT:

   502

		DrawTrainDepotWindow(w);

   503

		break;

   504

   505

	case WE_CLICK: {

   506

		switch(e->click.widget) {

   507

		case 7:

   508

			ShowBuildTrainWindow(w->window_number);

   509

			break;

   510

		case 8:

   511

			ScrollMainWindowToTile(w->window_number);

   512

			break;

   513

		case 3:

   514

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

   515