1

/* $Id$ */

     2

     3

/** @file order_cmd.cpp */

     4

     5

#include "stdafx.h"

     6

#include "openttd.h"

     7

#include "order_base.h"

     8

#include "order_func.h"

     9

#include "airport.h"

    10

#include "depot.h"

    11

#include "waypoint.h"

    12

#include "command_func.h"

    13

#include "player_func.h"

    14

#include "news_func.h"

    15

#include "saveload.h"

    16

#include "vehicle_gui.h"

    17

#include "cargotype.h"

    18

#include "aircraft.h"

    19

#include "strings_func.h"

    20

#include "core/alloc_func.hpp"

    21

#include "functions.h"

    22

#include "window_func.h"

    23

#include "settings_type.h"

    24

#include "string_func.h"

    25

#include "newgrf_cargo.h"

    28

    29

#include "table/strings.h"

    30

    31

/* DestinationID must be at least as large as every these below, because it can

    32

 * be any of them

    33

 */

    34

assert_compile(sizeof(DestinationID) >= sizeof(DepotID));

    35

assert_compile(sizeof(DestinationID) >= sizeof(WaypointID));

    36

assert_compile(sizeof(DestinationID) >= sizeof(StationID));

    37

    38

TileIndex _backup_orders_tile;

    39

BackuppedOrders _backup_orders_data;

    40

    41

DEFINE_OLD_POOL_GENERIC(Order, Order)

    42

    44

{

    50

    57

    65

   139

}

   140

   141

/**

   142

 *

   143

 * Unpacks a order from savegames with version 4 and lower

   144

 *

   145

 */

   146

static Order UnpackVersion4Order(uint16 packed)

   147

{

   168

	return order;

   169

}

   170

   171

/**

   172

 *

   173

 * Updates the widgets of a vehicle which contains the order-data

   174

 *

   175

 */

   176

void InvalidateVehicleOrder(const Vehicle *v)

   177

{

   178

	InvalidateWindow(WC_VEHICLE_VIEW,      v->index);

   179

	InvalidateWindow(WC_VEHICLE_ORDERS,    v->index);

   180

	InvalidateWindow(WC_VEHICLE_TIMETABLE, v->index);

   181

}

   182

   183

/**

   184

 *

   185

 * Swap two orders

   186

 *

   187

 */

   188

static void SwapOrders(Order *order1, Order *order2)

   189

{

   190

	Order temp_order;

   191

   192

	temp_order = *order1;

   194

	order1->next = order2->next;

   196

	order2->next = temp_order.next;

   197

}

   198

   199

/**

   200

 *

   201

 * Assign data to an order (from an other order)

   202

 *   This function makes sure that the index is maintained correctly

   203

 *

   204

 */

   206

{

   210

   213

   216

}

   217

   218

   219

/**

   220

 * Delete all news items regarding defective orders about a vehicle

   221

 * This could kill still valid warnings (for example about void order when just

   222

 * another order gets added), but assume the player will notice the problems,

   223

 * when (s)he's changing the orders.

   224

 */

   225

static void DeleteOrderWarnings(const Vehicle* v)

   226

{

   227

	DeleteVehicleNews(v->index, STR_TRAIN_HAS_TOO_FEW_ORDERS  + v->type * 4);

   228

	DeleteVehicleNews(v->index, STR_TRAIN_HAS_VOID_ORDER      + v->type * 4);

   229

	DeleteVehicleNews(v->index, STR_TRAIN_HAS_DUPLICATE_ENTRY + v->type * 4);

   230

	DeleteVehicleNews(v->index, STR_TRAIN_HAS_INVALID_ENTRY   + v->type * 4);

   231

}

   232

   233

   234

static TileIndex GetOrderLocation(const Order& o)

   235

{

   237

		default: NOT_REACHED();

   240

	}

   241

}

   242

   243

   244

/** Add an order to the orderlist of a vehicle.

   245

 * @param tile unused

   246

 * @param flags operation to perform

   247

 * @param p1 various bitstuffed elements

   248

 * - p1 = (bit  0 - 15) - ID of the vehicle

   249

 * - p1 = (bit 16 - 31) - the selected order (if any). If the last order is given,

   250

 *                        the order will be inserted before that one

   251

 *                        only the first 8 bits used currently (bit 16 - 23) (max 255)

   252

 * @param p2 packed order to insert

   253

 */

   254

CommandCost CmdInsertOrder(TileIndex tile, uint32 flags, uint32 p1, uint32 p2)

   255

{

   256

	Vehicle *v;

   257

	VehicleID veh   = GB(p1,  0, 16);

   258

	VehicleOrderID sel_ord = GB(p1, 16, 16);

   260

   261

	if (!IsValidVehicleID(veh)) return CMD_ERROR;

   262

   263

	v = GetVehicle(veh);

   264

   265

	if (!CheckOwnership(v->owner)) return CMD_ERROR;

   266

   267

	/* Check if the inserted order is to the correct destination (owner, type),

   268

	 * and has the correct flags if any */

   270

		case OT_GOTO_STATION: {

   272

   274

   275

			if (st->owner != OWNER_NONE && !CheckOwnership(st->owner)) {

   276

				return CMD_ERROR;

   277

			}

   278

   279

			switch (v->type) {

   280

				case VEH_TRAIN:

   281

					if (!(st->facilities & FACIL_TRAIN)) return CMD_ERROR;

   282

					break;

   283

   284

				case VEH_ROAD:

   285

					if (IsCargoInClass(v->cargo_type, CC_PASSENGERS)) {

   286

						if (!(st->facilities & FACIL_BUS_STOP)) return CMD_ERROR;

   287

					} else {

   288

						if (!(st->facilities & FACIL_TRUCK_STOP)) return CMD_ERROR;

   289

					}

   290

					break;

   291

   292

				case VEH_SHIP:

   293

					if (!(st->facilities & FACIL_DOCK)) return CMD_ERROR;

   294

					break;

   295

   296

				case VEH_AIRCRAFT:

   297

					if (!(st->facilities & FACIL_AIRPORT) || !CanAircraftUseStation(v->engine_type, st)) {

   298

						return CMD_ERROR;

   299

					}

   300

					break;

   301

   302

				default: return CMD_ERROR;

   303

			}

   304

   307

			/* Order flags can be any of the following for stations:

   308

			 * [full-load | unload] [+ transfer] [+ non-stop]

   309

			 * non-stop orders (if any) are only valid for trains */

   311

				case 0:

   312

				case OFB_FULL_LOAD:

   313

				case OFB_FULL_LOAD | OFB_TRANSFER:

   314

				case OFB_UNLOAD:

   315

				case OFB_UNLOAD | OFB_TRANSFER:

   316

				case OFB_TRANSFER:

   317

					break;

   318

   319

				default: return CMD_ERROR;

   320

			}

   321

			break;

   322

		}

   323

   324

		case OT_GOTO_DEPOT: {

   325

			if (v->type == VEH_AIRCRAFT) {

   327

   329

   330

				if (!CheckOwnership(st->owner) ||

   331

						!(st->facilities & FACIL_AIRPORT) ||

   332

						st->Airport()->nof_depots == 0 ||

   333

						!CanAircraftUseStation(v->engine_type, st)) {

   334

					return CMD_ERROR;

   335

				}

   336

			} else {

   338

   340

   341

				if (!CheckOwnership(GetTileOwner(dp->xy))) return CMD_ERROR;

   342

   343

				switch (v->type) {

   344

					case VEH_TRAIN:

   345

						if (!IsTileDepotType(dp->xy, TRANSPORT_RAIL)) return CMD_ERROR;

   346

						break;

   347

   348

					case VEH_ROAD:

   349

						if (!IsTileDepotType(dp->xy, TRANSPORT_ROAD)) return CMD_ERROR;

   350

						break;

   351

   352

					case VEH_SHIP:

   353

						if (!IsTileDepotType(dp->xy, TRANSPORT_WATER)) return CMD_ERROR;

   354

						break;

   355

   356

					default: return CMD_ERROR;

   357

				}

   358

			}

   359

   362

			/* Order flags can be any of the following for depots:

   363

			 * order [+ halt] [+ non-stop]

   364

			 * non-stop orders (if any) are only valid for trains */

   366

				case OFB_PART_OF_ORDERS:

   367

				case OFB_PART_OF_ORDERS | OFB_HALT_IN_DEPOT:

   368

					break;

   369

   370

				default: return CMD_ERROR;

   371

			}

   372

			break;

   373

		}

   374

   375

		case OT_GOTO_WAYPOINT: {

   376

   377

			if (v->type != VEH_TRAIN) return CMD_ERROR;

   378

   381

   382

			if (!CheckOwnership(GetTileOwner(wp->xy))) return CMD_ERROR;

   383

   384

			/* Order flags can be any of the following for waypoints:

   385

			 * [non-stop]

   386

			 * non-stop orders (if any) are only valid for trains */

   389

   390

				case OFB_NON_STOP:

   391

					if (v->type != VEH_TRAIN) return CMD_ERROR;

   392

					break;

   393

   394

				default: return CMD_ERROR;

   395

			}

   396

			break;

   397

		}

   398

   399

		default: return CMD_ERROR;

   400

	}

   401

   402

	if (sel_ord > v->num_orders) return CMD_ERROR;

   403

   404

	if (!HasOrderPoolFree(1)) return_cmd_error(STR_8831_NO_MORE_SPACE_FOR_ORDERS);

   405

   406

	if (v->type == VEH_SHIP && IsHumanPlayer(v->owner) && _patches.pathfinder_for_ships != VPF_NPF) {

   407

		/* Make sure the new destination is not too far away from the previous */

   408

		const Order *prev = NULL;

   409

		uint n = 0;

   410

   411

		/* Find the last goto station or depot order before the insert location.

   412

		 * If the order is to be inserted at the beginning of the order list this

   413

		 * finds the last order in the list. */

   414

		for (const Order *o = v->orders; o != NULL; o = o->next) {

   416

			if (++n == sel_ord && prev != NULL) break;

   417

		}

   418

		if (prev != NULL) {

   419

			uint dist = DistanceManhattan(

   420

				GetOrderLocation(*prev),

   421

				GetOrderLocation(new_order)

   422

			);

   423

			if (dist >= 130) {

   424

				return_cmd_error(STR_0210_TOO_FAR_FROM_PREVIOUS_DESTINATIO);

   425

			}

   426

		}

   427

	}

   428

   429

	if (flags & DC_EXEC) {

   430

		Vehicle *u;

   431

		Order *new_o = new Order();

   433

   434

		/* Create new order and link in list */

   435

		if (v->orders == NULL) {

   436

			v->orders = new_o;

   437

		} else {

   438

			/* Try to get the previous item (we are inserting above the

   439

			    selected) */

   440

			Order *order = GetVehicleOrder(v, sel_ord - 1);

   441

   442

			if (order == NULL && GetVehicleOrder(v, sel_ord) != NULL) {

   443

				/* There is no previous item, so we are altering v->orders itself

   444

				    But because the orders can be shared, we copy the info over

   445

				    the v->orders, so we don't have to change the pointers of

   446

				    all vehicles */

   447

				SwapOrders(v->orders, new_o);

   448

				/* Now update the next pointers */

   449

				v->orders->next = new_o;

   450

			} else if (order == NULL) {

   451

				/* 'sel' is a non-existing order, add him to the end */

   452

				order = GetLastVehicleOrder(v);

   453

				order->next = new_o;

   454

			} else {

   455

				/* Put the new order in between */

   456

				new_o->next = order->next;

   457

				order->next = new_o;

   458

			}

   459

		}

   460

   461

		u = GetFirstVehicleFromSharedList(v);

   462

		DeleteOrderWarnings(u);

   463

		for (; u != NULL; u = u->next_shared) {

   464

			/* Increase amount of orders */

   465

			u->num_orders++;

   466

   467

			/* If the orderlist was empty, assign it */

   468

			if (u->orders == NULL) u->orders = v->orders;

   469

   470

			assert(v->orders == u->orders);

   471

   472

			/* If there is added an order before the current one, we need

   473

			to update the selected order */

   474

			if (sel_ord <= u->cur_order_index) {

   475

				uint cur = u->cur_order_index + 1;

   476

				/* Check if we don't go out of bound */

   477

				if (cur < u->num_orders)

   478

					u->cur_order_index = cur;

   479

			}

   480

			/* Update any possible open window of the vehicle */

   481

			InvalidateVehicleOrder(u);

   482

		}

   483

   484

		/* Make sure to rebuild the whole list */

   485

		RebuildVehicleLists();