return false;

		}

			m_new_td_bits &= (TrackdirBits)~(int)TrackdirCrossesTrackdirs(m_old_td);

			if (m_new_td_bits == TRACKDIR_BIT_NONE) {

				m_err = EC_90DEG;

 * One-way-roads are taken into account. Signals are not tested.

 *

 * @param dst_tile The tile of interest.

 * @param src_trackdir The direction the vehicle is currently moving.

 * @param type The transporttype of the vehicle.

 * @param subtype For TRANSPORT_ROAD the compatible RoadTypes of the vehicle.

 * @return The Trackdirs the vehicle can continue moving on.

 */

{

	TrackdirBits trackdirbits = TrackStatusToTrackdirBits(GetTileTrackStatus(dst_tile, type, subtype));

	trackdirbits &= TrackdirReachesTrackdirs(src_trackdir);

	/* Filter out trackdirs that would make 90 deg turns for trains */

	DEBUG(npf, 6, "After filtering: (%d, %d), possible trackdirs: 0x%X", TileX(dst_tile), TileY(dst_tile), trackdirbits);

	if (CheckIgnoreFirstTile(&current->path)) {

		/* Do not perform any checks that involve src_tile */

		dst_tile = src_tile + TileOffsByDiagDir(src_exitdir);

	} else if (IsTileType(src_tile, MP_TUNNELBRIDGE) && GetTunnelBridgeDirection(src_tile) == src_exitdir) {

		/* We drive through the wormhole and arrive on the other side */

		dst_tile = GetOtherTunnelBridgeEnd(src_tile);

			src_trackdir = ReverseTrackdir(src_trackdir);

		}

		if (trackdirbits == TRACKDIR_BIT_NONE) {

			/* We cannot enter the next tile. Road vehicles can reverse, others reach dead end */

			dst_tile = src_tile;

			src_trackdir = ReverseTrackdir(src_trackdir);

		}

	}

	/* Check for reachable tracks. */

	ft.m_new_td_bits &= DiagdirReachesTrackdirs(ft.m_exitdir);

	if (ft.m_new_td_bits == TRACKDIR_BIT_NONE) return include_line_end;

	if (ft.m_new_td_bits != TRACKDIR_BIT_NONE && KillFirstBit(ft.m_new_td_bits) == TRACKDIR_BIT_NONE) {

	/* Check for reachable tracks. */

	ft.m_new_td_bits &= DiagdirReachesTrackdirs(ft.m_exitdir);

	return !HasReservedTracks(ft.m_new_tile, TrackdirBitsToTrackBits(ft.m_new_td_bits));

}

#include "strings_type.h"

#include "date_type.h"

#include "signal_type.h"

/** Railtype flags. */

enum RailTypeFlags {

	RTF_NO_LEVEL_CROSSING = 1,                           ///< Bit number for disallowing level crossings.

	RTF_HIDDEN            = 2,                           ///< Bit number for hiding from selection.

	RTF_NO_SPRITE_COMBINE = 3,                           ///< Bit number for using non-combined junctions.

	RTFB_NONE              = 0,                          ///< All flags cleared.

	RTFB_CATENARY          = 1 << RTF_CATENARY,          ///< Value for drawing a catenary.

	RTFB_NO_LEVEL_CROSSING = 1 << RTF_NO_LEVEL_CROSSING, ///< Value for disallowing level crossings.

	RTFB_HIDDEN            = 1 << RTF_HIDDEN,            ///< Value for hiding from selection.

	RTFB_NO_SPRITE_COMBINE = 1 << RTF_NO_SPRITE_COMBINE, ///< Value for using non-combined junctions.

};

DECLARE_ENUM_AS_BIT_SET(RailTypeFlags)

}

/**

 * Returns the cost of building the specified railtype.

 * @param railtype The railtype being built.

 * @return The cost multiplier.

			if (HasPbsSignalOnTrackdir(ft.m_new_tile, FindFirstTrackdir(ft.m_new_td_bits))) {

				/* If the next tile is a PBS signal, try to make a reservation. */

				TrackBits tracks = TrackdirBitsToTrackBits(ft.m_new_td_bits);

					tracks &= ~TrackCrossesTracks(TrackdirToTrack(ft.m_old_td));

				}

				ChooseTrainTrack(v, ft.m_new_tile, ft.m_exitdir, tracks, false, NULL, false);

			if (HasOnewaySignalBlockingTrackdir(ft.m_new_tile, FindFirstTrackdir(ft.m_new_td_bits))) break;

		}

			ft.m_new_td_bits &= ~TrackdirCrossesTrackdirs(ft.m_old_td);

			if (ft.m_new_td_bits == TRACKDIR_BIT_NONE) break;

		}

	while (tile != stopped || cur_td != stopped_td) {

		if (!ft.Follow(tile, cur_td)) break;

			ft.m_new_td_bits &= ~TrackdirCrossesTrackdirs(ft.m_old_td);

			assert(ft.m_new_td_bits != TRACKDIR_BIT_NONE);

		}

		DiagDirection exitdir = TrackdirToExitdir(res_dest.trackdir);

		TileIndex     next_tile = TileAddByDiagDir(res_dest.tile, exitdir);

		TrackBits     reachable = TrackdirBitsToTrackBits((TrackdirBits)(GetTileTrackStatus(next_tile, TRANSPORT_RAIL, 0))) & DiagdirReachesTracks(exitdir);

			reachable &= ~TrackCrossesTracks(TrackdirToTrack(res_dest.trackdir));

		}

	TileIndex     new_tile = TileAddByDiagDir(origin.tile, exitdir);

	TrackBits     reachable = TrackdirBitsToTrackBits(TrackStatusToTrackdirBits(GetTileTrackStatus(new_tile, TRANSPORT_RAIL, 0)) & DiagdirReachesTrackdirs(exitdir));

	bool res_made = false;

	ChooseTrainTrack(v, new_tile, exitdir, reachable, true, &res_made, mark_as_stuck);

				TrackBits red_signals = TrackdirBitsToTrackBits(TrackStatusToRedSignals(ts) & reachable_trackdirs);

				TrackBits bits = TrackdirBitsToTrackBits(trackdirbits);

					/* We allow wagons to make 90 deg turns, because forbid_90_deg

					 * can be switched on halfway a turn */

					bits &= ~TrackCrossesTracks(FindFirstTrack(v->track));

	/* mask unreachable track bits if we are forbidden to do 90deg turns */

	TrackBits bits = TrackdirBitsToTrackBits(trackdirbits);

		bits &= ~TrackCrossesTracks(FindFirstTrack(v->track));

	}