fiddlerwoaroof/crawl - Change HNPSSHGZFQ3E2I6X6VTKZ3WBBM2G25P2D7SIL2SZYKV2CCEA2ADAC

Implement the first part of FR 2055862: Make the database search also

output AC/EV and damage/accuracy/speed for armour and weapons, respectively.

Also, you can now wish for specific fixed and randarts in wizard mode via the 'o' command. (I was getting annoyed at always having to create all of them whenever I wanted to play around with the Singing Sword.)

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

Created by j-p-e-g on September 27, 2008

HNPSSHGZFQ3E2I6X6VTKZ3WBBM2G25P2D7SIL2SZYKV2CCEA2ADAC

Dependencies

In channels

main

Change contents

Insertion in crawl-ref/source/describe.h at line 60 [5.3734214]

[4.3151]

[5.3735845]


/* ***********************************************************************
 * called from: command
 * *********************************************************************** */
void append_weapon_stats(std::string &description, const item_def &item);
void append_armour_stats(std::string &description, const item_def &item);

Insertion in crawl-ref/source/describe.cc at line 784 [5.3736416]

[6.9310]

[5.3755433]


void append_weapon_stats(std::string &description, const item_def &item)
{
    description += "$Damage rating: ";
    _append_value(description, property( item, PWPN_DAMAGE ), false);
    description += "   ";

Insertion in crawl-ref/source/describe.cc at line 791 [5.3736416]

[5.3755434]

    description += "Accuracy rating: ";
    _append_value(description, property( item, PWPN_HIT ), true);
    description += "    ";
    description += "Base attack delay: ";
    _append_value(description, property( item, PWPN_SPEED ) * 10, false);
   description += "%";
}

Replacement in crawl-ref/source/describe.cc at line 900 [5.3736416]
∅:D[7.984374] → [5.3767102:3767108]
B:BD[5.3767102] → [5.3767102:3767108]
B:BD[5.3767108] → [8.1783:1826]
B:BD[8.1826] → [9.7315:7389]
∅:D[9.7389] → [10.307:337]
B:BD[5.3767224] → [10.307:337]
∅:D[10.337] → [5.3767224:3767225]
B:BD[5.3767224] → [5.3767224:3767225]
B:BD[5.3767225] → [10.338:382]
B:BD[10.382] → [9.7390:7460]
∅:D[9.7460] → [10.383:414]
B:BD[5.3767339] → [10.383:414]
∅:D[10.414] → [5.3767339:3767340]
B:BD[5.3767339] → [5.3767339:3767340]
B:BD[5.3767340] → [10.415:461]
B:BD[10.461] → [9.7461:7539]
∅:D[9.7539] → [7.984412:984440]
B:BD[5.3767464] → [7.984412:984440]
∅:D[7.984440] → [5.3767493:3767499]
B:BD[5.3767493] → [5.3767493:3767499]
```
    {
        description += "$Damage rating: ";
        _append_value(description, property( item, PWPN_DAMAGE ), false);
        description += "   ";
        description += "Accuracy rating: ";
        _append_value(description, property( item, PWPN_HIT ), true);
        description += "    ";
        description += "Base attack delay: ";
        _append_value(description, property( item, PWPN_SPEED ) * 10, false);
        description += "%";
    }
```
[7.984374]
[11.2844]
```
        append_weapon_stats(description, item);
```

Insertion in crawl-ref/source/describe.cc at line 1220 [5.3736416]

[5.3777799]


void append_armour_stats(std::string &description, const item_def &item)
{
    description += "$Armour rating: ";
    _append_value(description, property( item, PARM_AC ), false);
    description += "       ";

Insertion in crawl-ref/source/describe.cc at line 1227 [5.3736416]

[5.3777800]

    description += "Evasion modifier: ";
    _append_value(description, property( item, PARM_EVASION ), true);
}

Replacement in crawl-ref/source/describe.cc at line 1247 [5.3736416]
B:BD[5.3787547] → [5.3787547:3787590]
B:BD[5.3787590] → [9.7728:7798]
∅:D[9.7798] → [12.6345:6379]
B:BD[13.5730] → [12.6345:6379]
∅:D[13.5730] → [5.3788165:3788166]
∅:D[12.6379] → [5.3788165:3788166]
B:BD[5.3788165] → [5.3788165:3788166]
B:BD[5.3788166] → [12.6380:6425]
B:BD[12.6425] → [9.7799:7873]
```
        description += "$Armour rating: ";
        _append_value(description, property( item, PARM_AC ), false);
        description += "       ";
        description += "Evasion modifier: ";
        _append_value(description, property( item, PARM_EVASION ), true);
```
[5.3787547]
[5.3788313]
```
        append_armour_stats(description, item);
```

Insertion in crawl-ref/source/debug.h at line 132 [5.4011741]

[14.2338]

[5.4016394]


struct item_def;
bool get_item_by_name(item_def *item, char* specs,
                      object_class_type class_wanted,
                      bool create_for_real = false);

Deletion in crawl-ref/source/debug.cc at line 837 [5.4016436]
B:BD[15.151544] → [16.310:311]

Deletion in crawl-ref/source/debug.cc at line 1099 [5.4016436]

B:BD[5.4032917] → [17.10556:10587]

∅:D[17.10587] → [5.4032949:4033521]

B:BD[5.4032949] → [5.4032949:4033521]

    static int max_subtype[] =
    {
        NUM_WEAPONS,
        NUM_MISSILES,
        NUM_ARMOURS,
        NUM_WANDS,
        NUM_FOODS,
        0,              // unknown I
        NUM_SCROLLS,
        NUM_JEWELLERY,
        NUM_POTIONS,
        0,              // unknown II
        NUM_BOOKS,
        NUM_STAVES,
        0,              // Orbs         -- only one, handled specially
        NUM_MISCELLANY,
        0,              // corpses      -- handled specially
        0,              // gold         -- handled specially
        0,              // "gemstones"  -- no items of type
    };

Deletion in crawl-ref/source/debug.cc at line 1100 [5.4016436]
B:BD[5.4033551] → [5.4033551:4033597]
```
    char           obj_name[ ITEMNAME_SIZE ];
```
Deletion in crawl-ref/source/debug.cc at line 1101 [5.4016436]
B:BD[5.4033623] → [5.4033623:4033679]
```
    char *         ptr;
    int            best_index;
```
Deletion in crawl-ref/source/debug.cc at line 1102 [5.4016436]
B:BD[5.4033703] → [5.4033703:4033725]
```
    int            i;
```
Deletion in crawl-ref/source/debug.cc at line 1104 [5.4016436]
∅:D[18.4821] → [5.4033778:4033857]
B:BD[5.4033778] → [5.4033778:4033857]
```
    int            type_wanted    = -1;
    int            special_wanted = 0;
```

Insertion in crawl-ref/source/debug.cc at line 1217 [5.4016436]

[5.4037189]

            return;
        }
        if (!get_item_by_name(&mitm[thing_created], specs, class_wanted, true))
        {
            mpr( "No such item." );
            // Clean up item
            destroy_item(thing_created);

Insertion in crawl-ref/source/debug.cc at line 1228 [5.4016436]

[5.4037219]

    }
    // Deck colour (which control rarity) already set.
    if (!is_deck(mitm[thing_created]))
        item_colour( mitm[thing_created] );
    move_item_to_grid( &thing_created, you.pos() );
    if (thing_created != NON_ITEM)
    {
        // orig_monnum is used in corpses for things like the Animate
        // Dead spell, so leave it alone.
        if (class_wanted != OBJ_CORPSES)
            origin_acquired( mitm[thing_created], AQ_WIZMODE );
        canned_msg( MSG_SOMETHING_APPEARS );
    }
}
#endif
bool get_item_by_name(item_def *item, char* specs,
                      object_class_type class_wanted, bool create_for_real)
{
    static int max_subtype[] =
    {
        NUM_WEAPONS,
        NUM_MISSILES,
        NUM_ARMOURS,
        NUM_WANDS,
        NUM_FOODS,
        0,              // unknown I
        NUM_SCROLLS,
        NUM_JEWELLERY,
        NUM_POTIONS,
        0,              // unknown II
        NUM_BOOKS,
        NUM_STAVES,
        0,              // Orbs         -- only one, handled specially
        NUM_MISCELLANY,
        0,              // corpses      -- handled specially
        0,              // gold         -- handled specially
        0,              // "gemstones"  -- no items of type
    };

Replacement in crawl-ref/source/debug.cc at line 1271 [5.4016436]

B:BD[5.4037220] → [17.10763:10908]

∅:D[17.10908] → [5.4037367:4037792]

B:BD[5.4037367] → [5.4037367:4037792]

        // In order to get the sub-type, we'll fill out the base type...
        // then we're going to iterate over all possible subtype values
        // and see if we get a winner. -- bwr
        mitm[thing_created].base_type = class_wanted;
        mitm[thing_created].sub_type  = 0;
        mitm[thing_created].plus      = 0;
        mitm[thing_created].plus2     = 0;
        mitm[thing_created].special   = 0;
        mitm[thing_created].flags     = 0;
        mitm[thing_created].quantity  = 1;
        set_ident_flags( mitm[thing_created], ISFLAG_IDENT_MASK );

[5.4037220]

[16.5944]

    char           obj_name[ ITEMNAME_SIZE ];
    char*          ptr;
    int            i;
    int            best_index;
    int            type_wanted    = -1;
    int            special_wanted = 0;
    // In order to get the sub-type, we'll fill out the base type...
    // then we're going to iterate over all possible subtype values
    // and see if we get a winner. -- bwr
    item->base_type = class_wanted;
    item->sub_type  = 0;
    item->plus      = 0;
    item->plus2     = 0;
    item->special   = 0;
    item->flags     = 0;
    item->quantity  = 1;
    set_ident_flags( *item, ISFLAG_IDENT_MASK );
    if (class_wanted == OBJ_MISCELLANY)
    {
        // Leaves object unmodified if it wasn't a rune or deck.
        _rune_or_deck_from_specs(specs, *item);
        if (item->base_type == OBJ_UNASSIGNED)
        {
            // Rune or deck creation canceled, clean up item->
            return (false);
        }
    }

Replacement in crawl-ref/source/debug.cc at line 1302 [5.4016436]

B:BD[16.5945] → [16.5945:5989]

        if (class_wanted == OBJ_MISCELLANY)

[16.5945]

[16.5989]

    if (!item->sub_type)
    {
        type_wanted = -1;
        best_index  = 10000;
        for (i = 0; i < max_subtype[ item->base_type ]; i++)

Replacement in crawl-ref/source/debug.cc at line 1309 [5.4016436]

B:BD[16.5999] → [19.12453:12522]

B:BD[19.12522] → [20.8070:8136]

            // Leaves object unmodified if it wasn't a rune or deck.
            _rune_or_deck_from_specs(specs, mitm[thing_created]);

[16.5999]

[5.4037792]

            item->sub_type = i;
            strcpy(obj_name, item->name(DESC_PLAIN).c_str());

Replacement in crawl-ref/source/debug.cc at line 1312 [5.4016436]

B:BD[5.4037793] → [16.6133:6198]

            if (mitm[thing_created].base_type == OBJ_UNASSIGNED)

[5.4037793]

[16.6198]

            ptr = strstr( strlwr(obj_name), specs );
            if (ptr != NULL)

Replacement in crawl-ref/source/debug.cc at line 1315 [5.4016436]

B:BD[16.6212] → [19.12523:12589]

∅:D[19.12589] → [16.6277:6346]

B:BD[16.6277] → [16.6277:6346]

                // Rune or deck creation canceled, clean up item.
                destroy_item(thing_created);
                return;

[16.6212]

[16.6346]

                // Earliest match is the winner.
                if (ptr - obj_name < best_index)
                {
                    mpr( obj_name );
                    type_wanted = i;
                    best_index = ptr - obj_name;
                }

Replacement in crawl-ref/source/debug.cc at line 1325 [5.4016436]

B:BD[5.4038843] → [5.4038843:4038886]

        if (!mitm[thing_created].sub_type)

[5.4038843]

[5.4038886]

        if (type_wanted != -1)
        {
            item->sub_type = type_wanted;
            if (!create_for_real)
                return (true);
        }
        else

Replacement in crawl-ref/source/debug.cc at line 1333 [5.4016436]

B:BD[5.4038896] → [5.4038896:4038959]

            type_wanted = -1;
            best_index  = 10000;

[5.4038896]

[5.4038959]

            switch (class_wanted)
            {
            case OBJ_BOOKS:
                // Try if we get a match against a spell.
                if (_book_from_spell(specs, *item))
                    type_wanted = item->sub_type;
                break;

Replacement in crawl-ref/source/debug.cc at line 1341 [5.4016436]

B:BD[5.4038960] → [5.4038960:4039039]

            for (i = 0; i < max_subtype[ mitm[thing_created].base_type ]; i++)

[5.4038960]

[5.4039039]

            case OBJ_WEAPONS:

Replacement in crawl-ref/source/debug.cc at line 1343 [5.4016436]

B:BD[5.4039053] → [21.29293:29422]

                mitm[thing_created].sub_type = i;
                strcpy(obj_name,mitm[thing_created].name(DESC_PLAIN).c_str());

[5.4039053]

[5.4039180]

                // Try for fixed artefacts matching the name.
                unique_item_status_type exists;
                for (unsigned which = SPWPN_START_FIXEDARTS;
                     which <= SPWPN_END_FIXEDARTS; which++)
                {
                    exists = get_unique_item_status(OBJ_WEAPONS, which);
                    make_item_fixed_artefact(*item, false, which);
                    strcpy(obj_name, item->name(DESC_PLAIN).c_str());

Replacement in crawl-ref/source/debug.cc at line 1352 [5.4016436]

B:BD[5.4039181] → [16.6417:6474]

∅:D[16.6474] → [5.4039246:4039297]

B:BD[5.4039246] → [5.4039246:4039297]

B:BD[5.4039297] → [22.17553:17606]

∅:D[22.17606] → [5.4039349:4039402]

B:BD[5.4039349] → [5.4039349:4039402]

                ptr = strstr( strlwr(obj_name), specs );
                if (ptr != NULL)
                {
                    // Earliest match is the winner.
                    if (ptr - obj_name < best_index)

[5.4039181]

[5.4039402]

                    ptr = strstr( strlwr(obj_name), specs );
                    if (ptr != NULL)
                    {
                        if (create_for_real)
                            mpr( obj_name );
                        return(true);
                    }
                    else

Replacement in crawl-ref/source/debug.cc at line 1361 [5.4016436]

B:BD[5.4039424] → [5.4039424:4039465]

B:BD[5.4039465] → [17.10909:10950]

∅:D[17.10950] → [5.4039510:4039563]

B:BD[5.4039510] → [5.4039510:4039563]

                        mpr( obj_name );
                        type_wanted = i;
                        best_index = ptr - obj_name;

[5.4039424]

[5.4039563]

                        set_unique_item_status(OBJ_WEAPONS, which, exists);
                        do_uncurse_item(*item);
                        item->props.clear();

Replacement in crawl-ref/source/debug.cc at line 1367 [5.4016436]

B:BD[23.3131] → [23.3131:3196]


            if (type_wanted == -1 && class_wanted == OBJ_BOOKS)

[23.3131]

[23.3196]

            // intentional fall-through for the unrandarts
            case OBJ_ARMOUR:
            case OBJ_JEWELLERY:

Replacement in crawl-ref/source/debug.cc at line 1371 [5.4016436]

B:BD[23.3210] → [23.3210:3340]

∅:D[23.3340] → [5.4039603:4039617]

B:BD[5.4039603] → [5.4039603:4039617]

                if (_book_from_spell(specs, mitm[thing_created]))
                    type_wanted = mitm[thing_created].sub_type;
            }

[23.3210]

[5.4039617]

                bool exists;
                for (int unrand = 0; unrand < NO_UNRANDARTS; unrand++)
                {
                    exists = does_unrandart_exist( unrand );
                    make_item_unrandart(*item, unrand);
                    strcpy(obj_name, item->name(DESC_PLAIN).c_str());

Replacement in crawl-ref/source/debug.cc at line 1378 [5.4016436]

B:BD[5.4039618] → [5.4039618:4039667]

B:BD[5.4039667] → [22.17607:17673]

∅:D[22.17673] → [24.478969:479197]

B:BD[24.478969] → [24.478969:479197]

            if (type_wanted == -1)
            {
                // ds -- If specs is a valid int, try using that.
                //       Since zero is atoi's copout, the wizard
                //       must enter (subtype + 1).
                if (!(type_wanted = atoi(specs)))
                {
                    mpr( "No such item." );

[5.4039618]

[25.2615]

                    ptr = strstr( strlwr(obj_name), specs );
                    if (ptr != NULL && item->base_type == class_wanted)
                    {
                        if (create_for_real)
                            mpr( obj_name );
                        return(true);
                    }

Replacement in crawl-ref/source/debug.cc at line 1386 [5.4016436]

B:BD[25.2616] → [25.2616:2653]

B:BD[25.2653] → [26.6361:6410]

∅:D[25.2777] → [24.479197:479225]

∅:D[26.6410] → [24.479197:479225]

B:BD[24.479197] → [24.479197:479225]

                    // Clean up item
                    destroy_item(thing_created);
                    return;

[25.2616]

[24.479225]

                    set_unrandart_exist(unrand, exists);
                    do_uncurse_item(*item);
                    item->props.clear();

Replacement in crawl-ref/source/debug.cc at line 1390 [5.4016436]

B:BD[24.479243] → [24.479243:479274]

                type_wanted--;

[24.479243]

[5.4039731]


                // Reset base type to class_wanted, if nothing found.
                item->base_type = class_wanted;
                item->sub_type  = 0;
                break;

Replacement in crawl-ref/source/debug.cc at line 1397 [5.4016436]
∅:D[17.10952] → [5.4039758:4039814]
B:BD[5.4039758] → [5.4039758:4039814]
```
            mitm[thing_created].sub_type = type_wanted;
```
[17.10952]
[5.4039814]
```
            default:
                break;
            }
```
Replacement in crawl-ref/source/debug.cc at line 1402 [5.4016436]
∅:D[17.10954] → [5.4039833:4039880]
B:BD[5.4039833] → [5.4039833:4039880]
```
        switch (mitm[thing_created].base_type)
```
[17.10954]
[5.4039880]
```
        if (type_wanted == -1)
```

Replacement in crawl-ref/source/debug.cc at line 1404 [5.4016436]

B:BD[5.4039890] → [5.4039890:4040161]

        case OBJ_MISSILES:
            mitm[thing_created].quantity = 30;
            // intentional fall-through
        case OBJ_WEAPONS:
        case OBJ_ARMOUR:
            mpr( "What ego type? ", MSGCH_PROMPT );
            get_input_line( specs, sizeof( specs ) );

[5.4039890]

[17.10955]

            // ds -- If specs is a valid int, try using that.
            //       Since zero is atoi's copout, the wizard
            //       must enter (subtype + 1).
            if (!(type_wanted = atoi(specs)))
                return (false);
            type_wanted--;

Replacement in crawl-ref/source/debug.cc at line 1412 [5.4016436]

∅:D[17.10956] → [5.4040174:4040294]

B:BD[5.4040174] → [5.4040174:4040294]

            if (specs[0] != '\0')
            {
                special_wanted = 0;
                best_index = 10000;

[17.10956]

[5.4040294]

            item->sub_type = type_wanted;
        }
    }

Replacement in crawl-ref/source/debug.cc at line 1416 [5.4016436]

B:BD[5.4040295] → [5.4040295:4040407]

B:BD[5.4040407] → [21.29423:29534]

                for (i = 1; i < 25; i++)
                {
                    mitm[thing_created].special = i;
                    strcpy(obj_name,
                           mitm[thing_created].name(DESC_PLAIN).c_str());

[5.4040295]

[5.4040483]

    if (!create_for_real)
        return (true);

Replacement in crawl-ref/source/debug.cc at line 1419 [5.4016436]

B:BD[5.4040484] → [5.4040484:4040796]

B:BD[5.4040796] → [17.10957:11005]

∅:D[17.11005] → [5.4040848:4040971]

B:BD[5.4040848] → [5.4040848:4040971]

                    ptr = strstr( strlwr(obj_name), strlwr(specs) );
                    if (ptr != NULL)
                    {
                        // earliest match is the winner
                        if (ptr - obj_name < best_index)
                        {
                            mpr( obj_name );
                            special_wanted = i;
                            best_index = ptr - obj_name;
                        }
                    }
                }

[5.4040484]

[5.4040971]

    switch (item->base_type)
    {
    case OBJ_MISSILES:
        item->quantity = 30;
        // intentional fall-through
    case OBJ_WEAPONS:
    case OBJ_ARMOUR:
        mpr( "What ego type? ", MSGCH_PROMPT );
        get_input_line( specs, sizeof( specs ) );

Replacement in crawl-ref/source/debug.cc at line 1429 [5.4016436]

B:BD[5.4040972] → [5.4040972:4041067]

                mitm[thing_created].special = special_wanted;
            }
            break;

[5.4040972]

[5.4041067]

        if (specs[0] != '\0')
        {
            special_wanted = 0;
            best_index = 10000;

Replacement in crawl-ref/source/debug.cc at line 1434 [5.4016436]

B:BD[5.4041068] → [5.4041068:4041153]

        case OBJ_BOOKS:
            if (mitm[thing_created].sub_type == BOOK_MANUAL)

[5.4041068]

[5.4041153]

            for (i = 1; i < 25; i++)

Replacement in crawl-ref/source/debug.cc at line 1436 [5.4016436]

B:BD[5.4041167] → [20.8137:8251]

                special_wanted =
                        _debug_prompt_for_skill( "A manual for which skill? " );

[5.4041167]

[27.5596]

                item->special = i;
                strcpy(obj_name, item->name(DESC_PLAIN).c_str());

Replacement in crawl-ref/source/debug.cc at line 1439 [5.4016436]
∅:D[27.5597] → [5.4041256:4041298]
∅:D[20.8251] → [5.4041256:4041298]
B:BD[5.4041256] → [5.4041256:4041298]
```
                if (special_wanted != -1)
```
[27.5597]
[27.5598]
```
                ptr = strstr( strlwr(obj_name), strlwr(specs) );
                if (ptr != NULL)
```

Replacement in crawl-ref/source/debug.cc at line 1442 [5.4016436]

B:BD[27.5616] → [27.5616:5745]

                    mitm[thing_created].plus  = special_wanted;
                    mitm[thing_created].plus2 = 3 + random2(15);

[27.5616]

[27.5745]

                    // earliest match is the winner
                    if (ptr - obj_name < best_index)
                    {
                        mpr( obj_name );
                        special_wanted = i;
                        best_index = ptr - obj_name;
                    }

Deletion in crawl-ref/source/debug.cc at line 1450 [5.4016436]
∅:D[27.5763] → [5.4041361:4041449]
B:BD[5.4041361] → [5.4041361:4041449]
```
                else
                    mpr( "Sorry, no books on that skill today." );
```
Deletion in crawl-ref/source/debug.cc at line 1451 [5.4016436]
B:BD[5.4041463] → [5.4041463:4041482]
```
            break;
```

Replacement in crawl-ref/source/debug.cc at line 1452 [5.4016436]

∅:D[17.11007] → [5.4041491:4041558]

B:BD[5.4041491] → [5.4041491:4041558]

B:BD[5.4041558] → [7.1025231:1025250]

        case OBJ_WANDS:
            mitm[thing_created].plus = 24;
            break;

[17.11007]

[7.1025250]

            item->special = special_wanted;
        }
        break;

Replacement in crawl-ref/source/debug.cc at line 1456 [5.4016436]

B:BD[7.1025251] → [7.1025251:1025328]

        case OBJ_STAVES:
            if (item_is_rod( mitm[thing_created] ))

[7.1025251]

[7.1025328]

    case OBJ_BOOKS:
        if (item->sub_type == BOOK_MANUAL)
        {
            special_wanted =
                    _debug_prompt_for_skill( "A manual for which skill? " );
            if (special_wanted != -1)

Replacement in crawl-ref/source/debug.cc at line 1464 [5.4016436]

B:BD[7.1025342] → [19.12590:12668]

∅:D[19.12668] → [7.1025419:1025497]

B:BD[7.1025419] → [7.1025419:1025497]

                mitm[thing_created].plus  = MAX_ROD_CHARGE * ROD_CHARGE_MULT;
                mitm[thing_created].plus2 = MAX_ROD_CHARGE * ROD_CHARGE_MULT;

[7.1025342]

[7.1025497]

                item->plus  = special_wanted;
                item->plus2 = 3 + random2(15);

Replacement in crawl-ref/source/debug.cc at line 1467 [5.4016436]

∅:D[7.1025511] → [5.4041558:4041577]

B:BD[5.4041558] → [5.4041558:4041577]

            break;

[7.1025511]

[5.4041577]

            else
                mpr( "Sorry, no books on that skill today." );
        }
        break;
    case OBJ_WANDS:
        item->plus = 24;
        break;
    case OBJ_STAVES:
        if (item_is_rod(*item))
        {
            item->plus  = MAX_ROD_CHARGE * ROD_CHARGE_MULT;
            item->plus2 = MAX_ROD_CHARGE * ROD_CHARGE_MULT;
        }
        break;
    case OBJ_MISCELLANY:
        if (!is_rune(*item) && !is_deck(*item))
            item->plus = 50;
        break;

Replacement in crawl-ref/source/debug.cc at line 1489 [5.4016436]

B:BD[5.4041578] → [5.4041578:4041607]

B:BD[5.4041607] → [16.6475:6602]

∅:D[16.6602] → [5.4041725:4041744]

B:BD[5.4041725] → [5.4041725:4041744]

        case OBJ_MISCELLANY:
            if (!is_rune(mitm[thing_created]) && !is_deck(mitm[thing_created]))
                mitm[thing_created].plus = 50;
            break;

[5.4041578]

[5.4041744]

    case OBJ_POTIONS:
        item->quantity = 12;
        if (is_blood_potion(*item))
            init_stack_blood_potions(*item);
        break;

Replacement in crawl-ref/source/debug.cc at line 1495 [5.4016436]

B:BD[5.4041745] → [28.18026:18052]

B:BD[28.18052] → [29.24848:24895]

B:BD[29.24895] → [30.17075:17129]

∅:D[30.17129] → [29.25040:25103]

B:BD[29.25040] → [29.25040:25103]

B:BD[29.25117] → [29.25117:25136]

        case OBJ_POTIONS:
            mitm[thing_created].quantity = 12;
            if (is_blood_potion(mitm[thing_created]))
                init_stack_blood_potions(mitm[thing_created]);
            break;

[5.4041745]

[29.25136]

    case OBJ_FOOD:
    case OBJ_SCROLLS:
        item->quantity = 12;
        break;

Replacement in crawl-ref/source/debug.cc at line 1500 [5.4016436]
∅:D[31.13808] → [5.4041745:4041794]
∅:D[28.18187] → [5.4041745:4041794]
∅:D[29.25137] → [5.4041745:4041794]
B:BD[5.4041745] → [5.4041745:4041794]
B:BD[5.4041820] → [5.4041820:4041867]
```
        case OBJ_FOOD:
        case OBJ_SCROLLS:
            mitm[thing_created].quantity = 12;
```
[29.25137]
[5.4041867]
```
    case OBJ_JEWELLERY:
        if (jewellery_is_amulet(*item))
```

Replacement in crawl-ref/source/debug.cc at line 1504 [5.4016436]

B:BD[5.4041887] → [3.7128:7693]

        case OBJ_JEWELLERY:
            if (jewellery_is_amulet(mitm[thing_created]))
                break;
            switch(mitm[thing_created].sub_type)
            {
            case RING_SLAYING:
                mitm[thing_created].plus2 = 5;
                // intentional fall-through
            case RING_PROTECTION:
            case RING_EVASION:
            case RING_STRENGTH:
            case RING_DEXTERITY:
            case RING_INTELLIGENCE:
                mitm[thing_created].plus = 5;
            default:
                break;
            }

[5.4041887]

        switch(item->sub_type)
        {
        case RING_SLAYING:
            item->plus2 = 5;
            // intentional fall-through
        case RING_PROTECTION:
        case RING_EVASION:
        case RING_STRENGTH:
        case RING_DEXTERITY:
        case RING_INTELLIGENCE:
            item->plus = 5;

Deletion in crawl-ref/source/debug.cc at line 1518 [5.4016436]
B:BD[5.4041933] → [5.4041933:4041939]
```
    }
```

Replacement in crawl-ref/source/debug.cc at line 1519 [5.4016436]

B:BD[5.4041940] → [16.6603:6740]

∅:D[16.6740] → [5.4041980:4041981]

B:BD[5.4041980] → [5.4041980:4041981]

B:BD[5.4041981] → [32.52368:52420]

    // Deck colour (which control rarity) already set
    if (!is_deck(mitm[thing_created]))
        item_colour( mitm[thing_created] );
    move_item_to_grid( &thing_created, you.pos() );

[5.4041940]

[5.4042044]

    default:
        break;
    }

Replacement in crawl-ref/source/debug.cc at line 1523 [5.4016436]

B:BD[5.4042045] → [5.4042045:4042080]

B:BD[5.4042080] → [24.479275:479281]

B:BD[24.479281] → [2.3138:3355]

∅:D[2.3355] → [5.4042080:4042125]

∅:D[24.479341] → [5.4042080:4042125]

B:BD[5.4042080] → [5.4042080:4042125]

B:BD[5.4042125] → [24.479342:479348]

    if (thing_created != NON_ITEM)
    {
        // orig_monnum is used in corpses for things like the Animate
        // Dead spell, so leave it alone.
        if (class_wanted != OBJ_CORPSES)
            origin_acquired( mitm[thing_created], AQ_WIZMODE );
        canned_msg( MSG_SOMETHING_APPEARS );
    }

[5.4042045]

[5.4042126]

    return (true);

Deletion in crawl-ref/source/debug.cc at line 1525 [5.4016436]
B:BD[5.4042128] → [5.4042128:4042135]
```
#endif
```

Deletion in crawl-ref/source/debug.cc at line 1526 [5.4016436]

B:BD[5.4042136] → [5.4042136:4042297]


//---------------------------------------------------------------
//
// create_spec_object
//
//---------------------------------------------------------------

Deletion in crawl-ref/source/debug.cc at line 1527 [5.4016436]
B:BD[5.4042311] → [33.4288:4289]
Insertion in crawl-ref/source/command.cc at line 24 [5.4082507]
[34.1761]
[34.1761]
```
#include "debug.h"
```

Insertion in crawl-ref/source/command.cc at line 1195 [5.4082507]

[35.13675]

[34.3126]

        else
        {
            int thing_created = get_item_slot();
            if (thing_created != NON_ITEM)
            {
                char name[80];
                snprintf(name, 80, key.c_str());
                if (get_item_by_name(&mitm[thing_created], name, OBJ_WEAPONS))
                {
                    append_weapon_stats(desc, mitm[thing_created]);
                    desc += "$";
                }
                else if (get_item_by_name(&mitm[thing_created], name, OBJ_ARMOUR))
                {
                    append_armour_stats(desc, mitm[thing_created]);
                    desc += "$";
                }
                // Now we don't need the item anymore.
                destroy_item(thing_created);
            }
        }