openttd-ottdgrfs: comparison src/road

equal deleted inserted replaced

-:9b1552d0fd9b
+:f8eb3e208514
 				return CMD_ERROR;
 			}
 			/* Don't allow road to be removed from the crossing when there is tram;
 			 * we can't draw the crossing without trambits ;) */
-			if (rt == ROADTYPE_ROAD && HasBit(GetRoadTypes(tile), ROADTYPE_TRAM) && (flags & DC_EXEC || crossing_check)) return CMD_ERROR;
+			if (rt == ROADTYPE_ROAD && HasTileRoadType(tile, ROADTYPE_TRAM) && (flags & DC_EXEC || crossing_check)) return CMD_ERROR;
 			if (rt == ROADTYPE_ROAD) {
 				ChangeTownRating(t, -road_remove_cost[(byte)edge_road], RATING_ROAD_MINIMUM);
 			}
 	switch (GetTileType(tile)) {
 		case MP_ROAD:
 			switch (GetRoadTileType(tile)) {
 				case ROAD_TILE_NORMAL: {
 					if (HasRoadWorks(tile)) return_cmd_error(STR_ROAD_WORKS_IN_PROGRESS);
-					if (!EnsureNoVehicleOnGround(tile)) return CMD_ERROR;
 					all_bits = GetAllRoadBits(tile);
-					if (!HasBit(GetRoadTypes(tile), rt)) break;
+					if (!HasTileRoadType(tile, rt)) break;
 					existing = GetRoadBits(tile, rt);
 					RoadBits merged = existing | pieces;
 					bool crossing = (merged != ROAD_X && merged != ROAD_Y);
 					if (rt != ROADTYPE_TRAM && (GetDisallowedRoadDirections(tile) != DRD_NONE || toggle_drd != DRD_NONE) && crossing) {
 					if ((existing & pieces) == pieces) {
 						/* We only want to set the (dis)allowed road directions */
 						if (toggle_drd != DRD_NONE && rt != ROADTYPE_TRAM && GetRoadOwner(tile, ROADTYPE_ROAD) == _current_player) {
 							if (crossing) return_cmd_error(STR_ERR_ONEWAY_ROADS_CAN_T_HAVE_JUNCTION);
+							if (!EnsureNoVehicleOnGround(tile)) return CMD_ERROR;
 							/* Ignore half built tiles */
 							if (flags & DC_EXEC && rt != ROADTYPE_TRAM && (existing == ROAD_X || existing == ROAD_Y)) {
 								SetDisallowedRoadDirections(tile, GetDisallowedRoadDirections(tile) ^ toggle_drd);
 								MarkTileDirtyByTile(tile);
 							}
 						return_cmd_error(STR_1007_ALREADY_BUILT);
 					}
 				} break;
 				case ROAD_TILE_CROSSING:
-					if (HasBit(GetRoadTypes(tile), rt)) return_cmd_error(STR_1007_ALREADY_BUILT);
+					if (HasTileRoadType(tile, rt)) return_cmd_error(STR_1007_ALREADY_BUILT);
 					all_bits = GetCrossingRoadBits(tile);
 					if (pieces & ComplementRoadBits(all_bits)) goto do_clear;
 					break;
 				default:
 			return CommandCost(EXPENSES_CONSTRUCTION, _price.build_road * (rt == ROADTYPE_ROAD ? 2 : 4));
 		}
 		case MP_STATION:
 			if (!IsDriveThroughStopTile(tile)) return CMD_ERROR;
-			if (HasBit(GetRoadTypes(tile), rt)) return_cmd_error(STR_1007_ALREADY_BUILT);
+			if (HasTileRoadType(tile, rt)) return_cmd_error(STR_1007_ALREADY_BUILT);
-			/* Don't allow adding roadtype to the roadstop when vehicles are already driving on it */
-			if (!EnsureNoVehicleOnGround(tile)) return CMD_ERROR;
 			break;
 		case MP_TUNNELBRIDGE:
 			if (GetTunnelBridgeTransportType(tile) != TRANSPORT_ROAD) return CMD_ERROR;
-			if (HasBit(GetRoadTypes(tile), rt)) return_cmd_error(STR_1007_ALREADY_BUILT);
+			if (HasTileRoadType(tile, rt)) return_cmd_error(STR_1007_ALREADY_BUILT);
 			/* Don't allow adding roadtype to the bridge/tunnel when vehicles are already driving on it */
 			if (GetVehicleTunnelBridge(tile, GetOtherTunnelBridgeEnd(tile)) != NULL) return CMD_ERROR;
 			break;
 		default:
 	if (IsTileType(tile, MP_ROAD)) {
 		/* Don't put the pieces that already exist */
 		pieces &= ComplementRoadBits(existing);
 		/* Check if new road bits will have the same foundation as other existing road types */
-		if (GetRoadTileType(tile) == ROAD_TILE_NORMAL) {
+		if (IsNormalRoad(tile)) {
 			Slope slope = GetTileSlope(tile, NULL);
 			Foundation found_new = GetRoadFoundation(slope, pieces | existing);
 			/* Test if all other roadtypes can be built at that foundation */
 			for (RoadType rtest = ROADTYPE_ROAD; rtest < ROADTYPE_END; rtest++) {
 				}
 			}
 		}
 	}
+	if (!EnsureNoVehicleOnGround(tile)) return CMD_ERROR;
 	cost.AddCost(CountBits(pieces) * _price.build_road);
 	if (IsTileType(tile, MP_TUNNELBRIDGE)) {
 		/* Pay for *every* tile of the bridge or tunnel */
 		cost.MultiplyCost(GetTunnelBridgeLength(GetOtherTunnelBridgeEnd(tile), tile) + 2);
 	}
 			default:
 				MakeRoadNormal(tile, pieces, RoadTypeToRoadTypes(rt), p2, _current_player, _current_player, _current_player);
 				break;
 		}
-		if (rt != ROADTYPE_TRAM && IsTileType(tile, MP_ROAD) && GetRoadTileType(tile) == ROAD_TILE_NORMAL) {
+		if (rt != ROADTYPE_TRAM && IsNormalRoadTile(tile)) {
 			existing |= pieces;
 			SetDisallowedRoadDirections(tile, (existing == ROAD_X || existing == ROAD_Y) ?
 					GetDisallowedRoadDirections(tile) ^ toggle_drd : DRD_NONE);
 		}
 	bool had_bridge = false;
 	bool had_tunnel = false;
 	bool had_success = false;
 	DisallowedRoadDirections drd = DRD_NORTHBOUND;
+	_error_message = INVALID_STRING_ID;
 	if (p1 >= MapSize()) return CMD_ERROR;
 	start_tile = p1;
 	RoadType rt = (RoadType)GB(p2, 3, 2);
 	if (!IsValidRoadType(rt) || !ValParamRoadType(rt)) return CMD_ERROR;
 		if (tile == start_tile && HasBit(p2, 0)) bits &= ROAD_SE | ROAD_SW;
 		ret = DoCommand(tile, drd << 6 | 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 {
 			had_success = true;
 			/* Only pay for the upgrade on one side of the bridges and tunnels */
 			if (IsTileType(tile, MP_TUNNELBRIDGE)) {
 				if (IsBridge(tile)) {
 * @param tram the roadbits for the tram
 */
 void DrawTramCatenary(TileInfo *ti, RoadBits tram)
 {
 	/* Don't draw the catenary under a low bridge */
-	if (MayHaveBridgeAbove(ti->tile) && IsBridgeAbove(ti->tile) && !IsTransparencySet(TO_BUILDINGS)) {
+	if (MayHaveBridgeAbove(ti->tile) && IsBridgeAbove(ti->tile) && !IsTransparencySet(TO_CATENARY)) {
 		uint height = GetBridgeHeight(GetNorthernBridgeEnd(ti->tile));
 		if (height <= GetTileMaxZ(ti->tile) + TILE_HEIGHT) return;
 	}
 	} else {
 		back  = SPR_TRAMWAY_BASE + _road_backpole_sprites_1[tram];
 		front = SPR_TRAMWAY_BASE + _road_frontwire_sprites_1[tram];
 	}
-	AddSortableSpriteToDraw(back,  PAL_NONE, ti->x, ti->y, 16, 16, TILE_HEIGHT + BB_HEIGHT_UNDER_BRIDGE, ti->z, IsTransparencySet(TO_BUILDINGS));
+	AddSortableSpriteToDraw(back,  PAL_NONE, ti->x, ti->y, 16, 16, TILE_HEIGHT + BB_HEIGHT_UNDER_BRIDGE, ti->z, IsTransparencySet(TO_CATENARY));
-	AddSortableSpriteToDraw(front, PAL_NONE, ti->x, ti->y, 16, 16, TILE_HEIGHT + BB_HEIGHT_UNDER_BRIDGE, ti->z, IsTransparencySet(TO_BUILDINGS));
+	AddSortableSpriteToDraw(front, PAL_NONE, ti->x, ti->y, 16, 16, TILE_HEIGHT + BB_HEIGHT_UNDER_BRIDGE, ti->z, IsTransparencySet(TO_CATENARY));
 }
 /**
 * Draws details on/around the road
 * @param img the sprite to draw
 	if (tram != ROAD_NONE) DrawTramCatenary(ti, tram);
 	/* Return if full detail is disabled, or we are zoomed fully out. */
 	if (!HasBit(_display_opt, DO_FULL_DETAIL) || _cur_dpi->zoom > ZOOM_LVL_DETAIL) return;
+	/* Do not draw details (street lights, trees) under low bridge */
+	if (MayHaveBridgeAbove(ti->tile) && IsBridgeAbove(ti->tile) && (roadside == ROADSIDE_TREES || roadside == ROADSIDE_STREET_LIGHTS)) {
+		uint height = GetBridgeHeight(GetNorthernBridgeEnd(ti->tile));
+		uint minz = GetTileMaxZ(ti->tile) + 2 * TILE_HEIGHT;
+		if (roadside == ROADSIDE_TREES) minz += TILE_HEIGHT;
+		if (height < minz) return;
+	}
 	/* Draw extra details. */
 	for (drts = _road_display_table[roadside][road]; drts->image != 0; drts++) {
 		DrawRoadDetail(drts->image, ti, drts->subcoord_x, drts->subcoord_y, 0x10);
 	}
 }
 					default:              image += 4; break; // Paved
 				}
 			}
 			DrawGroundSprite(image, pal);
-			if (HasBit(GetRoadTypes(ti->tile), ROADTYPE_TRAM)) {
+			if (HasTileRoadType(ti->tile, ROADTYPE_TRAM)) {
 				DrawGroundSprite(SPR_TRAMWAY_OVERLAY + (GetCrossingRoadAxis(ti->tile) ^ 1), pal);
 				DrawTramCatenary(ti, GetCrossingRoadBits(ti->tile));
 			}
 			if (GetRailType(ti->tile) == RAILTYPE_ELECTRIC) DrawCatenary(ti);
 			break;
 			if (ti->tileh != SLOPE_FLAT) DrawFoundation(ti, FOUNDATION_LEVELED);
 			palette = PLAYER_SPRITE_COLOR(GetTileOwner(ti->tile));
-			if (HasBit(GetRoadTypes(ti->tile), ROADTYPE_TRAM)) {
+			if (HasTileRoadType(ti->tile, ROADTYPE_TRAM)) {
 				dts =  &_tram_depot[GetRoadDepotDirection(ti->tile)];
 			} else {
 				dts =  &_road_depot[GetRoadDepotDirection(ti->tile)];
 			}
-			DrawGroundSprite(dts->ground_sprite, PAL_NONE);
+			DrawGroundSprite(dts->ground.sprite, PAL_NONE);
-			for (dtss = dts->seq; dtss->image != 0; dtss++) {
+			for (dtss = dts->seq; dtss->image.sprite != 0; dtss++) {
-				SpriteID image = dtss->image;
+				SpriteID image = dtss->image.sprite;
 				SpriteID pal;
 				if (!IsTransparencySet(TO_BUILDINGS) && HasBit(image, PALETTE_MODIFIER_COLOR)) {
 					pal = palette;
 				} else {
 	const DrawTileSeqStruct* dtss;
 	x += 33;
 	y += 17;
-	DrawSprite(dts->ground_sprite, PAL_NONE, x, y);
+	DrawSprite(dts->ground.sprite, PAL_NONE, x, y);
-	for (dtss = dts->seq; dtss->image != 0; dtss++) {
+	for (dtss = dts->seq; dtss->image.sprite != 0; dtss++) {
 		Point pt = RemapCoords(dtss->delta_x, dtss->delta_y, dtss->delta_z);
-		SpriteID image = dtss->image;
+		SpriteID image = dtss->image.sprite;
 		DrawSprite(image, HasBit(image, PALETTE_MODIFIER_COLOR) ? palette : PAL_NONE, x + pt.x, y + pt.y);
 	}
 }
 {
 	uint z;
 	Slope tileh = GetTileSlope(tile, &z);
 	if (tileh == SLOPE_FLAT) return z;
-	if (GetRoadTileType(tile) == ROAD_TILE_NORMAL) {
+	if (IsNormalRoad(tile)) {
 		Foundation f = GetRoadFoundation(tileh, GetAllRoadBits(tile));
 		z += ApplyFoundationToSlope(f, &tileh);
 		return z + GetPartialZ(x & 0xF, y & 0xF, tileh);
 	} else {
 		return z + TILE_HEIGHT;
 	}
 }
 static Foundation GetFoundation_Road(TileIndex tile, Slope tileh)
 {
-	if (GetRoadTileType(tile) == ROAD_TILE_NORMAL) {
+	if (IsNormalRoad(tile)) {
 		return GetRoadFoundation(tileh, GetAllRoadBits(tile));
 	} else {
 		return FlatteningFoundation(tileh);
 	}
 }
 				MarkTileDirtyByTile(tile);
 			}
 			break;
 	}
-	if (GetRoadTileType(tile) == ROAD_TILE_DEPOT) return;
+	if (IsRoadDepot(tile)) return;
 	const Town* t = ClosestTownFromTile(tile, (uint)-1);
 	if (!HasRoadWorks(tile)) {
 		HouseZonesBits grp = HZB_TOWN_EDGE;
 			grp = GetTownRadiusGroup(t, tile);
 			/* Show an animation to indicate road work */
 			if (t->road_build_months != 0 &&
 					(DistanceManhattan(t->xy, tile) < 8 || grp != HZB_TOWN_EDGE) &&
-					GetRoadTileType(tile) == ROAD_TILE_NORMAL && CountBits(GetAllRoadBits(tile)) > 1 ) {
+					IsNormalRoad(tile) && CountBits(GetAllRoadBits(tile)) > 1 ) {
 				if (GetTileSlope(tile, NULL) == SLOPE_FLAT && EnsureNoVehicleOnGround(tile) && Chance16(1, 40)) {
 					StartRoadWorks(tile);
 					SndPlayTileFx(SND_21_JACKHAMMER, tile);
 					CreateEffectVehicleAbove(
 	}
 }
 static void ClickTile_Road(TileIndex tile)
 {
-	if (GetRoadTileType(tile) == ROAD_TILE_DEPOT) ShowDepotWindow(tile, VEH_ROAD);
+	if (IsRoadDepot(tile)) ShowDepotWindow(tile, VEH_ROAD);
 }
+/* Converts RoadBits to TrackBits */
 static const byte _road_trackbits[16] = {
 	0x0, 0x0, 0x0, 0x10, 0x0, 0x2, 0x8, 0x1A, 0x0, 0x4, 0x1, 0x15, 0x20, 0x26, 0x29, 0x3F,
 };
-static uint32 GetTileTrackStatus_Road(TileIndex tile, TransportType mode, uint sub_mode)
+static TrackStatus GetTileTrackStatus_Road(TileIndex tile, TransportType mode, uint sub_mode, DiagDirection side)
 {
+	TrackdirBits trackdirbits = TRACKDIR_BIT_NONE;
+	TrackdirBits red_signals = TRACKDIR_BIT_NONE; // crossing barred
 	switch (mode) {
 		case TRANSPORT_RAIL:
-			if (!IsLevelCrossing(tile)) return 0;
+			if (IsLevelCrossing(tile)) trackdirbits = TrackBitsToTrackdirBits(GetCrossingRailBits(tile));
-			return GetCrossingRailBits(tile) * 0x101;
+			break;
 		case TRANSPORT_ROAD:
-			if ((GetRoadTypes(tile) & sub_mode) == 0) return 0;
+			if ((GetRoadTypes(tile) & sub_mode) == 0) break;
 			switch (GetRoadTileType(tile)) {
 				case ROAD_TILE_NORMAL: {
+					const uint drd_to_multiplier[DRD_END] = { 0x101, 0x100, 0x1, 0x0 };
 					RoadType rt = (RoadType)FindFirstBit(sub_mode);
-					const uint drd_to_multiplier[DRD_END] = { 0x101, 0x100, 0x1, 0x0 };
+					RoadBits bits = GetRoadBits(tile, rt);
+					/* no roadbit at this side of tile, return 0 */
+					if (side != INVALID_DIAGDIR && (DiagDirToRoadBits(side) & bits) == 0) break;
 					uint multiplier = drd_to_multiplier[rt == ROADTYPE_TRAM ? DRD_NONE : GetDisallowedRoadDirections(tile)];
-					return HasRoadWorks(tile) ? 0 : _road_trackbits[GetRoadBits(tile, rt)] * multiplier;
+					if (!HasRoadWorks(tile)) trackdirbits = (TrackdirBits)(_road_trackbits[bits] * multiplier);
+					break;
 				}
 				case ROAD_TILE_CROSSING: {
-					uint32 r = AxisToTrackBits(GetCrossingRoadAxis(tile)) * 0x101;
+					Axis axis = GetCrossingRoadAxis(tile);
-					if (IsCrossingBarred(tile)) r *= 0x10001;
+					if (side != INVALID_DIAGDIR && axis != DiagDirToAxis(side)) break;
-					return r;
+					trackdirbits = TrackBitsToTrackdirBits(AxisToTrackBits(axis));
+					if (IsCrossingBarred(tile)) red_signals = trackdirbits;
+					break;
 				}
 				default:
-				case ROAD_TILE_DEPOT:
+				case ROAD_TILE_DEPOT: {
-					return AxisToTrackBits(DiagDirToAxis(GetRoadDepotDirection(tile))) * 0x101;
+					DiagDirection dir = GetRoadDepotDirection(tile);
+					if (side != INVALID_DIAGDIR && side != dir) break;
+					trackdirbits = TrackBitsToTrackdirBits(AxisToTrackBits(DiagDirToAxis(dir)));
+					break;
+				}
 			}
 			break;
 		default: break;
 	}
-	return 0;
+	return CombineTrackStatus(trackdirbits, red_signals);
 }
 static const StringID _road_tile_strings[] = {
 	STR_1814_ROAD,
 	STR_1814_ROAD,
 }
 static void ChangeTileOwner_Road(TileIndex tile, PlayerID old_player, PlayerID new_player)
 {
-	if (GetRoadTileType(tile) == ROAD_TILE_DEPOT) {
+	if (IsRoadDepot(tile)) {
 		if (GetTileOwner(tile) == old_player) {
 			if (new_player == PLAYER_SPECTATOR) {
-				DoCommand(tile, 0, 0, DC_EXEC, CMD_LANDSCAPE_CLEAR);
+				DoCommand(tile, 0, 0, DC_EXEC | DC_BANKRUPT, CMD_LANDSCAPE_CLEAR);
 			} else {
 				SetTileOwner(tile, new_player);
 			}
 		}
 		return;
 	}
 	for (RoadType rt = ROADTYPE_ROAD; rt < ROADTYPE_END; rt++) {
-		if (!HasBit(GetRoadTypes(tile), rt)) continue;
+		/* ROADTYPE_ROAD denotes the tile owner, so update it too */
+		if (rt != ROADTYPE_ROAD && !HasTileRoadType(tile, rt)) continue;
 		if (GetRoadOwner(tile, rt) == old_player) {
 			SetRoadOwner(tile, rt, new_player == PLAYER_SPECTATOR ? OWNER_NONE : new_player);
 		}
 	}
 	if (IsLevelCrossing(tile)) {
 		if (GetTileOwner(tile) == old_player) {
 			if (new_player == PLAYER_SPECTATOR) {
-				MakeRoadNormal(tile, GetCrossingRoadBits(tile), GetRoadTypes(tile), GetTownIndex(tile), GetRoadOwner(tile, ROADTYPE_ROAD), GetRoadOwner(tile, ROADTYPE_TRAM), GetRoadOwner(tile, ROADTYPE_HWAY));
+				DoCommand(tile, 0, GetCrossingRailTrack(tile), DC_EXEC | DC_BANKRUPT, CMD_REMOVE_SINGLE_RAIL);
 			} else {
 				SetTileOwner(tile, new_player);
 			}
 		}
 	}

branch	noai
changeset 9732	f8eb3e208514
parent 9724	b39bc69bb2f2
child 9800	ab08ca2a2018