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

     8

#include "debug.h"

     9

#include "vehicle_gui.h"

    10

#include "train.h"

    11

#include "aircraft.h"

    12

#include "roadveh.h"

    13

#include "rail.h"

    14

#include "command_func.h"

    15

#include "engine_base.h"

    16

#include "engine_func.h"

    17

#include "vehicle_func.h"

    18

#include "functions.h"

    19

#include "autoreplace_func.h"

    20

#include "articulated_vehicles.h"

    21

#include "core/alloc_func.hpp"

    22

    23

#include "table/strings.h"

    24

    25

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

    26

 * @param engine_a one of the EngineIDs

    27

 * @param engine_b the other EngineID

    28

 * @param type the type of the engines

    29

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

    30

 */

    31

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

    32

{

    33

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

    34

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

    35

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

    36

}

    37

    38

/**

    39

 * Checks some basic properties whether autoreplace is allowed

    40

 * @param from Origin engine

    41

 * @param to Destination engine

    42

 * @param company Company to check for

    43

 * @return true if autoreplace is allowed

    44

 */

    45

bool CheckAutoreplaceValidity(EngineID from, EngineID to, CompanyID company)

    46

{

    47

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

    48

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

    49

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

    50

    51

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

    52

	if (from == to) return false;

    53

    54

	VehicleType type = GetEngine(from)->type;

    55

    56

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

    57

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

    58

    59

	switch (type) {

    60

		case VEH_TRAIN: {

    61

			const RailVehicleInfo *rvi_from = RailVehInfo(from);

    62

			const RailVehicleInfo *rvi_to   = RailVehInfo(to);

    63

    64

			/* make sure the railtypes are compatible */

    65

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

    66

    67

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

    68

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

    69

			break;

    70

		}

    71

    72

		case VEH_ROAD:

    73

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

    74

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

    75

			break;

    76

    77

		case VEH_AIRCRAFT:

    78

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

    79

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

    80

			break;

    81

    82

		default: break;

    83

	}

    84

    85

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

    86

	return EnginesGotCargoInCommon(from, to, type);

    87

}

    88

    89

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

    90

 * @param old_veh Old vehicle that will be sold

    91

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

    92

 * @param part_of_chain The vehicle is part of a train

    93

 */

    94

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

    95

{

    96

	assert(!part_of_chain || new_head->IsPrimaryVehicle());

    97

	/* Loop through source parts */

    98

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

    99

		if (!part_of_chain && src->type == VEH_TRAIN && src != old_veh && src != old_veh->u.rail.other_multiheaded_part && !IsArticulatedPart(src)) {

   100

			/* Skip vehicles, which do not belong to old_veh */

   101

			src = GetLastEnginePart(src);

   102

			continue;

   103

		}

   104

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

   105

   106

		/* Find free space in the new chain */

   107

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

   108

			if (!part_of_chain && dest->type == VEH_TRAIN && dest != new_head && dest != new_head->u.rail.other_multiheaded_part && !IsArticulatedPart(dest)) {

   109

				/* Skip vehicles, which do not belong to new_head */

   110

				dest = GetLastEnginePart(dest);

   111

				continue;

   112

			}

   113

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

   114

   115

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

   116

			if (amount <= 0) continue;

   117

   118

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

   119

		}

   120

	}

   121

   122

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

   123

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

   124

}

   125

   126

/**

   127

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

   128

 * @param v The vehicle to be replaced

   129

 * @param engine_type The type we want to replace with

   130

 * @return true iff all refit orders stay valid

   131

 */

   132

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

   133

{

   134

	const Order *o;

   135

	const Vehicle *u;

   136

   137

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

   138

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

   139

   140

	if (v->type == VEH_TRAIN) {

   141

		u = v->First();

   142

	} else {

   143

		u = v;

   144

	}

   145

   146

	FOR_VEHICLE_ORDERS(u, o) {

   147

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

   148

		CargoID cargo_type = o->GetRefitCargo();

   149

   150

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

   151

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

   152

	}

   153

   154

	return true;

   155

}

   156

   157

/**

   158

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

   159

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

   160

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

   161

 * @param part_of_chain The vehicle is part of a train

   162

 * @return The cargo type to replace to

   163

 *    CT_NO_REFIT is returned if no refit is needed

   164

 *    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

   165

 */

   166

static CargoID GetNewCargoTypeForReplace(Vehicle *v, EngineID engine_type, bool part_of_chain)

   167

{

   168

	CargoID cargo_type;

   169

   170

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

   171

   172

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

   173

   174

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

   175

   176

	if (cargo_type == CT_INVALID) {

   177

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

   178

   179

		if (!part_of_chain) return CT_NO_REFIT;

   180

   181

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

   182

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

   183

   184

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

   185

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

   186

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

   187

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

   188

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

   189

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

   190

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

   191

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

   192

				}

   193

   194

				return CT_NO_REFIT;

   195

			}

   196

		}

   197

   198

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

   199

	} else {

   200

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

   201

   202

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

   203

   204

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

   205

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

   206

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

   207

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

   208

		}

   209

   210

		return CT_NO_REFIT;

   211

	}

   212

}

   213

   214

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

   215

 * @param v The vehicle to find a replacement for

   216

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

   217

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

   218

 */

   219

static EngineID GetNewEngineType(const Vehicle *v, const Company *c)

   220

{

   221

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

   222

   223

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

   224

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

   225

		return INVALID_ENGINE;

   226

	}

   227

   228

	EngineID e = EngineReplacementForCompany(c, v->engine_type, v->group_id);

   229

   230

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

   231

		return e;

   232

	}

   233

   234

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

   235

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

   236

		return v->engine_type;

   237

	}

   238

   239

	return INVALID_ENGINE;

   240

}

   241

   242

/** Builds and refits a replacement vehicle

   243

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

   244

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

   245

 * @param new_vehicle Returns the newly build and refittet vehicle

   246

 * @param part_of_chain The vehicle is part of a train

   247

 * @return cost or error

   248

 */

   249

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

   250

{

   251

	*new_vehicle = NULL;

   252

   253

	/* Shall the vehicle be replaced? */

   254

	const Company *c = GetCompany(_current_company);

   255

	EngineID e = GetNewEngineType(old_veh, c);

   256

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

   257

   258

	/* Does it need to be refitted */

   259

	CargoID refit_cargo = GetNewCargoTypeForReplace(old_veh, e, part_of_chain);

   260

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

   261

   262

	/* Build the new vehicle */

   263

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

   264

	if (cost.Failed()) return cost;

   265

   266

	Vehicle *new_veh = GetVehicle(_new_vehicle_id);

   267

	*new_vehicle = new_veh;

   268

   269

	/* Refit the vehicle if needed */

   270

	if (refit_cargo != CT_NO_REFIT) {

   271

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

   272

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

   273

	}

   274

   275

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

   276

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

   277

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

   278

	}

   279

   280

	return cost;

   281

}

   282

   283

/** Issue a start/stop command

   284

 * @param v a vehicle

   285

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

   286

 * @return success or error

   287

 */

   288

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

   289

{

   290

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

   291

}

   292

   293

/** Issue a train vehicle move command

   294

 * @param v The vehicle to move

   295

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

   296

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

   297

 * @return success or error

   298

 */

   299

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

   300

{

   301

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

   302

}

   303

   304

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

   305

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

   306

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

   307

 * @param flags the command flags to use

   308

 */

   309

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

   310

{

   311

	CommandCost cost = CommandCost();

   312

   313

	/* Share orders */

   314

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

   315

   316

	/* Copy group membership */

   317

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

   318

   319

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

   320

	if (cost.Succeeded()) {

   321

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

   322

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

   323

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

   324

   325

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

   326

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

   327

	}

   328

   329

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

   330

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

   331

		/* Copy vehicle name */

   332

		if (old_head->name != NULL) {

   333

			_cmd_text = old_head->name;

   334

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

   335

			_cmd_text = NULL;

   336

		}

   337

   338

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

   339

		new_head->CopyVehicleConfigAndStatistics(old_head);

   340

   341

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

   342

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

   343

	}

   344

   345

	return cost;

   346

}

   347

   348

/** Replace a single unit in a free wagon chain

   349

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

   350

 * @param flags command flags

   351

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

   352

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

   353

 * @return cost or error

   354

 */

   355

static CommandCost ReplaceFreeUnit(Vehicle **single_unit, uint32 flags, bool *nothing_to_do)

   356

{

   357

	Vehicle *old_v = *single_unit;

   358

	assert(old_v->type == VEH_TRAIN && !IsArticulatedPart(old_v) && !IsRearDualheaded(old_v));

   359

   360

	CommandCost cost = CommandCost(EXPENSES_NEW_VEHICLES, 0);

   361

   362

	/* Build and refit replacement vehicle */

   363

	Vehicle *new_v = NULL;

   364

	cost.AddCost(BuildReplacementVehicle(old_v, &new_v, false));

   365

   366

	/* Was a new vehicle constructed? */

   367

	if (cost.Succeeded() && new_v != NULL) {

   368

		*nothing_to_do = false;

   369

   370

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

   371

			/* Move the new vehicle behind the old */

   372

			MoveVehicle(new_v, old_v, DC_EXEC, false);

   373

   374

			/* Take over cargo

   375

			 * Note: We do only transfer cargo from the old to the new vehicle.

   376

			 *       I.e. we do not transfer remaining cargo to other vehicles.

   377

			 *       Else you would also need to consider moving cargo to other free chains,

   378

			 *       or doing the same in ReplaceChain(), which would be quite troublesome.

   379

			 */

   380

			TransferCargo(old_v, new_v, false);

   381

   382

			*single_unit = new_v;

   383

		}

   384

   385

		/* Sell the old vehicle */

   386

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

   387

   388

		/* If we are not in DC_EXEC undo everything */

   389

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

   390

			DoCommand(0, new_v->index, 0, DC_EXEC, GetCmdSellVeh(new_v));

   391

		}

   392

	}

   393

   394

	return cost;

   395

}

   396

   397

/** Replace a whole vehicle chain

   398

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

   399

 * @param flags command flags

   400

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

   401

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

   402

 * @return cost or error

   403

 */

   404

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

   405

{

   406

	Vehicle *old_head = *chain;

   407

	assert(old_head->IsPrimaryVehicle());

   408

   409

	CommandCost cost = CommandCost(EXPENSES_NEW_VEHICLES, 0);

   410

   411

	if (old_head->type == VEH_TRAIN) {

   412

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

   413

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

   414

   415

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

   416

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

   417

   418

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

   419

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

   420

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

   421

   422

		/* Collect vehicles and build replacements

   423

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

   424

		int i;

   425

		Vehicle *w;

   426

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

   427

			assert(i < num_units);

   428

			old_vehs[i] = w;

   429

   430

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

   431

			cost.AddCost(ret);

   432

			if (cost.Failed()) break;

   433

   434

			new_costs[i] = ret.GetCost();

   435

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

   436

		}

   437

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

   438

   439

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

   440

		if (cost.Succeeded()) {

   441

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

   442

			Vehicle *second = GetNextUnit(old_head);

   443

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

   444

   445

			assert(GetNextUnit(new_head) == NULL);

   446

   447

			/* Append engines to the new chain

   448

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

   449

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

   450

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

   451

			if (cost.Succeeded()) {

   452

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

   453

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

   454

   455

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

   456

   457

					if (last_engine == NULL) last_engine = append;

   458

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

   459

					if (cost.Failed()) break;

   460

				}

   461

				if (last_engine == NULL) last_engine = new_head;

   462

			}

   463

   464

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

   465

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

   466

   467

			/* Append/insert wagons into the new vehicle chain

   468

			 * 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.

   469

			 */

   470

			if (cost.Succeeded()) {

   471

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

   472

					assert(last_engine != NULL);

   473

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

   474

   475

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

   476

						/* Insert wagon after 'last_engine' */

   477

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

   478

   479

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

   480

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

   481

							break;

   482

						}

   483

   484

						cost.AddCost(res);

   485

						if (cost.Failed()) break;

   486

					} else {

   487

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

   488

						assert(append == last_engine);

   489

						last_engine = GetPrevUnit(last_engine);

   490

					}