// XXX: ugly hack, but avoids adding dynamic allocation to this code

    // XXX: Ugly hack, but avoids adding dynamic allocation to this code.

    // some initial convenience & initializations

    // Some initial convenience & initializations.

    if ( returning && !one_chance_in(mons_power(monster->type) + 3) )

    if (returning && !one_chance_in(mons_power(monster->type) + 3))

    if ( really_returns )

    if (really_returns)

        // Fire beam in reverse

        // Fire beam in reverse.

        msg::stream << "The weapon returns to "

        msg::stream << "The weapon returns "

                        monster->name(DESC_NOCAP_THE) : "where it came from")

                          ("to " + monster->name(DESC_NOCAP_THE))
                        : "whence it came from")

        // Player saw the item return

        // Player saw the item return.

            set_ident_flags(mitm[hand_used], ISFLAG_KNOW_TYPE);

        {
            // Since this only happens for non-artefacts, also mark properties
            // as known.
            set_ident_flags(mitm[hand_used],
                            ISFLAG_KNOW_TYPE | ISFLAG_KNOW_PROPERTIES);
        }

                else if (mons_is_zombified(mons))
                {
                    simple_monster_message( mons, " sinks like a rock.",
                                            MSGCH_MONSTER_DAMAGE, MDAM_DEAD);
                }

    // NOTE: We never do any traversable() check for the starting square
    //       (target). This means that even if the target cannot be reached
    //       we may still find a path leading adjacent to this position, which
    //       is desirable if e.g. the player is hovering over deep water
    //       surrounded by shallow water or floor, or if a foe is hiding in
    //       a wall.
    //       If the surrounding squares also are not traversable, we return
    //       early that no path could be found.

//    memset(dist, INFINITE_DISTANCE, sizeof(dist));

            // Don't allow allies to pass over known Zot traps.

    // Moving from floor to water (or vice versa) is a bit more expensive.
    // The deep water checks are only done in case of amphibious monsters.
    if ((grd(pos) == DNGN_SHALLOW_WATER || grd(pos) == DNGN_DEEP_WATER)
           && grid_compatible(grd(npos), DNGN_FLOOR)
        || (grd(npos) == DNGN_SHALLOW_WATER || grd(npos) == DNGN_DEEP_WATER)
           && grid_compatible(grd(pos), DNGN_FLOOR))

    const int montype = mons_is_zombified(mons) ? mons_zombie_base(mons)
                                                : mons->type;
    const bool airborne = _mons_airborne(montype, -1, false);
    // Travelling through water, entering or leaving water is more expensive
    // for non-amphibious monsters, so they'll avoid it where possible.
    // Only tested for shallow water since they can't enter deep water anywa.
    if (!airborne && !mons_amphibious(montype)
        && (grd(pos) == DNGN_SHALLOW_WATER || grd(npos) == DNGN_SHALLOW_WATER))

        if (knows_trap)
        {
            const int montype = mons_is_zombified(mons) ? mons_zombie_base(mons)
                                                        : mons->type;

            // Mechanical traps can be avoided by flying, as can shafts, and
            // tele traps are never traversable anyway.
            if (!_mons_airborne(montype, -1, false))
                return 2;
        }

        // Mechanical traps can be avoided by flying, as can shafts, and
        // tele traps are never traversable anyway.
        if (knows_trap && !airborne)
            return 2;

//            mpr("Attempting to erase entry.");

            || mons_is_zombified(this)

            // for debugging, we don't have this silent.

            // For debugging, we don't have this silent.

    // Note: shields use ac-value as sh-value, EV pen is used for heavy_shield

    // Note: shields use ac-value as sh-value, EV pen is used for heavy_shield.

        // all flags necessary for full identification

        // All flags necessary for full identification.

                    || (get_armour_slot( *this ) == EQ_HELMET &&
                        !is_hard_helmet( *this )))

                    || get_armour_slot( *this ) == EQ_HELMET
                       && !is_hard_helmet( *this ))

    bool returning   = false;    // item can return to pack
    bool did_return  = false;    // returning item actually does return to pack

    bool returning   = false;    // Item can return to pack.
    bool did_return  = false;    // Returning item actually does return to pack.

            set_ident_flags(you.inv[throw_2], ISFLAG_KNOW_TYPE);

        {
            // Since this only happens for non-artefacts, also mark properties
            // as known.
            set_ident_flags(you.inv[throw_2],
                            ISFLAG_KNOW_TYPE | ISFLAG_KNOW_PROPERTIES);
        }

        // Next, let's take care of messaging {dlb}:
        if (how_carnivorous > 0 && carnivore_modifier < 0)
            mpr("Blech - you need meat!");
        else if (how_herbivorous > 0 && herbivore_modifier < 0)
            mpr("Blech - you need greens!");

    // don't drink poisonous or mutagenic blood

    // Don't drink poisonous or mutagenic blood.

            int old_poison = 0;

            int old_poison;

            else
                old_poison = (def->get_ench(ENCH_POISON)).degree;

                && old_poison < you.duration[DUR_POISONING])

                   && old_poison < you.duration[DUR_POISONING]
                || defender->atype() != ACT_PLAYER
                   && old_poison < (def->get_ench(ENCH_POISON)).degree)

        // 9 = speed - done before

        // note: leaving special_damage_message empty because there
        // isn't one.

        // Note: Leaving special_damage_message empty because there isn't one.

        // vampire bat form, why the special handling?

        // Vampire bat form -- why the special handling?

        // handle weapon effects

        // Handle weapon effects.

        // thus is probably more valuable on larger weapons?

        // Thus is probably more valuable on larger weapons?

// actually poisons a monster (w/ message)

// Actually poisons a monster (w/ message).

    // actually do the poisoning
    // note: order important here

    // Actually do the poisoning.
    // Note: order important here.

    // finally, take care of deity preferences

    // Finally, take care of deity preferences.

// actually napalms a monster (w/ message)

// Actually napalms a monster (w/ message).