openttd-ottdgrfs: comparison src/water

equal deleted inserted replaced

-:ffcab947226b
+:a0b7938c6082
 #include "vehicle_func.h"
 #include "sound_func.h"
 #include "variables.h"
 #include "player_func.h"
 #include "settings_type.h"
+#include "clear_map.h"
 #include "table/sprites.h"
 #include "table/strings.h"
-static Vehicle *FindFloodableVehicleOnTile(TileIndex tile);
+/**
-static void FloodVehicle(Vehicle *v);
+* Describes the behaviour of a tile during flooding.
+*/
+enum FloodingBehaviour {
+	FLOOD_NONE,    ///< The tile does not flood neighboured tiles.
+	FLOOD_ACTIVE,  ///< The tile floods neighboured tiles.
+	FLOOD_PASSIVE, ///< The tile does not actively flood neighboured tiles, but it prevents them from drying up.
+	FLOOD_DRYUP,   ///< The tile drys up if it is not constantly flooded from neighboured tiles.
+};
+/**
+* Describes from which directions a specific slope can be flooded (if the tile is floodable at all).
+*/
+static const uint8 _flood_from_dirs[] = {
+	(1 << DIR_NW) | (1 << DIR_SW) | (1 << DIR_SE) | (1 << DIR_NE), // SLOPE_FLAT
+	(1 << DIR_NE) | (1 << DIR_SE),                                 // SLOPE_W
+	(1 << DIR_NW) | (1 << DIR_NE),                                 // SLOPE_S
+	(1 << DIR_NE),                                                 // SLOPE_SW
+	(1 << DIR_NW) | (1 << DIR_SW),                                 // SLOPE_E
+	0,                                                             // SLOPE_EW
+	(1 << DIR_NW),                                                 // SLOPE_SE
+	(1 << DIR_N ) | (1 << DIR_NW) | (1 << DIR_NE),                 // SLOPE_WSE, SLOPE_STEEP_S
+	(1 << DIR_SW) | (1 << DIR_SE),                                 // SLOPE_N
+	(1 << DIR_SE),                                                 // SLOPE_NW
+	0,                                                             // SLOPE_NS
+	(1 << DIR_E ) | (1 << DIR_NE) | (1 << DIR_SE),                 // SLOPE_NWS, SLOPE_STEEP_W
+	(1 << DIR_SW),                                                 // SLOPE_NE
+	(1 << DIR_S ) | (1 << DIR_SW) | (1 << DIR_SE),                 // SLOPE_ENW, SLOPE_STEEP_N
+	(1 << DIR_W ) | (1 << DIR_SW) | (1 << DIR_NW),                 // SLOPE_SEN, SLOPE_STEEP_E
+};
+/**
+* Slopes that contain flat water and not only shore.
+*/
+static const uint32 _active_water_slopes = (1 << SLOPE_FLAT) | (1 << SLOPE_W) | (1 << SLOPE_S) | (1 << SLOPE_E) | (1 << SLOPE_N);
 /**
 * Makes a tile canal or water depending on the surroundings.
 * This as for example docks and shipdepots do not store
 * whether the tile used to be canal or 'normal' water.
 	/* Draw canal dikes if there are no river edges to draw. */
 	if (edges_base <= 48) edges_base = SPR_CANAL_DIKES_BASE;
 	DrawWaterEdges(edges_base, ti->tile);
 }
+void DrawShoreTile(Slope tileh)
+{
+	/* Converts the enum Slope into an offset based on SPR_SHORE_BASE.
+	 * This allows to calculate the proper sprite to display for this Slope */
+	static const byte tileh_to_shoresprite[32] = {
+		0, 1, 2, 3, 4, 16, 6, 7, 8, 9, 17, 11, 12, 13, 14, 0,
+		0, 0, 0, 0, 0,  0, 0, 0, 0, 0,  0,  5,  0, 10, 15, 0,
+	};
+	assert(!IsHalftileSlope(tileh)); // Halftile slopes need to get handled earlier.
+	assert(tileh != SLOPE_FLAT);     // Shore is never flat
+	assert((tileh != SLOPE_EW) && (tileh != SLOPE_NS)); // No suitable sprites for current flooding behaviour
+	DrawGroundSprite(SPR_SHORE_BASE + tileh_to_shoresprite[tileh], PAL_NONE);
+}
 static void DrawTile_Water(TileInfo *ti)
 {
 	switch (GetWaterTileType(ti->tile)) {
 		case WATER_TILE_CLEAR:
 			DrawGroundSprite(SPR_FLAT_WATER_TILE, PAL_NONE);
 			if (IsCanal(ti->tile)) DrawCanalWater(ti->tile);
 			DrawBridgeMiddle(ti);
 			break;
 		case WATER_TILE_COAST: {
-			/* Converts the enum Slope into an offset based on SPR_SHORE_BASE.
+			DrawShoreTile(ti->tileh);
-			 * This allows to calculate the proper sprite to display for this Slope */
-			static const byte tileh_to_shoresprite[32] = {
-				0, 1, 2, 3, 4, 16, 6, 7, 8, 9, 17, 11, 12, 13, 14, 0,
-				0, 0, 0, 0, 0,  0, 0, 0, 0, 0,  0,  5,  0, 10, 15, 0,
-			};
-			assert(!IsSteepSlope(ti->tileh));
-			DrawGroundSprite(SPR_SHORE_BASE + tileh_to_shoresprite[ti->tileh], PAL_NONE);
 			DrawBridgeMiddle(ti);
 		} break;
 		case WATER_TILE_LOCK: {
 			const WaterDrawTileStruct *t = _shiplift_display_seq[GetSection(ti->tile)];
 static inline void MarkTileDirtyIfCanal(TileIndex tile)
 {
 	if (IsTileType(tile, MP_WATER) && IsCanal(tile)) MarkTileDirtyByTile(tile);
 }
-/**
-* Floods neighboured floodable tiles
-*
-* @param tile The water source tile that causes the flooding.
-* @param offs[0] Destination tile to flood.
-* @param offs[1] First corner of edge between source and dest tile.
-* @param offs[2] Second corder of edge between source and dest tile.
-* @param offs[3] Third corner of dest tile.
-* @param offs[4] Fourth corner of dest tile.
-*/
-static void TileLoopWaterHelper(TileIndex tile, const TileIndexDiffC *offs)
-{
-	TileIndex target = TILE_ADD(tile, ToTileIndexDiff(offs[0]));
-	/* type of this tile mustn't be water already. */
-	if (IsTileType(target, MP_WATER)) return;
-	/* Are both corners of the edge between source and dest on height 0 ? */
-	if (TileHeight(TILE_ADD(tile, ToTileIndexDiff(offs[1]))) != 0 ||
-			TileHeight(TILE_ADD(tile, ToTileIndexDiff(offs[2]))) != 0) {
-		return;
-	}
-	bool flooded = false; // Will be set to true, when something is flooded
-	/* Is any corner of the dest tile raised? (First two corners already checked above. */
-	if (TileHeight(TILE_ADD(tile, ToTileIndexDiff(offs[3]))) != 0 ||
-			TileHeight(TILE_ADD(tile, ToTileIndexDiff(offs[4]))) != 0) {
-		/* make coast.. */
-		switch (GetTileType(target)) {
-			case MP_RAILWAY: {
-				if (!IsPlainRailTile(target)) break;
-				flooded = FloodHalftile(target);
-				Vehicle *v = FindFloodableVehicleOnTile(target);
-				if (v != NULL) FloodVehicle(v);
-				break;
-			}
-			case MP_CLEAR:
-			case MP_TREES:
-				_current_player = OWNER_WATER;
-				if (CmdSucceeded(DoCommand(target, 0, 0, DC_EXEC, CMD_LANDSCAPE_CLEAR))) {
-					flooded = true;
-					MakeShore(target);
-					MarkTileDirtyByTile(target);
-				}
-				break;
-			default:
-				break;
-		}
-	} else {
-		/* Flood vehicles */
-		_current_player = OWNER_WATER;
-		Vehicle *v = FindFloodableVehicleOnTile(target);
-		if (v != NULL) FloodVehicle(v);
-		/* flood flat tile */
-		if (CmdSucceeded(DoCommand(target, 0, 0, DC_EXEC, CMD_LANDSCAPE_CLEAR))) {
-			flooded = true;
-			MakeWater(target);
-			MarkTileDirtyByTile(target);
-		}
-	}
-	if (flooded) {
-		/* Mark surrounding canal tiles dirty too to avoid glitches */
-		for (Direction dir = DIR_BEGIN; dir < DIR_END; dir++) {
-			MarkTileDirtyIfCanal(target + TileOffsByDir(dir));
-		}
-		/* update signals if needed */
-		UpdateSignalsInBuffer();
-	}
-}
 /**
 * Finds a vehicle to flood.
 * It does not find vehicles that are already crashed on bridges, i.e. flooded.
 * @param tile the tile where to find a vehicle to flood
 		SndPlayVehicleFx(SND_12_EXPLOSION, v);
 	}
 }
 /**
+* Returns the behaviour of a tile during flooding.
+*
+* @return Behaviour of the tile
+*/
+static FloodingBehaviour GetFloodingBehaviour(TileIndex tile)
+{
+	/* FLOOD_ACTIVE:  'single-corner-raised'-coast, sea, sea-shipdepots, sea-buoys, rail with flooded halftile
+	 * FLOOD_DRYUP:   coast with more than one corner raised
+	 * FLOOD_PASSIVE: oilrig, dock, water-industries
+	 * FLOOD_NONE:    canals, rivers, everything else
+	 */
+	switch (GetTileType(tile)) {
+		case MP_WATER:
+			if (IsCoast(tile)) {
+				Slope tileh = GetTileSlope(tile, NULL);
+				return (HasBit(_active_water_slopes, tileh) ? FLOOD_ACTIVE : FLOOD_DRYUP);
+			} else {
+				return ((IsSea(tile) || (IsShipDepot(tile) && (GetShipDepotWaterOwner(tile) == OWNER_WATER))) ? FLOOD_ACTIVE : FLOOD_NONE);
+			}
+		case MP_RAILWAY:
+			return ((GetRailGroundType(tile) == RAIL_GROUND_WATER) ? FLOOD_ACTIVE : FLOOD_NONE);
+		case MP_STATION:
+			if (IsSeaBuoyTile(tile)) return FLOOD_ACTIVE;
+			if (IsOilRig(tile) || IsDock(tile)) return FLOOD_PASSIVE;
+			return FLOOD_NONE;
+		case MP_INDUSTRY:
+			return ((GetIndustrySpec(GetIndustryType(tile))->behaviour & INDUSTRYBEH_BUILT_ONWATER) != 0 ? FLOOD_PASSIVE : FLOOD_NONE);
+		default:
+			return FLOOD_NONE;
+	}
+}
+/**
+* Floods a tile.
+*/
+static void DoFloodTile(TileIndex target)
+{
+	if (IsTileType(target, MP_WATER)) return;
+	bool flooded = false; // Will be set to true if something is changed.
+	_current_player = OWNER_WATER;
+	if (GetTileSlope(target, NULL) != SLOPE_FLAT) {
+		/* make coast.. */
+		switch (GetTileType(target)) {
+			case MP_RAILWAY: {
+				if (!IsPlainRailTile(target)) break;
+				flooded = FloodHalftile(target);
+				Vehicle *v = FindFloodableVehicleOnTile(target);
+				if (v != NULL) FloodVehicle(v);
+				break;
+			}
+			case MP_CLEAR:
+			case MP_TREES:
+				if (CmdSucceeded(DoCommand(target, 0, 0, DC_EXEC, CMD_LANDSCAPE_CLEAR))) {
+					MakeShore(target);
+					MarkTileDirtyByTile(target);
+					flooded = true;
+				}
+				break;
+			default:
+				break;
+		}
+	} else {
+		/* Flood vehicles */
+		Vehicle *v = FindFloodableVehicleOnTile(target);
+		if (v != NULL) FloodVehicle(v);
+		/* flood flat tile */
+		if (CmdSucceeded(DoCommand(target, 0, 0, DC_EXEC, CMD_LANDSCAPE_CLEAR))) {
+			MakeWater(target);
+			MarkTileDirtyByTile(target);
+			flooded = true;
+		}
+	}
+	if (flooded) {
+		/* Mark surrounding canal tiles dirty too to avoid glitches */
+		for (Direction dir = DIR_BEGIN; dir < DIR_END; dir++) {
+			MarkTileDirtyIfCanal(target + TileOffsByDir(dir));
+		}
+		/* update signals if needed */
+		UpdateSignalsInBuffer();
+	}
+	_current_player = OWNER_NONE;
+}
+/**
+* Drys a tile up.
+*/
+static void DoDryUp(TileIndex tile)
+{
+	assert(IsTileType(tile, MP_WATER) && IsCoast(tile));
+	_current_player = OWNER_WATER;
+	if (CmdSucceeded(DoCommand(tile, 0, 0, DC_EXEC, CMD_LANDSCAPE_CLEAR))) {
+		MakeClear(tile, CLEAR_GRASS, 3);
+		MarkTileDirtyByTile(tile);
+	}
+	_current_player = OWNER_NONE;
+}
+/**
 * Let a water tile floods its diagonal adjoining tiles
 * called from tunnelbridge_cmd, and by TileLoop_Industry() and TileLoop_Track()
 *
 * @param tile the water/shore tile that floods
 */
 void TileLoop_Water(TileIndex tile)
 {
-	static const TileIndexDiffC _tile_loop_offs_array[][5] = {
+	switch (GetFloodingBehaviour(tile)) {
-		// tile to mod              shore?    shore?
+		case FLOOD_ACTIVE:
-		{{-1,  0}, {0, 0}, {0, 1}, {-1,  0}, {-1,  1}},
+			for (Direction dir = DIR_BEGIN; dir < DIR_END; dir++) {
-		{{ 0,  1}, {0, 1}, {1, 1}, { 0,  2}, { 1,  2}},
+				TileIndex dest = AddTileIndexDiffCWrap(tile, TileIndexDiffCByDir(dir));
-		{{ 1,  0}, {1, 0}, {1, 1}, { 2,  0}, { 2,  1}},
+				if (dest == INVALID_TILE) continue;
-		{{ 0, -1}, {0, 0}, {1, 0}, { 0, -1}, { 1, -1}}
-	};
+				uint z_dest;
+				Slope slope_dest = (Slope)(GetFoundationSlope(dest, &z_dest) & ~SLOPE_HALFTILE_MASK & ~SLOPE_STEEP);
-	/* Ensure buoys on canal borders do not flood */
+				if (z_dest > 0) continue;
-	if (IsCanalBuoyTile(tile)) return;
-	/* Ensure only sea and coast floods, not canals or rivers */
+				if (!HasBit(_flood_from_dirs[slope_dest], ReverseDir(dir))) continue;
-	if (IsTileType(tile, MP_WATER) && !(IsSea(tile) || IsCoast(tile))) return;
+				DoFloodTile(dest);
-	/* floods in all four diagonal directions with the exception of the edges */
+			}
-	if (IsInsideMM(TileX(tile), 1, MapSizeX() - 3 + 1) &&
+			break;
-			IsInsideMM(TileY(tile), 1, MapSizeY() - 3 + 1)) {
-		uint i;
+		case FLOOD_DRYUP: {
+			Slope slope_here = (Slope)(GetFoundationSlope(tile, NULL) & ~SLOPE_HALFTILE_MASK & ~SLOPE_STEEP);
-		for (i = 0; i != lengthof(_tile_loop_offs_array); i++) {
+			uint check_dirs = _flood_from_dirs[slope_here];
-			TileLoopWaterHelper(tile, _tile_loop_offs_array[i]);
+			uint dir;
-		}
+			FOR_EACH_SET_BIT(dir, check_dirs) {
-	}
+				TileIndex dest = AddTileIndexDiffCWrap(tile, TileIndexDiffCByDir((Direction)dir));
+				if (dest == INVALID_TILE) continue;
-	/* _current_player can be changed by TileLoopWaterHelper.. reset it back here */
-	_current_player = OWNER_NONE;
+				FloodingBehaviour dest_behaviour = GetFloodingBehaviour(dest);
+				if ((dest_behaviour == FLOOD_ACTIVE) || (dest_behaviour == FLOOD_PASSIVE)) return;
-	/* edges */
+			}
-	if (TileX(tile) == 0 && IsInsideMM(TileY(tile), 1, MapSizeY() - 3 + 1)) { //NE
+			DoDryUp(tile);
-		TileLoopWaterHelper(tile, _tile_loop_offs_array[2]);
+			break;
-	}
+		}
-	if (TileX(tile) == MapSizeX() - 2 && IsInsideMM(TileY(tile), 1, MapSizeY() - 3 + 1)) { //SW
+		default: return;
-		TileLoopWaterHelper(tile, _tile_loop_offs_array[0]);
+	}
-	}
+}
-	if (TileY(tile) == 0 && IsInsideMM(TileX(tile), 1, MapSizeX() - 3 + 1)) { //NW
+void ConvertGroundTilesIntoWaterTiles()
-		TileLoopWaterHelper(tile, _tile_loop_offs_array[1]);
+{
-	}
+	TileIndex tile;
+	uint z;
-	if (TileY(tile) == MapSizeY() - 2 && IsInsideMM(TileX(tile), 1, MapSizeX() - 3 + 1)) { //SE
+	Slope slope;
-		TileLoopWaterHelper(tile, _tile_loop_offs_array[3]);
+	for (tile = 0; tile < MapSize(); ++tile) {
+		slope = GetTileSlope(tile, &z);
+		if (IsTileType(tile, MP_CLEAR) && z == 0) {
+			/* Make both water for tiles at level 0
+			 * and make shore, as that looks much better
+			 * during the generation. */
+			switch (slope) {
+				case SLOPE_FLAT:
+					MakeWater(tile);
+					break;
+				case SLOPE_N:
+				case SLOPE_E:
+				case SLOPE_S:
+				case SLOPE_W:
+					MakeShore(tile);
+					break;
+				default:
+					uint check_dirs = _flood_from_dirs[slope & ~SLOPE_STEEP];
+					uint dir;
+					FOR_EACH_SET_BIT(dir, check_dirs) {
+						TileIndex dest = TILE_ADD(tile, TileOffsByDir((Direction)dir));
+						Slope slope_dest = (Slope)(GetTileSlope(dest, NULL) & ~SLOPE_STEEP);
+						if (HasBit(_active_water_slopes, slope_dest)) {
+							MakeShore(tile);
+							break;
+						}
+					}
+					break;
+			}
+		}
 	}
 }
 static uint32 GetTileTrackStatus_Water(TileIndex tile, TransportType mode, uint sub_mode)
 {

changeset 8876	a0b7938c6082
parent 8864	0082e49e8351
child 8882	f54bd3d64027