check_note_item(item);

static void prepare_shoals();

static void prepare_shoals( int level_number );

static bool build_minivaults(int level_number, int force_vault);

static bool build_minivaults(int level_number, int force_vault,
                             coord_def where = coord_def() );

static int dgn_random_map_for_place(bool wantmini);

    {
        prepare_shoals();
        place_special_minivaults(level_number, level_type);
    }

        prepare_shoals( level_number );

static void prepare_shoals()

static void prepare_shoals(int level_number)

        grd[centres[0].x+2][centres[0].y] = DNGN_STONE_STAIRS_UP_III;

        grd[centres[0].x-1][centres[0].y] = DNGN_STONE_STAIRS_UP_III;
        
        // Place the rune
        int vaultidx;
        do {
            vaultidx = dgn_random_map_for_place(true);
        } while ( vaultidx == -1 ||
                  !map_by_index(vaultidx)->has_tag("has_rune") );

        // Minivault creation will place the rune (96.4% of the time)

        build_minivaults( level_number, vaultidx,
                          centres[1] - coord_def(3,3) );
        for ( int i = 2; i < num_islands; ++i )
        {
            // Place (non-rune) minivaults on the other islands
            do {
                vaultidx = dgn_random_map_for_place(true);
            } while ( vaultidx == -1 ||
                      map_by_index(vaultidx)->has_tag("has_rune") );
            build_minivaults( level_number, vaultidx,
                              centres[i] - coord_def(3,3) );
        }

    // FIXME hand-hackery for placing minivaults at the bottom of the Shoals.
    if ( (level_id::current().branch == BRANCH_SHOALS) &&
         (level_id::current().depth = branches[BRANCH_SHOALS].depth) )
    {
        int tries = 40;
        int num_to_place = random2(3) + 4;
        for ( int i = 0; i < num_to_place && tries > 0; ++i, --tries )
        {
            const int vault = dgn_random_map_for_place(true);
            if (vault == -1)
            {
                --i;
                continue;
            }
            
            // If we've already used this minivault and it doesn't
            // want duplicates, do another iteration.
            if (used.find(vault) != used.end()
                && !map_by_index(vault)->has_tag("allow_dup"))
            {
                --i;
                continue;
            }
            build_minivaults(level_number, vault);
            used.insert(vault);
        }
    }

static bool build_minivaults(int level_number, int force_vault)

static bool build_minivaults(int level_number, int force_vault,
                             coord_def where)

    int vx, vy;

    if (!find_minivault_place(place, v1x, v1y))

    if ( where.x > 0 && where.y > 0 )
    {
        v1x = where.x;
        v1y = where.y;
    }
    else if (!find_minivault_place(place, v1x, v1y))

    for (vx = v1x; vx < v1x + place.width; vx++)

    for (int vx = v1x; vx < v1x + place.width; vx++)

        for (vy = v1y; vy < v1y + place.height; vy++)

        for (int vy = v1y; vy < v1y + place.height; vy++)

CHANCE: 0

CHANCE: 0

CHANCE: 0

CHANCE: 0

TAGS: water_ok has_rune
MONS: cyclops
CHANCE: 1000

TAGS: has_rune
SHUFFLE: ABCD
SUBST: A:x, B:x, C:x=, D=+

 x+x 
xx1xx
=1O1x
xx1xx
 xxx 

.xxCxx.
xx...xx
x.....x
B..O..D
x.....x
xx...xx
.xxAxx

TAGS: water_ok allow_dup
MONS: cyclops
CHANCE: 1000

TAGS: allow_dup
SHUFFLE: ABCD
SUBST: A:x, B:x, C:x=, D=+

 x+x 
xx.xx
=.*1x
xx1xx
 xxx 

.xxCxx.
xx...xx
x.....x
B..|..D
x.....x
xx...xx
.xxAxx