openttd-ottdgrfs: comparison src/water

equal deleted inserted replaced

-:ca3fd1fbe311
+:5a9dc001e1ad
 #include "water_map.h"
 #include "industry_map.h"
 #include "newgrf.h"
 #include "newgrf_canal.h"
 #include "misc/autoptr.hpp"
+#include "transparency.h"
+/** Array for the shore sprites */
 static const SpriteID _water_shore_sprites[] = {
 	0,
-	SPR_SHORE_TILEH_1,
+	SPR_SHORE_TILEH_1,  // SLOPE_W
-	SPR_SHORE_TILEH_2,
+	SPR_SHORE_TILEH_2,  // SLOPE_S
-	SPR_SHORE_TILEH_3,
+	SPR_SHORE_TILEH_3,  // SLOPE_SW
-	SPR_SHORE_TILEH_4,
+	SPR_SHORE_TILEH_4,  // SLOPE_E
 	0,
-	SPR_SHORE_TILEH_6,
+	SPR_SHORE_TILEH_6,  // SLOPE_SE
 	0,
-	SPR_SHORE_TILEH_8,
+	SPR_SHORE_TILEH_8,  // SLOPE_N
-	SPR_SHORE_TILEH_9,
+	SPR_SHORE_TILEH_9,  // SLOPE_NW
 	0,
 	0,
-	SPR_SHORE_TILEH_12,
+	SPR_SHORE_TILEH_12, // SLOPE_NE
 	0,
 	0
 };
 static Vehicle *FindFloodableVehicleOnTile(TileIndex tile);
 static void FloodVehicle(Vehicle *v);
+/**
+* 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.
+* @param t the tile to change.
+* @param o the owner of the new tile.
+*/
+void MakeWaterOrCanalDependingOnSurroundings(TileIndex t, Owner o)
+{
+	assert(GetTileSlope(t, NULL) == SLOPE_FLAT);
+	/* Non-sealevel -> canal */
+	if (TileHeight(t) != 0) {
+		MakeCanal(t, o);
+		return;
+	}
+	bool has_water = false;
+	bool has_canal = false;
+	for (DiagDirection dir = DIAGDIR_BEGIN; dir < DIAGDIR_END; dir++) {
+		TileIndex neighbour = TileAddByDiagDir(t, dir);
+		if (IsTileType(neighbour, MP_WATER)) {
+			has_water |= IsSea(neighbour) || IsCoast(neighbour);
+			has_canal |= IsCanal(neighbour);
+		}
+	}
+	if (has_canal || !has_water) {
+		MakeCanal(t, o);
+	} else {
+		MakeWater(t);
+	}
+	MarkTileDirtyByTile(t);
+}
 /** Build a ship depot.
 * @param tile tile where ship depot is built
 * @param flags type of operation
 * @param p1 bit 0 depot orientation (Axis)
 	Axis axis = Extract<Axis, 0>(p1);
 	tile2 = tile + (axis == AXIS_X ? TileDiffXY(1, 0) : TileDiffXY(0, 1));
-	if (!IsClearWaterTile(tile) || !IsClearWaterTile(tile2))
+	if (!IsWaterTile(tile) || !IsWaterTile(tile2))
 		return_cmd_error(STR_3801_MUST_BE_BUILT_ON_WATER);
 	if (IsBridgeAbove(tile) || IsBridgeAbove(tile2)) return_cmd_error(STR_5007_MUST_DEMOLISH_BRIDGE_FIRST);
 	ret = DoCommand(tile, 0, 0, flags, CMD_LANDSCAPE_CLEAR);
 {
 	TileIndex tile2;
 	if (!IsShipDepot(tile)) return CMD_ERROR;
 	if (!CheckTileOwnership(tile)) return CMD_ERROR;
-	if (!EnsureNoVehicle(tile)) return CMD_ERROR;
+	if (!EnsureNoVehicleOnGround(tile)) return CMD_ERROR;
 	tile2 = GetOtherShipDepotTile(tile);
-	if (!EnsureNoVehicle(tile2)) return CMD_ERROR;
+	if (!EnsureNoVehicleOnGround(tile2)) return CMD_ERROR;
 	if (flags & DC_EXEC) {
 		/* Kill the depot, which is registered at the northernmost tile. Use that one */
 		delete GetDepotByTile(tile2 < tile ? tile2 : tile);
 	TileIndexDiff delta = TileOffsByDiagDir(GetLockDirection(tile));
 	if (!CheckTileOwnership(tile) && GetTileOwner(tile) != OWNER_NONE) return CMD_ERROR;
 	/* make sure no vehicle is on the tile. */
-	if (!EnsureNoVehicle(tile) || !EnsureNoVehicle(tile + delta) || !EnsureNoVehicle(tile - delta))
+	if (!EnsureNoVehicleOnGround(tile) || !EnsureNoVehicleOnGround(tile + delta) || !EnsureNoVehicleOnGround(tile - delta))
 		return CMD_ERROR;
 	if (flags & DC_EXEC) {
 		DoClearSquare(tile);
-		DoClearSquare(tile + delta);
+		MakeWaterOrCanalDependingOnSurroundings(tile + delta, _current_player);
-		DoClearSquare(tile - delta);
+		MakeWaterOrCanalDependingOnSurroundings(tile - delta, _current_player);
 	}
 	return CommandCost(_price.clear_water * 2);
 }
 	int y;
 	int sx, sy;
 	if (p1 >= MapSize()) return CMD_ERROR;
 	/* Outside of the editor you can only build canals, not oceans */
-	if (HASBIT(p2, 0) && _game_mode != GM_EDITOR) return CMD_ERROR;
+	if (HasBit(p2, 0) && _game_mode != GM_EDITOR) return CMD_ERROR;
 	x = TileX(tile);
 	y = TileY(tile);
 	sx = TileX(p1);
 	sy = TileY(p1);
 		if (GetTileSlope(tile, NULL) != SLOPE_FLAT) {
 			return_cmd_error(STR_0007_FLAT_LAND_REQUIRED);
 		}
 		/* can't make water of water! */
-		if (IsTileType(tile, MP_WATER) && (!IsTileOwner(tile, OWNER_WATER) || HASBIT(p2, 0))) continue;
+		if (IsTileType(tile, MP_WATER) && (!IsTileOwner(tile, OWNER_WATER) || HasBit(p2, 0))) continue;
 		ret = DoCommand(tile, 0, 0, flags, CMD_LANDSCAPE_CLEAR);
 		if (CmdFailed(ret)) return ret;
 		cost.AddCost(ret);
 		if (flags & DC_EXEC) {
-			if (TileHeight(tile) == 0 && HASBIT(p2, 0)) {
+			if (TileHeight(tile) == 0 && HasBit(p2, 0)) {
 				MakeWater(tile);
 			} else {
 				MakeCanal(tile, _current_player);
 			}
 			MarkTileDirtyByTile(tile);
 	switch (GetWaterTileType(tile)) {
 		case WATER_TILE_CLEAR:
 			if (flags & DC_NO_WATER) return_cmd_error(STR_3807_CAN_T_BUILD_ON_WATER);
 			/* Make sure it's not an edge tile. */
-			if (!IS_INT_INSIDE(TileX(tile), 1, MapMaxX() - 1) ||
+			if (!IsInsideMM(TileX(tile), 1, MapMaxX() - 1) ||
-					!IS_INT_INSIDE(TileY(tile), 1, MapMaxY() - 1)) {
+					!IsInsideMM(TileY(tile), 1, MapMaxY() - 1)) {
 				return_cmd_error(STR_0002_TOO_CLOSE_TO_EDGE_OF_MAP);
 			}
 			/* Make sure no vehicle is on the tile */
-			if (!EnsureNoVehicle(tile)) return CMD_ERROR;
+			if (!EnsureNoVehicleOnGround(tile)) return CMD_ERROR;
 			if (GetTileOwner(tile) != OWNER_WATER && GetTileOwner(tile) != OWNER_NONE && !CheckTileOwnership(tile)) return CMD_ERROR;
 			if (flags & DC_EXEC) DoClearSquare(tile);
 			return CommandCost(_price.clear_water);
 		case WATER_TILE_COAST: {
 			Slope slope = GetTileSlope(tile, NULL);
 			/* Make sure no vehicle is on the tile */
-			if (!EnsureNoVehicle(tile)) return CMD_ERROR;
+			if (!EnsureNoVehicleOnGround(tile)) return CMD_ERROR;
 			if (flags & DC_EXEC) DoClearSquare(tile);
 			if (slope == SLOPE_N || slope == SLOPE_E || slope == SLOPE_S || slope == SLOPE_W) {
 				return CommandCost(_price.clear_water);
 			} else {
-				return CommandCost(_price.purchase_land);
+				return CommandCost(_price.clear_roughland);
 			}
 		}
 		case WATER_TILE_LOCK: {
 			static const TileIndexDiffC _shiplift_tomiddle_offs[] = {
 {
 	uint wa;
 	/* Test for custom graphics, else use the default */
 	SpriteID dikes_base = GetCanalSprite(CF_DIKES, tile);
-	if (dikes_base == 0) dikes_base = SPR_CANALS_BASE + 57;
+	if (dikes_base == 0) dikes_base = SPR_CANAL_DIKES_BASE;
 	/* determine the edges around with water. */
 	wa  = IsWateredTile(TILE_ADDXY(tile, -1,  0)) << 0;
 	wa += IsWateredTile(TILE_ADDXY(tile,  0,  1)) << 1;
 	wa += IsWateredTile(TILE_ADDXY(tile,  1,  0)) << 2;
 	SpriteID image;
 	SpriteID water_base = GetCanalSprite(CF_WATERSLOPE, ti->tile);
 	SpriteID locks_base = GetCanalSprite(CF_LOCKS, ti->tile);
 	/* If no custom graphics, use defaults */
-	if (water_base == 0) water_base = SPR_CANALS_BASE + 5;
+	if (water_base == 0) water_base = SPR_CANALS_BASE;
 	if (locks_base == 0) {
-		locks_base = SPR_CANALS_BASE + 9;
+		locks_base = SPR_SHIPLIFT_BASE;
 	} else {
 		/* If using custom graphics, ignore the variation on height */
 		base = 0;
 	}
 	for (; wdts->delta_x != 0x80; wdts++) {
 		AddSortableSpriteToDraw(wdts->image + base + ((wdts->image < 24) ? locks_base : 0), palette,
 			ti->x + wdts->delta_x, ti->y + wdts->delta_y,
 			wdts->width, wdts->height,
 			wdts->unk, ti->z + wdts->delta_z,
-			HASBIT(_transparent_opt, TO_BUILDINGS));
+			IsTransparencySet(TO_BUILDINGS));
 	}
 }
 static void DrawTile_Water(TileInfo *ti)
 {
 	switch (GetWaterTileType(ti->tile)) {
 		case WATER_TILE_CLEAR:
 			DrawGroundSprite(SPR_FLAT_WATER_TILE, PAL_NONE);
-			if (ti->z != 0 || !IsTileOwner(ti->tile, OWNER_WATER)) DrawCanalWater(ti->tile);
+			if (IsCanal(ti->tile)) DrawCanalWater(ti->tile);
 			DrawBridgeMiddle(ti);
 			break;
 		case WATER_TILE_COAST:
 			assert(!IsSteepSlope(ti->tileh));
-			if (_coast_base != 0) {
+			if (_loaded_newgrf_features.has_newwater) {
 				DrawGroundSprite(_coast_base + ti->tileh, PAL_NONE);
 			} else {
 				DrawGroundSprite(_water_shore_sprites[ti->tileh], PAL_NONE);
 			}
 			DrawBridgeMiddle(ti);
 static void GetTileDesc_Water(TileIndex tile, TileDesc *td)
 {
 	switch (GetWaterTileType(tile)) {
 		case WATER_TILE_CLEAR:
-			if (TilePixelHeight(tile) == 0 || IsTileOwner(tile, OWNER_WATER)) {
+			if (!IsCanal(tile)) {
 				td->str = STR_3804_WATER;
 			} else {
 				td->str = STR_LANDINFO_CANAL;
 			}
 			break;
 static void AnimateTile_Water(TileIndex tile)
 {
 	/* not used */
 }
+/**
+* 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;
 	/* Ensure sea-level FSMports do not flood */
-	if ((IsTileType(target, MP_STATION)))
+	if (IsTileType(target, MP_STATION) && GetStationByTile(target)->FSMport_flood_protected) return;
-	{
-		if (GetStationByTile(target)->FSMport_flood_protected) 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;
 	}
+	/* 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: {
-				TrackBits tracks;
-				Slope slope;
 				if (!IsPlainRailTile(target)) break;
-				tracks = GetTrackBits(target);
+				FloodHalftile(target);
-				slope = GetTileSlope(target, NULL);
-				if (!(
-							(slope == SLOPE_W && tracks == TRACK_BIT_RIGHT) ||
-							(slope == SLOPE_S && tracks == TRACK_BIT_UPPER) ||
-							(slope == SLOPE_E && tracks == TRACK_BIT_LEFT)  ||
-							(slope == SLOPE_N && tracks == TRACK_BIT_LOWER)
-						)) {
-					break;
-				}
 				Vehicle *v = FindFloodableVehicleOnTile(target);
 				if (v != NULL) FloodVehicle(v);
-			}
-			/* FALLTHROUGH */
+				break;
+			}
 			case MP_CLEAR:
 			case MP_TREES:
 				_current_player = OWNER_WATER;
 				if (CmdSucceeded(DoCommand(target, 0, 0, DC_EXEC, CMD_LANDSCAPE_CLEAR))) {
 			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))) {
 			MakeWater(target);
 			MarkTileDirtyByTile(target);
 		}
 	}
 		CreateEffectVehicleRel(v, 4, 4, 8, EV_EXPLOSION_LARGE);
 		SndPlayVehicleFx(SND_12_EXPLOSION, v);
 	}
 }
-/** called from tunnelbridge_cmd, and by TileLoop_Industry() */
+/**
+* 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] = {
 		// tile to mod              shore?    shore?
 		{{-1,  0}, {0, 0}, {0, 1}, {-1,  0}, {-1,  1}},
 		{{ 0,  1}, {0, 1}, {1, 1}, { 0,  2}, { 1,  2}},
 		{{ 1,  0}, {1, 0}, {1, 1}, { 2,  0}, { 2,  1}},
 		{{ 0, -1}, {0, 0}, {1, 0}, { 0, -1}, { 1, -1}}
 	};
-	/* Ensure sea-level canals and buoys on canal borders do not flood */
+	/* Ensure buoys on canal borders do not flood */
-	if ((IsTileType(tile, MP_WATER) || IsBuoyTile(tile)) && !IsTileOwner(tile, OWNER_WATER)) return;
+	if (IsCanalBuoyTile(tile)) return;
+	/* Ensure only sea and coast floods, not canals or rivers */
-	if (IS_INT_INSIDE(TileX(tile), 1, MapSizeX() - 3 + 1) &&
+	if (IsTileType(tile, MP_WATER) && !(IsSea(tile) || IsCoast(tile))) return;
-			IS_INT_INSIDE(TileY(tile), 1, MapSizeY() - 3 + 1)) {
+	/* floods in all four diagonal directions with the exception of the edges */
+	if (IsInsideMM(TileX(tile), 1, MapSizeX() - 3 + 1) &&
+			IsInsideMM(TileY(tile), 1, MapSizeY() - 3 + 1)) {
 		uint i;
 		for (i = 0; i != lengthof(_tile_loop_offs_array); i++) {
 			TileLoopWaterHelper(tile, _tile_loop_offs_array[i]);
 		}
 	}
 	/* _current_player can be changed by TileLoopWaterHelper.. reset it back here */
 	_current_player = OWNER_NONE;
 	/* edges */
-	if (TileX(tile) == 0 && IS_INT_INSIDE(TileY(tile), 1, MapSizeY() - 3 + 1)) { //NE
+	if (TileX(tile) == 0 && IsInsideMM(TileY(tile), 1, MapSizeY() - 3 + 1)) { //NE
 		TileLoopWaterHelper(tile, _tile_loop_offs_array[2]);
 	}
-	if (TileX(tile) == MapSizeX() - 2 && IS_INT_INSIDE(TileY(tile), 1, MapSizeY() - 3 + 1)) { //SW
+	if (TileX(tile) == MapSizeX() - 2 && IsInsideMM(TileY(tile), 1, MapSizeY() - 3 + 1)) { //SW
 		TileLoopWaterHelper(tile, _tile_loop_offs_array[0]);
 	}
-	if (TileY(tile) == 0 && IS_INT_INSIDE(TileX(tile), 1, MapSizeX() - 3 + 1)) { //NW
+	if (TileY(tile) == 0 && IsInsideMM(TileX(tile), 1, MapSizeX() - 3 + 1)) { //NW
 		TileLoopWaterHelper(tile, _tile_loop_offs_array[1]);
 	}
-	if (TileY(tile) == MapSizeY() - 2 && IS_INT_INSIDE(TileX(tile), 1, MapSizeX() - 3 + 1)) { //SE
+	if (TileY(tile) == MapSizeY() - 2 && IsInsideMM(TileX(tile), 1, MapSizeX() - 3 + 1)) { //SE
 		TileLoopWaterHelper(tile, _tile_loop_offs_array[3]);
 	}
 }
 static uint32 GetTileTrackStatus_Water(TileIndex tile, TransportType mode, uint sub_mode)
 }
 static CommandCost TerraformTile_Water(TileIndex tile, uint32 flags, uint z_new, Slope tileh_new)
 {
 	/* Canals can't be terraformed */
-	if (IsClearWaterTile(tile) && IsCanal(tile)) return_cmd_error(STR_MUST_DEMOLISH_CANAL_FIRST);
+	if (IsWaterTile(tile) && IsCanal(tile)) return_cmd_error(STR_MUST_DEMOLISH_CANAL_FIRST);
 	return DoCommand(tile, 0, 0, flags, CMD_LANDSCAPE_CLEAR);
 }

branch	NewGRF_ports
changeset 6871	5a9dc001e1ad
parent 6870	ca3fd1fbe311
child 6872	1c4a4a609f85