| blob | 262c636c4f4c1cbdb2f85bc02f69f77da821f9dd |
1 /* $Id$ */
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 */
10 /** @file train_cmd.cpp Handling of trains. */
52 static Track ChooseTrainTrack(Train *v, TileIndex tile, DiagDirection enterdir, TrackBits tracks, bool force_res, bool *got_reservation, bool mark_stuck);
54 bool TrainController(Train *v, Vehicle *nomove, bool reverse = true); // Also used in vehicle_sl.cpp.
64 {
66 }
68 /**
69 * Determine the side in which the train will leave the tile
70 *
71 * @param direction vehicle direction
72 * @param track vehicle track bits
73 * @return side of tile the train will leave
74 */
76 {
77 static const TrackBits state_dir_table[DIAGDIR_END] = { TRACK_BIT_RIGHT, TRACK_BIT_LOWER, TRACK_BIT_LEFT, TRACK_BIT_UPPER };
81 /* Determine the diagonal direction in which we will exit this tile */
84 }
87 }
90 /**
91 * Return the cargo weight multiplier to use for a rail vehicle
92 * @param cargo Cargo type to get multiplier for
93 * @return Cargo weight multiplier
94 */
96 {
99 }
101 /** Checks if lengths of all rail vehicles are valid. If not, shows an error message. */
103 {
121 }
122 /* Break so we warn only once for each train. */
124 }
125 }
126 }
127 }
128 }
129 }
131 /**
132 * Recalculates the cached stuff of a train. Should be called each time a vehicle is added
133 * to/removed from the chain, and when the game is loaded.
134 * Note: this needs to be called too for 'wagon chains' (in the depot, without an engine)
135 * @param allowed_changes Stuff that is allowed to change.
136 */
138 {
153 /* Check the this->first cache. */
156 /* update the 'first engine' */
162 /* Set user defined data to its default value */
166 }
169 /* Update user defined data (must be done before other properties) */
173 }
181 /* Cache wagon override sprite group. NULL is returned if there is none */
182 u->tcache.cached_override = GetWagonOverrideSpriteSet(u->engine_type, u->cargo_type, u->gcache.first_engine);
184 /* Reset colour map */
189 /* Update powered-wagon-status and visual effect */
194 /* wagon is powered */
198 }
201 /* Do not count powered wagons for the compatible railtypes, as wagons always
202 have railtype normal */
205 }
207 /* Some electric engines can be allowed to run on normal rail. It happens to all
208 * existing electric engines when elrails are disabled and then re-enabled */
212 }
214 /* max speed is the minimum of the speed limits of all vehicles in the consist */
215 if ((rvi_u->railveh_type != RAILVEH_WAGON || _settings_game.vehicle.wagon_speed_limits) && !UsesWagonOverride(u)) {
218 }
219 }
223 /* Update vehicle capacity. */
228 /* Verify capacity hasn't changed. */
229 if (new_cap != u->cargo_cap) ShowNewGrfVehicleError(u->engine_type, STR_NEWGRF_BROKEN, STR_NEWGRF_BROKEN_CAPACITY, GBUG_VEH_CAPACITY, true);
230 }
231 u->vcache.cached_cargo_age_period = GetVehicleProperty(u, PROP_TRAIN_CARGO_AGE_PERIOD, e_u->info.cargo_age_period);
233 /* check the vehicle length (callback) */
236 /* Use callback 36 */
241 }
243 /* Use callback 11 */
245 }
250 /* Update vehicle length. */
253 /* Verify length hasn't changed. */
255 }
260 }
262 /* store consist weight/max speed in cache */
267 /* recalculate cached weights and power too (we do this *after* the rest, so it is known which wagons are powered and need extra weight added) */
276 }
277 }
279 /**
280 * Get the stop location of (the center) of the front vehicle of a train at
281 * a platform of a station.
282 * @param station_id the ID of the station where we're stopping
283 * @param tile the tile where the vehicle currently is
284 * @param v the vehicle to get the stop location of
285 * @param station_ahead 'return' the amount of 1/16th tiles in front of the train
286 * @param station_length 'return' the station length in 1/16th tiles
287 * @return the location, calculated from the begin of the station to stop at.
288 */
289 int GetTrainStopLocation(StationID station_id, TileIndex tile, const Train *v, int *station_ahead, int *station_length)
290 {
295 /* Default to the middle of the station for stations stops that are not in
296 * the order list like intermediate stations when non-stop is disabled */
299 /* The train is longer than the station, make it stop at the far end of the platform */
301 } else if (v->current_order.IsType(OT_GOTO_STATION) && v->current_order.GetDestination() == station_id) {
303 }
305 /* The stop location of the FRONT! of the train */
321 }
323 /* Subtract half the front vehicle length of the train so we get the real
324 * stop location of the train. */
326 }
329 /**
330 * Computes train speed limit caused by curves
331 * @return imposed speed limit
332 */
334 {
344 /* first find the curve speed limit */
360 numcurve++;
364 }
365 }
367 }
369 /* if we have a 90 degree turn, fix the speed limit to 60 */
372 }
373 }
381 }
382 }
385 /* Apply the engine's rail type curve speed advantage, if it slowed by curves */
390 /* Apply max_speed bonus of 20% for a tilting train */
392 }
393 }
396 }
400 /**
401 * Calculates the maximum speed of the vehicle under its current conditions.
402 * @return Maximum speed of the vehicle.
403 */
405 {
417 /* Basic idea: Follow the track for 20 tiles or 3 signals (i.e. at most two signal blocks) looking for other trains. */
418 /* If we find one (that meets certain restrictions), we limit the max speed to the speed of that train. */
425 /* If we are on a depot or rail station tile stop searching */
429 /* Increment signal counter if we're on a signal */
432 HasSignalOnTrack(ft.m_new_tile, TrackBitsToTrack(TrackdirBitsToTrackBits(ft.m_new_td_bits)))) { ///< Tile has signal
433 num_signals++;
434 }
436 /* Check if tile has train/is reserved */
438 HasReservedTracks(ft.m_new_tile, TrackdirBitsToTrackBits(ft.m_new_td_bits))) { ///< Tile is reserved
439 Train* other_train = GetTrainForReservation(ft.m_new_tile, TrackBitsToTrack(TrackdirBitsToTrackBits(ft.m_new_td_bits)));
447 }
448 }
450 /* Decide what in direction to continue: reservation, straight or "first/only" direction. */
451 /* Abort if there's no reservation even though the tile contains multiple tracks. */
452 TrackdirBits reserved = ft.m_new_td_bits & TrackBitsToTrackdirBits(GetReservedTrackbits(ft.m_new_tile));
455 // There is a reservation to follow.
457 }
459 // Tile has more than one track and we have no reservation. Bail out.
461 }
463 // There was no reservation but there is only one direction to follow, so follow it.
465 }
467 num_tiles++;
469 }
471 /* Check that the ATC speed is sufficiently large.
472 Avoids assertion error in UpdateSpeed(). */
474 }
476 if (_settings_game.vehicle.train_acceleration_model == AM_REALISTIC && IsRailStationTile(this->tile)) {
483 /* The distance to go is whatever is still ahead of the train minus the
484 * distance from the train's stop location to the end of the platform */
493 }
497 }
498 }
499 }
502 if (_settings_game.vehicle.train_acceleration_model == AM_REALISTIC && u->track == TRACK_BIT_DEPOT) {
505 }
507 /* Vehicle is on the middle part of a bridge. */
510 }
511 }
515 }
517 /** Update acceleration of the train from the cached power and weight. */
519 {
526 }
528 /**
529 * Get the width of a train vehicle image in the GUI.
530 * @param offset Additional offset for positioning the sprite; set to NULL if not needed
531 * @return Width in pixels
532 */
534 {
542 }
547 }
549 }
552 {
554 return ((direction + _engine_sprite_add[spritenum]) & _engine_sprite_and[spritenum]) + _engine_sprite_base[spritenum];
555 }
557 /**
558 * Get the sprite to display the train.
559 * @param direction Direction of view/travel.
560 * @param image_type Visualisation context.
561 * @return Sprite to display.
562 */
563 void Train::GetImage(Direction direction, EngineImageType image_type, VehicleSpriteSeq *result) const
564 {
570 GetCustomVehicleSprite(this, (Direction)(direction + 4 * IS_CUSTOM_SECONDHEAD_SPRITE(spritenum)), image_type, result);
574 }
582 }
584 static void GetRailIcon(EngineID engine, bool rear_head, int &y, EngineImageType image_type, VehicleSpriteSeq *result)
585 {
595 }
597 }
600 }
605 }
607 void DrawTrainEngine(int left, int right, int preferred_x, int y, EngineID engine, PaletteID pal, EngineImageType image_type)
608 {
627 VehicleSpriteSeq seq;
636 }
637 }
639 /**
640 * Get the size of the sprite of a train sprite heading west, or both heads (used for lists).
641 * @param engine The engine to get the sprite from.
642 * @param[out] width The width of the sprite.
643 * @param[out] height The height of the sprite.
644 * @param[out] xoffs Number of pixels to shift the sprite to the right.
645 * @param[out] yoffs Number of pixels to shift the sprite downwards.
646 * @param image_type Context the sprite is used in.
647 */
648 void GetTrainSpriteSize(EngineID engine, uint &width, uint &height, int &xoffs, int &yoffs, EngineImageType image_type)
649 {
652 VehicleSpriteSeq seq;
666 /* Calculate values relative to an imaginary center between the two sprites. */
671 }
672 }
674 /**
675 * Build a railroad wagon.
676 * @param tile tile of the depot where rail-vehicle is built.
677 * @param flags type of operation.
678 * @param e the engine to build.
679 * @param ret[out] the vehicle that has been built.
680 * @return the cost of this operation or an error.
681 */
682 static CommandCost CmdBuildRailWagon(TileIndex tile, DoCommandFlag flags, const Engine *e, Vehicle **ret)
683 {
686 /* Check that the wagon can drive on the track in question */
741 /* Try to connect the vehicle to one of free chains of wagons. */
751 }
752 }
753 }
756 }
758 /** Move all free vehicles in the depot to the train */
760 {
768 }
769 }
770 }
773 {
801 /* Now we need to link the front and rear engines together */
804 }
806 /**
807 * Build a railroad vehicle.
808 * @param tile tile of the depot where rail-vehicle is built.
809 * @param flags type of operation.
810 * @param e the engine to build.
811 * @param data bit 0 prevents any free cars from being added to the train.
812 * @param ret[out] the vehicle that has been built.
813 * @return the cost of this operation or an error.
814 */
815 CommandCost CmdBuildRailVehicle(TileIndex tile, DoCommandFlag flags, const Engine *e, uint16 data, Vehicle **ret)
816 {
821 /* Check if depot and new engine uses the same kind of tracks *
822 * We need to see if the engine got power on the tile to avoid electric engines in non-electric depots */
865 v->SetServiceIntervalIsPercent(Company::Get(_current_company)->settings.vehicle.servint_ispercent);
878 }
883 if (!HasBit(data, 0) && !(flags & DC_AUTOREPLACE)) { // check if the cars should be added to the new vehicle
885 }
888 }
891 }
894 {
901 /* check so all vehicles in the line have the same engine. */
906 }
907 }
908 }
911 }
913 /** Helper type for lists/vectors of trains */
916 /**
917 * Make a backup of a train into a train list.
918 * @param list to make the backup in
919 * @param t the train to make the backup of
920 */
922 {
924 }
926 /**
927 * Restore the train from the backup list.
928 * @param list the train to restore.
929 */
931 {
932 /* No train, nothing to do. */
936 /* Iterate over the list and rebuild it. */
942 /* Make sure the head of the train is always the first in the chain. */
944 }
946 }
947 }
949 /**
950 * Remove the given wagon from its consist.
951 * @param part the part of the train to remove.
952 * @param chain whether to remove the whole chain.
953 */
955 {
958 /* Unlink at the front, but make it point to the next
959 * vehicle after the to be remove part. */
962 /* Unlink at the back */
964 }
966 /**
967 * Inserts a chain into the train at dst.
968 * @param dst the place where to append after.
969 * @param chain the chain to actually add.
970 */
972 {
973 /* We do not want to add something in the middle of an articulated part. */
978 }
980 /**
981 * Normalise the dual heads in the train, i.e. if one is
982 * missing move that one to this train.
983 * @param t the train to normalise.
984 */
986 {
990 /* Make sure that there are no free cars before next engine */
996 /* Remove the part from the 'wrong' train */
998 /* And add it to the 'right' train */
1000 }
1001 }
1003 /**
1004 * Normalise the sub types of the parts in this chain.
1005 * @param chain the chain to normalise.
1006 */
1008 {
1009 /* Nothing to do */
1012 /* We must be the first in the chain. */
1015 /* Set the appropriate bits for the first in the chain. */
1021 }
1023 /* Now clear the bits for the rest of the chain */
1027 }
1028 }
1030 /**
1031 * Check/validate whether we may actually build a new train.
1032 * @note All vehicles are/were 'heads' of their chains.
1033 * @param original_dst The original destination chain.
1034 * @param dst The destination chain after constructing the train.
1035 * @param original_dst The original source chain.
1036 * @param dst The source chain after constructing the train.
1037 * @return possible error of this command.
1038 */
1039 static CommandCost CheckNewTrain(Train *original_dst, Train *dst, Train *original_src, Train *src)
1040 {
1041 /* Just add 'new' engines and subtract the original ones.
1042 * If that's less than or equal to 0 we can be sure we did
1043 * not add any engines (read: trains) along the way. */
1049 }
1051 /* Get a free unit number and check whether it's within the bounds.
1052 * There will always be a maximum of one new train. */
1056 }
1058 /**
1059 * Check whether the train parts can be attached.
1060 * @param t the train to check
1061 * @return possible error of this command.
1062 */
1064 {
1065 /* No multi-part train, no need to check. */
1068 /* The maximum length for a train. For each part we decrease this by one
1069 * and if the result is negative the train is simply too long. */
1070 int allowed_len = _settings_game.vehicle.max_train_length * TILE_SIZE - t->gcache.cached_veh_length;
1075 /* Break the prev -> t link so it always holds within the loop. */
1079 /* Make sure the cache is cleared. */
1087 /* Unlink the to-be-added piece; it is already unlinked from the previous
1088 * part due to the fact that the prev -> t link is broken. */
1091 /* Don't check callback for articulated or rear dual headed parts */
1093 /* Back up and clear the first_engine data to avoid using wagon override group */
1097 /* We don't want the cache to interfere. head's cache is cleared before
1098 * the loop and after each callback does not need to be cleared here. */
1101 uint16 callback = GetVehicleCallbackParent(CBID_TRAIN_ALLOW_WAGON_ATTACH, 0, 0, head->engine_type, t, head);
1103 /* Restore original first_engine data */
1106 /* We do not want to remember any cached variables from the test run */
1111 /* A failing callback means everything is okay */
1117 if (callback >= 0x100) ErrorUnknownCallbackResult(head->GetGRFID(), CBID_TRAIN_ALLOW_WAGON_ATTACH, callback);
1131 }
1132 }
1133 }
1136 }
1137 }
1139 /* And link it to the new part. */
1143 }
1147 }
1149 /**
1150 * Validate whether we are going to create valid trains.
1151 * @note All vehicles are/were 'heads' of their chains.
1152 * @param original_dst The original destination chain.
1153 * @param dst The destination chain after constructing the train.
1154 * @param original_dst The original source chain.
1155 * @param dst The source chain after constructing the train.
1156 * @param check_limit Whether to check the vehicle limit.
1157 * @return possible error of this command.
1158 */
1159 static CommandCost ValidateTrains(Train *original_dst, Train *dst, Train *original_src, Train *src, bool check_limit)
1160 {
1161 /* Check whether we may actually construct the trains. */
1167 /* Check whether we need to build a new train. */
1169 }
1171 /**
1172 * Arrange the trains in the wanted way.
1173 * @param dst_head The destination chain of the to be moved vehicle.
1174 * @param dst The destination for the to be moved vehicle.
1175 * @param src_head The source chain of the to be moved vehicle.
1176 * @param src The to be moved vehicle.
1177 * @param move_chain Whether to move all vehicles after src or not.
1178 */
1179 static void ArrangeTrains(Train **dst_head, Train *dst, Train **src_head, Train *src, bool move_chain)
1180 {
1181 /* First determine the front of the two resulting trains */
1183 /* If we aren't moving part(s) to a new train, we are just moving the
1184 * front back and there is not destination head. */
1187 /* If we are moving to a new train the head of the move train would become
1188 * the head of the new vehicle. */
1190 }
1193 /* If we are moving the front of a train then we are, in effect, creating
1194 * a new head for the train. Point to that. Unless we are moving the whole
1195 * train in which case there is not 'source' train anymore.
1196 * In case we are a multiheaded part we want the complete thing to come
1197 * with us, so src->GetNextUnit(), however... when we are e.g. a wagon
1198 * that is followed by a rear multihead we do not want to include that. */
1201 }
1203 /* Now it's just simply removing the part that we are going to move from the
1204 * source train and *if* the destination is a not a new train add the chain
1205 * at the destination location. */
1209 /* Now normalise the dual heads, that is move the dual heads around in such
1210 * a way that the head and rear of a dual head are in the same train */
1213 }
1215 /**
1216 * Normalise the head of the train again, i.e. that is tell the world that
1217 * we have changed and update all kinds of variables.
1218 * @param head the train to update.
1219 */
1221 {
1222 /* Not much to do! */
1225 /* Tell the 'world' the train changed. */
1229 /* Not a front engine, i.e. a free wagon chain. No need to do more. */
1232 /* Update the refit button and window */
1236 /* If we don't have a unit number yet, set one. */
1239 }
1241 /**
1242 * Move a rail vehicle around inside the depot.
1243 * @param tile unused
1244 * @param flags type of operation
1245 * Note: DC_AUTOREPLACE is set when autoreplace tries to undo its modifications or moves vehicles to temporary locations inside the depot.
1246 * @param p1 various bitstuffed elements
1247 * - p1 (bit 0 - 19) source vehicle index
1248 * - p1 (bit 20) move all vehicles following the source vehicle
1249 * - p1 (bit 21) this is a virtual vehicle (for creating TemplateVehicles)
1250 * @param p2 what wagon to put the source wagon AFTER, XXX - INVALID_VEHICLE to make a new line
1251 * @param text unused
1252 * @return the cost of this operation or an error
1253 */
1254 CommandCost CmdMoveRailVehicle(TileIndex tile, DoCommandFlag flags, uint32 p1, uint32 p2, const char *text)
1255 {
1266 /* Do not allow moving crashed vehicles inside the depot, it is likely to cause asserts later */
1269 /* if nothing is selected as destination, try and find a matching vehicle to drag to. */
1280 /* Do not allow appending to crashed vehicles, too */
1282 }
1284 /* if an articulated part is being handled, deal with its parent vehicle */
1289 }
1291 /* don't move the same vehicle.. */
1294 /* locate the head of the two chains */
1302 /* Now deal with articulated part of destination wagon */
1306 }
1310 /* When moving all wagons, we can't have the same src_head and dst_head */
1313 /* When moving a multiheaded part to be place after itself, bail out. */
1314 if (!move_chain && dst != NULL && dst->IsRearDualheaded() && src == dst->other_multiheaded_part) return CommandCost();
1316 /* Check if all vehicles in the source train are stopped inside a depot. */
1317 /* Do this check only if the vehicle to be moved is non-virtual */
1319 if (!src_head->IsStoppedInDepot()) return_cmd_error(STR_ERROR_TRAINS_CAN_ONLY_BE_ALTERED_INSIDE_A_DEPOT);
1321 /* Check if all vehicles in the destination train are stopped inside a depot. */
1322 /* Do this check only if the destination vehicle is non-virtual */
1324 if (dst_head != NULL && !dst_head->IsStoppedInDepot()) return_cmd_error(STR_ERROR_TRAINS_CAN_ONLY_BE_ALTERED_INSIDE_A_DEPOT);
1326 /* First make a backup of the order of the trains. That way we can do
1327 * whatever we want with the order and later on easily revert. */
1328 TrainList original_src;
1329 TrainList original_dst;
1334 /* Also make backup of the original heads as ArrangeTrains can change them.
1335 * For the destination head we do not care if it is the same as the source
1336 * head because in that case it's just a copy. */
1340 /* We want this information from before the rearrangement, but execute this after the validation.
1341 * original_src_head can't be NULL; src is by definition != NULL, so src_head can't be NULL as
1342 * src->GetFirst() always yields non-NULL, so eventually original_src_head != NULL as well. */
1344 bool original_dst_head_front_engine = original_dst_head != NULL && original_dst_head->IsFrontEngine();
1346 /* (Re)arrange the trains in the wanted arrangement. */
1350 /* If the autoreplace flag is set we do not need to test for the validity
1351 * because we are going to revert the train to its original state. As we
1352 * assume the original state was correct autoreplace can skip this. */
1353 CommandCost ret = ValidateTrains(original_dst_head, dst_head, original_src_head, src_head, true);
1355 /* Restore the train we had. */
1359 }
1360 }
1362 /* do it? */
1364 /* Remove old heads from the statistics */
1368 /* First normalise the sub types of the chains. */
1372 /* There are 14 different cases:
1373 * 1) front engine gets moved to a new train, it stays a front engine.
1374 * a) the 'next' part is a wagon that becomes a free wagon chain.
1375 * b) the 'next' part is an engine that becomes a front engine.
1376 * c) there is no 'next' part, nothing else happens
1377 * 2) front engine gets moved to another train, it is not a front engine anymore
1378 * a) the 'next' part is a wagon that becomes a free wagon chain.
1379 * b) the 'next' part is an engine that becomes a front engine.
1380 * c) there is no 'next' part, nothing else happens
1381 * 3) front engine gets moved to later in the current train, it is not a front engine anymore.
1382 * a) the 'next' part is a wagon that becomes a free wagon chain.
1383 * b) the 'next' part is an engine that becomes a front engine.
1384 * 4) free wagon gets moved
1385 * a) the 'next' part is a wagon that becomes a free wagon chain.
1386 * b) the 'next' part is an engine that becomes a front engine.
1387 * c) there is no 'next' part, nothing else happens
1388 * 5) non front engine gets moved and becomes a new train, nothing else happens
1389 * 6) non front engine gets moved within a train / to another train, nothing hapens
1390 * 7) wagon gets moved, nothing happens
1391 */
1393 /* Cases #2 and #3: the front engine gets trashed. */
1402 /* Delete orders, group stuff and the unit number as we're not the
1403 * front of any vehicle anymore. */
1410 }
1411 }
1413 /* We weren't a front engine but are becoming one. So
1414 * we should be put in the default group. */
1418 }
1420 /* Add new heads to statistics */
1424 /* Handle 'new engine' part of cases #1b, #2b, #3b, #4b and #5 in NormaliseTrainHead. */
1431 }
1436 }
1440 }
1445 /* We are undoubtedly changing something in the depot and train list. */
1446 /* But only if the moved vehicle is not virtual */
1452 }
1454 /* We don't want to execute what we're just tried. */
1457 }
1460 }
1462 /**
1463 * Sell a (single) train wagon/engine.
1464 * @param flags type of operation
1465 * @param t the train wagon to sell
1466 * @param data the selling mode
1467 * - data = 0: only sell the single dragged wagon/engine (and any belonging rear-engines)
1468 * - data = 1: sell the vehicle and all vehicles following it in the chain
1469 * if the wagon is dragged, don't delete the possibly belonging rear-engine to some front
1470 * @param user the user for the order backup.
1471 * @return the cost of this operation or an error
1472 */
1474 {
1475 /* Sell a chain of vehicles or not? */
1483 /* First make a backup of the order of the train. That way we can do
1484 * whatever we want with the order and later on easily revert. */
1485 TrainList original;
1488 /* We need to keep track of the new head and the head of what we're going to sell. */
1492 /* Split the train in the wanted way. */
1495 /* We don't need to validate the second train; it's going to be sold. */
1498 /* Restore the train we had. */
1501 }
1504 /* Restore the train we had. */
1507 }
1512 /* do it? */
1514 /* First normalise the sub types of the chain. */
1517 if (v == first && v->IsEngine() && !sell_chain && new_head != NULL && new_head->IsFrontEngine()) {
1518 /* We are selling the front engine. In this case we want to
1519 * 'give' the order, unit number and such to the new head. */
1524 /* Copy other important data from the front engine */
1529 }
1531 /* We need to update the information about the train. */
1534 /* We are undoubtedly changing something in the depot and train list. */
1535 /* Unless its a virtual train */
1541 }
1543 /* Actually delete the sold 'goods' */
1546 /* We don't want to execute what we're just tried. */
1548 }
1551 }
1554 {
1555 /* Set common defaults. */
1566 {
1567 /* x, y */
1572 };
1576 /* For all straight directions, move the bound box to the centre of the vehicle, but keep the size. */
1583 /* Shorten southern corner of the bounding box according the vehicle length
1584 * and center the bounding box on the vehicle. */
1597 /* Move northern corner of the bounding box down according to vehicle length
1598 * and center the bounding box on the vehicle. */
1613 }
1614 }
1615 }
1617 /**
1618 * Mark a train as stuck and stop it if it isn't stopped right now.
1619 * @param v %Train to mark as being stuck.
1620 */
1622 {
1624 /* It is the first time the problem occurred, set the "train stuck" flag. */
1630 /* Stop train */
1639 }
1640 }
1642 /**
1643 * Swap the two up/down flags in two ways:
1644 * - Swap values of \a swap_flag1 and \a swap_flag2, and
1645 * - If going up previously (#GVF_GOINGUP_BIT set), the #GVF_GOINGDOWN_BIT is set, and vice versa.
1646 * @param swap_flag1 [inout] First train flag.
1647 * @param swap_flag2 [inout] Second train flag.
1648 */
1650 {
1654 /* Clear the flags */
1662 /* Reverse the rail-flags (if needed) */
1667 }
1673 }
1677 }
1681 }
1682 }
1684 /**
1685 * Updates some variables after swapping the vehicle.
1686 * @param v swapped vehicle
1687 */
1689 {
1690 /* Reverse the direction. */
1693 /* Call the proper EnterTile function unless we are in a wormhole. */
1697 /* VehicleEnter_TunnelBridge() sets TRACK_BIT_WORMHOLE when the vehicle
1698 * is on the last bit of the bridge head (frame == TILE_SIZE - 1).
1699 * If we were swapped with such a vehicle, we have set TRACK_BIT_WORMHOLE,
1700 * when we shouldn't have. Check if this is the case. */
1705 /* We have just left the wormhole, possibly set the
1706 * "goingdown" bit. UpdateInclination() can be used
1707 * because we are at the border of the tile. */
1711 }
1712 }
1713 }
1718 }
1720 /**
1721 * Swap vehicles \a l and \a r in consist \a v, and reverse their direction.
1722 * @param v Consist to change.
1723 * @param l %Vehicle index in the consist of the first vehicle.
1724 * @param r %Vehicle index in the consist of the second vehicle.
1725 */
1727 {
1730 /* locate vehicles to swap */
1735 /* swap the hidden bits */
1736 {
1740 }
1754 /* Swap GVF_GOINGUP_BIT/GVF_GOINGDOWN_BIT.
1755 * This is a little bit redundant way, a->gv_flags will
1756 * be (re)set twice, but it reduces code duplication */
1759 }
1760 }
1763 /**
1764 * Check if the vehicle is a train
1765 * @param v vehicle on tile
1766 * @return v if it is a train, NULL otherwise
1767 */
1769 {
1771 }
1774 /**
1775 * Checks if a train is approaching a rail-road crossing
1776 * @param v vehicle on tile
1777 * @param data tile with crossing we are testing
1778 * @return v if it is approaching a crossing, NULL otherwise
1779 */
1781 {
1792 }
1795 /**
1796 * Finds a vehicle approaching rail-road crossing
1797 * @param tile tile to test
1798 * @return true if a vehicle is approaching the crossing
1799 * @pre tile is a rail-road crossing
1800 */
1802 {
1814 }
1816 /** Check if the crossing should be closed
1817 * @return train on crossing || train approaching crossing || reserved
1818 */
1820 {
1821 return HasCrossingReservation(tile) || HasVehicleOnPos(tile, NULL, &TrainOnTileEnum) || TrainApproachingCrossing(tile);
1822 }
1824 /**
1825 * Sets correct crossing state
1826 * @param tile tile to update
1827 * @param sound should we play sound?
1828 * @param is_forced force set the crossing state to that of forced_state
1829 * @param forced_state the crossing state to set when using is_forced
1830 * @pre tile is a rail-road crossing
1831 */
1832 static void UpdateLevelCrossingTile(TileIndex tile, bool sound, bool is_forced, bool forced_state)
1833 {
1841 }
1852 }
1853 }
1856 }
1857 }
1859 /**
1860 * Cycles the adjacent crossings and sets their state
1861 * @param tile tile to update
1862 * @param sound should we play sound?
1863 * @param force_close force close the crossing
1864 */
1866 {
1874 for (TileIndex t = tile; !forced_state && IsLevelCrossingTile(t) && GetCrossingRoadAxis(t) == axis; t = TileAddByDiagDir(t, dir)) {
1876 }
1877 for (TileIndex t = TileAddByDiagDir(tile, reverse_dir); !forced_state && IsLevelCrossingTile(t) && GetCrossingRoadAxis(t) == axis; t = TileAddByDiagDir(t, reverse_dir)) {
1879 }
1882 for (TileIndex t = TileAddByDiagDir(tile, dir); IsLevelCrossingTile(t) && GetCrossingRoadAxis(t) == axis; t = TileAddByDiagDir(t, dir)) {
1884 }
1885 for (TileIndex t = TileAddByDiagDir(tile, reverse_dir); IsLevelCrossingTile(t) && GetCrossingRoadAxis(t) == axis; t = TileAddByDiagDir(t, reverse_dir)) {
1887 }
1888 }
1891 /**
1892 * Bars crossing and plays ding-ding sound if not barred already
1893 * @param tile tile with crossing
1894 * @pre tile is a rail-road crossing
1895 */
1897 {
1900 }
1901 }
1904 /**
1905 * Advances wagons for train reversing, needed for variable length wagons.
1906 * This one is called before the train is reversed.
1907 * @param v First vehicle in chain
1908 */
1910 {
1922 /* do not update images now
1923 * negative differential will be handled in AdvanceWagonsAfterSwap() */
1928 }
1929 }
1932 /**
1933 * Advances wagons for train reversing, needed for variable length wagons.
1934 * This one is called after the train is reversed.
1935 * @param v First vehicle in chain
1936 */
1938 {
1939 /* first of all, fix the situation when the train was entering a depot */
1941 while (dep->Next() != NULL && (dep->track == TRACK_BIT_DEPOT || dep->Next()->track != TRACK_BIT_DEPOT)) {
1943 }
1948 /* 'pull' next wagon out of the depot, so we won't miss it (it could stay in depot forever) */
1954 for (int i = 0; i >= d; i--) TrainController(leave, NULL); // maybe move it, and maybe let another wagon leave
1955 }
1958 }
1965 /* We have to make sure all wagons that leave a depot because of train reversing are moved correctly
1966 * they have already correct spacing, so we have to make sure they are moved how they should */
1967 bool nomove = (dep == NULL); // If there is no vehicle leaving a depot, limit the number of wagons moved immediately.
1970 /* we reached vehicle (originally) in front of a depot, stop now
1971 * (we would move wagons that are already moved with new wagon length). */
1974 /* the last wagon was that one leaving a depot, so do not move it anymore */
1982 /* do not update images now */
1987 }
1988 }
1990 /**
1991 * Turn a train around.
1992 * @param v %Train to turn around.
1993 */
1995 {
1998 }
2002 /* Clear path reservation in front if train is not stuck. */
2005 /* Check if we were approaching a rail/road-crossing */
2008 /* count number of vehicles */
2013 /* swap start<>end, start+1<>end-1, ... */
2023 }
2029 /* recalculate cached data */
2032 /* update all images */
2035 /* update crossing we were approaching */
2038 /* maybe we are approaching crossing now, after reversal */
2042 /* If we are inside a depot after reversing, don't bother with path reserving. */
2044 /* Can't be stuck here as inside a depot is always a safe tile. */
2045 if (HasBit(v->flags, VRF_TRAIN_STUCK)) SetWindowWidgetDirty(WC_VEHICLE_VIEW, v->index, WID_VV_START_STOP);
2048 }
2050 /* We are inside tunnel/bidge with signals, reversing will close the entrance. */
2052 /* Flip signal on tunnel entrance tile red. */
2055 /* Clear counters. */
2059 }
2061 /* TrainExitDir does not always produce the desired dir for depots and
2062 * tunnels/bridges that is needed for UpdateSignalsOnSegment. */
2066 if (UpdateSignalsOnSegment(v->tile, dir, v->owner) == SIGSEG_PBS || _settings_game.pf.reserve_paths) {
2067 /* If we are currently on a tile with conventional signals, we can't treat the
2068 * current tile as a safe tile or we would enter a PBS block without a reservation. */
2073 /* If we are on a depot tile facing outwards, do not treat the current tile as safe. */
2074 if (IsRailDepotTile(v->tile) && TrackdirToExitdir(v->GetVehicleTrackdir()) == GetRailDepotDirection(v->tile)) first_tile_okay = false;
2076 if (IsRailStationTile(v->tile)) SetRailStationPlatformReservation(v->tile, TrackdirToExitdir(v->GetVehicleTrackdir()), true);
2078 /* Do a look-ahead now in case our current tile was already a safe tile. */
2081 /* Do not wait for a way out when we're still loading */
2083 }
2085 /* A train not inside a PBS block can't be stuck. */
2088 }
2089 }
2091 /**
2092 * Reverse train.
2093 * @param tile unused
2094 * @param flags type of operation
2095 * @param p1 train to reverse
2096 * @param p2 if true, reverse a unit in a train (needs to be in a depot)
2097 * @param text unused
2098 * @return the cost of this operation or an error
2099 */
2100 CommandCost CmdReverseTrainDirection(TileIndex tile, DoCommandFlag flags, uint32 p1, uint32 p2, const char *text)
2101 {
2109 /* turn a single unit around */
2111 if (v->IsMultiheaded() || HasBit(EngInfo(v->engine_type)->callback_mask, CBM_VEHICLE_ARTIC_ENGINE)) {
2113 }
2117 /* make sure the vehicle is stopped in the depot */
2120 }
2130 }
2132 /* turn the whole train around */
2136 /* Properly leave the station if we are loading and won't be loading anymore */
2141 /* not a station || different station --> leave the station */
2142 if (!IsTileType(last->tile, MP_STATION) || GetStationIndex(last->tile) != GetStationIndex(v->tile)) {
2144 }
2145 }
2147 /* We cancel any 'skip signal at dangers' here */
2158 }
2159 }
2160 }
2162 }
2164 /**
2165 * Force a train through a red signal
2166 * @param tile unused
2167 * @param flags type of operation
2168 * @param p1 train to ignore the red signal
2169 * @param p2 unused
2170 * @param text unused
2171 * @return the cost of this operation or an error
2172 */
2173 CommandCost CmdForceTrainProceed(TileIndex tile, DoCommandFlag flags, uint32 p1, uint32 p2, const char *text)
2174 {
2185 /* If we are forced to proceed, cancel that order.
2186 * If we are marked stuck we would want to force the train
2187 * to proceed to the next signal. In the other cases we
2188 * would like to pass the signal at danger and run till the
2189 * next signal we encounter. */
2190 t->force_proceed = t->force_proceed == TFP_SIGNAL ? TFP_NONE : HasBit(t->flags, VRF_TRAIN_STUCK) || t->IsChainInDepot() ? TFP_STUCK : TFP_SIGNAL;
2192 }
2195 }
2197 /**
2198 * Try to find a depot nearby.
2199 * @param v %Train that wants a depot.
2200 * @param max_distance Maximal search distance.
2201 * @return Information where the closest train depot is located.
2202 * @pre The given vehicle must not be crashed!
2203 */
2205 {
2218 }
2219 }
2221 /**
2222 * Locate the closest depot for this consist, and return the information to the caller.
2223 * @param location [out] If not \c NULL and a depot is found, store its location in the given address.
2224 * @param destination [out] If not \c NULL and a depot is found, store its index in the given address.
2225 * @param reverse [out] If not \c NULL and a depot is found, store reversal information in the given address.
2226 * @return A depot has been found.
2227 */
2229 {
2238 }
2240 /** Play a sound for a train leaving the station. */
2242 {
2244 SND_04_TRAIN,
2245 SND_0A_TRAIN_HORN,
2246 SND_0A_TRAIN_HORN,
2247 SND_47_MAGLEV_2,
2248 SND_41_MAGLEV
2249 };
2255 }
2257 /**
2258 * Check if the train is on the last reserved tile and try to extend the path then.
2259 * @param v %Train that needs its path extended.
2260 */
2262 {
2263 /* Don't do any look-ahead if path_backoff_interval is 255. */
2266 /* Exit if we are inside a depot. */
2270 /* Exit if we reached our destination depot. */
2276 /* If we reached our waypoint, make sure we see that. */
2277 if (IsRailWaypointTile(v->tile) && GetStationIndex(v->tile) == v->current_order.GetDestination()) ProcessOrders(v);
2283 /* Exit if the current order doesn't have a destination, but the train has orders. */
2289 }
2290 /* Exit if we are on a station tile and are going to stop. */
2291 if (IsRailStationTile(v->tile) && v->current_order.ShouldStopAtStation(v, GetStationIndex(v->tile))) return;
2295 /* On a tile with a red non-pbs signal, don't look ahead. */
2304 /* Next tile is not reserved. */
2307 /* If the next tile is a PBS signal, try to make a reservation. */
2311 }
2313 }
2314 }
2315 }
2316 }
2318 /**
2319 * Will the train stay in the depot the next tick?
2320 * @param v %Train to check.
2321 * @return True if it stays in the depot, false otherwise.
2322 */
2324 {
2325 /* bail out if not all wagons are in the same depot or not in a depot at all */
2328 }
2330 /* if the train got no power, then keep it in the depot */
2335 }
2342 SigSegState seg_state;
2345 /* force proceed was not pressed */
2349 }
2353 seg_state = _settings_game.pf.reserve_paths ? SIGSEG_PBS : UpdateSignalsOnSegment(v->tile, INVALID_DIAGDIR, v->owner);
2355 /* Full and no PBS signal in block or depot reserved, can't exit. */
2358 }
2360 seg_state = _settings_game.pf.reserve_paths ? SIGSEG_PBS : UpdateSignalsOnSegment(v->tile, INVALID_DIAGDIR, v->owner);
2361 }
2363 /* We are leaving a depot, but have to go to the exact same one; re-enter */
2365 /* We need to have a reservation for this to work. */
2370 }
2372 /* Only leave when we can reserve a path to our destination. */
2374 /* No path and no force proceed. */
2378 }
2381 if (_settings_client.gui.show_track_reservation) MarkTileDirtyByTile(v->tile, ZOOM_LVL_DRAW_MAP);
2400 }
2403 {
2411 slot--;
2417 }
2418 }
2419 }
2420 }
2425 }
2428 }
2430 static void HandleLastTunnelBridgeSignals(TileIndex tile, TileIndex end, DiagDirection dir, bool free)
2431 {
2433 /* Clearing last bridge signal. */
2436 TileIndex last_signal_tile = end + (TileOffsByDiagDir(dir) * _settings_game.construction.simulated_wormhole_signals * signal_offset);
2438 }
2440 }
2442 /* Open up the wormhole and clear m2. */
2445 }
2447 if (IsTunnelBridgeSignalSimulationEntrance(end) && GetTunnelBridgeSignalState(end) == SIGNAL_STATE_RED) {
2450 } else if (IsTunnelBridgeSignalSimulationEntrance(tile) && GetTunnelBridgeSignalState(tile) == SIGNAL_STATE_RED) {
2453 }
2454 }
2455 }
2458 {
2460 if (IsTunnelBridgeSignalSimulationExit(tile) && IsTunnelBridgePBS(tile)) SetTunnelBridgeSignalState(tile, SIGNAL_STATE_RED);
2461 }
2463 /**
2464 * Clear the reservation of \a tile that was just left by a wagon on \a track_dir.
2465 * @param v %Train owning the reservation.
2466 * @param tile Tile with reservation to clear.
2467 * @param track_dir Track direction to clear.
2468 */
2470 {
2474 /* Are we just leaving a tunnel/bridge? */
2485 }
2486 }
2488 /* Free the reservation only if no other train is on the tiles. */
2495 }
2499 }
2500 }
2501 }
2503 /* canceling reservation of entry ramp, due to reverse */
2507 }
2508 }
2509 }
2512 /* If the new tile is not a further tile of the same station, we
2513 * clear the reservation for the whole platform. */
2516 }
2518 /* Any other tile */
2520 }
2521 }
2523 /**
2524 * Free the reserved path in front of a vehicle.
2525 * @param v %Train owning the reserved path.
2526 * @param origin %Tile to start clearing (if #INVALID_TILE, use the current tile of \a v).
2527 * @param orig_td Track direction (if #INVALID_TRACKDIR, use the track direction of \a v).
2528 */
2530 {
2535 bool free_tile = tile != v->tile || !(IsRailStationTile(v->tile) || IsTileType(v->tile, MP_TUNNELBRIDGE));
2536 StationID station_id = IsRailStationTile(v->tile) ? GetStationIndex(v->tile) : INVALID_STATION;
2538 /* Can't be holding a reservation if we enter a depot. */
2541 /* Front engine is in a depot. We enter if some part is not in the depot. */
2544 }
2545 }
2546 /* Don't free reservation if it's not ours. */
2560 /* Conventional signal along trackdir: remove reservation and stop. */
2563 }
2566 /* Red PBS signal? Can't be our reservation, would be green then. */
2569 /* Turn the signal back to red. */
2573 /* notify logic signals of the state change */
2575 }
2576 } else if (HasSignalOnTrackdir(tile, ReverseTrackdir(td)) && IsOnewaySignal(tile, TrackdirToTrack(td))) {
2578 }
2579 }
2581 /* Don't free first station/bridge/tunnel if we are on it. */
2582 if (free_tile || (!(ft.m_is_station && GetStationIndex(ft.m_new_tile) == station_id) && !ft.m_is_tunnel && !ft.m_is_bridge)) ClearPathReservation(v, tile, td);
2585 }
2586 }
2595 };
2597 /**
2598 * Perform pathfinding for a train.
2599 *
2600 * @param v The train
2601 * @param tile The tile the train is about to enter
2602 * @param enterdir Diagonal direction the train is coming from
2603 * @param tracks Usable tracks on the new tile
2604 * @param path_found [out] Whether a path has been found or not.
2605 * @param do_track_reservation Path reservation is requested
2606 * @param dest [out] State and destination of the requested path
2607 * @return The best track the train should follow
2608 */
2609 static Track DoTrainPathfind(const Train *v, TileIndex tile, DiagDirection enterdir, TrackBits tracks, bool &path_found, bool do_track_reservation, PBSTileInfo *dest)
2610 {
2612 case VPF_NPF: return NPFTrainChooseTrack(v, tile, enterdir, tracks, path_found, do_track_reservation, dest);
2613 case VPF_YAPF: return YapfTrainChooseTrack(v, tile, enterdir, tracks, path_found, do_track_reservation, dest);
2616 }
2617 }
2619 /**
2620 * Extend a train path as far as possible. Stops on encountering a safe tile,
2621 * another reservation or a track choice.
2622 * @param v The train.
2623 * @param origin The tile from which the reservation have to be extended
2624 * @param new_tracks [out] Tracks to choose from when encountering a choice
2625 * @param enterdir [out] The direction from which the choice tile is to be entered
2626 * @return INVALID_TILE indicates that the reservation failed.
2627 */
2628 static PBSTileInfo ExtendTrainReservation(const Train *v, const PBSTileInfo &origin, TrackBits *new_tracks, DiagDirection *enterdir)
2629 {
2636 /* Possible signal tile. */
2637 if (HasOnewaySignalBlockingTrackdir(ft.m_new_tile, FindFirstTrackdir(ft.m_new_td_bits))) break;
2638 }
2643 }
2645 /* Station, depot or waypoint are a possible target. */
2646 bool target_seen = ft.m_is_station || (IsTileType(ft.m_new_tile, MP_RAILWAY) && !IsPlainRail(ft.m_new_tile));
2648 /* Choice found or possible target encountered.
2649 * On finding a possible target, we need to stop and let the pathfinder handle the
2650 * remaining path. This is because we don't know if this target is in one of our
2651 * orders, so we might cause pathfinding to fail later on if we find a choice.
2652 * This failure would cause a bogous call to TryReserveSafePath which might reserve
2653 * a wrong path not leading to our next destination. */
2654 if (HasReservedTracks(ft.m_new_tile, TrackdirBitsToTrackBits(TrackdirReachesTrackdirs(ft.m_old_td)))) break;
2656 /* If we did skip some tiles, backtrack to the first skipped tile so the pathfinder
2657 * actually starts its search at the first unreserved tile. */
2658 if (ft.m_tiles_skipped != 0) ft.m_new_tile -= TileOffsByDiagDir(ft.m_exitdir) * ft.m_tiles_skipped;
2660 /* Choice found, path valid but not okay. Save info about the choice tile as well. */
2664 }
2672 /* Safe position is all good, path valid and okay. */
2674 }
2677 }
2680 /* End of line, path valid and okay. */
2682 }
2684 /* Sorry, can't reserve path, back out. */
2695 }
2702 }
2704 /* Path invalid. */
2706 }
2708 /**
2709 * Try to reserve any path to a safe tile, ignoring the vehicle's destination.
2710 * Safe tiles are tiles in front of a signal, depots and station tiles at end of line.
2711 *
2712 * @param v The vehicle.
2713 * @param tile The tile the search should start from.
2714 * @param td The trackdir the search should start from.
2715 * @param override_railtype Whether all physically compatible railtypes should be followed.
2716 * @return True if a path to a safe stopping tile could be reserved.
2717 */
2718 static bool TryReserveSafeTrack(const Train *v, TileIndex tile, Trackdir td, bool override_tailtype)
2719 {
2725 }
2726 }
2728 /** This class will save the current order of a vehicle and restore it on destruction. */
2732 Order old_order;
2733 TileIndex old_dest_tile;
2734 StationID old_last_station_visited;
2735 VehicleOrderID index;
2746 {
2747 }
2750 {
2755 }
2757 /**
2758 * Set the current vehicle order to the next order in the order list.
2759 * @param skip_first Shall the first (i.e. active) order be skipped?
2760 * @return True if a suitable next order could be found.
2761 */
2763 {
2769 bool has_manual_depot_order = (HasBit(v->vehicle_flags, VF_SHOULD_GOTO_DEPOT) || HasBit(v->vehicle_flags, VF_SHOULD_SERVICE_AT_DEPOT));
2772 /* Wrap around. */
2780 /* Skip service in depot orders when the train doesn't need service. */
2781 if ((order->GetDepotOrderType() & ODTFB_SERVICE) && !(this->v->NeedsServicing() || has_manual_depot_order)) break;
2782 FALLTHROUGH;
2790 depth++;
2792 /* Don't increment next, so no break here. */
2794 }
2796 }
2799 }
2800 /* Don't increment inside the while because otherwise conditional
2801 * orders can lead to an infinite loop. */
2803 depth++;
2807 }
2808 };
2810 /**
2811 * This is called to retrieve the previous signal, as required
2812 * This is not run all the time as it is somewhat expensive and most restrictions will not test for the previous signal
2813 */
2814 static TileIndex ChooseTrainTrackTraceRestrictPreviousSignalCallback(const Train *v, const void *)
2815 {
2816 // scan forwards from vehicle position, for the case that train is waiting at/approaching PBS signal
2826 // found PBS signal
2829 // wrong type of signal
2831 }
2832 }
2834 // advance to next tile
2836 // ran out of track
2838 }
2841 // reached a junction tile
2843 }
2847 }
2848 }
2851 {
2854 const TraceRestrictProgram *prog = GetExistingTraceRestrictProgram(tile, TrackdirToTrack(trackdir));
2856 TraceRestrictProgramResult out;
2857 prog->Execute(v, TraceRestrictProgramInput(tile, trackdir, &ChooseTrainTrackTraceRestrictPreviousSignalCallback, nullptr), out);
2860 }
2861 }
2862 }
2863 }
2866 }
2868 /**
2869 * Choose a track and reserve if necessary
2870 *
2871 * @param v The vehicle
2872 * @param tile The tile from which to start
2873 * @param enterdir
2874 * @param tracks
2875 * @param force_res Force a reservation to be made
2876 * @param p_got_reservation [out] If the train has a reservation
2877 * @param mark_stuck The train has to be marked as stuck when needed
2878 * @return The track the train should take.
2879 */
2880 static Track ChooseTrainTrack(Train *v, TileIndex tile, DiagDirection enterdir, TrackBits tracks, bool force_res, bool *p_got_reservation, bool mark_stuck)
2881 {
2890 /* Don't use tracks here as the setting to forbid 90 deg turns might have been switched between reservation and now. */
2891 TrackBits res_tracks = (TrackBits)(GetReservedTrackbits(tile) & DiagdirReachesTracks(enterdir));
2892 /* Do we have a suitable reserved track? */
2895 /* Quick return in case only one possible track is available */
2898 /* We need to check for signals only here, as a junction tile can't have signals. */
2899 if (track != INVALID_TRACK && HasPbsSignalOnTrackdir(tile, TrackEnterdirToTrackdir(track, enterdir))) {
2903 TraceRestrictProgramResult out;
2910 }
2911 }
2912 }
2919 /* notify logic signals of the state change */
2923 }
2925 }
2933 /* Reservation failed? */
2936 SetSignalStateByTrackdir(tile, TrackEnterdirToTrackdir(best_track, enterdir), SIGNAL_STATE_RED);
2938 /* notify logic signals of the state change */
2940 }
2942 }
2950 /* Got a valid reservation that ends at a safe target, quick exit. */
2955 }
2956 }
2957 }
2959 /* Check if the train needs service here, so it has a chance to always find a depot.
2960 * Also check if the current order is a service order so we don't reserve a path to
2961 * the destination but instead to the next one if service isn't needed. */
2963 if (v->current_order.IsType(OT_DUMMY) || v->current_order.IsType(OT_CONDITIONAL) || v->current_order.IsType(OT_GOTO_DEPOT)) ProcessOrders(v);
2964 }
2966 /* Save the current train order. The destructor will restore the old order on function exit. */
2969 /* If the current tile is the destination of the current order and
2970 * a reservation was requested, advance to the next order.
2971 * Don't advance on a depot order as depots are always safe end points
2972 * for a path and no look-ahead is necessary. This also avoids a
2973 * problem with depot orders not part of the order list when the
2974 * order list itself is empty. */
2977 } else if (v->current_order.IsType(OT_LOADING) || (!v->current_order.IsType(OT_GOTO_DEPOT) && (
2982 }
2985 /* Pathfinders are able to tell that route was only 'guessed'. */
2989 Track next_track = DoTrainPathfind(v, new_tile, dest_enterdir, tracks, path_found, do_track_reservation, &res_dest);
2992 }
2994 /* No track reservation requested -> finished. */
2997 /* A path was found, but could not be reserved. */
3002 }
3004 /* No possible reservation target found, we are probably lost. */
3006 /* Try to find any safe destination. */
3012 // Use p_got_reservation because were going to return
3018 }
3020 }
3024 /* Reservation target found and free, check if it is safe. */
3025 while (!IsSafeWaitingPosition(v, res_dest.tile, res_dest.trackdir, true, _settings_game.pf.forbid_90_deg)) {
3026 /* Extend reservation until we have found a safe position. */
3029 TrackBits reachable = TrackdirBitsToTrackBits((TrackdirBits)(GetTileTrackStatus(next_tile, TRANSPORT_RAIL, 0))) & DiagdirReachesTracks(exitdir);
3032 }
3034 /* Get next order with destination. */
3036 PBSTileInfo cur_dest;
3042 /* Path found, but could not be reserved. */
3048 }
3049 }
3050 /* No order or no safe position found, try any position. */
3056 }
3058 }
3066 // We reserved up to a LR signal, reserve past it as well. recursion
3067 ChooseTrainTrack(v, ft.m_new_tile, ft.m_exitdir, TrackdirBitsToTrackBits(ft.m_new_td_bits), force_res, NULL, mark_stuck);
3068 }
3069 }
3070 }
3078 }
3080 /**
3081 * Try to reserve a path to a safe position.
3082 *
3083 * @param v The vehicle
3084 * @param mark_as_stuck Should the train be marked as stuck on a failed reservation?
3085 * @param first_tile_okay True if no path should be reserved if the current tile is a safe position.
3086 * @return True if a path could be reserved.
3087 */
3089 {
3092 /* We have to handle depots specially as the track follower won't look
3093 * at the depot tile itself but starts from the next tile. If we are still
3094 * inside the depot, a depot reservation can never be ours. */
3100 /* Depot not reserved, but the next tile might be. */
3102 if (HasReservedTracks(next_tile, DiagdirReachesTracks(GetRailDepotDirection(v->tile)))) return false;
3103 }
3104 }
3108 // prevent any attempt to reserve the wrong way onto a tunnel/bridge exit
3110 }
3114 /* The path we are driving on is already blocked by some other train.
3115 * This can only happen in certain situations when mixing path and
3116 * block signals or when changing tracks and/or signals.
3117 * Exit here as doing any further reservations will probably just
3118 * make matters worse. */
3122 }
3123 /* If we have a reserved path and the path ends at a safe tile, we are finished already. */
3125 /* Can't be stuck then. */
3126 if (HasBit(v->flags, VRF_TRAIN_STUCK)) SetWindowWidgetDirty(WC_VEHICLE_VIEW, v->index, WID_VV_START_STOP);
3129 }
3131 /* If we are in a depot, tentatively reserve the depot. */
3134 if (_settings_client.gui.show_track_reservation) MarkTileDirtyByTile(v->tile, ZOOM_LVL_DRAW_MAP);
3135 }
3139 TrackBits reachable = TrackdirBitsToTrackBits(TrackStatusToTrackdirBits(GetTileTrackStatus(new_tile, TRANSPORT_RAIL, 0)) & DiagdirReachesTrackdirs(exitdir));
3141 if (_settings_game.pf.forbid_90_deg) reachable &= ~TrackCrossesTracks(TrackdirToTrack(origin.trackdir));
3147 /* Free the depot reservation as well. */
3148 if (v->track == TRACK_BIT_DEPOT && v->tile == origin.tile) SetDepotReservation(v->tile, false);
3150 }
3155 }
3158 }
3162 {
3167 }
3176 }
3177 }
3179 /**
3180 * Get the location of the next station to visit.
3181 * @param station Next station to visit.
3182 * @return Location of the new station.
3183 */
3185 {
3190 /* The destination station has no trainstation tiles. */
3193 }
3196 }
3198 /** Goods at the consist have changed, update the graphics, cargo, and acceleration. */
3200 {
3207 /* need to update acceleration and cached values since the goods on the train changed. */
3210 }
3212 /**
3213 * This function looks at the vehicle and updates its speed (cur_speed
3214 * and subspeed) variables. Furthermore, it returns the distance that
3215 * the train can drive this tick. #Vehicle::GetAdvanceDistance() determines
3216 * the distance to drive before moving a step on the map.
3217 * @return distance to drive.
3218 */
3220 {
3224 return this->DoUpdateSpeed(this->acceleration * (this->GetAccelerationStatus() == AS_BRAKE ? -4 : 2), 0, this->GetCurrentMaxSpeed());
3227 return this->DoUpdateSpeed(this->GetAcceleration(), this->GetAccelerationStatus() == AS_BRAKE ? 0 : 2, this->GetCurrentMaxSpeed());
3228 }
3229 }
3231 /**
3232 * Trains enters a station, send out a news item if it is the first train, and start loading.
3233 * @param v Train that entered the station.
3234 * @param station Station visited.
3235 */
3237 {
3240 /* check if a train ever visited this station before */
3246 STR_NEWS_FIRST_TRAIN_ARRIVAL,
3249 st->index
3250 );
3253 }
3262 }
3264 /* Check if the vehicle is compatible with the specified tile */
3266 {
3269 }
3271 /** Data structure for storing engine speed changes of an acceleration type. */
3277 };
3279 /** Speed update fractions for each acceleration type. */
3281 /* normal accel */
3285 };
3287 /**
3288 * Modify the speed of the vehicle due to a change in altitude.
3289 * @param v %Train to update.
3290 * @param old_z Previous height.
3291 */
3293 {
3294 if (old_z == v->z_pos || _settings_game.vehicle.train_acceleration_model != AM_ORIGINAL) return;
3296 const AccelerationSlowdownParams *asp = &_accel_slowdown[GetRailTypeInfo(v->railtype)->acceleration_type];
3303 }
3304 }
3309 CHANGED_LR_PBS ///< A long reserve PBS signal
3310 };
3312 static TrainMovedChangeSignalEnum TrainMovedChangeSignal(Train* v, TileIndex tile, DiagDirection dir)
3313 {
3316 TrackdirBits tracks = TrackBitsToTrackdirBits(GetTrackBits(tile)) & DiagdirReachesTrackdirs(dir);
3318 if (UpdateSignalsOnSegment(tile, TrackdirToExitdir(trackdir), GetTileOwner(tile)) == SIGSEG_PBS && HasSignalOnTrackdir(tile, trackdir)) {
3319 /* A PBS block with a non-PBS signal facing us? */
3320 if (!IsPbsSignal(GetSignalType(tile, TrackdirToTrack(trackdir)))) return CHANGED_NORMAL_TO_PBS_BLOCK;
3323 }
3324 }
3326 if (IsTileType(tile, MP_TUNNELBRIDGE) && IsTunnelBridgeSignalSimulationExit(tile) && GetTunnelBridgeDirection(tile) == ReverseDiagDir(dir)) {
3329 }
3330 }
3333 }
3335 /** Tries to reserve track under whole train consist. */
3337 {
3348 }
3349 }
3350 }
3352 /**
3353 * The train vehicle crashed!
3354 * Update its status and other parts around it.
3355 * @param flooded Crash was caused by flooding.
3356 * @return Number of people killed.
3357 */
3359 {
3364 /* Remove the reserved path in front of the train if it is not stuck.
3365 * Also clear all reserved tracks the train is currently on. */
3370 /* ClearPathReservation will not free the wormhole exit
3371 * if the train has just entered the wormhole. */
3373 }
3374 }
3376 /* we may need to update crossing we were approaching,
3377 * but must be updated after the train has been marked crashed */
3381 /* Remove the loading indicators (if any) */
3383 }
3389 }
3391 /**
3392 * Marks train as crashed and creates an AI event.
3393 * Doesn't do anything if the train is crashed already.
3394 * @param v first vehicle of chain
3395 * @return number of victims (including 2 drivers; zero if train was already crashed)
3396 */
3398 {
3401 /* do not crash train twice */
3404 AI::NewEvent(v->owner, new ScriptEventVehicleCrashed(v->index, v->tile, ScriptEventVehicleCrashed::CRASH_TRAIN));
3405 Game::NewEvent(new ScriptEventVehicleCrashed(v->index, v->tile, ScriptEventVehicleCrashed::CRASH_TRAIN));
3406 }
3408 /* Try to re-reserve track under already crashed train too.
3409 * Crash() clears the reservation! */
3413 }
3415 /** Temporary data storage for testing collisions. */
3419 };
3421 /**
3422 * Collision test function.
3423 * @param v %Train vehicle to test collision with.
3424 * @param data %Train being examined.
3425 * @return \c NULL (always continue search)
3426 */
3428 {
3431 /* not a train or in depot */
3434 /* do not crash into trains of another company. */
3437 /* get first vehicle now to make most usual checks faster */
3440 /* can't collide with own wagons */
3446 /* Do fast calculation to check whether trains are not in close vicinity
3447 * and quickly reject trains distant enough for any collision.
3448 * Differences are shifted by 7, mapping range [-7 .. 8] into [0 .. 15]
3449 * Differences are then ORed and then we check for any higher bits */
3453 /* Slower check using multiplication */
3454 int min_diff = (Train::From(v)->gcache.cached_veh_length + 1) / 2 + (tcc->v->gcache.cached_veh_length + 1) / 2 - 1;
3457 /* Happens when there is a train under bridge next to bridge head */
3460 /* crash both trains */
3465 }
3467 /**
3468 * Checks whether the specified train has a collision with another vehicle. If
3469 * so, destroys this vehicle, and the other vehicle if its subtype has TS_Front.
3470 * Reports the incident in a flashy news item, modifies station ratings and
3471 * plays a sound.
3472 * @param v %Train to test.
3473 */
3475 {
3476 /* can't collide in depot */
3481 TrainCollideChecker tcc;
3485 /* find colliding vehicles */
3491 }
3493 /* any dead -> no crash */
3502 }
3505 {
3511 /* not front engine of a train, inside wormhole or depot, crashed */
3517 }
3519 /** Find train in front and keep distance between trains in tunnel/bridge. */
3521 {
3522 /* Don't look at wagons between front and back of train. */
3534 }
3538 }
3541 {
3547 /* Revert train if not going with tunnel direction. */
3551 }
3553 }
3554 /* Cover blind spot at end of tunnel bridge. */
3557 /* Revert train if not going with tunnel direction. */
3561 }
3563 }
3564 }
3567 }
3570 {
3575 TrackdirBits reserved = ft.m_new_td_bits & TrackBitsToTrackdirBits(GetReservedTrackbits(ft.m_new_tile));
3577 /* next tile is not reserved, so reserve the exit tile */
3579 }
3580 }
3585 }
3587 /** Simulate signals in tunnel - bridge. */
3589 {
3592 /* When not exit reverse train. */
3597 }
3598 SigSegState seg_state = (_settings_game.pf.reserve_paths || IsTunnelBridgePBS(tile)) ? SIGSEG_PBS : UpdateSignalsOnSegment(tile, INVALID_DIAGDIR, t->owner);
3602 if (ft.m_new_td_bits != TRACKDIR_BIT_NONE && KillFirstBit(ft.m_new_td_bits) == TRACKDIR_BIT_NONE) {
3605 /* immediately after the exit, there is a PBS signal, switch to PBS mode */
3607 }
3608 }
3609 }
3610 }
3611 if (seg_state == SIGSEG_FULL || (seg_state == SIGSEG_PBS && !CheckTrainStayInWormHolePathReserve(t, tile))) {
3615 }
3618 }
3621 {
3622 TileIndex tile;
3625 case DIR_NE: tile = TileVirtXY(v->x_pos + (TILE_SIZE * _settings_game.construction.simulated_wormhole_signals), v->y_pos); break;
3626 case DIR_SE: tile = TileVirtXY(v->x_pos, v->y_pos - (TILE_SIZE * _settings_game.construction.simulated_wormhole_signals) ); break;
3627 case DIR_SW: tile = TileVirtXY(v->x_pos - (TILE_SIZE * _settings_game.construction.simulated_wormhole_signals), v->y_pos); break;
3628 case DIR_NW: tile = TileVirtXY(v->x_pos, v->y_pos + (TILE_SIZE * _settings_game.construction.simulated_wormhole_signals)); break;
3629 }
3632 /* Flip signal on ramp. */
3633 if (IsTunnelBridgeSignalSimulationEntrance(tile) && GetTunnelBridgeSignalState(tile) == SIGNAL_STATE_RED) {
3636 }
3640 }
3641 }
3644 {
3650 /* ignore track_piece, 1 state per tile */
3657 else
3664 /* If rounded growth amount changes, redraw */
3667 }
3670 {
3674 }
3677 }
3679 }
3681 /**
3682 * Move a vehicle chain one movement stop forwards.
3683 * @param v First vehicle to move.
3684 * @param nomove Stop moving this and all following vehicles.
3685 * @param reverse Set to false to not execute the vehicle reversing. This does not change any other logic.
3686 * @return True if the vehicle could be moved forward, false otherwise.
3687 */
3689 {
3696 }
3701 }
3703 /* For every vehicle after and including the given vehicle */
3710 /* Not inside tunnel */
3712 /* Staying in the old tile */
3714 /* Inside depot */
3719 /* Not inside depot */
3721 /* Reverse when we are at the end of the track already, do not move to the new position */
3727 }
3729 /* The new position is the end of the platform */
3731 }
3732 }
3734 /* A new tile is about to be entered. */
3736 /* Determine what direction we're entering the new tile from */
3740 /* Get the status of the tracks in the new tile and mask
3741 * away the bits that aren't reachable. */
3746 TrackBits red_signals = TrackdirBitsToTrackBits(TrackStatusToRedSignals(ts) & reachable_trackdirs);
3750 /* We allow wagons to make 90 deg turns, because forbid_90_deg
3751 * can be switched on halfway a turn */
3753 }
3758 /* Check if the new tile constrains tracks that are compatible
3759 * with the current train, if not, bail out. */
3763 TrackBits chosen_track;
3765 /* Currently the locomotive is active. Determine which one of the
3766 * available tracks to choos/// e */
3772 /* For each signal we find decrease the counter by one.
3773 * We start at two, so the first signal we pass decreases
3774 * this to one, then if we reach the next signal it is
3775 * decreased to zero and we won't pass that new signal. */
3780 /* However, we do not want to be stopped by PBS signals
3781 * entered via the back. */
3784 }
3785 }
3787 /* Check if it's a red signal and that force proceed is not clicked. */
3789 /* In front of a red signal */
3792 /* Don't handle stuck trains here. */
3799 if (!_settings_game.pf.reverse_at_signals || ++v->wait_counter < _settings_game.pf.wait_oneway_signal * 20) return false;
3804 if (!_settings_game.pf.reverse_at_signals || ++v->wait_counter < _settings_game.pf.wait_twoway_signal * 73) {
3810 /* check if a train is waiting on the other side */
3812 }
3813 }
3815 /* If we would reverse but are currently in a PBS block and
3816 * reversing of stuck trains is disabled, don't reverse.
3817 * This does not apply if the reason for reversing is a one-way
3818 * signal blocking us, because a train would then be stuck forever. */
3819 if (!_settings_game.pf.reverse_at_signals && !HasOnewaySignalBlockingTrackdir(gp.new_tile, i) &&
3823 }
3828 if (IsPlainRailTile(gp.new_tile) && HasSignals(gp.new_tile) && IsRestrictedSignal(gp.new_tile)) {
3831 const TraceRestrictProgram *prog = GetExistingTraceRestrictProgram(gp.new_tile, TrackdirToTrack(dir));
3833 TraceRestrictProgramResult out;
3837 }
3838 }
3839 }
3840 }
3843 /* The wagon is active, simply follow the prev vehicle. */
3845 /* Choose the same track as prev */
3847 /* Vehicles entering tunnels enter the wormhole earlier than for bridges.
3848 * However, just choose the track into the wormhole. */
3853 }
3855 /* Choose the track that leads to the tile where prev is.
3856 * This case is active if 'prev' is already on the second next tile, when 'v' just enters the next tile.
3857 * I.e. when the tile between them has only space for a single vehicle like
3858 * 1) horizontal/vertical track tiles and
3859 * 2) some orientations of tunnel entries, where the vehicle is already inside the wormhole at 8/16 from the tile edge.
3860 * Is also the train just reversing, the wagon inside the tunnel is 'on' the tile of the opposite tunnel entry.
3861 */
3867 };
3871 }
3873 }
3875 /* Make sure chosen track is a valid track */
3881 /* Update XY to reflect the entrance to the new tile, and select the direction to use */
3887 /* Call the landscape function and tell it that the vehicle entered the tile */
3891 }
3894 /* If red signal stop. */
3896 if (IsTunnelBridgeSignalSimulationEntrance(gp.new_tile) && GetTunnelBridgeSignalState(gp.new_tile) == SIGNAL_STATE_RED) {
3900 }
3904 }
3905 /* Flip signal on tunnel entrance tile red. */
3908 }
3909 }
3918 /* notify logic signals of the state change */
3920 }
3922 /* Clear any track reservation when the last vehicle leaves the tile */
3929 }
3933 }
3935 /* We need to update signal status, but after the vehicle position hash
3936 * has been updated by UpdateInclination() */
3941 const AccelerationSlowdownParams *asp = &_accel_slowdown[GetRailTypeInfo(v->railtype)->acceleration_type];
3943 v->cur_speed -= (diff == DIRDIFF_45RIGHT || diff == DIRDIFF_45LEFT ? asp->small_turn : asp->large_turn) * v->cur_speed >> 8;
3944 }
3947 }
3952 /* If we are approaching a crossing that is reserved, play the sound now. */
3956 {
3958 bool is_no_sound_rail_type = (railTypeLabel == _planning_tracks_label || railTypeLabel == _pipeline_tracks_label || railTypeLabel == _wires_tracks_label);
3960 if (HasCrossingReservation(crossing) && _settings_client.sound.ambient && !is_no_sound_rail_type)
3962 }
3964 /* Always try to extend the reservation when entering a tile. */
3966 }
3969 /* The new position is the location where we want to stop */
3971 }
3972 }
3974 /* Handle signal simulation on tunnel/bridge. */
3976 if (old_tile != gp.new_tile && IsTunnelBridgeWithSignalSimulation(v->tile) && (v->IsFrontEngine() || v->Next() == NULL)) {
3978 if (v->IsFrontEngine() && v->force_proceed == 0 && IsTunnelBridgeSignalSimulationExit(v->tile))
3980 /* Entered wormhole set counters. */
3981 v->wait_counter = (TILE_SIZE * _settings_game.construction.simulated_wormhole_signals) - TILE_SIZE;
3983 }
3987 if (distance == 0) v->wait_counter = (TILE_SIZE * _settings_game.construction.simulated_wormhole_signals);
3990 /* Check if track in front is free and see if we can leave wormhole. */
4001 }
4002 /* flip signal in front to red on bridges*/
4006 }
4007 }
4008 }
4010 if (v->load_unload_ticks > 0 && distance == (TILE_SIZE * _settings_game.construction.simulated_wormhole_signals) - TILE_SIZE) HandleSignalBehindTrain(v, v->load_unload_ticks - 2);
4012 /* We left ramp into wormhole. */
4017 }
4018 }
4032 }
4033 }
4035 if (IsTileType(gp.new_tile, MP_TUNNELBRIDGE) && HasBit(VehicleEnterTile(v, gp.new_tile, gp.x, gp.y), VETS_ENTERED_WORMHOLE)) {
4036 /* Perform look-ahead on tunnel exit. */
4040 }
4041 /* Prevent v->UpdateInclination() being called with wrong parameters.
4042 * This could happen if the train was reversed inside the tunnel/bridge. */
4045 }
4051 /* update the Z position of the vehicle */
4055 /* This is the first vehicle in the train */
4057 }
4058 }
4061 }
4062 }
4064 /* update image of train, as well as delta XY */
4072 }
4074 /* update the Z position of the vehicle */
4075 int old_z = v->UpdateInclination(gp.new_tile != gp.old_tile, false, v->track == TRACK_BIT_WORMHOLE);
4078 /* This is the first vehicle in the train */
4080 }
4086 /* We are entering a block with PBS signals right now, but
4087 * not through a PBS signal. This means we don't have a
4088 * reservation right now. As a conventional signal will only
4089 * ever be green if no other train is in the block, getting
4090 * a path should always be possible. If the player built
4091 * such a strange network that it is not possible, the train
4092 * will be marked as stuck and the player has to deal with
4093 * the problem. */
4098 }
4102 {
4103 /* We went past a long reserve PBS signal. Try to extend the
4104 * reservation if reserving failed at another LR signal. */
4112 ChooseTrainTrack(v, ft.m_new_tile, ft.m_exitdir, TrackdirBitsToTrackBits(ft.m_new_td_bits), true, NULL, false);
4113 }
4114 }
4117 }
4119 }
4120 }
4122 /* Signals can only change when the first
4123 * (above) or the last vehicle moves. */
4128 if (IsTileType(gp.old_tile, MP_RAILWAY) && HasSignals(gp.old_tile) && IsRestrictedSignal(gp.old_tile)) {
4129 const TrackdirBits rev_tracks = TrackBitsToTrackdirBits(GetTrackBits(gp.old_tile)) & DiagdirReachesTrackdirs(ReverseDiagDir(enterdir));
4135 TraceRestrictProgramResult out;
4139 }
4140 }
4141 }
4142 }
4143 }
4145 /* Do not check on every tick to save some computing time. */
4146 if (v->IsFrontEngine() && v->tick_counter % _settings_game.pf.path_backoff_interval == 0) CheckNextTrainTile(v);
4147 }
4153 invalid_rail:
4154 /* We've reached end of line?? */
4157 reverse_train_direction:
4163 }
4166 }
4168 /**
4169 * Collect trackbits of all crashed train vehicles on a tile
4170 * @param v Vehicle passed from Find/HasVehicleOnPos()
4171 * @param data trackdirbits for the result
4172 * @return NULL to iterate over all vehicles on the tile.
4173 */
4175 {
4181 /* Vehicle is inside a wormhole, v->track contains no useful value then. */
4185 }
4186 }
4189 }
4191 /**
4192 * Deletes/Clears the last wagon of a crashed train. It takes the engine of the
4193 * train, then goes to the last wagon and deletes that. Each call to this function
4194 * will remove the last wagon of a crashed train. If this wagon was on a crossing,
4195 * or inside a tunnel/bridge, recalculate the signals as they might need updating
4196 * @param v the Vehicle of which last wagon is to be removed
4197 */
4199 {
4202 /* Go to the last wagon and delete the link pointing there
4203 * *u is then the one-before-last wagon, and *v the last
4204 * one which will physically be removed */
4210 /* Recalculate cached train properties */
4212 /* Update the depot window if the first vehicle is in depot -
4213 * if v == first, then it is updated in PreDestructor() */
4216 }
4218 }
4220 /* 'v' shouldn't be accessed after it has been deleted */
4229 /* Vehicle is inside a wormhole, v->track contains no useful value then. */
4231 }
4237 /* If there are still crashed vehicles on the tile, give the track reservation to them */
4241 /* It is important that these two are the first in the loop, as reservation cannot deal with every trackbit combination */
4243 Track t;
4245 }
4247 /* check if the wagon was on a road/rail-crossing */
4250 /* Update signals */
4262 }
4263 if (IsTunnelBridgeSignalSimulationEntrance(entrance) && GetTunnelBridgeSignalState(entrance) == SIGNAL_STATE_RED) {
4266 }
4267 }
4268 }
4273 }
4274 }
4276 /**
4277 * Rotate all vehicles of a (crashed) train chain randomly to animate the crash.
4278 * @param v First crashed vehicle.
4279 */
4281 {
4284 };
4287 /* We don't need to twist around vehicles if they're not visible */
4290 /* Refrain from updating the z position of the vehicle when on
4291 * a bridge, because UpdateInclination() will put the vehicle under
4292 * the bridge in that case */
4298 }
4299 }
4301 }
4303 /**
4304 * Handle a crashed train.
4305 * @param v First train vehicle.
4306 * @return %Vehicle chain still exists.
4307 */
4309 {
4314 }
4316 uint32 r;
4329 EV_EXPLOSION_SMALL);
4331 }
4333 }
4341 }
4344 }
4346 /** Maximum speeds for train that is broken down or approaching line end */
4349 };
4352 /**
4353 * Train is approaching line end, slow down and possibly reverse
4354 *
4355 * @param v front train engine
4356 * @param signal not line end, just a red signal
4357 * @param reverse Set to false to not execute the vehicle reversing. This does not change any other logic.
4358 * @return true iff we did NOT have to reverse
4359 */
4361 {
4362 /* Calc position within the current tile */
4366 /* for diagonal directions, 'x' will be 0..15 -
4367 * for other directions, it will be 1, 3, 5, ..., 15 */
4377 }
4379 /* Do not reverse when approaching red signal. Make sure the vehicle's front
4380 * does not cross the tile boundary when we do reverse, but as the vehicle's
4381 * location is based on their center, use half a vehicle's length as offset.
4382 * Multiply the half-length by two for straight directions to compensate that
4383 * we only get odd x offsets there. */
4384 if (!signal && x + (v->gcache.cached_veh_length + 1) / 2 * (IsDiagonalDirection(v->direction) ? 1 : 2) >= TILE_SIZE) {
4385 /* we are too near the tile end, reverse now */
4389 }
4391 /* slow down */
4397 }
4400 /**
4401 * Determines whether train would like to leave the tile
4402 * @param v train to test
4403 * @return true iff vehicle is NOT entering or inside a depot or tunnel/bridge
4404 */
4406 {
4407 /* Exit if inside a tunnel/bridge or a depot */
4412 /* entering a tunnel/bridge? */
4416 }
4418 /* entering a depot? */
4422 }
4425 }
4428 /**
4429 * Determines whether train is approaching a rail-road crossing
4430 * (thus making it barred)
4431 * @param v front engine of train
4432 * @return TileIndex of crossing the train is approaching, else INVALID_TILE
4433 * @pre v in non-crashed front engine
4434 */
4436 {
4445 /* not a crossing || wrong axis || unusable rail (wrong type or owner) */
4449 }
4452 }
4455 /**
4456 * Checks for line end. Also, bars crossing at next tile if needed
4457 *
4458 * @param v vehicle we are checking
4459 * @param reverse Set to false to not execute the vehicle reversing. This does not change any other logic.
4460 * @return true iff we did NOT have to reverse
4461 */
4463 {
4464 /* First, handle broken down train */
4474 }
4478 /* Determine the non-diagonal direction in which we will exit this tile */
4480 /* Calculate next tile */
4483 /* Determine the track status on the next tile */
4490 /* We are sure the train is not entering a depot, it is detected above */
4492 /* mask unreachable track bits if we are forbidden to do 90deg turns */
4496 }
4498 /* no suitable trackbits at all || unusable rail (wrong type or owner) */
4501 }
4503 /* approaching red signal */
4506 /* approaching a rail/road crossing? then make it red */
4510 }
4512 /* Calculate the summed up value of all parts of a train */
4514 {
4521 }
4524 {
4525 /* train has crashed? */
4528 }
4533 }
4535 /* train is broken down? */
4540 }
4542 /* exit if train is stopped */
4545 bool valid_order = !v->current_order.IsType(OT_NOTHING) && v->current_order.GetType() != OT_CONDITIONAL;
4554 /* Try to reserve a path when leaving the station as we
4555 * might not be marked as wanting a reservation, e.g.
4556 * when an overlength train gets turned around in a station. */
4560 if (UpdateSignalsOnSegment(v->tile, dir, v->owner) == SIGSEG_PBS || _settings_game.pf.reserve_paths) {
4562 }
4564 }
4574 /* We had no order but have an order now, do look ahead. */
4577 }
4579 /* Handle stuck trains. */
4583 /* Should we try reversing this tick if still stuck? */
4584 bool turn_around = v->wait_counter % (_settings_game.pf.wait_for_pbs_path * DAY_TICKS) == 0 && _settings_game.pf.reverse_at_signals;
4586 if (!turn_around && v->wait_counter % _settings_game.pf.path_backoff_interval != 0 && v->force_proceed == TFP_NONE) return true;
4588 /* Still stuck. */
4591 if (HasBit(v->flags, VRF_TRAIN_STUCK) && v->wait_counter > 2 * _settings_game.pf.wait_for_pbs_path * DAY_TICKS) {
4592 /* Show message to player. */
4596 }
4598 }
4599 /* Exit if force proceed not pressed, else reset stuck flag anyway. */
4604 }
4605 }
4611 }
4615 /* we need to invalidate the widget if we are stopping from 'Stopping 0 km/h' to 'Stopped' */
4617 /* If we manually stopped, we're not force-proceeding anymore. */
4620 }
4624 /* if the vehicle has speed 0, update the last_speed field. */
4628 /* Loop until the train has finished moving. */
4632 /* Don't continue to move if the train crashed. */
4634 /* Determine distance to next map position */
4637 /* No more moving this tick */
4641 /* Do not skip waypoints (incl. 'via' stations) when passing through at full speed. */
4647 }
4648 }
4650 }
4656 }
4658 if (v->progress == 0) v->progress = j; // Save unused spd for next time, if TrainController didn't set progress
4661 }
4663 /**
4664 * Get running cost for the train consist.
4665 * @return Yearly running costs.
4666 */
4668 {
4676 uint cost_factor = GetVehicleProperty(v, PROP_TRAIN_RUNNING_COST_FACTOR, e->u.rail.running_cost);
4679 /* Halve running cost for multiheaded parts */
4686 }
4688 /**
4689 * Update train vehicle data for a tick.
4690 * @return True if the vehicle still exists, false if it has ceased to exist (front of consists only).
4691 */
4693 {
4697 if (!((this->vehstatus & VS_STOPPED) || this->IsChainInDepot()) || this->cur_speed > 0) this->running_ticks++;
4705 /* Delete flooded standalone wagon chain */
4709 }
4710 }
4713 }
4715 /**
4716 * Check whether a train needs service, and if so, find a depot or service it.
4717 * @return v %Train to check.
4718 */
4720 {
4721 if (Company::Get(v->owner)->settings.vehicle.servint_trains == 0 || !v->NeedsAutomaticServicing()) return;
4725 }
4727 uint max_penalty;
4732 }
4735 /* Only go to the depot if it is not too far out of our way. */
4738 /* If we were already heading for a depot but it has
4739 * suddenly moved farther away, we continue our normal
4740 * schedule? */
4743 }
4745 }
4753 }
4759 }
4761 /** Update day counters of the train vehicle. */
4763 {
4775 /* update destination */
4779 }
4782 /* running costs */
4783 CommandCost cost(EXPENSES_TRAIN_RUN, this->GetRunningCost() * this->running_ticks / (DAYS_IN_YEAR * DAY_TICKS));
4792 }
4793 }
4794 }
4796 /**
4797 * Get the tracks of the train vehicle.
4798 * @return Current tracks of the vehicle.
4799 */
4801 {
4806 /* We'll assume the train is facing outwards */
4808 }
4811 /* train in tunnel or on bridge, so just use his direction and assume a diagonal track */
4813 }
4816 }
4819 /* Get the pixel-width of the image that is used for the train vehicle
4820 * @return: the image width number in pixel
4821 */
4823 {
4831 }
4836 }
4837 //printf(" refwid:%d gdiw.cachedvehlen(%d):%d ", reference_width, this->engine_type, this->gcache.cached_veh_length);
4839 }
4842 {
4878 // Make sure we set EVERYTHING to virtual, even articulated parts.
4881 }
4892 }
4895 {
4901 }
4902 }
4907 }
4908 }
4913 int num_vehicles = (e->u.rail.railveh_type == RAILVEH_MULTIHEAD ? 2 : 1) + CountArticulatedParts(eid, false);
4917 }
4960 }
4962 // Make sure we set EVERYTHING to virtual, even articulated parts.
4965 }
4974 }
4976 /**
4977 * Build a virtual train vehicle.
4978 * @param tile unused
4979 * @param flags type of operation
4980 * @param p1 the engine ID to build
4981 * @param p2 unused
4982 * @param text unused
4983 * @return the cost of this operation or an error
4984 */
4985 CommandCost CmdBuildVirtualRailVehicle(TileIndex tile, DoCommandFlag flags, uint32 p1, uint32 p2, const char *text)
4986 {
4991 }
5001 }
5002 }
5005 }
5007 /**
5008 * Replace a vehicle based on a template replacement order.
5009 * @param tile unused
5010 * @param flags type of operation
5011 * @param p1 the ID of the vehicle to replace.
5012 * @param p2 whether the vehicle should stay in the depot.
5013 * @param text unused
5014 * @return the cost of this operation or an error
5015 */
5016 CommandCost CmdTemplateReplaceVehicle(TileIndex tile, DoCommandFlag flags, uint32 p1, uint32 p2, const char *text)
5017 {
5039 }
5046 /* first some tests on necessity and sanity */
5060 // if a train shall keep its old refit, store the refit setting of its first vehicle
5066 }
5067 }
5068 }
5070 // TODO: set result status to success/no success before returning
5073 /* before returning, release incoming train first if 2nd param says so */
5076 }
5077 }
5087 }
5088 }
5089 }
5091 /* define replacement behavior */
5096 /// step 1: generate primary for newchain and generate remainder_chain
5097 // 1. primary of incoming might already fit the template
5098 // leave incoming's primary as is and move the rest to a free chain = remainder_chain
5099 // 2. needed primary might be one of incoming's member vehicles
5100 // 3. primary might be available as orphan vehicle in the depot
5101 // 4. we need to buy a new engine for the primary
5102 // all options other than 1. need to make sure to copy incoming's primary's status
5107 move_cost.AddCost(CmdMoveRailVehicle(tile, flags, remainder_chain->index | (1 << 20), INVALID_VEHICLE, 0));
5108 }
5110 // new_chain is the needed engine, move it to an empty spot in the depot
5112 move_cost.AddCost(DoCommand(tile, new_chain->index, INVALID_VEHICLE, flags, CMD_MOVE_RAIL_VEHICLE));
5114 }
5115 else if (reuseDepot && (tmp_chain = DepotContainsEngine(tile, eid, incoming)) && tmp_chain != NULL) { // 3
5117 move_cost.AddCost(DoCommand(tile, new_chain->index, INVALID_VEHICLE, flags, CMD_MOVE_RAIL_VEHICLE));
5119 }
5122 /* break up in case buying the vehicle didn't succeed */
5127 /* make sure the newly built engine is not attached to any free wagons inside the depot */
5128 move_cost.AddCost(DoCommand(tile, new_chain->index, INVALID_VEHICLE, flags, CMD_MOVE_RAIL_VEHICLE));
5129 /* prepare the remainder chain */
5131 }
5132 // If we bought a new engine or reused one from the depot, copy some parameters from the incoming primary engine
5138 // additionally, if we don't want to use the template refit, refit as incoming
5139 // the template refit will be set further down, if we use it at all
5142 DoCommand(new_chain->tile, new_chain->index, store_refit_ct | store_refit_csubt << 8 | 1 << 16 | (1 << 5), flags, cb);
5143 }
5145 }
5147 /// step 2: fill up newchain according to the template
5148 // foreach member of template (after primary):
5149 // 1. needed engine might be within remainder_chain already
5150 // 2. needed engine might be orphaned within the depot (copy status)
5151 // 3. we need to buy (again) (copy status)
5155 // 1. engine contained in remainder chain
5156 if ((tmp_chain = ChainContainsEngine(cur_tmpl->engine_type, remainder_chain)) && tmp_chain != NULL) {
5157 // advance remainder_chain (if necessary) to not lose track of it
5161 }
5162 // 2. engine contained somewhere else in the depot
5163 else if (reuseDepot && (tmp_chain = DepotContainsEngine(tile, cur_tmpl->engine_type, new_chain)) && tmp_chain != NULL) {
5165 }
5166 // 3. must buy new engine
5171 }
5175 }
5176 // TODO: is this enough ? might it be that we bought a new wagon here and it now has std refit ?
5180 DoCommand(tmp_chain->tile, tmp_chain->index, cur_tmpl->cargo_type | cur_tmpl->cargo_subtype << 8 | 1 << 16 | (1 << 5), flags, cb);
5181 // old
5182 // CopyWagonStatus(cur_tmpl, tmp_chain);
5185 DoCommand(tmp_chain->tile, tmp_chain->index, store_refit_ct | store_refit_csubt << 8 | 1 << 16 | (1 << 5), flags, cb);
5186 }
5187 }
5190 }
5191 }
5192 /* no replacement done */
5195 }
5196 /// step 3: reorder and neutralize the remaining vehicles from incoming
5197 // wagons remaining from remainder_chain should be filled up in as few freewagonchains as possible
5198 // each locos might be left as singular in the depot
5199 // neutralize each remaining engine's status
5201 // refit, only if the template option is set so
5204 }
5210 // point incoming to the newly created train so that starting/stopping from the calling function can be done
5219 }
5221 /* Redraw main gui for changed statistics */
5227 }