openttd-ottdgrfs: comparison src/road

equal deleted inserted replaced

-:0b2aebc8283e
+:0b8b245a2391
 #include "town.h"
 #include "gfx.h"
 #include "sound.h"
 #include "yapf/yapf.h"
 #include "depot.h"
+#include "newgrf.h"
 static uint CountRoadBits(RoadBits r)
 {
 	uint count = 0;
 	if (r & ROAD_NE) ++count;
 	return count;
 }
-bool CheckAllowRemoveRoad(TileIndex tile, RoadBits remove, Owner owner, bool *edge_road)
+bool CheckAllowRemoveRoad(TileIndex tile, RoadBits remove, Owner owner, bool *edge_road, RoadType rt)
 {
 	RoadBits present;
 	RoadBits n;
 	*edge_road = true;
-	if (_game_mode == GM_EDITOR) return true;
+	if (_game_mode == GM_EDITOR || remove == ROAD_NONE) return true;
 	/* Only do the special processing for actual players. */
 	if (!IsValidPlayer(_current_player)) return true;
 	/* Only do the special processing if the road is owned
 	if (_cheats.magic_bulldozer.value) return true;
 	/* Get a bitmask of which neighbouring roads has a tile */
 	n = ROAD_NONE;
-	present = GetAnyRoadBits(tile);
+	present = GetAnyRoadBits(tile, rt);
-	if (present & ROAD_NE && GetAnyRoadBits(TILE_ADDXY(tile, -1, 0)) & ROAD_SW) n |= ROAD_NE;
+	if (present & ROAD_NE && GetAnyRoadBits(TILE_ADDXY(tile, -1,  0), rt) & ROAD_SW) n |= ROAD_NE;
-	if (present & ROAD_SE && GetAnyRoadBits(TILE_ADDXY(tile, 0, 1)) & ROAD_NW) n |= ROAD_SE;
+	if (present & ROAD_SE && GetAnyRoadBits(TILE_ADDXY(tile,  0,  1), rt) & ROAD_NW) n |= ROAD_SE;
-	if (present & ROAD_SW && GetAnyRoadBits(TILE_ADDXY(tile, 1, 0)) & ROAD_NE) n |= ROAD_SW;
+	if (present & ROAD_SW && GetAnyRoadBits(TILE_ADDXY(tile,  1,  0), rt) & ROAD_NE) n |= ROAD_SW;
-	if (present & ROAD_NW && GetAnyRoadBits(TILE_ADDXY(tile, 0, -1)) & ROAD_SE) n |= ROAD_NW;
+	if (present & ROAD_NW && GetAnyRoadBits(TILE_ADDXY(tile,  0, -1), rt) & ROAD_SE) n |= ROAD_NW;
 	/* If 0 or 1 bits are set in n, or if no bits that match the bits to remove,
 	 * then allow it */
 	if ((n & (n - 1)) != 0 && (n & remove) != 0) {
 		Town *t;
 	}
 	return true;
 }
-static bool CheckAllowRemoveRoad(TileIndex tile, RoadBits remove, bool *edge_road)
+static bool CheckAllowRemoveRoad(TileIndex tile, RoadBits remove, bool *edge_road, RoadType rt)
 {
-	return CheckAllowRemoveRoad(tile, remove, IsLevelCrossingTile(tile) ? GetCrossingRoadOwner(tile) : GetTileOwner(tile), edge_road);
+	return CheckAllowRemoveRoad(tile, remove, GetRoadOwner(tile, rt), edge_road, rt);
 }
 /** Delete a piece of road.
 * @param tile tile where to remove road from
 * @param flags operation to perform
 * @param p1 bit 0..3 road pieces to remove (RoadBits)
+*           bit 4..5 road type
 * @param p2 unused
 */
 int32 CmdRemoveRoad(TileIndex tile, uint32 flags, uint32 p1, uint32 p2)
 {
 	/* cost for removing inner/edge -roads */
 	static const uint16 road_remove_cost[2] = {50, 18};
-	Owner owner;
 	Town *t;
 	/* true if the roadpiece was always removeable,
 	 * false if it was a center piece. Affects town ratings drop */
 	bool edge_road;
 	SET_EXPENSES_TYPE(EXPENSES_CONSTRUCTION);
-	if (!IsTileType(tile, MP_STREET)) return CMD_ERROR;
+	RoadType rt = (RoadType)GB(p1, 4, 2);
+	if (!IsTileType(tile, MP_STREET) || !IsValidRoadType(rt)) return CMD_ERROR;
-	owner = IsLevelCrossingTile(tile) ? GetCrossingRoadOwner(tile) : GetTileOwner(tile);
+	Owner owner = GetRoadOwner(tile, rt);
 	if (owner == OWNER_TOWN && _game_mode != GM_EDITOR) {
 		t = GetTownByTile(tile);
 	} else {
 		t = NULL;
 	}
 	RoadBits pieces = Extract<RoadBits, 0>(p1);
+	RoadTypes rts = GetRoadTypes(tile);
-	if (!CheckAllowRemoveRoad(tile, pieces, &edge_road)) return CMD_ERROR;
+	/* The tile doesn't have the given road type */
+	if (!HASBIT(rts, rt)) return CMD_ERROR;
+	if (!CheckAllowRemoveRoad(tile, pieces, &edge_road, rt)) return CMD_ERROR;
 	if (!EnsureNoVehicleOnGround(tile)) return CMD_ERROR;
 	/* check if you're allowed to remove the street owned by a town
 	 * removal allowance depends on difficulty setting */
 	if (!CheckforTownRating(flags, t, ROAD_REMOVE)) return CMD_ERROR;
 	switch (GetRoadTileType(tile)) {
 		case ROAD_TILE_NORMAL: {
-			RoadBits present = GetRoadBits(tile);
+			RoadBits present = GetRoadBits(tile, rt);
 			RoadBits c = pieces;
 			if (HasRoadWorks(tile)) return_cmd_error(STR_ROAD_WORKS_IN_PROGRESS);
 			if (GetTileSlope(tile, NULL) != SLOPE_FLAT  &&
 				c |= (RoadBits)((c & 0x3) << 2);
 			}
 			/* limit the bits to delete to the existing bits. */
 			c &= present;
-			if (c == 0) return CMD_ERROR;
+			if (c == ROAD_NONE) return CMD_ERROR;
 			present ^= c;
 			if (flags & DC_EXEC) {
 				ChangeTownRating(t, -road_remove_cost[(byte)edge_road], RATING_ROAD_MINIMUM);
-				if (present == 0) {
+				if (present == ROAD_NONE) {
-					DoClearSquare(tile);
+					RoadTypes rts = GetRoadTypes(tile) & ComplementRoadTypes(RoadTypeToRoadTypes(rt));
+					if (rts == ROADTYPES_NONE) {
+						DoClearSquare(tile);
+					} else {
+						SetRoadBits(tile, ROAD_NONE, rt);
+						SetRoadTypes(tile, rts);
+					}
 				} else {
-					SetRoadBits(tile, present);
+					SetRoadBits(tile, present, rt);
 					MarkTileDirtyByTile(tile);
 				}
 			}
 			return CountRoadBits(c) * _eco->GetPrice(CEconomy::REMOVE_ROAD, tile, (present == 0));
 		}
 			if (pieces & ComplementRoadBits(GetCrossingRoadBits(tile))) {
 				return CMD_ERROR;
 			}
 			if (flags & DC_EXEC) {
-				ChangeTownRating(t, -road_remove_cost[(byte)edge_road], RATING_ROAD_MINIMUM);
+				if (rt == ROADTYPE_ROAD) {
+					ChangeTownRating(t, -road_remove_cost[(byte)edge_road], RATING_ROAD_MINIMUM);
-				MakeRailNormal(tile, GetTileOwner(tile), GetCrossingRailBits(tile), GetRailType(tile));
+				}
+				RoadTypes rts = GetRoadTypes(tile) & ComplementRoadTypes(RoadTypeToRoadTypes(rt));
+				if (rts == ROADTYPES_NONE) {
+					MakeRailNormal(tile, GetTileOwner(tile), GetCrossingRailBits(tile), GetRailType(tile));
+				} else {
+					SetRoadTypes(tile, rts);
+				}
 				MarkTileDirtyByTile(tile);
 				YapfNotifyTrackLayoutChange(tile, FindFirstTrack(GetTrackBits(tile)));
 			}
 			return _eco->GetPrice(CEconomy::REMOVE_ROAD) * 2;
 		}
 /** Build a piece of road.
 * @param tile tile where to build road
 * @param flags operation to perform
 * @param p1 bit 0..3 road pieces to build (RoadBits)
+*           bit 4..5 road type
 * @param p2 the town that is building the road (0 if not applicable)
 */
 int32 CmdBuildRoad(TileIndex tile, uint32 flags, uint32 p1, uint32 p2)
 {
 	int32 cost = 0;
 	/* Road pieces are max 4 bitset values (NE, NW, SE, SW) and town can only be non-zero
 	 * if a non-player is building the road */
 	if ((IsValidPlayer(_current_player) && p2 != 0) || (_current_player == OWNER_TOWN && !IsValidTownID(p2))) return CMD_ERROR;
 	RoadBits pieces = Extract<RoadBits, 0>(p1);
+	RoadType rt = (RoadType)GB(p1, 4, 2);
+	if (!IsValidRoadType(rt)) return CMD_ERROR;
 	tileh = GetTileSlope(tile, NULL);
 	switch (GetTileType(tile)) {
 		case MP_STREET:
 			switch (GetRoadTileType(tile)) {
 				case ROAD_TILE_NORMAL:
 					if (HasRoadWorks(tile)) return_cmd_error(STR_ROAD_WORKS_IN_PROGRESS);
+					if (!HASBIT(GetRoadTypes(tile), rt)) break;
-					existing = GetRoadBits(tile);
+					existing = GetRoadBits(tile, rt);
 					if ((existing & pieces) == pieces) {
 						return_cmd_error(STR_1007_ALREADY_BUILT);
 					}
 					if (!EnsureNoVehicleOnGround(tile)) return CMD_ERROR;
 					break;
 				case ROAD_TILE_CROSSING:
-					if (pieces != GetCrossingRoadBits(tile)) { // XXX is this correct?
+					if (HASBIT(GetRoadTypes(tile), rt)) return_cmd_error(STR_1007_ALREADY_BUILT);
-						return_cmd_error(STR_1007_ALREADY_BUILT);
+					if (pieces & ComplementRoadBits(GetCrossingRoadBits(tile))) goto do_clear;
-					}
+					break;
-					goto do_clear;
 				default:
 				case ROAD_TILE_DEPOT:
 					goto do_clear;
 			}
 			if (!EnsureNoVehicleOnGround(tile)) return CMD_ERROR;
 			if (flags & DC_EXEC) {
 				YapfNotifyTrackLayoutChange(tile, FindFirstTrack(GetTrackBits(tile)));
-				MakeRoadCrossing(tile, _current_player, GetTileOwner(tile), roaddir, GetRailType(tile), p2);
+				MakeRoadCrossing(tile, _current_player, _current_player, _current_player, GetTileOwner(tile), roaddir, GetRailType(tile), RoadTypeToRoadTypes(rt), p2);
 				MarkTileDirtyByTile(tile);
 			}
 			/** @todo should be more expensive */
 			return _eco->GetPrice(CEconomy::BUILD_ROAD) * 2;
 		}
 	}
 	if (flags & DC_EXEC) {
 		if (IsTileType(tile, MP_STREET)) {
-			SetRoadBits(tile, existing | pieces);
+			if (existing == ROAD_NONE) {
+				SetRoadTypes(tile, GetRoadTypes(tile) | RoadTypeToRoadTypes(rt));
+				SetRoadOwner(tile, rt, _current_player);
+			}
+			SetRoadBits(tile, existing | pieces, rt);
 		} else {
-			MakeRoadNormal(tile, _current_player, pieces, p2);
+			MakeRoadNormal(tile, pieces, RoadTypeToRoadTypes(rt), p2, _current_player, _current_player, _current_player);
 		}
 		MarkTileDirtyByTile(tile);
 	}
 	return cost;
 * @param p1 start tile of drag
 * @param p2 various bitstuffed elements
 * - p2 = (bit 0) - start tile starts in the 2nd half of tile (p2 & 1)
 * - p2 = (bit 1) - end tile starts in the 2nd half of tile (p2 & 2)
 * - p2 = (bit 2) - direction: 0 = along x-axis, 1 = along y-axis (p2 & 4)
+* - p2 = (bit 3 + 4) - road type
 */
 int32 CmdBuildLongRoad(TileIndex end_tile, uint32 flags, uint32 p1, uint32 p2)
 {
 	TileIndex start_tile, tile;
 	int32 cost, ret;
 	SET_EXPENSES_TYPE(EXPENSES_CONSTRUCTION);
 	if (p1 >= MapSize()) return CMD_ERROR;
 	start_tile = p1;
+	RoadType rt = (RoadType)GB(p2, 3, 2);
+	if (!IsValidRoadType(rt)) return CMD_ERROR;
 	/* Only drag in X or Y direction dictated by the direction variable */
 	if (!HASBIT(p2, 2) && TileY(start_tile) != TileY(end_tile)) return CMD_ERROR; // x-axis
 	if (HASBIT(p2, 2)  && TileX(start_tile) != TileX(end_tile)) return CMD_ERROR; // y-axis
 		RoadBits bits = HASBIT(p2, 2) ? ROAD_Y : ROAD_X;
 		if (tile == end_tile && !HASBIT(p2, 1)) bits &= ROAD_NW | ROAD_NE;
 		if (tile == start_tile && HASBIT(p2, 0)) bits &= ROAD_SE | ROAD_SW;
-		ret = DoCommand(tile, bits, 0, flags, CMD_BUILD_ROAD);
+		ret = DoCommand(tile, rt << 4 | bits, 0, flags, CMD_BUILD_ROAD);
 		if (CmdFailed(ret)) {
 			if (_error_message != STR_1007_ALREADY_BUILT) return CMD_ERROR;
 			_error_message = INVALID_STRING_ID;
 		} else {
 			cost += ret;
 * @param p1 start tile of drag
 * @param p2 various bitstuffed elements
 * - p2 = (bit 0) - start tile starts in the 2nd half of tile (p2 & 1)
 * - p2 = (bit 1) - end tile starts in the 2nd half of tile (p2 & 2)
 * - p2 = (bit 2) - direction: 0 = along x-axis, 1 = along y-axis (p2 & 4)
+* - p2 = (bit 3 + 4) - road type
 */
 int32 CmdRemoveLongRoad(TileIndex end_tile, uint32 flags, uint32 p1, uint32 p2)
 {
 	TileIndex start_tile, tile;
 	int32 cost, ret;
 	SET_EXPENSES_TYPE(EXPENSES_CONSTRUCTION);
 	if (p1 >= MapSize()) return CMD_ERROR;
 	start_tile = p1;
+	RoadType rt = (RoadType)GB(p2, 3, 2);
+	if (!IsValidRoadType(rt)) return CMD_ERROR;
 	/* Only drag in X or Y direction dictated by the direction variable */
 	if (!HASBIT(p2, 2) && TileY(start_tile) != TileY(end_tile)) return CMD_ERROR; // x-axis
 	if (HASBIT(p2, 2)  && TileX(start_tile) != TileX(end_tile)) return CMD_ERROR; // y-axis
 		if (tile == end_tile && !HASBIT(p2, 1)) bits &= ROAD_NW | ROAD_NE;
 		if (tile == start_tile && HASBIT(p2, 0)) bits &= ROAD_SE | ROAD_SW;
 		/* try to remove the halves. */
 		if (bits != 0) {
-			ret = DoCommand(tile, bits, 0, flags, CMD_REMOVE_ROAD);
+			ret = DoCommand(tile, rt << 4 | bits, 0, flags, CMD_REMOVE_ROAD);
 			if (!CmdFailed(ret)) cost += ret;
 		}
 		if (tile == end_tile) break;
 /** Build a road depot.
 * @param tile tile where to build the depot
 * @param flags operation to perform
 * @param p1 bit 0..1 entrance direction (DiagDirection)
+*           bit 2..3 road type
 * @param p2 unused
 *
 * @todo When checking for the tile slope,
 * distingush between "Flat land required" and "land sloped in wrong direction"
 */
 	Slope tileh;
 	SET_EXPENSES_TYPE(EXPENSES_CONSTRUCTION);
 	DiagDirection dir = Extract<DiagDirection, 0>(p1);
+	RoadType rt = (RoadType)GB(p1, 2, 2);
+	if (!IsValidRoadType(rt)) return CMD_ERROR;
 	tileh = GetTileSlope(tile, NULL);
 	if (tileh != SLOPE_FLAT && (
 				!_patches.build_on_slopes ||
 				IsSteepSlope(tileh) ||
 	if (flags & DC_EXEC) {
 		dep->xy = tile;
 		dep->town_index = ClosestTownFromTile(tile, (uint)-1)->index;
-		MakeRoadDepot(tile, _current_player, dir);
+		MakeRoadDepot(tile, _current_player, dir, rt);
 		MarkTileDirtyByTile(tile);
 	}
 	return cost;
 }
 static int32 ClearTile_Road(TileIndex tile, byte flags)
 {
 	switch (GetRoadTileType(tile)) {
 		case ROAD_TILE_NORMAL: {
-			RoadBits b = GetRoadBits(tile);
+			RoadBits b = GetAllRoadBits(tile);
 #define M(x) (1 << (x))
 			/* Clear the road if only one piece is on the tile OR the AI tries
 			 * to clear town road OR we are not using the DC_AUTO flag */
 			if ((M(b) & (M(ROAD_NW) | M(ROAD_SW) | M(ROAD_SE) | M(ROAD_NE))) ||
 	3,  0,  0,  0,
 	0,  0
 };
 /**
+* Whether to draw unpaved roads regardless of the town zone.
+* By default, OpenTTD always draws roads as unpaved if they are on a desert
+* tile or above the snowline. Newgrf files, however, can set a bit that allows
+* paved roads to be built on desert tiles as they would be on grassy tiles.
+*
+* @param tile The tile the road is on
+* @param roadside What sort of road this is
+* @return True if the road should be drawn unpaved regardless of the roadside.
+*/
+static bool AlwaysDrawUnpavedRoads(TileIndex tile, Roadside roadside)
+{
+	return (IsOnSnow(tile) &&
+			!(_opt.landscape == LT_TROPIC && HasGrfMiscBit(GMB_DESERT_PAVED_ROADS) &&
+				roadside != ROADSIDE_BARREN && roadside != ROADSIDE_GRASS && roadside != ROADSIDE_GRASS_ROAD_WORKS));
+}
+/**
 * Draw ground sprite and road pieces
 * @param ti TileInfo
 */
 static void DrawRoadBits(TileInfo* ti)
 {
-	RoadBits road = GetRoadBits(ti->tile);
+	RoadBits road = GetRoadBits(ti->tile, ROADTYPE_ROAD);
 	const DrawRoadTileStruct *drts;
 	SpriteID image = 0;
 	SpriteID pal = PAL_NONE;
 	Roadside roadside;
 	if (image == 0) image = _road_tile_sprites_1[road];
 	roadside = GetRoadside(ti->tile);
-	if (IsOnSnow(ti->tile)) {
+	if (AlwaysDrawUnpavedRoads(ti->tile, roadside)) {
 		image += 19;
 	} else {
 		switch (roadside) {
 			case ROADSIDE_BARREN:           pal = PALETTE_TO_BARE_LAND; break;
 			case ROADSIDE_GRASS:            break;
 		DrawGroundSprite(road & ROAD_X ? SPR_EXCAVATION_X : SPR_EXCAVATION_Y, PAL_NONE);
 		return;
 	}
 	/* Return if full detail is disabled, or we are zoomed fully out. */
-	if (!(_display_opt & DO_FULL_DETAIL) || _cur_dpi->zoom == 2) return;
+	if (!HASBIT(_display_opt, DO_FULL_DETAIL) || _cur_dpi->zoom > ZOOM_LVL_DETAIL) return;
 	/* Draw extra details. */
 	for (drts = _road_display_table[roadside][road]; drts->image != 0; drts++) {
 		int x = ti->x | drts->subcoord_x;
 		int y = ti->y | drts->subcoord_y;
 			break;
 		case ROAD_TILE_CROSSING: {
 			SpriteID image;
 			SpriteID pal = PAL_NONE;
+			Roadside roadside = GetRoadside(ti->tile);
 			if (ti->tileh != SLOPE_FLAT) DrawFoundation(ti, ti->tileh);
 			image = GetRailTypeInfo(GetRailType(ti->tile))->base_sprites.crossing;
 			if (GetCrossingRoadAxis(ti->tile) == AXIS_X) image++;
 			if (IsCrossingBarred(ti->tile)) image += 2;
-			if (IsOnSnow(ti->tile)) {
+			if (AlwaysDrawUnpavedRoads(ti->tile, roadside)) {
 				image += 8;
 			} else {
-				switch (GetRoadside(ti->tile)) {
+				switch (roadside) {
 					case ROADSIDE_BARREN: pal = PALETTE_TO_BARE_LAND; break;
 					case ROADSIDE_GRASS:  break;
 					default:              image += 4; break; // Paved
 				}
 			}
 		}
 	}
 	DrawBridgeMiddle(ti);
 }
-void DrawRoadDepotSprite(int x, int y, DiagDirection dir)
+void DrawRoadDepotSprite(int x, int y, DiagDirection dir, RoadType rt)
 {
 	SpriteID palette = PLAYER_SPRITE_COLOR(_local_player);
 	const DrawTileSprites* dts =  &_road_depot[dir];
 	const DrawTileSeqStruct* dtss;
 	uint z;
 	Slope tileh = GetTileSlope(tile, &z);
 	if (tileh == SLOPE_FLAT) return z;
 	if (GetRoadTileType(tile) == ROAD_TILE_NORMAL) {
-		uint f = GetRoadFoundation(tileh, GetRoadBits(tile));
+		uint f = GetRoadFoundation(tileh, GetAllRoadBits(tile));
 		if (f != 0) {
 			if (IsSteepSlope(tileh)) {
 				z += TILE_HEIGHT;
 			} else if (f < 15) {
 static Slope GetSlopeTileh_Road(TileIndex tile, Slope tileh)
 {
 	if (tileh == SLOPE_FLAT) return SLOPE_FLAT;
 	if (GetRoadTileType(tile) == ROAD_TILE_NORMAL) {
-		uint f = GetRoadFoundation(tileh, GetRoadBits(tile));
+		uint f = GetRoadFoundation(tileh, GetAllRoadBits(tile));
 		if (f == 0) return tileh;
 		if (f < 15) return SLOPE_FLAT; // leveled foundation
 		return _inclined_tileh[f - 15]; // inclined foundation
 	} else {
 			grp = t->GetRadiusGroup(tile);
 			/* Show an animation to indicate road work */
 			if (t->road_build_months != 0 &&
 					(DistanceManhattan(t->xy, tile) < 8 || grp != 0) &&
-					GetRoadTileType(tile) == ROAD_TILE_NORMAL && (GetRoadBits(tile) == ROAD_X || GetRoadBits(tile) == ROAD_Y)) {
+					GetRoadTileType(tile) == ROAD_TILE_NORMAL && (GetAllRoadBits(tile) == ROAD_X || GetAllRoadBits(tile) == ROAD_Y)) {
 				if (GetTileSlope(tile, NULL) == SLOPE_FLAT && EnsureNoVehicleOnGround(tile) && CHANCE16(1, 20)) {
 					StartRoadWorks(tile);
 					SndPlayTileFx(SND_21_JACKHAMMER, tile);
 					CreateEffectVehicleAbove(
 	0x0, 0x0, 0x0, 0x10, 0x0, 0x2, 0x8, 0x1A, 0x0, 0x4, 0x1, 0x15, 0x20, 0x26, 0x29, 0x3F,
 };
 static uint32 GetTileTrackStatus_Road(TileIndex tile, TransportType mode)
 {
+	RoadType rt = ROADTYPE_ROAD;
 	switch (mode) {
 		case TRANSPORT_RAIL:
 			if (!IsLevelCrossing(tile)) return 0;
 			return GetCrossingRailBits(tile) * 0x101;
 		case TRANSPORT_ROAD:
+			if (!HASBIT(GetRoadTypes(tile), rt)) return 0;
 			switch (GetRoadTileType(tile)) {
 				case ROAD_TILE_NORMAL:
-					return HasRoadWorks(tile) ? 0 : _road_trackbits[GetRoadBits(tile)] * 0x101;
+					return HasRoadWorks(tile) ? 0 : _road_trackbits[GetRoadBits(tile, rt)] * 0x101;
 				case ROAD_TILE_CROSSING: {
 					uint32 r = AxisToTrackBits(GetCrossingRoadAxis(tile)) * 0x101;
 					if (IsCrossingBarred(tile)) r *= 0x10001;
 }
 static void ChangeTileOwner_Road(TileIndex tile, PlayerID old_player, PlayerID new_player)
 {
-	if (IsLevelCrossing(tile) && GetCrossingRoadOwner(tile) == old_player) {
+	if (GetRoadTileType(tile) == ROAD_TILE_DEPOT) {
-		SetCrossingRoadOwner(tile, new_player == PLAYER_SPECTATOR ? OWNER_NONE : new_player);
+		DoCommand(tile, 0, 0, DC_EXEC, CMD_LANDSCAPE_CLEAR);
-	}
+		return;
+	}
-	if (!IsTileOwner(tile, old_player)) return;
+	for (RoadType rt = ROADTYPE_ROAD; rt < ROADTYPE_END; rt++) {
-	if (new_player != PLAYER_SPECTATOR) {
+		if (!HASBIT(GetRoadTypes(tile), rt)) continue;
-		SetTileOwner(tile, new_player);
-	} else {
+		if (GetRoadOwner(tile, rt) == old_player) {
-		switch (GetRoadTileType(tile)) {
+			SetRoadOwner(tile, rt, new_player == PLAYER_SPECTATOR ? OWNER_NONE : new_player);
-			case ROAD_TILE_NORMAL:
-				SetTileOwner(tile, OWNER_NONE);
+			if (rt == ROADTYPE_TRAM) {
-				break;
+				DoCommand(tile, ROADTYPE_TRAM << 4 | GetRoadBits(tile, ROADTYPE_ROAD), 0, DC_EXEC, CMD_REMOVE_ROAD);
+			}
-			case ROAD_TILE_CROSSING:
+		}
-				MakeRoadNormal(tile, GetCrossingRoadOwner(tile), GetCrossingRoadBits(tile), GetTownIndex(tile));
+	}
-				break;
+	if (IsLevelCrossing(tile)) {
-			default:
+		MakeRoadNormal(tile, GetCrossingRoadBits(tile), GetRoadTypes(tile), GetTownIndex(tile), GetRoadOwner(tile, ROADTYPE_ROAD), GetRoadOwner(tile, ROADTYPE_TRAM), GetRoadOwner(tile, ROADTYPE_HWAY));
-			case ROAD_TILE_DEPOT:
-				DoCommand(tile, 0, 0, DC_EXEC, CMD_LANDSCAPE_CLEAR);
-				break;
-		}
 	}
 }
 extern const TileTypeProcs _tile_type_road_procs = {

branch	gamebalance
changeset 9911	0b8b245a2391
parent 9910	0b2aebc8283e
child 9912	1ac8aac92385