static inline bool ValParamTrackOrientation(Track track) {return IsValidTrack(track);}

/** Build a single piece of rail

 * @param p1 railtype of being built piece (normal, mono, maglev)

 * @param p2 rail track to build

 */

{

	uint tileh;

	Track track = (Track)p2;

	TrackBits trackbit;

	if (!ValParamRailtype(p1) || !ValParamTrackOrientation(track)) return CMD_ERROR;

	tileh = GetTileSlope(tile, NULL);

	trackbit = TrackToTrackBits(track);

					!IsBridgeMiddle(tile) ||

					(GetBridgeAxis(tile) == AXIS_X ? TRACK_BIT_Y : TRACK_BIT_X) != trackbit) {

				// Get detailed error message

			}

			if (IsClearUnderBridge(tile)) {

				return_cmd_error(STR_1007_ALREADY_BUILT);

			} else {

				// Get detailed error message

			}

			break;

					!IsTileOwner(tile, _current_player) ||

					GetRailType(tile) != p1) {

				// Get detailed error message

			}

			ret = CheckRailSlope(tileh, trackbit, GetTrackBits(tile), tile);

			if (CmdFailed(ret)) return ret;

			cost += ret;

			if (CmdFailed(ret)) return ret;

			cost += ret;

}

/** Remove a single piece of track

 * @param p1 unused

 * @param p2 rail orientation

 */

{

	Track track = (Track)p2;

	TrackBits trackbit;

	int32 cost = _price.remove_rail;

	bool crossing = false;

	SET_EXPENSES_TYPE(EXPENSES_CONSTRUCTION);

	switch (GetTileType(tile)) {

		case MP_TUNNELBRIDGE:

			if (!IsBridge(tile) ||

			/* Charge extra to remove signals on the track, if they are there */

			if (HasSignalOnTrack(tile, track))

			if (flags & DC_EXEC) {

				present ^= trackbit;

}

/** Build a stretch of railroad tracks.

 * @param p1 end tile of drag

 * @param p2 various bitstuffed elements

 * - p2 = (bit 0-3) - railroad type normal/maglev (0 = normal, 1 = mono, 2 = maglev)

 * - p2 = (bit 4-6) - track-orientation, valid values: 0-5 (Track enum)

 * - p2 = (bit 7)   - 0 = build, 1 = remove tracks

 */

{

	int ex, ey;

	int32 ret, total_cost = 0;

	Track track = (Track)GB(p2, 4, 3);

	trackdir = TrackToTrackdir(track);

	/* unpack end point */

	ex = TileX(p1) * TILE_SIZE;

	ey = TileY(p1) * TILE_SIZE;

	if (flags & DC_EXEC) SndPlayTileFx(SND_20_SPLAT_2, TileVirtXY(x, y));

	for (;;) {

		if (CmdFailed(ret)) {

			if ((_error_message != STR_1007_ALREADY_BUILT) && (mode == 0))

 * Stub for the unified rail builder/remover

 * @see CmdRailTrackHelper

 */

{

}

/** Build rail on a stretch of track.

 * Stub for the unified rail builder/remover

 * @see CmdRailTrackHelper

 */

{

}

/** Build a train depot

 * @param p1 rail type

 * @param p2 entrance direction (DiagDirection)

 *

 * @todo When checking for the tile slope,

 * distingush between "Flat land required" and "land sloped in wrong direction"

 */

{

	Depot *d;

	int32 cost, ret;

	uint tileh;

		return_cmd_error(STR_0007_FLAT_LAND_REQUIRED);

	}

	if (CmdFailed(ret)) return CMD_ERROR;

	cost = ret;

/** Build signals, alternate between double/single, signal/semaphore,

 * pre/exit/combo-signals, and what-else not

 * @param p1 various bitstuffed elements

 * - p1 = (bit 0-2) - track-orientation, valid values: 0-5 (Track enum)

 * - p1 = (bit 3)   - choose semaphores/signals or cycle normal/pre/exit/combo depending on context

 * @param p2 used for CmdBuildManySignals() to copy direction of first signal

 * TODO: p2 should be replaced by two bits for "along" and "against" the track.

 */

{

	SignalVariant sigvar;

	bool pre_signal;

	Track track = (Track)(p1 & 0x7);

}

/**	Build many signals by dragging; AutoSignals

 * @param p1  end tile of drag

 * @param p2 various bitstuffed elements

 * - p2 = (bit  0)    - 0 = build, 1 = remove signals

 * - p2 = (bit  4- 6) - track-orientation, valid values: 0-5 (Track enum)

 * - p2 = (bit 24-31) - user defined signals_density

 */

{

	int ex, ey;

	int32 ret, total_cost, signal_ctr;

	byte signals;

	bool error = true;

	int mode = p2 & 0x1;

		signal_density *= 2;

	// unpack end tile

	ex = TileX(p1) * TILE_SIZE;

	ey = TileY(p1) * TILE_SIZE;

	for (;;) {

		// only build/remove signals with the specified density

		if ((signal_ctr % signal_density) == 0 ) {

			/* Abort placement for any other error than NOT_SUITABLE_TRACK

			 * This includes vehicles on track, competitor's tracks, etc. */

 * Stub for the unified signal builder/remover

 * @see CmdSignalTrackHelper

 */

{

}

/** Remove signals

 * @param p1 track to remove signal from (Track enum)

 */

{

	Track track = (Track)(p1 & 0x7);

	if (!ValParamTrackOrientation(track) || !IsTileType(tile, MP_RAILWAY) || !EnsureNoVehicle(tile))

 * Stub for the unified signal builder/remover

 * @see CmdSignalTrackHelper

 */

{

}

typedef int32 DoConvertRailProc(TileIndex tile, RailType totype, bool exec);

/** Convert one rail type to the other. You can convert normal rail to

 * monorail/maglev easily or vice-versa.

 * @param p1 start tile of drag

 * @param p2 new railtype to convert to

 */

{

	int32 ret, cost, money;

	int sx, sy, x, y;

	SET_EXPENSES_TYPE(EXPENSES_CONSTRUCTION);

	if (p1 >= MapSize()) return CMD_ERROR;

	// make sure sx,sy are smaller than ex,ey

	sx = TileX(p1) * TILE_SIZE;

	sy = TileY(p1) * TILE_SIZE;

	if (ex < sx) intswap(ex, sx);

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

		case RAIL_TYPE_SIGNALS:

			if (HasSignalOnTrack(tile, TRACK_X)) {

				if (CmdFailed(ret)) return CMD_ERROR;

				cost += ret;

			}

			if (HasSignalOnTrack(tile, TRACK_LOWER)) {

				if (CmdFailed(ret)) return CMD_ERROR;

				cost += ret;

			}

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

				if (m5 & 1) {

					if (CmdFailed(ret)) return CMD_ERROR;

					cost += ret;

				}

	if (new_player != OWNER_SPECTATOR) {

		SetTileOwner(tile, new_player);

	}	else {

	}

}