else if (msg == "") // S_SILENT handled above

    else if (msg == "") // Still nothing found?

    // Don't enchant sticks marked with {!D}.
    if (!check_warning_inscriptions(you.inv[ weapon ], OPER_DESTROY))
    {
        mprf("%s feel%s slithery for a moment!",
             you.inv[weapon].name(DESC_CAP_YOUR).c_str(),
             you.inv[weapon].quantity > 1 ? "s" : "");
        return;
    }

        {
            i = next;
            continue;
        }
        if (!check_warning_inscriptions(mitm[i], OPER_DESTROY))

            mpr("Won't destroy {!D} inscribed item.");

            // Print this is addition to the above!

             // checked above
             if (xpos == you.x_pos && ypos == you.y_pos)
                 continue;

            // Checked above.
            if (xpos == you.x_pos && ypos == you.y_pos)
                continue;
            // Burn only squares in sight.
            if (!see_grid(xpos, ypos))
                continue;

             // burn only squares in sight
             if (!see_grid(xpos, ypos))
                 continue;

            // If a grid is blocked, books lying there will be ignored.
            // Allow bombing of monsters.
            const int cloud = env.cgrid[xpos][ypos];
            if (grid_is_solid(grd[ xpos ][ ypos ])
                || cloud != EMPTY_CLOUD && env.cloud[cloud].type != CLOUD_FIRE)
            {
                continue;
            }

             // if a grid is blocked, books lying there will be ignored
             // allow bombing of monsters
             const int cloud = env.cgrid[xpos][ypos];
             if (grid_is_solid(grd[ xpos ][ ypos ]) ||
//                 mgrd[ xpos ][ ypos ] != NON_MONSTER ||
                 (cloud != EMPTY_CLOUD && env.cloud[cloud].type != CLOUD_FIRE))
             {
                 continue;
             }

            int count = 0;
            int rarity = 0;
            i = igrd[xpos][ypos];
            while (i != NON_ITEM)
            {
                const int next = mitm[i].link; // in case we can't get it later

             int count = 0;
             int rarity = 0;
             i = igrd[xpos][ypos];
             while (i != NON_ITEM)
             {
                 const int next = mitm[i].link; // in case we can't get it later.

                if (mitm[i].base_type != OBJ_BOOKS
                    || mitm[i].sub_type == BOOK_MANUAL
                    || mitm[i].sub_type == BOOK_DESTRUCTION)
                {
                    i = next;
                    continue;
                }

                 if (mitm[i].base_type != OBJ_BOOKS
                     || mitm[i].sub_type == BOOK_MANUAL
                     || mitm[i].sub_type == BOOK_DESTRUCTION)
                 {
                     i = next;
                     continue;
                 }

                // Ignore {!D} inscribed books.
                if (!check_warning_inscriptions(mitm[i], OPER_DESTROY))
                {
                    mpr("Won't ignite {!D} inscribed book.");
                    i = next;
                    continue;
                }

                 // piety increases by 2 for books never picked up, else by 1

                 // Piety increases by 2 for books never picked up, else by 1.

        if ( _is_risky_sacrifice(item)
             || item.inscription.find("=p") != std::string::npos)

        // Ignore {!D} inscribed items.
        if (!check_warning_inscriptions(item, OPER_DESTROY))
        {
            mpr("Won't sacrifice {!D} inscribed item.");
            i = next;
            continue;
        }
        if (_is_risky_sacrifice(item)
            || item.inscription.find("=p") != std::string::npos)

            if ((item.base_type == OBJ_CORPSES &&
                 one_chance_in(2+you.piety/50))

            if (item.base_type == OBJ_CORPSES
                    && one_chance_in(2+you.piety/50)

                            monster_type cs, int power );

                            monster_type cs, int power, coord_def pos );

static band_type choose_band(int mon_type, int power, int &band_size );

static band_type _choose_band(int mon_type, int power, int &band_size );

    // Restricted fountains during generation, so we don't monsters
    // "trapped" in fountains for easy killing.

                    || actual_grid == DNGN_FOUNTAIN_BLUE)));

                    || !generation && actual_grid == DNGN_FOUNTAIN_BLUE)));

    const int type = mons_is_zombified(m) ? mons_zombie_base(m) : m->type;

    const int type = mons_is_zombified(m) ? mons_zombie_base(m)
                                          : m->type;

inline static bool mons_airborne(int mcls, int flies, bool paralysed)

inline static bool _mons_airborne(int mcls, int flies, bool paralysed)

    if (mons_airborne(monster_class, flies, paralysed)

    if (_mons_airborne(monster_class, flies, paralysed)

// Returns true if the monster can submerge in the given grid

// Returns true if the monster can submerge in the given grid.

    // Zombies of watery critters can not submerge.

        return false;

        return (false);

static void hell_spawn_random_monsters()

static void _hell_spawn_random_monsters()

        hell_spawn_random_monsters();

        _hell_spawn_random_monsters();

static bool can_place_on_trap(int mon_type, trap_type trap)

static bool _can_place_on_trap(int mon_type, trap_type trap)

static monster_type resolve_monster_type(monster_type mon_type,
                                         proximity_type proximity,
                                         monster_type base_type,
                                         coord_def &pos,
                                         unsigned mmask,
                                         dungeon_char_type *stair_type,
                                         int *lev_mons)

static monster_type _resolve_monster_type(monster_type mon_type,
                                          proximity_type proximity,
                                          monster_type base_type,
                                          coord_def &pos,
                                          unsigned mmask,
                                          dungeon_char_type *stair_type,
                                          int *lev_mons)

                    if (!can_place_on_trap(mon_type, env.trap[trap].type))

                    if (!_can_place_on_trap(mon_type, env.trap[trap].type))

    mg.cls = resolve_monster_type(mg.cls, mg.proximity, mg.base_type,
                                  mg.pos, mg.map_mask,
                                  &stair_type, &mg.power);

    mg.cls = _resolve_monster_type(mg.cls, mg.proximity, mg.base_type,
                                   mg.pos, mg.map_mask,
                                   &stair_type, &mg.power);

        const band_type band = choose_band(mg.cls, mg.power, band_size);

        const band_type band = _choose_band(mg.cls, mg.power, band_size);

        const int htype = (mons_class_is_zombified(mg.cls) ? mg.base_type
                                                           : mg.cls);

            habitat2grid( mons_habitat_by_type(mg.cls) );

            habitat2grid( mons_habitat_by_type(htype) );

            // Else choose a random point on the map.

            // Let's recheck these even for PROX_NEAR_STAIRS, just in case
            // occupied?

            // Let's recheck these even for PROX_NEAR_STAIRS, just in case.
            // Occupied?

                if (!can_place_on_trap(mg.cls, env.trap[trap].type))

                if (!_can_place_on_trap(mg.cls, env.trap[trap].type))

                close_to_player =
                    (distance(you.x_pos, you.y_pos,
                              mg.pos.x, mg.pos.y) < 64);

                close_to_player = (distance(you.x_pos, you.y_pos,
                                            mg.pos.x, mg.pos.y) < 64);

                    mg.pos = you.pos();

                    mg.pos         = you.pos();

            // cool.. passes all tests

            // Cool.. passes all tests.

        } // end while.. place first monster

        } // end while... place first monster

    // Message to player from stairwell/gate appearance?

    // Message to player from stairwell/gate appearance.

    // gotta be able to pick an ID

    // Gotta be able to pick an ID.

    // Too many monsters on level?

            if (trap >= 0 && !can_place_on_trap(mg.cls, env.trap[trap].type))

            if (trap >= 0 && !_can_place_on_trap(mg.cls, env.trap[trap].type))

            // cool.. passes all tests

            // Cool.. passes all tests.

        // did we really try 1000 times?

        // Did we really try 1000 times?

    menv[id].number = mg.number;

    menv[id].number       = mg.number;

        _define_zombie( id, mg.base_type, mg.cls, mg.power );

        _define_zombie( id, mg.base_type, mg.cls, mg.power, fpos );

    // give manticores 8 to 16 spike volleys.

    // Give manticores 8 to 16 spike volleys.

    // set attitude, behaviour and target

    // Set attitude, behaviour and target.

    // setting attitude will always make the
    // monster wander.. if you want sleeping
    // hostiles, use BEH_SLEEP since the default

    // Setting attitude will always make the monster wander...
    // If you want sleeping hostiles, use BEH_SLEEP since the default

                            monster_type cs, int power )

                            monster_type cs, int power, coord_def pos )

    monster_type cls       = MONS_PROGRAM_BUG;

    int zombie_size        = 0;

    int  zombie_size       = 0;

    monster_type cls       = MONS_PROGRAM_BUG;

            // Actually pick a monster that is happy where we want to put it.
            // Fish zombies on land are helpless and uncool.
            if (!monster_habitable_grid(cls, grd(pos)))
                continue;

            if (mons_zombie_size(cls) != zombie_size && zombie_size != -1)

            if (zombie_size != -1 && mons_zombie_size(cls) != zombie_size)

            level  = mons_level( cls ) - 4;
            diff   = level - power;

            level = mons_level( cls ) - 4;
            diff  = level - power;

        // set type and secondary appropriately

        // Set type and secondary appropriately.

        mons_sec2 = menv[mid].base_monster;

        mons_sec2              = menv[mid].base_monster;

    // Set type to the base type to calculate appropriate stats.

    menv[mid].hit_points = hit_points( menv[mid].hit_dice, 6, 5 );

    menv[mid].hit_points     = hit_points( menv[mid].hit_dice, 6, 5 );

    // Now override type with the required type.

        menv[mid].hit_points = hit_points( menv[mid].hit_dice, 5, 4 );

        menv[mid].hit_points     = hit_points( menv[mid].hit_dice, 5, 4 );

        menv[mid].hit_points = hit_points( menv[mid].hit_dice, 1, 4 );

        menv[mid].hit_points     = hit_points( menv[mid].hit_dice, 1, 4 );

        menv[mid].hit_points = hit_points( menv[mid].hit_dice, 4, 4 );

        menv[mid].hit_points     = hit_points( menv[mid].hit_dice, 4, 4 );

        menv[mid].ac += 4;
        menv[mid].type = MONS_SPECTRAL_THING;

        menv[mid].ac            += 4;
        menv[mid].type           = MONS_SPECTRAL_THING;

    menv[mid].colour = mons_class_colour(cs);

    menv[mid].colour       = mons_class_colour(cs);

static band_type choose_band( int mon_type, int power, int &band_size )

static band_type _choose_band( int mon_type, int power, int &band_size )

static int ood_limit()

static int _ood_limit()

             && mons_level(monster->type) >= you.your_level + ood_limit()

             && mons_level(monster->type) >= you.your_level + _ood_limit()

static monster_type pick_zot_exit_defender()

static monster_type _pick_zot_exit_defender()

        mg.cls    = pick_zot_exit_defender();

        mg.cls    = _pick_zot_exit_defender();

            // players won't summon out of LOS, or past transparent
            // walls.

            // Players won't summon out of LOS, or past transparent walls.

    const int type = mons_is_zombified(mon)? mons_zombie_base(mon) : mon->type;

    const int type = mons_is_zombified(mon) ? mons_zombie_base(mon)
                                            : mon->type;

            /* note that r.size() is unsigned */

            // Note that r.size() is unsigned.

                return true;

                return (true);

                return true;

                return (true);

    return false;

    return (false);

    case OPER_DESTROY:        return "destroy";

/* return true if user OK'd it (or no warning), false otherwise */

// Return true if user OK'd it (or no warning), false otherwise.

        // When it's about destroying an item, don't even ask.
        // If the player really wants to do that, they'll have
        // to remove the inscription.
        if (oper == OPER_DESTROY)
            return (false);

            // don't ask if item already worn

            // Don't ask if item already worn.

            // don't ask if item already worn

            // Don't ask if item already worn.

    OPER_DESTROY  = 'D',

        butchery is interupted, the auto-switch will be reversed as

        butchery is interrupted, the auto-switch will be reversed as

  !D   prompt before performing an action that might destroy this item
       If you're attempting to destroy an item thus inscribed by
       sacrificing it, destroying a weapon, or burning a book in the 
       name of various deities, the game won't even ask you for 
       confirmation but silently ignore this item. It also protects
       against accidentally casting Sticks to Snakes on your favourite
       weapon. Won't protect against lava accidents or hungry jellies.

   : crawl.read_options('docs/034_monster_glyphs.txt')
   additional_macro_file   = docs/034_command_keys.txt

   include                 = 034_monster_glyphs.txt
   additional_macro_file   = 034_command_keys.txt

you intend to use your old macros, you need to look through your macro.txt
file.

you intend to use your old macros, you'll need to look through your 
macro.txt file.