--- a/ai/default/default.c	Tue May 09 08:17:33 2006 +0000
+++ b/ai/default/default.c	Tue May 09 08:25:31 2006 +0000
@@ -2546,7 +2546,7 @@
 
 		if (p->mode == 2) {
 			if (IsTileType(c, MP_STREET) &&
-					GetRoadType(c) == ROAD_NORMAL &&
+					GetRoadTileType(c) == ROAD_TILE_NORMAL &&
 					(GetRoadBits(c) & p->attr) != 0) {
 				roadflag |= 2;
 
@@ -2588,7 +2588,7 @@
 
 			if (GetTileSlope(c, NULL) != SLOPE_FLAT) return CMD_ERROR;
 
-			if (!IsTileType(c, MP_STREET) || GetRoadType(c) != ROAD_NORMAL) {
+			if (!IsTileType(c, MP_STREET) || GetRoadTileType(c) != ROAD_TILE_NORMAL) {
 				ret = DoCommand(c, 0, 0, flag | DC_AUTO | DC_NO_WATER | DC_AI_BUILDING, CMD_LANDSCAPE_CLEAR);
 				if (CmdFailed(ret)) return CMD_ERROR;
 			}
@@ -2765,7 +2765,7 @@
 	if (dist <= a->best_dist) {
 		TileIndex tile2 = TILE_MASK(tile + TileOffsByDir(_dir_by_track[track]));
 
-		if (IsTileType(tile2, MP_STREET) && GetRoadType(tile2) == ROAD_NORMAL) {
+		if (IsTileType(tile2, MP_STREET) && GetRoadTileType(tile2) == ROAD_TILE_NORMAL) {
 			a->best_dist = dist;
 			a->best_tile = tile;
 			a->best_track = track;
@@ -3653,7 +3653,7 @@
 
 		if (IsLevelCrossing(tile)) goto is_rail_crossing;
 
-		if (GetRoadType(tile) == ROAD_DEPOT) {
+		if (GetRoadTileType(tile) == ROAD_TILE_DEPOT) {
 			DiagDirection dir;
 
 			// Check if there are any stations around.

--- a/ai/trolly/trolly.c	Tue May 09 08:17:33 2006 +0000
+++ b/ai/trolly/trolly.c	Tue May 09 08:25:31 2006 +0000
@@ -796,7 +796,7 @@
 			TileIndex t = tile + TileOffsByDir(j);
 
 			if (IsTileType(t, MP_STREET) &&
-					GetRoadType(t) == ROAD_DEPOT &&
+					GetRoadTileType(t) == ROAD_TILE_DEPOT &&
 					IsTileOwner(t, _current_player) &&
 					GetRoadDepotDirection(t) == ReverseDiagDir(j)) {
 				p->ainew.depot_tile = t;
@@ -1097,7 +1097,7 @@
 	int res = 0;
 	assert(p->ainew.state == AI_STATE_BUILD_DEPOT);
 
-	if (IsTileType(p->ainew.depot_tile, MP_STREET) && GetRoadType(p->ainew.depot_tile) == ROAD_DEPOT) {
+	if (IsTileType(p->ainew.depot_tile, MP_STREET) && GetRoadTileType(p->ainew.depot_tile) == ROAD_TILE_DEPOT) {
 		if (IsTileOwner(p->ainew.depot_tile, _current_player)) {
 			// The depot is already builded!
 			p->ainew.state = AI_STATE_BUILD_VEHICLE;

--- a/elrail.c	Tue May 09 08:17:33 2006 +0000
+++ b/elrail.c	Tue May 09 08:25:31 2006 +0000
@@ -105,7 +105,7 @@
 				}
 			}
 		case MP_STREET:
-			if (GetRoadType(t) != ROAD_CROSSING) return 0;
+			if (GetRoadTileType(t) != ROAD_TILE_CROSSING) return 0;
 			if (GetRailTypeCrossing(t) != RAILTYPE_ELECTRIC) return 0;
 			return GetCrossingRailBits(t);
 		case MP_STATION:

--- a/order_gui.c	Tue May 09 08:17:33 2006 +0000
+++ b/order_gui.c	Tue May 09 08:25:31 2006 +0000
@@ -211,7 +211,7 @@
 			break;
 
 		case MP_STREET:
-			if (GetRoadType(tile) == ROAD_DEPOT && v->type == VEH_Road && IsTileOwner(tile, _local_player)) {
+			if (GetRoadTileType(tile) == ROAD_TILE_DEPOT && v->type == VEH_Road && IsTileOwner(tile, _local_player)) {
 				order.type = OT_GOTO_DEPOT;
 				order.flags = OF_PART_OF_ORDERS;
 				order.station = GetDepotByTile(tile)->index;

--- a/rail_cmd.c	Tue May 09 08:17:33 2006 +0000
+++ b/rail_cmd.c	Tue May 09 08:25:31 2006 +0000
@@ -288,7 +288,7 @@
 
 			if (!EnsureNoVehicle(tile)) return CMD_ERROR;
 
-			if (GetRoadType(tile) == ROAD_NORMAL && (
+			if (GetRoadTileType(tile) == ROAD_TILE_NORMAL && (
 						(track == TRACK_X && GetRoadBits(tile) == ROAD_Y) ||
 						(track == TRACK_Y && GetRoadBits(tile) == ROAD_X)
 					)) {

--- a/road_cmd.c	Tue May 09 08:17:33 2006 +0000
+++ b/road_cmd.c	Tue May 09 08:25:31 2006 +0000
@@ -149,8 +149,8 @@
 			// removal allowance depends on difficulty setting
 			if (!CheckforTownRating(flags, t, ROAD_REMOVE)) return CMD_ERROR;
 
-			switch (GetRoadType(tile)) {
-				case ROAD_NORMAL: {
+			switch (GetRoadTileType(tile)) {
+				case ROAD_TILE_NORMAL: {
 					RoadBits present = GetRoadBits(tile);
 					RoadBits c = pieces;
 
@@ -178,7 +178,7 @@
 					return CountRoadBits(c) * _price.remove_road;
 				}
 
-				case ROAD_CROSSING: {
+				case ROAD_TILE_CROSSING: {
 					if (pieces & ComplementRoadBits(GetCrossingRoadBits(tile))) {
 						return CMD_ERROR;
 					}
@@ -193,7 +193,7 @@
 				}
 
 				default:
-				case ROAD_DEPOT:
+				case ROAD_TILE_DEPOT:
 					return CMD_ERROR;
 			}
 
@@ -288,8 +288,8 @@
 
 	switch (GetTileType(tile)) {
 		case MP_STREET:
-			switch (GetRoadType(tile)) {
-				case ROAD_NORMAL:
+			switch (GetRoadTileType(tile)) {
+				case ROAD_TILE_NORMAL:
 					existing = GetRoadBits(tile);
 					if ((existing & pieces) == pieces) {
 						return_cmd_error(STR_1007_ALREADY_BUILT);
@@ -297,14 +297,14 @@
 					if (!EnsureNoVehicle(tile)) return CMD_ERROR;
 					break;
 
-				case ROAD_CROSSING:
+				case ROAD_TILE_CROSSING:
 					if (pieces != GetCrossingRoadBits(tile)) { // XXX is this correct?
 						return_cmd_error(STR_1007_ALREADY_BUILT);
 					}
 					goto do_clear;
 
 				default:
-				case ROAD_DEPOT:
+				case ROAD_TILE_DEPOT:
 					goto do_clear;
 			}
 			break;
@@ -604,8 +604,8 @@
 
 static int32 ClearTile_Road(TileIndex tile, byte flags)
 {
-	switch (GetRoadType(tile)) {
-		case ROAD_NORMAL: {
+	switch (GetRoadTileType(tile)) {
+		case ROAD_TILE_NORMAL: {
 			RoadBits b = GetRoadBits(tile);
 
 			if (!((1 << b) & (M(1)|M(2)|M(4)|M(8))) &&
@@ -616,7 +616,7 @@
 			return DoCommand(tile, b, 0, flags, CMD_REMOVE_ROAD);
 		}
 
-		case ROAD_CROSSING: {
+		case ROAD_TILE_CROSSING: {
 			int32 ret;
 
 			if (flags & DC_AUTO) return_cmd_error(STR_1801_MUST_REMOVE_ROAD_FIRST);
@@ -631,7 +631,7 @@
 		}
 
 		default:
-		case ROAD_DEPOT:
+		case ROAD_TILE_DEPOT:
 			if (flags & DC_AUTO) {
 				return_cmd_error(STR_2004_BUILDING_MUST_BE_DEMOLISHED);
 			}
@@ -742,12 +742,12 @@
 {
 	PalSpriteID image;
 
-	switch (GetRoadType(ti->tile)) {
-		case ROAD_NORMAL:
+	switch (GetRoadTileType(ti->tile)) {
+		case ROAD_TILE_NORMAL:
 			DrawRoadBits(ti, GetRoadBits(ti->tile));
 			break;
 
-		case ROAD_CROSSING: {
+		case ROAD_TILE_CROSSING: {
 			if (ti->tileh != SLOPE_FLAT) DrawFoundation(ti, ti->tileh);
 
 			image = GetRailTypeInfo(GetRailTypeCrossing(ti->tile))->base_sprites.crossing;
@@ -769,7 +769,7 @@
 		}
 
 		default:
-		case ROAD_DEPOT: {
+		case ROAD_TILE_DEPOT: {
 			uint32 ormod;
 			PlayerID player;
 			const DrawRoadSeqStruct* drss;
@@ -829,7 +829,7 @@
 	uint z = ti->z;
 
 	if (tileh == SLOPE_FLAT) return z;
-	if (GetRoadType(ti->tile) == ROAD_NORMAL) {
+	if (GetRoadTileType(ti->tile) == ROAD_TILE_NORMAL) {
 		uint f = GetRoadFoundation(tileh, GetRoadBits(ti->tile));
 
 		if (f != 0) {
@@ -845,7 +845,7 @@
 static Slope GetSlopeTileh_Road(TileIndex tile, Slope tileh)
 {
 	if (tileh == SLOPE_FLAT) return SLOPE_FLAT;
-	if (GetRoadType(tile) == ROAD_NORMAL) {
+	if (GetRoadTileType(tile) == ROAD_TILE_NORMAL) {
 		uint f = GetRoadFoundation(tileh, GetRoadBits(tile));
 
 		if (f == 0) return tileh;
@@ -904,7 +904,7 @@
 			break;
 	}
 
-	if (GetRoadType(tile) == ROAD_DEPOT) return;
+	if (GetRoadTileType(tile) == ROAD_TILE_DEPOT) return;
 
 	if (!HasRoadWorks(tile)) {
 		t = ClosestTownFromTile(tile, (uint)-1);
@@ -916,7 +916,7 @@
 			// Show an animation to indicate road work
 			if (t->road_build_months != 0 &&
 					!(DistanceManhattan(t->xy, tile) >= 8 && grp == 0) &&
-					GetRoadType(tile) == ROAD_NORMAL && (GetRoadBits(tile) == ROAD_X || GetRoadBits(tile) == ROAD_Y)) {
+					GetRoadTileType(tile) == ROAD_TILE_NORMAL && (GetRoadBits(tile) == ROAD_X || GetRoadBits(tile) == ROAD_Y)) {
 				if (GetTileSlope(tile, NULL) == SLOPE_FLAT && EnsureNoVehicle(tile) && CHANCE16(1, 20)) {
 					StartRoadWorks(tile);
 
@@ -963,7 +963,7 @@
 
 static void ClickTile_Road(TileIndex tile)
 {
-	if (GetRoadType(tile) == ROAD_DEPOT) ShowRoadDepotWindow(tile);
+	if (GetRoadTileType(tile) == ROAD_TILE_DEPOT) ShowRoadDepotWindow(tile);
 }
 
 static const byte _road_trackbits[16] = {
@@ -978,11 +978,11 @@
 			return GetCrossingRailBits(tile) * 0x101;
 
 		case TRANSPORT_ROAD:
-			switch (GetRoadType(tile)) {
-				case ROAD_NORMAL:
+			switch (GetRoadTileType(tile)) {
+				case ROAD_TILE_NORMAL:
 					return HasRoadWorks(tile) ?  0 : _road_trackbits[GetRoadBits(tile)] * 0x101;
 
-				case ROAD_CROSSING: {
+				case ROAD_TILE_CROSSING: {
 					uint32 r = (GetCrossingRoadAxis(tile) == AXIS_X ? TRACK_BIT_X : TRACK_BIT_Y) * 0x101;
 
 					if (IsCrossingBarred(tile)) r *= 0x10001;
@@ -990,7 +990,7 @@
 				}
 
 				default:
-				case ROAD_DEPOT:
+				case ROAD_TILE_DEPOT:
 					break;
 			}
 			break;
@@ -1014,9 +1014,9 @@
 static void GetTileDesc_Road(TileIndex tile, TileDesc *td)
 {
 	td->owner = GetTileOwner(tile);
-	switch (GetRoadType(tile)) {
-		case ROAD_CROSSING: td->str = STR_1818_ROAD_RAIL_LEVEL_CROSSING; break;
-		case ROAD_DEPOT: td->str = STR_1817_ROAD_VEHICLE_DEPOT; break;
+	switch (GetRoadTileType(tile)) {
+		case ROAD_TILE_CROSSING: td->str = STR_1818_ROAD_RAIL_LEVEL_CROSSING; break;
+		case ROAD_TILE_DEPOT: td->str = STR_1817_ROAD_VEHICLE_DEPOT; break;
 		default: td->str = _road_tile_strings[GetGroundType(tile)]; break;
 	}
 }
@@ -1027,8 +1027,8 @@
 
 static uint32 VehicleEnter_Road(Vehicle *v, TileIndex tile, int x, int y)
 {
-	switch (GetRoadType(tile)) {
-		case ROAD_CROSSING:
+	switch (GetRoadTileType(tile)) {
+		case ROAD_TILE_CROSSING:
 			if (v->type == VEH_Train && !IsCrossingBarred(tile)) {
 				/* train crossing a road */
 				SndPlayVehicleFx(SND_0E_LEVEL_CROSSING, v);
@@ -1037,7 +1037,7 @@
 			}
 			break;
 
-		case ROAD_DEPOT:
+		case ROAD_TILE_DEPOT:
 			if (v->type == VEH_Road && v->u.road.frame == 11) {
 				if (_roadveh_enter_depot_unk0[GetRoadDepotDirection(tile)] == v->u.road.state) {
 					RoadVehEnterDepot(v);
@@ -1063,17 +1063,17 @@
 	if (new_player != OWNER_SPECTATOR) {
 		SetTileOwner(tile, new_player);
 	}	else {
-		switch (GetRoadType(tile)) {
-			case ROAD_NORMAL:
+		switch (GetRoadTileType(tile)) {
+			case ROAD_TILE_NORMAL:
 				SetTileOwner(tile, OWNER_NONE);
 				break;
 
-			case ROAD_CROSSING:
+			case ROAD_TILE_CROSSING:
 				MakeRoadNormal(tile, GetCrossingRoadOwner(tile), GetCrossingRoadBits(tile), GetTownIndex(tile));
 				break;
 
 			default:
-			case ROAD_DEPOT:
+			case ROAD_TILE_DEPOT:
 				DoCommand(tile, 0, 0, DC_EXEC, CMD_LANDSCAPE_CLEAR);
 				break;
 		}

--- a/road_gui.c	Tue May 09 08:17:33 2006 +0000
+++ b/road_gui.c	Tue May 09 08:25:31 2006 +0000
@@ -72,7 +72,7 @@
 {
 	tile += TileOffsByDir(direction);
 	// if there is a roadpiece just outside of the station entrance, build a connecting route
-	if (IsTileType(tile, MP_STREET) && GetRoadType(tile) == ROAD_NORMAL) {
+	if (IsTileType(tile, MP_STREET) && GetRoadTileType(tile) == ROAD_TILE_NORMAL) {
 		DoCommandP(tile, DiagDirToRoadBits(ReverseDiagDir(direction)), 0, NULL, CMD_BUILD_ROAD);
 	}
 }

--- a/road_map.c	Tue May 09 08:17:33 2006 +0000
+++ b/road_map.c	Tue May 09 08:25:31 2006 +0000
@@ -14,11 +14,11 @@
 {
 	switch (GetTileType(tile)) {
 		case MP_STREET:
-			switch (GetRoadType(tile)) {
+			switch (GetRoadTileType(tile)) {
 				default:
-				case ROAD_NORMAL:   return GetRoadBits(tile);
-				case ROAD_CROSSING: return GetCrossingRoadBits(tile);
-				case ROAD_DEPOT:    return DiagDirToRoadBits(GetRoadDepotDirection(tile));
+				case ROAD_TILE_NORMAL:   return GetRoadBits(tile);
+				case ROAD_TILE_CROSSING: return GetCrossingRoadBits(tile);
+				case ROAD_TILE_DEPOT:    return DiagDirToRoadBits(GetRoadDepotDirection(tile));
 			}
 
 		case MP_STATION:

--- a/road_map.h	Tue May 09 08:17:33 2006 +0000
+++ b/road_map.h	Tue May 09 08:25:31 2006 +0000
@@ -9,13 +9,13 @@
 #include "tile.h"
 
 
-typedef enum RoadType {
-	ROAD_NORMAL,
-	ROAD_CROSSING,
-	ROAD_DEPOT
-} RoadType;
+typedef enum RoadTileType {
+	ROAD_TILE_NORMAL,
+	ROAD_TILE_CROSSING,
+	ROAD_TILE_DEPOT
+} RoadTileType;
 
-static inline RoadType GetRoadType(TileIndex t)
+static inline RoadTileType GetRoadTileType(TileIndex t)
 {
 	assert(IsTileType(t, MP_STREET));
 	return GB(_m[t].m5, 4, 4);
@@ -23,7 +23,7 @@
 
 static inline bool IsLevelCrossing(TileIndex t)
 {
-	return GetRoadType(t) == ROAD_CROSSING;
+	return GetRoadTileType(t) == ROAD_TILE_CROSSING;
 }
 
 static inline bool IsLevelCrossingTile(TileIndex t)
@@ -33,20 +33,20 @@
 
 static inline RoadBits GetRoadBits(TileIndex t)
 {
-	assert(GetRoadType(t) == ROAD_NORMAL);
+	assert(GetRoadTileType(t) == ROAD_TILE_NORMAL);
 	return GB(_m[t].m5, 0, 4);
 }
 
 static inline void SetRoadBits(TileIndex t, RoadBits r)
 {
-	assert(GetRoadType(t) == ROAD_NORMAL); // XXX incomplete
+	assert(GetRoadTileType(t) == ROAD_TILE_NORMAL); // XXX incomplete
 	SB(_m[t].m5, 0, 4, r);
 }
 
 
 static inline Axis GetCrossingRoadAxis(TileIndex t)
 {
-	assert(GetRoadType(t) == ROAD_CROSSING);
+	assert(GetRoadTileType(t) == ROAD_TILE_CROSSING);
 	return (Axis)GB(_m[t].m5, 3, 1);
 }
 
@@ -64,31 +64,31 @@
 // TODO swap owner of road and rail
 static inline Owner GetCrossingRoadOwner(TileIndex t)
 {
-	assert(GetRoadType(t) == ROAD_CROSSING);
+	assert(GetRoadTileType(t) == ROAD_TILE_CROSSING);
 	return (Owner)_m[t].m3;
 }
 
 static inline void SetCrossingRoadOwner(TileIndex t, Owner o)
 {
-	assert(GetRoadType(t) == ROAD_CROSSING);
+	assert(GetRoadTileType(t) == ROAD_TILE_CROSSING);
 	_m[t].m3 = o;
 }
 
 static inline void UnbarCrossing(TileIndex t)
 {
-	assert(GetRoadType(t) == ROAD_CROSSING);
+	assert(GetRoadTileType(t) == ROAD_TILE_CROSSING);
 	CLRBIT(_m[t].m5, 2);
 }
 
 static inline void BarCrossing(TileIndex t)
 {
-	assert(GetRoadType(t) == ROAD_CROSSING);
+	assert(GetRoadTileType(t) == ROAD_TILE_CROSSING);
 	SETBIT(_m[t].m5, 2);
 }
 
 static inline bool IsCrossingBarred(TileIndex t)
 {
-	assert(GetRoadType(t) == ROAD_CROSSING);
+	assert(GetRoadTileType(t) == ROAD_TILE_CROSSING);
 	return HASBIT(_m[t].m5, 2);
 }
 
@@ -161,7 +161,7 @@
 
 static inline DiagDirection GetRoadDepotDirection(TileIndex t)
 {
-	assert(GetRoadType(t) == ROAD_DEPOT);
+	assert(GetRoadTileType(t) == ROAD_TILE_DEPOT);
 	return (DiagDirection)GB(_m[t].m5, 0, 2);
 }
 
@@ -187,7 +187,7 @@
 	_m[t].m2 = town;
 	_m[t].m3 = 0;
 	_m[t].m4 = 0 << 7 | 0 << 4 | 0;
-	_m[t].m5 = ROAD_NORMAL << 4 | bits;
+	_m[t].m5 = ROAD_TILE_NORMAL << 4 | bits;
 }
 
 
@@ -198,7 +198,7 @@
 	_m[t].m2 = town;
 	_m[t].m3 = road;
 	_m[t].m4 = 0 << 7 | 0 << 4 | rt;
-	_m[t].m5 = ROAD_CROSSING << 4 | roaddir << 3 | 0 << 2;
+	_m[t].m5 = ROAD_TILE_CROSSING << 4 | roaddir << 3 | 0 << 2;
 }
 
 
@@ -209,7 +209,7 @@
 	_m[t].m2 = 0;
 	_m[t].m3 = 0;
 	_m[t].m4 = 0;
-	_m[t].m5 = ROAD_DEPOT << 4 | dir;
+	_m[t].m5 = ROAD_TILE_DEPOT << 4 | dir;
 }
 
 #endif

--- a/roadveh_cmd.c	Tue May 09 08:17:33 2006 +0000
+++ b/roadveh_cmd.c	Tue May 09 08:25:31 2006 +0000
@@ -298,7 +298,7 @@
 	tile += TileOffsByDir(_road_pf_directions[track]);
 
 	if (IsTileType(tile, MP_STREET) &&
-			GetRoadType(tile) == ROAD_DEPOT &&
+			GetRoadTileType(tile) == ROAD_TILE_DEPOT &&
 			IsTileOwner(tile, rfdd->owner) &&
 			length < rfdd->best_length) {
 		rfdd->best_length = length;
@@ -1003,7 +1003,7 @@
 	}
 
 	if (IsTileType(tile, MP_STREET)) {
-		if (GetRoadType(tile) == ROAD_DEPOT && IsTileOwner(tile, v->owner)) {
+		if (GetRoadTileType(tile) == ROAD_TILE_DEPOT && IsTileOwner(tile, v->owner)) {
 			/* Road depot */
 			bitmask |= _road_veh_fp_ax_or[GetRoadDepotDirection(tile)];
 		}
@@ -1078,7 +1078,7 @@
 		DiagDirection dir;
 
 		if (IsTileType(desttile, MP_STREET)) {
-			if (GetRoadType(desttile) == ROAD_DEPOT) {
+			if (GetRoadTileType(desttile) == ROAD_TILE_DEPOT) {
 				dir = GetRoadDepotDirection(desttile);
 				goto do_it;
 			}

--- a/tunnelbridge_cmd.c	Tue May 09 08:17:33 2006 +0000
+++ b/tunnelbridge_cmd.c	Tue May 09 08:25:31 2006 +0000
@@ -344,7 +344,7 @@
 				break;
 
 			case MP_STREET:
-				if (GetRoadType(tile) != ROAD_NORMAL ||
+				if (GetRoadTileType(tile) != ROAD_TILE_NORMAL ||
 						GetRoadBits(tile) != (direction == AXIS_X ? ROAD_Y : ROAD_X)) {
 					goto not_valid_below;
 				}