| blob | 386f3cdd10bdb560746938808e24fff7a201622a |
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);
55 bool TrainController(Train *v, Vehicle *nomove, bool reverse = true); // Also used in vehicle_sl.cpp.
65 {
67 }
69 /**
70 * Determine the side in which the train will leave the tile
71 *
72 * @param direction vehicle direction
73 * @param track vehicle track bits
74 * @return side of tile the train will leave
75 */
77 {
78 static const TrackBits state_dir_table[DIAGDIR_END] = { TRACK_BIT_RIGHT, TRACK_BIT_LOWER, TRACK_BIT_LEFT, TRACK_BIT_UPPER };
82 /* Determine the diagonal direction in which we will exit this tile */
85 }
88 }
91 /**
92 * Return the cargo weight multiplier to use for a rail vehicle
93 * @param cargo Cargo type to get multiplier for
94 * @return Cargo weight multiplier
95 */
97 {
100 }
102 /** Checks if lengths of all rail vehicles are valid. If not, shows an error message. */
104 {
122 }
123 /* Break so we warn only once for each train. */
125 }
126 }
127 }
128 }
129 }
130 }
132 /**
133 * Recalculates the cached stuff of a train. Should be called each time a vehicle is added
134 * to/removed from the chain, and when the game is loaded.
135 * Note: this needs to be called too for 'wagon chains' (in the depot, without an engine)
136 * @param allowed_changes Stuff that is allowed to change.
137 */
139 {
154 /* Check the this->first cache. */
157 /* update the 'first engine' */
163 /* Set user defined data to its default value */
167 }
170 /* Update user defined data (must be done before other properties) */
174 }
182 /* Cache wagon override sprite group. NULL is returned if there is none */
183 u->tcache.cached_override = GetWagonOverrideSpriteSet(u->engine_type, u->cargo_type, u->gcache.first_engine);
185 /* Reset colour map */
190 /* Update powered-wagon-status and visual effect */
195 /* wagon is powered */
199 }
202 /* Do not count powered wagons for the compatible railtypes, as wagons always
203 have railtype normal */
206 }
208 /* Some electric engines can be allowed to run on normal rail. It happens to all
209 * existing electric engines when elrails are disabled and then re-enabled */
213 }
215 /* max speed is the minimum of the speed limits of all vehicles in the consist */
216 if ((rvi_u->railveh_type != RAILVEH_WAGON || _settings_game.vehicle.wagon_speed_limits) && !UsesWagonOverride(u)) {
219 }
220 }
224 /* Update vehicle capacity. */
229 /* Verify capacity hasn't changed. */
230 if (new_cap != u->cargo_cap) ShowNewGrfVehicleError(u->engine_type, STR_NEWGRF_BROKEN, STR_NEWGRF_BROKEN_CAPACITY, GBUG_VEH_CAPACITY, true);
231 }
232 u->vcache.cached_cargo_age_period = GetVehicleProperty(u, PROP_TRAIN_CARGO_AGE_PERIOD, e_u->info.cargo_age_period);
234 /* check the vehicle length (callback) */
237 /* Use callback 36 */
242 }
244 /* Use callback 11 */
246 }
251 /* Update vehicle length. */
254 /* Verify length hasn't changed. */
256 }
261 }
263 /* store consist weight/max speed in cache */
268 /* 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) */
277 }
278 }
280 /**
281 * Get the stop location of (the center) of the front vehicle of a train at
282 * a platform of a station.
283 * @param station_id the ID of the station where we're stopping
284 * @param tile the tile where the vehicle currently is
285 * @param v the vehicle to get the stop location of
286 * @param station_ahead 'return' the amount of 1/16th tiles in front of the train
287 * @param station_length 'return' the station length in 1/16th tiles
288 * @return the location, calculated from the begin of the station to stop at.
289 */
290 int GetTrainStopLocation(StationID station_id, TileIndex tile, const Train *v, int *station_ahead, int *station_length)
291 {
296 /* Default to the middle of the station for stations stops that are not in
297 * the order list like intermediate stations when non-stop is disabled */
300 /* The train is longer than the station, make it stop at the far end of the platform */
302 } else if (v->current_order.IsType(OT_GOTO_STATION) && v->current_order.GetDestination() == station_id) {
304 }
306 /* The stop location of the FRONT! of the train */
322 }
324 /* Subtract half the front vehicle length of the train so we get the real
325 * stop location of the train. */
327 }
330 /**
331 * Computes train speed limit caused by curves
332 * @return imposed speed limit
333 */
335 {
345 /* first find the curve speed limit */
361 numcurve++;
365 }
366 }
368 }
370 /* if we have a 90 degree turn, fix the speed limit to 60 */
373 }
374 }
382 }
383 }
386 /* Apply the engine's rail type curve speed advantage, if it slowed by curves */
391 /* Apply max_speed bonus of 20% for a tilting train */
393 }
394 }
397 }
401 /**
402 * Calculates the maximum speed of the vehicle under its current conditions.
403 * @return Maximum speed of the vehicle.
404 */
406 {
418 /* Basic idea: Follow the track for 20 tiles or 3 signals (i.e. at most two signal blocks) looking for other trains. */
419 /* If we find one (that meets certain restrictions), we limit the max speed to the speed of that train. */
426 /* If we are on a depot or rail station tile stop searching */
430 /* Increment signal counter if we're on a signal */
433 HasSignalOnTrack(ft.m_new_tile, TrackBitsToTrack(TrackdirBitsToTrackBits(ft.m_new_td_bits)))) { ///< Tile has signal
434 num_signals++;
435 }
437 /* Check if tile has train/is reserved */
439 HasReservedTracks(ft.m_new_tile, TrackdirBitsToTrackBits(ft.m_new_td_bits))) { ///< Tile is reserved
440 Train* other_train = GetTrainForReservation(ft.m_new_tile, TrackBitsToTrack(TrackdirBitsToTrackBits(ft.m_new_td_bits)));
448 }
449 }
451 /* Decide what in direction to continue: reservation, straight or "first/only" direction. */
452 /* Abort if there's no reservation even though the tile contains multiple tracks. */
453 TrackdirBits reserved = ft.m_new_td_bits & TrackBitsToTrackdirBits(GetReservedTrackbits(ft.m_new_tile));
456 // There is a reservation to follow.
458 }
460 // Tile has more than one track and we have no reservation. Bail out.
462 }
464 // There was no reservation but there is only one direction to follow, so follow it.
466 }
468 num_tiles++;
470 }
472 /* Check that the ATC speed is sufficiently large.
473 Avoids assertion error in UpdateSpeed(). */
475 }
477 if (_settings_game.vehicle.train_acceleration_model == AM_REALISTIC && IsRailStationTile(this->tile)) {
484 /* The distance to go is whatever is still ahead of the train minus the
485 * distance from the train's stop location to the end of the platform */
494 }
498 }
499 }
500 }
503 if (_settings_game.vehicle.train_acceleration_model == AM_REALISTIC && u->track == TRACK_BIT_DEPOT) {
506 }
508 /* Vehicle is on the middle part of a bridge. */
511 }
512 }
516 }
518 /** Update acceleration of the train from the cached power and weight. */
520 {
527 }
529 /**
530 * Get the width of a train vehicle image in the GUI.
531 * @param offset Additional offset for positioning the sprite; set to NULL if not needed
532 * @return Width in pixels
533 */
535 {
543 }
548 }
550 }
553 {
555 return ((direction + _engine_sprite_add[spritenum]) & _engine_sprite_and[spritenum]) + _engine_sprite_base[spritenum];
556 }
558 /**
559 * Get the sprite to display the train.
560 * @param direction Direction of view/travel.
561 * @param image_type Visualisation context.
562 * @return Sprite to display.
563 */
564 void Train::GetImage(Direction direction, EngineImageType image_type, VehicleSpriteSeq *result) const
565 {
571 GetCustomVehicleSprite(this, (Direction)(direction + 4 * IS_CUSTOM_SECONDHEAD_SPRITE(spritenum)), image_type, result);
575 }
583 }
585 static void GetRailIcon(EngineID engine, bool rear_head, int &y, EngineImageType image_type, VehicleSpriteSeq *result)
586 {
596 }
598 }
601 }
606 }
608 void DrawTrainEngine(int left, int right, int preferred_x, int y, EngineID engine, PaletteID pal, EngineImageType image_type)
609 {
628 VehicleSpriteSeq seq;
637 }
638 }
640 /**
641 * Get the size of the sprite of a train sprite heading west, or both heads (used for lists).
642 * @param engine The engine to get the sprite from.
643 * @param[out] width The width of the sprite.
644 * @param[out] height The height of the sprite.
645 * @param[out] xoffs Number of pixels to shift the sprite to the right.
646 * @param[out] yoffs Number of pixels to shift the sprite downwards.
647 * @param image_type Context the sprite is used in.
648 */
649 void GetTrainSpriteSize(EngineID engine, uint &width, uint &height, int &xoffs, int &yoffs, EngineImageType image_type)
650 {
653 VehicleSpriteSeq seq;
667 /* Calculate values relative to an imaginary center between the two sprites. */
672 }
673 }
675 /**
676 * Build a railroad wagon.
677 * @param tile tile of the depot where rail-vehicle is built.
678 * @param flags type of operation.
679 * @param e the engine to build.
680 * @param ret[out] the vehicle that has been built.
681 * @return the cost of this operation or an error.
682 */
683 static CommandCost CmdBuildRailWagon(TileIndex tile, DoCommandFlag flags, const Engine *e, Vehicle **ret)
684 {
687 /* Check that the wagon can drive on the track in question */
742 /* Try to connect the vehicle to one of free chains of wagons. */
752 }
753 }
754 }
757 }
759 /** Move all free vehicles in the depot to the train */
761 {
769 }
770 }
771 }
774 {
802 /* Now we need to link the front and rear engines together */
805 }
807 /**
808 * Build a railroad vehicle.
809 * @param tile tile of the depot where rail-vehicle is built.
810 * @param flags type of operation.
811 * @param e the engine to build.
812 * @param data bit 0 prevents any free cars from being added to the train.
813 * @param ret[out] the vehicle that has been built.
814 * @return the cost of this operation or an error.
815 */
816 CommandCost CmdBuildRailVehicle(TileIndex tile, DoCommandFlag flags, const Engine *e, uint16 data, Vehicle **ret)
817 {
822 /* Check if depot and new engine uses the same kind of tracks *
823 * We need to see if the engine got power on the tile to avoid electric engines in non-electric depots */
866 v->SetServiceIntervalIsPercent(Company::Get(_current_company)->settings.vehicle.servint_ispercent);
879 }
884 if (!HasBit(data, 0) && !(flags & DC_AUTOREPLACE)) { // check if the cars should be added to the new vehicle
886 }
889 }
892 }
895 {
902 /* check so all vehicles in the line have the same engine. */
907 }
908 }
909 }
912 }
914 /** Helper type for lists/vectors of trains */
917 /**
918 * Make a backup of a train into a train list.
919 * @param list to make the backup in
920 * @param t the train to make the backup of
921 */
923 {
925 }
927 /**
928 * Restore the train from the backup list.
929 * @param list the train to restore.
930 */
932 {
933 /* No train, nothing to do. */
937 /* Iterate over the list and rebuild it. */
943 /* Make sure the head of the train is always the first in the chain. */
945 }
947 }
948 }
950 /**
951 * Remove the given wagon from its consist.
952 * @param part the part of the train to remove.
953 * @param chain whether to remove the whole chain.
954 */
956 {
959 /* Unlink at the front, but make it point to the next
960 * vehicle after the to be remove part. */
963 /* Unlink at the back */
965 }
967 /**
968 * Inserts a chain into the train at dst.
969 * @param dst the place where to append after.
970 * @param chain the chain to actually add.
971 */
973 {
974 /* We do not want to add something in the middle of an articulated part. */
979 }
981 /**
982 * Normalise the dual heads in the train, i.e. if one is
983 * missing move that one to this train.
984 * @param t the train to normalise.
985 */
987 {
991 /* Make sure that there are no free cars before next engine */
997 /* Remove the part from the 'wrong' train */
999 /* And add it to the 'right' train */
1001 }
1002 }
1004 /**
1005 * Normalise the sub types of the parts in this chain.
1006 * @param chain the chain to normalise.
1007 */
1009 {
1010 /* Nothing to do */
1013 /* We must be the first in the chain. */
1016 /* Set the appropriate bits for the first in the chain. */
1022 }
1024 /* Now clear the bits for the rest of the chain */
1028 }
1029 }
1031 /**
1032 * Check/validate whether we may actually build a new train.
1033 * @note All vehicles are/were 'heads' of their chains.
1034 * @param original_dst The original destination chain.
1035 * @param dst The destination chain after constructing the train.
1036 * @param original_dst The original source chain.
1037 * @param dst The source chain after constructing the train.
1038 * @return possible error of this command.
1039 */
1040 static CommandCost CheckNewTrain(Train *original_dst, Train *dst, Train *original_src, Train *src)
1041 {
1042 /* Just add 'new' engines and subtract the original ones.
1043 * If that's less than or equal to 0 we can be sure we did
1044 * not add any engines (read: trains) along the way. */
1050 }
1052 /* Get a free unit number and check whether it's within the bounds.
1053 * There will always be a maximum of one new train. */
1057 }
1059 /**
1060 * Check whether the train parts can be attached.
1061 * @param t the train to check
1062 * @return possible error of this command.
1063 */
1065 {
1066 /* No multi-part train, no need to check. */
1069 /* The maximum length for a train. For each part we decrease this by one
1070 * and if the result is negative the train is simply too long. */
1071 int allowed_len = _settings_game.vehicle.max_train_length * TILE_SIZE - t->gcache.cached_veh_length;
1076 /* Break the prev -> t link so it always holds within the loop. */
1080 /* Make sure the cache is cleared. */
1088 /* Unlink the to-be-added piece; it is already unlinked from the previous
1089 * part due to the fact that the prev -> t link is broken. */
1092 /* Don't check callback for articulated or rear dual headed parts */
1094 /* Back up and clear the first_engine data to avoid using wagon override group */
1098 /* We don't want the cache to interfere. head's cache is cleared before
1099 * the loop and after each callback does not need to be cleared here. */
1102 uint16 callback = GetVehicleCallbackParent(CBID_TRAIN_ALLOW_WAGON_ATTACH, 0, 0, head->engine_type, t, head);
1104 /* Restore original first_engine data */
1107 /* We do not want to remember any cached variables from the test run */
1112 /* A failing callback means everything is okay */
1118 if (callback >= 0x100) ErrorUnknownCallbackResult(head->GetGRFID(), CBID_TRAIN_ALLOW_WAGON_ATTACH, callback);
1132 }
1133 }
1134 }
1137 }
1138 }
1140 /* And link it to the new part. */
1144 }
1148 }
1150 /**
1151 * Validate whether we are going to create valid trains.
1152 * @note All vehicles are/were 'heads' of their chains.
1153 * @param original_dst The original destination chain.
1154 * @param dst The destination chain after constructing the train.
1155 * @param original_dst The original source chain.
1156 * @param dst The source chain after constructing the train.
1157 * @param check_limit Whether to check the vehicle limit.
1158 * @return possible error of this command.
1159 */
1160 static CommandCost ValidateTrains(Train *original_dst, Train *dst, Train *original_src, Train *src, bool check_limit)
1161 {
1162 /* Check whether we may actually construct the trains. */
1168 /* Check whether we need to build a new train. */
1170 }
1172 /**
1173 * Arrange the trains in the wanted way.
1174 * @param dst_head The destination chain of the to be moved vehicle.
1175 * @param dst The destination for the to be moved vehicle.
1176 * @param src_head The source chain of the to be moved vehicle.
1177 * @param src The to be moved vehicle.
1178 * @param move_chain Whether to move all vehicles after src or not.
1179 */
1180 static void ArrangeTrains(Train **dst_head, Train *dst, Train **src_head, Train *src, bool move_chain)
1181 {
1182 /* First determine the front of the two resulting trains */
1184 /* If we aren't moving part(s) to a new train, we are just moving the
1185 * front back and there is not destination head. */
1188 /* If we are moving to a new train the head of the move train would become
1189 * the head of the new vehicle. */
1191 }
1194 /* If we are moving the front of a train then we are, in effect, creating
1195 * a new head for the train. Point to that. Unless we are moving the whole
1196 * train in which case there is not 'source' train anymore.
1197 * In case we are a multiheaded part we want the complete thing to come
1198 * with us, so src->GetNextUnit(), however... when we are e.g. a wagon
1199 * that is followed by a rear multihead we do not want to include that. */
1202 }
1204 /* Now it's just simply removing the part that we are going to move from the
1205 * source train and *if* the destination is a not a new train add the chain
1206 * at the destination location. */
1210 /* Now normalise the dual heads, that is move the dual heads around in such
1211 * a way that the head and rear of a dual head are in the same train */
1214 }
1216 /**
1217 * Normalise the head of the train again, i.e. that is tell the world that
1218 * we have changed and update all kinds of variables.
1219 * @param head the train to update.
1220 */
1222 {
1223 /* Not much to do! */
1226 /* Tell the 'world' the train changed. */
1230 /* Not a front engine, i.e. a free wagon chain. No need to do more. */
1233 /* Update the refit button and window */
1237 /* If we don't have a unit number yet, set one. */
1240 }
1242 /**
1243 * Move a rail vehicle around inside the depot.
1244 * @param tile unused
1245 * @param flags type of operation
1246 * Note: DC_AUTOREPLACE is set when autoreplace tries to undo its modifications or moves vehicles to temporary locations inside the depot.
1247 * @param p1 various bitstuffed elements
1248 * - p1 (bit 0 - 19) source vehicle index
1249 * - p1 (bit 20) move all vehicles following the source vehicle
1250 * - p1 (bit 21) this is a virtual vehicle (for creating TemplateVehicles)
1251 * @param p2 what wagon to put the source wagon AFTER, XXX - INVALID_VEHICLE to make a new line
1252 * @param text unused
1253 * @return the cost of this operation or an error
1254 */
1255 CommandCost CmdMoveRailVehicle(TileIndex tile, DoCommandFlag flags, uint32 p1, uint32 p2, const char *text)
1256 {
1267 /* Do not allow moving crashed vehicles inside the depot, it is likely to cause asserts later */
1270 /* if nothing is selected as destination, try and find a matching vehicle to drag to. */
1281 /* Do not allow appending to crashed vehicles, too */
1283 }
1285 /* if an articulated part is being handled, deal with its parent vehicle */
1290 }
1292 /* don't move the same vehicle.. */
1295 /* locate the head of the two chains */
1303 /* Now deal with articulated part of destination wagon */
1307 }
1311 /* When moving all wagons, we can't have the same src_head and dst_head */
1314 /* When moving a multiheaded part to be place after itself, bail out. */
1315 if (!move_chain && dst != NULL && dst->IsRearDualheaded() && src == dst->other_multiheaded_part) return CommandCost();
1317 /* Check if all vehicles in the source train are stopped inside a depot. */
1318 /* Do this check only if the vehicle to be moved is non-virtual */
1320 if (!src_head->IsStoppedInDepot()) return_cmd_error(STR_ERROR_TRAINS_CAN_ONLY_BE_ALTERED_INSIDE_A_DEPOT);
1322 /* Check if all vehicles in the destination train are stopped inside a depot. */
1323 /* Do this check only if the destination vehicle is non-virtual */
1325 if (dst_head != NULL && !dst_head->IsStoppedInDepot()) return_cmd_error(STR_ERROR_TRAINS_CAN_ONLY_BE_ALTERED_INSIDE_A_DEPOT);
1327 /* First make a backup of the order of the trains. That way we can do
1328 * whatever we want with the order and later on easily revert. */
1329 TrainList original_src;
1330 TrainList original_dst;
1335 /* Also make backup of the original heads as ArrangeTrains can change them.
1336 * For the destination head we do not care if it is the same as the source
1337 * head because in that case it's just a copy. */
1341 /* We want this information from before the rearrangement, but execute this after the validation.
1342 * original_src_head can't be NULL; src is by definition != NULL, so src_head can't be NULL as
1343 * src->GetFirst() always yields non-NULL, so eventually original_src_head != NULL as well. */
1345 bool original_dst_head_front_engine = original_dst_head != NULL && original_dst_head->IsFrontEngine();
1347 /* (Re)arrange the trains in the wanted arrangement. */
1351 /* If the autoreplace flag is set we do not need to test for the validity
1352 * because we are going to revert the train to its original state. As we
1353 * assume the original state was correct autoreplace can skip this. */
1354 CommandCost ret = ValidateTrains(original_dst_head, dst_head, original_src_head, src_head, true);
1356 /* Restore the train we had. */
1360 }
1361 }
1363 /* do it? */
1365 /* Remove old heads from the statistics */
1369 /* First normalise the sub types of the chains. */
1373 /* There are 14 different cases:
1374 * 1) front engine gets moved to a new train, it stays a front engine.
1375 * a) the 'next' part is a wagon that becomes a free wagon chain.
1376 * b) the 'next' part is an engine that becomes a front engine.
1377 * c) there is no 'next' part, nothing else happens
1378 * 2) front engine gets moved to another train, it is not a front engine anymore
1379 * a) the 'next' part is a wagon that becomes a free wagon chain.
1380 * b) the 'next' part is an engine that becomes a front engine.
1381 * c) there is no 'next' part, nothing else happens
1382 * 3) front engine gets moved to later in the current train, it is not a front engine anymore.
1383 * a) the 'next' part is a wagon that becomes a free wagon chain.
1384 * b) the 'next' part is an engine that becomes a front engine.
1385 * 4) free wagon gets moved
1386 * a) the 'next' part is a wagon that becomes a free wagon chain.
1387 * b) the 'next' part is an engine that becomes a front engine.
1388 * c) there is no 'next' part, nothing else happens
1389 * 5) non front engine gets moved and becomes a new train, nothing else happens
1390 * 6) non front engine gets moved within a train / to another train, nothing hapens
1391 * 7) wagon gets moved, nothing happens
1392 */
1394 /* Cases #2 and #3: the front engine gets trashed. */
1403 /* Delete orders, group stuff and the unit number as we're not the
1404 * front of any vehicle anymore. */
1411 }
1412 }
1414 /* We weren't a front engine but are becoming one. So
1415 * we should be put in the default group. */
1419 }
1421 /* Add new heads to statistics */
1425 /* Handle 'new engine' part of cases #1b, #2b, #3b, #4b and #5 in NormaliseTrainHead. */
1432 }
1437 }
1441 }
1446 /* We are undoubtedly changing something in the depot and train list. */
1447 /* But only if the moved vehicle is not virtual */
1453 }
1455 /* We don't want to execute what we're just tried. */
1458 }
1461 }
1463 /**
1464 * Sell a (single) train wagon/engine.
1465 * @param flags type of operation
1466 * @param t the train wagon to sell
1467 * @param data the selling mode
1468 * - data = 0: only sell the single dragged wagon/engine (and any belonging rear-engines)
1469 * - data = 1: sell the vehicle and all vehicles following it in the chain
1470 * if the wagon is dragged, don't delete the possibly belonging rear-engine to some front
1471 * @param user the user for the order backup.
1472 * @return the cost of this operation or an error
1473 */
1475 {
1476 /* Sell a chain of vehicles or not? */
1484 /* First make a backup of the order of the train. That way we can do
1485 * whatever we want with the order and later on easily revert. */
1486 TrainList original;
1489 /* We need to keep track of the new head and the head of what we're going to sell. */
1493 /* Split the train in the wanted way. */
1496 /* We don't need to validate the second train; it's going to be sold. */
1499 /* Restore the train we had. */
1502 }
1505 /* Restore the train we had. */
1508 }
1513 /* do it? */
1515 /* First normalise the sub types of the chain. */
1518 if (v == first && v->IsEngine() && !sell_chain && new_head != NULL && new_head->IsFrontEngine()) {
1519 /* We are selling the front engine. In this case we want to
1520 * 'give' the order, unit number and such to the new head. */
1525 /* Copy other important data from the front engine */
1530 }
1532 /* We need to update the information about the train. */
1535 /* We are undoubtedly changing something in the depot and train list. */
1536 /* Unless its a virtual train */
1542 }
1544 /* Actually delete the sold 'goods' */
1547 /* We don't want to execute what we're just tried. */
1549 }
1552 }
1555 {
1556 /* Set common defaults. */
1567 {
1568 /* x, y */
1573 };
1577 /* For all straight directions, move the bound box to the centre of the vehicle, but keep the size. */
1584 /* Shorten southern corner of the bounding box according the vehicle length
1585 * and center the bounding box on the vehicle. */
1598 /* Move northern corner of the bounding box down according to vehicle length
1599 * and center the bounding box on the vehicle. */
1614 }
1615 }
1616 }
1618 /**
1619 * Mark a train as stuck and stop it if it isn't stopped right now.
1620 * @param v %Train to mark as being stuck.
1621 */
1623 {
1625 /* It is the first time the problem occurred, set the "train stuck" flag. */
1631 /* Stop train */
1640 }
1641 }
1643 /**
1644 * Swap the two up/down flags in two ways:
1645 * - Swap values of \a swap_flag1 and \a swap_flag2, and
1646 * - If going up previously (#GVF_GOINGUP_BIT set), the #GVF_GOINGDOWN_BIT is set, and vice versa.
1647 * @param swap_flag1 [inout] First train flag.
1648 * @param swap_flag2 [inout] Second train flag.
1649 */
1651 {
1655 /* Clear the flags */
1663 /* Reverse the rail-flags (if needed) */
1668 }
1674 }
1678 }
1682 }
1683 }
1685 /**
1686 * Updates some variables after swapping the vehicle.
1687 * @param v swapped vehicle
1688 */
1690 {
1691 /* Reverse the direction. */
1694 /* Call the proper EnterTile function unless we are in a wormhole. */
1698 /* VehicleEnter_TunnelBridge() sets TRACK_BIT_WORMHOLE when the vehicle
1699 * is on the last bit of the bridge head (frame == TILE_SIZE - 1).
1700 * If we were swapped with such a vehicle, we have set TRACK_BIT_WORMHOLE,
1701 * when we shouldn't have. Check if this is the case. */
1706 /* We have just left the wormhole, possibly set the
1707 * "goingdown" bit. UpdateInclination() can be used
1708 * because we are at the border of the tile. */
1712 }
1713 }
1714 }
1719 }
1721 /**
1722 * Swap vehicles \a l and \a r in consist \a v, and reverse their direction.
1723 * @param v Consist to change.
1724 * @param l %Vehicle index in the consist of the first vehicle.
1725 * @param r %Vehicle index in the consist of the second vehicle.
1726 */
1728 {
1731 /* locate vehicles to swap */
1736 /* swap the hidden bits */
1737 {
1741 }
1755 /* Swap GVF_GOINGUP_BIT/GVF_GOINGDOWN_BIT.
1756 * This is a little bit redundant way, a->gv_flags will
1757 * be (re)set twice, but it reduces code duplication */
1760 }
1761 }
1764 /**
1765 * Check if the vehicle is a train
1766 * @param v vehicle on tile
1767 * @return v if it is a train, NULL otherwise
1768 */
1770 {
1772 }
1775 /**
1776 * Checks if a train is approaching a rail-road crossing
1777 * @param v vehicle on tile
1778 * @param data tile with crossing we are testing
1779 * @return v if it is approaching a crossing, NULL otherwise
1780 */
1782 {
1793 }
1796 /**
1797 * Finds a vehicle approaching rail-road crossing
1798 * @param tile tile to test
1799 * @return true if a vehicle is approaching the crossing
1800 * @pre tile is a rail-road crossing
1801 */
1803 {
1815 }
1817 /** Check if the crossing should be closed
1818 * @return train on crossing || train approaching crossing || reserved
1819 */
1821 {
1822 return HasCrossingReservation(tile) || HasVehicleOnPos(tile, NULL, &TrainOnTileEnum) || TrainApproachingCrossing(tile);
1823 }
1825 /**
1826 * Sets correct crossing state
1827 * @param tile tile to update
1828 * @param sound should we play sound?
1829 * @param is_forced force set the crossing state to that of forced_state
1830 * @param forced_state the crossing state to set when using is_forced
1831 * @pre tile is a rail-road crossing
1832 */
1833 static void UpdateLevelCrossingTile(TileIndex tile, bool sound, bool is_forced, bool forced_state)
1834 {
1842 }
1853 }
1854 }
1857 }
1858 }
1860 /**
1861 * Cycles the adjacent crossings and sets their state
1862 * @param tile tile to update
1863 * @param sound should we play sound?
1864 * @param force_close force close the crossing
1865 */
1867 {
1875 for (TileIndex t = tile; !forced_state && IsLevelCrossingTile(t) && GetCrossingRoadAxis(t) == axis; t = TileAddByDiagDir(t, dir)) {
1877 }
1878 for (TileIndex t = TileAddByDiagDir(tile, reverse_dir); !forced_state && IsLevelCrossingTile(t) && GetCrossingRoadAxis(t) == axis; t = TileAddByDiagDir(t, reverse_dir)) {
1880 }
1883 for (TileIndex t = TileAddByDiagDir(tile, dir); IsLevelCrossingTile(t) && GetCrossingRoadAxis(t) == axis; t = TileAddByDiagDir(t, dir)) {
1885 }
1886 for (TileIndex t = TileAddByDiagDir(tile, reverse_dir); IsLevelCrossingTile(t) && GetCrossingRoadAxis(t) == axis; t = TileAddByDiagDir(t, reverse_dir)) {
1888 }
1889 }
1892 /**
1893 * Bars crossing and plays ding-ding sound if not barred already
1894 * @param tile tile with crossing
1895 * @pre tile is a rail-road crossing
1896 */
1898 {
1901 }
1902 }
1905 /**
1906 * Advances wagons for train reversing, needed for variable length wagons.
1907 * This one is called before the train is reversed.
1908 * @param v First vehicle in chain
1909 */
1911 {
1923 /* do not update images now
1924 * negative differential will be handled in AdvanceWagonsAfterSwap() */
1929 }
1930 }
1933 /**
1934 * Advances wagons for train reversing, needed for variable length wagons.
1935 * This one is called after the train is reversed.
1936 * @param v First vehicle in chain
1937 */
1939 {
1940 /* first of all, fix the situation when the train was entering a depot */
1942 while (dep->Next() != NULL && (dep->track == TRACK_BIT_DEPOT || dep->Next()->track != TRACK_BIT_DEPOT)) {
1944 }
1949 /* 'pull' next wagon out of the depot, so we won't miss it (it could stay in depot forever) */
1955 for (int i = 0; i >= d; i--) TrainController(leave, NULL); // maybe move it, and maybe let another wagon leave
1956 }
1959 }
1966 /* We have to make sure all wagons that leave a depot because of train reversing are moved correctly
1967 * they have already correct spacing, so we have to make sure they are moved how they should */
1968 bool nomove = (dep == NULL); // If there is no vehicle leaving a depot, limit the number of wagons moved immediately.
1971 /* we reached vehicle (originally) in front of a depot, stop now
1972 * (we would move wagons that are already moved with new wagon length). */
1975 /* the last wagon was that one leaving a depot, so do not move it anymore */
1983 /* do not update images now */
1988 }
1989 }
1991 /**
1992 * Turn a train around.
1993 * @param v %Train to turn around.
1994 */
1996 {
1999 }
2003 /* Clear path reservation in front if train is not stuck. */
2006 /* Check if we were approaching a rail/road-crossing */
2009 /* count number of vehicles */
2014 /* swap start<>end, start+1<>end-1, ... */
2024 }
2030 /* recalculate cached data */
2033 /* update all images */
2036 /* update crossing we were approaching */
2039 /* maybe we are approaching crossing now, after reversal */
2043 /* If we are inside a depot after reversing, don't bother with path reserving. */
2045 /* Can't be stuck here as inside a depot is always a safe tile. */
2046 if (HasBit(v->flags, VRF_TRAIN_STUCK)) SetWindowWidgetDirty(WC_VEHICLE_VIEW, v->index, WID_VV_START_STOP);
2049 }
2051 /* We are inside tunnel/bidge with signals, reversing will close the entrance. */
2053 /* Flip signal on tunnel entrance tile red. */
2056 /* Clear counters. */
2060 }
2062 /* TrainExitDir does not always produce the desired dir for depots and
2063 * tunnels/bridges that is needed for UpdateSignalsOnSegment. */
2067 if (UpdateSignalsOnSegment(v->tile, dir, v->owner) == SIGSEG_PBS || _settings_game.pf.reserve_paths) {
2068 /* If we are currently on a tile with conventional signals, we can't treat the
2069 * current tile as a safe tile or we would enter a PBS block without a reservation. */
2074 /* If we are on a depot tile facing outwards, do not treat the current tile as safe. */
2075 if (IsRailDepotTile(v->tile) && TrackdirToExitdir(v->GetVehicleTrackdir()) == GetRailDepotDirection(v->tile)) first_tile_okay = false;
2077 if (IsRailStationTile(v->tile)) SetRailStationPlatformReservation(v->tile, TrackdirToExitdir(v->GetVehicleTrackdir()), true);
2079 /* Do a look-ahead now in case our current tile was already a safe tile. */
2082 /* Do not wait for a way out when we're still loading */
2084 }
2086 /* A train not inside a PBS block can't be stuck. */
2089 }
2090 }
2092 /**
2093 * Reverse train.
2094 * @param tile unused
2095 * @param flags type of operation
2096 * @param p1 train to reverse
2097 * @param p2 if true, reverse a unit in a train (needs to be in a depot)
2098 * @param text unused
2099 * @return the cost of this operation or an error
2100 */
2101 CommandCost CmdReverseTrainDirection(TileIndex tile, DoCommandFlag flags, uint32 p1, uint32 p2, const char *text)
2102 {
2110 /* turn a single unit around */
2112 if (v->IsMultiheaded() || HasBit(EngInfo(v->engine_type)->callback_mask, CBM_VEHICLE_ARTIC_ENGINE)) {
2114 }
2118 /* make sure the vehicle is stopped in the depot */
2121 }
2131 }
2133 /* turn the whole train around */
2137 /* Properly leave the station if we are loading and won't be loading anymore */
2142 /* not a station || different station --> leave the station */
2143 if (!IsTileType(last->tile, MP_STATION) || GetStationIndex(last->tile) != GetStationIndex(v->tile)) {
2145 }
2146 }
2148 /* We cancel any 'skip signal at dangers' here */
2159 }
2160 }
2161 }
2163 }
2165 /**
2166 * Force a train through a red signal
2167 * @param tile unused
2168 * @param flags type of operation
2169 * @param p1 train to ignore the red signal
2170 * @param p2 unused
2171 * @param text unused
2172 * @return the cost of this operation or an error
2173 */
2174 CommandCost CmdForceTrainProceed(TileIndex tile, DoCommandFlag flags, uint32 p1, uint32 p2, const char *text)
2175 {
2186 /* If we are forced to proceed, cancel that order.
2187 * If we are marked stuck we would want to force the train
2188 * to proceed to the next signal. In the other cases we
2189 * would like to pass the signal at danger and run till the
2190 * next signal we encounter. */
2191 t->force_proceed = t->force_proceed == TFP_SIGNAL ? TFP_NONE : HasBit(t->flags, VRF_TRAIN_STUCK) || t->IsChainInDepot() ? TFP_STUCK : TFP_SIGNAL;
2193 }
2196 }
2198 /**
2199 * Try to find a depot nearby.
2200 * @param v %Train that wants a depot.
2201 * @param max_distance Maximal search distance.
2202 * @return Information where the closest train depot is located.
2203 * @pre The given vehicle must not be crashed!
2204 */
2206 {
2219 }
2220 }
2222 /**
2223 * Locate the closest depot for this consist, and return the information to the caller.
2224 * @param location [out] If not \c NULL and a depot is found, store its location in the given address.
2225 * @param destination [out] If not \c NULL and a depot is found, store its index in the given address.
2226 * @param reverse [out] If not \c NULL and a depot is found, store reversal information in the given address.
2227 * @return A depot has been found.
2228 */
2230 {
2239 }
2241 /** Play a sound for a train leaving the station. */
2243 {
2245 SND_04_TRAIN,
2246 SND_0A_TRAIN_HORN,
2247 SND_0A_TRAIN_HORN,
2248 SND_47_MAGLEV_2,
2249 SND_41_MAGLEV
2250 };
2256 }
2258 /**
2259 * Check if the train is on the last reserved tile and try to extend the path then.
2260 * @param v %Train that needs its path extended.
2261 */
2263 {
2264 /* Don't do any look-ahead if path_backoff_interval is 255. */
2267 /* Exit if we are inside a depot. */
2271 /* Exit if we reached our destination depot. */
2277 /* If we reached our waypoint, make sure we see that. */
2278 if (IsRailWaypointTile(v->tile) && GetStationIndex(v->tile) == v->current_order.GetDestination()) ProcessOrders(v);
2284 /* Exit if the current order doesn't have a destination, but the train has orders. */
2290 }
2291 /* Exit if we are on a station tile and are going to stop. */
2292 if (IsRailStationTile(v->tile) && v->current_order.ShouldStopAtStation(v, GetStationIndex(v->tile))) return;
2296 /* On a tile with a red non-pbs signal, don't look ahead. */
2305 /* Next tile is not reserved. */
2308 /* If the next tile is a PBS signal, try to make a reservation. */
2312 }
2314 }
2315 }
2316 }
2317 }
2319 /**
2320 * Will the train stay in the depot the next tick?
2321 * @param v %Train to check.
2322 * @return True if it stays in the depot, false otherwise.
2323 */
2325 {
2326 /* bail out if not all wagons are in the same depot or not in a depot at all */
2329 }
2331 /* if the train got no power, then keep it in the depot */
2336 }
2343 SigSegState seg_state;
2346 /* force proceed was not pressed */
2350 }
2354 seg_state = _settings_game.pf.reserve_paths ? SIGSEG_PBS : UpdateSignalsOnSegment(v->tile, INVALID_DIAGDIR, v->owner);
2356 /* Full and no PBS signal in block or depot reserved, can't exit. */
2359 }
2361 seg_state = _settings_game.pf.reserve_paths ? SIGSEG_PBS : UpdateSignalsOnSegment(v->tile, INVALID_DIAGDIR, v->owner);
2362 }
2364 /* We are leaving a depot, but have to go to the exact same one; re-enter */
2366 /* We need to have a reservation for this to work. */
2371 }
2373 /* Only leave when we can reserve a path to our destination. */
2375 /* No path and no force proceed. */
2379 }
2382 if (_settings_client.gui.show_track_reservation) MarkTileDirtyByTile(v->tile, ZOOM_LVL_DRAW_MAP);
2401 }
2404 {
2412 slot--;
2418 }
2419 }
2420 }
2421 }
2426 }
2429 }
2431 static void HandleLastTunnelBridgeSignals(TileIndex tile, TileIndex end, DiagDirection dir, bool free)
2432 {
2434 /* Clearing last bridge signal. */
2437 TileIndex last_signal_tile = end + (TileOffsByDiagDir(dir) * _settings_game.construction.simulated_wormhole_signals * signal_offset);
2439 }
2441 }
2443 /* Open up the wormhole and clear m2. */
2446 }
2448 if (IsTunnelBridgeSignalSimulationEntrance(end) && GetTunnelBridgeSignalState(end) == SIGNAL_STATE_RED) {
2451 } else if (IsTunnelBridgeSignalSimulationEntrance(tile) && GetTunnelBridgeSignalState(tile) == SIGNAL_STATE_RED) {
2454 }
2455 }
2456 }
2459 {
2461 if (IsTunnelBridgeSignalSimulationExit(tile) && IsTunnelBridgePBS(tile)) SetTunnelBridgeSignalState(tile, SIGNAL_STATE_RED);
2462 }
2464 /**
2465 * Clear the reservation of \a tile that was just left by a wagon on \a track_dir.
2466 * @param v %Train owning the reservation.
2467 * @param tile Tile with reservation to clear.
2468 * @param track_dir Track direction to clear.
2469 */
2471 {
2475 /* Are we just leaving a tunnel/bridge? */
2486 }
2487 }
2489 /* Free the reservation only if no other train is on the tiles. */
2496 }
2500 }
2501 }
2502 }
2504 /* canceling reservation of entry ramp, due to reverse */
2508 }
2509 }
2510 }
2513 /* If the new tile is not a further tile of the same station, we
2514 * clear the reservation for the whole platform. */
2517 }
2519 /* Any other tile */
2521 }
2522 }
2524 /**
2525 * Free the reserved path in front of a vehicle.
2526 * @param v %Train owning the reserved path.
2527 * @param origin %Tile to start clearing (if #INVALID_TILE, use the current tile of \a v).
2528 * @param orig_td Track direction (if #INVALID_TRACKDIR, use the track direction of \a v).
2529 */
2531 {
2536 bool free_tile = tile != v->tile || !(IsRailStationTile(v->tile) || IsTileType(v->tile, MP_TUNNELBRIDGE));
2537 StationID station_id = IsRailStationTile(v->tile) ? GetStationIndex(v->tile) : INVALID_STATION;
2539 /* Can't be holding a reservation if we enter a depot. */
2542 /* Front engine is in a depot. We enter if some part is not in the depot. */
2545 }
2546 }
2547 /* Don't free reservation if it's not ours. */
2561 /* Conventional signal along trackdir: remove reservation and stop. */
2564 }
2567 /* Red PBS signal? Can't be our reservation, would be green then. */
2570 /* Turn the signal back to red. */
2574 /* notify logic signals of the state change */
2576 }
2577 } else if (HasSignalOnTrackdir(tile, ReverseTrackdir(td)) && IsOnewaySignal(tile, TrackdirToTrack(td))) {
2579 }
2580 }
2582 /* Don't free first station/bridge/tunnel if we are on it. */
2583 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);
2586 }
2587 }
2596 };
2598 /**
2599 * Perform pathfinding for a train.
2600 *
2601 * @param v The train
2602 * @param tile The tile the train is about to enter
2603 * @param enterdir Diagonal direction the train is coming from
2604 * @param tracks Usable tracks on the new tile
2605 * @param path_found [out] Whether a path has been found or not.
2606 * @param do_track_reservation Path reservation is requested
2607 * @param dest [out] State and destination of the requested path
2608 * @return The best track the train should follow
2609 */
2610 static Track DoTrainPathfind(const Train *v, TileIndex tile, DiagDirection enterdir, TrackBits tracks, bool &path_found, bool do_track_reservation, PBSTileInfo *dest)
2611 {
2613 case VPF_NPF: return NPFTrainChooseTrack(v, tile, enterdir, tracks, path_found, do_track_reservation, dest);
2614 case VPF_YAPF: return YapfTrainChooseTrack(v, tile, enterdir, tracks, path_found, do_track_reservation, dest);
2617 }
2618 }
2620 /**
2621 * Extend a train path as far as possible. Stops on encountering a safe tile,
2622 * another reservation or a track choice.
2623 * @param v The train.
2624 * @param origin The tile from which the reservation have to be extended
2625 * @param new_tracks [out] Tracks to choose from when encountering a choice
2626 * @param enterdir [out] The direction from which the choice tile is to be entered
2627 * @return INVALID_TILE indicates that the reservation failed.
2628 */
2629 static PBSTileInfo ExtendTrainReservation(const Train *v, const PBSTileInfo &origin, TrackBits *new_tracks, DiagDirection *enterdir)
2630 {
2637 /* Possible signal tile. */
2638 if (HasOnewaySignalBlockingTrackdir(ft.m_new_tile, FindFirstTrackdir(ft.m_new_td_bits))) break;
2639 }
2644 }
2646 /* Station, depot or waypoint are a possible target. */
2647 bool target_seen = ft.m_is_station || (IsTileType(ft.m_new_tile, MP_RAILWAY) && !IsPlainRail(ft.m_new_tile));
2649 /* Choice found or possible target encountered.
2650 * On finding a possible target, we need to stop and let the pathfinder handle the
2651 * remaining path. This is because we don't know if this target is in one of our
2652 * orders, so we might cause pathfinding to fail later on if we find a choice.
2653 * This failure would cause a bogous call to TryReserveSafePath which might reserve
2654 * a wrong path not leading to our next destination. */
2655 if (HasReservedTracks(ft.m_new_tile, TrackdirBitsToTrackBits(TrackdirReachesTrackdirs(ft.m_old_td)))) break;
2657 /* If we did skip some tiles, backtrack to the first skipped tile so the pathfinder
2658 * actually starts its search at the first unreserved tile. */
2659 if (ft.m_tiles_skipped != 0) ft.m_new_tile -= TileOffsByDiagDir(ft.m_exitdir) * ft.m_tiles_skipped;
2661 /* Choice found, path valid but not okay. Save info about the choice tile as well. */
2665 }
2673 /* Safe position is all good, path valid and okay. */
2675 }
2678 }
2681 /* End of line, path valid and okay. */
2683 }
2685 /* Sorry, can't reserve path, back out. */
2696 }
2703 }
2705 /* Path invalid. */
2707 }
2709 /**
2710 * Try to reserve any path to a safe tile, ignoring the vehicle's destination.
2711 * Safe tiles are tiles in front of a signal, depots and station tiles at end of line.
2712 *
2713 * @param v The vehicle.
2714 * @param tile The tile the search should start from.
2715 * @param td The trackdir the search should start from.
2716 * @param override_railtype Whether all physically compatible railtypes should be followed.
2717 * @return True if a path to a safe stopping tile could be reserved.
2718 */
2719 static bool TryReserveSafeTrack(const Train *v, TileIndex tile, Trackdir td, bool override_tailtype)
2720 {
2726 }
2727 }
2729 /** This class will save the current order of a vehicle and restore it on destruction. */
2733 Order old_order;
2734 TileIndex old_dest_tile;
2735 StationID old_last_station_visited;
2736 VehicleOrderID index;
2747 {
2748 }
2751 {
2756 }
2758 /**
2759 * Set the current vehicle order to the next order in the order list.
2760 * @param skip_first Shall the first (i.e. active) order be skipped?
2761 * @return True if a suitable next order could be found.
2762 */
2764 {
2770 bool has_manual_depot_order = (HasBit(v->vehicle_flags, VF_SHOULD_GOTO_DEPOT) || HasBit(v->vehicle_flags, VF_SHOULD_SERVICE_AT_DEPOT));
2773 /* Wrap around. */
2781 /* Skip service in depot orders when the train doesn't need service. */
2782 if ((order->GetDepotOrderType() & ODTFB_SERVICE) && !(this->v->NeedsServicing() || has_manual_depot_order)) break;
2783 FALLTHROUGH;
2791 depth++;
2793 /* Don't increment next, so no break here. */
2795 }
2797 }
2800 }
2801 /* Don't increment inside the while because otherwise conditional
2802 * orders can lead to an infinite loop. */
2804 depth++;
2808 }
2809 };
2811 /**
2812 * This is called to retrieve the previous signal, as required
2813 * This is not run all the time as it is somewhat expensive and most restrictions will not test for the previous signal
2814 */
2815 static TileIndex ChooseTrainTrackTraceRestrictPreviousSignalCallback(const Train *v, const void *)
2816 {
2817 // scan forwards from vehicle position, for the case that train is waiting at/approaching PBS signal
2827 // found PBS signal
2830 // wrong type of signal
2832 }
2833 }
2835 // advance to next tile
2837 // ran out of track
2839 }
2842 // reached a junction tile
2844 }
2848 }
2849 }
2852 {
2855 const TraceRestrictProgram *prog = GetExistingTraceRestrictProgram(tile, TrackdirToTrack(trackdir));
2857 TraceRestrictProgramResult out;
2858 prog->Execute(v, TraceRestrictProgramInput(tile, trackdir, &ChooseTrainTrackTraceRestrictPreviousSignalCallback, nullptr), out);
2861 }
2862 }
2863 }
2864 }
2867 }
2869 /**
2870 * Choose a track and reserve if necessary
2871 *
2872 * @param v The vehicle
2873 * @param tile The tile from which to start
2874 * @param enterdir
2875 * @param tracks
2876 * @param force_res Force a reservation to be made
2877 * @param p_got_reservation [out] If the train has a reservation
2878 * @param mark_stuck The train has to be marked as stuck when needed
2879 * @return The track the train should take.
2880 */
2881 static Track ChooseTrainTrack(Train *v, TileIndex tile, DiagDirection enterdir, TrackBits tracks, bool force_res, bool *p_got_reservation, bool mark_stuck)
2882 {
2891 /* Don't use tracks here as the setting to forbid 90 deg turns might have been switched between reservation and now. */
2892 TrackBits res_tracks = (TrackBits)(GetReservedTrackbits(tile) & DiagdirReachesTracks(enterdir));
2893 /* Do we have a suitable reserved track? */
2896 /* Quick return in case only one possible track is available */
2899 /* We need to check for signals only here, as a junction tile can't have signals. */
2900 if (track != INVALID_TRACK && HasPbsSignalOnTrackdir(tile, TrackEnterdirToTrackdir(track, enterdir))) {
2904 TraceRestrictProgramResult out;
2911 }
2912 }
2913 }
2920 /* notify logic signals of the state change */
2924 }
2926 }
2934 /* Reservation failed? */
2937 SetSignalStateByTrackdir(tile, TrackEnterdirToTrackdir(best_track, enterdir), SIGNAL_STATE_RED);
2939 /* notify logic signals of the state change */
2941 }
2943 }
2951 /* Got a valid reservation that ends at a safe target, quick exit. */
2956 }
2957 }
2958 }
2960 /* Check if the train needs service here, so it has a chance to always find a depot.
2961 * Also check if the current order is a service order so we don't reserve a path to
2962 * the destination but instead to the next one if service isn't needed. */
2964 if (v->current_order.IsType(OT_DUMMY) || v->current_order.IsType(OT_CONDITIONAL) || v->current_order.IsType(OT_GOTO_DEPOT)) ProcessOrders(v);
2965 }
2967 /* Save the current train order. The destructor will restore the old order on function exit. */
2970 /* If the current tile is the destination of the current order and
2971 * a reservation was requested, advance to the next order.
2972 * Don't advance on a depot order as depots are always safe end points
2973 * for a path and no look-ahead is necessary. This also avoids a
2974 * problem with depot orders not part of the order list when the
2975 * order list itself is empty. */
2978 } else if (v->current_order.IsType(OT_LOADING) || (!v->current_order.IsType(OT_GOTO_DEPOT) && (
2983 }
2986 /* Pathfinders are able to tell that route was only 'guessed'. */
2990 Track next_track = DoTrainPathfind(v, new_tile, dest_enterdir, tracks, path_found, do_track_reservation, &res_dest);
2993 }
2995 /* No track reservation requested -> finished. */
2998 /* A path was found, but could not be reserved. */
3003 }
3005 /* No possible reservation target found, we are probably lost. */
3007 /* Try to find any safe destination. */
3013 // Use p_got_reservation because were going to return
3019 }
3021 }
3025 /* Reservation target found and free, check if it is safe. */
3026 while (!IsSafeWaitingPosition(v, res_dest.tile, res_dest.trackdir, true, _settings_game.pf.forbid_90_deg)) {
3027 /* Extend reservation until we have found a safe position. */
3030 TrackBits reachable = TrackdirBitsToTrackBits((TrackdirBits)(GetTileTrackStatus(next_tile, TRANSPORT_RAIL, 0))) & DiagdirReachesTracks(exitdir);
3033 }
3035 /* Get next order with destination. */
3037 PBSTileInfo cur_dest;
3043 /* Path found, but could not be reserved. */
3049 }
3050 }
3051 /* No order or no safe position found, try any position. */
3057 }
3059 }
3067 // We reserved up to a LR signal, reserve past it as well. recursion
3068 ChooseTrainTrack(v, ft.m_new_tile, ft.m_exitdir, TrackdirBitsToTrackBits(ft.m_new_td_bits), force_res, NULL, mark_stuck);
3069 }
3070 }
3071 }
3079 }
3081 /**
3082 * Try to reserve a path to a safe position.
3083 *
3084 * @param v The vehicle
3085 * @param mark_as_stuck Should the train be marked as stuck on a failed reservation?
3086 * @param first_tile_okay True if no path should be reserved if the current tile is a safe position.
3087 * @return True if a path could be reserved.
3088 */
3090 {
3093 /* We have to handle depots specially as the track follower won't look
3094 * at the depot tile itself but starts from the next tile. If we are still
3095 * inside the depot, a depot reservation can never be ours. */
3101 /* Depot not reserved, but the next tile might be. */
3103 if (HasReservedTracks(next_tile, DiagdirReachesTracks(GetRailDepotDirection(v->tile)))) return false;
3104 }
3105 }
3109 // prevent any attempt to reserve the wrong way onto a tunnel/bridge exit
3111 }
3115 /* The path we are driving on is already blocked by some other train.
3116 * This can only happen in certain situations when mixing path and
3117 * block signals or when changing tracks and/or signals.
3118 * Exit here as doing any further reservations will probably just
3119 * make matters worse. */
3123 }
3124 /* If we have a reserved path and the path ends at a safe tile, we are finished already. */
3126 /* Can't be stuck then. */
3127 if (HasBit(v->flags, VRF_TRAIN_STUCK)) SetWindowWidgetDirty(WC_VEHICLE_VIEW, v->index, WID_VV_START_STOP);
3130 }
3132 /* If we are in a depot, tentatively reserve the depot. */
3135 if (_settings_client.gui.show_track_reservation) MarkTileDirtyByTile(v->tile, ZOOM_LVL_DRAW_MAP);
3136 }
3140 TrackBits reachable = TrackdirBitsToTrackBits(TrackStatusToTrackdirBits(GetTileTrackStatus(new_tile, TRANSPORT_RAIL, 0)) & DiagdirReachesTrackdirs(exitdir));
3142 if (_settings_game.pf.forbid_90_deg) reachable &= ~TrackCrossesTracks(TrackdirToTrack(origin.trackdir));
3148 /* Free the depot reservation as well. */
3149 if (v->track == TRACK_BIT_DEPOT && v->tile == origin.tile) SetDepotReservation(v->tile, false);
3151 }
3156 }
3159 }
3163 {
3168 }
3177 }
3178 }
3180 /**
3181 * Get the location of the next station to visit.
3182 * @param station Next station to visit.
3183 * @return Location of the new station.
3184 */
3186 {
3191 /* The destination station has no trainstation tiles. */
3194 }
3197 }
3199 /** Goods at the consist have changed, update the graphics, cargo, and acceleration. */
3201 {
3208 /* need to update acceleration and cached values since the goods on the train changed. */
3211 }
3213 /**
3214 * This function looks at the vehicle and updates its speed (cur_speed
3215 * and subspeed) variables. Furthermore, it returns the distance that
3216 * the train can drive this tick. #Vehicle::GetAdvanceDistance() determines
3217 * the distance to drive before moving a step on the map.
3218 * @return distance to drive.
3219 */
3221 {
3225 return this->DoUpdateSpeed(this->acceleration * (this->GetAccelerationStatus() == AS_BRAKE ? -4 : 2), 0, this->GetCurrentMaxSpeed());
3228 return this->DoUpdateSpeed(this->GetAcceleration(), this->GetAccelerationStatus() == AS_BRAKE ? 0 : 2, this->GetCurrentMaxSpeed());
3229 }
3230 }
3232 /**
3233 * Trains enters a station, send out a news item if it is the first train, and start loading.
3234 * @param v Train that entered the station.
3235 * @param station Station visited.
3236 */
3238 {
3241 /* check if a train ever visited this station before */
3247 STR_NEWS_FIRST_TRAIN_ARRIVAL,
3250 st->index
3251 );
3254 }
3263 }
3265 /* Check if the vehicle is compatible with the specified tile */
3267 {
3270 }
3272 /** Data structure for storing engine speed changes of an acceleration type. */
3278 };
3280 /** Speed update fractions for each acceleration type. */
3282 /* normal accel */
3286 };
3288 /**
3289 * Modify the speed of the vehicle due to a change in altitude.
3290 * @param v %Train to update.
3291 * @param old_z Previous height.
3292 */
3294 {
3295 if (old_z == v->z_pos || _settings_game.vehicle.train_acceleration_model != AM_ORIGINAL) return;
3297 const AccelerationSlowdownParams *asp = &_accel_slowdown[GetRailTypeInfo(v->railtype)->acceleration_type];
3304 }
3305 }
3310 CHANGED_LR_PBS ///< A long reserve PBS signal
3311 };
3313 static TrainMovedChangeSignalEnum TrainMovedChangeSignal(Train* v, TileIndex tile, DiagDirection dir)
3314 {
3317 TrackdirBits tracks = TrackBitsToTrackdirBits(GetTrackBits(tile)) & DiagdirReachesTrackdirs(dir);
3319 if (UpdateSignalsOnSegment(tile, TrackdirToExitdir(trackdir), GetTileOwner(tile)) == SIGSEG_PBS && HasSignalOnTrackdir(tile, trackdir)) {
3320 /* A PBS block with a non-PBS signal facing us? */
3321 if (!IsPbsSignal(GetSignalType(tile, TrackdirToTrack(trackdir)))) return CHANGED_NORMAL_TO_PBS_BLOCK;
3324 }
3325 }
3327 if (IsTileType(tile, MP_TUNNELBRIDGE) && IsTunnelBridgeSignalSimulationExit(tile) && GetTunnelBridgeDirection(tile) == ReverseDiagDir(dir)) {
3330 }
3331 }
3334 }
3336 /** Tries to reserve track under whole train consist. */
3338 {
3349 }
3350 }
3351 }
3353 /**
3354 * The train vehicle crashed!
3355 * Update its status and other parts around it.
3356 * @param flooded Crash was caused by flooding.
3357 * @return Number of people killed.
3358 */
3360 {
3365 /* Remove the reserved path in front of the train if it is not stuck.
3366 * Also clear all reserved tracks the train is currently on. */
3371 /* ClearPathReservation will not free the wormhole exit
3372 * if the train has just entered the wormhole. */
3374 }
3375 }
3377 /* we may need to update crossing we were approaching,
3378 * but must be updated after the train has been marked crashed */
3382 /* Remove the loading indicators (if any) */
3384 }
3390 }
3392 /**
3393 * Marks train as crashed and creates an AI event.
3394 * Doesn't do anything if the train is crashed already.
3395 * @param v first vehicle of chain
3396 * @return number of victims (including 2 drivers; zero if train was already crashed)
3397 */
3399 {
3402 /* do not crash train twice */
3405 AI::NewEvent(v->owner, new ScriptEventVehicleCrashed(v->index, v->tile, ScriptEventVehicleCrashed::CRASH_TRAIN));
3406 Game::NewEvent(new ScriptEventVehicleCrashed(v->index, v->tile, ScriptEventVehicleCrashed::CRASH_TRAIN));
3407 }
3409 /* Try to re-reserve track under already crashed train too.
3410 * Crash() clears the reservation! */
3414 }
3416 /** Temporary data storage for testing collisions. */
3420 };
3422 /**
3423 * Collision test function.
3424 * @param v %Train vehicle to test collision with.
3425 * @param data %Train being examined.
3426 * @return \c NULL (always continue search)
3427 */
3429 {
3432 /* not a train or in depot */
3435 /* do not crash into trains of another company. */
3438 /* get first vehicle now to make most usual checks faster */
3441 /* can't collide with own wagons */
3447 /* Do fast calculation to check whether trains are not in close vicinity
3448 * and quickly reject trains distant enough for any collision.
3449 * Differences are shifted by 7, mapping range [-7 .. 8] into [0 .. 15]
3450 * Differences are then ORed and then we check for any higher bits */
3454 /* Slower check using multiplication */
3455 int min_diff = (Train::From(v)->gcache.cached_veh_length + 1) / 2 + (tcc->v->gcache.cached_veh_length + 1) / 2 - 1;
3458 /* Happens when there is a train under bridge next to bridge head */
3461 /* crash both trains */
3466 }
3468 /**
3469 * Checks whether the specified train has a collision with another vehicle. If
3470 * so, destroys this vehicle, and the other vehicle if its subtype has TS_Front.
3471 * Reports the incident in a flashy news item, modifies station ratings and
3472 * plays a sound.
3473 * @param v %Train to test.
3474 */
3476 {
3477 /* can't collide in depot */
3482 TrainCollideChecker tcc;
3486 /* find colliding vehicles */
3492 }
3494 /* any dead -> no crash */
3503 }
3506 {
3512 /* not front engine of a train, inside wormhole or depot, crashed */
3518 }
3521 int32 pos;
3522 uint16 distance;
3523 DirectionByte direction;
3524 };
3526 /** Find train in front and keep distance between trains in tunnel/bridge. */
3528 {
3529 /* Don't look at wagons between front and back of train. */
3541 }
3545 }
3547 static bool IsTooCloseBehindTrain(Vehicle *v, TileIndex tile, uint16 distance, bool check_endtile)
3548 {
3553 FindSpaceBetweenTrainsChecker checker;
3562 }
3565 /* Revert train if not going with tunnel direction. */
3568 }
3570 }
3571 /* Cover blind spot at end of tunnel bridge. */
3573 if (HasVehicleOnPos(GetOtherTunnelBridgeEnd(t->tile), &checker, &FindSpaceBetweenTrainsEnum)) {
3574 /* Revert train if not going with tunnel direction. */
3577 }
3579 }
3580 }
3583 }
3586 {
3591 TrackdirBits reserved = ft.m_new_td_bits & TrackBitsToTrackdirBits(GetReservedTrackbits(ft.m_new_tile));
3593 /* next tile is not reserved, so reserve the exit tile */
3595 }
3596 }
3601 }
3603 /** Simulate signals in tunnel - bridge. */
3605 {
3608 /* When not exit reverse train. */
3612 }
3613 SigSegState seg_state = (_settings_game.pf.reserve_paths || IsTunnelBridgePBS(tile)) ? SIGSEG_PBS : UpdateSignalsOnSegment(tile, INVALID_DIAGDIR, t->owner);
3617 if (ft.m_new_td_bits != TRACKDIR_BIT_NONE && KillFirstBit(ft.m_new_td_bits) == TRACKDIR_BIT_NONE) {
3620 /* immediately after the exit, there is a PBS signal, switch to PBS mode */
3622 }
3623 }
3624 }
3625 }
3626 if (seg_state == SIGSEG_FULL || (seg_state == SIGSEG_PBS && !CheckTrainStayInWormHolePathReserve(t, tile))) {
3629 }
3632 }
3635 {
3636 TileIndex tile;
3639 case DIR_NE: tile = TileVirtXY(v->x_pos + (TILE_SIZE * _settings_game.construction.simulated_wormhole_signals), v->y_pos); break;
3640 case DIR_SE: tile = TileVirtXY(v->x_pos, v->y_pos - (TILE_SIZE * _settings_game.construction.simulated_wormhole_signals) ); break;
3641 case DIR_SW: tile = TileVirtXY(v->x_pos - (TILE_SIZE * _settings_game.construction.simulated_wormhole_signals), v->y_pos); break;
3642 case DIR_NW: tile = TileVirtXY(v->x_pos, v->y_pos + (TILE_SIZE * _settings_game.construction.simulated_wormhole_signals)); break;
3643 }
3646 /* Flip signal on ramp. */
3647 if (IsTunnelBridgeSignalSimulationEntrance(tile) && GetTunnelBridgeSignalState(tile) == SIGNAL_STATE_RED) {
3650 }
3654 }
3655 }
3658 {
3664 /* ignore track_piece, 1 state per tile */
3671 else
3678 /* If rounded growth amount changes, redraw */
3681 }
3684 {
3688 }
3691 }
3693 }
3695 /**
3696 * Move a vehicle chain one movement stop forwards.
3697 * @param v First vehicle to move.
3698 * @param nomove Stop moving this and all following vehicles.
3699 * @param reverse Set to false to not execute the vehicle reversing. This does not change any other logic.
3700 * @return True if the vehicle could be moved forward, false otherwise.
3701 */
3703 {
3710 }
3715 }
3717 /* For every vehicle after and including the given vehicle */
3724 /* Not inside tunnel */
3726 /* Staying in the old tile */
3728 /* Inside depot */
3733 /* Not inside depot */
3735 /* Reverse when we are at the end of the track already, do not move to the new position */
3741 }
3743 /* The new position is the end of the platform */
3745 }
3746 }
3748 /* A new tile is about to be entered. */
3750 /* Determine what direction we're entering the new tile from */
3754 /* Get the status of the tracks in the new tile and mask
3755 * away the bits that aren't reachable. */
3760 TrackBits red_signals = TrackdirBitsToTrackBits(TrackStatusToRedSignals(ts) & reachable_trackdirs);
3764 /* We allow wagons to make 90 deg turns, because forbid_90_deg
3765 * can be switched on halfway a turn */
3767 }
3772 /* Check if the new tile constrains tracks that are compatible
3773 * with the current train, if not, bail out. */
3777 TrackBits chosen_track;
3779 /* Currently the locomotive is active. Determine which one of the
3780 * available tracks to choos/// e */
3786 /* For each signal we find decrease the counter by one.
3787 * We start at two, so the first signal we pass decreases
3788 * this to one, then if we reach the next signal it is
3789 * decreased to zero and we won't pass that new signal. */
3794 /* However, we do not want to be stopped by PBS signals
3795 * entered via the back. */
3798 }
3799 }
3801 /* Check if it's a red signal and that force proceed is not clicked. */
3803 /* In front of a red signal */
3806 /* Don't handle stuck trains here. */
3813 if (!_settings_game.pf.reverse_at_signals || ++v->wait_counter < _settings_game.pf.wait_oneway_signal * 20) return false;
3818 if (!_settings_game.pf.reverse_at_signals || ++v->wait_counter < _settings_game.pf.wait_twoway_signal * 73) {
3824 /* check if a train is waiting on the other side */
3826 }
3827 }
3829 /* If we would reverse but are currently in a PBS block and
3830 * reversing of stuck trains is disabled, don't reverse.
3831 * This does not apply if the reason for reversing is a one-way
3832 * signal blocking us, because a train would then be stuck forever. */
3833 if (!_settings_game.pf.reverse_at_signals && !HasOnewaySignalBlockingTrackdir(gp.new_tile, i) &&
3837 }
3842 if (IsPlainRailTile(gp.new_tile) && HasSignals(gp.new_tile) && IsRestrictedSignal(gp.new_tile)) {
3845 const TraceRestrictProgram *prog = GetExistingTraceRestrictProgram(gp.new_tile, TrackdirToTrack(dir));
3847 TraceRestrictProgramResult out;
3851 }
3852 }
3853 }
3854 }
3857 /* The wagon is active, simply follow the prev vehicle. */
3859 /* Choose the same track as prev */
3861 /* Vehicles entering tunnels enter the wormhole earlier than for bridges.
3862 * However, just choose the track into the wormhole. */
3867 }
3869 /* Choose the track that leads to the tile where prev is.
3870 * This case is active if 'prev' is already on the second next tile, when 'v' just enters the next tile.
3871 * I.e. when the tile between them has only space for a single vehicle like
3872 * 1) horizontal/vertical track tiles and
3873 * 2) some orientations of tunnel entries, where the vehicle is already inside the wormhole at 8/16 from the tile edge.
3874 * Is also the train just reversing, the wagon inside the tunnel is 'on' the tile of the opposite tunnel entry.
3875 */
3881 };
3885 }
3887 }
3889 /* Make sure chosen track is a valid track */
3895 /* Update XY to reflect the entrance to the new tile, and select the direction to use */
3901 /* Call the landscape function and tell it that the vehicle entered the tile */
3905 }
3908 /* If red signal stop. */
3910 if (IsTunnelBridgeSignalSimulationEntrance(gp.new_tile) && GetTunnelBridgeSignalState(gp.new_tile) == SIGNAL_STATE_RED) {
3914 }
3918 }
3919 /* Flip signal on tunnel entrance tile red. */
3922 }
3923 }
3932 /* notify logic signals of the state change */
3934 }
3936 /* Clear any track reservation when the last vehicle leaves the tile */
3943 }
3947 }
3949 /* We need to update signal status, but after the vehicle position hash
3950 * has been updated by UpdateInclination() */
3955 const AccelerationSlowdownParams *asp = &_accel_slowdown[GetRailTypeInfo(v->railtype)->acceleration_type];
3957 v->cur_speed -= (diff == DIRDIFF_45RIGHT || diff == DIRDIFF_45LEFT ? asp->small_turn : asp->large_turn) * v->cur_speed >> 8;
3958 }
3961 }
3966 /* If we are approaching a crossing that is reserved, play the sound now. */
3970 {
3972 bool is_no_sound_rail_type = (railTypeLabel == _planning_tracks_label || railTypeLabel == _pipeline_tracks_label || railTypeLabel == _wires_tracks_label);
3974 if (HasCrossingReservation(crossing) && _settings_client.sound.ambient && !is_no_sound_rail_type)
3976 }
3978 /* Always try to extend the reservation when entering a tile. */
3980 }
3983 /* The new position is the location where we want to stop */
3985 }
3986 }
3988 /* Handle signal simulation on tunnel/bridge. */
3990 if (old_tile != gp.new_tile && IsTunnelBridgeWithSignalSimulation(v->tile) && (v->IsFrontEngine() || v->Next() == NULL)) {
3992 if (v->IsFrontEngine() && v->force_proceed == 0 && IsTunnelBridgeSignalSimulationExit(v->tile))
3994 /* Entered wormhole set counters. */
3995 v->wait_counter = (TILE_SIZE * _settings_game.construction.simulated_wormhole_signals) - TILE_SIZE;
3997 }
4001 if (distance == 0) v->wait_counter = (TILE_SIZE * _settings_game.construction.simulated_wormhole_signals);
4004 /* Check if track in front is free and see if we can leave wormhole. */
4010 }
4018 }
4019 /* flip signal in front to red on bridges*/
4023 }
4024 }
4025 }
4027 if (v->tunnel_bridge_signal_num > 0 && distance == (TILE_SIZE * _settings_game.construction.simulated_wormhole_signals) - TILE_SIZE) HandleSignalBehindTrain(v, v->load_unload_ticks - 2);
4029 /* We left ramp into wormhole. */
4034 }
4035 }
4049 }
4050 }
4052 if (old_tile == gp.new_tile && IsTunnelBridgeWithSignalSimulation(v->tile) && v->IsFrontEngine()) {
4058 // bridge ramp facing towards us
4061 // tunnel exit at same height
4063 }
4064 }
4068 }
4070 if (IsTooCloseBehindTrain(v, next_tile, TILE_SIZE * _settings_game.construction.simulated_wormhole_signals, true)) {
4072 }
4073 }
4074 }
4076 if (IsTileType(gp.new_tile, MP_TUNNELBRIDGE) && HasBit(VehicleEnterTile(v, gp.new_tile, gp.x, gp.y), VETS_ENTERED_WORMHOLE)) {
4077 /* Perform look-ahead on tunnel exit. */
4081 }
4082 /* Prevent v->UpdateInclination() being called with wrong parameters.
4083 * This could happen if the train was reversed inside the tunnel/bridge. */
4086 }
4092 /* update the Z position of the vehicle */
4096 /* This is the first vehicle in the train */
4098 }
4099 }
4102 }
4103 }
4105 /* update image of train, as well as delta XY */
4113 }
4115 /* update the Z position of the vehicle */
4116 int old_z = v->UpdateInclination(gp.new_tile != gp.old_tile, false, v->track == TRACK_BIT_WORMHOLE);
4119 /* This is the first vehicle in the train */
4121 }
4127 /* We are entering a block with PBS signals right now, but
4128 * not through a PBS signal. This means we don't have a
4129 * reservation right now. As a conventional signal will only
4130 * ever be green if no other train is in the block, getting
4131 * a path should always be possible. If the player built
4132 * such a strange network that it is not possible, the train
4133 * will be marked as stuck and the player has to deal with
4134 * the problem. */
4139 }
4143 {
4144 /* We went past a long reserve PBS signal. Try to extend the
4145 * reservation if reserving failed at another LR signal. */
4153 ChooseTrainTrack(v, ft.m_new_tile, ft.m_exitdir, TrackdirBitsToTrackBits(ft.m_new_td_bits), true, NULL, false);
4154 }
4155 }
4158 }
4160 }
4161 }
4163 /* Signals can only change when the first
4164 * (above) or the last vehicle moves. */
4169 if (IsTileType(gp.old_tile, MP_RAILWAY) && HasSignals(gp.old_tile) && IsRestrictedSignal(gp.old_tile)) {
4170 const TrackdirBits rev_tracks = TrackBitsToTrackdirBits(GetTrackBits(gp.old_tile)) & DiagdirReachesTrackdirs(ReverseDiagDir(enterdir));
4176 TraceRestrictProgramResult out;
4180 }
4181 }
4182 }
4183 }
4184 }
4186 /* Do not check on every tick to save some computing time. */
4187 if (v->IsFrontEngine() && v->tick_counter % _settings_game.pf.path_backoff_interval == 0) CheckNextTrainTile(v);
4188 }
4194 invalid_rail:
4195 /* We've reached end of line?? */
4198 reverse_train_direction:
4204 }
4207 }
4209 /**
4210 * Collect trackbits of all crashed train vehicles on a tile
4211 * @param v Vehicle passed from Find/HasVehicleOnPos()
4212 * @param data trackdirbits for the result
4213 * @return NULL to iterate over all vehicles on the tile.
4214 */
4216 {
4222 /* Vehicle is inside a wormhole, v->track contains no useful value then. */
4226 }
4227 }
4230 }
4232 /**
4233 * Deletes/Clears the last wagon of a crashed train. It takes the engine of the
4234 * train, then goes to the last wagon and deletes that. Each call to this function
4235 * will remove the last wagon of a crashed train. If this wagon was on a crossing,
4236 * or inside a tunnel/bridge, recalculate the signals as they might need updating
4237 * @param v the Vehicle of which last wagon is to be removed
4238 */
4240 {
4243 /* Go to the last wagon and delete the link pointing there
4244 * *u is then the one-before-last wagon, and *v the last
4245 * one which will physically be removed */
4251 /* Recalculate cached train properties */
4253 /* Update the depot window if the first vehicle is in depot -
4254 * if v == first, then it is updated in PreDestructor() */
4257 }
4259 }
4261 /* 'v' shouldn't be accessed after it has been deleted */
4270 /* Vehicle is inside a wormhole, v->track contains no useful value then. */
4272 }
4278 /* If there are still crashed vehicles on the tile, give the track reservation to them */
4282 /* It is important that these two are the first in the loop, as reservation cannot deal with every trackbit combination */
4284 Track t;
4286 }
4288 /* check if the wagon was on a road/rail-crossing */
4291 /* Update signals */
4303 }
4304 if (IsTunnelBridgeSignalSimulationEntrance(entrance) && GetTunnelBridgeSignalState(entrance) == SIGNAL_STATE_RED) {
4307 }
4308 }
4309 }
4314 }
4315 }
4317 /**
4318 * Rotate all vehicles of a (crashed) train chain randomly to animate the crash.
4319 * @param v First crashed vehicle.
4320 */
4322 {
4325 };
4328 /* We don't need to twist around vehicles if they're not visible */
4331 /* Refrain from updating the z position of the vehicle when on
4332 * a bridge, because UpdateInclination() will put the vehicle under
4333 * the bridge in that case */
4339 }
4340 }
4342 }
4344 /**
4345 * Handle a crashed train.
4346 * @param v First train vehicle.
4347 * @return %Vehicle chain still exists.
4348 */
4350 {
4355 }
4357 uint32 r;
4370 EV_EXPLOSION_SMALL);
4372 }
4374 }
4382 }
4385 }
4387 /** Maximum speeds for train that is broken down or approaching line end */
4390 };
4393 /**
4394 * Train is approaching line end, slow down and possibly reverse
4395 *
4396 * @param v front train engine
4397 * @param signal not line end, just a red signal
4398 * @param reverse Set to false to not execute the vehicle reversing. This does not change any other logic.
4399 * @return true iff we did NOT have to reverse
4400 */
4402 {
4403 /* Calc position within the current tile */
4407 /* for diagonal directions, 'x' will be 0..15 -
4408 * for other directions, it will be 1, 3, 5, ..., 15 */
4418 }
4420 /* Do not reverse when approaching red signal. Make sure the vehicle's front
4421 * does not cross the tile boundary when we do reverse, but as the vehicle's
4422 * location is based on their center, use half a vehicle's length as offset.
4423 * Multiply the half-length by two for straight directions to compensate that
4424 * we only get odd x offsets there. */
4425 if (!signal && x + (v->gcache.cached_veh_length + 1) / 2 * (IsDiagonalDirection(v->direction) ? 1 : 2) >= TILE_SIZE) {
4426 /* we are too near the tile end, reverse now */
4430 }
4432 /* slow down */
4438 }
4441 /**
4442 * Determines whether train would like to leave the tile
4443 * @param v train to test
4444 * @return true iff vehicle is NOT entering or inside a depot or tunnel/bridge
4445 */
4447 {
4448 /* Exit if inside a tunnel/bridge or a depot */
4453 /* entering a tunnel/bridge? */
4457 }
4459 /* entering a depot? */
4463 }
4466 }
4469 /**
4470 * Determines whether train is approaching a rail-road crossing
4471 * (thus making it barred)
4472 * @param v front engine of train
4473 * @return TileIndex of crossing the train is approaching, else INVALID_TILE
4474 * @pre v in non-crashed front engine
4475 */
4477 {
4486 /* not a crossing || wrong axis || unusable rail (wrong type or owner) */
4490 }
4493 }
4496 /**
4497 * Checks for line end. Also, bars crossing at next tile if needed
4498 *
4499 * @param v vehicle we are checking
4500 * @param reverse Set to false to not execute the vehicle reversing. This does not change any other logic.
4501 * @return true iff we did NOT have to reverse
4502 */
4504 {
4505 /* First, handle broken down train */
4515 }
4519 /* Determine the non-diagonal direction in which we will exit this tile */
4521 /* Calculate next tile */
4524 /* Determine the track status on the next tile */
4531 /* We are sure the train is not entering a depot, it is detected above */
4533 /* mask unreachable track bits if we are forbidden to do 90deg turns */
4537 }
4539 /* no suitable trackbits at all || unusable rail (wrong type or owner) */
4542 }
4544 /* approaching red signal */
4547 /* approaching a rail/road crossing? then make it red */
4550 if (IsTileType(tile, MP_TUNNELBRIDGE) && GetTunnelBridgeTransportType(tile) == TRANSPORT_RAIL &&
4551 IsTunnelBridgeSignalSimulationEntrance(tile) && GetTunnelBridgeSignalState(tile) == SIGNAL_STATE_RED) {
4553 }
4556 }
4558 /* Calculate the summed up value of all parts of a train */
4560 {
4567 }
4570 {
4571 /* train has crashed? */
4574 }
4579 }
4581 /* train is broken down? */
4586 }
4588 /* exit if train is stopped */
4591 bool valid_order = !v->current_order.IsType(OT_NOTHING) && v->current_order.GetType() != OT_CONDITIONAL;
4600 /* Try to reserve a path when leaving the station as we
4601 * might not be marked as wanting a reservation, e.g.
4602 * when an overlength train gets turned around in a station. */
4606 if (UpdateSignalsOnSegment(v->tile, dir, v->owner) == SIGSEG_PBS || _settings_game.pf.reserve_paths) {
4608 }
4610 }
4620 /* We had no order but have an order now, do look ahead. */
4623 }
4625 /* Handle stuck trains. */
4629 /* Should we try reversing this tick if still stuck? */
4630 bool turn_around = v->wait_counter % (_settings_game.pf.wait_for_pbs_path * DAY_TICKS) == 0 && _settings_game.pf.reverse_at_signals;
4632 if (!turn_around && v->wait_counter % _settings_game.pf.path_backoff_interval != 0 && v->force_proceed == TFP_NONE) return true;
4634 /* Still stuck. */
4637 if (HasBit(v->flags, VRF_TRAIN_STUCK) && v->wait_counter > 2 * _settings_game.pf.wait_for_pbs_path * DAY_TICKS) {
4638 /* Show message to player. */
4642 }
4644 }
4645 /* Exit if force proceed not pressed, else reset stuck flag anyway. */
4650 }
4651 }
4657 }
4661 /* we need to invalidate the widget if we are stopping from 'Stopping 0 km/h' to 'Stopped' */
4663 /* If we manually stopped, we're not force-proceeding anymore. */
4666 }
4670 /* if the vehicle has speed 0, update the last_speed field. */
4674 /* Loop until the train has finished moving. */
4678 /* Don't continue to move if the train crashed. */
4680 /* Determine distance to next map position */
4683 /* No more moving this tick */
4687 /* Do not skip waypoints (incl. 'via' stations) when passing through at full speed. */
4693 }
4694 }
4696 }
4702 }
4704 if (v->progress == 0) v->progress = j; // Save unused spd for next time, if TrainController didn't set progress
4707 }
4709 /**
4710 * Get running cost for the train consist.
4711 * @return Yearly running costs.
4712 */
4714 {
4722 uint cost_factor = GetVehicleProperty(v, PROP_TRAIN_RUNNING_COST_FACTOR, e->u.rail.running_cost);
4725 /* Halve running cost for multiheaded parts */
4732 }
4734 /**
4735 * Update train vehicle data for a tick.
4736 * @return True if the vehicle still exists, false if it has ceased to exist (front of consists only).
4737 */
4739 {
4743 if (!((this->vehstatus & VS_STOPPED) || this->IsChainInDepot()) || this->cur_speed > 0) this->running_ticks++;
4751 /* Delete flooded standalone wagon chain */
4755 }
4756 }
4759 }
4761 /**
4762 * Check whether a train needs service, and if so, find a depot or service it.
4763 * @return v %Train to check.
4764 */
4766 {
4767 if (Company::Get(v->owner)->settings.vehicle.servint_trains == 0 || !v->NeedsAutomaticServicing()) return;
4771 }
4773 uint max_penalty;
4778 }
4781 /* Only go to the depot if it is not too far out of our way. */
4784 /* If we were already heading for a depot but it has
4785 * suddenly moved farther away, we continue our normal
4786 * schedule? */
4789 }
4791 }
4799 }
4805 }
4807 /** Update day counters of the train vehicle. */
4809 {
4821 /* update destination */
4825 }
4828 /* running costs */
4829 CommandCost cost(EXPENSES_TRAIN_RUN, this->GetRunningCost() * this->running_ticks / (DAYS_IN_YEAR * DAY_TICKS));
4838 }
4839 }
4840 }
4842 /**
4843 * Get the tracks of the train vehicle.
4844 * @return Current tracks of the vehicle.
4845 */
4847 {
4852 /* We'll assume the train is facing outwards */
4854 }
4857 /* train in tunnel or on bridge, so just use his direction and assume a diagonal track */
4859 }
4862 }
4865 /* Get the pixel-width of the image that is used for the train vehicle
4866 * @return: the image width number in pixel
4867 */
4869 {
4877 }
4882 }
4883 //printf(" refwid:%d gdiw.cachedvehlen(%d):%d ", reference_width, this->engine_type, this->gcache.cached_veh_length);
4885 }
4888 {
4924 // Make sure we set EVERYTHING to virtual, even articulated parts.
4927 }
4938 }
4941 {
4947 }
4948 }
4953 }
4954 }
4959 int num_vehicles = (e->u.rail.railveh_type == RAILVEH_MULTIHEAD ? 2 : 1) + CountArticulatedParts(eid, false);
4963 }
5006 }
5008 // Make sure we set EVERYTHING to virtual, even articulated parts.
5011 }
5020 }
5022 /**
5023 * Build a virtual train vehicle.
5024 * @param tile unused
5025 * @param flags type of operation
5026 * @param p1 the engine ID to build
5027 * @param p2 unused
5028 * @param text unused
5029 * @return the cost of this operation or an error
5030 */
5031 CommandCost CmdBuildVirtualRailVehicle(TileIndex tile, DoCommandFlag flags, uint32 p1, uint32 p2, const char *text)
5032 {
5037 }
5047 }
5048 }
5051 }
5053 /**
5054 * Replace a vehicle based on a template replacement order.
5055 * @param tile unused
5056 * @param flags type of operation
5057 * @param p1 the ID of the vehicle to replace.
5058 * @param p2 whether the vehicle should stay in the depot.
5059 * @param text unused
5060 * @return the cost of this operation or an error
5061 */
5062 CommandCost CmdTemplateReplaceVehicle(TileIndex tile, DoCommandFlag flags, uint32 p1, uint32 p2, const char *text)
5063 {
5085 }
5092 /* first some tests on necessity and sanity */
5106 // if a train shall keep its old refit, store the refit setting of its first vehicle
5112 }
5113 }
5114 }
5116 // TODO: set result status to success/no success before returning
5119 /* before returning, release incoming train first if 2nd param says so */
5122 }
5123 }
5133 }
5134 }
5135 }
5137 /* define replacement behavior */
5142 /// step 1: generate primary for newchain and generate remainder_chain
5143 // 1. primary of incoming might already fit the template
5144 // leave incoming's primary as is and move the rest to a free chain = remainder_chain
5145 // 2. needed primary might be one of incoming's member vehicles
5146 // 3. primary might be available as orphan vehicle in the depot
5147 // 4. we need to buy a new engine for the primary
5148 // all options other than 1. need to make sure to copy incoming's primary's status
5153 move_cost.AddCost(CmdMoveRailVehicle(tile, flags, remainder_chain->index | (1 << 20), INVALID_VEHICLE, 0));
5154 }
5156 // new_chain is the needed engine, move it to an empty spot in the depot
5158 move_cost.AddCost(DoCommand(tile, new_chain->index, INVALID_VEHICLE, flags, CMD_MOVE_RAIL_VEHICLE));
5160 }
5161 else if (reuseDepot && (tmp_chain = DepotContainsEngine(tile, eid, incoming)) && tmp_chain != NULL) { // 3
5163 move_cost.AddCost(DoCommand(tile, new_chain->index, INVALID_VEHICLE, flags, CMD_MOVE_RAIL_VEHICLE));
5165 }
5168 /* break up in case buying the vehicle didn't succeed */
5173 /* make sure the newly built engine is not attached to any free wagons inside the depot */
5174 move_cost.AddCost(DoCommand(tile, new_chain->index, INVALID_VEHICLE, flags, CMD_MOVE_RAIL_VEHICLE));
5175 /* prepare the remainder chain */
5177 }
5178 // If we bought a new engine or reused one from the depot, copy some parameters from the incoming primary engine
5184 // additionally, if we don't want to use the template refit, refit as incoming
5185 // the template refit will be set further down, if we use it at all
5188 DoCommand(new_chain->tile, new_chain->index, store_refit_ct | store_refit_csubt << 8 | 1 << 16 | (1 << 5), flags, cb);
5189 }
5191 }
5193 /// step 2: fill up newchain according to the template
5194 // foreach member of template (after primary):
5195 // 1. needed engine might be within remainder_chain already
5196 // 2. needed engine might be orphaned within the depot (copy status)
5197 // 3. we need to buy (again) (copy status)
5201 // 1. engine contained in remainder chain
5202 if ((tmp_chain = ChainContainsEngine(cur_tmpl->engine_type, remainder_chain)) && tmp_chain != NULL) {
5203 // advance remainder_chain (if necessary) to not lose track of it
5207 }
5208 // 2. engine contained somewhere else in the depot
5209 else if (reuseDepot && (tmp_chain = DepotContainsEngine(tile, cur_tmpl->engine_type, new_chain)) && tmp_chain != NULL) {
5211 }
5212 // 3. must buy new engine
5217 }
5221 }
5222 // TODO: is this enough ? might it be that we bought a new wagon here and it now has std refit ?
5226 DoCommand(tmp_chain->tile, tmp_chain->index, cur_tmpl->cargo_type | cur_tmpl->cargo_subtype << 8 | 1 << 16 | (1 << 5), flags, cb);
5227 // old
5228 // CopyWagonStatus(cur_tmpl, tmp_chain);
5231 DoCommand(tmp_chain->tile, tmp_chain->index, store_refit_ct | store_refit_csubt << 8 | 1 << 16 | (1 << 5), flags, cb);
5232 }
5233 }
5236 }
5237 }
5238 /* no replacement done */
5241 }
5242 /// step 3: reorder and neutralize the remaining vehicles from incoming
5243 // wagons remaining from remainder_chain should be filled up in as few freewagonchains as possible
5244 // each locos might be left as singular in the depot
5245 // neutralize each remaining engine's status
5247 // refit, only if the template option is set so
5250 }
5256 // point incoming to the newly created train so that starting/stopping from the calling function can be done
5265 }
5267 /* Redraw main gui for changed statistics */
5273 }