bool swap_features(const coord_def &pos1, const coord_def &pos2,
                   bool swap_everything = false);

#include "cloud.h"

// Um, what does this do? (jpeg)

// Clear blood off of terrain that shouldn't have it.  Also clear
// of blood if a bloody wall has been dug out and replaced by a floor,
// or if a bloody floor has been replaced by a wall.

        }
    }
}
void _dgn_check_terrain_player(const coord_def pos)
{
    if (pos != you.pos())
        return;
    if (you.can_pass_through(pos) || !grid_is_solid(grd(pos)))
    {
        if (!you.airborne())
        {
            // If the monster can't stay submerged in the new terrain
            // and there aren't any adjacent squares where it can
            // stay submerged then move it.
            if (mgrd(you.pos()) != NON_MONSTER
                && !mons_is_submerged( &menv[ mgrd(you.pos()) ] ))
            {
                monster_teleport( &menv[ mgrd(you.pos()) ], true, false);
            }
            move_player_to_grid(pos, false, true, false);

    else
        you_teleport_now(true, false);

    if (affect_player && pos == you.pos())

    if (affect_player)
        _dgn_check_terrain_player(pos);
    set_terrain_changed(pos.x, pos.y);
}
bool swap_features(const coord_def &pos1, const coord_def &pos2,
                   bool swap_everything)
{
    ASSERT(in_bounds(pos1) && in_bounds(pos2));
    ASSERT(pos1 != pos2);
    const dungeon_feature_type feat1 = grd(pos1);
    const dungeon_feature_type feat2 = grd(pos2);
    if (is_sanctuary(pos1) || is_sanctuary(pos2))
        return (false);
    if (is_notable_terrain(feat1) && !see_grid(pos1)
        && is_terrain_known(pos1.x, pos1.y))

        if (!grid_is_solid(grd(pos)))

        return (false);
    }
    if (is_notable_terrain(feat2) && !see_grid(pos2)
        && is_terrain_known(pos2.x, pos2.y))
    {
        return (false);
    }
    const unsigned short col1 = env.grid_colours(pos1);
    const unsigned short col2 = env.grid_colours(pos2);
    const unsigned long prop1 = env.map(pos1).property;
    const unsigned long prop2 = env.map(pos2).property;
    trap_def* trap1 = find_trap(pos1);
    trap_def* trap2 = find_trap(pos2);
    // Find a temporary holding place for pos1 stuff to be moved to
    // before pos2 is moved to pos1.
    coord_def temp(-1, -1);
    for (int x = X_BOUND_1 + 1; x < X_BOUND_2; x++)
    {
        for (int y = Y_BOUND_1 + 1; y < Y_BOUND_2; y++)

            if (!you.airborne())

            coord_def pos(x, y);
            if (pos == pos1 || pos == pos2)
                continue;
            if (!env.markers.find(pos, MAT_ANY)
                && !is_notable_terrain(grd(pos))
                && env.cgrid(pos) == EMPTY_CLOUD)

                // If the monster can't stay submerged in the new terrain
                // and there aren't any adjacent squares where it can
                // stay submerged then move it.
                if (mgrd(you.pos()) != NON_MONSTER
                    && !mons_is_submerged( &menv[ mgrd(you.pos()) ] ))
                {
                    monster_teleport( &menv[ mgrd(you.pos()) ], true, false);
                }
                move_player_to_grid(pos, false, true, false);

                temp = pos;
                break;

        else
            you_teleport_now(true, false);

        if (in_bounds(temp))
            break;

    set_terrain_changed(pos.x, pos.y);

    if (!in_bounds(temp))
    {
        mpr("swap_features(): No boring squares on level?", MSGCH_ERROR);
        return (false);
    }
    (void) move_notable_thing(pos1, temp);
    env.markers.move(pos1, temp);
    dungeon_events.move_listeners(pos1, temp);
    grd(pos1) = DNGN_UNSEEN;
    env.map(pos1).property = 0;
    (void) move_notable_thing(pos2, pos1);
    env.markers.move(pos2, pos1);
    dungeon_events.move_listeners(pos2, pos1);
    grd(pos2) = feat1;
    grd(pos1) = feat2;
    env.map(pos1).property = prop2;
    env.map(pos2).property = prop1;
    (void) move_notable_thing(temp, pos2);
    env.markers.move(temp, pos2);
    dungeon_events.move_listeners(temp, pos2);
    env.grid_colours(pos1) = col2;
    env.grid_colours(pos2) = col1;
    if (trap1)
        trap1->pos = pos2;
    if (trap2)
        trap2->pos = pos1;
    if (!swap_everything)
    {
        _dgn_check_terrain_items(pos1, false);
        _dgn_check_terrain_monsters(pos1);
        _dgn_check_terrain_player(pos1);
        set_terrain_changed(pos1.x, pos1.y);
        _dgn_check_terrain_items(pos2, false);
        _dgn_check_terrain_monsters(pos2);
        _dgn_check_terrain_player(pos2);
        set_terrain_changed(pos2.x, pos2.y);
        return (true);
    }
    const int i1 = igrd(pos1);
    const int i2 = igrd(pos2);
    igrd(pos1) = i2;
    igrd(pos2) = i1;
    const int m1 = mgrd(pos1);
    const int m2 = mgrd(pos1);
    mgrd(pos1) = m2;
    mgrd(pos2) = m1;
    move_cloud(env.cgrid(pos1), temp);
    move_cloud(env.cgrid(pos2), pos1);
    move_cloud(env.cgrid(temp), pos2);
    if (pos1 == you.pos())
    {
        you.position = pos2;
        viewwindow(true, false);
    }
    else if (pos2 == you.pos())
    {
        you.position = pos1;
        viewwindow(true, false);
    }
    set_terrain_changed(pos1.x, pos1.y);
    set_terrain_changed(pos2.x, pos2.y);
    return (false);

                     bool quiet = false);

                     bool quiet = false, int* mon_index = NULL);

                           unsigned short hitting, god_type god, bool actual)

                           unsigned short hitting, god_type god, bool actual,
                           int* mon_index)

    if (mon_index != NULL)
        *mon_index = -1;

    if (mon_index != NULL)
        *mon_index = monster;

                     bool quiet)

                     bool quiet, int* mon_index)

            success = _raise_remains(a, si.link(), beha, hitting, god, actual);

            success = _raise_remains(a, si.link(), beha, hitting, god, actual,
                                     mon_index);

}
bool actor::is_habitable(const coord_def &_pos) const
{
    return is_habitable_feat(grd(_pos));
}
bool player::is_habitable_feat(dungeon_feature_type actual_grid) const
{
    return can_pass_through_feat(actual_grid);

}
bool actor::can_wield(const item_def* item, bool ignore_curse,
                      bool ignore_brand, bool ignore_shield,
                      bool ignore_transform) const
{
    if (item == NULL)
    {
        // Unarmed combat.
        item_def fake;
        fake.base_type = OBJ_UNASSIGNED;
        return can_wield(fake, ignore_curse, ignore_brand, ignore_transform);
    }
    else
        return can_wield(*item, ignore_curse, ignore_brand, ignore_transform);
}
bool player::can_wield(const item_def& item, bool ignore_curse,
                       bool ignore_brand, bool ignore_shield,
                       bool ignore_transform) const
{
    if (equip[EQ_WEAPON] != -1 && !ignore_curse)
    {
        if (item_cursed(inv[equip[EQ_WEAPON]]))
            return (false);
    }
    // Unassigned means unarmed combat.
    const bool two_handed = item.base_type == OBJ_UNASSIGNED
                            || hands_reqd(item, body_size()) == HANDS_TWO;
    if (two_handed && !ignore_shield && equip[EQ_SHIELD] != -1)
        return (false);
    return could_wield(item, ignore_brand, ignore_transform);

bool player::could_wield(const item_def &item, bool ignore_brand,
                         bool /* ignore_transform */) const
{
    if (!check_weapon_wieldable_size(item, body_size(PSIZE_BODY)))
        return (false);

    if (!ignore_brand)
    {
        if (is_holy_item(item)
            && (you.is_undead || you.species == SP_DEMONSPAWN))
        {
            return (false);
        }
    }
#if 0
    if (!ignore_transform  && !transform_can_equip_type( EQ_WEAPON ))
        return (false);
#endif
    return (true);
}

bool player::is_summoned(int* _duration, int* summon_type) const
{
    if (_duration != NULL)
        *_duration = -1;
    if (summon_type != NULL)
        *summon_type = 0;
    return (false);
}

bool move_notable_thing(const coord_def& orig, const coord_def& dest);

}
bool move_notable_thing(const coord_def& orig, const coord_def& dest)
{
    ASSERT(in_bounds(orig) && in_bounds(dest));
    ASSERT(orig != dest);
    ASSERT(!is_notable_terrain(grd(dest)));
    if (!is_notable_terrain(grd(orig)))
        return (false);
    level_pos pos1(level_id::current(), orig);
    level_pos pos2(level_id::current(), dest);
    shops_present[pos2]         = shops_present[pos1];
    altars_present[pos2]        = altars_present[pos1];
    portals_present[pos2]       = portals_present[pos1];
    portal_vaults_present[pos2] = portal_vaults_present[pos1];
    portal_vault_notes[pos2]    = portal_vault_notes[pos1];
    portal_vault_colours[pos2]  = portal_vault_colours[pos1];
    unnotice_feature(pos1);
    return (true);

int fill_out_corpse(const monsters* monster, item_def& corpse,
                    bool allow_weightless = false);

static void _place_monster_corpse(const monsters *monster, bool silent,
                                  int summon_type)

int fill_out_corpse(const monsters* monster, item_def& corpse,
                    bool allow_weightless)

    bool force        = false;
    int  corpse_class = mons_species(monster->type);

    ASSERT(monster->type != -1 && monster->type != MONS_PROGRAM_BUG);
    corpse.clear();
    int summon_type;
    if (mons_is_summoned(monster, NULL, &summon_type)
        || mons_enslaved_body_and_soul(monster)
        || (monster->flags & (MF_BANISHED | MF_HARD_RESET)))
    {
        return (-1);
    }
    int corpse_class = mons_species(monster->type);

        force        = true;

    if (mons_weight(corpse_class) == 0 || mons_enslaved_body_and_soul(monster)
        || (!force && coinflip()))
    {
        return;
    }

    if (mons_weight(corpse_class) == 0 && !allow_weightless)
        return (-1);
    corpse.flags       = 0;
    corpse.base_type   = OBJ_CORPSES;
    corpse.plus        = corpse_class;
    corpse.plus2       = 0;    // butcher work done
    corpse.sub_type    = CORPSE_BODY;
    corpse.special     = FRESHEST_CORPSE;  // rot time
    corpse.quantity    = 1;
    corpse.orig_monnum = monster->type + 1;
    corpse.props[MONSTER_NUMBER] = short(monster->number);

    corpse.colour = mons_class_colour(corpse_class);
    if (corpse.colour == BLACK)
        corpse.colour = monster->colour;
    return (corpse_class);
}
static void _place_monster_corpse(const monsters *monster, bool silent)
{

    mitm[o].flags     = 0;
    mitm[o].base_type = OBJ_CORPSES;
    mitm[o].plus      = corpse_class;
    mitm[o].plus2     = 0;    // butcher work done
    mitm[o].sub_type  = CORPSE_BODY;
    mitm[o].special   = FRESHEST_CORPSE;  // rot time
    mitm[o].colour    = mons_class_colour(corpse_class);
    mitm[o].quantity  = 1;
    mitm[o].props[MONSTER_NUMBER] = short(monster->number);

    const int corpse_class = fill_out_corpse(monster, mitm[o]);

    if (mitm[o].colour == BLACK)
        mitm[o].colour = monster->colour;

    // Don't place a corpse?  If a zombified monster is somehow capable
    // of leaving a corpse then always place it.
    const bool force = mons_class_is_zombified(monster->type);
    if (corpse_class == -1 || (!force && coinflip()))
        return;

        // Have to add case for disintegration effect here? {dlb}

            // Have to add case for disintegration effect here? {dlb}
            _place_monster_corpse(monster, silent, summon_type);

            _place_monster_corpse(monster, silent);

bool monsters::is_habitable_feat(dungeon_feature_type actual_grid) const
{
    return monster_habitable_grid(this, actual_grid);
}

bool monsters::can_wield(const item_def& item, bool ignore_curse,
                         bool ignore_brand, bool ignore_shield,
                         bool ignore_transform) const
{
    // Monsters can only wield weapons or go unarmed (OBJ_UNASSIGNED
    // means unarmed)
    if (item.base_type != OBJ_WEAPONS && item.base_type != OBJ_UNASSIGNED)
        return (false);

    // These *are* weapons, so they can't wield another weapon or
    // unwield themselves.
    if (type == MONS_DANCING_WEAPON)
        return (false);

    // MF_HARD_RESET means that all items the monster is carrying will
    // disappear when it does, so it can't accept new items or give up
    // the ones it has.
    if (flags & MF_HARD_RESET)
        return (false);
    // Summoned items can only be held by summoned monsters.
    if ((item.flags & ISFLAG_SUMMONED) && !is_summoned())
        return (false);
    item_def* weap1 = NULL;
    if (inv[MSLOT_WEAPON] != NON_ITEM)
        weap1 = &mitm[inv[MSLOT_WEAPON]];
    int       avail_slots = 1;
    item_def* weap2       = NULL;
    if (mons_wields_two_weapons(this))
    {
        if (!weap1 || hands_reqd(*weap1, body_size()) != HANDS_TWO)
            avail_slots = 2;
        const int offhand = mons_offhand_weapon_index(this);
        if (offhand != NON_ITEM)
            weap2 = &mitm[offhand];
    }
    // If we're already wielding it, then of course we can wield it.
    if (&item == weap1 || &item == weap2)
        return(true);
    // Barehanded needs two hands.
    const bool two_handed = item.base_type == OBJ_UNASSIGNED
                            || hands_reqd(item, body_size()) == HANDS_TWO;
    item_def* _shield = NULL;
    if (inv[MSLOT_SHIELD] != NON_ITEM)
    {
        ASSERT(!(weap1 && weap2));
        if (!ignore_shield && two_handed)
            return (false);
        _shield = &mitm[inv[MSLOT_SHIELD]];
    }
    if (!ignore_curse)
    {
        int num_cursed = 0;
        if (weap1 && item_cursed(*weap1))
            num_cursed++;
        if (weap2 && item_cursed(*weap2))
            num_cursed++;
        if (_shield && item_cursed(*_shield))
            num_cursed++;
        if (two_handed && num_cursed > 0 || num_cursed >= avail_slots)
            return (false);
    }
    return could_wield(item, ignore_brand, ignore_transform);
}
bool monsters::could_wield(const item_def &item, bool ignore_brand,
                           bool /* ignore_transform */) const
{
    ASSERT(is_valid_item(item));
    // These *are* weapons, so they can't wield another weapon.
    if (type == MONS_DANCING_WEAPON)
        return (false);
    // Monsters can't use fixed artefacts
    if (is_fixed_artefact(item))
        return (false);
    // Wimpy monsters (e.g. kobold, goblin) can't use halberds etc.
    if (!check_weapon_wieldable_size(item, body_size(PSIZE_BODY)))
        return (false);
    if (!ignore_brand)
    {
        // Demonic/undead monsters won't use holy weapons.
        if (mons_is_unholy(this) && is_holy_item(item))
            return (false);
        // Holy monsters won't use demonic or chaotic weapons.
        if (mons_holiness(this) == MH_HOLY
            && (is_evil_item(item) || get_weapon_brand(item) == SPWPN_CHAOS))
        {
            return (false);
        }
    }
    return (true);
}

    if (!force && mons_near(this) && player_monster_visible(this))

    if (!force && you.can_see(this))

    // monsters can't use fixed artefacts
    if (is_fixed_artefact( weap ))
        return (false);

    if (!could_wield(weap))
       return (false);

    // Wimpy monsters (e.g. kobold, goblin) shouldn't pick up halberds etc.
    if (!check_weapon_wieldable_size(weap, body_size(PSIZE_BODY)))
        return (false);

    // Nobody picks up giant clubs.
    // Starting equipment is okay, of course.

    // Nobody picks up giant clubs. Starting equipment is okay, of course.

    // Demonic/undead monsters won't pick up holy wrath.
    if (get_weapon_brand(weap) == SPWPN_HOLY_WRATH && mons_is_unholy(this))
        return (false);
    // Holy monsters won't pick up demonic weapons.
    if (mons_holiness(this) == MH_HOLY && is_evil_item(weap))
        return (false);

int  move_item_to_player( int obj, int quant_got, bool quiet = false );

int  move_item_to_player( int obj, int quant_got, bool quiet = false,
                          bool ignore_burden = false );

int move_item_to_player( int obj, int quant_got, bool quiet )

int move_item_to_player( int obj, int quant_got, bool quiet,
                         bool ignore_burden )

    if (you.burden + imass > carrying_capacity())

    if (!ignore_burden && (you.burden + imass > carrying_capacity()))

#include "dgnevent.h"

static bool _ok_dest_grid(const coord_def &dest)
{
    dungeon_feature_type feat = grd(dest);
    if (grid_destroys_items(feat) || grid_is_solid(feat)
        || grid_is_water(feat) || grid_is_trap(feat, true)
        || is_notable_terrain(feat))
    {
        return (false);
    }

    return (true);
}

    // Moving shops is too much trouble, and anyways the player can't
    // use them to escape.

    // The player can't use shops to escape, so don't bother.

    const bool stair_is_marker = env.markers.find(orig_pos, MAT_ANY);

    // Don't move around notable terrain the player is aware of if it's
    // out of sight.
    if (is_notable_terrain(stair_feat)
        && is_terrain_known(orig_pos.x, orig_pos.y) && !see_grid(orig_pos))
    {
        return (false);
    }

    if (defender->alive() && defender->pos() != attacker->pos())

    if (defender->alive() && defender->pos() != attacker->pos()
        && _ok_dest_grid(defender->pos()))

        dungeon_feature_type feat = grd(defender->pos());
        if (!grid_destroys_items(feat) && !grid_is_solid(feat)
            && !grid_is_water(feat) && !grid_is_trap(feat, true))
        {
            dest = defender->pos();
        }
        // Don't try to swap two markers.
        if (stair_is_marker && env.markers.find(defender->pos(), MAT_ANY))
            dest.set(-1, -1);

        dest = defender->pos();

            // Don't try to swap two markers.
            if (stair_is_marker && env.markers.find(*ri, MAT_ANY))
                continue;
            dungeon_feature_type feat = grd(defender->pos());
            if (!grid_destroys_items(feat) && !grid_is_solid(feat)
                && !grid_is_water(feat) && !grid_is_trap(feat, true))

            if (_ok_dest_grid(*ri))

    const bool dest_is_marker            = env.markers.find(dest, MAT_ANY);
    const dungeon_feature_type dest_feat = grd(defender->pos());
    ASSERT(!(dest_is_marker && stair_is_marker));

    dungeon_terrain_changed(orig_pos, dest_feat);
    dungeon_terrain_changed(dest,      stair_feat);

    if (!swap_features(orig_pos, dest))
        return (false);

    if (stair_is_marker)
    {
        env.markers.move(orig_pos, dest);
        dungeon_events.move_listeners(orig_pos, dest);
    }
    else if (dest_is_marker)
    {
        env.markers.move(dest, orig_pos);
        dungeon_events.move_listeners(dest, orig_pos);
    }

    // Is player aware of it happening?

static void _find_remains(monsters* mon, int &corpse_class, int &corpse,
                          int &last_item, std::vector<int> items)

static void _find_remains(monsters* mon, int &corpse_class, int &corpse_index,
                          item_def &fake_corpse, int &last_item,
                          std::vector<int> items)

    corpse    = NON_ITEM;
    last_item = NON_ITEM;

    corpse_index = NON_ITEM;
    last_item    = NON_ITEM;

    corpse_class = mons_species(mon->type);

    corpse_class = fill_out_corpse(mon, fake_corpse, true);
    if (corpse_class == -1 || mons_weight(corpse_class) == 0)
        return;

    if (corpse_class == MONS_DRACONIAN)
        corpse_class = draco_subspecies(mon);
    if (mon->has_ench(ENCH_SHAPESHIFTER))
        corpse_class = MONS_SHAPESHIFTER;
    else if (mon->has_ench(ENCH_GLOWING_SHAPESHIFTER))
        corpse_class = MONS_GLOWING_SHAPESHIFTER;

            if (si->plus != corpse_class)
                break;
            // It should have just been dropped.
            if (corpse_freshness(*si) != FRESHEST_CORPSE)

            if (si->orig_monnum != fake_corpse.orig_monnum
                || si->plus != fake_corpse.plus
                || si->plus2 != fake_corpse.plus2
                || si->special != fake_corpse.special
                || si->flags != fake_corpse.flags)
            {

            }

            // If there was an opportunity to butcher it then it can't
            // have just been dropped.
            if (si->plus2 != 0)
                break;
            // It can't have been just made if it was picked up or
            // dropped.
            if (si->flags & (ISFLAG_DROPPED | ISFLAG_BEEN_IN_INV))
                break;

            corpse = si.link();

            corpse_index = si.link();

static bool _make_zombie(monsters* mon, int corpse_class, int corpse,
                         int last_item)

static bool _make_zombie(monsters* mon, int corpse_class, int corpse_index,
                         item_def &fake_corpse, int last_item)

    if (corpse != NON_ITEM || !mons_class_can_be_zombified(corpse_class))

    if (corpse_index != NON_ITEM || !mons_class_can_be_zombified(corpse_class))
        return (false);
    // Good gods won't let their gifts/followers be raised as the undead.
    if (is_good_god(mon->god))

    int idx = get_item_slot();

    // First attempt to raise zombie fitted out with all its old equipment.
    int zombie_index = -1;
    int idx = get_item_slot(0);

        // Fake a corpse
        item_def &corpse_item(mitm[idx]);
        corpse_item.base_type   = OBJ_CORPSES;
        corpse_item.sub_type    = CORPSE_BODY;
        corpse_item.plus        = corpse_class;
        corpse_item.orig_monnum = mon->type + 1;
        corpse_item.pos         = mon->pos();
        corpse_item.quantity    = 1;
        corpse_item.props[MONSTER_NUMBER] = short(mon->number);

        mitm[idx]     = fake_corpse;
        mitm[idx].pos = mon->pos();

        // Insert it in the item stack right after the monster's
        // last item, so it will be equipped with all the monster's
        // items.
        corpse_item.link = mitm[last_item].link;

        // Insert it in the item stack right after the monster's last item, so
        // it will be equipped with all the monster's items.
        mitm[idx].link       = mitm[last_item].link;

        void (animate_remains(mon->pos(), CORPSE_BODY, mon->behaviour,
                              mon->foe, mon->god, true, true, &zombie_index));
    }

        if (animate_remains(mon->pos(), CORPSE_BODY, mon->behaviour,
                            mon->foe, mon->god, true, true))
        {
            if (you.can_see(mon))
                simple_monster_message(mon,
                                       " instantly turns into a zombie!");
            else if (see_grid(mon->pos()))
                mpr("A zombie appears out of nowhere!");
            return (true);
        }

    // No equipment to get, or couldn't get it for some reason.
    if (zombie_index == -1)
    {
        monster_type type = (mons_zombie_size(mon->type) == Z_SMALL) ?
                            MONS_ZOMBIE_SMALL : MONS_ZOMBIE_LARGE;
        zombie_index = create_monster(
                           mgen_data(type, mon->behaviour, 0, mon->pos(),
                                     mon->foe, MG_FORCE_PLACE, mon->god,
                                     (monster_type) mon->type, mon->number));

    return (false);

    if (zombie_index == -1)
        return (false);
    monsters *zombie = &menv[zombie_index];
    // Attempt to force zombie into exact same spot.
    if (zombie->pos() != mon->pos() && zombie->is_habitable(mon->pos()))
        zombie->move_to_pos(mon->pos());
    if (you.can_see(mon))
    {
        if (you.can_see(zombie))
            simple_monster_message(mon, " instantly turns into a zombie!");
        else if (last_item != NON_ITEM)
            simple_monster_message(mon, "'s equipment vanishes!");
    }
    else
        simple_monster_message(zombie, " appears from thin air!");
    return (true);

// mon is a copy of the monster from before monster_die() was called,
// though its hitpoints may be non-positive.
//

    int              corpse_class, corpse, last_item;

    if (attacker->atype() == ACT_PLAYER && you.banished)
        return;
    if (mon->is_summoned() || (mon->flags & (MF_BANISHED | MF_HARD_RESET)))
        return;
    int              corpse_class, corpse_index, last_item;
    item_def         fake_corpse;

    _find_remains(mon, corpse_class, corpse, last_item, items);

    _find_remains(mon, corpse_class, corpse_index, fake_corpse, last_item,
                  items);

        _make_zombie(mon, corpse_class, corpse, last_item))

        _make_zombie(mon, corpse_class, corpse_index, fake_corpse, last_item))

    if (miscast_target->atype() == ACT_PLAYER && you.banished)
        return;

    virtual bool is_summoned(int* duration = NULL,
                             int* summon_type = NULL) const = 0;

    virtual bool is_habitable_feat(dungeon_feature_type actual_grid) const = 0;
            bool is_habitable(const coord_def &pos) const;

            bool can_wield(const item_def* item,
                           bool ignore_curse = false,
                           bool ignore_brand = false,
                           bool ignore_shield = false,
                           bool ignore_transform = false) const;
    virtual bool can_wield(const item_def &item,
                           bool ignore_curse = false,
                           bool ignore_brand = false,
                           bool ignore_shield = false,
                           bool ignore_transform = false) const = 0;
    virtual bool could_wield(const item_def &item,
                             bool ignore_brand = false,
                             bool ignore_transform = false) const = 0;

    bool      is_summoned(int* duration = NULL, int* summon_type = NULL) const;
  

    bool      is_habitable_feat(dungeon_feature_type actual_grid) const;

    bool      can_wield(const item_def &item,
                        bool ignore_curse = false,
                        bool ignore_brand = false,
                        bool ignore_shield = false,
                        bool ignore_transform = false) const;
    bool      could_wield(const item_def &item,
                          bool ignore_brand = false,
                          bool ignore_transform = false) const;

    bool      is_habitable_feat(dungeon_feature_type actual_grid) const;

    bool      can_wield(const item_def &item,
                        bool ignore_curse = false,
                        bool ignore_brand = false,
                        bool ignore_shield = false,
                        bool ignore_transform = false) const;
    bool      could_wield(const item_def &item,
                          bool ignore_brand = false,
                          bool ignore_transform = false) const;