// Convert into a bit position that CMD_REMOVE_SINGLE_RAIL expects.

	bit = FindFirstBit(b);

	// Then remove and signals if there are any.

	if (IsTileType(tile, MP_RAILWAY) &&

		DoCommand(tile, 0, 0, DC_EXEC, CMD_REMOVE_SIGNALS);

	}

	// And also remove the rail.

	if (CmdFailed(DoCommand(tile, 0, bit, DC_EXEC, CMD_REMOVE_SINGLE_RAIL)))

		return false;

static TrackBits GetRailTrackBitsUniversal(TileIndex t, byte *override)

{

	switch (GetTileType(t)) {

		case MP_RAILWAY:

			if (GetRailType(t) != RAILTYPE_ELECTRIC) return 0;

			switch (GetRailTileType(t)) {

					return GetTrackBits(t);

					if (GetRailTileSubtype(t) == RAIL_SUBTYPE_WAYPOINT) return GetRailWaypointBits(t);

				default:

					return 0;

			}

			break;

		case MP_TUNNELBRIDGE:

}

void DrawCatenary(const TileInfo *ti)

{

	switch (GetTileType(ti->tile)) {

		case MP_RAILWAY:

				const SortableSpriteStruct *sss = &CatenarySpriteData[WIRE_DEPOT_SW + ReverseDiagDir(GetRailDepotDirection(ti->tile))];

				AddSortableSpriteToDraw( sss->image, ti->x + sss->x_offset, ti->y + sss->y_offset,

					sss->x_size, sss->y_size, sss->z_size, GetSlopeZ(ti->x, ti->y) + sss->z_offset);

				return;

			}

			/* Fall through */

	while (true) {

		TileIndex new_tile = TILE_ADD(tile, delta);

		if (waypoint) {

			if (!IsTileType(new_tile, MP_RAILWAY)) break;

			if (GetRailTileSubtype(new_tile) != RAIL_SUBTYPE_WAYPOINT) break;

			if (check_axis && GetWaypointAxis(new_tile) != orig_axis) break;

		} else {

			if (!IsRailwayStationTile(new_tile)) break;

			if (check_type && GetCustomStationSpecIndex(new_tile) != orig_type) break;

			if (check_axis && GetRailStationAxis(new_tile) != orig_axis) break;

		Trackdir dst_trackdir;

		dst_trackdir =  FindFirstBit2x64(trackdirbits);

		trackdirbits = KillFirstBit2x64(trackdirbits);

		DEBUG(npf, 5)("Expanded into trackdir: %d, remaining trackdirs: 0x%X", dst_trackdir, trackdirbits);

		/* Check for oneway signal against us */

			if (HasSignalOnTrackdir(dst_tile, ReverseTrackdir(dst_trackdir)) && !HasSignalOnTrackdir(dst_tile, dst_trackdir))

				// if one way signal not pointing towards us, stop going in this direction.

				break;

		}

		{

			/* We've found ourselves a neighbour :-) */

		_m[i].m4 = _old_map3[i * 2 + 1];

	}

	for (i = 0; i < OLD_MAP_SIZE; i ++) {

		if (IsTileType(i, MP_RAILWAY)) {

			/* We save presignals different from TTDPatch, convert them */

				/* This byte is always zero in TTD for this type of tile */

				if (_m[i].m4) /* Convert the presignals to our own format */

					_m[i].m4 = (_m[i].m4 >> 1) & 7;

			}

			/* TTDPatch stores PBS things in L6 and all elsewhere; so we'll just

			* clear it for ourselves and let OTTD's rebuild PBS itself */

	// check depot first

	if (_patches.gotodepot) {

		switch (GetTileType(tile)) {

		case MP_RAILWAY:

			if (v->type == VEH_Train && IsTileOwner(tile, _local_player)) {

						GetRailTileSubtype(tile) == RAIL_SUBTYPE_DEPOT) {

					order.type = OT_GOTO_DEPOT;

					order.flags = OF_PART_OF_ORDERS;

					order.station = GetDepotByTile(tile)->index;

					return order;

				}

 * given rail tile.

 */

static inline bool HasSignalOnTrack(TileIndex tile, Track track)

{

	assert(IsValidTrack(track));

	return

		(_m[tile].m3 & SignalOnTrack(track)) != 0;

}

/**

 * Checks for the presence of signals along the given trackdir on the given

 * rail tile.

 * the signal that is facing us (for which we stop when it's red).

 */

static inline bool HasSignalOnTrackdir(TileIndex tile, Trackdir trackdir)

{

	assert (IsValidTrackdir(trackdir));

	return

		_m[tile].m3 & SignalAlongTrackdir(trackdir);

}

/**

 * Gets the state of the signal along the given trackdir.

 *

{

	RailTileType type = GetRailTileType(tile);

	TrackBits current; /* The current track layout */

	TrackBits future; /* The track layout we want to build */

	_error_message = STR_1001_IMPOSSIBLE_TRACK_COMBINATION;

		return false; /* Cannot build anything on depots and checkpoints */

	/* So, we have a tile with tracks on it (and possibly signals). Let's see

	 * what tracks first */

	current = GetTrackBits(tile);

	future = current | to_build;

		/* Nothing new is being built */

		_error_message = STR_1007_ALREADY_BUILT;

		return false;

	}

	/* Let's see if we may build this */

		/* If we are not allowed to overlap (flag is on for ai players or we have

		 * signals on the tile), check that */

		return future == TRACK_BIT_HORZ || future == TRACK_BIT_VERT;

	} else {

		/* Normally, we may overlap and any combination is valid */

		return true;

		case MP_RAILWAY:

			if (!CheckTrackCombination(tile, trackbit, flags) ||

					!EnsureNoVehicle(tile)) {

				return CMD_ERROR;

			}

					!IsTileOwner(tile, _current_player) ||

					GetRailType(tile) != p1) {

				// Get detailed error message

				return DoCommand(tile, 0, 0, flags, CMD_LANDSCAPE_CLEAR);

			}

			// it is free to change orientation/pre-exit-combo signals

			cost = 0;

		}

	}

	if (flags & DC_EXEC) {

			// there are no signals at all on this tile yet

			_m[tile].m2 |= 0xF0;              // all signals are on

			_m[tile].m3 &= ~0xF0;          // no signals built by default

			SetSignalType(tile, SIGTYPE_NORMAL);

			SetSignalVariant(tile, sigvar);

		}

	if (CmdFailed(ValidateAutoDrag(&trackdir, tile, end_tile))) return CMD_ERROR;

	track = TrackdirToTrack(trackdir); /* trackdir might have changed, keep track in sync */

	// copy the signal-style of the first rail-piece if existing

		signals = _m[tile].m3 & SignalOnTrack(track);

		if (signals == 0) signals = SignalOnTrack(track); /* Can this actually occur? */

		// copy signal/semaphores style (independent of CTRL)

		semaphores = (GetSignalVariant(tile) == SIG_ELECTRIC ? 0 : 8);

	} else // no signals exist, drag a two-way signal stretch

	if (flags & DC_EXEC) {

		_m[tile].m3 &= ~SignalOnTrack(track);

		/* removed last signal from tile? */

		if (GB(_m[tile].m3, 4, 4) == 0) {

			SB(_m[tile].m2, 4, 4, 0);

			SetSignalVariant(tile, SIG_ELECTRIC); // remove any possible semaphores

		}

		SetSignalsOnBothDir(tile, track);

		MarkTileDirtyByTile(tile);

	int32 ret;

	byte m5;

	m5 = _m[tile].m5;

	if (flags & DC_AUTO) {

			return_cmd_error(STR_2004_BUILDING_MUST_BE_DEMOLISHED);

		}

		if (!IsTileOwner(tile, _current_player))

			return_cmd_error(STR_1024_AREA_IS_OWNED_BY_ANOTHER);

	}

	cost = 0;

	switch (GetRailTileType(tile)) {

		/* XXX: Why the fuck do we remove these thow signals first? */

			if (HasSignalOnTrack(tile, TRACK_X)) {

				ret = DoCommand(tile, TRACK_X, 0, flags, CMD_REMOVE_SIGNALS);

				if (CmdFailed(ret)) return CMD_ERROR;

				cost += ret;

			}

			if (HasSignalOnTrack(tile, TRACK_LOWER)) {

			if (!(flags & DC_EXEC)) {

				for (; m5 != 0; m5 >>= 1) if (m5 & 1) cost += _price.remove_rail;

				return cost;

			}

			/* FALLTHROUGH */

			uint i;

			for (i = 0; m5 != 0; i++, m5 >>= 1) {

				if (m5 & 1) {

					ret = DoCommand(tile, 0, i, flags, CMD_REMOVE_SINGLE_RAIL);

					if (CmdFailed(ret)) return CMD_ERROR;

					cost += ret;

				}

			}

			return cost;

		}

			if (GetRailTileSubtype(tile) == RAIL_SUBTYPE_DEPOT) {

				return RemoveTrainDepot(tile, flags);

			} else {

				return RemoveTrainWaypoint(tile, flags, false);

			}

{

	const RailtypeInfo *rti = GetRailTypeInfo(GetRailType(ti->tile));

	PalSpriteID image;

	_drawtile_track_palette = SPRITE_PALETTE(PLAYER_SPRITE_COLOR(GetTileOwner(ti->tile)));

		TrackBits rails = GetTrackBits(ti->tile);

		DrawTrackBits(ti, rails, false);

		if (_display_opt & DO_FULL_DETAIL) _detailed_track_proc[GetRailGroundType(ti->tile)](ti);

		/* draw signals also? */

	} else {

		/* draw depots / waypoints */

		const DrawTrackSeqStruct *drss;

		bool is_depot = GetRailTileSubtype(ti->tile) == RAIL_SUBTYPE_DEPOT;

static uint GetSlopeZ_Track(const TileInfo* ti)

{

	Slope tileh = ti->tileh;

	uint z = ti->z;

	if (tileh == SLOPE_FLAT) return z;

		return z + TILE_HEIGHT;

	} else {

		uint f = GetRailFoundation(ti->tileh, GetTrackBits(ti->tile));

		if (f != 0) {

			if (f < 15) return z + TILE_HEIGHT; // leveled foundation

	}

}

static Slope GetSlopeTileh_Track(TileIndex tile, Slope tileh)

{

	if (tileh == SLOPE_FLAT) return SLOPE_FLAT;

		return SLOPE_FLAT;

	} else {

		uint f = GetRailFoundation(tileh, GetTrackBits(tile));

		if (f == 0) return tileh;

		if (f < 15) return SLOPE_FLAT; // leveled foundation

		MarkTileDirtyByTile(tile);

	}

	if (quick_return) return;

	// Don't continue tile loop for depots

	new_ground = RAIL_GROUND_GRASS;

	if (old_ground != RAIL_GROUND_BARREN) { /* wait until bottom is green */

		/* determine direction of fence */

		TrackBits rail = GetTrackBits(tile);

{

	byte a;

	uint16 b;

	if (mode != TRANSPORT_RAIL) return 0;

		TrackBits rails = GetTrackBits(tile);

		uint32 ret = rails * 0x101;

			if (rails == TRACK_BIT_CROSS) ret |= 0x40;

		} else {

			/* has_signals */

			a = _m[tile].m3;

			b = _m[tile].m2;

}

static void GetTileDesc_Track(TileIndex tile, TileDesc *td)

{

	td->owner = GetTileOwner(tile);

	switch (GetRailTileType(tile)) {

			td->str = STR_1021_RAILROAD_TRACK;

			break;

			const StringID signal_type[] = {

				STR_RAILROAD_TRACK_WITH_NORMAL_SIGNALS,

				STR_RAILROAD_TRACK_WITH_PRESIGNALS,

				STR_RAILROAD_TRACK_WITH_EXITSIGNALS,

				STR_RAILROAD_TRACK_WITH_COMBOSIGNALS

			};

			td->str = signal_type[GetSignalType(tile)];

			break;

		}

		default:

			td->str = (GetRailTileSubtype(tile) == RAIL_SUBTYPE_DEPOT) ?

				STR_1023_RAILROAD_TRAIN_DEPOT : STR_LANDINFO_WAYPOINT;

			break;

	}

}

{

	VpStartPlaceSizing(tile, VPM_RAILDIRS);

}

static void PlaceExtraDepotRail(TileIndex tile, uint16 extra)

{

	if ((GetTrackBits(tile) & GB(extra, 8, 8)) == 0) return;

	DoCommandP(tile, _cur_railtype, extra & 0xFF, NULL, CMD_BUILD_SINGLE_RAIL | CMD_AUTO | CMD_NO_WATER);

}

static const uint16 _place_depot_extra[12] = {

#include "direction.h"

#include "tile.h"

typedef enum RailTileType {

	RAIL_TILE_TYPE_MASK      = 0xC0

} RailTileType;

static inline RailTileType GetRailTileType(TileIndex t)

{

	assert(IsTileType(t, MP_RAILWAY));

	return _m[t].m5 & RAIL_TILE_TYPE_MASK;

}

/**

 * Returns whether this is plain rails, with or without signals. Iow, if this

 */

static inline bool IsPlainRailTile(TileIndex tile)

{

	RailTileType rtt = GetRailTileType(tile);

}

/**

 * Checks if a rail tile has signals.

 */

static inline bool HasSignals(TileIndex tile)

{

}

/** These specify the subtype when the main rail type is

typedef enum RailTileSubtypes {

	RAIL_SUBTYPE_DEPOT    = 0x00,

	RAIL_SUBTYPE_WAYPOINT = 0x04,

	RAIL_SUBTYPE_MASK     = 0x3C

} RailTileSubtype;

/**

 * Returns the RailTileSubtype of a given rail tile with type

 */

static inline RailTileSubtype GetRailTileSubtype(TileIndex tile)

{

	return (RailTileSubtype)(_m[tile].m5 & RAIL_SUBTYPE_MASK);

}

typedef enum RailTypes {

	RAILTYPE_RAIL     = 0,

	SIGTYPE_EXIT    = 2, // presignal block exit

	SIGTYPE_COMBO   = 3  // presignal inter-block

} SignalType;

static inline SignalType GetSignalType(TileIndex t)

{

	return (SignalType)GB(_m[t].m4, 0, 2);

}

static inline void SetSignalType(TileIndex t, SignalType s)

{

	SB(_m[t].m4, 0, 2, s);

}

static inline bool IsPresignalEntry(TileIndex t)

{

	return GetSignalType(t) == SIGTYPE_ENTRY || GetSignalType(t) == SIGTYPE_COMBO;

	RAIL_GROUND_FENCE_HORIZ2 = 11,

	RAIL_GROUND_ICE_DESERT = 12,

} RailGroundType;

static inline void SetRailGroundType(TileIndex t, RailGroundType rgt)

{

		SB(_m[t].m4, 0, 4, rgt);

		return;

	}

	SB(_m[t].m2, 0, 4, rgt);

}

static inline RailGroundType GetRailGroundType(TileIndex t)

{

	/* TODO Unify this */

	return GB(_m[t].m2, 0, 4);

}

static inline bool IsBarrenRailGround(TileIndex t)

{

	return GetRailGroundType(t) == RAIL_GROUND_BARREN;

{

	SetTileType(t, MP_RAILWAY);

	SetTileOwner(t, o);

	_m[t].m2 = 0;

	_m[t].m3 = r;

	_m[t].m4 = 0;

}

static inline void MakeRailDepot(TileIndex t, Owner o, DiagDirection d, RailType r)

{

	SetTileType(t, MP_RAILWAY);

	SetTileOwner(t, o);

	_m[t].m2 = 0;

	_m[t].m3 = r;

	_m[t].m4 = 0;

}

static inline void MakeRailWaypoint(TileIndex t, Owner o, Axis a, RailType r, uint index)

{

	SetTileType(t, MP_RAILWAY);

	SetTileOwner(t, o);

	_m[t].m2 = index;

	_m[t].m3 = r;

	_m[t].m4 = 0;

}

#endif

			/* Level crossings may only be built on these slopes */

			if (!HASBIT(M(SLOPE_SEN) | M(SLOPE_ENW) | M(SLOPE_NWS) | M(SLOPE_NS) | M(SLOPE_WSE) | M(SLOPE_EW) | M(SLOPE_FLAT), tileh)) {

				return_cmd_error(STR_1000_LAND_SLOPED_IN_WRONG_DIRECTION);

			}

#undef M

			switch (GetTrackBits(tile)) {

				case TRACK_BIT_X:

					if (pieces & ROAD_X) goto do_clear;

					roaddir = AXIS_Y;

					break;

} TrainFindDepotData;

static bool NtpCallbFindDepot(TileIndex tile, TrainFindDepotData *tfdd, int track, uint length)

{

	if (IsTileType(tile, MP_RAILWAY) &&

			IsTileOwner(tile, tfdd->owner) &&

			GetRailTileSubtype(tile) == RAIL_SUBTYPE_DEPOT) {

		tfdd->best_length = length;

		tfdd->tile = tile;

		return true;

	}

	DIAGDIR_SW, DIAGDIR_NW, DIAGDIR_NW, DIAGDIR_SW, DIAGDIR_NW, DIAGDIR_NE

};

static void TrainMovedChangeSignals(TileIndex tile, DiagDirection dir)

{

	if (IsTileType(tile, MP_RAILWAY) &&

		uint i = FindFirstBit2x64(GetTrackBits(tile) * 0x101 & _reachable_tracks[dir]);

		UpdateSignalsOnSegment(tile, _otherside_signal_directions[i]);

	}

}

				if (!EnsureNoVehicle(tile)) return_cmd_error(STR_980E_SHIP_IN_THE_WAY);

				if (!(IsWater(tile) || IsCoast(tile))) goto not_valid_below;

				transport_under = TRANSPORT_WATER;

				break;

			case MP_RAILWAY:

						GetTrackBits(tile) != (direction == AXIS_X ? TRACK_BIT_Y : TRACK_BIT_X)) {

					goto not_valid_below;

				}

				transport_under = TRANSPORT_RAIL;

				owner_under = GetTileOwner(tile);

				rail_under = GetRailType(tile);

	SET_EXPENSES_TYPE(EXPENSES_CONSTRUCTION);

	/* if custom gfx are used, make sure it is within bounds */

	if (p1 >= GetNumCustomStations(STAT_CLASS_WAYP)) return CMD_ERROR;

	if (!IsTileType(tile, MP_RAILWAY) ||

				(axis = AXIS_X, GetTrackBits(tile) != TRACK_BIT_X) &&

				(axis = AXIS_Y, GetTrackBits(tile) != TRACK_BIT_Y)

			)) {

		return_cmd_error(STR_1005_NO_SUITABLE_RAILROAD_TRACK);

	}

	byte localidx;     ///< Index of station within GRF file

	byte deleted;      ///< Delete counter. If greater than 0 then it is decremented until it reaches 0; the waypoint is then is deleted.

};

enum {

	RAIL_WAYPOINT_TRACK_MASK = 1,

};

extern MemoryPool _waypoint_pool;

/**