fiddlerwoaroof/crawl - Change EH4VJW3I5Y4V6DT3YMLNDA3NW2DEAV4LRE4T5IEXAVB4WB3JJMGAC

mapdef/vault items can now have their race type and ego explicitly set.

mapdef/vault monsters can now be given an explicit list of items.

git-svn-id: https://crawl-ref.svn.sourceforge.net/svnroot/crawl-ref/trunk@3055 c06c8d41-db1a-0410-9941-cceddc491573

Created by zelgadis on December 13, 2007

EH4VJW3I5Y4V6DT3YMLNDA3NW2DEAV4LRE4T5IEXAVB4WB3JJMGAC

Dependencies

In channels

main

Change contents

Insertion in crawl-ref/source/mapdef.h at line 326 [5.591249]

[4.140041]

[5.592836]

};
enum item_spec_type
{
    ISPEC_GOOD   = -2,
    ISPEC_SUPERB = -3
};
struct item_spec
{
    int genweight;
    
    object_class_type base_type;
    int sub_type;
    int ego;
    int allow_uniques;
    int level;
    int race;
    int qty;
    item_spec() : genweight(10), base_type(OBJ_RANDOM), sub_type(OBJ_RANDOM),
        ego(0), allow_uniques(1), level(-1), race(MAKE_ITEM_RANDOM_RACE),
        qty(0)
    {
    }
};
typedef std::vector<item_spec> item_spec_list;
class item_list
{
public:
    item_list() : items() { }
    void clear();
    item_spec get_item(int index);
    size_t size() const { return items.size(); }
    std::string add_item(const std::string &spec, bool fix = false);
    std::string set_item(int index, const std::string &spec);
private:
    struct item_spec_slot
    {
        item_spec_list ilist;
        bool fix_slot;
        item_spec_slot() : ilist(), fix_slot(false)
        {
        }
    };
    
private:
    item_spec item_by_specifier(const std::string &spec);
    item_spec_slot parse_item_spec(std::string spec);
    item_spec parse_single_spec(std::string s);
    void parse_raw_name(std::string name, item_spec &spec);
    void parse_random_by_class(std::string c, item_spec &spec);
    item_spec pick_item(item_spec_slot &slot);
private:
    std::vector<item_spec_slot> items;
    std::string error;

Insertion in crawl-ref/source/mapdef.h at line 400 [5.591249]
[6.244]
[5.592839]
```
    item_list items;
```

Replacement in crawl-ref/source/mapdef.h at line 407 [5.591249]

B:BD[7.557] → [6.245:291]

        generate_awake(awaken), colour(BLACK)

[7.557]

[8.379]

        generate_awake(awaken), colour(BLACK), items()

Deletion in crawl-ref/source/mapdef.h at line 459 [5.591249]
B:BD[9.1723] → [9.1723:1746]
B:BD[9.1746] → [10.277:348]
∅:D[10.348] → [11.138383:138387]
∅:D[9.1746] → [11.138383:138387]
B:BD[5.593169] → [11.138383:138387]
B:BD[11.138387] → [9.1747:1766]
∅:D[9.1766] → [11.138406:138430]
B:BD[11.138406] → [11.138406:138430]
B:BD[11.138430] → [12.1166:1217]
∅:D[12.1217] → [11.138459:138511]
B:BD[11.138459] → [11.138459:138511]
B:BD[11.138511] → [13.214:227]
∅:D[13.227] → [11.138511:138590]
B:BD[11.138511] → [11.138511:138590]
B:BD[11.138590] → [13.228:301]
∅:D[13.301] → [11.138655:138667]
B:BD[11.138655] → [11.138655:138667]
∅:D[11.138667] → [5.593169:593172]
B:BD[5.593169] → [5.593169:593172]
B:BD[5.593173] → [11.138668:138716]
B:BD[11.138716] → [9.1767:1785]
∅:D[9.1785] → [11.138734:138791]
B:BD[11.138734] → [11.138734:138791]
B:BD[11.138791] → [9.1786:1871]
∅:D[9.1871] → [11.138849:138850]
B:BD[11.138849] → [11.138849:138850]
B:BD[11.138850] → [14.2103:2172]
B:BD[14.2172] → [15.7204:7266]
∅:D[14.2172] → [9.1872:1967]
∅:D[15.7266] → [9.1872:1967]
B:BD[11.138901] → [9.1872:1967]
∅:D[9.1967] → [11.138955:138956]
B:BD[11.138955] → [11.138955:138956]
B:BD[11.138956] → [9.1968:2052]
∅:D[9.2052] → [11.138956:139023]
B:BD[11.138956] → [11.138956:139023]
B:BD[11.139023] → [9.2053:2107]
∅:D[9.2107] → [11.139077:139249]
B:BD[11.139077] → [11.139077:139249]
B:BD[11.139249] → [9.2108:2155]
∅:D[9.2155] → [11.139249:139259]
B:BD[11.139249] → [11.139249:139259]
B:BD[11.139259] → [9.2156:2195]
```
    std::string error;
};
enum item_spec_type
{
    ISPEC_GOOD   = -2,
    ISPEC_SUPERB = -3
};
struct item_spec
{
    int genweight;
    
    object_class_type base_type;
    int sub_type;
    int allow_uniques;
    int level;
    int race;
    int qty;
    item_spec() : genweight(10), base_type(OBJ_RANDOM), sub_type(OBJ_RANDOM),
        allow_uniques(1), level(-1), race(MAKE_ITEM_RANDOM_RACE), qty(0)
    {
    }
};
typedef std::vector<item_spec> item_spec_list;
class item_list
{
public:
    item_list() : items() { }
    void clear();
    item_spec get_item(int index);
    size_t size() const { return items.size(); }
    std::string add_item(const std::string &spec, bool fix = false);
    std::string set_item(int index, const std::string &spec);
private:
    struct item_spec_slot
    {
        item_spec_list ilist;
        bool fix_slot;
        item_spec_slot() : ilist(), fix_slot(false)
        {
        }
    };
    
private:
    item_spec item_by_specifier(const std::string &spec);
    item_spec_slot parse_item_spec(std::string spec);
    item_spec parse_single_spec(std::string s);
    void parse_raw_name(std::string name, item_spec &spec);
    void parse_random_by_class(std::string c, item_spec &spec);
    item_spec pick_item(item_spec_slot &slot);
private:
    std::vector<item_spec_slot> items;
```

Insertion in crawl-ref/source/mapdef.cc at line 1908 [5.594797]

[9.3689]

[7.860]

        std::vector<std::string> parts = split_string(";", s);
        std::string mon_str = parts[0];

Insertion in crawl-ref/source/mapdef.cc at line 1912 [5.594797]

[7.885]


        if (parts.size() > 2)
        {
            error = make_stringf("Too many semi-colons for '%s' spec.",
                                 mon_str.c_str());
            return (slot);
        }
        else if (parts.size() == 2)
        {
            // TODO: Allow for a "fix_slot" type tag which will cause
            // all monsters generated from this spec to have the
            // exact same equipment.
            std::string items_str = parts[1];
            items_str = replace_all(items_str, "|", "/");
            std::vector<std::string> segs = split_string(".", items_str);
            if (segs.size() > NUM_MONSTER_SLOTS)
            {
                error = make_stringf("More items than monster item slots "
                                     "for '%s'.", mon_str.c_str());
                return (slot);
            }

Replacement in crawl-ref/source/mapdef.cc at line 1936 [5.594797]

B:BD[7.886] → [7.886:928]

        mspec.genweight = find_weight(s);

[7.886]

[7.928]

            for (int j = 0, isize = segs.size(); j < isize; ++j)
            {
                error = mspec.items.add_item(segs[j], false);
                if (!error.empty())
                    return (slot);
            }
        }
        mspec.genweight = find_weight(mon_str);

Replacement in crawl-ref/source/mapdef.cc at line 1948 [5.594797]

B:BD[9.3818] → [7.1031:1145]

        mspec.fix_mons = strip_tag(s, "fix_mons");
        mspec.generate_awake = strip_tag(s, "generate_awake");

[9.3818]

[6.293]

        mspec.fix_mons = strip_tag(mon_str, "fix_mons");
        mspec.generate_awake = strip_tag(mon_str, "generate_awake");

Replacement in crawl-ref/source/mapdef.cc at line 1951 [5.594797]

B:BD[6.294] → [6.294:352]

        std::string colour = strip_tag_prefix(s, "col:");

[6.294]

[6.352]

        std::string colour = strip_tag_prefix(mon_str, "col:");

Replacement in crawl-ref/source/mapdef.cc at line 1963 [5.594797]
B:BD[9.3874] → [9.3874:3898]
```
        trim_string(s);
```
[9.3874]
[16.696]
```
        trim_string(mon_str);
```
Replacement in crawl-ref/source/mapdef.cc at line 1965 [5.594797]
B:BD[9.3940] → [16.732:754]
```
        if (s == "8")
```
[16.697]
[7.1146]
```
        if (mon_str == "8")
```
Replacement in crawl-ref/source/mapdef.cc at line 1967 [5.594797]
∅:D[7.1177] → [16.779:806]
B:BD[16.779] → [16.779:806]
```
        else if (s == "9")
```
[7.1177]
[7.1178]
```
        else if (mon_str == "9")
```

Replacement in crawl-ref/source/mapdef.cc at line 1969 [5.594797]

B:BD[7.1209] → [7.1209:1271]

        else if (check_mimic(s, &mspec.mid, &mspec.fix_mons))

[7.1209]

[17.1117]

        else if (check_mimic(mon_str, &mspec.mid, &mspec.fix_mons))

Replacement in crawl-ref/source/mapdef.cc at line 1971 [5.594797]
∅:D[17.1131] → [16.831:858]
B:BD[16.831] → [16.831:858]
```
        else if (s != "0")
```
[17.1131]
[9.3977]
```
        else if (mon_str != "0")
```

Replacement in crawl-ref/source/mapdef.cc at line 1973 [5.594797]

B:BD[9.3987] → [7.1272:1325]

            const mons_spec nspec = mons_by_name(s);

[9.3987]

[16.894]

            const mons_spec nspec = mons_by_name(mon_str);

Replacement in crawl-ref/source/mapdef.cc at line 1977 [5.594797]

B:BD[16.950] → [16.950:1030]

                error = make_stringf("unrecognised monster \"%s\"", s.c_str());

[16.950]

[16.1030]

                error = make_stringf("unrecognised monster \"%s\"",
                                     mon_str.c_str());

Insertion in crawl-ref/source/mapdef.cc at line 1985 [5.594797]

[9.4100]

[7.1452]


        if (mspec.items.size() > 0)
        {
            if (mspec.mid == RANDOM_MONSTER)
            {
                error = "Can't give spec items to a random monster.";
                return (slot);
            };
            if (mons_itemuse(mspec.mid) < MONUSE_STARTING_EQUIPMENT)
            {
                error = make_stringf("Monster '%s' can't use items.",
                                     mon_str.c_str());
            }
        }

Replacement in crawl-ref/source/mapdef.cc at line 2197 [5.594797]
B:BD[9.4905] → [9.4905:4910]
```
    
```
[9.4905]
[9.4910]

Insertion in crawl-ref/source/mapdef.cc at line 2241 [5.594797]

[15.16031]

[11.140959]

}
// TODO: More checking for innapropriate combinations, like the holy
// wrath brand on a demonic weapon or the running ego on a helmet.
static int str_to_ego(item_spec &spec, std::string ego_str)
{
    const char* armour_egos[] = {
        "running",
        "fire_resistance",
        "cold_resistance",
        "poison_resistance",
        "see_invisible",
        "darkness",
        "strength",
        "dexterity",
        "intelligence",
        "ponderousness",
        "levitation",
        "magic_resistance",
        "protection",
        "stealth",
        "resistance",
        "positive_energy",
        "archmagi",
        "preservation",
        NULL
    };
    const char* weapon_brands[] = {
        "flaming",
        "freezing",
        "holy_wrath",
        "electrocution",
        "orc_slaying",
        "venom",
        "protection",
        "draining",
        "speed",
        "vorpal",
        "flame",
        "frost",
        "vampiricism",
        "disruption",
        "pain",
        "distortion",
        "reaching",
        "returning",
        "confuse",
        NULL
    };
    const char* missile_brands[] = {
        "flame",
        "ice",
        "poisoned",
        "poisoned_ii",
        "curare",
        "returning",
        NULL
    };
    const char** name_lists[3] = {armour_egos, weapon_brands, missile_brands};
    int armour_order[3]  = {0, 1, 2};
    int weapon_order[3]  = {1, 0, 2};
    int missile_order[3] = {2, 0, 1};
    int *order;
    switch(spec.base_type)
    {
    case OBJ_ARMOUR:
        order = armour_order;
        break;
    case OBJ_WEAPONS:
        order = weapon_order;
        break;
    case OBJ_MISSILES:
        order = missile_order;
        break;
    default:
        DEBUGSTR("Bad base_type for ego'd item.");
        return 0;
    }
    const char** allowed = name_lists[order[0]];
    for (int i = 0; allowed[i] != NULL; i++)
    {
        if (ego_str == allowed[i])
            return (i + 1);
    }
    // Incompatible or non-existant ego type
    for (int i = 1; i <= 2; i++)
    {
        const char** list = name_lists[order[i]];
        for (int j = 0; list[j] != NULL; j++)
            if (ego_str == list[j])
                // Ego incompatible with base type.
                return (-1);
    }
    // Non-existant ego
    return 0;

Insertion in crawl-ref/source/mapdef.cc at line 2373 [5.594797]

[11.141435]

    std::string ego_str  = strip_tag_prefix(s, "ego:");
    std::string race_str = strip_tag_prefix(s, "race:");
    lowercase(ego_str);
    lowercase(race_str);
    if (race_str == "elven")
        result.race = MAKE_ITEM_ELVEN;
    else if (race_str == "dwarven")
        result.race = MAKE_ITEM_DWARVEN;
    else if (race_str == "orcish")
        result.race = MAKE_ITEM_ORCISH;
    else if (race_str == "none" || race_str == "no_race")
        result.race = MAKE_ITEM_NO_RACE;
    else if (!race_str.empty())
    {
        error = make_stringf("Bad race: %s", race_str.c_str());
        return (result);
    }

Insertion in crawl-ref/source/mapdef.cc at line 2400 [5.594797]
[11.141650]
[11.141650]
```
            {
```
Insertion in crawl-ref/source/mapdef.cc at line 2402 [5.594797]
[11.141718]
[11.141718]
```
                return (result);
            }
```
Insertion in crawl-ref/source/mapdef.cc at line 2419 [5.594797]
[11.142042]
[11.142042]
```
            {
```
Insertion in crawl-ref/source/mapdef.cc at line 2421 [5.594797]
[11.142108]
[11.142108]
```
                return (result);
            }
```

Insertion in crawl-ref/source/mapdef.cc at line 2429 [5.594797]

[11.142230]


    if (!ego_str.empty())
        error = "Can't set an ego for random items.";

Insertion in crawl-ref/source/mapdef.cc at line 2449 [5.594797]

[18.2421]

        if (!ego_str.empty())
            error = "Can't set an ego for gold.";

Insertion in crawl-ref/source/mapdef.cc at line 2459 [5.594797]
[19.152]
[19.152]
```
        error.clear();
```
Insertion in crawl-ref/source/mapdef.cc at line 2478 [5.594797]
[11.142633]
[11.142633]
```
    error.clear();
```

Insertion in crawl-ref/source/mapdef.cc at line 2480 [5.594797]

[11.142664]


    if (!error.empty() || ego_str.empty())
        return (result);
    if (result.base_type != OBJ_WEAPONS
        && result.base_type != OBJ_MISSILES
        && result.base_type != OBJ_ARMOUR)
    {
        error = "An ego can only be applied to a weapon, missile or "
            "armour.";
        return (result);
    }
    if (ego_str == "none")
    {
        result.ego = -1;
        return (result);
    }

Insertion in crawl-ref/source/mapdef.cc at line 2499 [5.594797]

[11.142665]

    const int ego = str_to_ego(result, ego_str);
    if (ego == 0)
    {
        error = make_stringf("No such ego as: %s", ego_str.c_str());
        return (result);
    }
    else if (ego == -1)
    {
        error = make_stringf("Ego '%s' is incompatible with item '%s'.",
                             ego_str.c_str(), s.c_str());
        return (result);
    }
    result.ego = ego;

Replacement in crawl-ref/source/makeitem.h at line 26 [20.516]

B:BD[20.701] → [21.714:749]

           unsigned mapmask = 0 );

[20.701]

[20.768]

           unsigned mapmask = 0, int force_ego = 0 );

Insertion in crawl-ref/source/makeitem.cc at line 1146 [20.927]

[22.8452]

    // Forced ego.
    if (item.special != 0)
        return static_cast<brand_type>(item.special);

Insertion in crawl-ref/source/makeitem.cc at line 1505 [20.927]

[22.18561]

[20.53268]

    const bool forced_ego = item.special > 0;
    const bool no_brand   = item.special == SPWPN_FORBID_BRAND;

Insertion in crawl-ref/source/makeitem.cc at line 1508 [20.927]

[20.53269]

[22.18562]

    if (no_brand)
        set_item_ego_type( item, OBJ_WEAPONS, SPWPN_NORMAL );

Deletion in crawl-ref/source/makeitem.cc at line 1521 [20.927]
B:BD[22.18847] → [22.18847:18880]
```
    item.special = SPWPN_NORMAL;
```

Replacement in crawl-ref/source/makeitem.cc at line 1527 [20.927]

B:BD[22.19131] → [22.19131:19194]

    if (force_good && get_equip_race( item ) == ISFLAG_ORCISH)

[22.19131]

[22.19194]

    if (force_good && !forced_ego && get_equip_race( item ) == ISFLAG_ORCISH)

Replacement in crawl-ref/source/makeitem.cc at line 1536 [20.927]

B:BD[20.54451] → [22.19398:19474]

    if ((force_good || is_demonic(item) || random2(200) <= 50 + item_level)

[20.54451]

[22.19474]

    if ((force_good || is_demonic(item) || forced_ego
         || random2(200) <= 50 + item_level)

Replacement in crawl-ref/source/makeitem.cc at line 1544 [20.927]

B:BD[22.19705] → [22.19705:19819]

        set_item_ego_type(item, OBJ_WEAPONS,
                          determine_weapon_brand(item, item_level));

[22.19705]

[20.54588]

        if (!no_brand)
            set_item_ego_type(item, OBJ_WEAPONS,
                              determine_weapon_brand(item, item_level));

Replacement in crawl-ref/source/makeitem.cc at line 1587 [20.927]

B:BD[20.56569] → [22.20806:20853]

    if (get_equip_race(item) == ISFLAG_ORCISH)

[20.56569]

[22.20853]

    if (get_equip_race(item) == ISFLAG_ORCISH
        && !(item_race == MAKE_ITEM_ORCISH && forced_ego))

Replacement in crawl-ref/source/makeitem.cc at line 1594 [20.927]

B:BD[22.21052] → [22.21052:21106]

            || (brand != SPWPN_NORMAL && coinflip()))

[22.21052]

[20.56624]

            || (brand != SPWPN_NORMAL && !forced_ego && coinflip()))

Insertion in crawl-ref/source/makeitem.cc at line 1669 [20.927]

[22.22739]

    // Forced ego.
    if (item.special != 0)
        return static_cast<special_missile_type>(item.special);

Insertion in crawl-ref/source/makeitem.cc at line 1725 [20.927]

[22.24204]

    const bool no_brand = item.special == SPMSL_FORBID_BRAND;
    if (no_brand)
        item.special = SPMSL_NORMAL;

Deletion in crawl-ref/source/makeitem.cc at line 1730 [20.927]
B:BD[22.24223] → [22.24223:24256]
```
    item.special = SPMSL_NORMAL;
```

Replacement in crawl-ref/source/makeitem.cc at line 1756 [20.927]

B:BD[22.25105] → [22.25105:25216]

    set_item_ego_type( item, OBJ_MISSILES,
                       determine_missile_brand(item, item_level) );

[22.25105]

[20.62718]

    if (!no_brand)
        set_item_ego_type( item, OBJ_MISSILES,
                           determine_missile_brand(item, item_level) );

Insertion in crawl-ref/source/makeitem.cc at line 1937 [20.927]

[22.30561]

    if (item.special != 0)
        return static_cast<special_armour_type>(item.special);

Insertion in crawl-ref/source/makeitem.cc at line 2068 [20.927]

[22.34313]

[20.78075]

    const bool forced_ego = item.special > 0;
    const bool no_ego     = item.special == SPARM_FORBID_EGO;

Replacement in crawl-ref/source/makeitem.cc at line 2071 [20.927]

B:BD[20.78076] → [3.1810:1864]

    if (force_good || item.sub_type == ARM_WIZARD_HAT

[20.78076]

[22.34435]

    if (no_ego)
        item.special = SPARM_NORMAL;
    if (force_good || forced_ego || item.sub_type == ARM_WIZARD_HAT

Replacement in crawl-ref/source/makeitem.cc at line 2083 [20.927]

B:BD[20.79995] → [22.34668:34739]

        if (30 + item_level >= random2(350)
            && (force_good

[20.79995]

[22.34739]

        if (!no_ego && (30 + item_level >= random2(350))
            && (force_good || forced_ego

Replacement in crawl-ref/source/makeitem.cc at line 2132 [20.927]

B:BD[22.36373] → [22.36373:36434]

        set_item_ego_type( item, OBJ_ARMOUR, SPARM_NORMAL );

[22.36373]

[22.36434]

        if (!forced_ego)
            set_item_ego_type( item, OBJ_ARMOUR, SPARM_NORMAL );

Replacement in crawl-ref/source/makeitem.cc at line 2646 [20.927]

B:BD[22.53911] → [22.53911:53941]

           unsigned mapmask)

[22.53911]

[22.53941]

           unsigned mapmask,
           int force_ego)           // desired ego/brand

Replacement in crawl-ref/source/makeitem.cc at line 2649 [20.927]

B:BD[22.53943] → [22.53943:54003]

    const bool force_good = (item_level == MAKE_GOOD_ITEM);

[22.53943]

[20.93573]

    // TODO: Allow a combination of force_ego > 0 and
    // force_type == OBJ_RANDOM, so that (for example) you could have
    // force_class = OBJ_WEAPON, force_type = OBJ_RANDOM and
    // force_ego = SPWPN_VORPAL, and a random weapon of a type
    // appropriate for the vorpal brand will be chosen.
    ASSERT(force_ego <= 0 ||
           ((force_class == OBJ_WEAPONS || force_class == OBJ_ARMOUR
             || force_class == OBJ_MISSILES)
            && force_type != OBJ_RANDOM));

Insertion in crawl-ref/source/makeitem.cc at line 2666 [20.927]

[20.94173]

[22.54182]

    const bool force_good = (item_level == MAKE_GOOD_ITEM);
    if (force_ego > 0)
        allow_uniques = false;
    item.special = force_ego;

Insertion in crawl-ref/source/itemprop.h at line 75 [5.641567]
[23.75553]
[23.75553]
```
const int SP_FORBID_EGO   = -1;
const int SP_FORBID_BRAND = -1;
```
Insertion in crawl-ref/source/itemprop.h at line 81 [5.641567]
[23.75632]
[23.75632]
```
    SPWPN_FORBID_BRAND = -1,           //   -1
```
Insertion in crawl-ref/source/itemprop.h at line 326 [5.641567]
[23.81890]
[23.81890]
```
    SPARM_FORBID_EGO = -1,             //   -1
```
Insertion in crawl-ref/source/itemprop.h at line 350 [5.641567]
[23.82822]
[23.82822]
```
    SPMSL_FORBID_BRAND = -1,           //   -1
```
Replacement in crawl-ref/source/dungeon.h at line 322 [25.3428186]
B:BD[24.363] → [24.363:410]
```
bool dgn_place_monster(const mons_spec &mspec,
```
[24.363]
[24.410]
```
bool dgn_place_monster(mons_spec &mspec,
```
Replacement in crawl-ref/source/dungeon.cc at line 4176 [25.3429798]
B:BD[14.10592] → [14.10592:10627]
```
               level, spec.race );
```
[14.10592]
[14.10627]
```
               level, spec.race, 0, spec.ego );
```

Insertion in crawl-ref/source/dungeon.cc at line 4214 [25.3429798]

[14.10810]

[19.265]


static void dgn_give_mon_spec_items(mons_spec &mspec,
                                    const int mindex,
                                    const int mid,
                                    const int monster_level)
{
    monsters &mon(menv[mindex]);
    unwind_var<int> save_speedinc(mon.speed_increment);
    // Get rid of existing equipment.
    for (int i = 0; i < NUM_MONSTER_SLOTS; i++)
    {
        if (mon.inv[i] != NON_ITEM)
        {
            item_def &item(mitm[mon.inv[i]]);
            mon.unequip(item, i, 0, true);
            destroy_item(mon.inv[i], true);
            mon.inv[i] = NON_ITEM;
        }
    }
    item_make_species_type racial = MAKE_ITEM_RANDOM_RACE;
    if (mons_genus(mid) == MONS_ORC)
        racial = MAKE_ITEM_ORCISH;
    else if (mons_genus(mid) == MONS_ELF)
        racial = MAKE_ITEM_ELVEN;
    item_list &list = mspec.items;
    const int size = list.size();
    for (int i = 0; i < size; ++i)
    {
        item_spec spec = list.get_item(i);
        if (spec.base_type == OBJ_UNASSIGNED)
            continue;
        // Don't give monster a randart, and don't radnomly give
        // monster an ego item.
        if (spec.base_type == OBJ_ARMOUR || spec.base_type == OBJ_WEAPONS
            || spec.base_type == OBJ_MISSILES)
        {
            spec.allow_uniques = 0;
            if (spec.ego == 0)
                spec.ego = SP_FORBID_EGO;
        }

Replacement in crawl-ref/source/dungeon.cc at line 4263 [25.3429798]

B:BD[19.266] → [24.807:854]

bool dgn_place_monster(const mons_spec &mspec,

[19.266]

[24.854]

        // Gives orcs and elves appropriate racial gear, unless
        // otherwise specified.
        if (spec.race == MAKE_ITEM_RANDOM_RACE)
        {
            // But don't automatically give elves elven boots or
            // elven cloaks.
            if (racial != MAKE_ITEM_ELVEN || spec.base_type != OBJ_ARMOUR
                || (spec.sub_type != ARM_CLOAK
                    && spec.sub_type != ARM_BOOTS))
            {
                spec.race = racial;
            }
        }
        int item_level = monster_level;
        if (spec.level >= 0)
            item_level = spec.level;
        else
        {
            switch(spec.level)
            {
            case ISPEC_GOOD:
                item_level = 5 + item_level * 2;
                break;
            case ISPEC_SUPERB:
                item_level = MAKE_GOOD_ITEM;
                break;
            }
        }
        const int item_made =
            items( spec.allow_uniques, spec.base_type, spec.sub_type, true,
                   item_level, spec.race, 0, spec.ego );
        if (item_made != NON_ITEM && item_made != -1)
        {
            item_def &item(mitm[item_made]);
            mon.pickup_item(item, 0, true);
        }
    }
}
                                    
bool dgn_place_monster(mons_spec &mspec,

Replacement in crawl-ref/source/dungeon.cc at line 4343 [25.3429798]

B:BD[6.1073] → [6.1073:1171]

        if (placed && mindex != -1 && mindex != NON_MONSTER
            && mspec.colour != BLACK)

[6.1073]

[6.1171]

        if (placed && mindex != -1 && mindex != NON_MONSTER)

Replacement in crawl-ref/source/dungeon.cc at line 4345 [25.3429798]

B:BD[6.1181] → [6.1181:1229]

            menv[mindex].colour = mspec.colour;

[6.1181]

[6.1229]

            if (mspec.colour != BLACK)
                menv[mindex].colour = mspec.colour;
            if (mspec.items.size() > 0)
                dgn_give_mon_spec_items(mspec, mindex, mid, monster_level);

Replacement in crawl-ref/source/dungeon.cc at line 4358 [25.3429798]
B:BD[24.1202] → [24.1202:1230]
```
    const mons_spec &mspec,
```
[24.1202]
[24.1230]
```
    mons_spec &mspec,
```

Replacement in crawl-ref/source/dungeon.cc at line 4376 [25.3429798]

B:BD[26.1109] → [24.1518:1576]

∅:D[24.1576] → [26.1168:1223]

B:BD[26.1168] → [26.1168:1223]

        if (dgn_place_monster(place, mons.get_monster(i),
                               monster_level, vx, vy))

[26.1109]

[26.1223]

        mons_spec spec = mons.get_monster(i);
        if (dgn_place_monster(place, spec, monster_level, vx, vy))

Replacement in crawl-ref/source/debug.cc at line 1 [25.4016436]
B:BD[25.4016436] → [25.4016437:4016440]
```
/*
```
[25.4016436]
[25.4016440]
```
 /*
```
Replacement in crawl-ref/source/debug.cc at line 430 [25.4016436]
B:BD[24.2520] → [24.2520:2570]
```
    const mons_spec mspec = mlist.get_monster(0);
```
[24.2520]
[24.2570]
```
    mons_spec mspec = mlist.get_monster(0);
```

Replacement in crawl-ref/docs/level-design.txt at line 458 [27.350]

B:BD[2.11756] → [2.11756:11907]

          * "good_item" makes the builder try to make the item a good one.
          * "any" by itself gives random choice; you can combine "any" with

[2.11756]

[2.11907]

          * "no_uniq" prevents the item from being turned into an artefact.
          * "good_item" makes the builder try to make the item a good one
            (acquirement quality). 
          * "level:N" sets the object's item level (can't be used with
            "good_item").  If set to -2 then the object's item level will
            be the same as a "*" symbol item (five plus twice the
            vault's level number).
          * "any" by itself gives a random choice; you can combine "any" with

Insertion in crawl-ref/docs/level-design.txt at line 472 [27.350]

[2.12264]

          * "race:race_name", where "race_name" is "elvish", "dwarven"
             or "orcish"; it can also be "none" or "no_race" to prevent
             the item from being randomly being made racial.  Has no effect
             if the item can't take that kind of racial setting.
             NOTE: Can result in a non-racial item if used with "any" and
             the chosen item isn't compatible with the desired race.
          * "ego:ego_name", where "ego_name" is something like
            "running", "fire_resistance", and so on; "none" can be used
            to prevent the item from getting an ego.  The item must
            be fully specified, so trying "any weapon ego:vorpal" or
            "any armour ego:positive_energy" will result in an error.
            Trying to give an ego to something which can't accept an
            ego will also result in an error.

Replacement in crawl-ref/docs/level-design.txt at line 486 [27.350]

B:BD[2.12265] → [2.12265:12465]

          Limitations: You can't specify curse status nor item race,
          nor can you give specific egos, nor can give fixedarts. You
          also can't lay down corpses, skeletons, or chunks.

[2.12265]

[2.12465]

            WARNING: While checks are done to make sure that an armour
            ego isn't given to a weapon, a weapon ego to a missile,
            and so on, and also to make sure that egos are only given
            to amrours, weapons and missiles, no other checking is
            done.  Thus it is possible to create a demonic weapon of
            holy wrath or a helmet of running.
 
          Limitations: You can't specify curse status, specificy
          pluses or number of charges, force a randart or give fixedarts.
          You also can't lay down corpses, skeletons, or chunks.

Replacement in crawl-ref/docs/level-design.txt at line 509 [27.350]
B:BD[2.13142] → [2.13142:13186]
```
          MONS: generate_awake giant beetle
```
[2.13142]
[2.13186]
```
              MONS: generate_awake giant beetle
```
Replacement in crawl-ref/docs/level-design.txt at line 513 [27.350]
B:BD[2.13305] → [2.13305:13341]
```
          MONS: col:darkgrey fungus
```
[2.13305]
[27.14571]
```
              MONS: col:darkgrey fungus
```

Insertion in crawl-ref/docs/level-design.txt at line 517 [27.350]

[27.14842]

[2.13408]

          A monster can be given specific items by following the monster
          name with a semi-colon and then with an item list as described
          in ITEM:, but with slashes replaced with pipes and commas replaced
          with periods.  For example:
              MONS: orc ; katana | quick blade . chain mail | scale mail

Insertion in crawl-ref/docs/level-design.txt at line 523 [27.350]

[2.13409]

          will generate an orc wielding either a katana or a quick blade
          and wearing either a chain mail or a scale mail.  Randarts are
          never generated, and ego items are only generated if the ego
          is explicitly stated.  Note that any items that the monster was
          originally generated with will be removed and destroyed.  This
          can be used force a monster to have no items whatsoever:
              MONS: orc; nothing
          
          Items given to an orc or an elf will be made orcish or elven
          unless the item's race type is explicitly set otherwise.        
          Limitations: If an item in the item list has alternatives,
          there's no way to force all monsters dervied from that monster
          spec to choose the same alternative.  If a monster is given
          a random launcher, there is no way to force the ammo type to
          match the launcher type.

mapdef/vault items can now have their race type and ego explicitly set.

Dependencies

In channels

Change contents

Insertion in crawl-ref/source/mapdef.h at line 326 [5.591249]

Insertion in crawl-ref/source/mapdef.h at line 400 [5.591249]

Replacement in crawl-ref/source/mapdef.h at line 407 [5.591249]

Deletion in crawl-ref/source/mapdef.h at line 459 [5.591249]

Insertion in crawl-ref/source/mapdef.cc at line 1908 [5.594797]

Insertion in crawl-ref/source/mapdef.cc at line 1912 [5.594797]

Replacement in crawl-ref/source/mapdef.cc at line 1936 [5.594797]

Replacement in crawl-ref/source/mapdef.cc at line 1948 [5.594797]

Replacement in crawl-ref/source/mapdef.cc at line 1951 [5.594797]

Replacement in crawl-ref/source/mapdef.cc at line 1963 [5.594797]

Replacement in crawl-ref/source/mapdef.cc at line 1965 [5.594797]

Replacement in crawl-ref/source/mapdef.cc at line 1967 [5.594797]

Replacement in crawl-ref/source/mapdef.cc at line 1969 [5.594797]

Replacement in crawl-ref/source/mapdef.cc at line 1971 [5.594797]

Replacement in crawl-ref/source/mapdef.cc at line 1973 [5.594797]

Replacement in crawl-ref/source/mapdef.cc at line 1977 [5.594797]

Insertion in crawl-ref/source/mapdef.cc at line 1985 [5.594797]

Replacement in crawl-ref/source/mapdef.cc at line 2197 [5.594797]

Insertion in crawl-ref/source/mapdef.cc at line 2241 [5.594797]

Insertion in crawl-ref/source/mapdef.cc at line 2373 [5.594797]

Insertion in crawl-ref/source/mapdef.cc at line 2400 [5.594797]

Insertion in crawl-ref/source/mapdef.cc at line 2402 [5.594797]

Insertion in crawl-ref/source/mapdef.cc at line 2419 [5.594797]

Insertion in crawl-ref/source/mapdef.cc at line 2421 [5.594797]

Insertion in crawl-ref/source/mapdef.cc at line 2429 [5.594797]

Insertion in crawl-ref/source/mapdef.cc at line 2449 [5.594797]

Insertion in crawl-ref/source/mapdef.cc at line 2459 [5.594797]

Insertion in crawl-ref/source/mapdef.cc at line 2478 [5.594797]