fiddlerwoaroof/crawl - Change RXYHE3C7R3EGCRZEJT2ZO4ALLRDR3HF66VHZZNF7TT3DFWZ6BJCQC

Split some parts of lua library "dgn" out.

Specifically, item and monster-related functions to l_dgnit.cc and l_dgnmon.cc.

Created by Robert Vollmert on October 19, 2009

RXYHE3C7R3EGCRZEJT2ZO4ALLRDR3HF66VHZZNF7TT3DFWZ6BJCQC

Dependencies

In channels

main

Change contents

Deletion in crawl-ref/source/makefile.obj at line 43 [7.79]
B:BD[5.2945] → [6.2831:2844]
```
l_dgn_bf.o \
```
Insertion in crawl-ref/source/makefile.obj at line 44 [7.79]
[8.2843]
[9.2830]
```
l_dgnit.o \
l_dgnmon.o \
l_dgn_bf.o \
```
Insertion in crawl-ref/source/l_libs.h at line 6 [9.2907]
[3.2931]
[9.2908]
```
#ifndef L_LIBS_H
#define L_LIBS_H
```

Insertion in crawl-ref/source/l_libs.h at line 14 [9.2907]

[4.2905]

[9.3009]

extern const struct luaL_reg dgn_item_lib[];
extern const struct luaL_reg dgn_mons_lib[];

Replacement in crawl-ref/source/l_libs.h at line 25 [9.2907]

B:BD[9.3125] → [9.3125:3169]

void register_mapdef_tables(lua_State *ls);

[9.3125]

[6.2912]

void register_monslist(lua_State *ls);
void register_itemlist(lua_State *ls);

Insertion in crawl-ref/source/l_libs.h at line 29 [9.2907]
[9.3174]
```
#endif
```

File addition: l_dgnmon.cc (----------)

[10.24]

/*
 * File:     l_dgnmon.cc
 * Summary:  Monster-related functions in lua library "dgn".
 */
#include "AppHdr.h"
#include "dlua.h"
#include "l_libs.h"
#include "dungeon.h"
#include "mapdef.h"
#include "mon-util.h"
#include "monplace.h"
#include "monstuff.h"
#define MONSLIST_METATABLE "crawldgn.monster_list"
static mons_list _lua_get_mlist(lua_State *ls, int ndx)
{
    if (lua_isstring(ls, ndx))
    {
        const char *spec = lua_tostring(ls, ndx);
        mons_list mlist;
        const std::string err = mlist.add_mons(spec);
        if (!err.empty())
            luaL_error(ls, err.c_str());
        return (mlist);
    }
    else
    {
        mons_list **mlist =
        clua_get_userdata<mons_list*>(ls, MONSLIST_METATABLE, ndx);
        if (mlist)
            return (**mlist);
        luaL_argerror(ls, ndx, "Expected monster list object or string");
        return mons_list();
    }
}
void register_monslist(lua_State *ls)
{
    clua_register_metatable(ls, MONSLIST_METATABLE, NULL,
                            lua_object_gc<mons_list>);
}
static int dgn_set_random_mon_list(lua_State *ls)
{
    // Don't complain if we're being called when the map is being loaded
    // and validated.
    if (you.level_type != LEVEL_PORTAL_VAULT &&
        !(you.start_time == 0 && !you.entering_level && !Generating_Level))
    {
        luaL_error(ls, "Can only be used in portal vaults.");
        return (0);
    }
    const int nargs = lua_gettop(ls);
    map_def *map = NULL;
    if (nargs > 2)
    {
        luaL_error(ls, "Too many arguments.");
        return (0);
    }
    else if (nargs == 0)
    {
        luaL_error(ls, "Too few arguments.");
        return (0);
    }
    else if (nargs == 2)
    {
        map_def **_map =
        clua_get_userdata<map_def*>(ls, MAP_METATABLE, 1);
        map = *_map;
    }
    if (map)
    {
        if (map->orient != MAP_ENCOMPASS || map->place.is_valid()
            || !map->depths.empty())
        {
            luaL_error(ls, "Can only be used in portal vaults.");
            return (0);
        }
    }
    int       list_pos = (map != NULL) ? 2 : 1;
    mons_list mlist    = _lua_get_mlist(ls, list_pos);
    if (mlist.size() == 0)
    {
        luaL_argerror(ls, list_pos, "Mon list is empty.");
        return (0);
    }
    if (mlist.size() > 1)
    {
        luaL_argerror(ls, list_pos, "Mon list must contain only one slot.");
        return (0);
    }
    const int num_mons = mlist.slot_size(0);
    if (num_mons == 0)
    {
        luaL_argerror(ls, list_pos, "Mon list is empty.");
        return (0);
    }
    std::vector<mons_spec> mons;
    int num_lords = 0;
    for (int i = 0; i < num_mons; i++)
    {
        mons_spec mon = mlist.get_monster(0, i);
        // Pandemonium lords are pseudo-unique, so don't randomly generate
        // them.
        if (mon.mid == MONS_PANDEMONIUM_DEMON)
        {
            num_lords++;
            continue;
        }
        std::string name;
        if (mon.place.is_valid())
        {
            if (mon.place.level_type == LEVEL_LABYRINTH
                || mon.place.level_type == LEVEL_PORTAL_VAULT)
            {
                std::string err;
                err = make_stringf("mon #%d: Can't use Lab or Portal as a "
                                   "monster place.", i + 1);
                luaL_argerror(ls, list_pos, err.c_str());
                return(0);
            }
            name = mon.place.describe();
        }
        else
        {
            if (mon.mid == RANDOM_MONSTER || mon.monbase == RANDOM_MONSTER)
            {
                std::string err;
                err = make_stringf("mon #%d: can't use random monster in "
                                   "list specifying random monsters", i + 1);
                luaL_argerror(ls, list_pos, err.c_str());
                return(0);
            }
            if (mon.mid == -1)
                mon.mid = MONS_PROGRAM_BUG;
            name = mons_type_name(mon.mid, DESC_PLAIN);
        }
        mons.push_back(mon);
        if (mon.number != 0)
            mprf(MSGCH_ERROR, "dgn.set_random_mon_list() : number for %s "
                 "being discarded.",
                 name.c_str());
        if (mon.band)
            mprf(MSGCH_ERROR, "dgn.set_random_mon_list() : band request for "
                 "%s being ignored.",
                 name.c_str());
        if (mon.colour != BLACK)
            mprf(MSGCH_ERROR, "dgn.set_random_mon_list() : colour for "
                 "%s being ignored.",
                 name.c_str());
        if (mon.items.size() > 0)
            mprf(MSGCH_ERROR, "dgn.set_random_mon_list() : items for "
                 "%s being ignored.",
                 name.c_str());
    } // for (int i = 0; i < num_mons; i++)
    if (mons.size() == 0 && num_lords > 0)
    {
        luaL_argerror(ls, list_pos,
                      "Mon list contains only pandemonium lords.");
        return (0);
    }
    if (map)
        map->random_mons = mons;
    else
        set_vault_mon_list(mons);
    return (0);
}
static int dgn_mons_from_index(lua_State *ls)
{
    const int index = luaL_checkint(ls, 1);
    monsters *mons = &menv[index];
    if (mons->type != -1)
        push_monster(ls, mons);
    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);
    else
        lua_pushnil(ls);
    return (1);
}
static int dgn_create_monster(lua_State *ls)
{
    COORDS(c, 1, 2);
    mons_list mlist = _lua_get_mlist(ls, 3);
    for (int i = 0, size = mlist.size(); i < size; ++i)
    {
        mons_spec mspec = mlist.get_monster(i);
        const int mid = dgn_place_monster(mspec, you.your_level, c,
                                          false, false, false);
        if (mid != -1)
        {
            push_monster(ls, &menv[mid]);
            return (1);
        }
    }
    lua_pushnil(ls);
    return (1);
}
static int _dgn_monster_spec(lua_State *ls)
{
    const mons_list mlist = _lua_get_mlist(ls, 1);
    dlua_push_object_type<mons_list>(ls, MONSLIST_METATABLE, mlist);
    return (1);
}
LUARET1(_dgn_max_monsters, number, MAX_MONSTERS)
LUAFN(dgn_dismiss_monsters)
{
    PLUARET(number,
            dismiss_monsters(lua_gettop(ls) == 0 ? "" :
                             luaL_checkstring(ls, 1)));
}
const struct luaL_reg dgn_mons_lib[] =
{
{ "set_random_mon_list", dgn_set_random_mon_list },
{ "mons_from_index", dgn_mons_from_index },
{ "mons_at", dgn_mons_at },
{ "create_monster", dgn_create_monster },
{ "monster_spec", _dgn_monster_spec },
{ "max_monsters", _dgn_max_monsters },
{ "dismiss_monsters", dgn_dismiss_monsters },
{ NULL, NULL }
};

File addition: l_dgnit.cc (----------)

[10.24]

/*
 * File:     l_dgnit.cc
 * Summary:  Item-related functions in lua library "dgn".
 */
#include "AppHdr.h"
#include "dlua.h"
#include "l_libs.h"
#include "dungeon.h"
#include "items.h"
#include "mapdef.h"
#define ITEMLIST_METATABLE "crawldgn.item_list"
static item_list _lua_get_ilist(lua_State *ls, int ndx)
{
    if (lua_isstring(ls, ndx))
    {
        const char *spec = lua_tostring(ls, ndx);
        item_list ilist;
        const std::string err = ilist.add_item(spec);
        if (!err.empty())
            luaL_error(ls, err.c_str());
        return (ilist);
    }
    else
    {
        item_list **ilist =
            clua_get_userdata<item_list*>(ls, ITEMLIST_METATABLE, ndx);
        if (ilist)
            return (**ilist);
        luaL_argerror(ls, ndx, "Expected item list object or string");
        return item_list();
    }
}
void register_itemlist(lua_State *ls)
{
    clua_register_metatable(ls, ITEMLIST_METATABLE, NULL,
                            lua_object_gc<item_list>);
}
static int dgn_item_from_index(lua_State *ls)
{
    const int index = luaL_checkint(ls, 1);
    item_def *item = &mitm[index];
    if (is_valid_item(*item))
        lua_pushlightuserdata(ls, item);
    else
        lua_pushnil(ls);
    return (1);
}
static int dgn_items_at(lua_State *ls)
{
    COORDS(c, 1, 2);
    lua_push_items(ls, env.igrid(c));
    return (1);
}
static int _dgn_item_spec(lua_State *ls)
{
    const item_list ilist = _lua_get_ilist(ls, 1);
    dlua_push_object_type<item_list>(ls, ITEMLIST_METATABLE, ilist);
    return (1);
}
static int dgn_create_item(lua_State *ls)
{
    COORDS(c, 1, 2);
    item_list ilist = _lua_get_ilist(ls, 3);
    const int level =
    lua_isnumber(ls, 4) ? lua_tointeger(ls, 4) : you.your_level;
    dgn_place_multiple_items(ilist, c, level);
    link_items();
    return (0);
}
const struct luaL_reg dgn_item_lib[] =
{
{ "item_from_index", dgn_item_from_index },
{ "items_at", dgn_items_at },
{ "create_item", dgn_create_item },
{ "item_spec", _dgn_item_spec },
{ NULL, NULL }
};

Deletion in crawl-ref/source/l_dgn.cc at line 12 [13.1232]
B:BD[11.73766] → [12.102928:102947]
```
#include "items.h"
```
Deletion in crawl-ref/source/l_dgn.cc at line 15 [13.1232]
B:BD[14.4442] → [15.3756:3778]
B:BD[15.3778] → [16.12702:12724]
B:BD[16.12724] → [17.5303:5325]
```
#include "mon-util.h"
#include "monplace.h"
#include "monstuff.h"
```

Deletion in crawl-ref/source/l_dgn.cc at line 18 [13.1232]

B:BD[18.3214] → [18.3214:3315]

B:BD[18.3315] → [5.3064:3120]

∅:D[5.3120] → [13.1671:1673]

B:BD[13.1671] → [13.1671:1673]

B:BD[13.1673] → [5.3121:3152]

∅:D[5.3152] → [13.1753:1759]

B:BD[13.1753] → [13.1753:1759]

B:BD[13.1759] → [5.3153:3373]

∅:D[5.3373] → [13.1825:1831]

B:BD[13.1825] → [13.1825:1831]

B:BD[19.2896] → [20.1234:1249]

B:BD[20.1249] → [5.3374:3523]


#define MONSLIST_METATABLE "crawldgn.monster_list"
#define ITEMLIST_METATABLE "crawldgn.item_list"
static mons_list _lua_get_mlist(lua_State *ls, int ndx)
{
    if (lua_isstring(ls, ndx))
    {
        const char *spec = lua_tostring(ls, ndx);
        mons_list mlist;
        const std::string err = mlist.add_mons(spec);
        if (!err.empty())
            luaL_error(ls, err.c_str());
        return (mlist);
    }
    else
    {
        mons_list **mlist =
            clua_get_userdata<mons_list*>(ls, MONSLIST_METATABLE, ndx);
        if (mlist)
            return (**mlist);

Deletion in crawl-ref/source/l_dgn.cc at line 19 [13.1232]
B:BD[19.2899] → [5.3524:3626]
∅:D[20.1716] → [19.3077:3083]
∅:D[5.3626] → [19.3077:3083]
B:BD[19.3077] → [19.3077:3083]
B:BD[13.2771] → [13.2771:2774]
B:BD[13.2774] → [5.3627:3683]
∅:D[19.3119] → [13.2809:2811]
∅:D[5.3683] → [13.2809:2811]
B:BD[13.2809] → [13.2809:2811]
B:BD[13.2811] → [5.3684:3715]
∅:D[5.3715] → [20.2349:2355]
B:BD[20.2349] → [20.2349:2355]
B:BD[20.2355] → [5.3716:3766]
∅:D[5.3766] → [21.3313:3314]
B:BD[20.2385] → [21.3313:3314]
B:BD[21.3314] → [5.3767:3942]
∅:D[5.3942] → [20.2777:2783]
B:BD[20.2777] → [20.2777:2783]
B:BD[20.2783] → [5.3943:3952]
∅:D[5.3952] → [22.406:412]
B:BD[22.406] → [22.406:412]
B:BD[22.412] → [5.3953:4102]
∅:D[22.478] → [23.1530:1531]
∅:D[5.4102] → [23.1530:1531]
B:BD[23.1530] → [23.1530:1531]
B:BD[23.1531] → [5.4103:4202]
∅:D[5.4202] → [23.2137:2143]
B:BD[23.2137] → [23.2137:2143]
∅:D[23.2178] → [13.3340:3343]
B:BD[13.3340] → [13.3340:3343]
B:BD[13.3343] → [5.4203:4246]
∅:D[24.1128] → [23.2255:2257]
∅:D[5.4246] → [23.2255:2257]
B:BD[23.2255] → [23.2255:2257]
B:BD[23.2257] → [5.4247:4473]
∅:D[24.1277] → [23.2958:2961]
∅:D[5.4473] → [23.2958:2961]
B:BD[23.2958] → [23.2958:2961]
B:BD[23.2961] → [5.4474:4571]
∅:D[5.4571] → [23.3034:3036]
B:BD[23.3034] → [23.3034:3036]
B:BD[23.3036] → [5.4572:4643]
∅:D[24.1324] → [23.3344:3347]
∅:D[5.4643] → [23.3344:3347]
B:BD[23.3344] → [23.3344:3347]
```
        luaL_argerror(ls, ndx, "Expected monster list object or string");
        return mons_list();
    }
}
static item_list _lua_get_ilist(lua_State *ls, int ndx)
{
    if (lua_isstring(ls, ndx))
    {
        const char *spec = lua_tostring(ls, ndx);
        item_list ilist;
        const std::string err = ilist.add_item(spec);
        if (!err.empty())
            luaL_error(ls, err.c_str());
    
        return (ilist);
    }
    else
    {
        item_list **ilist =
            clua_get_userdata<item_list*>(ls, ITEMLIST_METATABLE, ndx);
        if (ilist)
            return (**ilist);
        luaL_argerror(ls, ndx, "Expected item list object or string");
        return item_list();
    }
}
void register_mapdef_tables(lua_State *ls)
{
    clua_register_metatable(ls, MONSLIST_METATABLE, NULL,
                            lua_object_gc<mons_list>);
    clua_register_metatable(ls, ITEMLIST_METATABLE, NULL,
                            lua_object_gc<item_list>);
}
template <class T>
static void _push_object_type(lua_State *ls, const char *meta, const T &data)
{
    T **ptr = clua_new_userdata<T*>(ls, meta);
    *ptr = new T(data);
}
```

Deletion in crawl-ref/source/l_dgn.cc at line 310 [13.1232]

B:BD[12.104990] → [16.12725:12780]

B:BD[16.12780] → [2.2580:2799]

∅:D[2.2799] → [16.12826:12920]

B:BD[16.12826] → [16.12826:12920]

B:BD[16.12920] → [5.5013:5018]

∅:D[5.5018] → [25.2860:2898]

B:BD[25.2860] → [25.2860:2898]

B:BD[25.2898] → [5.5019:5024]

∅:D[5.5024] → [25.2899:3156]

B:BD[16.12921] → [25.2899:3156]

B:BD[25.3156] → [26.3193:3218]

B:BD[26.3218] → [5.5025:5084]

∅:D[26.3285] → [25.3248:3275]

∅:D[5.5084] → [25.3248:3275]

B:BD[25.3248] → [25.3248:3275]

B:BD[25.3275] → [5.5085:5090]

∅:D[5.5090] → [25.3276:3514]

B:BD[25.3276] → [25.3276:3514]

B:BD[25.3514] → [5.5091:5096]

∅:D[5.5096] → [25.3515:3618]

B:BD[16.12967] → [25.3515:3618]

B:BD[25.3618] → [5.5097:5102]

∅:D[25.3619] → [16.12967:12994]

∅:D[5.5102] → [16.12967:12994]

B:BD[16.12967] → [16.12967:12994]

B:BD[16.12994] → [25.3620:3685]

∅:D[25.3685] → [16.12994:13014]

B:BD[16.12994] → [16.12994:13014]

B:BD[16.13014] → [25.3686:3692]

B:BD[25.3692] → [5.5103:5108]

∅:D[5.5108] → [16.13015:13047]

B:BD[16.13015] → [16.13015:13047]

B:BD[16.13047] → [25.3693:3770]

∅:D[25.3770] → [16.13117:13143]

B:BD[16.13117] → [16.13117:13143]

B:BD[16.13143] → [5.5109:5114]

∅:D[5.5114] → [16.13144:13189]

B:BD[16.13144] → [16.13144:13189]

B:BD[16.13189] → [5.5115:5120]

∅:D[5.5120] → [16.13190:13219]

B:BD[16.13190] → [16.13190:13219]

B:BD[16.13219] → [25.3771:3830]

∅:D[25.3830] → [16.13271:13297]

B:BD[16.13271] → [16.13271:13297]

B:BD[16.13297] → [5.5121:5126]

∅:D[5.5126] → [16.13298:13448]

B:BD[16.13298] → [16.13298:13448]

B:BD[16.13448] → [5.5127:5136]

∅:D[5.5136] → [16.13449:13655]

B:BD[16.13449] → [16.13449:13655]

B:BD[16.13655] → [5.5137:5146]

∅:D[5.5146] → [16.13656:14029]

B:BD[16.13656] → [16.13656:14029]

B:BD[16.14029] → [25.3831:3889]

∅:D[25.3889] → [16.14080:14471]

B:BD[16.14080] → [16.14080:14471]

B:BD[16.14471] → [25.3890:3948]

∅:D[25.3948] → [16.14522:14563]

B:BD[16.14522] → [16.14522:14563]

B:BD[16.14563] → [2.2800:2875]

∅:D[2.2875] → [16.14563:14629]

B:BD[16.14563] → [16.14563:14629]

B:BD[16.14629] → [5.5147:5156]

∅:D[5.5156] → [16.14630:14659]

B:BD[16.14630] → [16.14630:14659]

B:BD[16.14659] → [5.5157:5166]

∅:D[5.5166] → [16.14660:14764]

B:BD[16.14660] → [16.14660:14764]

B:BD[16.14764] → [5.5167:5204]

∅:D[5.5204] → [16.14814:14846]

B:BD[16.14814] → [16.14814:14846]

B:BD[16.14846] → [5.5205:5214]

∅:D[5.5214] → [16.14847:14947]

B:BD[16.14847] → [16.14847:14947]

B:BD[16.14947] → [5.5215:5253]

∅:D[5.5253] → [16.14998:15030]

B:BD[16.14998] → [16.14998:15030]

B:BD[16.15030] → [5.5254:5263]

∅:D[5.5263] → [16.15031:15136]

B:BD[16.15031] → [16.15031:15136]

B:BD[16.15136] → [5.5264:5302]

∅:D[5.5302] → [16.15187:15219]

B:BD[16.15187] → [16.15187:15219]

B:BD[16.15219] → [5.5303:5312]

∅:D[5.5312] → [16.15220:15325]

B:BD[16.15220] → [16.15220:15325]

B:BD[16.15325] → [5.5313:5351]

∅:D[5.5351] → [16.15376:15452]

B:BD[16.15376] → [16.15376:15452]

B:BD[16.15452] → [5.5352:5357]

∅:D[5.5357] → [16.15453:15502]

B:BD[16.15453] → [16.15453:15502]

B:BD[16.15502] → [25.3949:4053]

∅:D[25.4053] → [16.15577:15603]

B:BD[16.15577] → [16.15577:15603]

B:BD[16.15603] → [5.5358:5363]

∅:D[5.5363] → [25.4054:4143]

B:BD[16.15604] → [25.4054:4143]

B:BD[25.4143] → [5.5364:5369]

∅:D[5.5369] → [16.15635:15651]

B:BD[16.15635] → [16.15635:15651]

}
static int dgn_set_random_mon_list(lua_State *ls)
{
    // Don't complain if we're being called when the map is being loaded
    // and validated.
    if (you.level_type != LEVEL_PORTAL_VAULT &&
        !(you.start_time == 0 && !you.entering_level && !Generating_Level))
    {
        luaL_error(ls, "Can only be used in portal vaults.");
        return (0);
    }
    
    const int nargs = lua_gettop(ls);
    
    map_def *map = NULL;
    if (nargs > 2)
    {
        luaL_error(ls, "Too many arguments.");
        return (0);
    }
    else if (nargs == 0)
    {
        luaL_error(ls, "Too few arguments.");
        return (0);
    }
    else if (nargs == 2)
    {
        map_def **_map =
        clua_get_userdata<map_def*>(ls, MAP_METATABLE, 1);
        map = *_map;
    }
    
    if (map)
    {
        if (map->orient != MAP_ENCOMPASS || map->place.is_valid()
            || !map->depths.empty())
        {
            luaL_error(ls, "Can only be used in portal vaults.");
            return (0);
        }
    }
    
    int       list_pos = (map != NULL) ? 2 : 1;
    mons_list mlist    = _lua_get_mlist(ls, list_pos);
    
    if (mlist.size() == 0)
    {
        luaL_argerror(ls, list_pos, "Mon list is empty.");
        return (0);
    }
    
    if (mlist.size() > 1)
    {
        luaL_argerror(ls, list_pos, "Mon list must contain only one slot.");
        return (0);
    }
    
    const int num_mons = mlist.slot_size(0);
    
    if (num_mons == 0)
    {
        luaL_argerror(ls, list_pos, "Mon list is empty.");
        return (0);
    }
    
    std::vector<mons_spec> mons;
    int num_lords = 0;
    for (int i = 0; i < num_mons; i++)
    {
        mons_spec mon = mlist.get_monster(0, i);
        
        // Pandemonium lords are pseudo-unique, so don't randomly generate
        // them.
        if (mon.mid == MONS_PANDEMONIUM_DEMON)
        {
            num_lords++;
            continue;
        }
        
        std::string name;
        if (mon.place.is_valid())
        {
            if (mon.place.level_type == LEVEL_LABYRINTH
                || mon.place.level_type == LEVEL_PORTAL_VAULT)
            {
                std::string err;
                err = make_stringf("mon #%d: Can't use Lab or Portal as a "
                                   "monster place.", i + 1);
                luaL_argerror(ls, list_pos, err.c_str());
                return(0);
            }
            name = mon.place.describe();
        }
        else
        {
            if (mon.mid == RANDOM_MONSTER || mon.monbase == RANDOM_MONSTER)
            {
                std::string err;
                err = make_stringf("mon #%d: can't use random monster in "
                                   "list specifying random monsters", i + 1);
                luaL_argerror(ls, list_pos, err.c_str());
                return(0);
            }
            if (mon.mid == -1)
                mon.mid = MONS_PROGRAM_BUG;
            name = mons_type_name(mon.mid, DESC_PLAIN);
        }
        
        mons.push_back(mon);
        
        if (mon.number != 0)
            mprf(MSGCH_ERROR, "dgn.set_random_mon_list() : number for %s "
                 "being discarded.",
                 name.c_str());
        
        if (mon.band)
            mprf(MSGCH_ERROR, "dgn.set_random_mon_list() : band request for "
                 "%s being ignored.",
                 name.c_str());
        
        if (mon.colour != BLACK)
            mprf(MSGCH_ERROR, "dgn.set_random_mon_list() : colour for "
                 "%s being ignored.",
                 name.c_str());
        
        if (mon.items.size() > 0)
            mprf(MSGCH_ERROR, "dgn.set_random_mon_list() : items for "
                 "%s being ignored.",
                 name.c_str());
    } // for (int i = 0; i < num_mons; i++)
    
    if (mons.size() == 0 && num_lords > 0)
    {
        luaL_argerror(ls, list_pos,
                      "Mon list contains only pandemonium lords.");
        return (0);
    }
    
    if (map)
        map->random_mons = mons;
    else
        set_vault_mon_list(mons);
    
    return (0);

Deletion in crawl-ref/source/l_dgn.cc at line 1123 [13.1232]
∅:D[27.17891] → [28.15287:15290]
B:BD[28.15287] → [28.15287:15290]
B:BD[28.15290] → [12.105643:105735]
B:BD[12.105735] → [5.9858:9863]
∅:D[5.9863] → [12.105736:105771]
B:BD[12.105736] → [12.105736:105771]
B:BD[12.105771] → [5.9864:9869]
∅:D[5.9869] → [12.105772:105877]
B:BD[12.105772] → [12.105772:105877]
B:BD[12.105877] → [5.9870:9875]
∅:D[5.9875] → [12.105878:105989]
B:BD[12.105878] → [12.105878:105989]
B:BD[12.105989] → [5.9876:9881]
∅:D[5.9881] → [12.105990:106025]
B:BD[12.105990] → [12.105990:106025]
B:BD[12.106025] → [5.9882:9887]
∅:D[5.9887] → [12.106026:106084]
B:BD[12.106026] → [12.106026:106084]
B:BD[12.106084] → [15.5436:5470]
B:BD[15.5470] → [5.9888:9893]
∅:D[5.9893] → [15.5471:5551]
B:BD[15.5471] → [15.5471:5551]
B:BD[15.5551] → [5.9894:9899]
∅:D[5.9899] → [15.5552:5647]
B:BD[15.5552] → [15.5552:5647]
∅:D[15.5647] → [12.106084:106118]
B:BD[12.106084] → [12.106084:106118]
B:BD[12.106118] → [15.5648:5664]
```
}
static int dgn_item_from_index(lua_State *ls)
{
    const int index = luaL_checkint(ls, 1);
    
    item_def *item = &mitm[index];
    
    if (is_valid_item(*item))
        lua_pushlightuserdata(ls, item);
    else
        lua_pushnil(ls);
    
    return (1);
}
static int dgn_mons_from_index(lua_State *ls)
{
    const int index = luaL_checkint(ls, 1);
    
    monsters *mons = &menv[index];
    
    if (mons->type != -1)
        push_monster(ls, mons);
    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);
    else
        lua_pushnil(ls);
    return (1);
```
Deletion in crawl-ref/source/l_dgn.cc at line 1125 [13.1232]
B:BD[12.106119] → [15.5667:5767]
∅:D[15.5767] → [12.106119:106135]
B:BD[12.106119] → [12.106119:106135]
B:BD[12.106135] → [29.3922:3925]
```
static int dgn_items_at(lua_State *ls)
{
    COORDS(c, 1, 2);
    lua_push_items(ls, env.igrid(c));
    return (1);
}
```

Deletion in crawl-ref/source/l_dgn.cc at line 1845 [13.1232]

B:BD[15.5940] → [15.5940:6011]

B:BD[15.6011] → [5.11464:11469]

∅:D[5.11469] → [18.3603:3704]

B:BD[15.6012] → [18.3603:3704]

∅:D[18.3704] → [15.6060:6066]

B:BD[15.6060] → [15.6060:6066]

B:BD[15.6066] → [18.3705:3753]

B:BD[18.3753] → [30.8006:8161]

∅:D[18.3861] → [15.6273:6283]

∅:D[30.8161] → [15.6273:6283]

B:BD[15.6273] → [15.6273:6283]

B:BD[15.6283] → [30.8162:8204]

∅:D[30.8204] → [18.3908:3932]

B:BD[18.3908] → [18.3908:3932]

∅:D[18.3932] → [15.6557:6613]

B:BD[15.6557] → [15.6557:6613]

B:BD[15.6613] → [18.3933:4111]

}
static int dgn_create_monster(lua_State *ls)
{
    COORDS(c, 1, 2);
    
    mons_list mlist = _lua_get_mlist(ls, 3);
    for (int i = 0, size = mlist.size(); i < size; ++i)
    {
        mons_spec mspec = mlist.get_monster(i);
        const int mid = dgn_place_monster(mspec, you.your_level, c,
                                          false, false, false);
        if (mid != -1)
        {
            push_monster(ls, &menv[mid]);
            return (1);
        }
    }
    lua_pushnil(ls);
    return (1);
}
static int _dgn_monster_spec(lua_State *ls)
{
    const mons_list mlist = _lua_get_mlist(ls, 1);
    _push_object_type<mons_list>(ls, MONSLIST_METATABLE, mlist);
    return (1);

Deletion in crawl-ref/source/l_dgn.cc at line 1847 [13.1232]

B:BD[18.4114] → [18.4114:4342]

∅:D[18.4342] → [15.6613:6678]

B:BD[15.6613] → [15.6613:6678]

B:BD[15.6678] → [5.11470:11475]

∅:D[5.11475] → [18.4343:4410]

B:BD[15.6679] → [18.4343:4410]

B:BD[18.4410] → [5.11476:11546]

∅:D[5.11546] → [18.4480:4545]

B:BD[15.6980] → [18.4480:4545]

∅:D[18.4545] → [31.7142:7160]

∅:D[15.7059] → [31.7142:7160]

B:BD[31.7142] → [31.7142:7160]

B:BD[31.7160] → [15.7060:7061]

static int _dgn_item_spec(lua_State *ls)
{
    const item_list ilist = _lua_get_ilist(ls, 1);
    _push_object_type<item_list>(ls, ITEMLIST_METATABLE, ilist);
    return (1);
}
LUARET1(_dgn_max_monsters, number, MAX_MONSTERS)
static int dgn_create_item(lua_State *ls)
{
    COORDS(c, 1, 2);
    
    item_list ilist = _lua_get_ilist(ls, 3);
    const int level =
    lua_isnumber(ls, 4) ? lua_tointeger(ls, 4) : you.your_level;
    
    dgn_place_multiple_items(ilist, c, level);
    link_items();
    return (0);
}

Deletion in crawl-ref/source/l_dgn.cc at line 2370 [13.1232]

B:BD[17.5329] → [17.5329:5491]

∅:D[17.5491] → [32.3104:3107]

B:BD[32.3104] → [32.3104:3107]

LUAFN(dgn_dismiss_monsters)
{
    PLUARET(number,
            dismiss_monsters(lua_gettop(ls) == 0 ? "" :
                             luaL_checkstring(ls, 1)));
}

Deletion in crawl-ref/source/l_dgn.cc at line 2381 [13.1232]
B:BD[5.13951] → [5.13951:13997]
```
{ "dismiss_monsters", dgn_dismiss_monsters },
```

Deletion in crawl-ref/source/l_dgn.cc at line 2435 [13.1232]

B:BD[5.15714] → [5.15714:15860]

{ "item_from_index", dgn_item_from_index },
{ "mons_from_index", dgn_mons_from_index },
{ "mons_at", dgn_mons_at },
{ "items_at", dgn_items_at },

Deletion in crawl-ref/source/l_dgn.cc at line 2437 [13.1232]
B:BD[5.15962] → [5.15962:16014]
```
{ "set_random_mon_list", dgn_set_random_mon_list },
```
Deletion in crawl-ref/source/l_dgn.cc at line 2474 [13.1232]
∅:D[5.17416] → [18.5620:5621]
B:BD[18.5620] → [18.5620:5621]
B:BD[18.5621] → [5.17417:17495]
```
{ "create_monster", dgn_create_monster },
{ "create_item", dgn_create_item },
```
Deletion in crawl-ref/source/l_dgn.cc at line 2475 [13.1232]
B:BD[18.5731] → [5.17496:17568]
∅:D[5.17568] → [18.5876:5877]
B:BD[18.5876] → [18.5876:5877]
B:BD[18.5877] → [5.17569:17608]
∅:D[18.6023] → [27.22682:22683]
∅:D[5.17608] → [27.22682:22683]
B:BD[27.22682] → [27.22682:22683]
```
{ "monster_spec", _dgn_monster_spec },
{ "item_spec", _dgn_item_spec },
{ "max_monsters", _dgn_max_monsters },
```

Insertion in crawl-ref/source/dlua.h at line 90 [13.228]

[33.3152]

template <class T>
static void dlua_push_object_type(lua_State *ls, const char *meta, const T &data)
{
    T **ptr = clua_new_userdata<T*>(ls, meta);
    *ptr = new T(data);
}

Insertion in crawl-ref/source/dlua.cc at line 311 [5.19392]

[4.4636]

[5.42078]

    luaL_openlib(dlua, "dgn", dgn_item_lib, 0);
    luaL_openlib(dlua, "dgn", dgn_mons_lib, 0);

Replacement in crawl-ref/source/dlua.cc at line 332 [5.19392]
B:BD[5.42639] → [5.42639:42673]
```
    register_mapdef_tables(dlua);
```
[5.42639]
[5.42673]
```
    register_itemlist(dlua);
    register_monslist(dlua);
```

Split some parts of lua library "dgn" out.

Dependencies

In channels

Change contents

Deletion in crawl-ref/source/makefile.obj at line 43 [7.79]

Insertion in crawl-ref/source/makefile.obj at line 44 [7.79]

Insertion in crawl-ref/source/l_libs.h at line 6 [9.2907]

Insertion in crawl-ref/source/l_libs.h at line 14 [9.2907]

Replacement in crawl-ref/source/l_libs.h at line 25 [9.2907]

Insertion in crawl-ref/source/l_libs.h at line 29 [9.2907]

File addition: l_dgnmon.cc (----------)

File addition: l_dgnit.cc (----------)

Deletion in crawl-ref/source/l_dgn.cc at line 12 [13.1232]

Deletion in crawl-ref/source/l_dgn.cc at line 15 [13.1232]

Deletion in crawl-ref/source/l_dgn.cc at line 18 [13.1232]

Deletion in crawl-ref/source/l_dgn.cc at line 19 [13.1232]

Deletion in crawl-ref/source/l_dgn.cc at line 310 [13.1232]

Deletion in crawl-ref/source/l_dgn.cc at line 1123 [13.1232]

Deletion in crawl-ref/source/l_dgn.cc at line 1125 [13.1232]

Deletion in crawl-ref/source/l_dgn.cc at line 1845 [13.1232]

Deletion in crawl-ref/source/l_dgn.cc at line 1847 [13.1232]

Deletion in crawl-ref/source/l_dgn.cc at line 2370 [13.1232]

Deletion in crawl-ref/source/l_dgn.cc at line 2381 [13.1232]

Deletion in crawl-ref/source/l_dgn.cc at line 2435 [13.1232]

Deletion in crawl-ref/source/l_dgn.cc at line 2437 [13.1232]

Deletion in crawl-ref/source/l_dgn.cc at line 2474 [13.1232]

Deletion in crawl-ref/source/l_dgn.cc at line 2475 [13.1232]

Insertion in crawl-ref/source/dlua.h at line 90 [13.228]

Insertion in crawl-ref/source/dlua.cc at line 311 [5.19392]

Replacement in crawl-ref/source/dlua.cc at line 332 [5.19392]