if (you.level_type_name == "bazaar")
             return "- a Bazaar";
         return "- a Portal Chamber";

        if (!you.level_type_name.empty())
            return "- " + article_a(upcase_first(you.level_type_name));
        return "- a Portal Chamber";

    TAG_MINOR_VERSION  = 10      // Current version

    TAG_MINOR_LUADGN   = 11,     // Allow dungeon Lua to persist data.
    TAG_MINOR_VERSION            // Current version

    marshallString(th, you.level_type_tag);

    dlua.callfn("dgn_save_data", "u", &th);

    if (minorVersion >= TAG_MINOR_LUADGN)
        you.level_type_tag = unmarshallString(th);

    if (minorVersion >= TAG_MINOR_LUADGN)
        dlua.callfn("dgn_load_data", "u", &th);

    std::string newname =
        env.markers.property_at(you.pos(), MAT_ANY, "dstname");

    // Don't clobber level_type_name for stairs in portal vaults.
    if (you.level_type_name.empty() || !newname.empty()
        || you.level_type != LEVEL_PORTAL_VAULT)
    {
        you.level_type_name = newname;
    }

    you.level_type_name = newtype;

    if (you.level_type_tag.empty() || !newtype.empty()
        || you.level_type != LEVEL_PORTAL_VAULT)
    {
        you.level_type_tag  = newtype;
    }
    if (!you.level_type_tag.empty() && you.level_type_name.empty())
        you.level_type_name = you.level_type_tag;

            || stair_find != DNGN_TRANSIT_PANDEMONIUM))

            || stair_find != DNGN_TRANSIT_PANDEMONIUM)
        && (you.level_type != LEVEL_PORTAL_VAULT
            || !grid_is_stone_stair(stair_find)))

    if (!dlua.callfn("dgn_run_map", 1, 1))

    if (fn.is_function() && !dlua.callfn("dgn_run_map", 1, 1))

    // Markers with no key are not an error.

        return make_stringf("cant find key '%c' for marker", key);

        return ("");

static dungeon_feature_type _get_lua_feature(lua_State *ls, int idx)
{
    dungeon_feature_type feat = (dungeon_feature_type)0;
    if (lua_isnumber(ls, idx))
        feat = (dungeon_feature_type)luaL_checkint(ls, idx);
    else if (lua_isstring(ls, idx))
        feat = dungeon_feature_by_name(luaL_checkstring(ls, idx));
    else
        luaL_argerror(ls, idx, "Feature must be a string or a feature index.");
    return feat;
}
static dungeon_feature_type _check_lua_feature(lua_State *ls, int idx)
{
    const dungeon_feature_type f = _get_lua_feature(ls, idx);
    if (!f)
        luaL_argerror(ls, idx, "Invalid dungeon feature");
    return (f);
}

#define COORDS(c, p1, p2)                                \
    coord_def c;                                          \
    c.x = luaL_checkint(ls, p1);                          \
    c.y = luaL_checkint(ls, p2);                          \
    if (!in_bounds(c))                                    \
        luaL_error(                                         \
            ls,                                                 \
            make_stringf("Point (%d,%d) is out of map bounds",  \
                         c.x, c.y).c_str());
#define FEAT(f, pos) \
    dungeon_feature_type f = _check_lua_feature(ls, pos)

    if (lua_gettop(ls) != 3 || !lua_isstring(ls, 2) || !lua_isfunction(ls, 3))
        luaL_error(ls, "Expected marker key and marker function.");

    if (lua_gettop(ls) != 3 || !lua_isstring(ls, 2)
        || (!lua_isfunction(ls, 3) && !lua_istable(ls, 3)))
    {
        luaL_error(ls, "Expected marker key and marker function/table.");
    }

    const int x = luaL_checkint(ls, 1), y = luaL_checkint(ls, 2);
    if (!map_bounds(x, y))
        luaL_error(ls,
                   make_stringf("(%d,%d) is out of bounds (%d-%d,%d-%d)",
                                x, y,
                                X_BOUND_1, X_BOUND_2,
                                Y_BOUND_1, Y_BOUND_2).c_str());
    if (lua_isnumber(ls, 3))
        grd[x][y] = static_cast<dungeon_feature_type>(luaL_checkint(ls, 3));
    PLUARET(number, grd[x][y]);

    COORDS(c, 1, 2);
    const dungeon_feature_type feat = _get_lua_feature(ls, 3);
    if (feat)
        grd(c) = feat;
    PLUARET(number, grd(c));

static dungeon_feature_type _get_lua_feature(lua_State *ls, int idx)
{
    dungeon_feature_type feat = (dungeon_feature_type)0;
    if (lua_isnumber(ls, idx))
        feat = (dungeon_feature_type)luaL_checkint(ls, idx);
    else if (lua_isstring(ls, idx))
        feat = dungeon_feature_by_name(luaL_checkstring(ls, idx));
    else
        luaL_argerror(ls, idx, "Feature must be a string or a feature index.");

    return feat;
}

    dungeon_feature_type feat = _get_lua_feature(ls, 5);
    if (!feat)
    {
        luaL_argerror(ls, 5, "Invalid feature.");
        return 0;
    }

    dungeon_feature_type feat = _check_lua_feature(ls, 5);

    dungeon_feature_type search = _get_lua_feature(ls, 5);
    if (!search)
    {
        luaL_argerror(ls, 5, "Invalid feature.");
        return 0;
    }
    dungeon_feature_type replace = _get_lua_feature(ls, 6);
    if (!replace)
    {
        luaL_argerror(ls, 6, "Invalid feature.");
        return 0;
    }

    dungeon_feature_type search = _check_lua_feature(ls, 5);
    dungeon_feature_type replace = _check_lua_feature(ls, 6);

    dungeon_feature_type fill = _get_lua_feature(ls, 6);
    if (!fill)
    {
        luaL_argerror(ls, 6, "Invalid feature.");
        return 0;
    }

    dungeon_feature_type fill = _check_lua_feature(ls, 6);

    dungeon_feature_type fill = _get_lua_feature(ls, 8);
    if (!fill)
    {
        luaL_argerror(ls, 8, "Invalid feature.");
        return 0;
    }

    dungeon_feature_type fill = _check_lua_feature(ls, 8);

    dungeon_feature_type fill = _get_lua_feature(ls, 4);
    if (!fill)
    {
        luaL_argerror(ls, 4, "Invalid feature.");
        return 0;
    }

    dungeon_feature_type fill = _check_lua_feature(ls, 4);

    dungeon_feature_type fill = _get_lua_feature(ls, 4);
    if (!fill)
    {
        luaL_argerror(ls, 4, "Invalid feature.");
        return 0;
    }

    dungeon_feature_type fill = _check_lua_feature(ls, 4);

    dungeon_feature_type fill = _get_lua_feature(ls, 4);
    if (!fill)
    {
        luaL_argerror(ls, 4, "Invalid feature.");
        return 0;
    }

    dungeon_feature_type fill = _check_lua_feature(ls, 4);

    dungeon_feature_type search = _get_lua_feature(ls, 5);
    if (!search)
    {
        luaL_argerror(ls, 5, "Invalid feature.");
        lua_pushboolean(ls, false);
        return 1;
    }
    dungeon_feature_type replace = _get_lua_feature(ls, 6);
    if (!replace)
    {
        luaL_argerror(ls, 6, "Invalid feature.");
        lua_pushboolean(ls, false);
        return 1;
    }

    dungeon_feature_type search = _check_lua_feature(ls, 5);
    dungeon_feature_type replace = _check_lua_feature(ls, 6);

    dungeon_feature_type search = _get_lua_feature(ls, 1);
    if (!search)
    {
        luaL_argerror(ls, 1, "Invalid feature.");
        return 0;
    }
    dungeon_feature_type replace = _get_lua_feature(ls, 2);
    if (!replace)
    {
        luaL_argerror(ls, 2, "Invalid feature.");
        return 0;
    }

    dungeon_feature_type search = _check_lua_feature(ls, 1);
    dungeon_feature_type replace = _check_lua_feature(ls, 2);

    dungeon_feature_type feat = _get_lua_feature(ls, 3);
    if (!feat)
    {
        luaL_argerror(ls, 3, "Invalid feature.");
        return 0;
    }

    dungeon_feature_type feat = _check_lua_feature(ls, 3);

    dungeon_feature_type feat = _get_lua_feature(ls, 5);
    if (!feat)
    {
        luaL_argerror(ls, 5, "Invalid feature.");
        lua_pushnil(ls);
        return 1;
    }

    dungeon_feature_type feat = _check_lua_feature(ls, 5);

    dungeon_feature_type feat = _get_lua_feature(ls, 5);
    if (!feat)
    {
        luaL_argerror(ls, 5, "Invalid feature.");
        lua_pushnil(ls);
        return 1;
    }

    dungeon_feature_type feat = _check_lua_feature(ls, 5);

    dungeon_feature_type feat = _get_lua_feature(ls, 3);
    if (!feat)
    {
        luaL_argerror(ls, 3, "Invalid feature.");
        lua_pushnil(ls);
        return 1;
    }

    dungeon_feature_type feat = _check_lua_feature(ls, 3);

    dungeon_feature_type feat = _get_lua_feature(ls, 5);
    if (!feat)
    {
        luaL_argerror(ls, 5, "Invalid feature.");
        return 0;
    }

    dungeon_feature_type feat = _check_lua_feature(ls, 5);

}
static int dgn_register_feature_marker(lua_State *ls)
{
    COORDS(c, 1, 2);
    FEAT(feat, 3);
    env.markers.add( new map_feature_marker(c, feat) );
    return (0);

static int dgn_register_lua_marker(lua_State *ls)
{
    COORDS(c, 1, 2);
    if (!lua_istable(ls, 3) && !lua_isfunction(ls, 3))
        return luaL_argerror(ls, 3, "Expected marker table or function");
    lua_datum table(CLua::get_vm(ls), 3, false);
    map_marker *marker = new map_lua_marker(table);
    marker->pos = c;
    env.markers.add(marker);
    return (0);
}

    { "register_feature_marker", dgn_register_feature_marker },
    { "register_lua_marker", dgn_register_lua_marker },

    }
    bool zero() const
    {
        return origin();

  // Human-readable name for portal vault. Will be set to level_type_tag
  // if not explicitly set by the entry portal.

  // .des file tag for portal vault
  std::string level_type_tag;

    // level_type_name may contain spaces for human readability, but the

    // level_type_tag may contain spaces for human readability, but the

        replace_all(trimmed_string(you.level_type_name), " ", "_");

        replace_all(trimmed_string(you.level_type_tag), " ", "_");

            vault = find_map_by_name(you.level_type_name + "_" + name);

            vault = find_map_by_name(you.level_type_tag + "_" + name);

        i = level_type_post_callbacks.find(you.level_type_name);

        i = level_type_post_callbacks.find(you.level_type_tag);

    // NOTE: assumes *no* previous item (I think) or monster (definitely)
    // placement.
    for ( rectangle_iterator ri(place.pos, place.pos + place.size - 1);
          ri; ++ri )

    if (!place.size.zero())

        if (vgrid[ri->y][ri->x] == ' ')
            continue;

        // NOTE: assumes *no* previous item (I think) or monster (definitely)
        // placement.
        for ( rectangle_iterator ri(place.pos, place.pos + place.size - 1);
              ri; ++ri )
        {
            if (vgrid[ri->y][ri->x] == ' ')
                continue;

        const dungeon_feature_type oldgrid = grd(*ri);
        altar_count = _vault_grid( place, level_number, *ri, altar_count,
                                   acq_item_class,
                                   vgrid[ri->y][ri->x],
                                   target_connections,
                                   num_runes,
                                   rune_subst );
        if (!generating_level)
        {
            // Have to link items each square at a time, or
            // dungeon_terrain_changed could blow up.
            link_items();
            const dungeon_feature_type newgrid = grd(*ri);
            grd(*ri) = oldgrid;
            dungeon_terrain_changed(*ri, newgrid, true, true);
            env.markers.remove_markers_at(*ri, MAT_ANY);

            const dungeon_feature_type oldgrid = grd(*ri);
            altar_count = _vault_grid( place, level_number, *ri, altar_count,
                                       acq_item_class,
                                       vgrid[ri->y][ri->x],
                                       target_connections,
                                       num_runes,
                                       rune_subst );
            if (!generating_level)
            {
                // Have to link items each square at a time, or
                // dungeon_terrain_changed could blow up.
                link_items();
                const dungeon_feature_type newgrid = grd(*ri);
                grd(*ri) = oldgrid;
                dungeon_terrain_changed(*ri, newgrid, true, true);
                env.markers.remove_markers_at(*ri, MAT_ANY);
            }
            env.map(*ri).property |= FPROP_VAULT;

        env.map(*ri).property |= FPROP_VAULT;

    if (you.level_type == LEVEL_PORTAL_VAULT && you.level_type_name == "bazaar")

    if (you.level_type == LEVEL_PORTAL_VAULT && you.level_type_tag == "bazaar")

            && you.level_type_name == "bazaar")

            && you.level_type_tag == "bazaar")

    // Last attempt: look for marker.
    const coord_def pos(_dgn_find_feature_marker(stair_to_find));
    if (in_bounds(pos))
        return (pos);
    // Still hosed? If we're in a portal vault, convert to a search for
    // any stone arch.
    if (you.level_type == LEVEL_PORTAL_VAULT
        && stair_to_find != DNGN_STONE_ARCH)
    {
        return dgn_find_nearby_stair(DNGN_STONE_ARCH, base_pos, find_closest);
    }

    // FAIL

void dgn_set_lt_callback(std::string level_type_name,

void dgn_set_lt_callback(std::string level_type_tag,

    ASSERT(!level_type_name.empty());

    ASSERT(!level_type_tag.empty());

    level_type_post_callbacks[level_type_name] = callback_name;

    level_type_post_callbacks[level_type_tag] = callback_name;

            you.level_type_name = "bazaar";

            you.level_type_tag = you.level_type_name = "bazaar";

###############################################################################
# ziggurat.des - Ziggurat entry vaults and ziggurat layouts.
###############################################################################
# Most ziggurat code is in ziggurat.lua.
# XXX: Ziggurat code is incomplete.
: dofile("clua/ziggurat.lua")
NAME: enter_the_ziggurat
# Disabled; ziggurat is still incomplete.
WEIGHT: 0
: ziggurat_portal(_G)
MAP
O
ENDMAP
NAME: ziggurat1
: ziggurat_level(_G)
MAP
ENDMAP
#############################################################################
# Multilevel portal vault structure:
# This is how a multilevel portal vault should be laid out. All stairs are
# one-way; the player cannot return to a level once left.
NAME: multilevel_portal_vault_entry
# Demo vault, disabled.
WEIGHT: 0
MARKER: O = lua:one_way_stair { \
              dst="multilevel portal vault", \
              desc="An entrance to a multilevel portal vault" \
            }
KFEAT: O = enter_portal_vault
MAP
O
ENDMAP
NAME: portal_level_1
TAGS: multilevel_portal_vault
: portal_vault(_G, "multilevel_portal_vault")
# portal_next() links all downstairs to the vault with the specified tag.
: portal_next(_G, "multilevel_portal_vault_b")
MAP
xxxxxx
xA..]x
xxxxxx
ENDMAP
NAME: portal_level_2
: portal_vault(_G, "multilevel_portal_vault_b")
: portal_next(_G, "multilevel_portal_vault_c")
MAP
xxxxxx
xAWW]x
xxxxxx
ENDMAP
NAME: portal_level_3
: portal_vault(_G, "multilevel_portal_vault_c")
KFEAT: < = exit_portal_vault
MAP
xxxxxxx
xlllllx
xA...<x
xlllllx
xxxxxxx
ENDMAP

------------------------------------------------------------------------------
-- ziggurat.lua:
--
-- Code for ziggurats.
--
-- Important notes:
-- ----------------
-- Functions that are attached to Lua markers' onclimb properties
-- cannot be closures, because Lua markers must be saved and closure
-- upvalues cannot (yet) be saved.
------------------------------------------------------------------------------
function zig()
  if not dgn.persist.ziggurat then
    dgn.persist.ziggurat = { }
  end
  return dgn.persist.ziggurat
end
-- Returns a function that changes the depth in the ziggurat to the depth
-- specified.
local function zig_depth_increment()
  return function (...)
           zig().depth = zig().depth + 1
         end
end
function ziggurat_initializer()
  local z = zig()
  z.depth = 1
  z.builder = ziggurat_choose_builder()
end
-- Returns the current depth in the ziggurat.
local function zig_depth()
  return zig().depth or 0
end
-- Common setup for ziggurat entry vaults.
function ziggurat_portal(e)
  local function stair()
    return one_way_stair {
      desc = "gateway to a ziggurat",
      dst = "ziggurat",
      floor = "stone_arch",
      onclimb = ziggurat_initializer
    }
  end
  e.lua_marker("O", stair)
  e.kfeat("O = enter_portal_vault")
end
-- Common setup for ziggurat levels.
function ziggurat_level(e)
  e.tags("ziggurat")
  e.tags("allow_dup")
  e.orient("encompass")
  ziggurat_build_level(e)
end
-----------------------------------------------------------------------------
-- Ziggurat level builders.
function ziggurat_build_level(e)
  local builder = zig().builder
  if builder then
    return ziggurat_builder_map[builder](e)
  end
end
local function zigstair(x, y, stair, marker)
  dgn.grid(x, y, stair)
  if marker then
    local t = type(marker)
    if t == "function" or t == "table" then
      dgn.register_lua_marker(x, y, marker)
    else
      dgn.register_feature_marker(x, y, marker)
    end
  end
end
-- Creates a Lua marker table that increments ziggurat depth.
local function zig_go_deeper()
  return one_way_stair {
    onclimb = zig_depth_increment()
  }
end
local function ziggurat_rectangle_builder(e)
  local grid = dgn.grid
  -- FIXME: Cool code goes here.
  local x1, y1 = 20, 20
  local x2, y2 = dgn.GXM - 20, dgn.GYM - 20
  dgn.fill_area(x1, y1, x2, y2, "floor")
  local my = math.floor((y1 + y2) / 2)
  zigstair(x1, my, "stone_arch", "stone_stairs_up_i")
  zigstair(x2, my, "stone_stairs_down_i", zig_go_deeper)
  grid(x2, my + 1, "exit_portal_vault")
  crawl.mpr("Ziggurat depth is now " .. zig_depth())
end
----------------------------------------------------------------------
ziggurat_builder_map = {
  rectangle = ziggurat_rectangle_builder
}
local ziggurat_builders = { }
for key, val in pairs(ziggurat_builder_map) do
  table.insert(ziggurat_builders, key)
end
function ziggurat_choose_builder()
  return ziggurat_builders[crawl.random_range(1, #ziggurat_builders)]
end

  "crypt.des", "zot.des"

  "crypt.des", "ziggurat.des", "zot.des"

    -- If there's an onclimb function, call it before we do our thing.
    if self.props.onclimb then
      self.props.onclimb(self, marker, ev)
    end

dgn.f_rockwall = dgn.feature_number("rock_wall")
dgn.f_floor = dgn.feature_number("floor")
-- Table that will be saved in <foo>.sav.
dgn.persist = { }

function dgn_save_data(th)
  lmark.marshall_table(th, dgn.persist)
end
function dgn_load_data(th)
  dgn.persist = lmark.unmarshall_table(th) or { }
end

  end
end
----------------------------------------------------------------------
-- Convenience functions for vaults.
-- Returns a marker table that sets the destination tag for that square,
-- usually used to set a destination tag for a portal or a stair in a
-- portal vault.
function portal_stair_dst(dst)
  return one_way_stair { dst = dst }
end
-- Common initialisation for portal vaults.
function portal_vault(e, tag)
  if tag then
    e.tags(tag)

  e.orient("encompass")
end
-- Set all stone downstairs in this vault to go to the tag 'next'.
function portal_next(e, next)
  for _, feat in ipairs({ "]", ")", "}" }) do
    e.lua_marker(feat, portal_stair_dst(next))
  end

    bool is_table() const;
    bool is_function() const;
    bool is_number() const;
    bool is_string() const;
    bool is_udata() const;

}
#define LUA_CHECK_TYPE(check) \
    lua_stack_cleaner clean(lua);                               \
    push();                                                     \
    return check(lua, -1)
bool lua_datum::is_table() const
{
    LUA_CHECK_TYPE(lua_istable);
}
bool lua_datum::is_function() const
{
    LUA_CHECK_TYPE(lua_isfunction);
}
bool lua_datum::is_number() const
{
    LUA_CHECK_TYPE(lua_isnumber);

bool lua_datum::is_string() const
{
    LUA_CHECK_TYPE(lua_isstring);
}
bool lua_datum::is_udata() const
{
    LUA_CHECK_TYPE(lua_isuserdata);
}