1

#include "stdafx.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

void Set_DPARAM_Train_Engine_Build_Window(uint16 engine_number)

    21

{

    22

	const RailVehicleInfo *rvi = RailVehInfo(engine_number);

    23

	Engine *e;

    24

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

    25

	YearMonthDay ymd;

    26

    27

    28

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

    29

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

    30

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

    31

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

    32

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

    33

    34

	SetDParam(5, STR_8838_N_A);

    35

	if (rvi->capacity != 0) {

    36

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

    37

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

    38

	}

    39

    40

	e = &_engines[engine_number];

    41

    42

	SetDParam(8, e->lifelength);

    43

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

    44

	ConvertDayToYMD(&ymd, e->intro_date);

    45

	SetDParam(7, ymd.year + 1920);

    46

}

    47

    48

void Set_DPARAM_Train_Car_Build_Window(Window *w, uint16 engine_number)

    49

{

    50

	const RailVehicleInfo *rvi = RailVehInfo(engine_number);

    51

    52

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

    53

	SetDParam(4, rvi->capacity);

    54

	SetDParam(1, rvi->weight);

    55

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

    56

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

    57

}

    58

    59

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

    60

{

    61

	Vehicle *v,*found;

    62

    63

	if (!success)

    64

		return;

    65

    66

	// find a locomotive in the depot.

    67

	found = NULL;

    68

	FOR_ALL_VEHICLES(v) {

    69

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

    70

				v->tile == tile &&

    71

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

    72

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

    73

				return;

    74

			found = v;

    75

		}

    76

	}

    77

    78

	// if we found a loco,

    79

	if (found != NULL) {

    80

		found = GetLastVehicleInChain(found);

    81

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

    82

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

    83

		RebuildVehicleLists();

    84

	}

    85

}

    86

    87

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

    88

{

    89

	Vehicle *v;

    90

    91

	if (!success)

    92

		return;

    93

    94

	v = GetVehicle(_new_train_id);

    95

	if (tile == _backup_orders_tile) {

    96

		_backup_orders_tile = 0;

    97

		RestoreVehicleOrders(v, _backup_orders_data);

    98

	}

    99

	ShowTrainViewWindow(v);

   100

}

   101

   102

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

   103

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

   104

{

   105

	int i;

   106

   107

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

   108

		const Engine *e = DEREF_ENGINE(i);

   109

		const RailVehicleInfo *rvi = RailVehInfo(i);

   110

   111

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

   112

				!HASBIT(e->player_avail, _local_player))

   113

			continue;

   114

   115

		if (*sel == 0)

   116

			*selected_id = i;

   117

   118

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

   119

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

   120

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

   121

				SPRITE_PALETTE(PLAYER_SPRITE_COLOR(_local_player)));

   122

			*y += 14;

   123

		}

   124

		--*sel;

   125

	}

   126

}

   127

   128

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

   129

{

   130

	switch(e->event) {

   131

	case WE_PAINT:

   132

   133

		if (w->window_number == 0)

   134

			SETBIT(w->disabled_state, 5);

   135

   136

		{

   137

			int count = 0;

   138

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

   139

			int i;

   140

   141

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

   142

				const Engine *e = DEREF_ENGINE(i);

   143

				if (e->railtype == railtype

   144

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

   145

					count++;

   146

			}

   147

			SetVScrollCount(w, count);

   148

		}

   149

   150

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

   151

		DrawWindowWidgets(w);

   152

   153

		{

   154

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

   155

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

   156

			int pos = w->vscroll.pos;

   157

			int x = 1;

   158

			int y = 15;

   159

			int selected_id = -1;

   160

   161

			/* Ensure that custom engines which substituted wagons

   162

			 * are sorted correctly.

   163

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

   164

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

   165

			 * then it is exit!!! */

   166

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

   167

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

   168

   169

			WP(w,buildtrain_d).sel_engine = selected_id;

   170

   171

			if (selected_id != -1) {

   172

				const RailVehicleInfo *rvi = RailVehInfo(selected_id);

   173

   174

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

   175

					/* it's an engine */

   176

					Set_DPARAM_Train_Engine_Build_Window(selected_id);

   177

   178

					DrawString(2, w->widget[4].top + 1, STR_8817_COST_WEIGHT_T_SPEED_POWER, 0);

   179

				} else {

   180

					/* it's a wagon */

   181

					Set_DPARAM_Train_Car_Build_Window(w, selected_id);

   182

   183

					DrawString(2, w->widget[4].top + 1, STR_8821_COST_WEIGHT_T_T_CAPACITY, 0);

   184

				}

   185

			}

   186

		}

   187

	break;

   188

   189

	case WE_CLICK: {

   190

		switch(e->click.widget) {

   191

		case 2: {

   192

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

   193

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

   194

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

   195

				SetWindowDirty(w);

   196

			}

   197

		} break;

   198

		case 5: {

   199

			int sel_eng;

   200

			sel_eng = WP(w,buildtrain_d).sel_engine;

   201

			if (sel_eng != -1)

   202

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

   203

		}	break;

   204

		case 6: { /* rename */

   205

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

   206

			if (sel_eng != -1) {

   207

				WP(w,buildtrain_d).rename_engine = sel_eng;

   208

				ShowQueryString(GetCustomEngineName(sel_eng),

   209

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

   210

			}

   211

		} break;

   212

		}

   213

	} break;

   214

   215

	case WE_4:

   216

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

   217

			DeleteWindow(w);

   218

		}

   219

		break;

   220

   221

	case WE_ON_EDIT_TEXT: {

   222

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

   223

			_cmd_text = e->edittext.str;

   224

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

   225

				CMD_RENAME_ENGINE | CMD_MSG(STR_886B_CAN_T_RENAME_TRAIN_VEHICLE));

   226

		}

   227

	} break;

   228

   229

	case WE_RESIZE: {

   230

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

   231

			break;

   232

   233

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

   234

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

   235

	} break;

   236

	}

   237

}

   238

   239

static const Widget _new_rail_vehicle_widgets[] = {

   240

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

   241

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

   242

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

   243

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

   244

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

   245

{ WWT_PUSHTXTBTN,     RESIZE_TB,    14,     0,   107,   188,   199, STR_881F_BUILD_VEHICLE,		STR_8844_BUILD_THE_HIGHLIGHTED_TRAIN},

   246

{ WWT_PUSHTXTBTN,     RESIZE_TB,    14,   108,   215,   188,   199, STR_8820_RENAME,					STR_8845_RENAME_TRAIN_VEHICLE_TYPE},

   247

{  WWT_RESIZEBOX,     RESIZE_TB,    14,   216,   227,   188,   199, 0x0,											STR_RESIZE_BUTTON},

   248

{   WIDGETS_END},

   249

};

   250

   251

static const WindowDesc _new_rail_vehicle_desc = {

   252

	-1, -1, 228, 200,

   253

	WC_BUILD_VEHICLE,0,

   254

	WDF_STD_TOOLTIPS | WDF_STD_BTN | WDF_DEF_WIDGET | WDF_UNCLICK_BUTTONS | WDF_RESIZABLE,

   255

	_new_rail_vehicle_widgets,

   256

	NewRailVehicleWndProc

   257

};

   258

   259

static void ShowBuildTrainWindow(uint tile)

   260

{

   261

	Window *w;

   262

   263

	DeleteWindowById(WC_BUILD_VEHICLE, tile);

   264

   265

	w = AllocateWindowDesc(&_new_rail_vehicle_desc);

   266

	w->window_number = tile;

   267

	w->vscroll.cap = 8;

   268

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

   269

   270

	w->resize.step_height = 14;

   271

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

   272

   273

	if (tile != 0) {

   274

		w->caption_color = _map_owner[tile];

   275

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

   276

	} else {

   277

		w->caption_color = _local_player;

   278

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

   279

	}

   280

}

   281

   282

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

   283

{

   284

	do {

   285

		if (--skip < 0) {

   286

			int image = GetTrainImage(v, 6);

   287

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

   288

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

   289

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

   290

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

   291

			x += 29;

   292

			count--;

   293

		}

   294

   295

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

   296

			break;

   297

	} while (count);

   298

}

   299

   300

static void DrawTrainDepotWindow(Window *w)

   301

{

   302

	uint tile;

   303

	Vehicle *v, *u;

   304

	int num,x,y,i, hnum;

   305

	Depot *depot;

   306

   307

	tile = w->window_number;

   308

   309

	/* setup disabled buttons */

   310

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

   311

   312

	/* determine amount of items for scroller */

   313

	num = 0;

   314

	hnum = 1;

   315

	FOR_ALL_VEHICLES(v) {

   316

		if (v->type == VEH_Train &&

   317

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

   318

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

   319

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

   320

					num++;

   321

					// determine number of items in the X direction.

   322

					if (v->subtype == TS_Front_Engine) {

   323

						i = 0;

   324

						u = v;

   325

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

   326

						if (i > hnum) hnum = i;

   327

					}

   328

		}

   329

	}

   330

   331

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

   332

	num++;

   333

   334

	SetVScrollCount(w, num);

   335

	SetHScrollCount(w, hnum);

   336

   337

	/* locate the depot struct */

   338

	depot = GetDepotByTile(tile);

   339

	assert(depot != NULL);

   340

   341

	SetDParam(0, depot->town_index);

   342

	DrawWindowWidgets(w);

   343

   344

	x = 2;

   345

	y = 15;

   346

	num = w->vscroll.pos;

   347

   348

	// draw all trains

   349

	FOR_ALL_VEHICLES(v) {

   350

		if (v->type == VEH_Train &&

   351

				v->subtype == TS_Front_Engine &&

   352

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

   353

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

   354

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

   355

   356

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

   357

			/* Draw the train number */

   358

			SetDParam(0, v->unitnumber);

   359

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

   360

   361

			/*Draw the train counter */

   362

			i = 0;

   363

			u = v;

   364

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

   365

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

   366

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

   367

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

   368

   369

			/* Draw the pretty flag */

   370

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

   371

   372

			y += 14;

   373

		}

   374

	}

   375

   376

	// draw all remaining vehicles

   377

	FOR_ALL_VEHICLES(v) {

   378

		if (v->type == VEH_Train &&

   379

				v->subtype == TS_Free_Car &&

   380

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

   381

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

   382

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

   383

   384

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

   385

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

   386

   387

			/*Draw the train counter */

   388

			i = 0;

   389

			u = v;

   390

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

   391

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

   392

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

   393

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

   394

			y += 14;

   395

		}

   396

	}

   397

}

   398

   399

typedef struct GetDepotVehiclePtData {

   400

	Vehicle *head;

   401

	Vehicle *wagon;

   402

} GetDepotVehiclePtData;

   403

   404

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

   405

{

   406

	int area_x;

   407

	int row;

   408

	Vehicle *v;

   409

   410

	x = x - 23;

   411

	if (x < 0) {

   412

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

   413

	} else {

   414

		area_x = x / 29;

   415

	}

   416

   417

	row = (y - 14) / 14;

   418

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

   419

		return 1; /* means err */

   420

   421

	row += w->vscroll.pos;

   422

   423

	/* go through all the locomotives */

   424

	FOR_ALL_VEHICLES(v) {

   425

		if (v->type == VEH_Train &&

   426

				v->subtype == TS_Front_Engine &&

   427

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

   428

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

   429

				--row < 0) {

   430

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

   431

					goto found_it;

   432

		}

   433

	}

   434

   435

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

   436

   437

	/* and then the list of free wagons */

   438

	FOR_ALL_VEHICLES(v) {

   439

		if (v->type == VEH_Train &&

   440

				v->subtype == TS_Free_Car &&

   441

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

   442

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

   443

				--row < 0)

   444

					goto found_it;

   445

	}

   446

   447

	d->head = NULL;

   448

	d->wagon = NULL;

   449

   450

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

   451

	return 0;

   452

   453

found_it:

   454

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

   455

   456

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

   457

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

   458

		return area_x;

   459

   460

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

   461

	while (--area_x >= 0) {

   462

		v = v->next;

   463

		if (v == NULL) break;

   464

	}

   465

   466

	d->wagon = v;

   467

   468

	return 0;

   469

}

   470

   471

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

   472

{

   473

	Vehicle *v;

   474

   475

	v = GetVehicle(sel);

   476

   477

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

   478

		return;

   479

   480

	if (wagon == NULL) {

   481

		if (head != NULL)

   482

			wagon = GetLastVehicleInChain(head);

   483

	} else  {

   484

		wagon = GetPrevVehicleInChain(wagon);

   485

		if (wagon == NULL)

   486

			return;

   487

	}

   488

   489

	if (wagon == v)

   490

		return;

   491

   492

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

   493

}

   494

   495

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

   496

{

   497

	GetDepotVehiclePtData gdvp;

   498

	int mode, sel;

   499

	Vehicle *v;

   500

   501

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

   502

   503

	// share / copy orders

   504

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

   505

   506

	v = gdvp.wagon;