if (ret.Failed()) return ret;

			cost.AddCost(ret);

			/* If the rail types don't match, try to convert only if engines of

			 * the new rail type are not powered on the present rail type and engines of

			 * the present rail type are powered on the new rail type. */

			if (GetRailType(tile) != railtype && !HasPowerOnRail(railtype, GetRailType(tile))) {

				if (HasPowerOnRail(GetRailType(tile), railtype)) {

					ret = DoCommand(tile, tile, railtype, flags, CMD_CONVERT_RAIL);

					if (ret.Failed()) return ret;

					cost.AddCost(ret);

				} else {

					return CMD_ERROR;

				}

			}

			if (flags & DC_EXEC) {

				SetRailGroundType(tile, RAIL_GROUND_BARREN);

				SetTrackBits(tile, GetTrackBits(tile) | trackbit);

			}

			break;

		}

		case MP_ROAD: {

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

			CommandCost ret = EnsureNoVehicleOnGround(tile);

			if (ret.Failed()) return ret;

			if (IsNormalRoad(tile)) {

				if (HasRoadWorks(tile)) return_cmd_error(STR_ERROR_ROAD_WORKS_IN_PROGRESS);

				if (GetDisallowedRoadDirections(tile) != DRD_NONE) return_cmd_error(STR_ERROR_CROSSING_ON_ONEWAY_ROAD);

				if (RailNoLevelCrossings(railtype)) return_cmd_error(STR_ERROR_CROSSING_DISALLOWED);

				RoadTypes roadtypes = GetRoadTypes(tile);

				RoadBits road = GetRoadBits(tile, ROADTYPE_ROAD);

				RoadBits tram = GetRoadBits(tile, ROADTYPE_TRAM);

				switch (roadtypes) {

					default: break;

					case ROADTYPES_TRAM:

						/* Tram crossings must always have road. */

						if (flags & DC_EXEC) SetRoadOwner(tile, ROADTYPE_ROAD, _current_company);

						roadtypes |= ROADTYPES_ROAD;

						break;

					case ROADTYPES_ALL:

						if (road != tram) return CMD_ERROR;

#include "effectvehicle_func.h"

#include "effectvehicle_base.h"

#include "elrail_func.h"

#include "roadveh.h"

#include "town.h"

#include "company_base.h"

#include "core/random_func.hpp"

#include "newgrf_railtype.h"

#include "date_func.h"

#include "table/strings.h"

/**

 * Verify whether a road vehicle is available.

 * @return \c true if at least one road vehicle is available, \c false if not

 */

bool RoadVehiclesAreBuilt()

{

	const RoadVehicle *rv;

	FOR_ALL_ROADVEHICLES(rv) return true;

	return false;

}

/* Invalid RoadBits on slopes  */

static const RoadBits _invalid_tileh_slopes_road[2][15] = {

	/* The inverse of the mixable RoadBits on a leveled slope */

	{

		ROAD_NONE,         // SLOPE_FLAT

		ROAD_NE | ROAD_SE, // SLOPE_W

		ROAD_NE | ROAD_NW, // SLOPE_S

		ROAD_NE,           // SLOPE_SW

		ROAD_NW | ROAD_SW, // SLOPE_E

		ROAD_NONE,         // SLOPE_EW

		ROAD_NW,           // SLOPE_SE

		ROAD_NONE,         // SLOPE_WSE

		ROAD_SE | ROAD_SW, // SLOPE_N

		ROAD_SE,           // SLOPE_NW

		ROAD_NONE,         // SLOPE_NS

		ROAD_NONE,         // SLOPE_ENW

		ROAD_SW,           // SLOPE_NE

		ROAD_NONE,         // SLOPE_SEN

		ROAD_NONE          // SLOPE_NWS

	},

	SLOPE_SW       = SLOPE_S | SLOPE_W,                     ///< south and west corner are raised

	SLOPE_SE       = SLOPE_S | SLOPE_E,                     ///< south and east corner are raised

	SLOPE_NE       = SLOPE_N | SLOPE_E,                     ///< north and east corner are raised

	SLOPE_EW       = SLOPE_E | SLOPE_W,                     ///< east and west corner are raised

	SLOPE_NS       = SLOPE_N | SLOPE_S,                     ///< north and south corner are raised

	SLOPE_ELEVATED = SLOPE_N | SLOPE_E | SLOPE_S | SLOPE_W, ///< bit mask containing all 'simple' slopes

	SLOPE_NWS      = SLOPE_N | SLOPE_W | SLOPE_S,           ///< north, west and south corner are raised

	SLOPE_WSE      = SLOPE_W | SLOPE_S | SLOPE_E,           ///< west, south and east corner are raised

	SLOPE_SEN      = SLOPE_S | SLOPE_E | SLOPE_N,           ///< south, east and north corner are raised

	SLOPE_ENW      = SLOPE_E | SLOPE_N | SLOPE_W,           ///< east, north and west corner are raised

	SLOPE_STEEP_W  = SLOPE_STEEP | SLOPE_NWS,               ///< a steep slope falling to east (from west)

	SLOPE_STEEP_S  = SLOPE_STEEP | SLOPE_WSE,               ///< a steep slope falling to north (from south)

	SLOPE_STEEP_E  = SLOPE_STEEP | SLOPE_SEN,               ///< a steep slope falling to west (from east)

	SLOPE_STEEP_N  = SLOPE_STEEP | SLOPE_ENW,               ///< a steep slope falling to south (from north)

	SLOPE_HALFTILE = 0x20,                                  ///< one halftile is leveled (non continuous slope)

	SLOPE_HALFTILE_MASK = 0xE0,                             ///< three bits used for halftile slopes

	SLOPE_HALFTILE_W = SLOPE_HALFTILE | (CORNER_W << 6),    ///< the west halftile is leveled (non continuous slope)

	SLOPE_HALFTILE_S = SLOPE_HALFTILE | (CORNER_S << 6),    ///< the south halftile is leveled (non continuous slope)

	SLOPE_HALFTILE_E = SLOPE_HALFTILE | (CORNER_E << 6),    ///< the east halftile is leveled (non continuous slope)

	SLOPE_HALFTILE_N = SLOPE_HALFTILE | (CORNER_N << 6),    ///< the north halftile is leveled (non continuous slope)

};

DECLARE_ENUM_AS_BIT_SET(Slope)

/**

 * Enumeration for Foundations.

 */

enum Foundation {

	FOUNDATION_NONE,             ///< The tile has no foundation, the slope remains unchanged.

	FOUNDATION_LEVELED,          ///< The tile is leveled up to a flat slope.

	FOUNDATION_INCLINED_X,       ///< The tile has an along X-axis inclined foundation.

	FOUNDATION_INCLINED_Y,       ///< The tile has an along Y-axis inclined foundation.

	FOUNDATION_STEEP_LOWER,      ///< The tile has a steep slope. The lowest corner is raised by a foundation to allow building railroad on the lower halftile.

	/* Halftile foundations */

	FOUNDATION_STEEP_BOTH,       ///< The tile has a steep slope. The lowest corner is raised by a foundation and the upper halftile is leveled.

	FOUNDATION_HALFTILE_W,       ///< Level west halftile non-continuously.

	FOUNDATION_HALFTILE_S,       ///< Level south halftile non-continuously.

	FOUNDATION_HALFTILE_E,       ///< Level east halftile non-continuously.

	FOUNDATION_HALFTILE_N,       ///< Level north halftile non-continuously.

	/* Special anti-zig-zag foundations for single horizontal/vertical track */

	FOUNDATION_RAIL_W,           ///< Foundation for TRACK_BIT_LEFT, but not a leveled foundation.

	FOUNDATION_RAIL_S,           ///< Foundation for TRACK_BIT_LOWER, but not a leveled foundation.

	FOUNDATION_RAIL_E,           ///< Foundation for TRACK_BIT_RIGHT, but not a leveled foundation.

	FOUNDATION_RAIL_N,           ///< Foundation for TRACK_BIT_UPPER, but not a leveled foundation.