// last updated 12may2000 {dlb}
/* ***********************************************************************
 * called from: acr
 * *********************************************************************** */
void viewwindow2(char draw_it, bool do_updates);
// last updated 12may2000 {dlb}
/* ***********************************************************************
 * called from: acr
 * *********************************************************************** */
void viewwindow3(char draw_it, bool do_updates);        // non-IBM graphics

bool view_update();
void view_update_at(const coord_def &pos);

static void beogh_follower_convert(monsters *monster)

inline static void beogh_follower_convert(monsters *monster)

    if (you.species != SP_HILL_ORC)
        return;
    
    const bool is_orc = mons_species(monster->type) == MONS_ORC;

    if (mons_species(monster->type) == MONS_ORC
        && you.religion == GOD_BEOGH
        && !(monster->flags & MF_CONVERT_ATTEMPT)
        // && !mons_is_unique(monster->type) // does not work on Blork

    if (you.religion == GOD_BEOGH

        && !(monster->flags & MF_CONVERT_ATTEMPT)
        && is_orc
        && !mons_friendly(monster)

    else if (mons_species(monster->type) == MONS_ORC
             && you.species == SP_HILL_ORC

    else if (is_orc

//                     && monster->foe == MHITYOU

}
inline static bool update_monster_grid(const monsters *monster)
{
    const int ex = monster->x - you.x_pos + 9;
    const int ey = monster->y - you.y_pos + 9;
    if (!player_monster_visible( monster ))
    {
        // ripple effect?
        if (grd[monster->x][monster->y] == DNGN_SHALLOW_WATER
            && !mons_flies(monster)
            && env.cgrid(monster->pos()) == EMPTY_CLOUD)
        {
            set_show_backup(ex, ey);
            env.show[ex][ey] = DNGN_INVIS_EXPOSED;
            env.show_col[ex][ey] = BLUE; 
        }
        return (false);
    }
    // mimics are always left on map
    if (!mons_is_mimic( monster->type ))
        set_show_backup(ex, ey);
    env.show[ex][ey] = monster->type + DNGN_START_OF_MONSTERS;
    env.show_col[ex][ey] = get_mons_colour( monster );
    return (true);

            const int ex = monster->x - you.x_pos + 9;
            const int ey = monster->y - you.y_pos + 9;
            if (!player_monster_visible( monster ))
            {
                // ripple effect?
                if (grd[monster->x][monster->y] == DNGN_SHALLOW_WATER
                    && !mons_flies(monster)
                    && env.cgrid(monster->pos()) == EMPTY_CLOUD)
                {
                    set_show_backup(ex, ey);
                    env.show[ex][ey] = DNGN_INVIS_EXPOSED;
                    env.show_col[ex][ey] = BLUE; 
                }

            if (!update_monster_grid(monster))

            }
            // mimics are always left on map
            if (!mons_is_mimic( monster->type ))
                set_show_backup(ex, ey);

            env.show[ex][ey] = monster->type + DNGN_START_OF_MONSTERS;
            env.show_col[ex][ey] = get_mons_colour( monster );

inline static void update_item_grid(const coord_def &gp, const coord_def &ep)
{
    const item_def &eitem = mitm[igrd(gp)];
    unsigned short &ecol = env.show_col(ep);
    const dungeon_feature_type grid = grd(gp);
    if (Options.stair_item_brand && is_stair(grid))
        ecol |= COLFLAG_STAIR_ITEM;
    else
    {
        ecol = (grid == DNGN_SHALLOW_WATER)? CYAN : eitem.colour;
        if (eitem.link != NON_ITEM)
            ecol |= COLFLAG_ITEM_HEAP;
        env.show(ep) = get_item_dngn_code( eitem );
    }
}

    char count_x, count_y;
    for (count_y = (you.y_pos - 8); (count_y < you.y_pos + 9); count_y++)

    coord_def gp;
    for (gp.y = (you.y_pos - 8); (gp.y < you.y_pos + 9); gp.y++)

        for (count_x = (you.x_pos - 8); (count_x < you.x_pos + 9); count_x++)

        for (gp.x = (you.x_pos - 8); (gp.x < you.x_pos + 9); gp.x++)

            if (count_x >= 0 && count_x < GXM && count_y >= 0 && count_y < GYM)

            if (in_bounds(gp))

                if (igrd[count_x][count_y] != NON_ITEM)

                if (igrd(gp) != NON_ITEM)

                    const int ix = count_x - you.x_pos + 9;
                    const int iy = count_y - you.y_pos + 9;
                    if (env.show[ix][iy])
                    {
                        const item_def &eitem = mitm[igrd[count_x][count_y]];
                        unsigned short &ecol = env.show_col[ix][iy];
                        const dungeon_feature_type grid = grd[count_x][count_y];
                        if (Options.stair_item_brand && is_stair(grid))
                            ecol |= COLFLAG_STAIR_ITEM;
                        else
                        {
                            ecol = (grid == DNGN_SHALLOW_WATER)?
                                CYAN
                                : eitem.colour;
                            if (eitem.link != NON_ITEM)
                            {
                                ecol |= COLFLAG_ITEM_HEAP;
                            }
                            env.show[ix][iy] = get_item_dngn_code( eitem );
                        }
                    }

                    const coord_def ep = gp - you.pos() + coord_def(9, 9);
                    if (env.show(ep))
                        update_item_grid(gp, ep);

        }                       // end of "for count_y, count_x"

        }

}                               // end item()

}

}
inline static void update_cloud_grid(int cloudno)
{
    int which_colour = LIGHTGREY;
    const int ex = env.cloud[cloudno].x - you.x_pos + 9;
    const int ey = env.cloud[cloudno].y - you.y_pos + 9;
                
    switch (env.cloud[cloudno].type)
    {
    case CLOUD_FIRE:
        if (env.cloud[cloudno].decay <= 20)
            which_colour = RED;
        else if (env.cloud[cloudno].decay <= 40)
            which_colour = LIGHTRED;
        else if (one_chance_in(4))
            which_colour = RED;
        else if (one_chance_in(4))
            which_colour = LIGHTRED;
        else
            which_colour = YELLOW;
        break;
    case CLOUD_STINK:
        which_colour = GREEN;
        break;
    case CLOUD_COLD:
        if (env.cloud[cloudno].decay <= 20)
            which_colour = BLUE;
        else if (env.cloud[cloudno].decay <= 40)
            which_colour = LIGHTBLUE;
        else if (one_chance_in(4))
            which_colour = BLUE;
        else if (one_chance_in(4))
            which_colour = LIGHTBLUE;
        else
            which_colour = WHITE;
        break;
    case CLOUD_POISON:
        which_colour = (one_chance_in(3) ? LIGHTGREEN : GREEN);
        break;
    case CLOUD_BLUE_SMOKE:
        which_colour = LIGHTBLUE;
        break;
    case CLOUD_PURP_SMOKE:
        which_colour = MAGENTA;
        break;
    case CLOUD_MIASMA:
    case CLOUD_BLACK_SMOKE:
        which_colour = DARKGREY;
        break;
    case CLOUD_MIST:
        which_colour = EC_MIST;
        break;
    default:
        which_colour = LIGHTGREY;
        break;
    }
    set_show_backup(ex, ey);
    env.show[ex][ey] = DNGN_CLOUD;
    env.show_col[ex][ey] = which_colour;    

    // btw, this is also the 'default' color {dlb}
    unsigned char which_colour = LIGHTGREY;

        if (mnc > env.cloud_no) 

        if (mnc >= env.cloud_no) 

            {
                const int ex = env.cloud[s].x - you.x_pos + 9;
                const int ey = env.cloud[s].y - you.y_pos + 9;
                
                switch (env.cloud[s].type)
                {
                case CLOUD_FIRE:
                    if (env.cloud[s].decay <= 20)
                        which_colour = RED;
                    else if (env.cloud[s].decay <= 40)
                        which_colour = LIGHTRED;
                    else if (one_chance_in(4))
                        which_colour = RED;
                    else if (one_chance_in(4))
                        which_colour = LIGHTRED;
                    else
                        which_colour = YELLOW;
                    break;
                case CLOUD_STINK:
                    which_colour = GREEN;
                    break;

                update_cloud_grid(s);
        }
    }
}

                case CLOUD_COLD:
                    if (env.cloud[s].decay <= 20)
                        which_colour = BLUE;
                    else if (env.cloud[s].decay <= 40)
                        which_colour = LIGHTBLUE;
                    else if (one_chance_in(4))
                        which_colour = BLUE;
                    else if (one_chance_in(4))
                        which_colour = LIGHTBLUE;
                    else
                        which_colour = WHITE;
                    break;
                case CLOUD_POISON:
                    which_colour = (one_chance_in(3) ? LIGHTGREEN : GREEN);
                    break;
                case CLOUD_BLUE_SMOKE:
                    which_colour = LIGHTBLUE;
                    break;
                case CLOUD_PURP_SMOKE:
                    which_colour = MAGENTA;
                    break;
                case CLOUD_MIASMA:
                case CLOUD_BLACK_SMOKE:
                    which_colour = DARKGREY;
                    break;
                case CLOUD_MIST:
                    which_colour = EC_MIST;
                    break;
                default:
                    which_colour = LIGHTGREY;
                    break;
                }
                set_show_backup(ex, ey);
                env.show[ex][ey] = DNGN_CLOUD;
                env.show_col[ex][ey] = which_colour;
            }
        }                       // end 'if != CLOUD_NONE'
    }                           // end 'for s' loop
}                               // end cloud_grid()

static void update_env_show(const coord_def &gp, const coord_def &ep)
{
    // The sequence is grid, items, clouds, monsters.
    env.show(ep) = grd(gp);
    env.show_col(ep) = 0;
    if (igrd(gp) != NON_ITEM)
        update_item_grid(gp, ep);
    const int cloud = env.cgrid(gp);
    if (cloud != EMPTY_CLOUD && env.cloud[cloud].type != CLOUD_NONE)
        update_cloud_grid(cloud);
    
    const monsters *mons = monster_at(gp);
    if (mons && mons->alive())
        update_monster_grid(mons);
}
// Updates one square of the view area. Should only be called for square
// in LOS.
void view_update_at(const coord_def &pos)
{
    if (pos == you.pos())
        return;
    const coord_def vp = grid2view(pos);
    const coord_def ep = view2show(vp);
    update_env_show(pos, ep);
    int object = env.show(ep);
    if (!object)
        return;
    
    unsigned short  colour = env.show_col(ep);
    unsigned        ch = 0;
    if (object == DNGN_SECRET_DOOR)
        object = grid_secret_door_appearance( pos.x, pos.y );
    get_symbol( pos.x, pos.y, object, &ch, &colour );
    int flash_colour = you.flash_colour;
    if (flash_colour == BLACK)
        flash_colour = viewmap_flash_colour();
    
    gotoxy(vp.x, vp.y);
    textcolor(flash_colour? flash_colour : colour);
    putwch(ch);
}
bool view_update()
{
    if (you.num_turns > you.last_view_update)
    {
        viewwindow(true, false);
        return (true);
    }
    return (false);
}

        const bool draw = !you.running || Options.travel_delay > -1;

        if (!you.running || (Options.travel_delay > -1))

        if (draw)

            you.last_view_update = you.num_turns;

    num_turns = 0;

    num_turns = 0L;
    last_view_update = 0L;

    const coord_def mwhere = monster->pos();

    // Force redraw for monsters that die.
    if (see_grid(mwhere))
    {
        view_update_at(mwhere);
        update_screen();
    }

    while (monster->speed_increment >= 80)

    while (monster->has_action_energy())

        if (monster->type == MONS_TIAMAT && one_chance_in(3) )

        if (monster->type == MONS_TIAMAT && one_chance_in(3))

    mon->check_redraw(coord_def(cx, cy));

    monster->check_redraw(monster->pos() - coord_def(xi, yi));
    

monsters *monster_at(const coord_def &pos);

monsters *monster_at(const coord_def &pos)
{
    const int mindex = mgrd(pos);
    return (mindex != NON_MONSTER? &menv[mindex] : NULL);
}

bool monsters::has_action_energy() const
{
    return (speed_increment >= 80);
}
void monsters::check_redraw(const coord_def &old) const
{
    const bool see_new = see_grid(pos());
    const bool see_old = see_grid(old);
    if ((see_new || see_old) && !view_update())
    {
        if (see_new)
            view_update_at(pos());
        if (see_old)
            view_update_at(old);
        update_screen();
    }
}

#include "view.h"

            viewwindow(true, false);

  long          last_view_update;     // what turn was the view last updated?

    bool has_action_energy() const;
    void check_redraw(const coord_def &oldpos) const;
    

inline coord_def grid2show(const coord_def &pos)
{
    return (view2show(grid2view(pos)));
}

        view_update();

#ifdef UNIX

#endif

    viewwindow(1, true);

    viewwindow(true, true);