#include "state.h"

}
static int dgn_map_size(lua_State *ls)
{
    MAP(ls, 1, map);
    lua_pushnumber(ls, map->map.width());
    lua_pushnumber(ls, map->map.height());
    return (2);

    viewwindow(true, false);

    if (crawl_state.need_save)
        viewwindow(true, false);

    viewwindow(true, false);

    if (crawl_state.need_save)
        viewwindow(true, false);

        lua_pushlightuserdata(ls, const_cast<map_def*>(map));

        clua_push_map(ls, const_cast<map_def*>(map));

    if (!lua_isuserdata(ls, 1))
        luaL_argerror(ls, 1, "Expected map");
    const map_def *map = static_cast<map_def *>(lua_touserdata(ls, 1));

    MAP(ls, 1, map);

    lua_pushboolean(ls, dgn_place_map(map, clobber, no_exits, where));

    if (dgn_place_map(map, clobber, no_exits, where) && !Level_Vaults.empty())
        lua_pushlightuserdata(ls, &Level_Vaults[Level_Vaults.size() - 1]);
    else
        lua_pushnil(ls);
    return (1);
}
LUAFN(_dgn_in_vault)
{
    GETCOORD(c, 1, 2, map_bounds);
    const int mask = lua_isnone(ls, 3) ? MMT_VAULT : lua_tointeger(ls, 3);
    lua_pushboolean(ls, dgn_Map_Mask(c) & mask);

LUAFN(_dgn_resolve_map)
{
    if (lua_isnil(ls, 1))
    {
        lua_pushnil(ls);
        return (1);
    }

    MAP(ls, 1, map);
    const bool check_collisions = _lua_boolean(ls, 2, true);
    // Save the vault_placement into Temp_Vaults because the map_def
    // will need to be alive through to the end of dungeon gen.
    Temp_Vaults.push_back(vault_placement());
    vault_placement &place(Temp_Vaults[Temp_Vaults.size() - 1]);
    if (vault_main(place, map, check_collisions) != MAP_NONE)
    {
        clua_push_map(ls, &place.map);
        lua_pushlightuserdata(ls, &place);
    }
    else
    {
        lua_pushnil(ls);
        lua_pushnil(ls);
    }
    return (2);
}
LUAFN(_dgn_reuse_map)
{
    if (!lua_isuserdata(ls, 1))
        luaL_argerror(ls, 1, "Expected vault_placement");
    vault_placement &vp(
        *static_cast<vault_placement*>(lua_touserdata(ls, 1)));
    COORDS(place, 2, 3);
    const bool flip_horiz = _lua_boolean(ls, 4, false);
    const bool flip_vert = _lua_boolean(ls, 5, false);
    // 1 for clockwise, -1 for anticlockwise, 0 for no rotation.
    const int rotate_dir = lua_isnone(ls, 6) ? 0 : luaL_checkint(ls, 6);
    const bool register_place = _lua_boolean(ls, 7, true);
    const bool register_vault = register_place && _lua_boolean(ls, 8, false);
    if (flip_horiz)
        vp.map.hmirror();
    if (flip_vert)
        vp.map.vmirror();
    if (rotate_dir)
        vp.map.rotate(rotate_dir == 1);
    vp.size = vp.map.map.size();
    // draw_at changes vault_placement.
    vp.draw_at(place);
    if (register_place)
        dgn_register_place(vp, register_vault);
    return (0);
}

    { "mapsize", dgn_map_size },

    { "reuse_map", _dgn_reuse_map },
    { "resolve_map", _dgn_resolve_map },
    { "in_vault", _dgn_in_vault },

extern map_mask dgn_Map_Mask;
extern bool Generating_Level;
extern std::string dgn_Layout_Type;
extern std::set<std::string> Level_Unique_Maps;
extern std::set<std::string> Level_Unique_Tags;

extern map_mask dgn_Map_Mask;
extern bool Generating_Level;
extern std::string dgn_Layout_Type;
extern std::set<std::string> Level_Unique_Maps;
extern std::set<std::string> Level_Unique_Tags;
extern std::vector<vault_placement> Level_Vaults;
extern std::vector<vault_placement> Temp_Vaults;

void dgn_register_place(const vault_placement &place, bool register_vault);

std::vector<vault_placement> Temp_Vaults;

        dgn_level_vetoed = false;
        Level_Unique_Maps.clear();
        Level_Unique_Tags.clear();

    Temp_Vaults.clear();

    if (map.has_tag("uniq"))

    if (map.has_tag("luniq"))

static void _register_place(const vault_placement &place)

void dgn_register_place(const vault_placement &place, bool register_vault)

    _dgn_register_vault(place.map);

    if (register_vault)
        _dgn_register_vault(place.map);

    dgn_level_vetoed = false;
    Level_Unique_Maps.clear();
    Level_Unique_Tags.clear();

    _register_place(place);

    dgn_register_place(place, true);

    _register_place(place);

    dgn_register_place(place, true);

# Ziggurat pillars are handled specially in ziggurat.lua. In particular:
# - ziggurat pillars do not need allow_dup. The pillar map is never 
#   registered as used.
# - ziggurat pillars cannot use map markers.

cc

c 

TAGS: ziggurat_pillar

TAGS: ziggurat_pillar centered

#######################################################################

  local floor = dgn.fnum("floor")

  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

  local map, vplace = dgn.resolve_map(dgn.map_by_tag("ziggurat_pillar"))
  if not map then
    return
  end
  local name = dgn.name(map)
  local size = dgn.point(dgn.mapsize(map))
  -- Does the pillar want to be centered?
  local centered = string.find(dgn.tags(map), " centered ")
  local function good_place(p)
    local function good_square(where)
      return dgn.grid(where.x, where.y) == floor

    return nil

    return dgn.rectangle_forall(p, p + size - 1, good_square)

  local function place_pillar()
    if centered then
      if good_place(c) then
        return dgn.place_map(map, false, true, c.x, c.y)
      end
    else
      for i = 1, 100 do
        local offset = range(-15, -size.x)
        local offsets = {
          dgn.point(offset, offset) - size + 1,
          dgn.point(offset - size.x + 1, -offset),
          dgn.point(-offset, -offset),
          dgn.point(-offset, offset - size.y + 1)
        }

  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)

        offsets = util.map(function (o)
                             return o + c
                           end, offsets)
        if util.forall(offsets, good_place) then
          local function replace(at, hflip, vflip)
            dgn.reuse_map(vplace, at.x, at.y, hflip, vflip)
          end
          replace(offsets[1], false, false)
          replace(offsets[2], false, true)
          replace(offsets[3], true, false)
          replace(offsets[4], false, true)
          return true
        end
      end

  for i = 1, crawl.random_range(1,3) do
    local p = pillar_spot()
    if p then
      place_pillar(p)

  for i = 1, 5 do
    if place_pillar() then
      break

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

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

  local entry = { x = x1, y = cy }
  local exit = { x = x2, y = cy }

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

  ziggurat_place_pillars { x = cx, y = cy }

  ziggurat_place_pillars(c)

  dgn.colour_map(function (x, y)
                   return dgn.grid(x, y) == dgn.fnum("stone_wall")
                 end,
                 zig().colour)

  local function needs_colour(p)
    return not dgn.in_vault(p.x, p.y)
      and dgn.grid(p.x, p.y) == dgn.fnum("stone_wall")
  end

  dgn.colour_map(needs_colour, zig().colour)

end
function util.forall(list, pred)
  for _, value in ipairs(list) do
    if not pred(value) then
      return false
    end
  end
  return true

function util.exists(list, pred)
  for _, value in ipairs(list) do
    if pred(value) then
      return true
    end
  end
  return false
end

--------------------------------------------------------------------------
-- point.lua
--------------------------------------------------------------------------
local point_metatable = { }
function dgn.point(x, y)
  local pt = { x = x, y = y }
  setmetatable(pt, point_metatable)
  return pt
end
point_metatable.__add = function (a, b)
                          if type(b) == "number" then
                            return dgn.point(a.x + b, a.y + b)
                          else
                            return dgn.point(a.x + b.x, a.y + b.y)
                          end
                        end
point_metatable.__sub = function (a, b)
                          if type(b) == "number" then
                            return dgn.point(a.x - b, a.y - b)
                          else
                            return dgn.point(a.x - b.x, a.y - b.y)
                          end
                        end
point_metatable.__div = function (a, b)
                          if type(b) ~= "number" then
                            error("Can only divide by numbers.")
                          end
                          return dgn.point(math.floor(a.x / b),
                                           math.floor(a.y / b))
                        end
point_metatable.__mul = function (a, b)
                          if type(b) ~= "number" then
                            error("Can only multiply by numbers.")
                          end
                          return dgn.point(a.x * b, a.y * b)
                        end
point_metatable.__unm = function (a)
                          return dgn.point(-a.x, -a.y)
                        end
point_metatable.__concat = function (pre, post)
                             local function pstr(p)
                               return "(" .. p.x .. "," .. p.y .. ")"
                             end
                             if getmetatable(pre) == point_metatable then
                               return pstr(pre) .. post
                             else
                               return pre .. pstr(post)
                             end
                           end

require("clua/point.lua")

      if fselect(x, y) then

      if fselect(dgn.point(x, y)) then

      end
    end
  end
end
-- Returns true if fpred returns true for all squares in the rectangle
-- whose top-left corner is tl and bottom right corner is br (br.x >=
-- tl.x and br.y >= tl.y).
function dgn.rectangle_forall(tl, br, fpred)
  for x = tl.x, br.x do
    for y = tl.y, br.y do
      if not fpred(dgn.point(x, y)) then
        return false

  return true

static int  _clua_require(lua_State *);

    lua_register(_state, "require", _clua_require);

static int _clua_require(lua_State *ls)
{
    const char *file = luaL_checkstring(ls, 1);
    if (!file)
        return (0);
    CLua &vm(CLua::get_vm(ls));
    if (vm.execfile(file, false, false) != 0)
        luaL_error(ls, vm.error.c_str());
    lua_pushboolean(ls, true);
    return (1);
}