int absdepth() const;

    int absdepth() const;

    return absdungeon_depth(branch, depth);

    switch (level_type)
    {
    case LEVEL_DUNGEON:
        return absdungeon_depth(branch, depth);
    case LEVEL_PANDEMONIUM:
        return 52;
    case LEVEL_ABYSS:
        return 51;
    default:
        // No true notion of depth here.
        return you.your_level;
    }

    {
        switch(place.level_type)
        {
        case LEVEL_DUNGEON:
            level_number = absdungeon_depth(place.branch, place.depth);
            break;
        case LEVEL_ABYSS:
            level_number = 51;
            break;
        case LEVEL_PANDEMONIUM:
            level_number = 52;
            break;
        default:
            level_number = you.your_level;
        }
    }

        level_number = place.absdepth();

    {
        switch (place.level_type)
        {
        case LEVEL_DUNGEON:
            level_number = absdungeon_depth(place.branch, place.depth);
            break;
        case LEVEL_ABYSS:
            level_number = 51;
            break;
        case LEVEL_PANDEMONIUM:
            level_number = 52;
            break;
        default:
            level_number = you.your_level;
        }
    }

        level_number = place.absdepth();

monster_type pick_random_monster(const level_id &place);

}
monster_type pick_random_monster(const level_id &place)
{
    int level = place.absdepth();
    return pick_random_monster(place, level, level);

        case LEVEL_PANDEMONIUM:
            mg.power = 52;     // sigh..
            break;
        case LEVEL_ABYSS:
            mg.power = 51;
            break;
        case LEVEL_DUNGEON:
        default:
            mg.power = you.your_level;
            break;

    case LEVEL_PANDEMONIUM:
    case LEVEL_ABYSS:
        mg.power = level_id(mg.level_type).absdepth();
        break;
    case LEVEL_DUNGEON:
    default:
        mg.power = you.your_level;
        break;

        monster_level = ((mons_abyss(mcls)) ? 51 : 0);

        monster_level = ((mons_abyss(mcls)) ? place.absdepth() : 0);

        monster_level = ((mons_pan(mcls)) ? 52 : 0);

        monster_level = ((mons_pan(mcls)) ? place.absdepth() : 0);

    bool band;

          patrolling(false), colour(BLACK), items()

          patrolling(false), band(false), colour(BLACK), items()

        mspec.band           = strip_tag(mon_str, "band");

        if (make_item_fixed_artefact( item, (item_level == 51) ))

        if (make_item_fixed_artefact(
                item,
                (item_level == level_id(LEVEL_ABYSS).absdepth()) ))

#include "mon-util.h"

#define LUAFN(name) static int name(lua_State *ls)

#define COORDS(c, p1, p2)                                \

#define GETCOORD(c, p1, p2, boundfn)                      \

    if (!in_bounds(c))                                    \
        luaL_error(                                         \

    if (!boundfn(c))                                        \
        luaL_error(                                             \

            make_stringf("Point (%d,%d) is out of map bounds",  \
                         c.x, c.y).c_str());

            make_stringf("Point (%d,%d) is out of bounds",      \
                         c.x, c.y).c_str());                    \
    else ;                                                      \
#define COORDS(c, p1, p2)                                \
    GETCOORD(c, p1, p2, in_bounds)

    COORDS(c, 1, 2);

    GETCOORD(c, 1, 2, map_bounds);

static int dgn_change_floor_colour(lua_State *ls)

static int _lua_colour(lua_State *ls, int ndx,
                       int forbidden_colour = -1)

    const char *s = luaL_checkstring(ls, 1);
    int colour = str_to_colour(s);
    if (colour < 0 || colour == BLACK)

    if (lua_isnumber(ls, ndx))
        return lua_tonumber(ls, ndx);
    else if (const char *s = luaL_checkstring(ls, ndx))

        std::string error;

        const int colour = str_to_colour(s);

        if (colour == BLACK)

        if (colour < 0 || colour == forbidden_colour)

            error = "Can't set floor to black.";
        }
        else
        {
            error = "No such colour as '";
            error += s;
            error += "'";

            std::string error;
            if (colour == forbidden_colour)
                error = std::string("Can't set floor to ") + s;
            else
                error = std::string("Unknown colour: '") + s + "'";
            return luaL_argerror(ls, 1, error.c_str());

        luaL_argerror(ls, 1, error.c_str());
        return (0);

        return (colour);

    return luaL_argerror(ls, ndx, "Expected colour name or number");
}

static int dgn_change_floor_colour(lua_State *ls)
{
    const int colour = _lua_colour(ls, 1, BLACK);

    const char *s = luaL_checkstring(ls, 1);
    int colour = str_to_colour(s);
    if (colour < 0 || colour == BLACK)
    {
        std::string error;
        if (colour == BLACK)
        {
            error = "Can't set rock to black.";
        }
        else
        {
            error = "No such colour as '";
            error += s;
            error += "'";
        }
        luaL_argerror(ls, 1, error.c_str());
        return (0);
    }

    const int colour = _lua_colour(ls, 1, BLACK);

    return (0);
}

    return (0);

static int dgn_colour_at(lua_State *ls)
{
    COORDS(c, 1, 2);
    if (!lua_isnone(ls, 3))
        env.grid_colours(c) = _lua_colour(ls, 3);
    PLUARET(string, colour_to_str(env.grid_colours(c)).c_str());

    else
        lua_pushnil(ls);
    return (1);
}
static int dgn_mons_at(lua_State *ls)
{
    COORDS(c, 1, 2);
    monsters *mon = monster_at(c);
    if (mon && mon->alive())
        push_monster(ls, mon);

    return (1);
}

static int dgn_items_at(lua_State *ls)
{
    COORDS(c, 1, 2);
    lua_push_items(ls, env.igrid(c));

static int _dgn_is_passable(lua_State *ls)
{
    COORDS(c, 1, 2);
    lua_pushboolean(ls, is_travelsafe_square(c.x, c.y, false, true));
    return (1);
}

    return (0);
}
static int dgn_create_monster(lua_State *ls)
{
    COORDS(c, 1, 2);
    if (const char *spec = lua_tostring(ls, 3))
    {
        mons_list mlist;
        const std::string err = mlist.add_mons(spec);
        if (!err.empty())
            luaL_error(ls, err.c_str());
        for (int i = 0, size = mlist.size(); i < size; ++i)
        {
            mons_spec mspec = mlist.get_monster(i);
            if (dgn_place_monster(mspec, you.your_level, c,
                                  false, false, false))
            {
                push_monster(ls, &menv[mgrd(c)]);
                return (1);
            }
        }
    }
    lua_pushnil(ls);
    return (1);
}
static int dgn_create_item(lua_State *ls)
{
    COORDS(c, 1, 2);
    if (const char *spec = lua_tostring(ls, 3))
    {
        item_list ilist;
        const std::string err = ilist.add_item(spec);
        if (!err.empty())
            luaL_error(ls, err.c_str());
        const int level =
            lua_isnumber(ls, 4) ? lua_tointeger(ls, 4) : you.your_level;
        dgn_place_multiple_items(ilist, c, level);
        link_items();
    }

#define BRANCH(br, pos)                                                 \
    const char *branch_name = luaL_checkstring(ls, pos);                \
    branch_type req_branch_type = str_to_branch(branch_name);           \
    if (req_branch_type == NUM_BRANCHES)                                \
        luaL_error(ls, "Expected branch name");                         \
    Branch &br = branches[req_branch_type]
#define BRANCHFN(name, type, expr)   \
    LUAFN(dgn_br_##name) {           \
    BRANCH(br, 1);                   \
    PLUARET(type, expr);             \
    }

BRANCHFN(floorcol, number, br.floor_colour)
BRANCHFN(rockcol, number, br.rock_colour)
BRANCHFN(has_shops, boolean, br.has_shops)
BRANCHFN(has_uniques, boolean, br.has_uniques)
BRANCHFN(parent_branch, string,
         br.parent_branch == NUM_BRANCHES ? ""
         : branches[br.parent_branch].abbrevname)

    { "colour_at", dgn_colour_at },

    { "mons_at", dgn_mons_at },
    { "items_at", dgn_items_at },

    { "is_passable", _dgn_is_passable },

    { "create_monster", dgn_create_monster },
    { "create_item", dgn_create_item },
    { "br_floorcol", dgn_br_floorcol },
    { "br_rockcol", dgn_br_rockcol },
    { "br_has_shops", dgn_br_has_shops },
    { "br_has_uniques", dgn_br_has_uniques },
    { "br_parent_branch", dgn_br_parent_branch },

void lua_push_items(lua_State *ls, int link)
{
    lua_newtable(ls);
    int index = 0;
    for ( ; link != NON_ITEM; link = mitm[link].link)
    {
        lua_pushlightuserdata(ls, &mitm[link]);
        lua_rawseti(ls, -2, ++index);
    }
}

class item_list;
void dgn_place_multiple_items(item_list &list,
                              const coord_def& where,
                              int level);

static void _dgn_place_multiple_items(item_list &list,
                                      const coord_def& where, int level)

void dgn_place_multiple_items(item_list &list,
                              const coord_def& where, int level)

        const bool m_band           = mspec.band;

                lev = absdungeon_depth(mspec.place.branch, mspec.place.depth);

                lev = mspec.place.absdepth();

        if (m_band)
            mg.flags |= MG_PERMIT_BANDS;

        if (mindex != -1)
        {
            if (mspec.items.size() > 0)
                _dgn_give_mon_spec_items(mspec, mindex, mid, monster_level);
        }

        if (mindex != -1 && mspec.items.size() > 0)
            _dgn_give_mon_spec_items(mspec, mindex, mid, monster_level);

        _dgn_place_multiple_items(items, where, level_number);

        dgn_place_multiple_items(items, where, level_number);

-- 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

local wall_colours = {
  "blue", "red", "lightblue", "magenta", "green", "white"
}
local function wall_colour()
  return util.random_from(wall_colours)
end
local function random_floor_colour()
  return wall_colour()

  -- Any given ziggurat will use the same builder for all its levels.

  z.colour = wall_colour()
  z.level  = { }

-- Returns a function that changes the depth in the ziggurat to the depth
-- specified.
function zig_depth_increment()
  zig().depth = zig().depth + 1
  zig().level = { }
end

    onclimb = zig_depth_increment()

    onclimb = zig_depth_increment

end
local function map_area()
  local base_area = 20 + 8 * zig_depth()
  return 2 * base_area + crawl.random2(base_area)
end
local function clamp_in(val, low, high)
  if val < low then
    return low
  elseif val > high then
    return high
  else
    return val
  end
end
local function clamp_in_bounds(x, y)
  return clamp_in(x, 1, dgn.GXM - 2), clamp_in(y, 1, dgn.GYM - 2)
end
local function rectangle_dimensions()
  local area = map_area()
  local cx, cy = dgn.GXM / 2, dgn.GYM / 2
  local asqrt = math.sqrt(area)
  local b = crawl.random_range(1 + asqrt / 2, asqrt + 1)
  local a = math.floor((area + b - 1) / b)
  local a2 = math.floor(a / 2) + (a % 2);
  local b2 = math.floor(b / 2) + (b % 2);
  local x1, y1 = clamp_in_bounds(cx - a2, cy - b2)
  local x2, y2 = clamp_in_bounds(cx + a2, cy + b2)
  return x1, y1, x2, y2
end
local mons_populations = {
  "Elf:7", "Orc:4", "Vault:8", "Slime:6",
  "Snake:5", "Lair:10", "Tomb:3", "Crypt:5",
  "Abyss", "Shoal:5", "Pan"
}
local function set_floor_colour(colour)
  if not zig().level.floor_colour then
    zig().level.floor_colour = colour
    dgn.change_floor_colour(colour)
  end
end
local function set_random_floor_colour()
  set_floor_colour( random_floor_colour() )
end
local function mons_random_gen(x, y, nth)
  set_random_floor_colour()
  return dgn.create_monster(x, y, "place:" ..
                            util.random_from(mons_populations))
end
local function mons_drac_gen(x, y, nth)
  set_random_floor_colour()
  return dgn.create_monster(x, y, "random draconian")
end
local function mons_panlord_gen(x, y, nth)
  set_random_floor_colour()
  if nth == 1 then
    return dgn.create_monster(x, y, "pandemonium lord band")
  else
    return dgn.create_monster(x, y, "place:Pan")
  end

local mons_generators = {
  mons_random_gen,
  mons_drac_gen,
  mons_panlord_gen
}

local function monster_creator_fn(arg)
  if type(arg) == "string" then
    local _, _, branch = string.find(arg, "^(%w+):")
    return function (x, y, nth)
             if branch then
               set_floor_colour(dgn.br_floorcol(branch))
             end
             return dgn.create_monster(x, y, "place:" .. arg)
           end
  else
    return arg
  end
end
local monster_creators =
  util.map(monster_creator_fn, util.catlist(mons_populations, mons_generators))
local function ziggurat_vet_monster(fn)
  return function (x, y, nth)
           while true do
             local mons = fn(x, y, nth)
             if mons then
               if mons.experience == 0 then
                 mons.dismiss()
               else
                 -- Monster is ok!
                 return mons
               end
             end
           end
         end
end
local function choose_monster_set()
  return ziggurat_vet_monster(util.random_from(monster_creators))
end
local function ziggurat_create_monsters(p)
  local depth = zig_depth()
  local hd_pool = depth * (depth + 8)
  local function mons_place_p(point)
    return not dgn.mons_at(point.x, point.y)
  end
  local mfn = choose_monster_set()
  local nth = 1
  -- No monsters
  while hd_pool > 0 do
    local place = dgn.find_adjacent_point(p, mons_place_p)
    local mons = mfn(place.x, place.y, nth)
    if mons then
      nth = nth + 1
      hd_pool = hd_pool - mons.hd
    end
  end
end
local function flip_rectangle(x1, y1, x2, y2)
  local cx = math.floor((x1 + x2) / 2)
  local cy = math.floor((y1 + y2) / 2)
  local nx1 = cx + y1 - cy
  local nx2 = cx + y2 - cy
  local ny1 = cy + x1 - cx
  local ny2 = cy + x2 - cx
  return { nx1, ny1, nx2, ny2 }
end
local function ziggurat_create_loot(c)
  local nloot = zig_depth()
  local depth = zig_depth()
  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
  end
  local function free_space_do(fn)
    local p = dgn.find_adjacent_point(c, is_free_space)
    if p then
      fn(p)
    end
  end
  for i = 1, nloot do
    if crawl.one_chance_in(depth) then
      for j = 1, 4 do
        free_space_do(function (p)
                        dgn.create_item(p.x, p.y, "*", 20)
                      end)
      end
    else
      free_space_do(function (p)
                      dgn.create_item(p.x, p.y, "|", 20)
                    end)
    end
  end
end

  -- FIXME: Cool code goes here.
  local x1, y1 = 20, 20
  local x2, y2 = dgn.GXM - 20, dgn.GYM - 20

  dgn.fill_area(0, 0, dgn.GXM - 1, dgn.GYM - 1, "stone_wall")
  local x1, y1, x2, y2 = rectangle_dimensions()

  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")

  dgn.fill_area(unpack( util.catlist(flip_rectangle(x1, y1, x2, y2),
                                     { "floor" }) ) )
  local cy = math.floor((y1 + y2) / 2)
  local entry = { x = x1, y = cy }
  local exit = { x = x2, y = cy }
  if zig_depth() % 2 == 0 then
    entry, exit = exit, entry
  end

  crawl.mpr("Ziggurat depth is now " .. zig_depth())

  zigstair(entry.x, entry.y, "stone_arch", "stone_stairs_up_i")
  zigstair(exit.x, exit.y, "stone_stairs_down_i", zig_go_deeper)
  grid(exit.x, exit.y + 1, "exit_portal_vault")
  grid(exit.x, exit.y - 1, "exit_portal_vault")
  ziggurat_create_loot(exit)
  --ziggurat_create_monsters(exit)
  dgn.colour_map(function (x, y)
                   return dgn.grid(x, y) == dgn.fnum("stone_wall")
                 end,
                 zig().colour)
  crawl.mpr("Ziggurat depth is now " .. zig_depth(), "diagnostic")

------------------------------------------------------------------------------
-- util.lua
-- Lua utilities.
------------------------------------------------------------------------------
util = { }
function util.catlist(...)
  local res = { }
  local tables = { ... }
  if #tables == 1 then
    return tables[1]
  else
    for _, tab in ipairs(tables) do
      for _, val in ipairs(tab) do
        table.insert(res, val)
      end
    end
  end
  return res
end
function util.cathash(...)
  local res = { }
  local tables = { ... }
  if #tables == 1 then
    return tables[1]
  else
    for _, tab in ipairs(tables) do
      for key, val in ipairs(tab) do
        res[key] = val
      end
    end
  end
  return res
end
function util.map(fn, ...)
  local lists = { ... }
  local res = { }
  if #lists == 0 then
    return res
  elseif #lists == 1 then
    for _, val in ipairs(lists[1]) do
      table.insert(res, fn(val))
    end
  else
    for i = 1, #lists[1] do
      local args = { }
      for _, list in ipairs(lists) do
        if not list[i] then
          break
        end
        table.insert(args, list[i])
      end
      if #args < #lists then
        break
      end
      table.insert(res, fn(unpack(args)))
    end
  end
  return res
end
function util.random_from(list)
  return list[ crawl.random2(#list) + 1 ]
end

dgn.f_rockwall = dgn.feature_number("rock_wall")
dgn.f_floor = dgn.feature_number("floor")

dgn.f_map = { }

end
function dgn.fnum(name)
  local fnum = dgn.f_map[name]
  if not fnum then
    fnum = dgn.feature_number(name)
    dgn.f_map[name] = fnum
  end
  return fnum

   return dgn.places_connected(map, dgn.gly_points, 

   return dgn.places_connected(map, dgn.gly_points,

-- Replaces all features matching 

-- Replaces all features matching

function dgn.adjacent_points(c, faccept)
  local plist = { }
  local compass = {
    { 0, -1 }, { 1, 0 }, { 0, 1 }, { -1, 0 },
    { -1, -1 }, { 1, -1 }, { 1, 1 }, { -1, 1 }
  }
  for _, cp in ipairs(compass) do
    local p = { x = c.x + cp[1], y = c.y + cp[2] }
    if dgn.in_bounds(p.x, p.y) and faccept(p) then
      table.insert(plist, p)
    end
  end
  return plist
end
function dgn.find_adjacent_point(c, fcondition, fpassable)
  local mapped_points = { }
  local function pstr(p)
    return p.x .. "," .. p.y
  end
  local function seen(p)
    return mapped_points[pstr(p)]
  end
  local function record(p, val)
    mapped_points[pstr(p)] = val or 1
  end
  if not fpassable then
    fpassable = function (p)
                  return dgn.is_passable(p.x, p.y)
                end
  end
  local iter_points = { { }, { } }
  local iter = 1
  table.insert(iter_points[iter], c)
  local function next_iter()
    if iter == 1 then
      return 2
    else
      return 1
    end
  end
  local distance = 1
  record(c, distance)
  while #iter_points[iter] > 0 do
    for _, p in ipairs(iter_points[iter]) do
      if fcondition(p) then
        return p
      end
      -- Add adjacent points to queue.
      for _, np in ipairs(dgn.adjacent_points(p, fpassable)) do
        if not seen(np) then
          table.insert(iter_points[next_iter()], np)
          record(np, distance + 1)
        end
      end
    end
    iter_points[iter] = { }
    iter = next_iter()
    distance = distance + 1
  end
  -- No suitable point.
  return nil
end
function dgn.colour_map(fselect, colour)
  for x = 0, dgn.GXM - 1 do
    for y = 0, dgn.GYM - 1 do
      if fselect(x, y) then
        dgn.colour_at(x, y, colour)
      end
    end
  end
end

void lua_push_items(lua_State *ls, int link);

#include "monstuff.h"

    execfile("clua/util.lua", true, true);

}
void lua_push_items(lua_State *ls, int link)
{
    lua_newtable(ls);
    int index = 0;
    for ( ; link != NON_ITEM; link = mitm[link].link)
    {
        lua_pushlightuserdata(ls, &mitm[link]);
        lua_rawseti(ls, -2, ++index);
    }

#define MDEF(name)                                                      \
    static int l_mons_##name(lua_State *ls, monsters *mons,             \
                             const char *attr)                         \

static int l_mons_name(lua_State *ls, monsters *mons, const char *attr)

#define MDEFN(name, closure)                    \
    static int l_mons_##name(lua_State *ls, monsters *mons, const char *attrs) \
    {                                                                   \
    lua_pushlightuserdata(ls, mons);                                    \
    lua_pushcclosure(ls, l_mons_do_dismiss, 1);                         \
    return (1);                                                         \
    }
#define ASSERT_DLUA \
    do {                                                            \
        if (CLua::get_vm(ls).managed_vm)                            \
            luaL_error(ls, "Operation forbidden in end-user script");   \
    } while (false)
MDEF(name)

    lua_pushstring(ls, mons_type_name(mons->type, DESC_PLAIN).c_str());
    return (1);

    PLUARET(string, mons_type_name(mons->type, DESC_PLAIN).c_str());

static int l_mons_x(lua_State *ls, monsters *mons, const char *attr)

MDEF(x)
{
    PLUARET(number, int(mons->pos().x) - int(you.pos().x));
}
MDEF(y)
{
    PLUARET(number, int(mons->pos().y) - int(you.pos().y));
}
MDEF(hd)
{
    PLUARET(number, mons->hit_dice);
}
static int l_mons_do_dismiss(lua_State *ls)

    lua_pushnumber(ls, int(mons->pos().x) - int(you.pos().x));
    return (1);

    // dismiss is only callable from dlua, not from managed VMs (i.e.
    // end-user scripts cannot dismiss monsters).
    ASSERT_DLUA;
    monsters *mons =
        util_get_userdata<monsters>(ls, lua_upvalueindex(1));
    if (mons->alive())
    {
        mons->flags |= MF_HARD_RESET;
        monster_die(mons, KILL_DISMISSED, NON_MONSTER);
    }
    return (0);

static int l_mons_y(lua_State *ls, monsters *mons, const char *attr)

MDEFN(dismiss, do_dismiss)
MDEF(experience)

    lua_pushnumber(ls, int(mons->pos().y) - int(you.pos().y));
    return (1);

    ASSERT_DLUA;
    PLUARET(number, exper_value(mons));

    { "hd"  , l_mons_hd   },
    { "dismiss", l_mons_dismiss },
    { "experience", l_mons_experience },

    {
        switch(place.level_type)
        {
        case LEVEL_DUNGEON:
            level_number = absdungeon_depth(place.branch, place.depth);
            break;
        case LEVEL_ABYSS:
            level_number = 51;
            break;
        case LEVEL_PANDEMONIUM:
            level_number = 52;
            break;
        default:
            level_number = you.your_level;
        }
    }

        level_number = place.absdepth();

    {
        switch(place.level_type)
        {
        case LEVEL_DUNGEON:
            level_number = absdungeon_depth(place.branch, place.depth);
            break;
        case LEVEL_ABYSS:
            level_number = 51;
            break;
        case LEVEL_PANDEMONIUM:
            level_number = 52;
            break;
        default:
            level_number = you.your_level;
        }
    }

        level_number = place.absdepth();

        int level = 51;
        monster_type mons = pick_random_monster(level_id(LEVEL_ABYSS), level,
                                                level);

        monster_type mons = pick_random_monster(level_id(LEVEL_ABYSS));

          If a monster is a member of a band, you can request that it
          be eligible for band members by adding the keyword "band" to
          the name. For instance:
              MONS: orc warlord band

          Specifying "band" doesn't force bands to be placed - it
          requests that the game use the normal chances of creating a
          band. If you use "band", leave some empty space around the
          monster for its band members to be placed.

BAR may *not* end in _entry (otherwise the level builder assumes that 

BAR may *not* end in _entry (otherwise the level builder assumes that