local str = mon[1]
        for i = 2, table.getn(mon) do
            str = str .. " / " .. mon[i]
        end
        mon = str

        mon = util.join(" / ", mon)

  -- Any given ziggurat will use the same builder for all its levels.
  z.builder = ziggurat_choose_builder()

  -- Any given ziggurat will use the same builder for all its levels,
  -- and the same colours for outer walls. Before choosing the builder,
  -- we specify a global excentricity. If zig_exc=0, then the ellipses
  -- will be circles etc. It is not the actual excentricity but some
  -- value between 0 and 100. For deformed ellipses and rectangles, make
  -- sure that the map is wider than it is high for the sake of ASCII.

  z.zig_exc = crawl.random2(101)
  z.builder = ziggurat_choose_builder()

-- the estimated total map area for ziggurat maps of given depth
-- this is be independent of the layout type

  local base_area = 5 + 2 * zig_depth()

  local base_area = 5 + 3 * zig_depth()

  -- exc is the excentrity for the two rectangle, it grows with depth as
  -- 0, 0-1, 1, 1-2, 2, ...
    local exc = math.floor((zig().depth-1) / 2)
    if ((zig().depth-1) % 2) ~= 0 and crawl.coinflip() then

    -- exc is the local eccentricity for the two rectangles
    -- exc grows with depth as 0-1, 1, 1-2, 2, 2-3 ...
    local exc = math.floor(zig().depth / 2)
    if ((zig().depth-1) % 2) == 0 and crawl.coinflip() then

  local b = math.floor(math.sqrt(area+12*exc*exc)) - 4*exc
  if b <= 0 then
      b = 1
  end
  local a = math.floor((area + b - 1) / b)

  local b = math.floor(math.sqrt(area+4*exc*exc))
  local a = b-2*exc

  end
end
local function ziggurat_stairs(entry, exit)
  zigstair(entry.x, entry.y, "stone_arch", "stone_stairs_up_i")
  if zig().depth < ZIGGURAT_MAX then
    zigstair(exit.x, exit.y, "stone_stairs_down_i", zig_go_deeper)
  end
  zigstair(exit.x, exit.y + 1, "exit_portal_vault", cleanup_ziggurat())
  zigstair(exit.x, exit.y - 1, "exit_portal_vault", cleanup_ziggurat())
end
local function ziggurat_furnish(centre, entry, exit)
  local monster_generation = choose_monster_set()
  -- If we're going to spawn jellies, do our loot protection thing.
  if monster_generation.jelly_protect then
    zig().level.jelly_protect = true
  end
  ziggurat_create_loot(entry, exit)
  if not zig().level.loot_chamber then
    -- Place pillars if we did not create a loot chamber.
    ziggurat_place_pillars(centre)
  end
  ziggurat_create_monsters(exit, monster_generation.fn)
  local function needs_colour(p)
    return not dgn.in_vault(p.x, p.y)
      and dgn.grid(p.x, p.y) == dgn.fnum("stone_wall")

  dgn.colour_map(needs_colour, zig().colour)

-- builds ziggurat maps consisting of two overimposed rectangles

  zigstair(entry.x, entry.y, "stone_arch", "stone_stairs_up_i")

  ziggurat_stairs(entry, exit)
  ziggurat_furnish(c, entry, exit)
end

  if zig().depth < ZIGGURAT_MAX then
    zigstair(exit.x, exit.y, "stone_stairs_down_i", zig_go_deeper)
  end

-- builds elliptic ziggurat maps
-- given the area, half axes a and b are determined by:
-- pi*a*b=area,
-- a=b for zig_exc=0,
-- a=b*3/2 for zig_exc=100
local function ziggurat_ellipse_builder(e)
  local grid = dgn.grid

  zigstair(exit.x, exit.y + 1, "exit_portal_vault", cleanup_ziggurat())
  zigstair(exit.x, exit.y - 1, "exit_portal_vault", cleanup_ziggurat())

  dgn.fill_area(0, 0, dgn.GXM - 1, dgn.GYM - 1, "stone_wall")

  local monster_generation = choose_monster_set()

  local zig_exc = zig().zig_exc

  -- If we're going to spawn jellies, do our loot protection thing.
  if monster_generation.jelly_protect then
    zig().level.jelly_protect = true
  end

  local area = map_area()
  local b = math.floor(math.sqrt(200*area/(200+zig_exc) * 100/314))
  local a = math.floor(b * (200+zig_exc) / 200)
  local cx, cy = dgn.GXM / 2, dgn.GYM / 2

  ziggurat_create_loot(entry, exit)

  local floor = dgn.fnum("floor")

  if not zig().level.loot_chamber then
    -- Place pillars if we did not create a loot chamber.
    ziggurat_place_pillars(c)

  for x=0, dgn.GXM-1 do
    for y=0, dgn.GYM-1 do
      if b*b*(cx-x)*(cx-x) + a*a*(cy-y)*(cy-y) <= a*a*b*b then
        dgn.grid(x, y, floor)
      end
    end

  ziggurat_create_monsters(exit, monster_generation.fn)

  local entry = dgn.point(cx-a+2, cy)
  local exit  = dgn.point(cx+a-2, cy)

  local function needs_colour(p)
    return not dgn.in_vault(p.x, p.y)
      and dgn.grid(p.x, p.y) == dgn.fnum("stone_wall")

  if zig_depth() % 2 == 0 then
    entry, exit = exit, entry

  dgn.colour_map(needs_colour, zig().colour)

  ziggurat_stairs(entry, exit)
  ziggurat_furnish(dgn.point(cx, cy), entry, exit)

  rectangle = ziggurat_rectangle_builder

  rectangle = ziggurat_rectangle_builder,
  ellipse = ziggurat_ellipse_builder

local ziggurat_builders = { }
for key, val in pairs(ziggurat_builder_map) do
  table.insert(ziggurat_builders, key)
end

local ziggurat_builders = util.keys(ziggurat_builder_map)

end

end

end
-- Returns a list of the keys in the given map.
function util.keys(map)
  local keys = { }
  for key, _ in pairs(ziggurat_builder_map) do
    table.insert(keys, key)
  end
  return keys
end
-- Returns a list of the values in the given map.
function util.values(map)
  local values = { }
  for _, value in pairs(ziggurat_builder_map) do
    table.insert(values, value)
  end
  return values

-- Creates a string of the elements in list joined by separator.
function util.join(sep, list)
  local res = ""
  for i, val in ipairs(list) do
    if i > 1 then
      res = res .. sep
    end
    res = res .. val
  end
  return res
end