00001
00002
00003
00004
00005
00006
00007
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 "group.h"
00021 #include "articulated_vehicles.h"
00022 #include "core/random_func.hpp"
00023
00024 #include "table/strings.h"
00025
00026 extern void ChangeVehicleViewports(VehicleID from_index, VehicleID to_index);
00027 extern void ChangeVehicleNews(VehicleID from_index, VehicleID to_index);
00028 extern void ChangeVehicleViewWindow(VehicleID from_index, VehicleID to_index);
00029
00037 static bool EnginesHaveCargoInCommon(EngineID engine_a, EngineID engine_b)
00038 {
00039 uint32 available_cargos_a = GetUnionOfArticulatedRefitMasks(engine_a, true);
00040 uint32 available_cargos_b = GetUnionOfArticulatedRefitMasks(engine_b, true);
00041 return (available_cargos_a == 0 || available_cargos_b == 0 || (available_cargos_a & available_cargos_b) != 0);
00042 }
00043
00051 bool CheckAutoreplaceValidity(EngineID from, EngineID to, CompanyID company)
00052 {
00053 assert(Engine::IsValidID(from) && Engine::IsValidID(to));
00054
00055
00056 if (from == to) return false;
00057
00058 const Engine *e_from = Engine::Get(from);
00059 const Engine *e_to = Engine::Get(to);
00060 VehicleType type = e_from->type;
00061
00062
00063 if (!IsEngineBuildable(to, type, company)) return false;
00064
00065 switch (type) {
00066 case VEH_TRAIN: {
00067
00068 if ((GetRailTypeInfo(e_from->u.rail.railtype)->compatible_railtypes & GetRailTypeInfo(e_to->u.rail.railtype)->compatible_railtypes) == 0) return false;
00069
00070
00071 if ((e_from->u.rail.railveh_type == RAILVEH_WAGON) != (e_to->u.rail.railveh_type == RAILVEH_WAGON)) return false;
00072 break;
00073 }
00074
00075 case VEH_ROAD:
00076
00077 if (HasBit(e_from->info.misc_flags, EF_ROAD_TRAM) != HasBit(e_to->info.misc_flags, EF_ROAD_TRAM)) return false;
00078 break;
00079
00080 case VEH_AIRCRAFT:
00081
00082 if ((e_from->u.air.subtype & AIR_CTOL) != (e_to->u.air.subtype & AIR_CTOL)) return false;
00083 break;
00084
00085 default: break;
00086 }
00087
00088
00089 return EnginesHaveCargoInCommon(from, to);
00090 }
00091
00098 static void TransferCargo(Vehicle *old_veh, Vehicle *new_head, bool part_of_chain)
00099 {
00100 assert(!part_of_chain || new_head->IsPrimaryVehicle());
00101
00102 for (Vehicle *src = old_veh; src != NULL; src = src->Next()) {
00103 if (!part_of_chain && src->type == VEH_TRAIN && src != old_veh && src != Train::From(old_veh)->other_multiheaded_part && !src->IsArticulatedPart()) {
00104
00105 src = src->GetLastEnginePart();
00106 continue;
00107 }
00108 if (src->cargo_type >= NUM_CARGO || src->cargo.Count() == 0) continue;
00109
00110
00111 for (Vehicle *dest = new_head; dest != NULL && src->cargo.Count() > 0; dest = dest->Next()) {
00112 if (!part_of_chain && dest->type == VEH_TRAIN && dest != new_head && dest != Train::From(new_head)->other_multiheaded_part && !dest->IsArticulatedPart()) {
00113
00114 dest = dest->GetLastEnginePart();
00115 continue;
00116 }
00117 if (dest->cargo_type != src->cargo_type) continue;
00118
00119 uint amount = min(src->cargo.Count(), dest->cargo_cap - dest->cargo.Count());
00120 if (amount <= 0) continue;
00121
00122 src->cargo.MoveTo(&dest->cargo, amount, VehicleCargoList::MTA_UNLOAD, NULL);
00123 }
00124 }
00125
00126
00127 if (part_of_chain && new_head->type == VEH_TRAIN) Train::From(new_head)->ConsistChanged(true);
00128 }
00129
00136 static bool VerifyAutoreplaceRefitForOrders(const Vehicle *v, EngineID engine_type)
00137 {
00138
00139 uint32 union_refit_mask_a = GetUnionOfArticulatedRefitMasks(v->engine_type, false);
00140 uint32 union_refit_mask_b = GetUnionOfArticulatedRefitMasks(engine_type, false);
00141
00142 const Order *o;
00143 const Vehicle *u = (v->type == VEH_TRAIN) ? v->First() : v;
00144 FOR_VEHICLE_ORDERS(u, o) {
00145 if (!o->IsRefit()) continue;
00146 CargoID cargo_type = o->GetRefitCargo();
00147
00148 if (!HasBit(union_refit_mask_a, cargo_type)) continue;
00149 if (!HasBit(union_refit_mask_b, cargo_type)) return false;
00150 }
00151
00152 return true;
00153 }
00154
00164 static CargoID GetNewCargoTypeForReplace(Vehicle *v, EngineID engine_type, bool part_of_chain)
00165 {
00166 uint32 available_cargo_types, union_mask;
00167 GetArticulatedRefitMasks(engine_type, true, &union_mask, &available_cargo_types);
00168
00169 if (union_mask == 0) return CT_NO_REFIT;
00170
00171 CargoID cargo_type;
00172 if (IsArticulatedVehicleCarryingDifferentCargos(v, &cargo_type)) return CT_INVALID;
00173
00174 if (cargo_type == CT_INVALID) {
00175 if (v->type != VEH_TRAIN) return CT_NO_REFIT;
00176
00177 if (!part_of_chain) return CT_NO_REFIT;
00178
00179
00180
00181
00182 for (v = v->First(); v != NULL; v = v->Next()) {
00183 if (v->cargo_cap == 0) continue;
00184
00185 if (HasBit(available_cargo_types, v->cargo_type)) {
00186
00187 CargoArray default_capacity = GetCapacityOfArticulatedParts(engine_type);
00188 for (CargoID cid = 0; cid < NUM_CARGO; cid++) {
00189 if (cid != v->cargo_type && default_capacity[cid] > 0) return v->cargo_type;
00190 }
00191
00192 return CT_NO_REFIT;
00193 }
00194 }
00195
00196 return CT_NO_REFIT;
00197 } else {
00198 if (!HasBit(available_cargo_types, cargo_type)) return CT_INVALID;
00199
00200 if (part_of_chain && !VerifyAutoreplaceRefitForOrders(v, engine_type)) return CT_INVALID;
00201
00202
00203 CargoArray default_capacity = GetCapacityOfArticulatedParts(engine_type);
00204 for (CargoID cid = 0; cid < NUM_CARGO; cid++) {
00205 if (cid != cargo_type && default_capacity[cid] > 0) return cargo_type;
00206 }
00207
00208 return CT_NO_REFIT;
00209 }
00210 }
00211
00219 static CommandCost GetNewEngineType(const Vehicle *v, const Company *c, EngineID &e)
00220 {
00221 assert(v->type != VEH_TRAIN || !v->IsArticulatedPart());
00222
00223 e = INVALID_ENGINE;
00224
00225 if (v->type == VEH_TRAIN && Train::From(v)->IsRearDualheaded()) {
00226
00227 return CommandCost();
00228 }
00229
00230 e = EngineReplacementForCompany(c, v->engine_type, v->group_id);
00231
00232
00233 if (e != INVALID_ENGINE && IsEngineBuildable(e, v->type, _current_company)) {
00234 return CommandCost();
00235 }
00236
00237
00238 if (v->NeedsAutorenewing(c)) e = v->engine_type;
00239
00240
00241 if (e == INVALID_ENGINE || IsEngineBuildable(e, v->type, _current_company)) return CommandCost();
00242
00243
00244 return CommandCost(STR_ERROR_RAIL_VEHICLE_NOT_AVAILABLE + v->type);
00245 }
00246
00255 static CommandCost BuildReplacementVehicle(Vehicle *old_veh, Vehicle **new_vehicle, bool part_of_chain)
00256 {
00257 *new_vehicle = NULL;
00258
00259
00260 const Company *c = Company::Get(_current_company);
00261 EngineID e;
00262 CommandCost cost = GetNewEngineType(old_veh, c, e);
00263 if (cost.Failed()) return cost;
00264 if (e == INVALID_ENGINE) return CommandCost();
00265
00266
00267 CargoID refit_cargo = GetNewCargoTypeForReplace(old_veh, e, part_of_chain);
00268 if (refit_cargo == CT_INVALID) return CommandCost();
00269
00270
00271 cost = DoCommand(old_veh->tile, e, 0, DC_EXEC | DC_AUTOREPLACE, GetCmdBuildVeh(old_veh));
00272 if (cost.Failed()) return cost;
00273
00274 Vehicle *new_veh = Vehicle::Get(_new_vehicle_id);
00275 *new_vehicle = new_veh;
00276
00277
00278 byte subtype = GetBestFittingSubType(old_veh, new_veh);
00279
00280
00281 if (subtype != 0 && refit_cargo == CT_NO_REFIT) refit_cargo = old_veh->cargo_type;
00282
00283 if (refit_cargo != CT_NO_REFIT) {
00284 cost.AddCost(DoCommand(0, new_veh->index, refit_cargo | (subtype << 8), DC_EXEC, GetCmdRefitVeh(new_veh)));
00285 assert(cost.Succeeded());
00286 }
00287
00288
00289 if (new_veh->type == VEH_TRAIN && HasBit(Train::From(old_veh)->flags, VRF_REVERSE_DIRECTION)) {
00290 DoCommand(0, new_veh->index, true, DC_EXEC, CMD_REVERSE_TRAIN_DIRECTION);
00291 }
00292
00293 return cost;
00294 }
00295
00302 static inline CommandCost CmdStartStopVehicle(const Vehicle *v, bool evaluate_callback)
00303 {
00304 return DoCommand(0, v->index, evaluate_callback ? 1 : 0, DC_EXEC | DC_AUTOREPLACE, CMD_START_STOP_VEHICLE);
00305 }
00306
00315 static inline CommandCost CmdMoveVehicle(const Vehicle *v, const Vehicle *after, DoCommandFlag flags, bool whole_chain)
00316 {
00317 return DoCommand(0, v->index | (whole_chain ? 1 : 0) << 20, after != NULL ? after->index : INVALID_VEHICLE, flags, CMD_MOVE_RAIL_VEHICLE);
00318 }
00319
00326 static CommandCost CopyHeadSpecificThings(Vehicle *old_head, Vehicle *new_head, DoCommandFlag flags)
00327 {
00328 CommandCost cost = CommandCost();
00329
00330
00331 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));
00332
00333
00334 if (cost.Succeeded() && old_head != new_head) cost.AddCost(DoCommand(0, old_head->group_id, new_head->index, DC_EXEC, CMD_ADD_VEHICLE_GROUP));
00335
00336
00337 if (cost.Succeeded()) {
00338
00339 assert((new_head->vehstatus & VS_STOPPED) != 0);
00340 cost.AddCost(CmdStartStopVehicle(new_head, true));
00341
00342
00343 if (cost.Succeeded()) cost.AddCost(CmdStartStopVehicle(new_head, false));
00344 }
00345
00346
00347 if (cost.Succeeded() && old_head != new_head && (flags & DC_EXEC) != 0) {
00348
00349 if (old_head->name != NULL) {
00350 DoCommand(0, new_head->index, 0, DC_EXEC | DC_AUTOREPLACE, CMD_RENAME_VEHICLE, old_head->name);
00351 }
00352
00353
00354 new_head->CopyVehicleConfigAndStatistics(old_head);
00355
00356
00357 ChangeVehicleViewports(old_head->index, new_head->index);
00358 ChangeVehicleViewWindow(old_head->index, new_head->index);
00359 ChangeVehicleNews(old_head->index, new_head->index);
00360 }
00361
00362 return cost;
00363 }
00364
00372 static CommandCost ReplaceFreeUnit(Vehicle **single_unit, DoCommandFlag flags, bool *nothing_to_do)
00373 {
00374 Train *old_v = Train::From(*single_unit);
00375 assert(!old_v->IsArticulatedPart() && !old_v->IsRearDualheaded());
00376
00377 CommandCost cost = CommandCost(EXPENSES_NEW_VEHICLES, 0);
00378
00379
00380 Vehicle *new_v = NULL;
00381 cost.AddCost(BuildReplacementVehicle(old_v, &new_v, false));
00382
00383
00384 if (cost.Succeeded() && new_v != NULL) {
00385 *nothing_to_do = false;
00386
00387 if ((flags & DC_EXEC) != 0) {
00388
00389 CmdMoveVehicle(new_v, old_v, DC_EXEC, false);
00390
00391
00392
00393
00394
00395
00396
00397 TransferCargo(old_v, new_v, false);
00398
00399 *single_unit = new_v;
00400 }
00401
00402
00403 cost.AddCost(DoCommand(0, old_v->index, 0, flags, GetCmdSellVeh(old_v)));
00404
00405
00406 if ((flags & DC_EXEC) == 0) {
00407 DoCommand(0, new_v->index, 0, DC_EXEC, GetCmdSellVeh(new_v));
00408 }
00409 }
00410
00411 return cost;
00412 }
00413
00422 static CommandCost ReplaceChain(Vehicle **chain, DoCommandFlag flags, bool wagon_removal, bool *nothing_to_do)
00423 {
00424 Vehicle *old_head = *chain;
00425 assert(old_head->IsPrimaryVehicle());
00426
00427 CommandCost cost = CommandCost(EXPENSES_NEW_VEHICLES, 0);
00428
00429 if (old_head->type == VEH_TRAIN) {
00430
00431 uint16 old_total_length = CeilDiv(Train::From(old_head)->gcache.cached_total_length, TILE_SIZE) * TILE_SIZE;
00432
00433 int num_units = 0;
00434 for (Train *w = Train::From(old_head); w != NULL; w = w->GetNextUnit()) num_units++;
00435
00436 Train **old_vehs = CallocT<Train *>(num_units);
00437 Train **new_vehs = CallocT<Train *>(num_units);
00438 Money *new_costs = MallocT<Money>(num_units);
00439
00440
00441
00442 int i;
00443 Train *w;
00444 for (w = Train::From(old_head), i = 0; w != NULL; w = w->GetNextUnit(), i++) {
00445 assert(i < num_units);
00446 old_vehs[i] = w;
00447
00448 CommandCost ret = BuildReplacementVehicle(old_vehs[i], (Vehicle**)&new_vehs[i], true);
00449 cost.AddCost(ret);
00450 if (cost.Failed()) break;
00451
00452 new_costs[i] = ret.GetCost();
00453 if (new_vehs[i] != NULL) *nothing_to_do = false;
00454 }
00455 Train *new_head = (new_vehs[0] != NULL ? new_vehs[0] : old_vehs[0]);
00456
00457
00458 if (cost.Succeeded()) {
00459
00460 Train *second = Train::From(old_head)->GetNextUnit();
00461 if (second != NULL) cost.AddCost(CmdMoveVehicle(second, NULL, DC_EXEC | DC_AUTOREPLACE, true));
00462
00463 assert(Train::From(new_head)->GetNextUnit() == NULL);
00464
00465
00466
00467
00468
00469 Train *last_engine = NULL;
00470 if (cost.Succeeded()) {
00471 for (int i = num_units - 1; i > 0; i--) {
00472 Train *append = (new_vehs[i] != NULL ? new_vehs[i] : old_vehs[i]);
00473
00474 if (RailVehInfo(append->engine_type)->railveh_type == RAILVEH_WAGON) continue;
00475
00476 if (new_vehs[i] != NULL) {
00477
00478
00479
00480 CmdMoveVehicle(old_vehs[i], NULL, DC_EXEC | DC_AUTOREPLACE, false);
00481 }
00482
00483 if (last_engine == NULL) last_engine = append;
00484 cost.AddCost(CmdMoveVehicle(append, new_head, DC_EXEC, false));
00485 if (cost.Failed()) break;
00486 }
00487 if (last_engine == NULL) last_engine = new_head;
00488 }
00489
00490
00491 if (cost.Succeeded() && wagon_removal && new_head->gcache.cached_total_length > old_total_length) cost = CommandCost(STR_ERROR_TRAIN_TOO_LONG_AFTER_REPLACEMENT);
00492
00493
00494
00495
00496 if (cost.Succeeded()) {
00497 for (int i = num_units - 1; i > 0; i--) {
00498 assert(last_engine != NULL);
00499 Vehicle *append = (new_vehs[i] != NULL ? new_vehs[i] : old_vehs[i]);
00500
00501 if (RailVehInfo(append->engine_type)->railveh_type == RAILVEH_WAGON) {
00502
00503 CommandCost res = CmdMoveVehicle(append, last_engine, DC_EXEC, false);
00504
00505
00506
00507
00508 if (wagon_removal && (res.Failed() ? res.GetErrorMessage() == STR_ERROR_TRAIN_TOO_LONG : new_head->gcache.cached_total_length > old_total_length)) {
00509 CmdMoveVehicle(append, NULL, DC_EXEC | DC_AUTOREPLACE, false);
00510 break;
00511 }
00512
00513 cost.AddCost(res);
00514 if (cost.Failed()) break;
00515 } else {
00516
00517 assert(append == last_engine);
00518 last_engine = last_engine->GetPrevUnit();
00519 }
00520 }
00521 }
00522
00523
00524 if (cost.Succeeded() && wagon_removal) {
00525 assert(new_head->gcache.cached_total_length <= _settings_game.vehicle.max_train_length * TILE_SIZE);
00526 for (int i = 1; i < num_units; i++) {
00527 Vehicle *wagon = new_vehs[i];
00528 if (wagon == NULL) continue;
00529 if (wagon->First() == new_head) break;
00530
00531 assert(RailVehInfo(wagon->engine_type)->railveh_type == RAILVEH_WAGON);
00532
00533
00534 CommandCost ret = DoCommand(0, wagon->index, 0, DC_EXEC, GetCmdSellVeh(wagon));
00535 assert(ret.Succeeded());
00536 new_vehs[i] = NULL;
00537
00538
00539
00540 cost.AddCost(-new_costs[i]);
00541 }
00542 }
00543
00544
00545 if (cost.Succeeded()) cost.AddCost(CopyHeadSpecificThings(old_head, new_head, flags));
00546
00547 if (cost.Succeeded()) {
00548
00549 if ((flags & DC_EXEC) != 0 && new_head != old_head) {
00550 *chain = new_head;
00551 }
00552
00553
00554 for (int i = 0; i < num_units; i++) {
00555 Vehicle *w = old_vehs[i];
00556
00557
00558 if (w->First() == new_head) continue;
00559
00560 if ((flags & DC_EXEC) != 0) TransferCargo(w, new_head, true);
00561
00562
00563
00564
00565 cost.AddCost(DoCommand(0, w->index, 0, flags | DC_AUTOREPLACE, GetCmdSellVeh(w)));
00566 if ((flags & DC_EXEC) != 0) {
00567 old_vehs[i] = NULL;
00568 if (i == 0) old_head = NULL;
00569 }
00570 }
00571 }
00572
00573
00574
00575
00576 if ((flags & DC_EXEC) == 0) {
00577
00578 Train *second = Train::From(old_head)->GetNextUnit();
00579 if (second != NULL) CmdMoveVehicle(second, NULL, DC_EXEC | DC_AUTOREPLACE, true);
00580
00581 assert(Train::From(old_head)->GetNextUnit() == NULL);
00582
00583 for (int i = num_units - 1; i > 0; i--) {
00584 CommandCost ret = CmdMoveVehicle(old_vehs[i], old_head, DC_EXEC | DC_AUTOREPLACE, false);
00585 assert(ret.Succeeded());
00586 }
00587 }
00588 }
00589
00590
00591 if ((flags & DC_EXEC) == 0) {
00592 for (int i = num_units - 1; i >= 0; i--) {
00593 if (new_vehs[i] != NULL) {
00594 DoCommand(0, new_vehs[i]->index, 0, DC_EXEC, GetCmdSellVeh(new_vehs[i]));
00595 new_vehs[i] = NULL;
00596 }
00597 }
00598 }
00599
00600 free(old_vehs);
00601 free(new_vehs);
00602 free(new_costs);
00603 } else {
00604
00605 Vehicle *new_head = NULL;
00606 cost.AddCost(BuildReplacementVehicle(old_head, &new_head, true));
00607
00608
00609 if (cost.Succeeded() && new_head != NULL) {
00610 *nothing_to_do = false;
00611
00612
00613 cost.AddCost(CopyHeadSpecificThings(old_head, new_head, flags));
00614
00615 if (cost.Succeeded()) {
00616
00617 if ((flags & DC_EXEC) != 0) {
00618 TransferCargo(old_head, new_head, true);
00619 *chain = new_head;
00620 }
00621
00622
00623 cost.AddCost(DoCommand(0, old_head->index, 0, flags, GetCmdSellVeh(old_head)));
00624 }
00625
00626
00627 if ((flags & DC_EXEC) == 0) {
00628 DoCommand(0, new_head->index, 0, DC_EXEC, GetCmdSellVeh(new_head));
00629 }
00630 }
00631 }
00632
00633 return cost;
00634 }
00635
00646 CommandCost CmdAutoreplaceVehicle(TileIndex tile, DoCommandFlag flags, uint32 p1, uint32 p2, const char *text)
00647 {
00648 Vehicle *v = Vehicle::GetIfValid(p1);
00649 if (v == NULL) return CMD_ERROR;
00650
00651 CommandCost ret = CheckOwnership(v->owner);
00652 if (ret.Failed()) return ret;
00653
00654 if (!v->IsInDepot()) return CMD_ERROR;
00655 if (v->vehstatus & VS_CRASHED) return CMD_ERROR;
00656
00657 bool free_wagon = false;
00658 if (v->type == VEH_TRAIN) {
00659 Train *t = Train::From(v);
00660 if (t->IsArticulatedPart() || t->IsRearDualheaded()) return CMD_ERROR;
00661 free_wagon = !t->IsFrontEngine();
00662 if (free_wagon && t->First()->IsFrontEngine()) return CMD_ERROR;
00663 } else {
00664 if (!v->IsPrimaryVehicle()) return CMD_ERROR;
00665 }
00666
00667 const Company *c = Company::Get(_current_company);
00668 bool wagon_removal = c->settings.renew_keep_length;
00669
00670
00671 Vehicle *w = v;
00672 bool any_replacements = false;
00673 while (w != NULL) {
00674 EngineID e;
00675 CommandCost cost = GetNewEngineType(w, c, e);
00676 if (cost.Failed()) return cost;
00677 any_replacements |= (e != INVALID_ENGINE);
00678 w = (!free_wagon && w->type == VEH_TRAIN ? Train::From(w)->GetNextUnit() : NULL);
00679 }
00680
00681 CommandCost cost = CommandCost(EXPENSES_NEW_VEHICLES, 0);
00682 bool nothing_to_do = true;
00683
00684 if (any_replacements) {
00685 bool was_stopped = free_wagon || ((v->vehstatus & VS_STOPPED) != 0);
00686
00687
00688 if (!was_stopped) cost.AddCost(CmdStartStopVehicle(v, true));
00689 if (cost.Failed()) return cost;
00690
00691 assert(v->IsStoppedInDepot());
00692
00693
00694
00695
00696 SavedRandomSeeds saved_seeds;
00697 SaveRandomSeeds(&saved_seeds);
00698 if (free_wagon) {
00699 cost.AddCost(ReplaceFreeUnit(&v, flags & ~DC_EXEC, ¬hing_to_do));
00700 } else {
00701 cost.AddCost(ReplaceChain(&v, flags & ~DC_EXEC, wagon_removal, ¬hing_to_do));
00702 }
00703 RestoreRandomSeeds(saved_seeds);
00704
00705 if (cost.Succeeded() && (flags & DC_EXEC) != 0) {
00706 CommandCost ret;
00707 if (free_wagon) {
00708 ret = ReplaceFreeUnit(&v, flags, ¬hing_to_do);
00709 } else {
00710 ret = ReplaceChain(&v, flags, wagon_removal, ¬hing_to_do);
00711 }
00712 assert(ret.Succeeded() && ret.GetCost() == cost.GetCost());
00713 }
00714
00715
00716 if (!was_stopped) cost.AddCost(CmdStartStopVehicle(v, false));
00717 }
00718
00719 if (cost.Succeeded() && nothing_to_do) cost = CommandCost(STR_ERROR_AUTOREPLACE_NOTHING_TO_DO);
00720 return cost;
00721 }
00722
00735 CommandCost CmdSetAutoReplace(TileIndex tile, DoCommandFlag flags, uint32 p1, uint32 p2, const char *text)
00736 {
00737 Company *c = Company::GetIfValid(_current_company);
00738 if (c == NULL) return CMD_ERROR;
00739
00740 EngineID old_engine_type = GB(p2, 0, 16);
00741 EngineID new_engine_type = GB(p2, 16, 16);
00742 GroupID id_g = GB(p1, 16, 16);
00743 CommandCost cost;
00744
00745 if (Group::IsValidID(id_g) ? Group::Get(id_g)->owner != _current_company : !IsAllGroupID(id_g) && !IsDefaultGroupID(id_g)) return CMD_ERROR;
00746 if (!Engine::IsValidID(old_engine_type)) return CMD_ERROR;
00747
00748 if (new_engine_type != INVALID_ENGINE) {
00749 if (!Engine::IsValidID(new_engine_type)) return CMD_ERROR;
00750 if (!CheckAutoreplaceValidity(old_engine_type, new_engine_type, _current_company)) return CMD_ERROR;
00751
00752 cost = AddEngineReplacementForCompany(c, old_engine_type, new_engine_type, id_g, flags);
00753 } else {
00754 cost = RemoveEngineReplacementForCompany(c, old_engine_type, id_g, flags);
00755 }
00756
00757 if ((flags & DC_EXEC) && IsLocalCompany()) InvalidateAutoreplaceWindow(old_engine_type, id_g);
00758
00759 return cost;
00760 }
00761