local base_area = 5 + 3 * zig_depth()
  return 4 * base_area + crawl.random2(base_area)

  return 30 + 18*zig_depth() + 2*zig_depth()*zig_depth()

local function rectangle_dimensions()
  local area = map_area()
  local cx, cy = dgn.GXM / 2, dgn.GYM / 2
  local function rectangle_eccentricity()
    -- 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
      exc = exc + 1
    end
    return exc
  end

  local exc = rectangle_eccentricity()
  local b = math.floor(math.sqrt(area+4*exc*exc))
  local a = b-2*exc
  local a2 = math.floor(a / 2) + (a % 2)
  local b2 = math.floor(b / 2) + (b % 2)
  local x1, y1 = clamp_in_bounds(cx - a2, cy - b2)
  local x2, y2 = clamp_in_bounds(cx + a2, cy + b2)
  return x1, y1, x2, y2
end

local function flip_rectangle(x1, y1, x2, y2)
  local cx = math.floor((x1 + x2) / 2)
  local cy = math.floor((y1 + y2) / 2)
  local nx1, ny1 = clamp_in_bounds(cx + y1 - cy, cy + x1 - cx)
  local nx2, ny2 = clamp_in_bounds(cx + y2 - cy, cy + x2 - cx)
  return { nx1, ny1, nx2, ny2 }
end

  
  local area = map_area()
  area = math.floor(area*3/4)
  
  local cx, cy = dgn.GXM / 2, dgn.GYM / 2

  local x1, y1, x2, y2 = rectangle_dimensions()

  -- 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
    exc = exc + 1
  end
  local a = math.floor(math.sqrt(area+4*exc*exc))
  local b = a - 2*exc
  local a2 = math.floor(a / 2) + (a % 2)
  local b2 = math.floor(b / 2) + (b % 2)
  local x1, y1 = clamp_in_bounds(cx - a2, cy - b2)
  local x2, y2 = clamp_in_bounds(cx + a2, cy + b2)

  dgn.fill_area(unpack( util.catlist(flip_rectangle(x1, y1, x2, y2),
                                     { "floor" }) ) )

  local zig_exc = zig().zig_exc
  local nx1 = cx + y1 - cy
  local ny1 = cy + x1 - cx + math.floor(zig().depth/2*(200-zig_exc)/300)
  local nx2 = cx + y2 - cy
  local ny2 = cy + x2 - cx - math.floor(zig().depth/2*(200-zig_exc)/300)
  nx1, ny1 = clamp_in_bounds(nx1, ny1)
  nx2, ny2 = clamp_in_bounds(nx2, ny2)
  dgn.fill_area(nx1, ny1, nx2, ny2, "floor")

  local c = dgn.point(x1 + x2, y1 + y2) / 2

  local entry = dgn.point(x1, cy)
  local exit = dgn.point(x2, cy)

  local entry = dgn.point(x1, c.y)
  local exit = dgn.point(x2, c.y)

--crawl.mpr("area= " ..area .. ", a=" .. a .. ", b=" .. b .. ", exc=" .. zig_exc)
  

-- builds hexagonal ziggurat maps

  crawl.mpr("a: " .. a)

  local b = math.floor(a*math.sqrt(3)/4)

--crawl.mpr("area=" .. area .. ", a: " .. a .. ", lx=" .. left.x .. ", rx=" .. right.x)  
  

        and y >= c.y - a and y <= c.y + a then

        and y >= c.y - b and y <= c.y + b then