#include "mapmark.h"

        && mons_itemuse(monster) == MONUSE_EATS_ITEMS)

        && mons_itemuse(monster) == MONUSE_EATS_ITEMS
        // Doors with permarock marker cannot be eaten.
        && !feature_marker_at(newpos, DNGN_PERMAROCK_WALL))

    MONUSE_MAGIC_ITEMS

    MONUSE_MAGIC_ITEMS,
    NUM_MONUSE

typedef bool (*map_place_check_t)(const map_def &, const coord_def &c,
                                  const coord_def &size);
typedef std::vector<coord_def> point_vector;
extern map_place_check_t map_place_invalid;
extern point_vector      map_anchor_points;

static bool bad_map_place(const map_def &map, const coord_def &c,
                          const coord_def &size);

// Globals: Use unwind_var to modify!

// Checks whether a map place is valid.
map_place_check_t map_place_invalid = bad_map_place;

// If non-empty, any floating vault's @ exit must land on these point.
point_vector map_anchor_points;

    if (check_place && bad_map_place(def, start, size))

    if (!map_bounds(start))
        return (false);
    if (check_place && map_place_invalid(def, start, size))

bool feature_marker_at(const coord_def &pos, dungeon_feature_type feat);

bool feature_marker_at(const coord_def &pos, dungeon_feature_type feat)
{
    std::vector<map_marker*> markers = env.markers.get_markers_at(pos);
    for (int i = 0, size = markers.size(); i < size; ++i)
    {
        map_marker *mark = markers[i];
        if (mark->get_type() == MAT_FEATURE &&
            dynamic_cast<map_feature_marker*>(mark)->feat == feat)
        {
            return (true);
        }
    }
    return (false);
}

    coord_def float_aligned_place() const;

    std::vector<coord_def> anchor_points() const;

}
point_vector map_def::anchor_points() const
{
    point_vector points;
    for (int y = 0, cheight = map.height(); y < cheight; ++y)
        for (int x = 0, cwidth = map.width(); x < cwidth; ++x)
            if (map.glyph(x, y) == '@')
                points.push_back(coord_def(x, y));
    return (points);

coord_def map_def::float_aligned_place() const
{
    const point_vector our_anchors = anchor_points();
    const coord_def fail(-1, -1);
#ifdef DEBUG_DIAGNOSTICS
    mprf(MSGCH_DIAGNOSTICS,
         "Aligning floating vault with %lu points vs %lu reference points",
         our_anchors.size(), map_anchor_points.size());
#endif
    // Mismatch in the number of points we have to align, bail.
    if (our_anchors.size() != map_anchor_points.size())
        return (fail);
    // Align first point of both vectors, then check that the others match.
    const coord_def pos = map_anchor_points[0] - our_anchors[0];
    for (int i = 1, psize = map_anchor_points.size(); i < psize; ++i)
        if (pos + our_anchors[i] != map_anchor_points[i])
            return (fail);
    // Looking good, check bounds.
    if (!map_bounds(pos) || !map_bounds(pos + size() - 1))
        return (fail);
    // Go us!
    return (pos);
}

    if (coinflip())
        pos = float_dock();

    if (!map_anchor_points.empty())
        pos = float_aligned_place();
    else
    {
        if (coinflip())
            pos = float_dock();

    if (pos.x == -1)
        pos = float_random_place();

        if (pos.x == -1)
            pos = float_random_place();
    }

#include <memory>

    // map(<map>, x, y) = glyph at (x,y), subject to map being
    // resolved and normalised.
    if (lua_gettop(ls) == 3 && lua_isnumber(ls, 2) && lua_isnumber(ls, 3))
    {
        const int gly = map->map.glyph(luaL_checkint(ls, 2),
                                          luaL_checkint(ls, 3));
        char buf[2] = "";
        buf[0] = gly;
        lua_pushstring(ls, buf);
        return (1);
    }

LUARET1(_dgn_is_wall, boolean,
        grid_is_wall(static_cast<dungeon_feature_type>(luaL_checkint(ls, 1))))

static std::auto_ptr<lua_datum> _dgn_map_bad_bounds_fn;

static bool _lua_map_place_invalid(const map_def &map,
                                   const coord_def &c,
                                   const coord_def &size)
{
#ifdef DEBUG_DIAGNOSTICS
    mprf(MSGCH_DIAGNOSTICS, "lua_map_place_invalid: (%d,%d) (%d,%d)",
         c.x, c.y, size.x, size.y);
#endif
    lua_stack_cleaner clean(_dgn_map_bad_bounds_fn->lua);
    // Push the Lua function onto the stack.
    _dgn_map_bad_bounds_fn->push();
    lua_State *ls = _dgn_map_bad_bounds_fn->lua;
    // Push map, pos.x, pos.y, size.x, size.y
    clua_push_map(ls, const_cast<map_def*>(&map));
    clua_push_coord(ls, c);
    clua_push_coord(ls, size);
    const int err = lua_pcall(ls, 5, 1, 0);
    // Lua error invalidates place.
    if (err)
    {
        mprf(MSGCH_ERROR, "Lua error: %s", lua_tostring(ls, -1));
        return (true);
    }
    return (lua_toboolean(ls, -1));
}
LUAFN(dgn_with_map_bounds_fn)
{
    CLua &vm(CLua::get_vm(ls));
    if (lua_gettop(ls) != 2 || !lua_isfunction(ls, 1) || !lua_isfunction(ls, 2))
        luaL_error(ls, "Expected map-bounds check fn and action fn.");
    _dgn_map_bad_bounds_fn.reset(new lua_datum(vm, 1, false));
    int err = 0;
    {
        unwind_var<map_place_check_t> mpc(map_place_invalid,
                                          _lua_map_place_invalid);
        // All set, call our friend, the second function.
        ASSERT(lua_isfunction(ls, -1));
        // Copy the function since pcall will pop it off.
        lua_pushvalue(ls, -1);
        // Use pcall to catch the error here, else unwind_var won't
        // happen when lua_call does its longjmp.
        err = lua_pcall(ls, 0, 1, 0);
        _dgn_map_bad_bounds_fn.reset(NULL);
    }
    if (err)
        lua_error(ls);
    return (1);
}
// Accepts any number of point coordinates and a function, binds the
// points as anchors that floating vaults must match and calls the
// function, returning the return value of the function.
LUAFN(dgn_with_map_anchors)
{
    const int top = lua_gettop(ls);
    int err = 0;
    {
        unwind_var<point_vector> uanchor(map_anchor_points);
        map_anchor_points.clear();
        int i;
        for (i = 1; i < top; i += 2)
        {
            if (lua_isnumber(ls, i) && lua_isnumber(ls, i + 1))
                map_anchor_points.push_back(
                    coord_def( lua_tointeger(ls, i),
                               lua_tointeger(ls, i + 1) ) );
        }
        ASSERT(lua_isfunction(ls, -1));
        lua_pushvalue(ls, -1);
        err = lua_pcall(ls, 0, 1, 0);
    }
    if (err)
        lua_error(ls);
    return (1);
}

    { "is_wall", _dgn_is_wall },

    { "with_map_bounds_fn", dgn_with_map_bounds_fn },
    { "with_map_anchors", dgn_with_map_anchors },

ENDMAP
NAME: ziggurat_loot_1
TAGS: ziggurat_loot_chamber allow_dup
ORIENT: float
MAP
cccccccccccc
c..........c
@..........c
c..........c
cccccccccccc

-- Deepest you can go in a ziggurat - at this point it's beyond
-- obvious that we're not challenging the player, and one could hope
-- she has enough loot by now.
ZIGGURAT_MAX = 81

  ziggurat_build_level(e)

  if crawl.game_started() then
    ziggurat_build_level(e)
  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

local zigstair = dgn.gridmark

                 if mons.muse == "eats_items" then
                   zig().level.jelly_protect = true
                 end

local function ziggurat_create_loot(c)

local function ziggurat_create_loot_at(c)

  local function is_free_space(p)
    return dgn.grid(p.x, p.y) == dgn.fnum("floor") and
      #dgn.items_at(p.x, p.y) == 0

  local function free_space_threshold(max)
    local function is_free_space(p)
      return dgn.grid(p.x, p.y) == dgn.fnum("floor") and
        #dgn.items_at(p.x, p.y) <= max
    end
    return is_free_space
  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, is_free_space)
    if p then
      fn(p)

    for i = 0, 20 do
      local p = dgn.find_adjacent_point(c, free_space_threshold(i), passable)
      if p then
        fn(p)
        break
      end

local function ziggurat_create_loot_vault(entry, exit)
  local inc = (exit - entry):sgn()
  local function find_door_spot(p)
    while not dgn.is_wall(dgn.grid(p.x, p.y)) do
      p = p + inc
    end
    return p
  end
  -- Place a door.
  local doorplace = find_door_spot(exit, inc)

  -- Closed door with the permarock wall feature marker.
  dgn.gridmark(doorplace.x, doorplace.y, "closed_door", "permarock_wall")
  local connect_point = doorplace + inc
  local map = dgn.map_by_tag("ziggurat_loot_chamber", false)
  local function loot_fallback()
    crawl.mpr("Failed to create loot vault, giving up", "diagnostic")
    -- FAIL, generate loot the usual way.
    ziggurat_create_loot_at(exit)
  end
  if not map then
    return loot_fallback()
  end
  local function place_loot_chamber()
    return dgn.place_map(map, false, true)
  end
  local function bad_loot_bounds(map, px, py, xs, ys)
    local vc = dgn.point(px + math.floor(xs / 2),
                         py + math.floor(ys / 2))
    local linc = (vc - exit):sgn()
    -- The map's positions should be at the same increment to the exit
    -- as the exit is to the entrance, else reject the place.
    return not (inc == linc)
  end
  local function connect_loot_chamber()
    return dgn.with_map_bounds_fn(bad_loot_bounds, place_loot_chamber)
  end
  local res = dgn.with_map_anchors(connect_point.x, connect_point.y,
                                   connect_loot_chamber)
  if not res then
    loot_fallback()
  else
    ziggurat_create_loot_at(connect_point)
  end
end
local function ziggurat_create_loot(entrance, exit)
  if zig().level.jelly_protect then
    ziggurat_create_loot_vault(entrance, exit)
  else
    ziggurat_create_loot_at(exit)
  end
end

  local entry = { x = x1, y = c.y }
  local exit = { x = x2, y = c.y }

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

  zigstair(exit.x, exit.y, "stone_stairs_down_i", zig_go_deeper)

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

  ziggurat_create_loot(exit)

  ziggurat_create_loot(entry, exit)

point_metatable.__index = point_metatable

end
local function sgn(x)
  if x < 0 then
    return -1
  elseif x > 0 then
    return 1
  else
    return 0
  end

point_metatable.sgn = function (p)
                        return dgn.point(sgn(p.x), sgn(p.y))
                      end

point_metatable.__eq = function (a, b)
                         return a.x == b.x and a.y == b.y
                       end

end
function dgn.gridmark(x, y, grid, marker)
  dgn.grid(x, y, grid)
  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

    const lua_datum &operator = (const lua_datum &other);

public:
    CLua &lua;

    CLua &lua;

    void set_from(const lua_datum &o);

void clua_push_coord(lua_State *ls, const coord_def &c);

    lua_stack_cleaner clean(ls);

static const char *_monuse_names[] =
{
    "nothing", "eats_items", "open_doors", "starting_equipment",
    "weapons_armour", "magic_items"
};
static const char *_monuse_to_str(mon_itemuse_type ityp)
{
    ASSERT(ARRAYSZ(_monuse_names) == NUM_MONUSE);
    return _monuse_names[ityp];
}
MDEF(muse)
{
    if (const monsterentry *me = mons->find_monsterentry())
    {
        PLUARET(string, _monuse_to_str(me->gmon_use));
    }
    return (0);
}

    { "muse", l_mons_muse },

}
void clua_push_coord(lua_State *ls, const coord_def &c)
{
    lua_pushnumber(ls, c.x);
    lua_pushnumber(ls, c.y);

    : need_cleanup(true), lua(_lua)

    : lua(_lua), need_cleanup(true)

    : need_cleanup(true), lua(o.lua)

    : lua(o.lua), need_cleanup(true)
{
    set_from(o);
}
void lua_datum::set_from(const lua_datum &o)

    need_cleanup = true;
}
const lua_datum &lua_datum::operator = (const lua_datum &o)
{
    if (this != &o)
    {
        cleanup();
        set_from(o);
    }
    return (*this);