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

    10

#include "town.h"

    11

#include "command.h"

    12

#include "viewport.h"

    13

    14

static int OrderGetSel(Window *w)

    15

{

    16

	Vehicle *v = GetVehicle(w->window_number);

    17

	const Order *sched = v->schedule_ptr;

    18

	int num = WP(w,order_d).sel;

    19

	int count = 0;

    20

    21

	if (num == 0)

    22

		return 0;

    23

    24

	while (sched->type != OT_NOTHING) {

    25

		sched++;

    26

		count++;

    27

		if (--num == 0)

    28

			break;

    29

	}

    30

    31

	return count;

    32

}

    33

    34

static void DrawOrdersWindow(Window *w)

    35

{

    36

	Vehicle *v;

    37

	int num, sel;

    38

	const Order *sched;

    39

	Order ord;

    40

	int y, i;

    41

	StringID str;

    42

	bool shared_schedule;

    43

    44

	v = GetVehicle(w->window_number);

    45

    59

    60

	shared_schedule = IsScheduleShared(v) != NULL;

    61

    62

	sched = v->schedule_ptr;

    63

	num=0;

    64

	while (sched->type != OT_NOTHING) {

    65

		sched++;

    66

		num++;

    67

	}

    68

    69

	if ((uint)num + shared_schedule <= (uint)WP(w,order_d).sel)

    70

		SETBIT(w->disabled_state, 5); /* delete */

    71

    72

	if (num == 0)

    73

		SETBIT(w->disabled_state, 4); /* skip */

    74

    75

	SetVScrollCount(w, num+1);

    76

    77

	sel = OrderGetSel(w);

    78

    79

	SetDParam(2,STR_8827_FULL_LOAD);

    80

	switch (v->schedule_ptr[sel].type) {

    81

	case OT_GOTO_STATION:

    82

		break;

    83

	case OT_GOTO_DEPOT:

    84

		SETBIT(w->disabled_state, 9);	/* unload */

    85

		SetDParam(2,STR_SERVICE);

    86

		break;

    87

    88

	case OT_GOTO_WAYPOINT:

    89

		SETBIT(w->disabled_state, 8); /* full load */

    90

		SETBIT(w->disabled_state, 9); /* unload */

    91

		break;

    92

    93

	default:

    94

		SETBIT(w->disabled_state, 6); /* nonstop */

    95

		SETBIT(w->disabled_state, 8);	/* full load */

    96

		SETBIT(w->disabled_state, 9);	/* unload */

    97

	}

    98

    99

	SetDParam(0, v->string_id);

   100

	SetDParam(1, v->unitnumber);

   101

	DrawWindowWidgets(w);

   102

   103

	y = 15;

   104

   105

	i = 0;

   106

	for(;;) {

   107

		str = ((byte)v->cur_order_index == i) ? STR_8805 : STR_8804;

   108

   109

		ord = v->schedule_ptr[i];

   110

   111

		if ( (uint)(i - w->vscroll.pos) < 6) {

   112

   113

			if (ord.type == OT_NOTHING) {

   114

				str = shared_schedule ? STR_END_OF_SHARED_ORDERS : STR_882A_END_OF_ORDERS;

   115

			} else {

   116

				SetDParam(1, 6);

   117

   118

				if (ord.type == OT_GOTO_STATION) {

   119

					SetDParam(1, STR_8806_GO_TO + (ord.flags >> 1));

   120

					SetDParam(2, ord.station);

   121

				} else if (ord.type == OT_GOTO_DEPOT) {

   122

					StringID s = STR_NULL;

   123

					if (v->type == VEH_Aircraft) {

   124

						s = STR_GO_TO_AIRPORT_HANGAR;

   125

					  SetDParam(2, ord.station);

   126

					} else {

   127

						SetDParam(2, _depots[ord.station].town_index);

   128

						switch (v->type) {

   129

						case VEH_Train:	s = STR_880E_GO_TO_TRAIN_DEPOT; break;

   130

						case VEH_Road:	s = STR_9038_GO_TO_ROADVEH_DEPOT; break;

   131

						case VEH_Ship:	s = STR_GO_TO_SHIP_DEPOT; break;

   132

						}

   133

					}

   134

					if (v->type == VEH_Train && ord.flags & OF_NON_STOP) s += 2;

   135

					if (ord.flags & OF_FULL_LOAD) ++s; /* XXX service */

   136

					SetDParam(1, s);

   137

				} else if (ord.type == OT_GOTO_WAYPOINT) {

   138

					SetDParam(2, ord.station);

   139

					SetDParam(1, (ord.flags & OF_NON_STOP) ? STR_GO_NON_STOP_TO_WAYPOINT : STR_GO_TO_WAYPOINT);

   140

				}

   141

			}

   142

			{

   143

				byte color = (i == WP(w,order_d).sel) ? 0xC : 0x10;

   144

				SetDParam(0, i+1);

   145

				if (ord.type != OT_DUMMY) {

   146

					DrawString(2, y, str, color);

   147

				} else {

   148

					SetDParam(1, STR_INVALID_ORDER);

   149

					SetDParam(2, ord.station);

   150

					DrawString(2, y, str, color);

   151

				}

   152

			}

   153

			y += 10;

   154

		}

   155

   156

		i++;

   157

   158

		if (ord.type == OT_NOTHING)

   159

			break;

   160

	}

   161

}

   162

   163

   164

// lookup a vehicle on a tile

   165

typedef struct {

   166

	TileIndex tile;

   167

	byte owner;

   168

	byte type;

   169

} FindVehS;

   170

   171

static void *FindVehicleCallb(Vehicle *v, FindVehS *f)

   172

{

   173

	if (v->tile != f->tile || v->owner != f->owner || v->vehstatus & VS_HIDDEN ) return NULL;

   174

	return v;

   175

}

   176

   177

Vehicle *GetVehicleOnTile(TileIndex tile, byte owner)

   178

{

   179

	FindVehS fs;

   180

	fs.tile = tile;

   181

	fs.owner = owner;

   182

	fs.type = 0;

   183

	return VehicleFromPos(tile, &fs, (VehicleFromPosProc*)FindVehicleCallb);

   184

}

   185

   186

static Order GetOrderCmdFromTile(Vehicle *v, uint tile)

   187

{

   188

	Order order;

   189

	Station *st;

   190

	int st_index;

   191

   192

	// check depot first

   193

	if (_patches.gotodepot) {

   194

		switch(GET_TILETYPE(tile)) {

   195

		case MP_RAILWAY:

   196

			if (v->type == VEH_Train && _map_owner[tile] == _local_player) {

   197

				if ((_map5[tile]&0xFC)==0xC0) {

   198

					order.type = OT_GOTO_DEPOT;

   199

					order.flags = OF_UNLOAD;

   200

					order.station = GetDepotByTile(tile);

   201

					return order;

   202

				}

   203

			}

   204

			break;

   205

   206

		case MP_STREET:

   207

			if ((_map5[tile] & 0xF0) == 0x20 && v->type == VEH_Road && _map_owner[tile] == _local_player) {

   208

				order.type = OT_GOTO_DEPOT;

   209

				order.flags = OF_UNLOAD;

   210

				order.station = GetDepotByTile(tile);

   211

				return order;

   212

			}

   213

			break;

   214

   215

		case MP_STATION:

   216

			if (v->type != VEH_Aircraft) break;

   217

			if ( IsAircraftHangarTile(tile) && _map_owner[tile] == _local_player) {

   218

				order.type = OT_GOTO_DEPOT;

   219

				order.flags = OF_UNLOAD | OF_NON_STOP;

   220

				order.station = _map2[tile];

   221

				return order;

   222

			}

   223

			break;

   224

   225

		case MP_WATER:

   226

			if (v->type != VEH_Ship) break;

   227

			if ( IsShipDepotTile(tile) && _map_owner[tile] == _local_player) {

   228

				switch (_map5[tile]) {

   229

				case 0x81: tile--; break;

   230

				case 0x83: tile-= TILE_XY(0,1); break;

   231

				}

   232

				order.type = OT_GOTO_DEPOT;

   233

				order.flags = OF_UNLOAD;

   234

				order.station = GetDepotByTile(tile);

   235

				return order;

   236

			}

   237

		}

   238

	}

   239

   240

	// check waypoint

   241

	if (IS_TILETYPE(tile, MP_RAILWAY)

   242

	&& v->type == VEH_Train

   243

	&& _map_owner[tile] == _local_player

   244

	&& (_map5[tile]&0xFE)==0xC4) {

   245

		order.type = OT_GOTO_WAYPOINT;

   246

		order.flags = 0;

   247

		order.station = GetWaypointByTile(tile);

   248

		return order;

   249

	}

   250

   251

	if (IS_TILETYPE(tile, MP_STATION)) {

   252

		st = GetStation(st_index = _map2[tile]);

   253

   254

		if (st->owner == _current_player || st->owner == OWNER_NONE) {

   255

			byte facil;

   256

			(facil=FACIL_DOCK, v->type == VEH_Ship) ||

   257

			(facil=FACIL_TRAIN, v->type == VEH_Train) ||

   258

			(facil=FACIL_AIRPORT, v->type == VEH_Aircraft) ||

   259

			(facil=FACIL_BUS_STOP, v->type == VEH_Road && v->cargo_type == CT_PASSENGERS) ||

   260

			(facil=FACIL_TRUCK_STOP, 1);

   261

			if (st->facilities & facil) {

   262

				order.type = OT_GOTO_STATION;

   263

				order.flags = 0;

   264

				order.station = st_index;

   265

				return order;

   266

			}

   267

		}

   268

	}

   269

   270

	// not found

   271

	order.type = OT_NOTHING;

   272

	order.flags = 0;

   273

	return order;

   274

}

   275

   276

static bool HandleOrderVehClick(Vehicle *v, Vehicle *u, Window *w)

   277

{

   278

	if (u->type != v->type)

   279

		return false;

   280

   281

	if (u->type == VEH_Train && u->subtype != 0) {

   282

		u = GetFirstVehicleInChain(u);

   283

		if (u->subtype != 0)

   284

			return false;

   285

	}

   286

   287

	// v is vehicle getting orders. Only copy/clone orders if vehicle doesn't have any orders yet

   288

	// obviously if you press CTRL on a non-empty orders vehicle you know what you are doing

   289

	if (v->num_orders != 0 && _ctrl_pressed == 0) {return false;}

   290

   291

	if (DoCommandP(v->tile, v->index | (u->index << 16), _ctrl_pressed ? 0 : 1, NULL,

   292

		_ctrl_pressed ? CMD_CLONE_ORDER | CMD_MSG(STR_CANT_SHARE_ORDER_LIST) : CMD_CLONE_ORDER | CMD_MSG(STR_CANT_COPY_ORDER_LIST))) {

   293

		WP(w,order_d).sel = -1;

   294

		ResetObjectToPlace();

   295

	}

   296

   297

	return true;

   298

}

   299

   300

static void OrdersPlaceObj(Vehicle *v, uint tile, Window *w)

   301

{

   302

	Order cmd;

   303

	Vehicle *u;

   304

   305

	// check if we're clicking on a vehicle first.. clone orders in that case.

   306

	u = CheckMouseOverVehicle();

   307

	if (u && HandleOrderVehClick(v, u, w))

   308

		return;

   309

   310

	cmd = GetOrderCmdFromTile(v, tile);

   311

	if (cmd.type == OT_NOTHING) return;

   312

   313

	if (DoCommandP(v->tile, v->index + (OrderGetSel(w) << 16), PackOrder(&cmd), NULL, CMD_INSERT_ORDER | CMD_MSG(STR_8833_CAN_T_INSERT_NEW_ORDER))) {

   314

		if (WP(w,order_d).sel != -1)

   315

			WP(w,order_d).sel++;

   316

		ResetObjectToPlace();

   317

	}

   318

}

   319

   320

   321

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

   322

{

   323

	switch(e->event) {

   324

	case WE_PAINT:

   325

		DrawOrdersWindow(w);

   326

		break;

   327

   328

	case WE_CLICK: {

   329

		Vehicle *v = GetVehicle(w->window_number);

   330

		int mode;

   331

		switch(e->click.widget) {

   332

		case 2:	{/* orders list */

   333

			int sel;

   334

			sel = (e->click.pt.y - 15) / 10;

   335

   336

			if ( (uint) sel >= 6)

   337

				return;

   338

   339

			sel += w->vscroll.pos;

   340

   341

			if (_ctrl_pressed && sel < v->num_orders) { // watch out for schedule_ptr overflow

   342

				Order ord = v->schedule_ptr[sel];

   343

				int xy = 0;

   344

				switch (ord.type) {

   345

				case OT_GOTO_STATION:			/* station order */

   346

					xy = GetStation(ord.station)->xy ;

   347

					break;

   348

				case OT_GOTO_DEPOT:				/* goto depot order */

   349

					xy = _depots[ord.station].xy;

   350

					break;

   351

				case OT_GOTO_WAYPOINT:	/* goto waypoint order */

   352

					xy = _waypoints[ord.station].xy;

   353

				}

   354

   355

				if (xy)

   356

					ScrollMainWindowToTile(xy);

   357

   358

				return;

   359

			}

   360

   361

			if (sel == WP(w,order_d).sel) sel = -1;

   362

			WP(w,order_d).sel = sel;

   363

			SetWindowDirty(w);

   364

		}	break;

   365

   366

		case 4: /* skip button */

   367

			DoCommandP(v->tile,v->index, 0, NULL, CMD_SKIP_ORDER);

   368

			break;

   369

   370

		case 5: /* delete button */

   371

			DoCommandP(v->tile,v->index, OrderGetSel(w), NULL, CMD_DELETE_ORDER | CMD_MSG(STR_8834_CAN_T_DELETE_THIS_ORDER));

   372

			break;

   373

   374

		case 7: /* goto button */

   375

			InvalidateWidget(w, 7);

   376

			w->click_state ^= 1<<7;

   377

			if (HASBIT(w->click_state, 7)) {

   378

				_place_clicked_vehicle = NULL;

   379

				SetObjectToPlaceWnd(ANIMCURSOR_PICKSTATION, 1, w);

   380

			} else {

   381

				ResetObjectToPlace();

   382

			}

   383

			break;

   384

   385

		case 8: /* full load button */

   386

			mode = 0;

   387

			DoCommandP(v->tile, v->index, OrderGetSel(w) | (mode << 8), NULL, CMD_MODIFY_ORDER | CMD_MSG(STR_8835_CAN_T_MODIFY_THIS_ORDER));

   388

			break;

   389

   390

		case 9: /* unload button */

   391

			mode = 1;

   392

			DoCommandP(v->tile, v->index, OrderGetSel(w) | (mode << 8), NULL, CMD_MODIFY_ORDER | CMD_MSG(STR_8835_CAN_T_MODIFY_THIS_ORDER));

   393

			break;

   394

   395

		case 6: /* non stop button */

   396

			mode = 2;

   397

			DoCommandP(v->tile, v->index, OrderGetSel(w) | (mode << 8), NULL, CMD_MODIFY_ORDER | CMD_MSG(STR_8835_CAN_T_MODIFY_THIS_ORDER));

   398

			break;

   399

		}

   400

	} break;

   401

   402

   403

	case WE_RCLICK: {

   404

		Vehicle *v = GetVehicle(w->window_number);

   405

		if (e->click.widget != 8) break;

   406

		if (v->schedule_ptr[OrderGetSel(w)].type == OT_GOTO_DEPOT)

   407

			GuiShowTooltips(STR_SERVICE_HINT);

   408

		else

   409

			GuiShowTooltips(STR_8857_MAKE_THE_HIGHLIGHTED_ORDER);

   410

		} break;

   411

   412

	case WE_4: {

   413

		if (FindWindowById(WC_VEHICLE_VIEW, w->window_number) == NULL)

   414

			DeleteWindow(w);

   415

	} break;

   416

   417

	case WE_PLACE_OBJ: {

   418

		OrdersPlaceObj(GetVehicle(w->window_number), e->place.tile, w);

   419

	} break;

   420

   421

	case WE_ABORT_PLACE_OBJ: {

   422

		w->click_state &= ~(1<<7);

   423

		InvalidateWidget(w, 7);

   424

	} break;

   425

   426

	// check if a vehicle in a depot was clicked..

   427

	case WE_MOUSELOOP: {

   428

		Vehicle *v = _place_clicked_vehicle;

   429

		/*

   430

		 * Check if we clicked on a vehicle

   431

		 * and if the GOTO button of this window is pressed

   432

		 * This is because of all open order windows WE_MOUSELOOP is called

   433

		 * and if you have 3 windows open, and this check is not done

   434

		 * the order is copied to the last open window instead of the

   435

		 * one where GOTO is enalbed

   436

		 */

   437

		if (v && HASBIT(w->click_state, 7)) {

   438

			_place_clicked_vehicle = NULL;

   439

			HandleOrderVehClick(GetVehicle(w->window_number), v, w);

   440

		}

   441

	} break;

   442

   443

	}

   444

}

   445

   447

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

   448

{    WWT_CAPTION,   RESIZE_NONE,    14,    11,   319,     0,    13, STR_8829_ORDERS,					STR_018C_WINDOW_TITLE_DRAG_THIS},

   449

{      WWT_PANEL,   RESIZE_NONE,    14,     0,   307,    14,    75, 0x0,											STR_8852_ORDERS_LIST_CLICK_ON_ORDER},

   450

{  WWT_SCROLLBAR,   RESIZE_NONE,    14,   308,   319,    14,    75, 0x0,											STR_0190_SCROLL_BAR_SCROLLS_LIST},

   451

{ WWT_PUSHTXTBTN,   RESIZE_NONE,    14,     0,    52,    76,    87, STR_8823_SKIP,						STR_8853_SKIP_THE_CURRENT_ORDER},

   452

{ WWT_PUSHTXTBTN,   RESIZE_NONE,    14,    53,   105,    76,    87, STR_8824_DELETE,					STR_8854_DELETE_THE_HIGHLIGHTED},

   453

{ WWT_PUSHTXTBTN,   RESIZE_NONE,    14,   106,   158,    76,    87, STR_8825_NON_STOP,				STR_8855_MAKE_THE_HIGHLIGHTED_ORDER},

   454

{WWT_NODISTXTBTN,   RESIZE_NONE,    14,   159,   211,    76,    87, STR_8826_GO_TO,					STR_8856_INSERT_A_NEW_ORDER_BEFORE},

   455

{ WWT_PUSHTXTBTN,   RESIZE_NONE,    14,   212,   264,    76,    87, STR_FULLLOAD_OR_SERVICE,	STR_NULL},

   456

{ WWT_PUSHTXTBTN,   RESIZE_NONE,    14,   265,   319,    76,    87, STR_8828_UNLOAD,					STR_8858_MAKE_THE_HIGHLIGHTED_ORDER},

   457

{   WIDGETS_END},

   458

};

   459

   461

	-1,-1, 320, 88,

   462

	WC_VEHICLE_ORDERS,WC_VEHICLE_VIEW,

   463

	WDF_STD_TOOLTIPS | WDF_STD_BTN | WDF_DEF_WIDGET | WDF_UNCLICK_BUTTONS | WDF_RESTORE_DPARAM,

   465

	OrdersWndProc

   466

};

   467

   469

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

   470

{    WWT_CAPTION,   RESIZE_NONE,    14,    11,   319,     0,    13, STR_A00B_ORDERS,	STR_018C_WINDOW_TITLE_DRAG_THIS},

   471

{     WWT_IMGBTN,   RESIZE_NONE,    14,     0,   307,    14,    75, 0x0,							STR_8852_ORDERS_LIST_CLICK_ON_ORDER},

   472

{  WWT_SCROLLBAR,   RESIZE_NONE,    14,   308,   319,    14,    75, 0x0,							STR_0190_SCROLL_BAR_SCROLLS_LIST},

   473

{   WIDGETS_END},

   474

};

   475

   477

	-1,-1, 320, 76,

   478

	WC_VEHICLE_ORDERS,WC_VEHICLE_VIEW,

   479

	WDF_STD_TOOLTIPS | WDF_STD_BTN | WDF_DEF_WIDGET | WDF_UNCLICK_BUTTONS,

   481

	OrdersWndProc

   482

};

   483

   484

void ShowOrdersWindow(Vehicle *v)

   485

{

   486

	Window *w;

   487

	VehicleID veh = v->index;

   488

   489

	DeleteWindowById(WC_VEHICLE_ORDERS, veh);

   490

	DeleteWindowById(WC_VEHICLE_DETAILS, veh);

   491

   492

	_alloc_wnd_parent_num = veh;

   495

   496

	w->window_number = veh;

   497

	w->caption_color = v->owner;

   498

	w->vscroll.cap = 6;

   499

	WP(w,order_d).sel = -1;

   500

}