autoreplace_cmd.cpp

Go to the documentation of this file.
00001 /* $Id: autoreplace_cmd.cpp 23740 2012-01-03 21:32:51Z rubidium $ */
00002 
00003 /*
00004  * This file is part of OpenTTD.
00005  * 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.
00006  * 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.
00007  * 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/>.
00008  */
00009 
00012 #include "stdafx.h"
00013 #include "company_func.h"
00014 #include "train.h"
00015 #include "command_func.h"
00016 #include "engine_func.h"
00017 #include "vehicle_func.h"
00018 #include "autoreplace_func.h"
00019 #include "autoreplace_gui.h"
00020 #include "articulated_vehicles.h"
00021 #include "core/random_func.hpp"
00022 
00023 #include "table/strings.h"
00024 
00025 extern void ChangeVehicleViewports(VehicleID from_index, VehicleID to_index);
00026 extern void ChangeVehicleNews(VehicleID from_index, VehicleID to_index);
00027 extern void ChangeVehicleViewWindow(VehicleID from_index, VehicleID to_index);
00028 
00036 static bool EnginesHaveCargoInCommon(EngineID engine_a, EngineID engine_b)
00037 {
00038   uint32 available_cargoes_a = GetUnionOfArticulatedRefitMasks(engine_a, true);
00039   uint32 available_cargoes_b = GetUnionOfArticulatedRefitMasks(engine_b, true);
00040   return (available_cargoes_a == 0 || available_cargoes_b == 0 || (available_cargoes_a & available_cargoes_b) != 0);
00041 }
00042 
00050 bool CheckAutoreplaceValidity(EngineID from, EngineID to, CompanyID company)
00051 {
00052   assert(Engine::IsValidID(from) && Engine::IsValidID(to));
00053 
00054   /* we can't replace an engine into itself (that would be autorenew) */
00055   if (from == to) return false;
00056 
00057   const Engine *e_from = Engine::Get(from);
00058   const Engine *e_to = Engine::Get(to);
00059   VehicleType type = e_from->type;
00060 
00061   /* check that the new vehicle type is available to the company and its type is the same as the original one */
00062   if (!IsEngineBuildable(to, type, company)) return false;
00063 
00064   switch (type) {
00065     case VEH_TRAIN: {
00066       /* make sure the railtypes are compatible */
00067       if ((GetRailTypeInfo(e_from->u.rail.railtype)->compatible_railtypes & GetRailTypeInfo(e_to->u.rail.railtype)->compatible_railtypes) == 0) return false;
00068 
00069       /* make sure we do not replace wagons with engines or vise versa */
00070       if ((e_from->u.rail.railveh_type == RAILVEH_WAGON) != (e_to->u.rail.railveh_type == RAILVEH_WAGON)) return false;
00071       break;
00072     }
00073 
00074     case VEH_ROAD:
00075       /* make sure that we do not replace a tram with a normal road vehicles or vise versa */
00076       if (HasBit(e_from->info.misc_flags, EF_ROAD_TRAM) != HasBit(e_to->info.misc_flags, EF_ROAD_TRAM)) return false;
00077       break;
00078 
00079     case VEH_AIRCRAFT:
00080       /* make sure that we do not replace a plane with a helicopter or vise versa */
00081       if ((e_from->u.air.subtype & AIR_CTOL) != (e_to->u.air.subtype & AIR_CTOL)) return false;
00082       break;
00083 
00084     default: break;
00085   }
00086 
00087   /* the engines needs to be able to carry the same cargo */
00088   return EnginesHaveCargoInCommon(from, to);
00089 }
00090 
00095 void CheckCargoCapacity(Vehicle *v)
00096 {
00097   assert(v == NULL || v->First() == v);
00098 
00099   for (Vehicle *src = v; src != NULL; src = src->Next()) {
00100     /* Do we need to more cargo away? */
00101     if (src->cargo.Count() <= src->cargo_cap) continue;
00102 
00103     /* We need to move a particular amount. Try that on the other vehicles. */
00104     uint to_spread = src->cargo.Count() - src->cargo_cap;
00105     for (Vehicle *dest = v; dest != NULL && to_spread != 0; dest = dest->Next()) {
00106       if (dest->cargo.Count() >= dest->cargo_cap || dest->cargo_type != src->cargo_type) continue;
00107 
00108       uint amount = min(to_spread, dest->cargo_cap - dest->cargo.Count());
00109       src->cargo.MoveTo(&dest->cargo, amount, VehicleCargoList::MTA_UNLOAD, NULL);
00110       to_spread -= amount;
00111     }
00112 
00113     /* Any left-overs will be thrown away, but not their feeder share. */
00114     src->cargo.Truncate(src->cargo_cap);
00115   }
00116 }
00117 
00124 static void TransferCargo(Vehicle *old_veh, Vehicle *new_head, bool part_of_chain)
00125 {
00126   assert(!part_of_chain || new_head->IsPrimaryVehicle());
00127   /* Loop through source parts */
00128   for (Vehicle *src = old_veh; src != NULL; src = src->Next()) {
00129     if (!part_of_chain && src->type == VEH_TRAIN && src != old_veh && src != Train::From(old_veh)->other_multiheaded_part && !src->IsArticulatedPart()) {
00130       /* Skip vehicles, which do not belong to old_veh */
00131       src = src->GetLastEnginePart();
00132       continue;
00133     }
00134     if (src->cargo_type >= NUM_CARGO || src->cargo.Count() == 0) continue;
00135 
00136     /* Find free space in the new chain */
00137     for (Vehicle *dest = new_head; dest != NULL && src->cargo.Count() > 0; dest = dest->Next()) {
00138       if (!part_of_chain && dest->type == VEH_TRAIN && dest != new_head && dest != Train::From(new_head)->other_multiheaded_part && !dest->IsArticulatedPart()) {
00139         /* Skip vehicles, which do not belong to new_head */
00140         dest = dest->GetLastEnginePart();
00141         continue;
00142       }
00143       if (dest->cargo_type != src->cargo_type) continue;
00144 
00145       uint amount = min(src->cargo.Count(), dest->cargo_cap - dest->cargo.Count());
00146       if (amount <= 0) continue;
00147 
00148       src->cargo.MoveTo(&dest->cargo, amount, VehicleCargoList::MTA_UNLOAD, NULL);
00149     }
00150   }
00151 
00152   /* Update train weight etc., the old vehicle will be sold anyway */
00153   if (part_of_chain && new_head->type == VEH_TRAIN) Train::From(new_head)->ConsistChanged(true);
00154 }
00155 
00162 static bool VerifyAutoreplaceRefitForOrders(const Vehicle *v, EngineID engine_type)
00163 {
00164 
00165   uint32 union_refit_mask_a = GetUnionOfArticulatedRefitMasks(v->engine_type, false);
00166   uint32 union_refit_mask_b = GetUnionOfArticulatedRefitMasks(engine_type, false);
00167 
00168   const Order *o;
00169   const Vehicle *u = (v->type == VEH_TRAIN) ? v->First() : v;
00170   FOR_VEHICLE_ORDERS(u, o) {
00171     if (!o->IsRefit() || o->IsAutoRefit()) continue;
00172     CargoID cargo_type = o->GetRefitCargo();
00173 
00174     if (!HasBit(union_refit_mask_a, cargo_type)) continue;
00175     if (!HasBit(union_refit_mask_b, cargo_type)) return false;
00176   }
00177 
00178   return true;
00179 }
00180 
00190 static CargoID GetNewCargoTypeForReplace(Vehicle *v, EngineID engine_type, bool part_of_chain)
00191 {
00192   uint32 available_cargo_types, union_mask;
00193   GetArticulatedRefitMasks(engine_type, true, &union_mask, &available_cargo_types);
00194 
00195   if (union_mask == 0) return CT_NO_REFIT; // Don't try to refit an engine with no cargo capacity
00196 
00197   CargoID cargo_type;
00198   if (IsArticulatedVehicleCarryingDifferentCargoes(v, &cargo_type)) return CT_INVALID; // We cannot refit to mixed cargoes in an automated way
00199 
00200   if (cargo_type == CT_INVALID) {
00201     if (v->type != VEH_TRAIN) return CT_NO_REFIT; // If the vehicle does not carry anything at all, every replacement is fine.
00202 
00203     if (!part_of_chain) return CT_NO_REFIT;
00204 
00205     /* the old engine didn't have cargo capacity, but the new one does
00206      * now we will figure out what cargo the train is carrying and refit to fit this */
00207 
00208     for (v = v->First(); v != NULL; v = v->Next()) {
00209       if (v->cargo_cap == 0) continue;
00210       /* Now we found a cargo type being carried on the train and we will see if it is possible to carry to this one */
00211       if (HasBit(available_cargo_types, v->cargo_type)) return v->cargo_type;
00212     }
00213 
00214     return CT_NO_REFIT; // We failed to find a cargo type on the old vehicle and we will not refit the new one
00215   } else {
00216     if (!HasBit(available_cargo_types, cargo_type)) return CT_INVALID; // We can't refit the vehicle to carry the cargo we want
00217 
00218     if (part_of_chain && !VerifyAutoreplaceRefitForOrders(v, engine_type)) return CT_INVALID; // Some refit orders lose their effect
00219 
00220     return cargo_type;
00221   }
00222 }
00223 
00231 static CommandCost GetNewEngineType(const Vehicle *v, const Company *c, EngineID &e)
00232 {
00233   assert(v->type != VEH_TRAIN || !v->IsArticulatedPart());
00234 
00235   e = INVALID_ENGINE;
00236 
00237   if (v->type == VEH_TRAIN && Train::From(v)->IsRearDualheaded()) {
00238     /* we build the rear ends of multiheaded trains with the front ones */
00239     return CommandCost();
00240   }
00241 
00242   e = EngineReplacementForCompany(c, v->engine_type, v->group_id);
00243 
00244   /* Autoreplace, if engine is available */
00245   if (e != INVALID_ENGINE && IsEngineBuildable(e, v->type, _current_company)) {
00246     return CommandCost();
00247   }
00248 
00249   /* Autorenew if needed */
00250   if (v->NeedsAutorenewing(c)) e = v->engine_type;
00251 
00252   /* Nothing to do or all is fine? */
00253   if (e == INVALID_ENGINE || IsEngineBuildable(e, v->type, _current_company)) return CommandCost();
00254 
00255   /* The engine we need is not available. Report error to user */
00256   return CommandCost(STR_ERROR_RAIL_VEHICLE_NOT_AVAILABLE + v->type);
00257 }
00258 
00267 static CommandCost BuildReplacementVehicle(Vehicle *old_veh, Vehicle **new_vehicle, bool part_of_chain)
00268 {
00269   *new_vehicle = NULL;
00270 
00271   /* Shall the vehicle be replaced? */
00272   const Company *c = Company::Get(_current_company);
00273   EngineID e;
00274   CommandCost cost = GetNewEngineType(old_veh, c, e);
00275   if (cost.Failed()) return cost;
00276   if (e == INVALID_ENGINE) return CommandCost(); // neither autoreplace is set, nor autorenew is triggered
00277 
00278   /* Does it need to be refitted */
00279   CargoID refit_cargo = GetNewCargoTypeForReplace(old_veh, e, part_of_chain);
00280   if (refit_cargo == CT_INVALID) return CommandCost(); // incompatible cargoes
00281 
00282   /* Build the new vehicle */
00283   cost = DoCommand(old_veh->tile, e, 0, DC_EXEC | DC_AUTOREPLACE, GetCmdBuildVeh(old_veh));
00284   if (cost.Failed()) return cost;
00285 
00286   Vehicle *new_veh = Vehicle::Get(_new_vehicle_id);
00287   *new_vehicle = new_veh;
00288 
00289   /* Refit the vehicle if needed */
00290   if (refit_cargo != CT_NO_REFIT) {
00291     byte subtype = GetBestFittingSubType(old_veh, new_veh, refit_cargo);
00292 
00293     cost.AddCost(DoCommand(0, new_veh->index, refit_cargo | (subtype << 8), DC_EXEC, GetCmdRefitVeh(new_veh)));
00294     assert(cost.Succeeded()); // This should be ensured by GetNewCargoTypeForReplace()
00295   }
00296 
00297   /* Try to reverse the vehicle, but do not care if it fails as the new type might not be reversible */
00298   if (new_veh->type == VEH_TRAIN && HasBit(Train::From(old_veh)->flags, VRF_REVERSE_DIRECTION)) {
00299     DoCommand(0, new_veh->index, true, DC_EXEC, CMD_REVERSE_TRAIN_DIRECTION);
00300   }
00301 
00302   return cost;
00303 }
00304 
00311 static inline CommandCost CmdStartStopVehicle(const Vehicle *v, bool evaluate_callback)
00312 {
00313   return DoCommand(0, v->index, evaluate_callback ? 1 : 0, DC_EXEC | DC_AUTOREPLACE, CMD_START_STOP_VEHICLE);
00314 }
00315 
00324 static inline CommandCost CmdMoveVehicle(const Vehicle *v, const Vehicle *after, DoCommandFlag flags, bool whole_chain)
00325 {
00326   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);
00327 }
00328 
00335 static CommandCost CopyHeadSpecificThings(Vehicle *old_head, Vehicle *new_head, DoCommandFlag flags)
00336 {
00337   CommandCost cost = CommandCost();
00338 
00339   /* Share orders */
00340   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));
00341 
00342   /* Copy group membership */
00343   if (cost.Succeeded() && old_head != new_head) cost.AddCost(DoCommand(0, old_head->group_id, new_head->index, DC_EXEC, CMD_ADD_VEHICLE_GROUP));
00344 
00345   /* Perform start/stop check whether the new vehicle suits newgrf restrictions etc. */
00346   if (cost.Succeeded()) {
00347     /* Start the vehicle, might be denied by certain things */
00348     assert((new_head->vehstatus & VS_STOPPED) != 0);
00349     cost.AddCost(CmdStartStopVehicle(new_head, true));
00350 
00351     /* Stop the vehicle again, but do not care about evil newgrfs allowing starting but not stopping :p */
00352     if (cost.Succeeded()) cost.AddCost(CmdStartStopVehicle(new_head, false));
00353   }
00354 
00355   /* Last do those things which do never fail (resp. we do not care about), but which are not undo-able */
00356   if (cost.Succeeded() && old_head != new_head && (flags & DC_EXEC) != 0) {
00357     /* Copy vehicle name */
00358     if (old_head->name != NULL) {
00359       DoCommand(0, new_head->index, 0, DC_EXEC | DC_AUTOREPLACE, CMD_RENAME_VEHICLE, old_head->name);
00360     }
00361 
00362     /* Copy other things which cannot be copied by a command and which shall not stay resetted from the build vehicle command */
00363     new_head->CopyVehicleConfigAndStatistics(old_head);
00364 
00365     /* Switch vehicle windows/news to the new vehicle, so they are not closed/deleted when the old vehicle is sold */
00366     ChangeVehicleViewports(old_head->index, new_head->index);
00367     ChangeVehicleViewWindow(old_head->index, new_head->index);
00368     ChangeVehicleNews(old_head->index, new_head->index);
00369   }
00370 
00371   return cost;
00372 }
00373 
00381 static CommandCost ReplaceFreeUnit(Vehicle **single_unit, DoCommandFlag flags, bool *nothing_to_do)
00382 {
00383   Train *old_v = Train::From(*single_unit);
00384   assert(!old_v->IsArticulatedPart() && !old_v->IsRearDualheaded());
00385 
00386   CommandCost cost = CommandCost(EXPENSES_NEW_VEHICLES, 0);
00387 
00388   /* Build and refit replacement vehicle */
00389   Vehicle *new_v = NULL;
00390   cost.AddCost(BuildReplacementVehicle(old_v, &new_v, false));
00391 
00392   /* Was a new vehicle constructed? */
00393   if (cost.Succeeded() && new_v != NULL) {
00394     *nothing_to_do = false;
00395 
00396     if ((flags & DC_EXEC) != 0) {
00397       /* Move the new vehicle behind the old */
00398       CmdMoveVehicle(new_v, old_v, DC_EXEC, false);
00399 
00400       /* Take over cargo
00401        * Note: We do only transfer cargo from the old to the new vehicle.
00402        *       I.e. we do not transfer remaining cargo to other vehicles.
00403        *       Else you would also need to consider moving cargo to other free chains,
00404        *       or doing the same in ReplaceChain(), which would be quite troublesome.
00405        */
00406       TransferCargo(old_v, new_v, false);
00407 
00408       *single_unit = new_v;
00409     }
00410 
00411     /* Sell the old vehicle */
00412     cost.AddCost(DoCommand(0, old_v->index, 0, flags, GetCmdSellVeh(old_v)));
00413 
00414     /* If we are not in DC_EXEC undo everything */
00415     if ((flags & DC_EXEC) == 0) {
00416       DoCommand(0, new_v->index, 0, DC_EXEC, GetCmdSellVeh(new_v));
00417     }
00418   }
00419 
00420   return cost;
00421 }
00422 
00431 static CommandCost ReplaceChain(Vehicle **chain, DoCommandFlag flags, bool wagon_removal, bool *nothing_to_do)
00432 {
00433   Vehicle *old_head = *chain;
00434   assert(old_head->IsPrimaryVehicle());
00435 
00436   CommandCost cost = CommandCost(EXPENSES_NEW_VEHICLES, 0);
00437 
00438   if (old_head->type == VEH_TRAIN) {
00439     /* Store the length of the old vehicle chain, rounded up to whole tiles */
00440     uint16 old_total_length = CeilDiv(Train::From(old_head)->gcache.cached_total_length, TILE_SIZE) * TILE_SIZE;
00441 
00442     int num_units = 0; 
00443     for (Train *w = Train::From(old_head); w != NULL; w = w->GetNextUnit()) num_units++;
00444 
00445     Train **old_vehs = CallocT<Train *>(num_units); 
00446     Train **new_vehs = CallocT<Train *>(num_units); 
00447     Money *new_costs = MallocT<Money>(num_units);   
00448 
00449     /* Collect vehicles and build replacements
00450      * Note: The replacement vehicles can only successfully build as long as the old vehicles are still in their chain */
00451     int i;
00452     Train *w;
00453     for (w = Train::From(old_head), i = 0; w != NULL; w = w->GetNextUnit(), i++) {
00454       assert(i < num_units);
00455       old_vehs[i] = w;
00456 
00457       CommandCost ret = BuildReplacementVehicle(old_vehs[i], (Vehicle**)&new_vehs[i], true);
00458       cost.AddCost(ret);
00459       if (cost.Failed()) break;
00460 
00461       new_costs[i] = ret.GetCost();
00462       if (new_vehs[i] != NULL) *nothing_to_do = false;
00463     }
00464     Train *new_head = (new_vehs[0] != NULL ? new_vehs[0] : old_vehs[0]);
00465 
00466     /* Note: When autoreplace has already failed here, old_vehs[] is not completely initialized. But it is also not needed. */
00467     if (cost.Succeeded()) {
00468       /* Separate the head, so we can start constructing the new chain */
00469       Train *second = Train::From(old_head)->GetNextUnit();
00470       if (second != NULL) cost.AddCost(CmdMoveVehicle(second, NULL, DC_EXEC | DC_AUTOREPLACE, true));
00471 
00472       assert(Train::From(new_head)->GetNextUnit() == NULL);
00473 
00474       /* Append engines to the new chain
00475        * We do this from back to front, so that the head of the temporary vehicle chain does not change all the time.
00476        * That way we also have less trouble when exceeding the unitnumber limit.
00477        * OTOH the vehicle attach callback is more expensive this way :s */
00478       Train *last_engine = NULL; 
00479       if (cost.Succeeded()) {
00480         for (int i = num_units - 1; i > 0; i--) {
00481           Train *append = (new_vehs[i] != NULL ? new_vehs[i] : old_vehs[i]);
00482 
00483           if (RailVehInfo(append->engine_type)->railveh_type == RAILVEH_WAGON) continue;
00484 
00485           if (new_vehs[i] != NULL) {
00486             /* Move the old engine to a separate row with DC_AUTOREPLACE. Else
00487              * moving the wagon in front may fail later due to unitnumber limit.
00488              * (We have to attach wagons without DC_AUTOREPLACE.) */
00489             CmdMoveVehicle(old_vehs[i], NULL, DC_EXEC | DC_AUTOREPLACE, false);
00490           }
00491 
00492           if (last_engine == NULL) last_engine = append;
00493           cost.AddCost(CmdMoveVehicle(append, new_head, DC_EXEC, false));
00494           if (cost.Failed()) break;
00495         }
00496         if (last_engine == NULL) last_engine = new_head;
00497       }
00498 
00499       /* When wagon removal is enabled and the new engines without any wagons are already longer than the old, we have to fail */
00500       if (cost.Succeeded() && wagon_removal && new_head->gcache.cached_total_length > old_total_length) cost = CommandCost(STR_ERROR_TRAIN_TOO_LONG_AFTER_REPLACEMENT);
00501 
00502       /* Append/insert wagons into the new vehicle chain
00503        * 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.
00504        */
00505       if (cost.Succeeded()) {
00506         for (int i = num_units - 1; i > 0; i--) {
00507           assert(last_engine != NULL);
00508           Vehicle *append = (new_vehs[i] != NULL ? new_vehs[i] : old_vehs[i]);
00509 
00510           if (RailVehInfo(append->engine_type)->railveh_type == RAILVEH_WAGON) {
00511             /* Insert wagon after 'last_engine' */
00512             CommandCost res = CmdMoveVehicle(append, last_engine, DC_EXEC, false);
00513 
00514             /* When we allow removal of wagons, either the move failing due
00515              * to the train becoming too long, or the train becoming longer
00516              * would move the vehicle to the empty vehicle chain. */
00517             if (wagon_removal && (res.Failed() ? res.GetErrorMessage() == STR_ERROR_TRAIN_TOO_LONG : new_head->gcache.cached_total_length > old_total_length)) {
00518               CmdMoveVehicle(append, NULL, DC_EXEC | DC_AUTOREPLACE, false);
00519               break;
00520             }
00521 
00522             cost.AddCost(res);
00523             if (cost.Failed()) break;
00524           } else {
00525             /* We have reached 'last_engine', continue with the next engine towards the front */
00526             assert(append == last_engine);
00527             last_engine = last_engine->GetPrevUnit();
00528           }
00529         }
00530       }
00531 
00532       /* Sell superfluous new vehicles that could not be inserted. */
00533       if (cost.Succeeded() && wagon_removal) {
00534         assert(new_head->gcache.cached_total_length <= _settings_game.vehicle.max_train_length * TILE_SIZE);
00535         for (int i = 1; i < num_units; i++) {
00536           Vehicle *wagon = new_vehs[i];
00537           if (wagon == NULL) continue;
00538           if (wagon->First() == new_head) break;
00539 
00540           assert(RailVehInfo(wagon->engine_type)->railveh_type == RAILVEH_WAGON);
00541 
00542           /* Sell wagon */
00543           CommandCost ret = DoCommand(0, wagon->index, 0, DC_EXEC, GetCmdSellVeh(wagon));
00544           assert(ret.Succeeded());
00545           new_vehs[i] = NULL;
00546 
00547           /* Revert the money subtraction when the vehicle was built.
00548            * This value is different from the sell value, esp. because of refitting */
00549           cost.AddCost(-new_costs[i]);
00550         }
00551       }
00552 
00553       /* The new vehicle chain is constructed, now take over orders and everything... */
00554       if (cost.Succeeded()) cost.AddCost(CopyHeadSpecificThings(old_head, new_head, flags));
00555 
00556       if (cost.Succeeded()) {
00557         /* Success ! */
00558         if ((flags & DC_EXEC) != 0 && new_head != old_head) {
00559           *chain = new_head;
00560         }
00561 
00562         /* Transfer cargo of old vehicles and sell them */
00563         for (int i = 0; i < num_units; i++) {
00564           Vehicle *w = old_vehs[i];
00565           /* Is the vehicle again part of the new chain?
00566            * Note: We cannot test 'new_vehs[i] != NULL' as wagon removal might cause to remove both */
00567           if (w->First() == new_head) continue;
00568 
00569           if ((flags & DC_EXEC) != 0) TransferCargo(w, new_head, true);
00570 
00571           /* Sell the vehicle.
00572            * Note: This might temporarly construct new trains, so use DC_AUTOREPLACE to prevent
00573            *       it from failing due to engine limits. */
00574           cost.AddCost(DoCommand(0, w->index, 0, flags | DC_AUTOREPLACE, GetCmdSellVeh(w)));
00575           if ((flags & DC_EXEC) != 0) {
00576             old_vehs[i] = NULL;
00577             if (i == 0) old_head = NULL;
00578           }
00579         }
00580 
00581         if ((flags & DC_EXEC) != 0) CheckCargoCapacity(new_head);
00582       }
00583 
00584       /* If we are not in DC_EXEC undo everything, i.e. rearrange old vehicles.
00585        * We do this from back to front, so that the head of the temporary vehicle chain does not change all the time.
00586        * Note: The vehicle attach callback is disabled here :) */
00587       if ((flags & DC_EXEC) == 0) {
00588         /* Separate the head, so we can reattach the old vehicles */
00589         Train *second = Train::From(old_head)->GetNextUnit();
00590         if (second != NULL) CmdMoveVehicle(second, NULL, DC_EXEC | DC_AUTOREPLACE, true);
00591 
00592         assert(Train::From(old_head)->GetNextUnit() == NULL);
00593 
00594         for (int i = num_units - 1; i > 0; i--) {
00595           CommandCost ret = CmdMoveVehicle(old_vehs[i], old_head, DC_EXEC | DC_AUTOREPLACE, false);
00596           assert(ret.Succeeded());
00597         }
00598       }
00599     }
00600 
00601     /* Finally undo buying of new vehicles */
00602     if ((flags & DC_EXEC) == 0) {
00603       for (int i = num_units - 1; i >= 0; i--) {
00604         if (new_vehs[i] != NULL) {
00605           DoCommand(0, new_vehs[i]->index, 0, DC_EXEC, GetCmdSellVeh(new_vehs[i]));
00606           new_vehs[i] = NULL;
00607         }
00608       }
00609     }
00610 
00611     free(old_vehs);
00612     free(new_vehs);
00613     free(new_costs);
00614   } else {
00615     /* Build and refit replacement vehicle */
00616     Vehicle *new_head = NULL;
00617     cost.AddCost(BuildReplacementVehicle(old_head, &new_head, true));
00618 
00619     /* Was a new vehicle constructed? */
00620     if (cost.Succeeded() && new_head != NULL) {
00621       *nothing_to_do = false;
00622 
00623       /* The new vehicle is constructed, now take over orders and everything... */
00624       cost.AddCost(CopyHeadSpecificThings(old_head, new_head, flags));
00625 
00626       if (cost.Succeeded()) {
00627         /* The new vehicle is constructed, now take over cargo */
00628         if ((flags & DC_EXEC) != 0) {
00629           TransferCargo(old_head, new_head, true);
00630           *chain = new_head;
00631         }
00632 
00633         /* Sell the old vehicle */
00634         cost.AddCost(DoCommand(0, old_head->index, 0, flags, GetCmdSellVeh(old_head)));
00635       }
00636 
00637       /* If we are not in DC_EXEC undo everything */
00638       if ((flags & DC_EXEC) == 0) {
00639         DoCommand(0, new_head->index, 0, DC_EXEC, GetCmdSellVeh(new_head));
00640       }
00641     }
00642   }
00643 
00644   return cost;
00645 }
00646 
00657 CommandCost CmdAutoreplaceVehicle(TileIndex tile, DoCommandFlag flags, uint32 p1, uint32 p2, const char *text)
00658 {
00659   Vehicle *v = Vehicle::GetIfValid(p1);
00660   if (v == NULL) return CMD_ERROR;
00661 
00662   CommandCost ret = CheckOwnership(v->owner);
00663   if (ret.Failed()) return ret;
00664 
00665   if (!v->IsInDepot()) return CMD_ERROR;
00666   if (v->vehstatus & VS_CRASHED) return CMD_ERROR;
00667 
00668   bool free_wagon = false;
00669   if (v->type == VEH_TRAIN) {
00670     Train *t = Train::From(v);
00671     if (t->IsArticulatedPart() || t->IsRearDualheaded()) return CMD_ERROR;
00672     free_wagon = !t->IsFrontEngine();
00673     if (free_wagon && t->First()->IsFrontEngine()) return CMD_ERROR;
00674   } else {
00675     if (!v->IsPrimaryVehicle()) return CMD_ERROR;
00676   }
00677 
00678   const Company *c = Company::Get(_current_company);
00679   bool wagon_removal = c->settings.renew_keep_length;
00680 
00681   /* Test whether any replacement is set, before issuing a whole lot of commands that would end in nothing changed */
00682   Vehicle *w = v;
00683   bool any_replacements = false;
00684   while (w != NULL) {
00685     EngineID e;
00686     CommandCost cost = GetNewEngineType(w, c, e);
00687     if (cost.Failed()) return cost;
00688     any_replacements |= (e != INVALID_ENGINE);
00689     w = (!free_wagon && w->type == VEH_TRAIN ? Train::From(w)->GetNextUnit() : NULL);
00690   }
00691 
00692   CommandCost cost = CommandCost(EXPENSES_NEW_VEHICLES, 0);
00693   bool nothing_to_do = true;
00694 
00695   if (any_replacements) {
00696     bool was_stopped = free_wagon || ((v->vehstatus & VS_STOPPED) != 0);
00697 
00698     /* Stop the vehicle */
00699     if (!was_stopped) cost.AddCost(CmdStartStopVehicle(v, true));
00700     if (cost.Failed()) return cost;
00701 
00702     assert(v->IsStoppedInDepot());
00703 
00704     /* We have to construct the new vehicle chain to test whether it is valid.
00705      * Vehicle construction needs random bits, so we have to save the random seeds
00706      * to prevent desyncs and to replay newgrf callbacks during DC_EXEC */
00707     SavedRandomSeeds saved_seeds;
00708     SaveRandomSeeds(&saved_seeds);
00709     if (free_wagon) {
00710       cost.AddCost(ReplaceFreeUnit(&v, flags & ~DC_EXEC, &nothing_to_do));
00711     } else {
00712       cost.AddCost(ReplaceChain(&v, flags & ~DC_EXEC, wagon_removal, &nothing_to_do));
00713     }
00714     RestoreRandomSeeds(saved_seeds);
00715 
00716     if (cost.Succeeded() && (flags & DC_EXEC) != 0) {
00717       CommandCost ret;
00718       if (free_wagon) {
00719         ret = ReplaceFreeUnit(&v, flags, &nothing_to_do);
00720       } else {
00721         ret = ReplaceChain(&v, flags, wagon_removal, &nothing_to_do);
00722       }
00723       assert(ret.Succeeded() && ret.GetCost() == cost.GetCost());
00724     }
00725 
00726     /* Restart the vehicle */
00727     if (!was_stopped) cost.AddCost(CmdStartStopVehicle(v, false));
00728   }
00729 
00730   if (cost.Succeeded() && nothing_to_do) cost = CommandCost(STR_ERROR_AUTOREPLACE_NOTHING_TO_DO);
00731   return cost;
00732 }
00733 
00746 CommandCost CmdSetAutoReplace(TileIndex tile, DoCommandFlag flags, uint32 p1, uint32 p2, const char *text)
00747 {
00748   Company *c = Company::GetIfValid(_current_company);
00749   if (c == NULL) return CMD_ERROR;
00750 
00751   EngineID old_engine_type = GB(p2, 0, 16);
00752   EngineID new_engine_type = GB(p2, 16, 16);
00753   GroupID id_g = GB(p1, 16, 16);
00754   CommandCost cost;
00755 
00756   if (Group::IsValidID(id_g) ? Group::Get(id_g)->owner != _current_company : !IsAllGroupID(id_g) && !IsDefaultGroupID(id_g)) return CMD_ERROR;
00757   if (!Engine::IsValidID(old_engine_type)) return CMD_ERROR;
00758 
00759   if (new_engine_type != INVALID_ENGINE) {
00760     if (!Engine::IsValidID(new_engine_type)) return CMD_ERROR;
00761     if (!CheckAutoreplaceValidity(old_engine_type, new_engine_type, _current_company)) return CMD_ERROR;
00762 
00763     cost = AddEngineReplacementForCompany(c, old_engine_type, new_engine_type, id_g, flags);
00764   } else {
00765     cost = RemoveEngineReplacementForCompany(c, old_engine_type, id_g, flags);
00766   }
00767 
00768   if (flags & DC_EXEC) GroupStatistics::UpdateAutoreplace(_current_company);
00769   if ((flags & DC_EXEC) && IsLocalCompany()) InvalidateAutoreplaceWindow(old_engine_type, id_g);
00770 
00771   return cost;
00772 }
00773