diff options
| -rw-r--r-- | src/train_cmd.cpp | 653 |
1 files changed, 340 insertions, 313 deletions
diff --git a/src/train_cmd.cpp b/src/train_cmd.cpp index cbeeb3f76..6bce1c2bd 100644 --- a/src/train_cmd.cpp +++ b/src/train_cmd.cpp @@ -1064,225 +1064,314 @@ static void NormaliseTrainConsist(Train *v) } } +/** Helper type for lists/vectors of trains */ +typedef SmallVector<Train *, 16> TrainList; + /** - * Check/validate the new train length - * @param dst_head The destination chain of the to be moved vehicle - * @param src_head The source chain of the to be moved vehicle - * @param src The to be moved vehicle - * @param move_chain Whether to move all vehicles after src or not - * @return possible error of this command. + * Make a backup of a train into a train list. + * @param list to make the backup in + * @param t the train to make the backup of */ -static CommandCost CheckNewTrainLength(const Train *dst_head, const Train *src_head, const Train *src, bool move_chain) +static void MakeTrainBackup(TrainList &list, Train *t) { - /* Check if all vehicles in the source train are stopped inside a depot. */ - int src_len = CheckTrainInDepot(src_head, true); - if (src_len < 0) return_cmd_error(STR_ERROR_TRAINS_CAN_ONLY_BE_ALTERED_INSIDE_A_DEPOT); + for (; t != NULL; t = t->Next()) *list.Append() = t; +} - /* Check if all vehicles in the destination train are stopped inside a depot. */ - int dst_len = dst_head != NULL ? CheckTrainInDepot(dst_head, true) : 0; - if (dst_len < 0) return_cmd_error(STR_ERROR_TRAINS_CAN_ONLY_BE_ALTERED_INSIDE_A_DEPOT); - - /* Determine the maximum length of trains. */ - int max_len = _settings_game.vehicle.mammoth_trains ? 100 : 10; - - /* If the length of both the source and destination combined is - * within the maximum length for trains there is no need for any - * complex calculations. All and any combination of vehicles - * will be within the required lengths. */ - if (src_len + dst_len <= max_len) return CommandCost(); - - if (!move_chain && !src_head->IsFrontEngine() && src_head == src && - /* First case moving within, second is make a new one */ - (src_head == dst_head ? src_len : src_len - 1) > max_len) { - /* Moving of a *single* non-engine at the front of the chain, - * i.e. a free wagon list. If the next unit is an engine a new - * train will be created instead of removing a vehicle from a - * free chain. The newly created train may not be too long. */ - const Train *u = src_head->GetNextUnit(); - if (u != NULL && u->IsEngine()) return_cmd_error(STR_ERROR_TRAIN_TOO_LONG); - } - - /* If we're only moving within the train. The 'only' corner case that - * needs to be checked for this is that no new vehicle is created. - * This is done in above here. */ - if (src_head == dst_head) return CommandCost(); - - /* Going to make a new vehicle chain, but it is going to be a wagon - * chain or we are going to add vehicles to a free wagon chain. - * That chain does not have a limitation on its length. - * NOTE that this cannot be done earlier in case the first vehicle - * is removed from a free wagon chain and the second is an engine; - * the new train in the source chain needs to be checked. */ - if (dst_head == NULL ? !src->IsEngine() : !dst_head->IsFrontEngine()) { - return CommandCost(); +/** + * Restore the train from the backup list. + * @param list the train to restore. + */ +static void RestoreTrainBackup(TrainList &list) +{ + /* No train, nothing to do. */ + if (list.Length() == 0) return; + + Train *prev = NULL; + /* Iterate over the list and rebuild it. */ + for (Train **iter = list.Begin(); iter != list.End(); iter++) { + Train *t = *iter; + if (prev != NULL) { + prev->SetNext(t); + } else if (t->Previous() != NULL) { + /* Make sure the head of the train is always the first in the chain. */ + t->Previous()->SetNext(NULL); + } + prev = t; } +} + +/** + * Remove the given wagon from it's consist. + * @param part the part of the train to remove. + * @param chain whether to remove the whole chain. + */ +static void RemoveFromConsist(Train *part, bool chain = false) +{ + Train *tail = chain ? part->Last() : part->GetLastEnginePart(); + + /* Unlink at the front, but make it point to the next + * vehicle after the to be remove part. */ + if (part->Previous() != NULL) part->Previous()->SetNext(tail->Next()); + + /* Unlink at the back */ + tail->SetNext(NULL); +} + +/** + * Inserts a chain into the train at dst. + * @param dst the place where to append after. + * @param chain the chain to actually add. + */ +static void InsertInConsist(Train *dst, Train *chain) +{ + /* We do not want to add something in the middle of an articulated part. */ + assert(dst->Next() == NULL || !dst->Next()->IsArticulatedPart()); + + chain->Last()->SetNext(dst->Next()); + dst->SetNext(chain); +} + +/** + * Normalise the dual heads in the train, i.e. if one is + * missing move that one to this train. + * @param t the train to normalise. + */ +static void NormaliseDualHeads(Train *t) +{ + for (; t != NULL; t = t->GetNextVehicle()) { + if (!t->IsMultiheaded() || !t->IsEngine()) continue; + + /* Make sure that there are no free cars before next engine */ + Train *u; + for (u = t; u->Next() != NULL && !u->Next()->IsEngine(); u = u->Next()) {} - /* We are moving between rows, so only count the wagons from the source - * row that are being moved. */ - if (move_chain) { - /* CheckTrainInDepot() counts units. */ - for (const Train *u = src_head; u != src && u != NULL; u = u->GetNextUnit()) src_len--; + if (u == t->other_multiheaded_part) continue; + + /* Remove the part from the 'wrong' train */ + RemoveFromConsist(t->other_multiheaded_part); + /* And add it to the 'right' train */ + InsertInConsist(u, t->other_multiheaded_part); + } +} + +/** + * Normalise the sub types of the parts in this chain. + * @param chain the chain to normalise. + */ +static void NormaliseSubtypes(Train *chain) +{ + /* Nothing to do */ + if (chain == NULL) return; + + /* We must be the first in the chain. */ + assert(chain->Previous() == NULL); + + /* Set the appropirate bits for the first in the chain. */ + if (chain->IsWagon()) { + chain->SetFreeWagon(); } else { - /* If moving only one vehicle, just count that. */ - src_len = 1; + assert(chain->IsEngine()); + chain->SetFrontEngine(); } - if (src_len + dst_len > max_len) return_cmd_error(STR_ERROR_TRAIN_TOO_LONG); - return CommandCost(); + /* Now clear the bits for the rest of the chain */ + for (Train *t = chain->Next(); t != NULL; t = t->Next()) { + t->ClearFreeWagon(); + t->ClearFrontEngine(); + } } /** - * Check/validate whether we may actually build a new train - * @param dst The destination for the to be moved vehicle - * @param src The to be moved vehicle - * @param move_chain Whether to move all vehicles after src or not - * @param flags Any command flags given to CmdMoveRailVehicle + * Check/validate whether we may actually build a new train. + * @note All vehicles are/were 'heads' of their chains. + * @param original_dst The original destination chain. + * @param dst The destination chain after constructing the train. + * @param original_dst The original source chain. + * @param dst The source chain after constructing the train. * @return possible error of this command. */ -static CommandCost CheckNewTrain(const Train *dst, Train *src, bool move_chain, DoCommandFlag flags) +static CommandCost CheckNewTrain(Train *original_dst, Train *dst, Train *original_src, Train *src) { - /* Moving a loco to a new line?, then we need to assign a unitnumber. */ - if (dst == NULL && !src->IsFrontEngine() && src->IsEngine()) { - UnitID unit_num = GetFreeUnitNumber(VEH_TRAIN); - if (unit_num > _settings_game.vehicle.max_trains) return_cmd_error(STR_ERROR_TOO_MANY_VEHICLES_IN_GAME); - - if (flags & DC_EXEC) src->unitnumber = unit_num; - } - - /* When we move the front vehicle, the second vehicle might need a unitnumber. - * We do not need to assign that here because there will be a second call to - * CmdMoveRailVehicle to make the new train which will then go through the - * unitnumber setting procedure described above. */ - if (!move_chain && (src->IsFreeWagon() || (src->IsFrontEngine() && dst == NULL))) { - const Train *second = src->GetNextUnit(); - if (second != NULL && second->IsEngine() && GetFreeUnitNumber(VEH_TRAIN) > _settings_game.vehicle.max_trains) { - return_cmd_error(STR_ERROR_TOO_MANY_VEHICLES_IN_GAME); - } + /* Just add 'new' engines and substract the original ones. + * If that's less than or equal to 0 we can be sure we did + * not add any engines (read: trains) along the way. */ + if ((src != NULL && src->IsEngine() ? 1 : 0) + + (dst != NULL && dst->IsEngine() ? 1 : 0) - + (original_src != NULL && original_src->IsEngine() ? 1 : 0) - + (original_dst != NULL && original_dst->IsEngine() ? 1 : 0) <= 0) { + return CommandCost(); } - return CommandCost(); + /* Get a free unit number and check whether it's within the bounds. + * There will always be a maximum of one new train. */ + if (GetFreeUnitNumber(VEH_TRAIN) <= _settings_game.vehicle.max_trains) return CommandCost(); + + return_cmd_error(STR_ERROR_TOO_MANY_VEHICLES_IN_GAME); } /** - * Check/validate the new train(s) - * @param dst_head The destination chain of the to be moved vehicle - * @param dst The destination for the to be moved vehicle - * @param src_head The source chain of the to be moved vehicle - * @param src The to be moved vehicle - * @param move_chain Whether to move all vehicles after src or not + * Check whether the train parts can be attached. + * @param t the train to check * @return possible error of this command. */ -static CommandCost CheckNewTrainValidity(Train *dst_head, Train *dst, Train *src_head, Train *src, bool move_chain) +static CommandCost CheckTrainAttachment(Train *t) { - /* - * Check whether the vehicles in the source chain are in the destination - * chain. This can easily be done by checking whether the first vehicle - * of the source chain is in the destination chain as the Next/Previous - * pointers always make a doubly linked list of it where the assumption - * v->Next()->Previous() == v holds (assuming v->Next() != NULL). - */ - bool src_in_dst = false; - for (Train *v = dst_head; !src_in_dst && v != NULL; v = v->Next()) src_in_dst = v == src; - - /* - * If the source chain is in the destination chain then the user is - * only reordering the vehicles, thus not attaching a new vehicle. - * Therefor the 'allow wagon attach' callback does not need to be - * called. If it would be called strange things would happen because - * one 'attaches' an already 'attached' vehicle causing more trouble - * than it actually solves (infinite loops and such). - */ - if (dst_head == NULL || src_in_dst) return CommandCost(); - - /* Forget everything, as everything is going to change */ - src->InvalidateNewGRFCacheOfChain(); - dst->InvalidateNewGRFCacheOfChain(); - - /* - * When performing the 'allow wagon attach' callback, we have to check - * that for each and every wagon, not only the first one. This means - * that we have to test one wagon, attach it to the train and then test - * the next wagon till we have reached the end. We have to restore it - * to the state it was before we 'tried' attaching the train when the - * attaching fails or succeeds because we are not 'only' doing this - * in the DC_EXEC state. - */ - Train *dst_tail = dst_head; - while (dst_tail->Next() != NULL) dst_tail = dst_tail->Next(); + /* No multi-part train, no need to check. */ + if (t == NULL || t->Next() == NULL || !t->IsEngine()) return CommandCost(); + + /* The maximum length for a train. For each part we decrease this by one + * and if the result is negative the train is simply too long. */ + int allowed_len = _settings_game.vehicle.mammoth_trains ? 100 : 10; + + Train *head = t; + Train *prev = t; + + /* Break the prev -> t link so it always holds within the loop. */ + t = t->Next(); + allowed_len--; + prev->SetNext(NULL); + + /* Make sure the cache is cleared. */ + head->InvalidateNewGRFCache(); - Train *orig_tail = dst_tail; - Train *next_to_attach = src; - Train *src_previous = src->Previous(); + while (t != NULL) { + Train *next = t->Next(); + + /* Unlink the to-be-added piece; it is already unlinked from the previous + * part due to the fact that the prev -> t link is broken. */ + t->SetNext(NULL); - while (next_to_attach != NULL) { /* Don't check callback for articulated or rear dual headed parts */ - if (!next_to_attach->IsArticulatedPart() && !next_to_attach->IsRearDualheaded()) { + if (!t->IsArticulatedPart() && !t->IsRearDualheaded()) { + allowed_len--; // We do not count articulated parts and rear heads either. + /* Back up and clear the first_engine data to avoid using wagon override group */ - EngineID first_engine = next_to_attach->tcache.first_engine; - next_to_attach->tcache.first_engine = INVALID_ENGINE; + EngineID first_engine = t->tcache.first_engine; + t->tcache.first_engine = INVALID_ENGINE; - uint16 callback = GetVehicleCallbackParent(CBID_TRAIN_ALLOW_WAGON_ATTACH, 0, 0, dst_head->engine_type, next_to_attach, dst_head); + /* We don't want the cache to interfere. head's cache is cleared before + * the loop and after each callback does not need to be cleared here. */ + t->InvalidateNewGRFCache(); + + uint16 callback = GetVehicleCallbackParent(CBID_TRAIN_ALLOW_WAGON_ATTACH, 0, 0, head->engine_type, t, head); /* Restore original first_engine data */ - next_to_attach->tcache.first_engine = first_engine; + t->tcache.first_engine = first_engine; /* We do not want to remember any cached variables from the test run */ - next_to_attach->InvalidateNewGRFCache(); - dst_head->InvalidateNewGRFCache(); + t->InvalidateNewGRFCache(); + head->InvalidateNewGRFCache(); if (callback != CALLBACK_FAILED) { + /* A failing callback means everything is okay */ StringID error = STR_NULL; if (callback == 0xFD) error = STR_ERROR_INCOMPATIBLE_RAIL_TYPES; - if (callback < 0xFD) error = GetGRFStringID(GetEngineGRFID(dst_head->engine_type), 0xD000 + callback); - - if (error != STR_NULL) { - /* - * The attaching is not allowed. In this case 'next_to_attach' - * can contain some vehicles of the 'source' and the destination - * train can have some too. We 'just' add the to-be added wagons - * to the chain and then split it where it was previously - * separated, i.e. the tail of the original destination train. - * Furthermore the 'previous' link of the original source vehicle needs - * to be restored, otherwise the train goes missing in the depot. - */ - dst_tail->SetNext(next_to_attach); - orig_tail->SetNext(NULL); - if (src_previous != NULL) src_previous->SetNext(src); - - return_cmd_error(error); - } + if (callback < 0xFD) error = GetGRFStringID(GetEngineGRFID(head->engine_type), 0xD000 + callback); + + if (error != STR_NULL) return_cmd_error(error); } } - /* Only check further wagons if told to move the chain */ - if (!move_chain) break; + /* And link it to the new part. */ + prev->SetNext(t); + prev = t; + t = next; + } - /* - * Adding a next wagon to the chain so we can test the other wagons. - * First 'take' the first wagon from 'next_to_attach' and move it - * to the next wagon. Then add that to the tail of the destination - * train and update the tail with the new vehicle. - */ - Train *to_add = next_to_attach; - next_to_attach = next_to_attach->Next(); + if (allowed_len <= 0) return_cmd_error(STR_ERROR_TRAIN_TOO_LONG); + return CommandCost(); +} - to_add->SetNext(NULL); - dst_tail->SetNext(to_add); - dst_tail = dst_tail->Next(); - } +/** + * Validate whether we are going to create valid trains. + * @note All vehicles are/were 'heads' of their chains. + * @param original_dst The original destination chain. + * @param dst The destination chain after constructing the train. + * @param original_dst The original source chain. + * @param dst The source chain after constructing the train. + * @return possible error of this command. + */ +static CommandCost ValidateTrains(Train *original_dst, Train *dst, Train *original_src, Train *src) +{ + /* Check whether we may actually construct the trains. */ + CommandCost ret = CheckTrainAttachment(src); + if (ret.Failed()) return ret; + ret = CheckTrainAttachment(dst); + if (ret.Failed()) return ret; + + /* Check whether we need to build a new train. */ + return CheckNewTrain(original_dst, dst, original_src, src); +} - /* - * When we reach this the attaching is allowed. It also means that the - * chain of vehicles to attach is empty, so we do not need to merge that. - * This means only the splitting needs to be done. - * Furthermore the 'previous' link of the original source vehicle needs - * to be restored, otherwise the train goes missing in the depot. - */ - orig_tail->SetNext(NULL); - if (src_previous != NULL) src_previous->SetNext(src); +/** + * Arrange the trains in the wanted way. + * @param dst_head The destination chain of the to be moved vehicle. + * @param dst The destination for the to be moved vehicle. + * @param src_head The source chain of the to be moved vehicle. + * @param src The to be moved vehicle. + * @param move_chain Whether to move all vehicles after src or not. + */ +static void ArrangeTrains(Train **dst_head, Train *dst, Train **src_head, Train *src, bool move_chain) +{ + /* First determine the front of the two resulting trains */ + if (*src_head == *dst_head) { + /* If we aren't moving part(s) to a new train, we are just moving the + * front back and there is not destination head. */ + *dst_head = NULL; + } else if (*dst_head == NULL) { + /* If we are moving to a new train the head of the move train would become + * the head of the new vehicle. */ + *dst_head = src; + } + + if (src == *src_head) { + /* If we are moving the front of a train then we are, in effect, creating + * a new head for the train. Point to that. Unless we are moving the whole + * train in which case there is not 'source' train anymore. + * In case we are a multiheaded part we want the complete thing to come + * with us, so src->GetNextUnit(), however... when we are e.g. a wagon + * that is followed by a rear multihead we do not want to include that. */ + *src_head = move_chain ? NULL : + (src->IsMultiheaded() ? src->GetNextUnit() : src->GetNextVehicle()); + } + + /* Now it's just simply removing the part that we are going to move from the + * source train and *if* the destination is a not a new train add the chain + * at the destination location. */ + RemoveFromConsist(src, move_chain); + if (*dst_head != src) InsertInConsist(dst, src); + + /* Now normalise the dual heads, that is move the dual heads around in such + * a way that the head and rear of a dual head are in the same train */ + NormaliseDualHeads(*src_head); + NormaliseDualHeads(*dst_head); +} - return CommandCost(); +/** + * Normalise the head of the train again, i.e. that is tell the world that + * we have changed and update all kinds of variables. + * @param head the train to update. + */ +static void NormaliseTrainHead(Train *head) +{ + /* Not much to do! */ + if (head == NULL) return; + + /* Tell the 'world' the train changed. */ + TrainConsistChanged(head, false); + UpdateTrainGroupID(head); + + /* Not a front engine, i.e. a free wagon chain. No need to do more. */ + if (!head->IsFrontEngine()) return; + + /* Update the refit button and window */ + SetWindowDirty(WC_VEHICLE_REFIT, head->index); + SetWindowWidgetDirty(WC_VEHICLE_VIEW, head->index, VVW_WIDGET_REFIT_VEH); + + /* If we don't have a unit number yet, set one. */ + if (head->unitnumber != 0) return; + head->unitnumber = GetFreeUnitNumber(VEH_TRAIN); } /** Move a rail vehicle around inside the depot. @@ -1346,156 +1435,94 @@ CommandCost CmdMoveRailVehicle(TileIndex tile, DoCommandFlag flags, uint32 p1, u /* when moving all wagons, we can't have the same src_head and dst_head */ if (move_chain && src_head == dst_head) return CommandCost(); - if ((flags & DC_AUTOREPLACE) == 0) { - /* If the autoreplace flag is set we already are sure about - * the fact that the vehicle is stopped. Autoreplace also - * cannot add more units to a chain. As such it will never - * create a too long vehicle and thus there is no need to - * do the length checks for autoreplace. */ - CommandCost ret = CheckNewTrainLength(dst_head, src_head, src, move_chain); - if (ret.Failed()) return ret; - - /* If the autoreplace flag is set we do not need to test for - * a new unit number because we are not going to create a - * new train. As such this can be skipped for autoreplace. */ - ret = CheckNewTrain(dst, src, move_chain, flags); - if (ret.Failed()) return ret; - - /* If the autoreplace flag is set we do not need to test for - * the validity because we are going to revert the train to - * its original state. As we can assume the original state - * was correct this can be skipped for autoreplace. */ - ret = CheckNewTrainValidity(dst_head, dst, src_head, src, move_chain); - if (ret.Failed()) return ret; - } - - /* do it? */ - if (flags & DC_EXEC) { - /* If we move the front Engine and if the second vehicle is not an engine - add the whole vehicle to the DEFAULT_GROUP */ - if (src->IsFrontEngine() && !IsDefaultGroupID(src->group_id)) { - Train *v = src->GetNextUnit(); - - if (v != NULL && v->IsEngine()) { - v->group_id = src->group_id; - src->group_id = DEFAULT_GROUP; - } - } - - if (move_chain) { - /* unlink ALL wagons */ - if (src != src_head) { - src->Previous()->SetNext(NULL); - } else { - InvalidateWindowData(WC_VEHICLE_DEPOT, src_head->tile); // We removed a line - src_head = NULL; - } - } else { - /* if moving within the same chain, dont use dst_head as it may get invalidated */ - if (src_head == dst_head) dst_head = NULL; - /* unlink single wagon from linked list */ - src_head = UnlinkWagon(src, src_head); - src->GetLastEnginePart()->SetNext(NULL); - } + /* Check if all vehicles in the source train are stopped inside a depot. */ + if (!src_head->IsStoppedInDepot()) return_cmd_error(STR_ERROR_TRAINS_CAN_ONLY_BE_ALTERED_INSIDE_A_DEPOT); - if (dst == NULL) { - /* We make a new line in the depot, so we know already that we invalidate the window data */ - InvalidateWindowData(WC_VEHICLE_DEPOT, src->tile); + /* Check if all vehicles in the destination train are stopped inside a depot. */ + if (dst_head != NULL && !dst_head->IsStoppedInDepot()) return_cmd_error(STR_ERROR_TRAINS_CAN_ONLY_BE_ALTERED_INSIDE_A_DEPOT); - /* move the train to an empty line. for locomotives, we set the type to TS_Front. for wagons, 4. */ - if (src->IsEngine()) { - if (!src->IsFrontEngine()) { - /* setting the type to 0 also involves setting up the orders field. */ - src->SetFrontEngine(); - assert(src->orders.list == NULL); + /* First make a backup of the order of the trains. That way we can do + * whatever we want with the order and later on easily revert. */ + TrainList original_src; + TrainList original_dst; - /* Decrease the engines number of the src engine_type */ - if (!IsDefaultGroupID(src->group_id) && Group::IsValidID(src->group_id)) { - Group::Get(src->group_id)->num_engines[src->engine_type]--; - } + MakeTrainBackup(original_src, src_head); + MakeTrainBackup(original_dst, dst_head); - /* If we move an engine to a new line affect it to the DEFAULT_GROUP */ - src->group_id = DEFAULT_GROUP; - } - } else { - src->SetFreeWagon(); - } - dst_head = src; - } else { - if (src->IsFrontEngine()) { - /* the vehicle was previously a loco. need to free the order list and delete vehicle windows etc. */ - DeleteWindowById(WC_VEHICLE_VIEW, src->index); - DeleteWindowById(WC_VEHICLE_ORDERS, src->index); - DeleteWindowById(WC_VEHICLE_REFIT, src->index); - DeleteWindowById(WC_VEHICLE_DETAILS, src->index); - DeleteWindowById(WC_VEHICLE_TIMETABLE, src->index); - DeleteVehicleOrders(src); - RemoveVehicleFromGroup(src); - } + /* Also make backup of the original heads as ArrangeTrains can change them. + * For the destination head we do not care if it is the same as the source + * head because in that case it's just a copy. */ + Train *original_src_head = src_head; + Train *original_dst_head = (dst_head == src_head ? NULL : dst_head); - if (src->IsFrontEngine() || src->IsFreeWagon()) { - InvalidateWindowData(WC_VEHICLE_DEPOT, src->tile); - src->ClearFrontEngine(); - src->ClearFreeWagon(); - src->unitnumber = 0; // doesn't occupy a unitnumber anymore. - } - - /* link in the wagon(s) in the chain. */ - { - Train *v; + /* (Re)arrange the trains in the wanted arrangement. */ + ArrangeTrains(&dst_head, dst, &src_head, src, move_chain); - for (v = src; v->Next() != NULL; v = v->Next()) {} - v->SetNext(dst->Next()); - } - dst->SetNext(src); - } - - if (src->other_multiheaded_part != NULL) { - if (src->other_multiheaded_part == src_head) { - src_head = src_head->Next(); - } - AddWagonToConsist(src->other_multiheaded_part, src); - } - - /* If there is an engine behind first_engine we moved away, it should become new first_engine - * To do this, CmdMoveRailVehicle must be called once more - * we can't loop forever here because next time we reach this line we will have a front engine */ - if (src_head != NULL && !src_head->IsFrontEngine() && src_head->IsEngine()) { - /* As in CmdMoveRailVehicle src_head->group_id will be equal to DEFAULT_GROUP - * we need to save the group and reaffect it to src_head */ - const GroupID tmp_g = src_head->group_id; - CmdMoveRailVehicle(0, flags, src_head->index | (INVALID_VEHICLE << 16), 1, text); - SetTrainGroupID(src_head, tmp_g); - src_head = NULL; // don't do anything more to this train since the new call will do it + if ((flags & DC_AUTOREPLACE) == 0) { + /* If the autoreplace flag is set we do not need to test for the validity + * because we are going to revert the train to its original state. As we + * assume the original state was correct autoreplace can skip this. */ + CommandCost ret = ValidateTrains(original_dst_head, dst_head, original_src_head, src_head); + if (ret.Failed()) { + /* Restore the train we had. */ + RestoreTrainBackup(original_src); + RestoreTrainBackup(original_dst); + return ret; } + } - if (src_head != NULL) { - NormaliseTrainConsist(src_head); - TrainConsistChanged(src_head, false); - UpdateTrainGroupID(src_head); - if (src_head->IsFrontEngine()) { - /* Update the refit button and window */ - SetWindowDirty(WC_VEHICLE_REFIT, src_head->index); - SetWindowWidgetDirty(WC_VEHICLE_VIEW, src_head->index, VVW_WIDGET_REFIT_VEH); - } - /* Update the depot window */ - SetWindowDirty(WC_VEHICLE_DEPOT, src_head->tile); + /* do it? */ + if (flags & DC_EXEC) { + /* First normalise the sub types of the chains. */ + NormaliseSubtypes(src_head); + NormaliseSubtypes(dst_head); + + /* There are 14 different cases: + * 1) front engine gets moved to a new train, it stays a front engine. + * a) the 'next' part is a wagon, that becomes a free wagon chain. + * b) the 'next' part is an engine, that becomes a front engine. + * c) there is no 'next' part, nothing else happens + * 2) front engine gets moved to another train, it is not a front engine anymore + * a) the 'next' part is a wagon, that becomes a free wagon chain. + * b) the 'next' part is an engine, that becomes a front engine. + * c) there is no 'next' part, nothing else happens + * 3) front engine gets moved to later in the current train, it is not an engine anymore. + * a) the 'next' part is a wagon, that becomes a free wagon chain. + * b) the 'next' part is an engine, that becomes a front engine. + * 4) free wagon gets moved + * a) the 'next' part is a wagon, that becomes a free wagon chain. + * b) the 'next' part is an engine, that becomes a front engine. + * c) there is no 'next' part, nothing else happens + * 5) non front engine gets moved and becomes a new train, nothing else happens + * 6) non front engine gets moved within a train / to another train, nothing hapens + * 7) wagon gets moved, nothing happens + */ + if (src == original_src_head && src->IsEngine() && !src->IsFrontEngine()) { + /* Cases #2 and #3: the front engine gets trashed. */ + DeleteWindowById(WC_VEHICLE_VIEW, src->index); + DeleteWindowById(WC_VEHICLE_ORDERS, src->index); + DeleteWindowById(WC_VEHICLE_REFIT, src->index); + DeleteWindowById(WC_VEHICLE_DETAILS, src->index); + DeleteWindowById(WC_VEHICLE_TIMETABLE, src->index); + + /* Delete orders, group stuff and the unit number as we're not the + * front of any vehicle anymore. */ + DeleteVehicleOrders(src); + RemoveVehicleFromGroup(src); + src->unitnumber = 0; } - if (dst_head != NULL) { - NormaliseTrainConsist(dst_head); - TrainConsistChanged(dst_head, false); - UpdateTrainGroupID(dst_head); - if (dst_head->IsFrontEngine()) { - /* Update the refit button and window */ - SetWindowWidgetDirty(WC_VEHICLE_VIEW, dst_head->index, VVW_WIDGET_REFIT_VEH); - SetWindowDirty(WC_VEHICLE_REFIT, dst_head->index); - } - /* Update the depot window */ - SetWindowDirty(WC_VEHICLE_DEPOT, dst_head->tile); - } + /* Handle 'new engine' part of cases #1b, #2b, #3b, #4b and #5 in NormaliseTrainHead. */ + NormaliseTrainHead(src_head); + NormaliseTrainHead(dst_head); + /* We are undoubtedly changing something in the depot and train list. */ + InvalidateWindowData(WC_VEHICLE_DEPOT, src->tile); InvalidateWindowClassesData(WC_TRAINS_LIST, 0); + } else { + /* We don't want to execute what we're just tried. */ + RestoreTrainBackup(original_src); + RestoreTrainBackup(original_dst); } return CommandCost(); |