1

#include "stdafx.h"

     2

#include "ttd.h"

     3

     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 "town.h"

    13

#include "engine.h"

    14

    15

static Engine * const _rail_engines[3] = {

    16

	&_engines[0],

    17

	&_engines[NUM_NORMAL_RAIL_ENGINES],

    18

	&_engines[NUM_MONORAIL_ENGINES + NUM_NORMAL_RAIL_ENGINES],

    19

};

    20

    21

const byte _rail_engines_count[3] = {

    22

	NUM_NORMAL_RAIL_ENGINES,

    23

	NUM_MONORAIL_ENGINES,

    24

	NUM_MAGLEV_ENGINES,

    25

};

    26

    27

const byte _rail_engines_start[3] = {

    28

	0,

    29

	NUM_NORMAL_RAIL_ENGINES,

    30

	NUM_MONORAIL_ENGINES + NUM_NORMAL_RAIL_ENGINES,

    31

};

    32

    33

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

    34

{

    35

	Vehicle *v,*found;

    36

    37

	if (!success)

    38

		return;

    39

    40

	// find a locomotive in the depot.

    41

	found = NULL;

    42

	FOR_ALL_VEHICLES(v) {

    43

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

    44

				v->tile == tile &&

    45

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

    46

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

    47

				return;

    48

			found = v;

    49

		}

    50

	}

    51

    52

	// if we found a loco,

    53

	if (found != NULL) {

    54

		found = GetLastVehicleInChain(found);

    55

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

    56

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

    57

	}

    58

}

    59

    60

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

    61

{

    62

	Vehicle *v;

    63

    64

	if (!success)

    65

		return;

    66

    67

	v = &_vehicles[_new_train_id];

    68

	if (tile == _backup_orders_tile) {

    69

		_backup_orders_tile = 0;

    70

		RestoreVehicleOrders(v, _backup_orders_data);

    71

	}

    72

	ShowTrainViewWindow(v);

    73

}

    74

    75

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

    76

{

    77

	switch(e->event) {

    78

	case WE_PAINT:

    79

    80

		if (w->window_number == 0)

    81

			SETBIT(w->disabled_state, 5);

    82

    83

		{

    84

			int count = 0;

    85

			int num = _rail_engines_count[WP(w,buildtrain_d).railtype];

    86

			Engine *e = _rail_engines[WP(w,buildtrain_d).railtype];

    87

			do {

    88

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

    89

					count++;

    90

			} while (++e,--num);

    91

			SetVScrollCount(w, count);

    92

		}

    93

    94

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

    95

		DrawWindowWidgets(w);

    96

    97

		{

    98

			int num = _rail_engines_count[WP(w,buildtrain_d).railtype];

    99

			Engine *e = _rail_engines[WP(w,buildtrain_d).railtype];

   100

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

   101

			int pos = w->vscroll.pos;

   102

			int x = 1;

   103

			int y = 15;

   104

			int engine_id = _rail_engines_start[WP(w,buildtrain_d).railtype];

   105

			int selected_id = -1;

   106

   107

			do {

   108

				if (HASBIT(e->player_avail, _local_player)) {

   109

					if (sel==0) selected_id = engine_id;

   110

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

   111

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

   112

						DrawTrainEngine(x+29, y+6, engine_id, SPRITE_PALETTE(PLAYER_SPRITE_COLOR(_local_player)));

   113

						y += 14;

   114

					}

   115

					sel--; 

   116

				}

   117

			} while (++engine_id, ++e,--num);

   118

   119

			WP(w,buildtrain_d).sel_engine = selected_id;

   120

   121

			if (selected_id != -1) {

   122

				const RailVehicleInfo *rvi = &_rail_vehicle_info[selected_id];

   123

				Engine *e;

   124

				YearMonthDay ymd;

   125

   126

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

   127

					/* it's an engine */

   128

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

   129

   130

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

   131

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

   132

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

   133

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

   134

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

   135

   136

					SET_DPARAM16(5, STR_8838_N_A);

   137

					if (rvi->capacity != 0) {

   138

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

   139

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

   140

					}

   141

   142

					e = &_engines[selected_id];	

   143

   144

					SET_DPARAM16(8, e->lifelength);

   145

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

   146

					ConvertDayToYMD(&ymd, e->intro_date);

   147

					SET_DPARAM16(7, ymd.year + 1920);

   148

   149

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

   150

				} else {

   151

					/* it's a wagon */

   152

   153

					SET_DPARAM32(0,

   154

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

   155

					);

   156

					SET_DPARAM16(4, rvi->capacity);

   157

					SET_DPARAM16(1, rvi->weight);

   158

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

   159

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

   160

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

   161

				}

   162

			}

   163

		}

   164

	break;

   165

   166

	case WE_CLICK: {

   167

		switch(e->click.widget) {

   168

		case 2: {

   169

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

   170

			if (i < 8) {

   171

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

   172

				SetWindowDirty(w);

   173

			}

   174

		} break;

   175

		case 5: {

   176

			int sel_eng;

   177

			sel_eng = WP(w,buildtrain_d).sel_engine;

   178

			if (sel_eng != -1)

   179

				DoCommandP(w->window_number, sel_eng, 0, (_rail_vehicle_info[sel_eng].flags & RVI_WAGON) ? CcBuildWagon : CcBuildLoco, CMD_BUILD_RAIL_VEHICLE | CMD_MSG(STR_882B_CAN_T_BUILD_RAILROAD_VEHICLE));

   180

		}	break;

   181

		case 6:

   182

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

   183

			ShowQueryString(

   184

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

   185

				STR_886A_RENAME_TRAIN_VEHICLE_TYPE,

   186

				31,

   187

				160,

   188

				w->window_class,

   189

				w->window_number);

   190

			break;

   191

		}

   192

	} break;

   193

   194

	case WE_4:

   195

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

   196

			DeleteWindow(w);

   197

		}

   198

		break;

   199

   200

	case WE_ON_EDIT_TEXT: {

   201

		byte *b = e->edittext.str;

   202

		if (*b == 0)

   203

			return;

   204

   205

		memcpy(_decode_parameters, b, 32);

   206

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

   207

	} break;

   208

	}

   209

}

   210

   211

static const Widget _new_rail_vehicle_widgets[] = {

   212

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

   213

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

   214

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

   215

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

   216

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

   217

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

   218

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

   219

{      WWT_LAST},

   220

};

   221

   222

static const WindowDesc _new_rail_vehicle_desc = {

   223

	-1, -1, 228, 200,

   224

	WC_BUILD_VEHICLE,0,

   225

	WDF_STD_TOOLTIPS | WDF_STD_BTN | WDF_DEF_WIDGET | WDF_UNCLICK_BUTTONS,

   226

	_new_rail_vehicle_widgets,

   227

	NewRailVehicleWndProc

   228

};

   229

   230

static void ShowBuildTrainWindow(uint tile)

   231

{

   232

	Window *w;

   233

   234

	DeleteWindowById(WC_BUILD_VEHICLE, tile);

   235

   236

	w = AllocateWindowDesc(&_new_rail_vehicle_desc);

   237

	w->window_number = tile;

   238

	w->vscroll.cap = 8;

   239

   240

	if (tile != 0) {

   241

		w->caption_color = _map_owner[tile];

   242

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

   243

	} else {

   244

		w->caption_color = _local_player;

   245

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

   246

	}

   247

}

   248

   249

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

   250

{

   251

	do {

   252

		if (--skip < 0) {

   253

			int image = GetTrainImage(v, 6);

   254

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

   255

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

   256

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

   257

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

   258

			x += 29;

   259

			count--;

   260

		}

   261

   262

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

   263

			break;

   264

	} while (count);

   265

}

   266

   267

static void DrawTrainDepotWindow(Window *w)

   268

{

   269

	uint tile;

   270

	Vehicle *v, *u;

   271

	int num,x,y,i, hnum;

   272

	Depot *d;

   273

   274

	tile = w->window_number;

   275

   276

	/* setup disabled buttons */

   277

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

   278

   279

	/* determine amount of items for scroller */

   280

	num = 1;

   281

	hnum = 0;

   282

	FOR_ALL_VEHICLES(v) {

   283

		if (v->type == VEH_Train &&

   284

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

   285

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

   286

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

   287

					num++;

   288

					// determine number of items in the X direction.

   289

					if (v->subtype == 0) {

   290

						i = -1;

   291

						u = v;

   292

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

   293

						if (i > hnum) hnum = i;

   294

					}

   295

		}

   296

	}

   297

	SetVScrollCount(w, num);

   298

	SetHScrollCount(w, hnum);

   299

   300

	/* locate the depot struct */

   301

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

   302

   303

	SET_DPARAM16(0,d->town_index);

   304

	DrawWindowWidgets(w);

   305

   306

	x = 2;

   307

	y = 15;

   308

	num = w->vscroll.pos;

   309

   310

	// draw all trains

   311

	FOR_ALL_VEHICLES(v) {

   312

		if (v->type == VEH_Train &&

   313

				v->subtype == 0 &&

   314

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

   315

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

   316

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

   317

   318

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

   319

			/* Draw the train number */

   320

			SET_DPARAM16(0, v->unitnumber);

   321

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

   322

			/* Draw the pretty flag */

   323

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

   324

   325

			y += 14;

   326

		}

   327

	}

   328

   329

	// draw all remaining vehicles

   330

	FOR_ALL_VEHICLES(v) {

   331

		if (v->type == VEH_Train &&

   332

				v->subtype == 4 &&

   333

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

   334

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

   335

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

   336

   337

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

   338

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

   339

			y += 14;

   340

		}

   341

	}

   342

}

   343

   344

typedef struct GetDepotVehiclePtData {

   345

	Vehicle *head;

   346

	Vehicle *wagon;

   347

} GetDepotVehiclePtData;

   348

   349

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

   350

{

   351

	int area_x;

   352

	int row;

   353

	Vehicle *v;

   354

   355

	x = x - 23;

   356

	if (x < 0) {

   357

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

   358

	} else {

   359

		area_x = x / 29;

   360

	}

   361

   362

	row = (y - 14) / 14;

   363

	if ( (uint) row >= 6)

   364

		return 1; /* means err */

   365

   366

	row += w->vscroll.pos;

   367

   368

	/* go through all the locomotives */

   369

	FOR_ALL_VEHICLES(v) {

   370

		if (v->type == VEH_Train &&

   371

				v->subtype == 0 &&

   372

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

   373

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

   374

				--row < 0) {

   375

					area_x += w->hscroll.pos;

   376

					goto found_it;

   377

		}

   378

	}

   379

   380

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

   381

   382

	/* and then the list of free wagons */

   383

	FOR_ALL_VEHICLES(v) {

   384

		if (v->type == VEH_Train &&

   385

				v->subtype == 4 &&

   386

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

   387

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

   388

				--row < 0)

   389

					goto found_it;

   390

	}

   391

   392

	d->head = NULL;

   393

	d->wagon = NULL;

   394

   395

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

   396

	return 0;

   397

   398

found_it:	

   399

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

   400

   401

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

   402

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

   403

		return area_x;

   404

   405

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

   406

	while (--area_x >= 0) {

   407

		v = v->next;

   408

		if (v == NULL) break;

   409

	}

   410

   411

	d->wagon = v;	

   412

   413

	return 0;

   414

}

   415

   416

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

   417

{

   418

	Vehicle *v;

   419

   420

	v = &_vehicles[sel];

   421

   422

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

   423

		return;

   424

   425

	if (wagon == NULL) {

   426

		if (head != NULL)

   427

			wagon = GetLastVehicleInChain(head);

   428

	} else  {

   429

		wagon = GetPrevVehicleInChain(wagon);

   430

		if (wagon == NULL)

   431

			return;

   432

	}

   433

   434

	if (wagon == v)

   435

		return;

   436

   437

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

   438

}

   439

   440

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

   441

{

   442

	GetDepotVehiclePtData gdvp;

   443

	int mode, sel;

   444

	Vehicle *v;

   445

   446

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

   447

   448

	// share / copy orders

   449

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

   450

   451

	v = gdvp.wagon;

   452

   453

	switch(mode) {

   454

	case 0: // start dragging of vehicle

   455

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

   456

		if (sel != -1) {

   457

			WP(w,traindepot_d).sel = INVALID_VEHICLE;

   458

			TrainDepotMoveVehicle(v, sel, gdvp.head);

   459

		} else if (v != NULL) {

   460

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

   461

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

   462

			SetWindowDirty(w);

   463

		}

   464

		break;

   465

   466

	case -1: // show info window

   467

		ShowTrainViewWindow(v);

   468

		break;

   469

   470

	case -2: // click start/stop flag

   471

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

   472

		break;

   473

	}

   474

}

   475

   476

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

   477

{

   478

	switch(e->event) {

   479

	case WE_PAINT:

   480

		DrawTrainDepotWindow(w);

   481

		break;

   482

   483

	case WE_CLICK: {

   484

		switch(e->click.widget) {

   485

		case 6: 

   486

			ShowBuildTrainWindow(w->window_number);

   487

			break;

   488

		case 7: 

   489

			ScrollMainWindowToTile(w->window_number);

   490

			break;

   491

		case 2:

   492

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

   493

			break;

   494

		}

   495

	} break;

   496

   497

	case WE_DESTROY:

   498

		DeleteWindowById(WC_BUILD_VEHICLE, w->window_number);

   499

		break;

   500

   501

	case WE_DRAGDROP: {

   502

		switch(e->click.widget) {

   503

		case 4:

   504

		case 3: {

   505

			Vehicle *v;

   506

			int sell_cmd;

   507

   508

			/* sell vehicle */

   509

			if (w->disabled_state & (1 << e->click.widget))

   510

				return;

   511

   512

			if (WP(w,traindepot_d).sel == INVALID_VEHICLE)

   513

				return;

   514

   515

			v = &_vehicles[WP(w,traindepot_d).sel];

   516

   517

			WP(w,traindepot_d).sel = INVALID_VEHICLE;

   518

			SetWindowDirty(w);

   519

   520

			HandleButtonClick(w, e->click.widget);

   521

   522

			sell_cmd = (e->click.widget == 4 || _ctrl_pressed) ? 1 : 0;

   523

   524

			if (v->subtype != 0) {

   525

				DoCommandP(v->tile, v->index, sell_cmd, NULL, CMD_SELL_RAIL_WAGON | CMD_MSG(STR_8839_CAN_T_SELL_RAILROAD_VEHICLE));

   526

			} else {

   527

				_backup_orders_tile = v->tile;

   528

				BackupVehicleOrders(v, _backup_orders_data);