static char _plan_3();

static char _plan_3(int level_number);

                 (force_plan == 3) ? _plan_3() :

                 (force_plan == 3) ? _plan_3(level_number) :

                                                       : _plan_3()) :

                                                       : _plan_3(level_number)) :

                                   : _plan_3());

                                   : _plan_3(level_number));

static char _plan_3()

static char _plan_3(int level_number)

    // Draws a room, then another and links them together, then another and etc.
    // Of course, this can easily end up looking just like a make_trail level.
    int i;
    int roomsss = 30 + random2(90);
    bool exclusive = (one_chance_in(10) ? false : true);
    bool exclusive2 = coinflip();
    char romx1[30], romy1[30], romx2[30], romy2[30];
    int which_room = 0;
    for (i = 0; i < roomsss; i++)
    {
        romx1[which_room] = 10 + random2(50);
        romy1[which_room] = 10 + random2(40);
        romx2[which_room] = romx1[which_room] + 2 + random2(8);
        romy2[which_room] = romy1[which_room] + 2 + random2(8);

        if (exclusive && count_antifeature_in_box(romx1[which_room] - 1,
                                                  romy1[which_room] - 1,
                                                  romx2[which_room] + 1,
                                                  romy2[which_room] + 1,
                                                  DNGN_ROCK_WALL))
        {
            continue;
        }

    const map_def *vault = find_map_by_name("layout_rooms");
    ASSERT(vault);

        _replace_area(romx1[which_room], romy1[which_room], romx2[which_room],
                      romy2[which_room], DNGN_ROCK_WALL, DNGN_FLOOR);

    bool success = _build_vaults(level_number, vault);
    _ensure_vault_placed(success, false);

        if (which_room > 0 && !exclusive2)
        {
            const int rx1 = romx1[which_room];
            const int rx2 = romx2[which_room];
            const int prev_rx1 = romx1[which_room - 1];
            const int prev_rx2 = romx2[which_room - 1];
            const int ry1 = romy1[which_room];
            const int ry2 = romy2[which_room];
            const int prev_ry1 = romy1[which_room - 1];
            const int prev_ry2 = romy2[which_room - 1];
            join_the_dots( coord_def(rx1 + random2( rx2 - rx1 ),
                                     ry1 + random2( ry2 - ry1 )),
                            coord_def(prev_rx1 + random2(prev_rx2 - prev_rx1),
                                      prev_ry1 + random2(prev_ry2 - prev_ry1)),
                            MMT_VAULT );
        }
        which_room++;
        if (which_room >= 29)
            break;
    }
    if (exclusive2)
    {
        for (i = 0; i < which_room; i++)
        {
            if (i > 0)
            {
                const int rx1 = romx1[i];
                const int rx2 = romx2[i];
                const int prev_rx1 = romx1[i - 1];
                const int prev_rx2 = romx2[i - 1];
                const int ry1 = romy1[i];
                const int ry2 = romy2[i];
                const int prev_ry1 = romy1[i - 1];
                const int prev_ry2 = romy2[i - 1];
                join_the_dots( coord_def( rx1 + random2( rx2 - rx1 ),
                                          ry1 + random2( ry2 - ry1 ) ),
                                coord_def(
                                    prev_rx1 + random2( prev_rx2 - prev_rx1 ),
                                    prev_ry1 + random2( prev_ry2 - prev_ry1 ) ),
                                MMT_VAULT );
            }
        }
    }

{{
    function dgn.random_room_point(room)
      return dgn.point(room.x1 + crawl.random2(room.x2 - room.x1),
                       room.y1 + crawl.random2(room.y2 - room.y1))
    end
    function dgn.join_the_dots_p(start, finish)
      return dgn.join_the_dots(start.x, start.y, finish.x, finish.y)
    end
}}

##############################################################
# layout_rooms
#
# This replaces dungeon.cc:_plan_3().
#
NAME: layout_rooms
ORIENT: encompass
TAGS: layout allow_dup
{{
    local wall = dgn.feature_number("rock_wall")
    local floor = dgn.feature_number("floor")
    local num_rooms = 30 + crawl.random2(90)
    local exclusive = not crawl.one_chance_in(10)
    local exclusive2 = crawl.coinflip()
    local rooms = {}
    for i = 0, num_rooms do
      local new_room = {
        x1 = 10 + crawl.random2(50),
        y1 = 10 + crawl.random2(40)
      }
      new_room.x2 = new_room.x1 + 2 + crawl.random2(8)
      new_room.y2 = new_room.y1 + 2 + crawl.random2(8)
      local not_walls = dgn.count_antifeature_in_box(new_room.x1 - 1,
                    new_room.y1 - 1, new_room.x2 + 1, new_room.y2 + 1, wall)
      if (not exclusive or not_walls == 0) then
        dgn.replace_area(new_room.x1, new_room.y1, new_room.x2,
                         new_room.y2, wall, floor);
        if #rooms > 0 and not exclusive2 then
          dgn.join_the_dots_p(dgn.random_room_point(new_room),
                              dgn.random_room_point(rooms[#rooms]))
        end
        table.insert(rooms, new_room)
        if #rooms >= 30 then
          break
        end
      end
    end
    if exclusive2 then
      for i = 2, #rooms do
        dgn.join_the_dots_p(dgn.random_room_point(rooms[i]),
                            dgn.random_room_point(rooms[i - 1]))
      end
    end
}}
MAP
ENDMAP