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