1

/* $Id$ */

     2

     3

/** @file autoreplace_cmd.cpp Deals with autoreplace execution but not the setup */

     4

     5

#include "stdafx.h"

     6

#include "openttd.h"

     7

#include "player_func.h"

     8

#include "debug.h"

     9

#include "vehicle_gui.h"

    10

#include "train.h"

    11

#include "rail.h"

    12

#include "command_func.h"

    13

#include "engine_base.h"

    14

#include "engine_func.h"

    15

#include "vehicle_func.h"

    16

#include "functions.h"

    17

#include "autoreplace_func.h"

    18

#include "articulated_vehicles.h"

    19

#include "core/alloc_func.hpp"

    20

    21

#include "table/strings.h"

    22

    23

/** Figure out if two engines got at least one type of cargo in common (refitting if needed)

    24

 * @param engine_a one of the EngineIDs

    25

 * @param engine_b the other EngineID

    26

 * @param type the type of the engines

    27

 * @return true if they can both carry the same type of cargo (or at least one of them got no capacity at all)

    28

 */

    29

static bool EnginesGotCargoInCommon(EngineID engine_a, EngineID engine_b, VehicleType type)

    30

{

    31

	uint32 available_cargos_a = GetUnionOfArticulatedRefitMasks(engine_a, type, true);

    32

	uint32 available_cargos_b = GetUnionOfArticulatedRefitMasks(engine_b, type, true);

    33

	return (available_cargos_a == 0 || available_cargos_b == 0 || (available_cargos_a & available_cargos_b) != 0);

    34

}

    35

    36

/**

    37

 * Checks some basic properties whether autoreplace is allowed

    38

 * @param from Origin engine

    39

 * @param to Destination engine

    40

 * @param player Player to check for

    41

 * @return true if autoreplace is allowed

    42

 */

    43

bool CheckAutoreplaceValidity(EngineID from, EngineID to, PlayerID player)

    44

{

    45

	/* First we make sure that it's a valid type the user requested

    46

	 * check that it's an engine that is in the engine array */

    47

	if (!IsEngineIndex(from) || !IsEngineIndex(to)) return false;

    48

    49

	/* we can't replace an engine into itself (that would be autorenew) */

    50

	if (from == to) return false;

    51

    52

	VehicleType type = GetEngine(from)->type;

    53

    54

	/* check that the new vehicle type is available to the player and its type is the same as the original one */

    55

	if (!IsEngineBuildable(to, type, player)) return false;

    56

    57

	switch (type) {

    58

		case VEH_TRAIN: {

    59

			const RailVehicleInfo *rvi_from = RailVehInfo(from);

    60

			const RailVehicleInfo *rvi_to   = RailVehInfo(to);

    61

    62

			/* make sure the railtypes are compatible */

    63

			if ((GetRailTypeInfo(rvi_from->railtype)->compatible_railtypes & GetRailTypeInfo(rvi_to->railtype)->compatible_railtypes) == 0) return false;

    64

    65

			/* make sure we do not replace wagons with engines or vise versa */

    66

			if ((rvi_from->railveh_type == RAILVEH_WAGON) != (rvi_to->railveh_type == RAILVEH_WAGON)) return false;

    67

			break;

    68

		}

    69

    70

		case VEH_ROAD:

    71

			/* make sure that we do not replace a tram with a normal road vehicles or vise versa */

    72

			if (HasBit(EngInfo(from)->misc_flags, EF_ROAD_TRAM) != HasBit(EngInfo(to)->misc_flags, EF_ROAD_TRAM)) return false;

    73

			break;

    74

    75

		case VEH_AIRCRAFT:

    76

			/* make sure that we do not replace a plane with a helicopter or vise versa */

    77

			if ((AircraftVehInfo(from)->subtype & AIR_CTOL) != (AircraftVehInfo(to)->subtype & AIR_CTOL)) return false;

    78

			break;

    79

    80

		default: break;

    81

	}

    82

    83

	/* the engines needs to be able to carry the same cargo */

    84

	return EnginesGotCargoInCommon(from, to, type);

    85

}

    86

    87

/** Transfer cargo from a single (articulated )old vehicle to the new vehicle chain

    88

 * @param old_veh Old vehicle that will be sold

    89

 * @param new_head Head of the completely constructed new vehicle chain

    90

 */

    91

static void TransferCargo(Vehicle *old_veh, Vehicle *new_head)

    92

{

    93

	/* Loop through source parts */

    94

	for (Vehicle *src = old_veh; src != NULL; src = src->Next()) {

    95

		if (src->cargo_type >= NUM_CARGO || src->cargo.Count() == 0) continue;

    96

    97

		/* Find free space in the new chain */

    98

		for (Vehicle *dest = new_head; dest != NULL && src->cargo.Count() > 0; dest = dest->Next()) {

    99

			if (dest->cargo_type != src->cargo_type) continue;

   100

   101

			uint amount = min(src->cargo.Count(), dest->cargo_cap - dest->cargo.Count());

   102

			if (amount <= 0) continue;

   103

   104

			src->cargo.MoveTo(&dest->cargo, amount);

   105

		}

   106

	}

   107

   108

	/* Update train weight etc., the old vehicle will be sold anyway */

   109

	if (new_head->type == VEH_TRAIN) TrainConsistChanged(new_head, true);

   110

}

   111

   112

/**

   113

 * Tests whether refit orders that applied to v will also apply to the new vehicle type

   114

 * @param v The vehicle to be replaced

   115

 * @param engine_type The type we want to replace with

   116

 * @return true iff all refit orders stay valid

   117

 */

   118

static bool VerifyAutoreplaceRefitForOrders(const Vehicle *v, EngineID engine_type)

   119

{

   120

	const Order *o;

   121

	const Vehicle *u;

   122

   123

	uint32 union_refit_mask_a = GetUnionOfArticulatedRefitMasks(v->engine_type, v->type, false);

   124

	uint32 union_refit_mask_b = GetUnionOfArticulatedRefitMasks(engine_type, v->type, false);

   125

   126

	if (v->type == VEH_TRAIN) {

   127

		u = v->First();

   128

	} else {

   129

		u = v;

   130

	}

   131

   132

	FOR_VEHICLE_ORDERS(u, o) {

   133

		if (!o->IsRefit()) continue;

   134

		CargoID cargo_type = o->GetRefitCargo();

   135

   136

		if (!HasBit(union_refit_mask_a, cargo_type)) continue;

   137

		if (!HasBit(union_refit_mask_b, cargo_type)) return false;

   138

	}

   139

   140

	return true;

   141

}

   142

   143

/**

   144

 * Function to find what type of cargo to refit to when autoreplacing

   145

 * @param *v Original vehicle, that is being replaced

   146

 * @param engine_type The EngineID of the vehicle that is being replaced to

   147

 * @return The cargo type to replace to

   148

 *    CT_NO_REFIT is returned if no refit is needed

   149

 *    CT_INVALID is returned when both old and new vehicle got cargo capacity and refitting the new one to the old one's cargo type isn't possible

   150

 */

   151

static CargoID GetNewCargoTypeForReplace(Vehicle *v, EngineID engine_type)

   152

{

   153

	CargoID cargo_type;

   154

   155

	if (GetUnionOfArticulatedRefitMasks(engine_type, v->type, true) == 0) return CT_NO_REFIT; // Don't try to refit an engine with no cargo capacity

   156

   157

	if (IsArticulatedVehicleCarryingDifferentCargos(v, &cargo_type)) return CT_INVALID; // We cannot refit to mixed cargos in an automated way

   158

   159

	uint32 available_cargo_types = GetIntersectionOfArticulatedRefitMasks(engine_type, v->type, true);

   160

   161

	if (cargo_type == CT_INVALID) {

   162

		if (v->type != VEH_TRAIN) return CT_NO_REFIT; // If the vehicle does not carry anything at all, every replacement is fine.

   163

   164

		/* the old engine didn't have cargo capacity, but the new one does

   165

		 * now we will figure out what cargo the train is carrying and refit to fit this */

   166

   167

		for (v = v->First(); v != NULL; v = v->Next()) {

   168

			if (v->cargo_cap == 0) continue;

   169

			/* Now we found a cargo type being carried on the train and we will see if it is possible to carry to this one */

   170

			if (HasBit(available_cargo_types, v->cargo_type)) {

   171

				/* Do we have to refit the vehicle, or is it already carrying the right cargo? */

   172

				uint16 *default_capacity = GetCapacityOfArticulatedParts(engine_type, v->type);

   173

				for (CargoID cid = 0; cid < NUM_CARGO; cid++) {

   174

					if (cid != v->cargo_type && default_capacity[cid] > 0) return v->cargo_type;

   175

				}

   176

   177

				return CT_NO_REFIT;

   178

			}

   179

		}

   180

   181

		return CT_NO_REFIT; // We failed to find a cargo type on the old vehicle and we will not refit the new one

   182

	} else {

   183

		if (!HasBit(available_cargo_types, cargo_type)) return CT_INVALID; // We can't refit the vehicle to carry the cargo we want

   184

   185

		if (!VerifyAutoreplaceRefitForOrders(v, engine_type)) return CT_INVALID; // Some refit orders lose their effect

   186

   187

		/* Do we have to refit the vehicle, or is it already carrying the right cargo? */

   188

		uint16 *default_capacity = GetCapacityOfArticulatedParts(engine_type, v->type);

   189

		for (CargoID cid = 0; cid < NUM_CARGO; cid++) {

   190

			if (cid != cargo_type && default_capacity[cid] > 0) return cargo_type;

   191

		}

   192

   193

		return CT_NO_REFIT;

   194

	}

   195

}

   196

   197

/** Get the EngineID of the replacement for a vehicle

   198

 * @param v The vehicle to find a replacement for

   199

 * @param p The vehicle's owner (it's faster to forward the pointer than refinding it)

   200

 * @return the EngineID of the replacement. INVALID_ENGINE if no buildable replacement is found

   201

 */

   202

static EngineID GetNewEngineType(const Vehicle *v, const Player *p)

   203

{

   204

	assert(v->type != VEH_TRAIN || !IsArticulatedPart(v));

   205

   206

	if (v->type == VEH_TRAIN && IsRearDualheaded(v)) {

   207

		/* we build the rear ends of multiheaded trains with the front ones */

   208

		return INVALID_ENGINE;

   209

	}

   210

   211

	EngineID e = EngineReplacementForPlayer(p, v->engine_type, v->group_id);

   212

   213

	if (e != INVALID_ENGINE && IsEngineBuildable(e, v->type, _current_player)) {

   214

		return e;

   215

	}

   216

   217

	if (v->NeedsAutorenewing(p) && // replace if engine is too old

   218

	    IsEngineBuildable(v->engine_type, v->type, _current_player)) { // engine can still be build

   219

		return v->engine_type;

   220

	}

   221

   222

	return INVALID_ENGINE;

   223

}

   224

   225

/** Builds and refits a replacement vehicle

   226

 * Important: The old vehicle is still in the original vehicle chain (used for determining the cargo when the old vehicle did not carry anything, but the new one does)

   227

 * @param old_veh A single (articulated/multiheaded) vehicle that shall be replaced.

   228

 * @param new_vehicle Returns the newly build and refittet vehicle

   229

 * @return cost or error

   230

 */

   231

static CommandCost BuildReplacementVehicle(Vehicle *old_veh, Vehicle **new_vehicle)

   232

{

   233

	*new_vehicle = NULL;

   234

   235

	/* Shall the vehicle be replaced? */

   236

	const Player *p = GetPlayer(_current_player);

   237

	EngineID e = GetNewEngineType(old_veh, p);

   238

	if (e == INVALID_ENGINE) return CommandCost(); // neither autoreplace is set, nor autorenew is triggered

   239

   240

	/* Does it need to be refitted */

   241

	CargoID refit_cargo = GetNewCargoTypeForReplace(old_veh, e);

   242

	if (refit_cargo == CT_INVALID) return CommandCost(); // incompatible cargos

   243

   244

	/* Build the new vehicle */

   245

	CommandCost cost = DoCommand(old_veh->tile, e, 0, DC_EXEC | DC_AUTOREPLACE, GetCmdBuildVeh(old_veh));

   246

	if (cost.Failed()) return cost;

   247

   248

	Vehicle *new_veh = GetVehicle(_new_vehicle_id);

   249

	*new_vehicle = new_veh;

   250

   251

	/* Refit the vehicle if needed */

   252

	if (refit_cargo != CT_NO_REFIT) {

   253

		cost.AddCost(DoCommand(0, new_veh->index, refit_cargo, DC_EXEC, GetCmdRefitVeh(new_veh)));

   254

		assert(cost.Succeeded()); // This should be ensured by GetNewCargoTypeForReplace()

   255

	}

   256

   257

	/* Try to reverse the vehicle, but do not care if it fails as the new type might not be reversible */

   258

	if (new_veh->type == VEH_TRAIN && HasBit(old_veh->u.rail.flags, VRF_REVERSE_DIRECTION)) {

   259

		DoCommand(0, new_veh->index, true, DC_EXEC, CMD_REVERSE_TRAIN_DIRECTION);

   260

	}

   261

   262

	return cost;

   263

}

   264

   265

/** Issue a start/stop command

   266

 * @param v a vehicle

   267

 * @param evaluate_callback shall the start/stop callback be evaluated?

   268

 * @return success or error

   269

 */

   270

static inline CommandCost StartStopVehicle(const Vehicle *v, bool evaluate_callback)

   271

{

   272

	return DoCommand(0, v->index, evaluate_callback ? 1 : 0, DC_EXEC | DC_AUTOREPLACE, CMD_START_STOP_VEHICLE);

   273

}

   274

   275

/** Issue a train vehicle move command

   276

 * @param v The vehicle to move

   277

 * @param after The vehicle to insert 'v' after, or NULL to start new chain

   278

 * @param whole_chain move all vehicles following 'v' (true), or only 'v' (false)

   279

 * @return success or error

   280

 */

   281

static inline CommandCost MoveVehicle(const Vehicle *v, const Vehicle *after, uint32 flags, bool whole_chain)

   282

{

   283

	return DoCommand(0, v->index | (after != NULL ? after->index : INVALID_VEHICLE) << 16, whole_chain ? 1 : 0, flags, CMD_MOVE_RAIL_VEHICLE);

   284

}

   285

   286

/** Copy head specific things to the new vehicle chain after it was successfully constructed

   287

 * @param old_head The old front vehicle (no wagons attached anymore)

   288

 * @param new_head The new head of the completely replaced vehicle chain

   289

 * @param flags the command flags to use

   290

 */

   291

static CommandCost CopyHeadSpecificThings(Vehicle *old_head, Vehicle *new_head, uint32 flags)

   292

{

   293

	CommandCost cost = CommandCost();

   294

   295

	/* Share orders */

   296

	if (cost.Succeeded() && old_head != new_head) cost.AddCost(DoCommand(0, (old_head->index << 16) | new_head->index, CO_SHARE, DC_EXEC, CMD_CLONE_ORDER));

   297

   298

	/* Copy group membership */

   299

	if (cost.Succeeded() && old_head != new_head) cost.AddCost(DoCommand(0, old_head->group_id, new_head->index, DC_EXEC, CMD_ADD_VEHICLE_GROUP));

   300

   301

	/* Perform start/stop check whether the new vehicle suits newgrf restrictions etc. */

   302

	if (cost.Succeeded()) {

   303

		/* Start the vehicle, might be denied by certain things */

   304

		assert((new_head->vehstatus & VS_STOPPED) != 0);

   305

		cost.AddCost(StartStopVehicle(new_head, true));

   306

   307

		/* Stop the vehicle again, but do not care about evil newgrfs allowing starting but not stopping :p */

   308

		if (cost.Succeeded()) cost.AddCost(StartStopVehicle(new_head, false));

   309

	}

   310

   311

	/* Last do those things which do never fail (resp. we do not care about), but which are not undo-able */

   312

	if (cost.Succeeded() && old_head != new_head && (flags & DC_EXEC) != 0) {

   313

		/* Copy vehicle name */

   314

		if (old_head->name != NULL) {

   315

			_cmd_text = old_head->name;

   316

			DoCommand(0, new_head->index, 0, DC_EXEC | DC_AUTOREPLACE, CMD_RENAME_VEHICLE);

   317

			_cmd_text = NULL;

   318

		}

   319

   320

		/* Copy other things which cannot be copied by a command and which shall not stay resetted from the build vehicle command */

   321

		new_head->CopyVehicleConfigAndStatistics(old_head);

   322

   323

		/* Switch vehicle windows to the new vehicle, so they are not closed when the old vehicle is sold */

   324

		ChangeVehicleViewWindow(old_head->index, new_head->index);

   325

	}

   326

   327

	return cost;

   328

}

   329

   330

/** Replace a whole vehicle chain

   331

 * @param chain vehicle chain to let autoreplace/renew operator on

   332

 * @param flags command flags

   333

 * @param wagon_removal remove wagons when the resulting chain occupies more tiles than the old did

   334

 * @param nothing_to_do is set to 'false' when something was done (only valid when not failed)

   335

 * @return cost or error

   336

 */

   337

static CommandCost ReplaceChain(Vehicle **chain, uint32 flags, bool wagon_removal, bool *nothing_to_do)

   338

{

   339

	Vehicle *old_head = *chain;

   340

   341

	CommandCost cost = CommandCost(EXPENSES_NEW_VEHICLES, 0);

   342

   343

	if (old_head->type == VEH_TRAIN) {

   344

		/* Store the length of the old vehicle chain, rounded up to whole tiles */

   345

		uint16 old_total_length = (old_head->u.rail.cached_total_length + TILE_SIZE - 1) / TILE_SIZE * TILE_SIZE;

   346

   347

		int num_units = 0; ///< Number of units in the chain

   348

		for (Vehicle *w = old_head; w != NULL; w = GetNextUnit(w)) num_units++;

   349

   350

		Vehicle **old_vehs = CallocT<Vehicle *>(num_units); ///< Will store vehicles of the old chain in their order

   351

		Vehicle **new_vehs = CallocT<Vehicle *>(num_units); ///< New vehicles corresponding to old_vehs or NULL if no replacement

   352

		Money *new_costs = MallocT<Money>(num_units);       ///< Costs for buying and refitting the new vehicles

   353

   354

		/* Collect vehicles and build replacements

   355

		 * Note: The replacement vehicles can only successfully build as long as the old vehicles are still in their chain */

   356

		int i;

   357

		Vehicle *w;

   358

		for (w = old_head, i = 0; w != NULL; w = GetNextUnit(w), i++) {

   359

			assert(i < num_units);

   360

			old_vehs[i] = w;

   361

   362

			CommandCost ret = BuildReplacementVehicle(old_vehs[i], &new_vehs[i]);

   363

			cost.AddCost(ret);

   364

			if (cost.Failed()) break;

   365

   366

			new_costs[i] = ret.GetCost();

   367

			if (new_vehs[i] != NULL) *nothing_to_do = false;

   368

		}

   369

		Vehicle *new_head = (new_vehs[0] != NULL ? new_vehs[0] : old_vehs[0]);

   370

   371

		/* Note: When autoreplace has already failed here, old_vehs[] is not completely initialized. But it is also not needed. */

   372

		if (cost.Succeeded()) {

   373

			/* Separate the head, so we can start constructing the new chain */

   374

			Vehicle *second = GetNextUnit(old_head);

   375

			if (second != NULL) cost.AddCost(MoveVehicle(second, NULL, DC_EXEC | DC_AUTOREPLACE, true));

   376

   377

			assert(GetNextUnit(new_head) == NULL);

   378

   379

			/* Append engines to the new chain

   380

			 * We do this from back to front, so that the head of the temporary vehicle chain does not change all the time.

   381

			 * OTOH the vehicle attach callback is more expensive this way :s */

   382

			Vehicle *last_engine = NULL; ///< Shall store the last engine unit after this step

   383

			if (cost.Succeeded()) {

   384

				for (int i = num_units - 1; i > 0; i--) {

   385

					Vehicle *append = (new_vehs[i] != NULL ? new_vehs[i] : old_vehs[i]);

   386

   387

					if (RailVehInfo(append->engine_type)->railveh_type == RAILVEH_WAGON) continue;

   388

   389

					if (last_engine == NULL) last_engine = append;

   390

					cost.AddCost(MoveVehicle(append, new_head, DC_EXEC, false));

   391

					if (cost.Failed()) break;

   392

				}

   393

				if (last_engine == NULL) last_engine = new_head;

   394

			}

   395

   396

			/* When wagon removal is enabled and the new engines without any wagons are already longer than the old, we have to fail */

   397

			if (cost.Succeeded() && wagon_removal && new_head->u.rail.cached_total_length > old_total_length) cost = CommandCost(STR_TRAIN_TOO_LONG_AFTER_REPLACEMENT);

   398

   399

			/* Append/insert wagons into the new vehicle chain

   400

			 * We do this from back to front, so we can stop when wagon removal or maximum train length (i.e. from mammoth-train setting) is triggered.

   401

			 */

   402

			if (cost.Succeeded()) {

   403

				for (int i = num_units - 1; i > 0; i--) {

   404

					assert(last_engine != NULL);

   405

					Vehicle *append = (new_vehs[i] != NULL ? new_vehs[i] : old_vehs[i]);

   406

   407

					if (RailVehInfo(append->engine_type)->railveh_type == RAILVEH_WAGON) {

   408

						/* Insert wagon after 'last_engine' */

   409

						CommandCost res = MoveVehicle(append, last_engine, DC_EXEC, false);

   410

   411

						if (res.Succeeded() && wagon_removal && new_head->u.rail.cached_total_length > old_total_length) {

   412

							MoveVehicle(append, NULL, DC_EXEC | DC_AUTOREPLACE, false);

   413

							break;

   414

						}

   415

   416

						cost.AddCost(res);

   417

						if (cost.Failed()) break;

   418

					} else {

   419

						/* We have reached 'last_engine', continue with the next engine towards the front */

   420

						assert(append == last_engine);

   421

						last_engine = GetPrevUnit(last_engine);

   422

					}

   423

				}

   424

			}

   425

   426

			/* Sell superfluous new vehicles that could not be inserted. */

   427

			if (cost.Succeeded() && wagon_removal) {

   428

				for (int i = 1; i < num_units; i++) {

   429

					Vehicle *wagon = new_vehs[i];

   430

					if (wagon == NULL) continue;

   431

					if (wagon->First() == new_head) break;

   432

   433

					assert(RailVehInfo(wagon->engine_type)->railveh_type == RAILVEH_WAGON);

   434

   435

					/* Sell wagon */

   436

					CommandCost ret = DoCommand(0, wagon->index, 0, DC_EXEC, GetCmdSellVeh(wagon));

   437

					assert(ret.Succeeded());

   438

					new_vehs[i] = NULL;

   439

   440

					/* Revert the money subtraction when the vehicle was built.

   441

					 * This value is different from the sell value, esp. because of refitting */

   442

					cost.AddCost(-new_costs[i]);

   443

				}

   444

			}

   445

   446

			/* The new vehicle chain is constructed, now take over orders and everything... */

   447

			if (cost.Succeeded()) cost.AddCost(CopyHeadSpecificThings(old_head, new_head, flags));

   448

   449

			if (cost.Succeeded()) {

   450

				/* Success ! */

   451

				if ((flags & DC_EXEC) != 0 && new_head != old_head) {

   452

					*chain = new_head;

   453

				}

   454

   455

				/* Transfer cargo of old vehicles and sell them*/

   456

				for (int i = 0; i < num_units; i++) {

   457

					Vehicle *w = old_vehs[i];

   458

					/* Is the vehicle again part of the new chain?

   459

					 * Note: We cannot test 'new_vehs[i] != NULL' as wagon removal might cause to remove both */

   460

					if (w->First() == new_head) continue;

   461

   462

					if ((flags & DC_EXEC) != 0) TransferCargo(w, new_head);

   463

   464

					cost.AddCost(DoCommand(0, w->index, 0, flags, GetCmdSellVeh(w)));

   465

					if ((flags & DC_EXEC) != 0) {

   466

						old_vehs[i] = NULL;

   467

						if (i == 0) old_head = NULL;

   468

					}

   469

				}

   470

			}

   471

   472

			/* If we are not in DC_EXEC undo everything, i.e. rearrange old vehicles.

   473

			 * We do this from back to front, so that the head of the temporary vehicle chain does not change all the time.

   474

			 * Note: The vehicle attach callback is disabled here :) */

   475

			if ((flags & DC_EXEC) == 0) {

   476

				/* Separate the head, so we can reattach the old vehicles */

   477

				Vehicle *second = GetNextUnit(old_head);

   478

				if (second != NULL) MoveVehicle(second, NULL, DC_EXEC | DC_AUTOREPLACE, true);

   479

   480

				assert(GetNextUnit(old_head) == NULL);

   481

   482

				for (int i = num_units - 1; i > 0; i--) {

   483

					CommandCost ret = MoveVehicle(old_vehs[i], old_head, DC_EXEC | DC_AUTOREPLACE, false);

   484

					assert(ret.Succeeded());

   485

				}

   486

			}

   487

		}

   488

   489

		/* Finally undo buying of new vehicles */

   490

		if ((flags & DC_EXEC) == 0) {

   491

			for (int i = num_units - 1; i >= 0; i--) {