const coord_def& center, bool clear_walls_block = false);

             const coord_def& center, bool clear_walls_block = false,
             bool ignore_clouds = false);

            bool excluded_stairs = (object >= DNGN_STONE_STAIRS_DOWN_I
                                    && object <= DNGN_ESCAPE_HATCH_UP
                                    && is_exclude_root(where));

            if (object < NUM_FEATURES && object >= DNGN_MINMOVE

            if (!excluded_stairs
                && object < NUM_FEATURES && object >= DNGN_MINMOVE

            if (blocked_movement)

            if (excluded_stairs)
            {
                *colour = Options.tc_excluded | colmask;
            }
            else if (blocked_movement)

//            if (is_terrain_changed(x, y))
//                continue;

                    ray        = fullrays[fullray];

                    ray             = fullrays[fullray];

                    if ( sourcex > targetx )

                    if (sourcex > targetx)

                    if ( sourcey > targety )

                    if (sourcey > targety)

             bool clear_walls_block)

             bool clear_walls_block, bool ignore_clouds)

    for ( int quadrant = 0; quadrant < 4; ++quadrant )

    for (int quadrant = 0; quadrant < 4; ++quadrant)

        for ( int xdiff = 0; xdiff <= LOS_MAX_RANGE_X; ++xdiff )

        for (int xdiff = 0; xdiff <= LOS_MAX_RANGE_X; ++xdiff)

                 ++ydiff, inptr += num_words )

                 ++ydiff, inptr += num_words)

                dungeon_feature_type dfeat = grid_appearance(real);

                dungeon_feature_type dfeat = grid_appearance(gr, real);

                if ( grid_is_opaque(dfeat)
                     || (clear_walls_block && grid_is_wall(dfeat)))

                if (grid_is_opaque(dfeat)
                    || clear_walls_block && grid_is_wall(dfeat))

                    for ( unsigned int i = 0; i < num_words; ++i )

                    for (unsigned int i = 0; i < num_words; ++i)

                else if ( is_opaque_cloud(env.cgrid[realx][realy]) )

                else if (!ignore_clouds
                         && is_opaque_cloud(env.cgrid[realx][realy]))

                    for ( unsigned int i = 0; i < num_words; ++i )

                    for (unsigned int i = 0; i < num_words; ++i)

        for ( unsigned int wordloc = 0; wordloc < num_words; ++wordloc )

        for (unsigned int wordloc = 0; wordloc < num_words; ++wordloc)

            for ( unsigned int bitloc = 0; bitloc < LONGSIZE; ++bitloc)

            for (unsigned int bitloc = 0; bitloc < LONGSIZE; ++bitloc)

                        && realx * realx + realy * realy <= los_radius_squared )

                        && realx * realx + realy * realy <= los_radius_squared)

                if ( rayidx == num_cellrays )

                if (rayidx == num_cellrays)

                && grd(*ri) == DNGN_EXIT_PANDEMONIUM)

                   && grd(*ri) == DNGN_EXIT_PANDEMONIUM)

        std::vector<coord_def> update_excludes;

                        if (is_terrain_changed(gc) || !is_terrain_seen(gc))
                            update_excludes.push_back(gc);

                            if (is_terrain_changed(gc) || !is_terrain_seen(gc))
                                update_excludes.push_back(gc);

        }
        if (!update_excludes.empty())
        {
            mark_all_excludes_non_updated();
            for (unsigned int k = 0; k < update_excludes.size(); k++)
                update_exclusion_los(update_excludes[k]);

void update_exclusion_los(coord_def &p);

void update_exclusion_los(const coord_def &p);
void mark_all_excludes_non_updated();

    coord_def pos;
    int       radius;
    env_show_grid show;

    coord_def     pos;       // exclusion centre
    int           radius;    // exclusion radisu
    env_show_grid show;      // los from exclusion centre
    bool          uptodate;  // Is show up to date?

static feature_grid _map_to_grid(coord_def &pos)
{
    feature_grid fgrid = env.grid;
    for (int x = pos.x - LOS_RADIUS; x < pos.x + LOS_RADIUS; x++)
        for (int y = pos.y - LOS_RADIUS; y < pos.y + LOS_RADIUS; y++)
        {
            if (!in_bounds(x,y))
                continue;
            // For unseen terrain, assume transparency.
            if (!is_terrain_seen(x,y))
            {
                fgrid[x][y] = DNGN_FLOOR;
                continue;
            }

            if (!is_terrain_changed(x,y))
                continue;
            if (env.map[x][y].object < NUM_REAL_FEATURES)
                fgrid[x][y] = (dungeon_feature_type) env.map[x][y].object;
            else
            {
                // If you have seen monsters, items or clouds there,
                // it must have been passable.
                fgrid[x][y] = DNGN_FLOOR;
            }
        }
    return fgrid;
}

    losight(show, grd, pos);

    // ignores clouds
    feature_grid fgrid = _map_to_grid(pos);
    losight(show, fgrid, pos, false, true);
    uptodate = true;

void update_exclusion_los(coord_def &p)

void update_exclusion_los(const coord_def &p)

        if ((curr_excludes[i].pos - p).abs() <= LOS_RADIUS)

        if (!curr_excludes[i].uptodate
            && (curr_excludes[i].pos - p).abs() <= LOS_RADIUS * LOS_RADIUS)
        {

        }
}
void mark_all_excludes_non_updated()
{
    for (unsigned int i = 0; i < curr_excludes.size(); i++)
        curr_excludes[i].uptodate = false;

dungeon_feature_type grid_appearance(feature_grid &gr, const coord_def &gc);

    dungeon_feature_type grid = grd(gc);

    return grid_appearance(grd, gc);
}
dungeon_feature_type grid_appearance(feature_grid &gr, const coord_def &gc)
{
    dungeon_feature_type grid = gr(gc);

    // Currently, difficulty is defined as "average hp".  Leaks too much info?
    const monsterentry* me = get_monster_data(mtype);
    // [ds] XXX: Use monster experience value as a better indicator of diff.?
    m_difficulty = me->hpdice[0] * (me->hpdice[1] + (me->hpdice[2]/2))
        + me->hpdice[3];

    // Currently, difficulty is defined as "average hp".
    m_difficulty = mons_difficulty(mtype);

                 int killer_index, bool silent = false);

                 int killer_index, bool silent = false, bool wizard = false);

                 int killer_index, bool silent)

                 int killer_index, bool silent, bool wizard)

    // Clear auto exclusion now the monster is killed.
    remove_auto_exclude(monster);

    // Clear auto exclusion now the monster is killed -- if we know about it.
    if (mons_near(monster) || wizard)
        remove_auto_exclude(monster);

        // Even fire resistant monsters perish in lava, but undead can survive
        // deep water.

        // Even fire resistant monsters perish in lava, but inanimate monsters
        // can survive deep water.

    // If the monster is in the auto_exclude list, automatically
    // set an exclusion.
    if (need_auto_exclude(monster) && !is_exclude_root(monster->pos()))
        toggle_exclude(monster->pos());

    // If the monster is in the auto_exclude list, automatically
    // set an exclusion.
    if (need_auto_exclude(monster) && !is_exclude_root(monster->pos()))
        toggle_exclude(monster->pos());

int mons_difficulty(int mtype);

int mons_difficulty(int mtype)
{
    // Currently, difficulty is defined as "average hp".  Leaks too much info?
    const monsterentry* me = get_monster_data(mtype);

    // [ds] XXX: Use monster experience value as a better indicator of diff.?
    return (me->hpdice[0] * (me->hpdice[1] + (me->hpdice[2]/2))
            + me->hpdice[3]);
}

    M_SENSE_INVIS | M_EVIL,

    M_SENSE_INVIS | M_EVIL | M_FLIES,

            set_terrain_changed(ri->x, ri->y);

    if (something_happened)
        init_exclusion_los();

                monster_die(monster, KILL_DISMISSED, NON_MONSTER);

                monster_die(monster, KILL_DISMISSED, NON_MONSTER, false, true);

            monster_die(monster, KILL_DISMISSED, NON_MONSTER);

            monster_die(monster, KILL_DISMISSED, NON_MONSTER, false, true);

            and string.find( item.name(it, "a"), " stones?$" )

            and item.class(it, true) == "missile"
            and string.find( item.name(it, "a"), " stones?" )

            and string.find( item.name(it, "a"), " arrows?$" )

            and item.class(it, true) == "missile"
            and string.find( item.name(it, "a"), " arrows?" )

    int a_toughness = mons_global_level(*a);
    int b_toughness = mons_global_level(*b);

    int a_toughness = mons_difficulty(*a);
    int b_toughness = mons_difficulty(*b);

        a_toughness = mons_type_hit_dice(*a);
        b_toughness = mons_type_hit_dice(*b);
    }
    if (a_toughness == b_toughness)
    {

    return (a_toughness < b_toughness);

    return (a_toughness > b_toughness);

                       "<w>g</w>      : add a skill\n"

                       "<w>g</w>      : exercise a skill\n"

            // Mark terrain as changed so travel excludes can be updated
            // as necessary.
            // XXX: This doesn't work for some reason: after digging
            //      the wrong grids are marked excluded.
            set_terrain_changed(p);

                {

                }