bool grid_is_solid(int x, int y);
bool grid_is_solid(const coord_def &c);
bool grid_is_rock(dungeon_feature_type grid);

bool grid_is_solid(int x, int y);
bool grid_is_solid(const coord_def &c);

bool grid_is_rock( dungeon_feature_type grid )
{
    return (grid == DNGN_ORCISH_IDOL
            || grid == DNGN_GRANITE_STATUE
            || grid == DNGN_SECRET_DOOR
            || (grid >= DNGN_ROCK_WALL
                && grid <= DNGN_CLEAR_PERMAROCK_WALL));
}

// XXX: Monsters of I_NORMAL or above should select a new target
// if their current target is another monser which is sitting in
// a wall and is immune to most attacks while in a wall
// (M_WALL_SHIELDED), unless the monster has a spell or special/nearby
// ability which isn't affected by M_WALL_SHIELDED.

            // XXX: If a monster can move through solid grids then it
            // should preferentially flee towards the nearest solid grid
            // it can move through.  If it has M_WALL_SHIELDED is will
            // be (mostly) safe as soon as it enters the wall, and even
            // if it doesn't once it moves again it will be on the other
            // side of the wall and likely beyond the reach of the player.

            // Amphibious critters are happy in the water.

            // Amphibious critters are happy in water or on land.

                && grid_compatible(DNGN_DEEP_WATER, actual_grid))

                && ((preferred_habitat == DNGN_FLOOR
                    && grid_compatible(DNGN_DEEP_WATER, actual_grid))
                    || (preferred_habitat == DNGN_DEEP_WATER
                        && grid_compatible(DNGN_FLOOR, actual_grid))))

            // And water elementals are native to the water but happy on land

            // Rock worms are native to walls but are happy on the floor

            || ((monster_class == MONS_WATER_ELEMENTAL
                  || monster_class == MONS_MERFOLK
                  || monster_class == MONS_MERMAID)

            || (monster_class == MONS_ROCK_WORM

    M_WALL_SHIELDED     = (1<<24),        // Shielded from attacks if in wall

        return (grid >= DNGN_ROCK_WALL && grid <= DNGN_CLEAR_PERMAROCK_WALL);

        return (!grid_is_solid(grid) || grid_is_rock(grid));

    M_FLIES,

    M_FLIES | M_AMPHIBIOUS,

    M_NO_FLAGS,

        //M_NO_FLAGS,
    M_WALL_SHIELDED,

    }
    // Defending monster protects itself from attacks using the
    // wall it's in.
    if (defender->atype() == ACT_MONSTER && grid_is_solid(def->pos())
        && mons_class_flag(def->type, M_WALL_SHIELDED))
    {
        std::string feat_name = raw_feature_description(grd(def->pos()));
        if (attacker->atype() == ACT_PLAYER)
        {
            player_apply_attack_delay();
            if (you.can_see(def))
            {
                mprf("The %s protects %s from harm.",
                     feat_name.c_str(),
                     def->name(DESC_NOCAP_THE).c_str());
            }
            else
            {
                mprf("You hit the %s.",
                     feat_name.c_str());
            }
        }
        else if (you.can_see(atk))
        {
            // Make sure the monster uses up some energy, even though
            // it didn't actually land a blow.
            monsterentry *entry   = get_monster_data(atk->type);
            atk->speed_increment -= entry->energy_usage.attack;
            if (!mons_near(def))
                simple_monster_message(atk, " hits something");
            else if (!you.can_see(atk))
                mprf("%s hits the %s.", def->name(DESC_CAP_THE).c_str(),
                     feat_name.c_str());
            else
                mprf("%s tries to hit the %s, but is blocked by the %s.",
                     atk->name(DESC_CAP_THE).c_str(),
                     def->name(DESC_NOCAP_THE).c_str(),
                     feat_name.c_str());
        }
        return (true);

// Affect monster in wall unless it can shield itself using the wall
// (M_WALL_SHIELDED).  The wall will always shield the monster if the
// beam bounces off the wall, and a monster can't use a metal wall to
// shield itself from electricty.
static bool affect_mon_in_wall(bolt &pbolt, item_def *item, int tx, int ty)
{
    UNUSED(item);
    int mid = mgrd[tx][ty];
    if (mid == NON_MONSTER)
        return false;
    if (pbolt.is_enchant
        || (!pbolt.is_explosion && !pbolt.is_big_cloud
            && (grd[tx][ty] != DNGN_METAL_WALL
                || !pbolt.flavour != BEAM_ELECTRICITY)))
    {
        monsters *mons = &menv[mid];
        if (!mons_class_flag(mons->type, M_WALL_SHIELDED))
            return true;
    }

    return false;
}

                {
                    pbolt.is_tracer  = false;
                    rangeRemaining  -= affect(pbolt, tx, ty);
                    pbolt.is_tracer  = true;
                }
                else

                // BEGIN bounce case

                // BEGIN bounce case.  Bouncing protects any monster
                // in the wall.

                    // Affect any monster that might be in the wall.
                    rangeRemaining -= affect(pbolt, tx, ty);

        // if it's still a wall, quit - we can't do anything else to
        // a wall.  Otherwise effects (like clouds, etc) are still possible.

        // if it's still a wall, quit - we can't do anything else to a
        // wall (but we still might be able to do something to any
        // monster inside the wall).  Otherwise effects (like clouds,
        // etc) are still possible.

        {
            int mid = mgrd[x][y];
            if (mid != NON_MONSTER)
            {
                monsters *mon = &menv[mid];
                if (affect_mon_in_wall(beam, NULL, x, y))
                    rangeUsed += affect_monster( beam, mon );
                else if (you.can_see(mon))
                {
                    mprf("The %s protects %s from harm.",
                         raw_feature_description(grd(mon->pos())).c_str(),
                         mon->name(DESC_NOCAP_THE).c_str());
                }
            }

        }

            // XXX: Moving into a normal wall does nothing and uses no
            // turns or energy, but moving into a wall which contains
            // an invisible monster attacks the monster, thus allowing
            // the player to figure out which adjacent wall an invis
            // monster is in "for free".

    if (targ_grid == DNGN_CLOSED_DOOR && Options.easy_open)

    if (targ_grid == DNGN_CLOSED_DOOR && Options.easy_open && !attacking)

    else if (!targ_pass)

    else if (!targ_pass && !attacking)