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

    20

#include "table/strings.h"

    21

    22

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

    23

 * @param engine_a one of the EngineIDs

    24

 * @param engine_b the other EngineID

    25

 * @param type the type of the engines

    26

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

    27

 */

    28

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

    29

{

    30

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

    31

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

    32

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

    33

}

    34

    35

/**

    36

 * Checks some basic properties whether autoreplace is allowed

    37

 * @param from Origin engine

    38

 * @param to Destination engine

    39

 * @param player Player to check for

    40

 * @return true if autoreplace is allowed

    41

 */

    42

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

    43

{

    44

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

    45

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

    46

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

    47

    48

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

    49

	if (from == to) return false;

    50

    51

	VehicleType type = GetEngine(from)->type;

    52

    53

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

    54

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

    55

    56

	switch (type) {

    57

		case VEH_TRAIN: {

    58

			const RailVehicleInfo *rvi_from = RailVehInfo(from);

    59

			const RailVehicleInfo *rvi_to   = RailVehInfo(to);

    60

    61

			/* make sure the railtypes are compatible */

    62

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

    63

    64

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

    65

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

    66

			break;

    67

		}

    68

    69

		case VEH_ROAD:

    70

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

    71

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

    72

			break;

    73

    74

		case VEH_AIRCRAFT:

    75

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

    76

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

    77

			break;

    78

    79

		default: break;

    80

	}

    81

    82

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

    83

	return EnginesGotCargoInCommon(from, to, type);

    84

}

    85

    86

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

    87

 * @param old_veh Old vehicle that will be sold

    88

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

    89

 */

    90

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

    91

{

    92

	/* Loop through source parts */

    93

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

    94

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

    95

    96

		/* Find free space in the new chain */

    97

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

    98

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

    99

   100

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

   101

			if (amount <= 0) continue;

   102

   103

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

   104

		}

   105

	}

   106

   107

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

   108

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

   109

}

   110

   111

/**

   112

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

   113

 * @param v The vehicle to be replaced

   114

 * @param engine_type The type we want to replace with

   115

 * @return true iff all refit orders stay valid

   116

 */

   117

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

   118

{

   119

	const Order *o;

   120

	const Vehicle *u;

   121

   122

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

   123

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

   124

   125

	if (v->type == VEH_TRAIN) {

   126

		u = v->First();

   127

	} else {

   128

		u = v;

   129

	}

   130

   131

	FOR_VEHICLE_ORDERS(u, o) {

   132

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

   133

		CargoID cargo_type = o->GetRefitCargo();

   134

   135

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

   136

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

   137

	}

   138

   139

	return true;

   140

}

   141

   142

/**

   143

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

   144

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

   145

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

   146

 * @return The cargo type to replace to

   147

 *    CT_NO_REFIT is returned if no refit is needed

   148

 *    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

   149

 */

   150

static CargoID GetNewCargoTypeForReplace(Vehicle *v, EngineID engine_type)

   151

{

   152

	CargoID cargo_type;

   153

   154

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

   155

   156

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

   157

   158

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

   159

   160

	if (cargo_type == CT_INVALID) {

   161

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

   162

   163

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

   164

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

   165

   166

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

   167

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

   168

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

   169

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

   170

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

   171

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

   172

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

   173

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

   174

				}

   175

   176

				return CT_NO_REFIT;

   177

			}

   178

		}

   179

   180

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

   181

	} else {

   182

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

   183

   184

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

   185

   186

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

   187

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

   188

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

   189

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

   190

		}

   191

   192

		return CT_NO_REFIT;

   193

	}

   194

}

   195

   196

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

   197

 * @param v The vehicle to find a replacement for

   198

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

   199

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

   200

 */

   201

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

   202

{

   203

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

   204

   205

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

   206

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

   207

		return INVALID_ENGINE;

   208

	}

   209

   210

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

   211

   212

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

   213

		return e;

   214

	}

   215

   216

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

   217

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

   218

		return v->engine_type;

   219

	}

   220

   221

	return INVALID_ENGINE;

   222

}

   223

   224

/** Builds and refits a replacement vehicle

   225

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

   226

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

   227

 * @param new_vehicle Returns the newly build and refittet vehicle

   228

 * @return cost or error

   229

 */

   230

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

   231

{

   232

	*new_vehicle = NULL;

   233

   234

	/* Shall the vehicle be replaced? */

   235

	const Player *p = GetPlayer(_current_player);

   236

	EngineID e = GetNewEngineType(old_veh, p);

   237

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

   238

   239

	/* Does it need to be refitted */

   240

	CargoID refit_cargo = GetNewCargoTypeForReplace(old_veh, e);

   241

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

   242

   243

	/* Build the new vehicle */

   244

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

   245

	if (cost.Failed()) return cost;

   246

   247

	Vehicle *new_veh = GetVehicle(_new_vehicle_id);

   248

	*new_vehicle = new_veh;

   249

   250

	/* Refit the vehicle if needed */

   251

	if (refit_cargo != CT_NO_REFIT) {

   252

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

   253

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

   254

	}

   255

   256

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

   257

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

   258

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

   259

	}

   260

   261

	return cost;

   262

}

   263

   264

/** Issue a start/stop command

   265

 * @param v a vehicle

   266

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

   267

 * @return success or error

   268

 */

   269

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

   270

{

   271

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

   272

}

   273

   274

/** Issue a train vehicle move command

   275

 * @param v The vehicle to move

   276

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

   277

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

   278

 * @return success or error

   279

 */

   280

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

   281

{

   282

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

   283

}

   284

   285

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

   286

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

   287

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

   288

 * @param flags the command flags to use

   289

 */

   290

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

   291

{

   292

	CommandCost cost = CommandCost();

   293

   294

	/* Share orders */

   295

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

   296

   297

	/* Copy group membership */

   298

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

   299

   300

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

   301

	if (cost.Succeeded()) {

   302

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

   303

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

   304

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

   305

   306

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

   307

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

   308

	}

   309

   310

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

   311

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

   312

		/* Copy vehicle name */

   313

		if (old_head->name != NULL) {

   314

			_cmd_text = old_head->name;

   315

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

   316

			_cmd_text = NULL;

   317

		}

   318

   319

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

   320

		new_head->CopyVehicleConfigAndStatistics(old_head);

   321

   322

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

   323

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

   324

	}

   325

   326

	return cost;

   327

}

   328

   329

/** Replace a whole vehicle chain

   330

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

   331

 * @param flags command flags

   332

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

   333

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

   334

 * @return cost or error

   335

 */

   336

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

   337

{

   338

	Vehicle *old_head = *chain;

   339

   340

	CommandCost cost = CommandCost(EXPENSES_NEW_VEHICLES, 0);

   341

   342

	if (old_head->type == VEH_TRAIN) {

   343

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

   344

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

   345

   346

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

   347

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

   348

   349

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

   350

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

   351

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

   352

   353

		/* Collect vehicles and build replacements

   354

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

   355

		int i;

   356

		Vehicle *w;

   357

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

   358

			assert(i < num_units);

   359

			old_vehs[i] = w;

   360

   361

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

   362

			cost.AddCost(ret);

   363

			if (cost.Failed()) break;

   364

   365

			new_costs[i] = ret.GetCost();

   366

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

   367

		}

   368

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

   369

   370

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

   371

		if (cost.Succeeded()) {

   372

			Vehicle *second = GetNextUnit(old_head);

   373

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

   374

   375

			assert(GetNextUnit(new_head) == NULL);

   376

		}

   377

   378

		/* Append engines to the new chain

   379

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

   380

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

   381

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

   382

		if (cost.Succeeded()) {

   383

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

   384

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

   385

   386

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

   387

   388

				if (last_engine == NULL) last_engine = append;

   389

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

   390

				if (cost.Failed()) break;

   391

			}

   392

			if (last_engine == NULL) last_engine = new_head;

   393

		}

   394

   395

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

   396

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

   397

   398

		/* Append/insert wagons into the new vehicle chain

   399

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

   400

		 */

   401

		if (cost.Succeeded()) {

   402

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

   403

				assert(last_engine != NULL);

   404

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

   405

   406

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

   407

					/* Insert wagon after 'last_engine' */

   408

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

   409

   410

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

   411

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

   412

						break;

   413

					}

   414

   415

					cost.AddCost(res);

   416

					if (cost.Failed()) break;

   417

				} else {

   418

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

   419

					assert(append == last_engine);

   420

					last_engine = GetPrevUnit(last_engine);

   421

				}

   422

			}

   423

		}

   424

   425

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

   426

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

   427

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

   428

				Vehicle *wagon = new_vehs[i];

   429

				if (wagon == NULL) continue;

   430

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

   431

   432

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

   433

   434

				/* Sell wagon */

   435

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

   436

				assert(ret.Succeeded());

   437

				new_vehs[i] = NULL;

   438

   439

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

   440

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

   441

				cost.AddCost(-new_costs[i]);

   442

			}

   443

		}

   444

   445

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

   446

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

   447

   448

		if (cost.Succeeded()) {

   449

			/* Success ! */

   450

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

   451

				*chain = new_head;

   452

			}

   453

   454

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

   455

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

   456

				Vehicle *w = old_vehs[i];

   457

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

   458

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

   459

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

   460

   461

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

   462

   463

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

   464

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

   465

					old_vehs[i] = NULL;

   466

					if (i == 0) old_head = NULL;

   467

				}

   468

			}

   469

		}

   470

   471

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

   472

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

   473

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

   474

			Vehicle *second = GetNextUnit(old_head);

   475

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

   476

   477

			assert(GetNextUnit(old_head) == NULL);

   478

   479

			/* Rearrange old vehicles and sell new

   480

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

   481

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

   482

   483

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

   484

				if (i > 0) {

   485

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

   486

					assert(ret.Succeeded());

   487

				}

   488

				if (new_vehs[i] != NULL) {

   489

					DoCommand(0, new_vehs[i]->index, 0, DC_EXEC, GetCmdSellVeh(new_vehs[i]));

   490

					new_vehs[i] = NULL;

   491

				}

   492

			}

   493

		}

   494