// Identifies a level.

// Identifies a level. Should never include virtual methods or
// dynamically allocated memory (see code to push level_id onto Lua
// stack in luadgn.cc)

    }
    const level_id &operator = (const level_id &id)
    {
        branch     = id.branch;
        depth      = id.depth;
        level_type = id.level_type;
        return (*this);

static void push_level_id(lua_State *ls, const level_id &lid)
{
    // We're skipping the constructor; naughty, but level_id has no
    // virtual methods and no dynamically allocated memory.
    level_id *nlev =
        static_cast<level_id*>(lua_newuserdata(ls, sizeof(level_id)));
    *nlev = lid;
}
static level_id _lua_level_id(lua_State *ls, int ndx)
{
    if (lua_isstring(ls, ndx))
    {
        const char *s = lua_tostring(ls, 1);
        try
        {
            return level_id::parse_level_id(s);
        }
        catch (const std::string &err)
        {
            luaL_error(ls, err.c_str());
        }
    }
    else if (lua_isuserdata(ls, ndx))
    {
        const level_id *lid = static_cast<level_id*>(lua_touserdata(ls, ndx));
        return (*lid);
    }
    luaL_argerror(ls, ndx, "Expected level_id");
    // Never gets here.
    return level_id();
}
LUAFN(dgn_level_id)
{
    const int nargs = lua_gettop(ls);
    if (!nargs)
        push_level_id(ls, level_id::current());
    else if (nargs == 1)
        push_level_id(ls, _lua_level_id(ls, 1));
    return (1);
}
static inline bool _lua_boolean(lua_State *ls, int ndx, bool defval)
{
    return lua_isnone(ls, ndx)? defval : lua_toboolean(ls, ndx);
}
static int _lua_push_map(lua_State *ls, const map_def *map)
{
    if (map)
        lua_pushlightuserdata(ls, const_cast<map_def*>(map));
    else
        lua_pushnil(ls);
    return (1);
}

LUAFN(dgn_map_by_tag)
{
    if (const char *tag = luaL_checkstring(ls, 1))
    {
        const bool mini = _lua_boolean(ls, 2, true);
        const bool check_depth = _lua_boolean(ls, 3, true);
        return _lua_push_map(ls, random_map_for_tag(tag, mini, check_depth));
    }
    return (0);
}
LUAFN(dgn_map_in_depth)
{
    const level_id lid = _lua_level_id(ls, 1);
    const bool mini = _lua_boolean(ls, 2, true);
    return _lua_push_map(ls, random_map_in_depth(lid, mini));
}
LUAFN(dgn_map_by_place)
{
    const level_id lid = _lua_level_id(ls, 1);
    const bool mini = _lua_boolean(ls, 2, true);
    return _lua_push_map(ls, random_map_for_place(lid, mini));
}
LUAFN(_dgn_place_map)
{
    if (!lua_isuserdata(ls, 1))
        luaL_argerror(ls, 1, "Expected map");
    const map_def *map = static_cast<map_def *>(lua_touserdata(ls, 1));
    const bool clobber = _lua_boolean(ls, 2, false);
    const bool no_exits = _lua_boolean(ls, 3, false);
    coord_def where(-1, -1);
    if (lua_isnumber(ls, 4) && lua_isnumber(ls, 5))
    {
        COORDS(c, 4, 5);
        where = c;
    }
    lua_pushboolean(ls, dgn_place_map(map, clobber, no_exits, where));
    return (1);
}

    { "level_id", dgn_level_id },
    { "map_by_tag", dgn_map_by_tag },
    { "map_in_depth", dgn_map_in_depth },
    { "map_by_place", dgn_map_by_place },
    { "place_map", _dgn_place_map },

level_area_type str_to_level_area_type(const std::string &s);

static level_area_type _str_to_level_area_type(const std::string &s)

level_area_type str_to_level_area_type(const std::string &s)

    level_type = _str_to_level_area_type(fields->str_field("ltyp"));

    level_type = str_to_level_area_type(fields->str_field("ltyp"));

#######################################################################
# Pillars for ziggurats.
#######################################################################
NAME: ziggurat_pillar_a
TAGS: ziggurat_pillar
SUBST: c : cxv
MAP
c
ENDMAP

NAME: ziggurat_pillar_b
TAGS: ziggurat_pillar
SUBST: c : cxv
MAP
cc
cc
ENDMAP
NAME: ziggurat_pillar_c
TAGS: ziggurat_pillar
MAP
lll
lGl
lll
ENDMAP

    end
  end
end
local function ziggurat_place_pillars(c)
  local range = crawl.random_range
  local function pillar_spot()
    local floor = dgn.fnum("floor")
    for i = 1, 100 do
      local place = { x = c.x + range(-30, 30), y = c.y + range(-30, 30) }
      if (dgn.grid(place.x, place.y) == floor) then
        return place
      end
    end
    return nil
  end
  local function place_pillar(p)
    local map = dgn.map_by_tag("ziggurat_pillar")
    if map then
      dgn.place_map(map, false, true, p.x, p.y)
    end
  end
  for i = 1, crawl.random_range(1,3) do
    local p = pillar_spot()
    if p then
      place_pillar(p)

  local cx = math.floor((x1 + x2) / 2)

  ziggurat_place_pillars { x = cx, y = cy }