Maniacs Patch - AB Autotiling Support

Introduces IsWaterTile and IsDeepWaterTile helpers and implements specialized autotiling logic for water and deep water tiles in RecalculateAutotile. This enables more accurate coastline and deep water boundary rendering, including diagonal and cardinal neighbor checks for seamless water transitions.

Author: jetrotal

src/tilemap_layer.cpp

@@ -734,6 +734,13 @@ static inline bool IsTileFromBlock(int tile_id, int block) {
 	}
 }
 
+static bool IsWaterTile(int tile_id) {
+	return tile_id >= 0 && tile_id < 3000;
+}
+static bool IsDeepWaterTile(int tile_id) {
+	return tile_id >= 2000 && tile_id < 3000;
+}
+
 void TilemapLayer::SetMapTileDataAt(int x, int y, int tile_id, bool disable_autotile) {
 	if(!IsInMapBounds(x, y))
 		return;
@@ -847,16 +854,90 @@ void TilemapLayer::RecalculateAutotile(int x, int y, int tile_id) {
 		RecreateTileDataAt(x, y, new_tile_id);
 		};
 
-	if (IsTileFromBlock(tile_id, BLOCK_A)) {
-		processBlock(BLOCK_A, BLOCK_A_STRIDE, BLOCK_A, IsSameAutotileAB);
-	}
-	if (IsTileFromBlock(tile_id, BLOCK_B)) {
-		processBlock(BLOCK_B, BLOCK_B_STRIDE, BLOCK_B, IsSameAutotileAB);
+	if (IsWaterTile(tile_id)) {
+		int type = tile_id / 1000;
+		int base = type * 1000;
+
+		// 1. Calculate a_subtile (Coastline) - 8 neighbors
+		// Any Water connects to Any Water (0-2999) + Animated (3000-3999)
+		auto isWaterCompatible = [&](int /*curr*/, int neighbor) {
+			return IsWaterTile(neighbor) || (neighbor >= 3000 && neighbor < 4000);
+			};
+
+		uint8_t neighbors_a = calculateNeighbors(isWaterCompatible);
+		int a_subtile = AUTOTILE_D_VARIANTS_MAP.at(neighbors_a);
+
+		// 2. Calculate b_subtile (Deep Boundary) - 4 neighbors (N, E, S, W)
+		auto is_b_compatible = [&](int nid) {
+			bool n_deep = IsDeepWaterTile(nid);
+			bool n_water = IsWaterTile(nid) || (nid >= 3000 && nid < 4000);
+
+			if (type == 2) { // Deep
+				// Deep connects to Deep or Land (Non-Water). Blocks on Shallow.
+				return n_deep || !n_water;
+			}
+			else { // Shallow
+				// Shallow connects to Shallow or Land. Blocks on Deep.
+				return !n_deep;
+			}
+			};
+
+		auto check_blocked = [&](int dx, int dy) {
+			auto nx = x + dx;
+			auto ny = y + dy;
+			if (!IsInMapBounds(nx, ny)) return false; // Treat map edge as connected
+			auto adj_id = GetDataCache(nx, ny).ID;
+			return !is_b_compatible(adj_id);
+			};
+
+		bool b_n = check_blocked(0, -1);
+		bool b_e = check_blocked(1, 0);
+		bool b_s = check_blocked(0, 1);
+		bool b_w = check_blocked(-1, 0);
+
+		int b_subtile = 0;
+
+		if (type == 2) {
+			// Handle diagonal connections for Deep Water (Type 2)
+			// A corner is only cut (border added) if the cardinal neighbors are blocked
+			// AND the corresponding diagonal neighbor is NOT Deep Water.
+			// If the diagonal neighbor IS Deep Water, we maintain the connection (don't cut).
+
+			auto check_diag_deep = [&](int dx, int dy) {
+				auto nx = x + dx;
+				auto ny = y + dy;
+				if (!IsInMapBounds(nx, ny)) return false;
+				auto adj_id = GetDataCache(nx, ny).ID;
+				return IsDeepWaterTile(adj_id);
+				};
+
+			bool d_nw = check_diag_deep(-1, -1);
+			bool d_ne = check_diag_deep(1, -1);
+			bool d_sw = check_diag_deep(-1, 1);
+			bool d_se = check_diag_deep(1, 1);
+
+			if (b_n && b_w && !d_nw) b_subtile |= 1; // TL
+			if (b_n && b_e && !d_ne) b_subtile |= 2; // TR
+			if (b_s && b_w && !d_sw) b_subtile |= 4; // BL
+			if (b_s && b_e && !d_se) b_subtile |= 8; // BR
+		}
+		else {
+			// Shallow Water (Type 0 & 1) - Standard corner logic
+			if (b_n && b_w) b_subtile |= 1; // TL
+			if (b_n && b_e) b_subtile |= 2; // TR
+			if (b_s && b_w) b_subtile |= 4; // BL
+			if (b_s && b_e) b_subtile |= 8; // BR
+		}
+
+		int new_tile_id = base + (b_subtile * 50) + a_subtile;
+		RecreateTileDataAt(x, y, new_tile_id);
 	}
+
 	if (IsTileFromBlock(tile_id, BLOCK_D)) {
 		processBlock(BLOCK_D, BLOCK_D_STRIDE, BLOCK_D, IsSameAutotileD);
 	}
 }
+
 void TilemapLayer::SetPassable(std::vector<unsigned char> npassable) {
 	passable = std::move(npassable);