static bool GrowingBlocksWaterConnection(const TileIndex tile)

    if (!IsValidTile(tile) || !IsCoastTile(tile)) return false;

 

    const Slope slope = GetTileSlope(tile);

    /* Is this a coast tile with one corner raised ? */

    if (IsSlopeWithOneCornerRaised(slope)) {

        const Track main_track_mask = TrackBitsToTrack(TrackStatusToTrackBits(GetTileTrackStatus(tile, TRANSPORT_WATER, 0)));

        const Track oppo_track_mask = TrackToOppositeTrack(main_track_mask);

        const Trackdir main_trackdir = TrackToTrackdir(main_track_mask);

        const Trackdir oppo_trackdir = TrackToTrackdir(oppo_track_mask);

        const DiagDirection main_dir_1 = TrackdirToExitdir(main_trackdir);

        const DiagDirection main_dir_2 = TrackdirToExitdir(ReverseTrackdir(main_trackdir));

        const DiagDirection oppo_dir_1 = TrackdirToExitdir(oppo_trackdir);

        const DiagDirection oppo_dir_2 = TrackdirToExitdir(ReverseTrackdir(oppo_trackdir));

 

        const TrackBits main_trackbits_mask_1 = DiagdirReachesTracks(main_dir_1);

        const TrackBits main_trackbits_mask_2 = DiagdirReachesTracks(main_dir_2);

        const TrackBits oppo_trackbits_mask_1 = DiagdirReachesTracks(oppo_dir_1);

        const TrackBits oppo_trackbits_mask_2 = DiagdirReachesTracks(oppo_dir_2);

 

        const Corner corner = GetHighestSlopeCorner(slope);

        static const Direction corner_to_direction[] = { DIR_W, DIR_S, DIR_E, DIR_N };

        const TileIndex opposite_tile = AddTileIndexDiffCWrap(tile, TileIndexDiffCByDir(corner_to_direction[OppositeCorner(corner)]));

 

        if (IsValidTile(opposite_tile)) {

            const TileIndex tile_1 = AddTileIndexDiffCWrap(tile, TileIndexDiffCByDiagDir(main_dir_1));

            const TileIndex tile_2 = AddTileIndexDiffCWrap(tile, TileIndexDiffCByDiagDir(main_dir_2));

 

            const TrackBits track_1 = TrackStatusToTrackBits(GetTileTrackStatus(tile_1, TRANSPORT_WATER, 0));

            const TrackBits track_2 = TrackStatusToTrackBits(GetTileTrackStatus(tile_2, TRANSPORT_WATER, 0));

 

            const TrackBits main_track_1 = main_trackbits_mask_1 & track_1;

            const TrackBits main_track_2 = main_trackbits_mask_2 & track_2;

            const TrackBits oppo_track_1 = oppo_trackbits_mask_1 & track_1;

            const TrackBits oppo_track_2 = oppo_trackbits_mask_2 & track_2;

 

            /* Is there a connection between tile_1 and tile_2 via tile? */

            if (main_track_1 && main_track_2) {

                const TrackBits oppo_trackbits = TrackStatusToTrackBits(GetTileTrackStatus(opposite_tile, TRANSPORT_WATER, 0));

                /* Is there a track in the opposite_tile that can be used to try an alternative connection? */

                if (HasTrack(oppo_trackbits, oppo_track_mask)) {

                    const TrackBits mirror = TRACK_BIT_CROSS | (corner & 1 ? TRACK_BIT_HORZ : TRACK_BIT_VERT);

                    /* Is there a connection between tile_1 and tile_2 via opposite_tile? */

                    if (oppo_track_1 & (main_track_1 ^ mirror) && oppo_track_2 & (main_track_2 ^ mirror)) {

                        /* There is an alternative connection. Town can grow on tile. */

                        return false;

                    }

                }

                /* There is either no track or an incomplete connection via opposite_tile. */

                return true;

            }

        }

    }

    /* There was no connection via tile, or it was incomplete, or the opposite_tile is outside the map. */

    return false;