// Do not move diagonally along the path.

    // If false, do not move diagonally along the path.

//
// FIXME: There needs to be some sort of "dead-end" check similar to floor
//        grids, but the other way around: turning a wall into floor can
//        turn perfectly fine corridors into too short wonky-looking
//        dead-ends.

// Example: If a wall is built at X (A), two deadends are created, a short and
//          a long one. The latter is perfectly fine, but the former looks
//          a bit odd. If Y is chosen, this looks much better (B).

// Example: If a wall is built at X (A), two dead-ends are created, a short
//          and a long one. The latter is perfectly fine, but the former
//          looks a bit odd. If Y is chosen, this looks much better (B).

// Changes a small portion of a labyrinth by exchanging wall against floor
// grids in such a way that connectivity remains guaranteed.

    int size = random_range(12, 24);
    coord_def c1, c2;

    int size = random_range(12, 24); // size of the shifted area (square)
    coord_def c1, c2; // upper left, lower right corners of the shifted area

    // Try 10 times for an area that is little mapped.

    // Fill a vector with wall grids that are potential targets for swapping
    // against floor, i.e. are flanked by walls to two cardinal directions,
    // and by floor on the two remaining sides.

    int max_targets = random_range(std::min((int) targets.size(), 12),
                                   std::min((int) targets.size(), 45));

    // How many switches we'll be doing.
    const int max_targets = random_range(std::min((int) targets.size(), 12),
                                         std::min((int) targets.size(), 45));

    // Shuffle the targets, then pick the max_targets first ones.

    std::vector<coord_def> dirs;
    dirs.push_back(coord_def(-1,-1));
    dirs.push_back(coord_def( 0,-1));
    dirs.push_back(coord_def( 1,-1));
    dirs.push_back(coord_def(-1, 0));
//    dirs.push_back(coord_def( 0, 0));
    dirs.push_back(coord_def( 1, 0));
    dirs.push_back(coord_def(-1, 1));
    dirs.push_back(coord_def( 0, 1));
    dirs.push_back(coord_def( 1, 1));

    // For each of the chosen wall grids, calculate the path connecting the
    // two floor grids to either side, and block off one floor grid on this
    // path to close the circle opened by turning the wall into floor.

        // Use the adjacent floor grids as source and destination.

                MSGCH_DIAGNOSTICS);

                    MSGCH_DIAGNOSTICS);

        // Get the actual path.

        std::vector<coord_def> points;

        // Replace the wall with floor, but preserve the old grid for later
        // change of the floor grid, or in case this fails.
        // It's better if the change is done now, so the grid can be
        // treated as floor rather than a wall, and we don't need any
        // special cases.

        // Add all floor grids meeting a couple of conditions to a vector
        // of potential switch points.
        std::vector<coord_def> points;

            // Take back the previous change.

        // Randomly pick one floor grid from the vector and replace it
        // with the original wall type.
        // FIXME: This is not optimal since it may lead to e.g. a single
        //        metal wall appearing among stone ones.

    // The directions are used to randomly decide where to place items that
    // have ended up in walls during the switching.
    std::vector<coord_def> dirs;
    dirs.push_back(coord_def(-1,-1));
    dirs.push_back(coord_def( 0,-1));
    dirs.push_back(coord_def( 1,-1));
    dirs.push_back(coord_def(-1, 0));
//    dirs.push_back(coord_def( 0, 0));
    dirs.push_back(coord_def( 1, 0));
    dirs.push_back(coord_def(-1, 1));
    dirs.push_back(coord_def( 0, 1));
    dirs.push_back(coord_def( 1, 1));

    // Search the entire shifted area for stacks of items now stuck in walls
    // and move them to a random adjacent non-wall grid.

            // Search the eight possible directions in random order.

                if (grd(p) == DNGN_FLOOR)

                if (!grid_is_solid(grd(p)) && !grid_destroys_items(grd(p)))

                    // Once a valid grid is found, move all items from the
                    // stack onto it.

                    // Link to the stack on the target grid p, or
                    // NON_ITEM if empty.

                    if (msg)
                    {
                        mprf(MSGCH_DIAGNOSTICS, "Moved items over to (%d, %d)",
                             p.x, p.y);
                    }
                    break;

#ifdef DEBUG_CHANGE
                if (msg)
                {
                    mprf(MSGCH_DIAGNOSTICS, "Moved items over to (%d, %d)",
                         p.x, p.y);
                }
#endif
                break;

    // Just to be on the safe side.

    // Recheck item coordinates, to make totally sure.

                                          : random2(4));

                                           : random2(4));