static bool player_knows_aptitudes()

static bool _player_knows_aptitudes()

static void display_skill_table(bool show_aptitudes)

static void _display_skill_table(bool show_aptitudes)

        if (player_knows_aptitudes())

        if (_player_knows_aptitudes())

        display_skill_table(show_aptitudes);

        _display_skill_table(show_aptitudes);

        if (keyin == '!' && player_knows_aptitudes())

        if (keyin == '!' && _player_knows_aptitudes())

bool i_feel_safe(bool announce = false, bool want_move = false);

void get_playervisible_monsters(std::vector<monsters*>& mons,
                                bool just_check = false, bool want_move = false,
                                bool dangerous = false, int range = -1);
bool i_feel_safe(bool announce = false, bool want_move = false,
                 bool just_monsters = false, int range = -1);

void get_playervisible_monsters(std::vector<monsters*>& mons);

    bool moving = ((!you.delay_queue.empty() &&
                   is_run_delay(you.delay_queue.front().type) &&
                   you.delay_queue.front().type != DELAY_REST) ||
                   you.running < RMODE_NOT_RUNNING || want_move);

    bool moving = ((!you.delay_queue.empty()
                       && is_run_delay(you.delay_queue.front().type)
                       && you.delay_queue.front().type != DELAY_REST)
                   || you.running < RMODE_NOT_RUNNING || want_move);

void get_playervisible_monsters(std::vector<monsters*>& mons)

void get_playervisible_monsters(std::vector<monsters*> &mons, bool want_move,
                                bool just_check, bool dangerous, int range)

    const int ystart = MAX(0,   you.y_pos - LOS_RADIUS);
    const int yend   = MIN(GYM, you.y_pos + LOS_RADIUS);
    const int xstart = MAX(0,   you.x_pos - LOS_RADIUS);
    const int xend   = MIN(GXM, you.x_pos + LOS_RADIUS);

    if (range == -1)
        range = LOS_RADIUS;
    const int ystart = MAX(0,   you.y_pos - range);
    const int yend   = MIN(GYM, you.y_pos + range);
    const int xstart = MAX(0,   you.x_pos - range);
    const int xend   = MIN(GXM, you.x_pos + range);

    for ( int x = xstart; x < xend; ++x )
    {
        const unsigned short targ_monst = env.mgrid[x][y];
        if ( targ_monst != NON_MONSTER )

        for ( int x = xstart; x < xend; ++x )

            if ( see_grid(x,y) )

            const unsigned short targ_monst = env.mgrid[x][y];
            if ( targ_monst != NON_MONSTER )

                monsters *mon = &env.mons[targ_monst];
                if ( player_monster_visible(mon) &&
                     !mons_is_submerged(mon) &&
                     (!mons_is_mimic(mon->type) || mons_is_known_mimic(mon))
                    )

                if ( see_grid(x,y) )

                    mons.push_back(mon);

                    monsters *mon = &env.mons[targ_monst];
                    if ( player_monster_visible(mon)
                        && !mons_is_submerged(mon)
                        && (!mons_is_mimic(mon->type)
                            || mons_is_known_mimic(mon))
                        && (!dangerous || !mons_is_safe(mon, want_move)))
                    {
                        mons.push_back(mon);
                        if (just_check)
                        {
                            // one monster found, that's enough
                            return;
                        }
                    }

    }

bool i_feel_safe(bool announce, bool want_move)

bool i_feel_safe(bool announce, bool want_move, bool just_monsters, int range)

    int ystart = you.y_pos - 9, xstart = you.x_pos - 9;
    int yend = you.y_pos + 9, xend = you.x_pos + 9;
    if ( xstart < 0 ) xstart = 0;
    if ( ystart < 0 ) ystart = 0;
    if ( xend >= GXM ) xend = GXM;
    if ( yend >= GYM ) yend = GYM;
    if (in_bounds(you.x_pos, you.y_pos)
        && env.cgrid[you.x_pos][you.y_pos] != EMPTY_CLOUD)
    {
        const cloud_type type =
            env.cloud[ env.cgrid[you.x_pos][you.y_pos] ].type;
        if (is_damaging_cloud(type, false))
        {
            if (announce)
                mprf(MSGCH_WARN, "You're standing in a cloud of %s!",
                     cloud_name(type).c_str());
            return (false);
        }
    }
    // no monster will attack you inside a sanctuary,
    // so presence of monsters won't matter
    if (is_sanctuary(you.x_pos, you.y_pos))
        return (true);
    std::vector<const monsters *> mons;
    // monster check
    // XXX: refactor this to make use of get_playervisible_monsters()
    for ( int y = ystart; y < yend; ++y )

    if (!just_monsters)

        for ( int x = xstart; x < xend; ++x )

        if (in_bounds(you.x_pos, you.y_pos)
            && env.cgrid[you.x_pos][you.y_pos] != EMPTY_CLOUD)

            // if you can see an unfriendly monster, then you feel unsafe
            if ( see_grid(x,y) )

            const cloud_type type =
                    env.cloud[ env.cgrid[you.x_pos][you.y_pos] ].type;
            if (is_damaging_cloud(type, false))

                const unsigned short targ_monst = mgrd[x][y];
                if ( targ_monst != NON_MONSTER )

                if (announce)

                    const monsters *mon = &menv[targ_monst];
                    if ( player_monster_visible(mon) &&
                         !mons_is_submerged(mon) &&
                         !mons_is_mimic(mon->type) &&
                         !mons_is_safe(mon, want_move))
                    {
                        if (announce)
                            mons.push_back(mon);
                        else
                        {
                            tutorial_first_monster(*mon);
                            return false;
                        }
                    }

                    mprf(MSGCH_WARN, "You're standing in a cloud of %s!",
                         cloud_name(type).c_str());

                return (false);

        // no monster will attack you inside a sanctuary,
        // so presence of monsters won't matter
        if (is_sanctuary(you.x_pos, you.y_pos))
            return (true);

    if (announce)

    // monster check
    std::vector<monsters*> visible;
    get_playervisible_monsters(visible, !announce, want_move, true, range);
    // No monsters found.
    if (visible.empty())
        return true;
    // Announce the presence of monsters (Eidolos).
    if (visible.size() == 1)

        // Announce the presence of monsters (Eidolos).
        if (mons.size() == 1)

        const monsters &m = *visible[0];
        if (announce)

            const monsters &m = *mons[0];

                 m.name(DESC_NOCAP_A).c_str());
        }
        else if (mons.size() > 1)
        {
            mprf(MSGCH_WARN, "Not with these monsters around!");

                m.name(DESC_NOCAP_A).c_str());

        return (mons.empty());

        else
            tutorial_first_monster(m);
    }
    else if (announce && visible.size() > 1)
    {
        mprf(MSGCH_WARN, "Not with these monsters around!");

    return true;

    return (false);

    water_attack = is_water_attack(attacker, defender);
    attacker_visible = attacker->visible();

    water_attack       = is_water_attack(attacker, defender);
    attacker_visible   = attacker->visible();

    defender_visible = defender && defender->visible();

    defender_visible   = defender && defender->visible();

                        && see_grid(defender->pos());
    needs_message = attacker_visible || defender_visible;

                         && see_grid(defender->pos());
    needs_message      = attacker_visible || defender_visible;

}
// Unseen monsters in shallow water show a "strange disturbance".
// (Unless flying!)
static bool _mon_submerged_in_water(const monsters *mon)
{
    if (!mon)
        return false;
    return (grd[mon->x][mon->y] == DNGN_SHALLOW_WATER
            && see_grid(mon->x, mon->y)
            && !player_monster_visible(mon)
            && !mons_flies(mon));

        if (target_unshifted &&
            (key_command == CMD_TARGET_CYCLE_FORWARD
             || key_command == CMD_TARGET_CYCLE_BACK
             || key_command == CMD_TARGET_OBJ_CYCLE_FORWARD
             || key_command == CMD_TARGET_OBJ_CYCLE_BACK))

        if (target_unshifted
            && (key_command == CMD_TARGET_CYCLE_FORWARD
                || key_command == CMD_TARGET_CYCLE_BACK
                || key_command == CMD_TARGET_OBJ_CYCLE_FORWARD
                || key_command == CMD_TARGET_OBJ_CYCLE_BACK))

                  (mode == TARG_ENEMY) ? "enemies" :
                  "friends" );

                  (mode == TARG_ENEMY) ? "enemies"
                                       : "friends" );

            moves.isValid = true;

            if (!moves.isEndpoint
                && mgrd[moves.tx][moves.ty] != NON_MONSTER
                && _mon_submerged_in_water(&menv[mgrd[moves.tx][moves.ty]]))
            {
                moves.isEndpoint = true;
            }
            moves.isValid  = true;

            else if ( moves.isValid || moves.isCancel ||
                      yesno("Are you sure you want to fizzle?", false, 'n') )

            else if ( moves.isValid || moves.isCancel
                      || yesno("Are you sure you want to fizzle?", false, 'n') )

        if (show_beam && find_ray(you.x_pos, you.y_pos, moves.tx, moves.ty,
            true, ray, 0, true) || need_beam_redraw )

        if ( need_beam_redraw
             || show_beam && find_ray(you.x_pos, you.y_pos, moves.tx, moves.ty,
                                      true, ray, 0, true) )

            if ( show_beam &&
                 in_vlos(grid2viewX(moves.tx), grid2viewY(moves.ty)) &&
                 moves.target() != you.pos() )

            if ( show_beam
                 && in_vlos(grid2viewX(moves.tx), grid2viewY(moves.ty))
                 && moves.target() != you.pos() )

                    MAGENTA | COLFLAG_REVERSE);

                               MAGENTA | COLFLAG_REVERSE);

    // Unseen monsters in shallow water show a "strange disturbance"
    // (unless flying!)
    if (!player_monster_visible(&menv[targ_mon]))

    monsters *mon = &menv[targ_mon];
    // Unknown mimics don't count as monsters, either.
    if (mons_is_mimic(mon->type)
        && !(mon->flags & MF_KNOWN_MIMIC))

        // since you can't see the monster, assume it's not a friend
        return (mode != TARG_FRIEND
                && grd[x][y] == DNGN_SHALLOW_WATER
                && !mons_flies(&menv[targ_mon]));

        return (false);

    // Unknown mimics don't count as monsters, either.
    if (mons_is_mimic(menv[targ_mon].type)
        && !(menv[targ_mon].flags & MF_KNOWN_MIMIC))

    // Don't usually target unseen monsters...
    if (!player_monster_visible(mon))

        return (false);

        // ... unless it creates a "disturbance in the water".
        // Since you can't see the monster, assume it's not a friend.
        // Also don't target submerged monsters if there are other targets
        // in sight. (This might be too restrictive.)
        return (mode != TARG_FRIEND
                && _mon_submerged_in_water(mon)
                && i_feel_safe(false, false, true, range));