src/autoreplace_cmd.cpp

   1 /* $Id$ */
   2
   3 /*
   4  * This file is part of OpenTTD.
   5  * OpenTTD is free software; you can redistribute it and/or modify it under the terms of the GNU General Public License as published by the Free Software Foundation, version 2.
   6  * OpenTTD is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
   7  * See the GNU General Public License for more details. You should have received a copy of the GNU General Public License along with OpenTTD. If not, see <http://www.gnu.org/licenses/>.
   8  */
   9
  10 /** @file autoreplace_cmd.cpp Deals with autoreplace execution but not the setup */
  11
  12 #include "stdafx.h"
  13 #include "company_func.h"
  14 #include "train.h"
  15 #include "command_func.h"
  16 #include "engine_func.h"
  17 #include "vehicle_func.h"
  18 #include "autoreplace_func.h"
  19 #include "autoreplace_gui.h"
  20 #include "articulated_vehicles.h"
  21 #include "core/random_func.hpp"
  22
  23 #include "table/strings.h"
  24
  25 #include "safeguards.h"
  26
  27 extern void ChangeVehicleViewports(VehicleID from_index, VehicleID to_index);
  28 extern void ChangeVehicleNews(VehicleID from_index, VehicleID to_index);
  29 extern void ChangeVehicleViewWindow(VehicleID from_index, VehicleID to_index);
  30
  31 /**
  32  * Figure out if two engines got at least one type of cargo in common (refitting if needed)
  33  * @param engine_a one of the EngineIDs
  34  * @param engine_b the other EngineID
  35  * @param type the type of the engines
  36  * @return true if they can both carry the same type of cargo (or at least one of them got no capacity at all)
  37  */
  38 static bool EnginesHaveCargoInCommon(EngineID engine_a, EngineID engine_b)
  39 {
  40         uint32 available_cargoes_a = GetUnionOfArticulatedRefitMasks(engine_a, true);
  41         uint32 available_cargoes_b = GetUnionOfArticulatedRefitMasks(engine_b, true);
  42         return (available_cargoes_a == 0 || available_cargoes_b == 0 || (available_cargoes_a & available_cargoes_b) != 0);
  43 }
  44
  45 /**
  46  * Checks some basic properties whether autoreplace is allowed
  47  * @param from Origin engine
  48  * @param to Destination engine
  49  * @param company Company to check for
  50  * @return true if autoreplace is allowed
  51  */
  52 bool CheckAutoreplaceValidity(EngineID from, EngineID to, CompanyID company)
  53 {
  54         assert(Engine::IsValidID(from) && Engine::IsValidID(to));
  55
  56         /* we can't replace an engine into itself (that would be autorenew) */
  57         if (from == to) return false;
  58
  59         const Engine *e_from = Engine::Get(from);
  60         const Engine *e_to = Engine::Get(to);
  61         VehicleType type = e_from->type;
  62
  63         /* check that the new vehicle type is available to the company and its type is the same as the original one */
  64         if (!IsEngineBuildable(to, type, company)) return false;
  65
  66         switch (type) {
  67                 case VEH_TRAIN: {
  68                         /* make sure the railtypes are compatible */
  69                         if ((GetRailTypeInfo(e_from->u.rail.railtype)->compatible_railtypes & GetRailTypeInfo(e_to->u.rail.railtype)->compatible_railtypes) == 0) return false;
  70
  71                         /* make sure we do not replace wagons with engines or vice versa */
  72                         if ((e_from->u.rail.railveh_type == RAILVEH_WAGON) != (e_to->u.rail.railveh_type == RAILVEH_WAGON)) return false;
  73                         break;
  74                 }
  75
  76                 case VEH_ROAD:
  77                         /* make sure that we do not replace a tram with a normal road vehicles or vice versa */
  78                         if (HasBit(e_from->info.misc_flags, EF_ROAD_TRAM) != HasBit(e_to->info.misc_flags, EF_ROAD_TRAM)) return false;
  79                         break;
  80
  81                 case VEH_AIRCRAFT:
  82                         /* make sure that we do not replace a plane with a helicopter or vice versa */
  83                         if ((e_from->u.air.subtype & AIR_CTOL) != (e_to->u.air.subtype & AIR_CTOL)) return false;
  84                         break;
  85
  86                 default: break;
  87         }
  88
  89         /* the engines needs to be able to carry the same cargo */
  90         return EnginesHaveCargoInCommon(from, to);
  91 }
  92
  93 /**
  94  * Check the capacity of all vehicles in a chain and spread cargo if needed.
  95  * @param v The vehicle to check.
  96  * @pre You can only do this if the consist is not loading or unloading. It
  97  *      must not carry reserved cargo, nor cargo to be unloaded or transferred.
  98  */
  99 void CheckCargoCapacity(Vehicle *v)
 100 {
 101         assert(v == NULL || v->First() == v);
 102
 103         for (Vehicle *src = v; src != NULL; src = src->Next()) {
 104                 assert(src->cargo.TotalCount() == src->cargo.ActionCount(VehicleCargoList::MTA_KEEP));
 105
 106                 /* Do we need to more cargo away? */
 107                 if (src->cargo.TotalCount() <= src->cargo_cap) continue;
 108
 109                 /* We need to move a particular amount. Try that on the other vehicles. */
 110                 uint to_spread = src->cargo.TotalCount() - src->cargo_cap;
 111                 for (Vehicle *dest = v; dest != NULL && to_spread != 0; dest = dest->Next()) {
 112                         assert(dest->cargo.TotalCount() == dest->cargo.ActionCount(VehicleCargoList::MTA_KEEP));
 113                         if (dest->cargo.TotalCount() >= dest->cargo_cap || dest->cargo_type != src->cargo_type) continue;
 114
 115                         uint amount = min(to_spread, dest->cargo_cap - dest->cargo.TotalCount());
 116                         src->cargo.Shift(amount, &dest->cargo);
 117                         to_spread -= amount;
 118                 }
 119
 120                 /* Any left-overs will be thrown away, but not their feeder share. */
 121                 if (src->cargo_cap < src->cargo.TotalCount()) src->cargo.Truncate(src->cargo.TotalCount() - src->cargo_cap);
 122         }
 123 }
 124
 125 /**
 126  * Transfer cargo from a single (articulated )old vehicle to the new vehicle chain
 127  * @param old_veh Old vehicle that will be sold
 128  * @param new_head Head of the completely constructed new vehicle chain
 129  * @param part_of_chain The vehicle is part of a train
 130  * @pre You can only do this if both consists are not loading or unloading.
 131  *      They must not carry reserved cargo, nor cargo to be unloaded or
 132  *      transferred.
 133  */
 134 static void TransferCargo(Vehicle *old_veh, Vehicle *new_head, bool part_of_chain)
 135 {
 136         assert(!part_of_chain || new_head->IsPrimaryVehicle());
 137         /* Loop through source parts */
 138         for (Vehicle *src = old_veh; src != NULL; src = src->Next()) {
 139                 assert(src->cargo.TotalCount() == src->cargo.ActionCount(VehicleCargoList::MTA_KEEP));
 140                 if (!part_of_chain && src->type == VEH_TRAIN && src != old_veh && src != Train::From(old_veh)->other_multiheaded_part && !src->IsArticulatedPart()) {
 141                         /* Skip vehicles, which do not belong to old_veh */
 142                         src = src->GetLastEnginePart();
 143                         continue;
 144                 }
 145                 if (src->cargo_type >= NUM_CARGO || src->cargo.TotalCount() == 0) continue;
 146
 147                 /* Find free space in the new chain */
 148                 for (Vehicle *dest = new_head; dest != NULL && src->cargo.TotalCount() > 0; dest = dest->Next()) {
 149                         assert(dest->cargo.TotalCount() == dest->cargo.ActionCount(VehicleCargoList::MTA_KEEP));
 150                         if (!part_of_chain && dest->type == VEH_TRAIN && dest != new_head && dest != Train::From(new_head)->other_multiheaded_part && !dest->IsArticulatedPart()) {
 151                                 /* Skip vehicles, which do not belong to new_head */
 152                                 dest = dest->GetLastEnginePart();
 153                                 continue;
 154                         }
 155                         if (dest->cargo_type != src->cargo_type) continue;
 156
 157                         uint amount = min(src->cargo.TotalCount(), dest->cargo_cap - dest->cargo.TotalCount());
 158                         if (amount <= 0) continue;
 159
 160                         src->cargo.Shift(amount, &dest->cargo);
 161                 }
 162         }
 163
 164         /* Update train weight etc., the old vehicle will be sold anyway */
 165         if (part_of_chain && new_head->type == VEH_TRAIN) Train::From(new_head)->ConsistChanged(CCF_LOADUNLOAD);
 166 }
 167
 168 /**
 169  * Tests whether refit orders that applied to v will also apply to the new vehicle type
 170  * @param v The vehicle to be replaced
 171  * @param engine_type The type we want to replace with
 172  * @return true iff all refit orders stay valid
 173  */
 174 static bool VerifyAutoreplaceRefitForOrders(const Vehicle *v, EngineID engine_type)
 175 {
 176
 177         uint32 union_refit_mask_a = GetUnionOfArticulatedRefitMasks(v->engine_type, false);
 178         uint32 union_refit_mask_b = GetUnionOfArticulatedRefitMasks(engine_type, false);
 179
 180         const Order *o;
 181         const Vehicle *u = (v->type == VEH_TRAIN) ? v->First() : v;
 182         FOR_VEHICLE_ORDERS(u, o) {
 183                 if (!o->IsRefit() || o->IsAutoRefit()) continue;
 184                 CargoID cargo_type = o->GetRefitCargo();
 185
 186                 if (!HasBit(union_refit_mask_a, cargo_type)) continue;
 187                 if (!HasBit(union_refit_mask_b, cargo_type)) return false;
 188         }
 189
 190         return true;
 191 }
 192
 193 /**
 194  * Function to find what type of cargo to refit to when autoreplacing
 195  * @param *v Original vehicle that is being replaced.
 196  * @param engine_type The EngineID of the vehicle that is being replaced to
 197  * @param part_of_chain The vehicle is part of a train
 198  * @return The cargo type to replace to
 199  *    CT_NO_REFIT is returned if no refit is needed
 200  *    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
 201  */
 202 static CargoID GetNewCargoTypeForReplace(Vehicle *v, EngineID engine_type, bool part_of_chain)
 203 {
 204         uint32 available_cargo_types, union_mask;
 205         GetArticulatedRefitMasks(engine_type, true, &union_mask, &available_cargo_types);
 206
 207         if (union_mask == 0) return CT_NO_REFIT; // Don't try to refit an engine with no cargo capacity
 208
 209         CargoID cargo_type;
 210         if (IsArticulatedVehicleCarryingDifferentCargoes(v, &cargo_type)) return CT_INVALID; // We cannot refit to mixed cargoes in an automated way
 211
 212         if (cargo_type == CT_INVALID) {
 213                 if (v->type != VEH_TRAIN) return CT_NO_REFIT; // If the vehicle does not carry anything at all, every replacement is fine.
 214
 215                 if (!part_of_chain) return CT_NO_REFIT;
 216
 217                 /* the old engine didn't have cargo capacity, but the new one does
 218                  * now we will figure out what cargo the train is carrying and refit to fit this */
 219
 220                 for (v = v->First(); v != NULL; v = v->Next()) {
 221                         if (!v->GetEngine()->CanCarryCargo()) continue;
 222                         /* Now we found a cargo type being carried on the train and we will see if it is possible to carry to this one */
 223                         if (HasBit(available_cargo_types, v->cargo_type)) return v->cargo_type;
 224                 }
 225
 226                 return CT_NO_REFIT; // We failed to find a cargo type on the old vehicle and we will not refit the new one
 227         } else {
 228                 if (!HasBit(available_cargo_types, cargo_type)) return CT_INVALID; // We can't refit the vehicle to carry the cargo we want
 229
 230                 if (part_of_chain && !VerifyAutoreplaceRefitForOrders(v, engine_type)) return CT_INVALID; // Some refit orders lose their effect
 231
 232                 return cargo_type;
 233         }
 234 }
 235
 236 /**
 237  * Get the EngineID of the replacement for a vehicle
 238  * @param v The vehicle to find a replacement for
 239  * @param c The vehicle's owner (it's faster to forward the pointer than refinding it)
 240  * @param always_replace Always replace, even if not old.
 241  * @param [out] e the EngineID of the replacement. INVALID_ENGINE if no replacement is found
 242  * @return Error if the engine to build is not available
 243  */
 244 static CommandCost GetNewEngineType(const Vehicle *v, const Company *c, bool always_replace, EngineID &e)
 245 {
 246         assert(v->type != VEH_TRAIN || !v->IsArticulatedPart());
 247
 248         e = INVALID_ENGINE;
 249
 250         if (v->type == VEH_TRAIN && Train::From(v)->IsRearDualheaded()) {
 251                 /* we build the rear ends of multiheaded trains with the front ones */
 252                 return CommandCost();
 253         }
 254
 255         bool replace_when_old;
 256         e = EngineReplacementForCompany(c, v->engine_type, v->group_id, &replace_when_old);
 257         if (!always_replace && replace_when_old && !v->NeedsAutorenewing(c, false)) e = INVALID_ENGINE;
 258
 259         /* Autoreplace, if engine is available */
 260         if (e != INVALID_ENGINE && IsEngineBuildable(e, v->type, _current_company)) {
 261                 return CommandCost();
 262         }
 263
 264         /* Autorenew if needed */
 265         if (v->NeedsAutorenewing(c)) e = v->engine_type;
 266
 267         /* Nothing to do or all is fine? */
 268         if (e == INVALID_ENGINE || IsEngineBuildable(e, v->type, _current_company)) return CommandCost();
 269
 270         /* The engine we need is not available. Report error to user */
 271         return CommandCost(STR_ERROR_RAIL_VEHICLE_NOT_AVAILABLE + v->type);
 272 }
 273
 274 /**
 275  * Builds and refits a replacement vehicle
 276  * 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)
 277  * @param old_veh A single (articulated/multiheaded) vehicle that shall be replaced.
 278  * @param new_vehicle Returns the newly build and refitted vehicle
 279  * @param part_of_chain The vehicle is part of a train
 280  * @return cost or error
 281  */
 282 static CommandCost BuildReplacementVehicle(Vehicle *old_veh, Vehicle **new_vehicle, bool part_of_chain)
 283 {
 284         *new_vehicle = NULL;
 285
 286         /* Shall the vehicle be replaced? */
 287         const Company *c = Company::Get(_current_company);
 288         EngineID e;
 289         CommandCost cost = GetNewEngineType(old_veh, c, true, e);
 290         if (cost.Failed()) return cost;
 291         if (e == INVALID_ENGINE) return CommandCost(); // neither autoreplace is set, nor autorenew is triggered
 292
 293         /* Does it need to be refitted */
 294         CargoID refit_cargo = GetNewCargoTypeForReplace(old_veh, e, part_of_chain);
 295         if (refit_cargo == CT_INVALID) return CommandCost(); // incompatible cargoes
 296
 297         /* Build the new vehicle */
 298         cost = DoCommand(old_veh->tile, e, 0, DC_EXEC | DC_AUTOREPLACE, GetCmdBuildVeh(old_veh));
 299         if (cost.Failed()) return cost;
 300
 301         Vehicle *new_veh = Vehicle::Get(_new_vehicle_id);
 302         *new_vehicle = new_veh;
 303
 304         /* Refit the vehicle if needed */
 305         if (refit_cargo != CT_NO_REFIT) {
 306                 byte subtype = GetBestFittingSubType(old_veh, new_veh, refit_cargo);
 307
 308                 cost.AddCost(DoCommand(0, new_veh->index, refit_cargo | (subtype << 8), DC_EXEC, GetCmdRefitVeh(new_veh)));
 309                 assert(cost.Succeeded()); // This should be ensured by GetNewCargoTypeForReplace()
 310         }
 311
 312         /* Try to reverse the vehicle, but do not care if it fails as the new type might not be reversible */
 313         if (new_veh->type == VEH_TRAIN && HasBit(Train::From(old_veh)->flags, VRF_REVERSE_DIRECTION)) {
 314                 DoCommand(0, new_veh->index, true, DC_EXEC, CMD_REVERSE_TRAIN_DIRECTION);
 315         }
 316
 317         return cost;
 318 }
 319
 320 /**
 321  * Issue a start/stop command
 322  * @param v a vehicle
 323  * @param evaluate_callback shall the start/stop callback be evaluated?
 324  * @return success or error
 325  */
 326 static inline CommandCost CmdStartStopVehicle(const Vehicle *v, bool evaluate_callback)
 327 {
 328         return DoCommand(0, v->index, evaluate_callback ? 1 : 0, DC_EXEC | DC_AUTOREPLACE, CMD_START_STOP_VEHICLE);
 329 }
 330
 331 /**
 332  * Issue a train vehicle move command
 333  * @param v The vehicle to move
 334  * @param after The vehicle to insert 'v' after, or NULL to start new chain
 335  * @param flags the command flags to use
 336  * @param whole_chain move all vehicles following 'v' (true), or only 'v' (false)
 337  * @return success or error
 338  */
 339 static inline CommandCost CmdMoveVehicle(const Vehicle *v, const Vehicle *after, DoCommandFlag flags, bool whole_chain)
 340 {
 341         return DoCommand(0, v->index | (whole_chain ? 1 : 0) << 20, after != NULL ? after->index : INVALID_VEHICLE, flags | DC_NO_CARGO_CAP_CHECK, CMD_MOVE_RAIL_VEHICLE);
 342 }
 343
 344 /**
 345  * Copy head specific things to the new vehicle chain after it was successfully constructed
 346  * @param old_head The old front vehicle (no wagons attached anymore)
 347  * @param new_head The new head of the completely replaced vehicle chain
 348  * @param flags the command flags to use
 349  */
 350 static CommandCost CopyHeadSpecificThings(Vehicle *old_head, Vehicle *new_head, DoCommandFlag flags)
 351 {
 352         CommandCost cost = CommandCost();
 353
 354         /* Share orders */
 355         if (cost.Succeeded() && old_head != new_head) cost.AddCost(DoCommand(0, new_head->index | CO_SHARE << 30, old_head->index, DC_EXEC, CMD_CLONE_ORDER));
 356
 357         /* Copy group membership */
 358         if (cost.Succeeded() && old_head != new_head) cost.AddCost(DoCommand(0, old_head->group_id, new_head->index, DC_EXEC, CMD_ADD_VEHICLE_GROUP));
 359
 360         /* Perform start/stop check whether the new vehicle suits newgrf restrictions etc. */
 361         if (cost.Succeeded()) {
 362                 /* Start the vehicle, might be denied by certain things */
 363                 assert((new_head->vehstatus & VS_STOPPED) != 0);
 364                 cost.AddCost(CmdStartStopVehicle(new_head, true));
 365
 366                 /* Stop the vehicle again, but do not care about evil newgrfs allowing starting but not stopping :p */
 367                 if (cost.Succeeded()) cost.AddCost(CmdStartStopVehicle(new_head, false));
 368         }
 369
 370         /* Last do those things which do never fail (resp. we do not care about), but which are not undo-able */
 371         if (cost.Succeeded() && old_head != new_head && (flags & DC_EXEC) != 0) {
 372                 /* Copy other things which cannot be copied by a command and which shall not stay resetted from the build vehicle command */
 373                 new_head->CopyVehicleConfigAndStatistics(old_head);
 374
 375                 /* Switch vehicle windows/news to the new vehicle, so they are not closed/deleted when the old vehicle is sold */
 376                 ChangeVehicleViewports(old_head->index, new_head->index);
 377                 ChangeVehicleViewWindow(old_head->index, new_head->index);
 378                 ChangeVehicleNews(old_head->index, new_head->index);
 379         }
 380
 381         return cost;
 382 }
 383
 384 /**
 385  * Replace a single unit in a free wagon chain
 386  * @param single_unit vehicle to let autoreplace/renew operator on
 387  * @param flags command flags
 388  * @param nothing_to_do is set to 'false' when something was done (only valid when not failed)
 389  * @return cost or error
 390  */
 391 static CommandCost ReplaceFreeUnit(Vehicle **single_unit, DoCommandFlag flags, bool *nothing_to_do)
 392 {
 393         Train *old_v = Train::From(*single_unit);
 394         assert(!old_v->IsArticulatedPart() && !old_v->IsRearDualheaded());
 395
 396         CommandCost cost = CommandCost(EXPENSES_NEW_VEHICLES, 0);
 397
 398         /* Build and refit replacement vehicle */
 399         Vehicle *new_v = NULL;
 400         cost.AddCost(BuildReplacementVehicle(old_v, &new_v, false));
 401
 402         /* Was a new vehicle constructed? */
 403         if (cost.Succeeded() && new_v != NULL) {
 404                 *nothing_to_do = false;
 405
 406                 if ((flags & DC_EXEC) != 0) {
 407                         /* Move the new vehicle behind the old */
 408                         CmdMoveVehicle(new_v, old_v, DC_EXEC, false);
 409
 410                         /* Take over cargo
 411                          * Note: We do only transfer cargo from the old to the new vehicle.
 412                          *       I.e. we do not transfer remaining cargo to other vehicles.
 413                          *       Else you would also need to consider moving cargo to other free chains,
 414                          *       or doing the same in ReplaceChain(), which would be quite troublesome.
 415                          */
 416                         TransferCargo(old_v, new_v, false);
 417
 418                         *single_unit = new_v;
 419                 }
 420
 421                 /* Sell the old vehicle */
 422                 cost.AddCost(DoCommand(0, old_v->index, 0, flags, GetCmdSellVeh(old_v)));
 423
 424                 /* If we are not in DC_EXEC undo everything */
 425                 if ((flags & DC_EXEC) == 0) {
 426                         DoCommand(0, new_v->index, 0, DC_EXEC, GetCmdSellVeh(new_v));
 427                 }
 428         }
 429
 430         return cost;
 431 }
 432
 433 /**
 434  * Replace a whole vehicle chain
 435  * @param chain vehicle chain to let autoreplace/renew operator on
 436  * @param flags command flags
 437  * @param wagon_removal remove wagons when the resulting chain occupies more tiles than the old did
 438  * @param nothing_to_do is set to 'false' when something was done (only valid when not failed)
 439  * @return cost or error
 440  */
 441 static CommandCost ReplaceChain(Vehicle **chain, DoCommandFlag flags, bool wagon_removal, bool *nothing_to_do)
 442 {
 443         Vehicle *old_head = *chain;
 444         assert(old_head->IsPrimaryVehicle());
 445
 446         CommandCost cost = CommandCost(EXPENSES_NEW_VEHICLES, 0);
 447
 448         if (old_head->type == VEH_TRAIN) {
 449                 /* Store the length of the old vehicle chain, rounded up to whole tiles */
 450                 uint16 old_total_length = CeilDiv(Train::From(old_head)->gcache.cached_total_length, TILE_SIZE) * TILE_SIZE;
 451
 452                 int num_units = 0; ///< Number of units in the chain
 453                 for (Train *w = Train::From(old_head); w != NULL; w = w->GetNextUnit()) num_units++;
 454
 455                 Train **old_vehs = CallocT<Train *>(num_units); ///< Will store vehicles of the old chain in their order
 456                 Train **new_vehs = CallocT<Train *>(num_units); ///< New vehicles corresponding to old_vehs or NULL if no replacement
 457                 Money *new_costs = MallocT<Money>(num_units);   ///< Costs for buying and refitting the new vehicles
 458
 459                 /* Collect vehicles and build replacements
 460                  * Note: The replacement vehicles can only successfully build as long as the old vehicles are still in their chain */
 461                 int i;
 462                 Train *w;
 463                 for (w = Train::From(old_head), i = 0; w != NULL; w = w->GetNextUnit(), i++) {
 464                         assert(i < num_units);
 465                         old_vehs[i] = w;
 466
 467                         CommandCost ret = BuildReplacementVehicle(old_vehs[i], (Vehicle**)&new_vehs[i], true);
 468                         cost.AddCost(ret);
 469                         if (cost.Failed()) break;
 470
 471                         new_costs[i] = ret.GetCost();
 472                         if (new_vehs[i] != NULL) *nothing_to_do = false;
 473                 }
 474                 Train *new_head = (new_vehs[0] != NULL ? new_vehs[0] : old_vehs[0]);
 475
 476                 /* Note: When autoreplace has already failed here, old_vehs[] is not completely initialized. But it is also not needed. */
 477                 if (cost.Succeeded()) {
 478                         /* Separate the head, so we can start constructing the new chain */
 479                         Train *second = Train::From(old_head)->GetNextUnit();
 480                         if (second != NULL) cost.AddCost(CmdMoveVehicle(second, NULL, DC_EXEC | DC_AUTOREPLACE, true));
 481
 482                         assert(Train::From(new_head)->GetNextUnit() == NULL);
 483
 484                         /* Append engines to the new chain
 485                          * We do this from back to front, so that the head of the temporary vehicle chain does not change all the time.
 486                          * That way we also have less trouble when exceeding the unitnumber limit.
 487                          * OTOH the vehicle attach callback is more expensive this way :s */
 488                         Train *last_engine = NULL; ///< Shall store the last engine unit after this step
 489                         if (cost.Succeeded()) {
 490                                 for (int i = num_units - 1; i > 0; i--) {
 491                                         Train *append = (new_vehs[i] != NULL ? new_vehs[i] : old_vehs[i]);
 492
 493                                         if (RailVehInfo(append->engine_type)->railveh_type == RAILVEH_WAGON) continue;
 494
 495                                         if (new_vehs[i] != NULL) {
 496                                                 /* Move the old engine to a separate row with DC_AUTOREPLACE. Else
 497                                                  * moving the wagon in front may fail later due to unitnumber limit.
 498                                                  * (We have to attach wagons without DC_AUTOREPLACE.) */
 499                                                 CmdMoveVehicle(old_vehs[i], NULL, DC_EXEC | DC_AUTOREPLACE, false);
 500                                         }
 501
 502                                         if (last_engine == NULL) last_engine = append;
 503                                         cost.AddCost(CmdMoveVehicle(append, new_head, DC_EXEC, false));
 504                                         if (cost.Failed()) break;
 505                                 }
 506                                 if (last_engine == NULL) last_engine = new_head;
 507                         }
 508
 509                         /* When wagon removal is enabled and the new engines without any wagons are already longer than the old, we have to fail */
 510                         if (cost.Succeeded() && wagon_removal && new_head->gcache.cached_total_length > old_total_length) cost = CommandCost(STR_ERROR_TRAIN_TOO_LONG_AFTER_REPLACEMENT);
 511
 512                         /* Append/insert wagons into the new vehicle chain
 513                          * 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.
 514                          */
 515                         if (cost.Succeeded()) {
 516                                 for (int i = num_units - 1; i > 0; i--) {
 517                                         assert(last_engine != NULL);
 518                                         Vehicle *append = (new_vehs[i] != NULL ? new_vehs[i] : old_vehs[i]);
 519
 520                                         if (RailVehInfo(append->engine_type)->railveh_type == RAILVEH_WAGON) {
 521                                                 /* Insert wagon after 'last_engine' */
 522                                                 CommandCost res = CmdMoveVehicle(append, last_engine, DC_EXEC, false);
 523
 524                                                 /* When we allow removal of wagons, either the move failing due
 525                                                  * to the train becoming too long, or the train becoming longer
 526                                                  * would move the vehicle to the empty vehicle chain. */
 527                                                 if (wagon_removal && (res.Failed() ? res.GetErrorMessage() == STR_ERROR_TRAIN_TOO_LONG : new_head->gcache.cached_total_length > old_total_length)) {
 528                                                         CmdMoveVehicle(append, NULL, DC_EXEC | DC_AUTOREPLACE, false);
 529                                                         break;
 530                                                 }
 531
 532                                                 cost.AddCost(res);
 533                                                 if (cost.Failed()) break;
 534                                         } else {
 535                                                 /* We have reached 'last_engine', continue with the next engine towards the front */
 536                                                 assert(append == last_engine);
 537                                                 last_engine = last_engine->GetPrevUnit();
 538                                         }
 539                                 }
 540                         }
 541
 542                         /* Sell superfluous new vehicles that could not be inserted. */
 543                         if (cost.Succeeded() && wagon_removal) {
 544                                 assert(new_head->gcache.cached_total_length <= _settings_game.vehicle.max_train_length * TILE_SIZE);
 545                                 for (int i = 1; i < num_units; i++) {
 546                                         Vehicle *wagon = new_vehs[i];
 547                                         if (wagon == NULL) continue;
 548                                         if (wagon->First() == new_head) break;
 549
 550                                         assert(RailVehInfo(wagon->engine_type)->railveh_type == RAILVEH_WAGON);
 551
 552                                         /* Sell wagon */
 553                                         CommandCost ret = DoCommand(0, wagon->index, 0, DC_EXEC, GetCmdSellVeh(wagon));
 554                                         assert(ret.Succeeded());
 555                                         new_vehs[i] = NULL;
 556
 557                                         /* Revert the money subtraction when the vehicle was built.
 558                                          * This value is different from the sell value, esp. because of refitting */
 559                                         cost.AddCost(-new_costs[i]);
 560                                 }
 561                         }
 562
 563                         /* The new vehicle chain is constructed, now take over orders and everything... */
 564                         if (cost.Succeeded()) cost.AddCost(CopyHeadSpecificThings(old_head, new_head, flags));
 565
 566                         if (cost.Succeeded()) {
 567                                 /* Success ! */
 568                                 if ((flags & DC_EXEC) != 0 && new_head != old_head) {
 569                                         *chain = new_head;
 570                                 }
 571
 572                                 /* Transfer cargo of old vehicles and sell them */
 573                                 for (int i = 0; i < num_units; i++) {
 574                                         Vehicle *w = old_vehs[i];
 575                                         /* Is the vehicle again part of the new chain?
 576                                          * Note: We cannot test 'new_vehs[i] != NULL' as wagon removal might cause to remove both */
 577                                         if (w->First() == new_head) continue;
 578
 579                                         if ((flags & DC_EXEC) != 0) TransferCargo(w, new_head, true);
 580
 581                                         /* Sell the vehicle.
 582                                          * Note: This might temporarly construct new trains, so use DC_AUTOREPLACE to prevent
 583                                          *       it from failing due to engine limits. */
 584                                         cost.AddCost(DoCommand(0, w->index, 0, flags | DC_AUTOREPLACE, GetCmdSellVeh(w)));
 585                                         if ((flags & DC_EXEC) != 0) {
 586                                                 old_vehs[i] = NULL;
 587                                                 if (i == 0) old_head = NULL;
 588                                         }
 589                                 }
 590
 591                                 if ((flags & DC_EXEC) != 0) CheckCargoCapacity(new_head);
 592                         }
 593
 594                         /* If we are not in DC_EXEC undo everything, i.e. rearrange old vehicles.
 595                          * We do this from back to front, so that the head of the temporary vehicle chain does not change all the time.
 596                          * Note: The vehicle attach callback is disabled here :) */
 597                         if ((flags & DC_EXEC) == 0) {
 598                                 /* Separate the head, so we can reattach the old vehicles */
 599                                 Train *second = Train::From(old_head)->GetNextUnit();
 600                                 if (second != NULL) CmdMoveVehicle(second, NULL, DC_EXEC | DC_AUTOREPLACE, true);
 601
 602                                 assert(Train::From(old_head)->GetNextUnit() == NULL);
 603
 604                                 for (int i = num_units - 1; i > 0; i--) {
 605                                         CommandCost ret = CmdMoveVehicle(old_vehs[i], old_head, DC_EXEC | DC_AUTOREPLACE, false);
 606                                         assert(ret.Succeeded());
 607                                 }
 608                         }
 609                 }
 610
 611                 /* Finally undo buying of new vehicles */
 612                 if ((flags & DC_EXEC) == 0) {
 613                         for (int i = num_units - 1; i >= 0; i--) {
 614                                 if (new_vehs[i] != NULL) {
 615                                         DoCommand(0, new_vehs[i]->index, 0, DC_EXEC, GetCmdSellVeh(new_vehs[i]));
 616                                         new_vehs[i] = NULL;
 617                                 }
 618                         }
 619                 }
 620
 621                 free(old_vehs);
 622                 free(new_vehs);
 623                 free(new_costs);
 624         } else {
 625                 /* Build and refit replacement vehicle */
 626                 Vehicle *new_head = NULL;
 627                 cost.AddCost(BuildReplacementVehicle(old_head, &new_head, true));
 628
 629                 /* Was a new vehicle constructed? */
 630                 if (cost.Succeeded() && new_head != NULL) {
 631                         *nothing_to_do = false;
 632
 633                         /* The new vehicle is constructed, now take over orders and everything... */
 634                         cost.AddCost(CopyHeadSpecificThings(old_head, new_head, flags));
 635
 636                         if (cost.Succeeded()) {
 637                                 /* The new vehicle is constructed, now take over cargo */
 638                                 if ((flags & DC_EXEC) != 0) {
 639                                         TransferCargo(old_head, new_head, true);
 640                                         *chain = new_head;
 641                                 }
 642
 643                                 /* Sell the old vehicle */
 644                                 cost.AddCost(DoCommand(0, old_head->index, 0, flags, GetCmdSellVeh(old_head)));
 645                         }
 646
 647                         /* If we are not in DC_EXEC undo everything */
 648                         if ((flags & DC_EXEC) == 0) {
 649                                 DoCommand(0, new_head->index, 0, DC_EXEC, GetCmdSellVeh(new_head));
 650                         }
 651                 }
 652         }
 653
 654         return cost;
 655 }
 656
 657 /**
 658  * Autoreplaces a vehicle
 659  * Trains are replaced as a whole chain, free wagons in depot are replaced on their own
 660  * @param tile not used
 661  * @param flags type of operation
 662  * @param p1 Index of vehicle
 663  * @param p2 not used
 664  * @param text unused
 665  * @return the cost of this operation or an error
 666  */
 667 CommandCost CmdAutoreplaceVehicle(TileIndex tile, DoCommandFlag flags, uint32 p1, uint32 p2, const char *text)
 668 {
 669         Vehicle *v = Vehicle::GetIfValid(p1);
 670         if (v == NULL) return CMD_ERROR;
 671
 672         CommandCost ret = CheckOwnership(v->owner);
 673         if (ret.Failed()) return ret;
 674
 675         if (!v->IsChainInDepot()) return CMD_ERROR;
 676         if (v->vehstatus & VS_CRASHED) return CMD_ERROR;
 677
 678         bool free_wagon = false;
 679         if (v->type == VEH_TRAIN) {
 680                 Train *t = Train::From(v);
 681                 if (t->IsArticulatedPart() || t->IsRearDualheaded()) return CMD_ERROR;
 682                 free_wagon = !t->IsFrontEngine();
 683                 if (free_wagon && t->First()->IsFrontEngine()) return CMD_ERROR;
 684         } else {
 685                 if (!v->IsPrimaryVehicle()) return CMD_ERROR;
 686         }
 687
 688         const Company *c = Company::Get(_current_company);
 689         bool wagon_removal = c->settings.renew_keep_length;
 690
 691         /* Test whether any replacement is set, before issuing a whole lot of commands that would end in nothing changed */
 692         Vehicle *w = v;
 693         bool any_replacements = false;
 694         while (w != NULL) {
 695                 EngineID e;
 696                 CommandCost cost = GetNewEngineType(w, c, false, e);
 697                 if (cost.Failed()) return cost;
 698                 any_replacements |= (e != INVALID_ENGINE);
 699                 w = (!free_wagon && w->type == VEH_TRAIN ? Train::From(w)->GetNextUnit() : NULL);
 700         }
 701
 702         CommandCost cost = CommandCost(EXPENSES_NEW_VEHICLES, 0);
 703         bool nothing_to_do = true;
 704
 705         if (any_replacements) {
 706                 bool was_stopped = free_wagon || ((v->vehstatus & VS_STOPPED) != 0);
 707
 708                 /* Stop the vehicle */
 709                 if (!was_stopped) cost.AddCost(CmdStartStopVehicle(v, true));
 710                 if (cost.Failed()) return cost;
 711
 712                 assert(free_wagon || v->IsStoppedInDepot());
 713
 714                 /* We have to construct the new vehicle chain to test whether it is valid.
 715                  * Vehicle construction needs random bits, so we have to save the random seeds
 716                  * to prevent desyncs and to replay newgrf callbacks during DC_EXEC */
 717                 SavedRandomSeeds saved_seeds;
 718                 SaveRandomSeeds(&saved_seeds);
 719                 if (free_wagon) {
 720                         cost.AddCost(ReplaceFreeUnit(&v, flags & ~DC_EXEC, &nothing_to_do));
 721                 } else {
 722                         cost.AddCost(ReplaceChain(&v, flags & ~DC_EXEC, wagon_removal, &nothing_to_do));
 723                 }
 724                 RestoreRandomSeeds(saved_seeds);
 725
 726                 if (cost.Succeeded() && (flags & DC_EXEC) != 0) {
 727                         CommandCost ret;
 728                         if (free_wagon) {
 729                                 ret = ReplaceFreeUnit(&v, flags, &nothing_to_do);
 730                         } else {
 731                                 ret = ReplaceChain(&v, flags, wagon_removal, &nothing_to_do);
 732                         }
 733                         assert(ret.Succeeded() && ret.GetCost() == cost.GetCost());
 734                 }
 735
 736                 /* Restart the vehicle */
 737                 if (!was_stopped) cost.AddCost(CmdStartStopVehicle(v, false));
 738         }
 739
 740         if (cost.Succeeded() && nothing_to_do) cost = CommandCost(STR_ERROR_AUTOREPLACE_NOTHING_TO_DO);
 741         return cost;
 742 }
 743
 744 /**
 745  * Change engine renewal parameters
 746  * @param tile unused
 747  * @param flags operation to perform
 748  * @param p1 packed data
 749  *   - bit      0 = replace when engine gets old?
 750  *   - bits 16-31 = engine group
 751  * @param p2 packed data
 752  *   - bits  0-15 = old engine type
 753  *   - bits 16-31 = new engine type
 754  * @param text unused
 755  * @return the cost of this operation or an error
 756  */
 757 CommandCost CmdSetAutoReplace(TileIndex tile, DoCommandFlag flags, uint32 p1, uint32 p2, const char *text)
 758 {
 759         Company *c = Company::GetIfValid(_current_company);
 760         if (c == NULL) return CMD_ERROR;
 761
 762         EngineID old_engine_type = GB(p2, 0, 16);
 763         EngineID new_engine_type = GB(p2, 16, 16);
 764         GroupID id_g = GB(p1, 16, 16);
 765         CommandCost cost;
 766
 767         if (Group::IsValidID(id_g) ? Group::Get(id_g)->owner != _current_company : !IsAllGroupID(id_g) && !IsDefaultGroupID(id_g)) return CMD_ERROR;
 768         if (!Engine::IsValidID(old_engine_type)) return CMD_ERROR;
 769
 770         if (new_engine_type != INVALID_ENGINE) {
 771                 if (!Engine::IsValidID(new_engine_type)) return CMD_ERROR;
 772                 if (!CheckAutoreplaceValidity(old_engine_type, new_engine_type, _current_company)) return CMD_ERROR;
 773
 774                 cost = AddEngineReplacementForCompany(c, old_engine_type, new_engine_type, id_g, HasBit(p1, 0), flags);
 775         } else {
 776                 cost = RemoveEngineReplacementForCompany(c, old_engine_type, id_g, flags);
 777         }
 778
 779         if (flags & DC_EXEC) {
 780                 GroupStatistics::UpdateAutoreplace(_current_company);
 781                 if (IsLocalCompany()) SetWindowDirty(WC_REPLACE_VEHICLE, Engine::Get(old_engine_type)->type);
 782         }
 783         if ((flags & DC_EXEC) && IsLocalCompany()) InvalidateAutoreplaceWindow(old_engine_type, id_g);
 784
 785         return cost;
 786 }
 787