else if (player_can_hear(this->pos))

        else if (player_can_hear(this->pos) && see_grid(this->pos))

static bool _is_floor(const dungeon_feature_type feat)
{
    return (!grid_is_solid(feat) && !grid_destroys_items(feat));
}

               && grd(adjs[2]) == DNGN_FLOOR && grd(adjs[3]) == DNGN_FLOOR
            || grd(adjs[0]) == DNGN_FLOOR && grd(adjs[1]) == DNGN_FLOOR

               && _is_floor(grd(adjs[2])) && _is_floor(grd(adjs[3]))
            || _is_floor(grd(adjs[0])) && _is_floor(grd(adjs[1]))

static bool _deadend_check(const coord_def &p)

static bool _deadend_check_wall(const coord_def &p)

            coord_def a(p.x-1, p.y+i);
            coord_def b(p.x+1, p.y+i);
            coord_def c(p.x-1, p.y+2*i);
            coord_def d(p.x+1, p.y+2*i);

            const coord_def a(p.x-1, p.y+i);
            const coord_def b(p.x+1, p.y+i);
            const coord_def c(p.x-1, p.y+2*i);
            const coord_def d(p.x+1, p.y+2*i);

            coord_def a(p.x+i  , p.y-1);
            coord_def b(p.x+i  , p.y+1);
            coord_def c(p.x+2*i, p.y-1);
            coord_def d(p.x+2*i, p.y+1);

            const coord_def a(p.x+i  , p.y-1);
            const coord_def b(p.x+i  , p.y+1);
            const coord_def c(p.x+2*i, p.y-1);
            const coord_def d(p.x+2*i, p.y+1);

// Similar to the above, checks whether turning a wall grid into floor
// would create a short "dead-end" of only 1 grid.
//
// In the example below, X would create dead-ends at positions a and b,
// but both Y and Z avoid this, and the resulting mini-mazes looks better.
//
// ########   (A)  ########     (B)  ########     (C)  ########
// #.....#.        #....a#.          #.....#.          #.....#.
// #.#YXZ#.        #.##.##.          #.#.###.          #.###.#.
// #.#.....        #.#b....          #.#.....          #.#.....
//
// In general, if a floor grid horizontally or vertically adjacent to the
// change target has a floor neighbour diagonally adjacent to the change
// target, the next neighbour in the same direction needs to be floor,
// as well.
static bool _deadend_check_floor(const coord_def &p)
{
    if (grid_is_wall(grd[p.x-1][p.y]))
    {
        for (int i = -1; i <= 1; i++)
        {
            if (i == 0)
                continue;
            const coord_def a(p.x, p.y+2*i);
            if (!in_bounds(a) || _is_floor(grd(a)))
                continue;
            for (int j = -1; j <= 1; j++)
            {
                if (j == 0)
                    continue;
                const coord_def b(p.x+2*j, p.y+i);
                if (!in_bounds(b))
                    continue;
                const coord_def c(p.x+j, p.y+i);
                if (_is_floor(grd(c)) && !_is_floor(grd(b)))
                    return (false);
            }
        }
    }
    else
    {
        for (int i = -1; i <= 1; i++)
        {
            if (i == 0)
                continue;
            const coord_def a(p.x+2*i, p.y);
            if (!in_bounds(a) || _is_floor(grd(a)))
                continue;
            for (int j = -1; j <= 1; j++)
            {
                if (j == 0)
                    continue;
                const coord_def b(p.x+i, p.y+2*j);
                if (!in_bounds(b))
                    continue;
                const coord_def c(p.x+i, p.y+j);
                if (_is_floor(grd(c)) && !_is_floor(grd(b)))
                    return (false);
            }
        }
    }
    return (true);
}

            if (_grid_is_flanked_by_walls(c))

            if (_grid_is_flanked_by_walls(c) && _deadend_check_floor(c))

        if (grd(src) != DNGN_FLOOR || grd(dst) != DNGN_FLOOR)

        if (!_is_floor(grd(src)) || !_is_floor(grd(dst)))

        // Replace the wall with floor, but preserve the old grid for later
        // change of the floor grid, or in case this fails.

        // Replace the wall with floor, but preserve the old grid in case
        // we find no floor grid to swap with.

            if (_grid_is_flanked_by_walls(p) && _deadend_check(p))

            if (_grid_is_flanked_by_walls(p) && _deadend_check_wall(p))

        const coord_def p(points[pick]);

                 (int) grd(c), c.x, c.y,
                 (int) grd(points[pick]), points[pick].x, points[pick].y);

                 (int) old_grid, c.x, c.y, (int) grd(p), p.x, p.y);
        }
        // Rather than use old_grid directly, replace with the adjacent
        // wall type.
        old_grid = grd[p.x-1][p.y];
        if (!grid_is_wall(old_grid))
        {
            old_grid = grd[p.x][p.y-1];
            if (!grid_is_wall(old_grid))
            {
                if (msg)
                {
                    mprf(MSGCH_DIAGNOSTICS,
                         "No adjacent walls at pos (%d, %d)?", p.x, p.y);
                }
                old_grid = DNGN_STONE_WALL;
            }

        grd(points[pick]) = old_grid;

        grd(p) = old_grid;