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

    if (!dlua.callfn("dgn_save_data", "u", &th))
        mprf(MSGCH_ERROR, "Failed to save Lua data: %s", dlua.error.c_str());

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

    {
        if (!dlua.callfn("dgn_load_data", "u", &th))
            mprf(MSGCH_ERROR, "Failed to load Lua persist table: %s",
                 dlua.error.c_str());
    }

    bottomright.set( GXM - x_border_dist, GYM - y_border_dist );

    bottomright.set( GXM - x_border_dist - 1, GYM - y_border_dist - 1 );

const coord_def find_marker_prop(const std::string &prop,
                                 const std::string &expected = "");

}
const coord_def find_marker_prop(const std::string &prop,
                                 const std::string &expected)
{
    for (rectangle_iterator i(0, 0); i; ++i)
    {
        const std::string value =
            env.markers.property_at(*i, MAT_ANY, prop);
        if (!value.empty() && (expected.empty() || value == expected))
            return (*i);
    }
    const coord_def nowhere(-1, -1);
    return (nowhere);

}
LUAFN(_dgn_find_marker_prop)
{
    const char *prop = luaL_checkstring(ls, 1);
    const std::string value(
        lua_gettop(ls) >= 2 ? luaL_checkstring(ls, 2) : "");
    const coord_def place = find_marker_prop(prop, value);
    if (map_bounds(place))
        clua_push_coord(ls, place);
    else
    {
        lua_pushnil(ls);
        lua_pushnil(ls);
    }
    return (2);

    { "find_marker_prop", _dgn_find_marker_prop },

    else if (lua_isboolean(ls, 2))
        marshallByte(th, lua_toboolean(ls, 2));

}
static int file_unmarshall_boolean(lua_State *ls)
{
    if (lua_gettop(ls) != 1)
        luaL_error(ls, "Need reader as one argument");
    reader &th(*static_cast<reader*>( lua_touserdata(ls, 1) ));
    lua_pushboolean(ls, unmarshallByte(th));
    return (1);

    LPT_NIL

    LPT_NIL,
    LPT_BOOLEAN

    else if (lua_isboolean(ls, 2))
        ptype = LPT_BOOLEAN;

        luaL_error(ls, "Can marshall only numbers, strings and functions.");

        luaL_error(ls,
                   make_stringf("Cannot marshall %s",
                                lua_typename(ls, lua_type(ls, 2))).c_str());

    case LPT_BOOLEAN:
        return file_unmarshall_boolean(ls);

: dofile("clua/ziggurat.lua")

: require("clua/ziggurat.lua")

: ziggurat_loot_spot(_G, "X")

@..........c

@.........Xc

end
local function set_floor_colour(colour)
  if not zig().level.floor_colour then
    zig().level.floor_colour = colour
    dgn.change_floor_colour(colour, false)
  end
end
local function set_random_floor_colour()
  set_floor_colour( random_floor_colour() )
end
local function with_props(spec, props)
  return util.cathash({ spec = spec }, props)

end
local function set_floor_colour(colour)
  if not zig().level.floor_colour then
    zig().level.floor_colour = colour
    dgn.change_floor_colour(colour, false)
  end
end
local function set_random_floor_colour()
  set_floor_colour( random_floor_colour() )

    return function (x, y, nth)
             if branch then
               set_floor_colour(dgn.br_floorcol(branch))
             end

    local function mspec(x, y, nth)
      if branch then
        set_floor_colour(dgn.br_floorcol(branch))
      end

             return dgn.create_monster(x, y, arg)
           end

      return dgn.create_monster(x, y, arg)
    end
    return { fn = mspec }

    if arg.cond() then
      return monster_creator_fn(arg.spec)

    if not arg.cond or arg.cond() then
      return util.cathash(monster_creator_fn(arg.spec), arg)

  else
    return arg

  elseif atyp == "function" then
    return { fn = arg }

  "place:Slime:6",

  with_props("place:Slime:6", { jelly_protect = true }),

    if mgen then
      mgen = mgen.fn
    end

local function ziggurat_vet_monster(fn)
  return function (x, y, nth, hdmax)
           for i = 1, 100 do
             local mons = fn(x, y, nth)
             if mons then
               -- Discard zero-exp monsters, and monsters that explode
               -- the HD limit.
               if mons.experience == 0 or mons.hd > hdmax * 1.3 then
                 mons.dismiss()
               else
                 if mons.muse == "eats_items" then
                   zig().level.jelly_protect = true
                 end
                 -- Monster is ok!
                 return mons
               end
             end
           end
           -- Give up.
           return nil
         end

local function ziggurat_vet_monster(fmap)
  local fn = fmap.fn
  fmap.fn = function (x, y, nth, hdmax)
              for i = 1, 100 do
                local mons = fn(x, y, nth)
                if mons then
                  -- Discard zero-exp monsters, and monsters that explode
                  -- the HD limit.
                  if mons.experience == 0 or mons.hd > hdmax * 1.3 then
                    mons.dismiss()
                  else
                    if mons.muse == "eats_items" then
                      zig().level.jelly_protect = true
                    end
                    -- Monster is ok!
                    return mons
                  end
                end
              end
              -- Give up.
              return nil
            end
  return fmap

local function ziggurat_create_monsters(p)

-- Function to find travel-safe squares, excluding closed doors.
local dgn_passable = dgn.passable_excluding("closed_door")
local function ziggurat_create_monsters(p, mfn)

  local mfn = choose_monster_set()

  -- No monsters

    local place = dgn.find_adjacent_point(p, mons_place_p)

    local place = dgn.find_adjacent_point(p, mons_place_p, dgn_passable)

      -- Can't find any suitable monster for the HD we have left.

  end
  local door = dgn.fnum("closed_door")
  local function passable(p)
    return dgn.is_passable(p.x, p.y) and dgn.grid(p.x, p.y) ~= door

      local p = dgn.find_adjacent_point(c, free_space_threshold(i), passable)

      local p =
        dgn.find_adjacent_point(c, free_space_threshold(i), dgn_passable)

end
-- Suitable for use in loot vaults.
function ziggurat_loot_spot(e, key)
  e.lua_marker(key, portal_desc { ziggurat_loot = "X" })
  e.kfeat(key .. " = .")
  e.marker("@ = feat: permarock_wall")
  e.kfeat("@ = +")

  -- Place a door.
  local doorplace = find_door_spot(exit, inc)

  local connect_point = exit - inc * 3

  -- Closed door with the permarock wall feature marker.
  dgn.gridmark(doorplace.x, doorplace.y, "closed_door", "permarock_wall")
  local connect_point = doorplace + inc

    return dgn.place_map(map, false, true)

    local res = dgn.place_map(map, false, true)
    if res then
      zig().level.loot_chamber = true
    end
    return res

    local linc = (vc - exit):sgn()

    local function safe_area()
      local p = dgn.point(px, py)
      local sz = dgn.point(xs, ys)
      local floor = dgn.fnum("floor")
      return dgn.rectangle_forall(p, p + sz - 1,
                                  function (c)
                                    return dgn.grid(c.x, c.y) == floor
                                  end)
    end
    local linc = (exit - vc):sgn()

    return not (inc == linc)

    return not (inc == linc) or not safe_area()

    ziggurat_create_loot_at(connect_point)

    -- Find the square to drop the loot.
    local lootx, looty = dgn.find_marker_prop("ziggurat_loot")
    if lootx and looty then
      ziggurat_create_loot_at(dgn.point(lootx, looty))
    else
      loot_fallback()
    end

  ziggurat_place_pillars(c)

  local monster_generation = choose_monster_set()

  ziggurat_create_monsters(exit)

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

  if not zig().level.loot_chamber then
    -- Place pillars if we did not create a loot chamber.
    ziggurat_place_pillars(c)
  end
  ziggurat_create_monsters(exit, monster_generation.fn)

-- Creates a set (a map of keys to true) from the list supplied.
function util.set(list)
  local set = { }
  for _, value in ipairs(list) do
    set[value] = true
  end
  return set
end

      for key, val in ipairs(tab) do

      for key, val in pairs(tab) do

point_metatable.str = function (p)
                        return "(" .. p.x .. "," .. p.y .. ")"
                      end

                             local function pstr(p)
                               return "(" .. p.x .. "," .. p.y .. ")"
                             end

                               return pstr(pre) .. post

                               return pre:str() .. post

                               return pre .. pstr(post)

                               return pre .. post:str()

end
-- Given a feature name or number, returns a feature number.
function dgn.find_feature_number(name_num)
  if type(name_num) == "number" then
    return name_num
  else
    return dgn.fnum(name_num)
  end

end
-- Returns a function that returns true if the point specified is
-- travel-passable and is not one of the features specified.
function dgn.passable_excluding(...)
  local forbidden_features =
    util.set(util.map(dgn.find_feature_number, { ... }))
  return function (p)
           local x, y = p.x, p.y
           return dgn.is_passable(x, y) and
             not forbidden_features[dgn.grid(x, y)]
         end

-- Returns all adjacent points of c which are in_bounds (i.e. excluding the
-- outermost layer of wall) and for which faccept returns true.

    local p = { x = c.x + cp[1], y = c.y + cp[2] }

    local p = dgn.point(c.x + cp[1], c.y + cp[2])

-- Returns the closest point p starting from c (including c) for which
-- fcondition(p) is true, without passing through squares for which
-- fpassable(p) is false. If no suitable square is found, returns nil.
--
-- All points are instances of dgn.point, i.e. a Lua table with x and y keys.
--
-- fpassable may be omitted, in which case it defaults to dgn.is_passable.

  local mapped_points = { }

  -- Just in case c isn't a real dgn.point - canonicalise.
  c = dgn.point(c.x, c.y)

  local function pstr(p)
    return p.x .. "," .. p.y
  end

  local mapped_points = { }

    return mapped_points[pstr(p)]

    return mapped_points[p:str()]

    mapped_points[pstr(p)] = val or 1

    mapped_points[p:str()] = val or 1

-- Scans the entire map, colouring squares for which fselect(p)
-- returns true with colour.

-- Sets the grid feature at (x,y) to grid. Optionally, if a marker value
-- is provided, creates a suitable marker at (x,y).
--
-- marker may be
-- 1) a function, in which case a Lua marker is created that
--    will call the function to create a marker table.
-- 2) a table, in which case a Lua marker is created that uses the table
--    directly as a marker table.
-- 3) anything else, which is assumed to be a feature name or number, and
--    is used to create a feature marker.
--