LOS_RADIUS, LOS_RADIUS,

     LOS_RADIUS, LOS_RADIUS,

       -1, -1,

     -1, -1,

int list_spells(bool toggle_with_I = true, bool viewing = false);

int list_spells(bool toggle_with_I = true, bool viewing = false,
                int minRange = -1);

bool cast_a_spell( void );

bool cast_a_spell( bool check_range );

static int _calc_spell_range(spell_type spell, int power = 0,
                             bool real_cast = false);

        if ( wpn == NULL ||
             wpn->base_type != OBJ_STAVES ||
             item_ident(*wpn, ISFLAG_KNOW_PROPERTIES) )

        if (wpn == NULL
            || wpn->base_type != OBJ_STAVES
            || item_ident(*wpn, ISFLAG_KNOW_PROPERTIES))

            for ( int i = EQ_LEFT_RING; i <= EQ_RIGHT_RING; ++i )

            for (int i = EQ_LEFT_RING; i <= EQ_RIGHT_RING; ++i)

            if ( num_unknown == 1 )

            if (num_unknown == 1)

                for ( int i = EQ_LEFT_RING; i <= EQ_RIGHT_RING; ++i )
                    if ( you.equip[i] != -1 )

                for (int i = EQ_LEFT_RING; i <= EQ_RIGHT_RING; ++i)
                    if (player_wearing_slot(i))

static std::string _spell_base_description(spell_type spell)

static std::string _spell_base_description(spell_type spell, bool grey = false)

    if (grey)
        desc << "<darkgrey>";

    for ( int i = 0; i <= SPTYP_LAST_EXPONENT; ++i)

    for (int i = 0; i <= SPTYP_LAST_EXPONENT; ++i)

    const int so_far = desc.str().length();
    if ( so_far < 60 )

    const int so_far = desc.str().length() - (grey ? 10 : 0);
    if (so_far < 60)

    if (grey)
        desc << "</darkgrey>";

static std::string _spell_extra_description(spell_type spell)

static std::string _spell_extra_description(spell_type spell, bool grey = false)

    if (grey)
        desc << "<darkgrey>";

    if (grey)
        desc << "</darkgrey>";

int list_spells(bool toggle_with_I, bool viewing)

static bool _spell_no_hostile_in_range(spell_type spell, int minRange)
{
    if (minRange < 0)
        return (false);
    switch (spell)
    {
    case SPELL_APPORTATION:
    case SPELL_PROJECTED_NOISE:
        // These don't target monsters.
        return (false);
    default:
        break;
    }
    // The healing spells.
    if (testbits(get_spell_flags(spell), SPFLAG_HELPFUL))
        return (false);
    const int range = _calc_spell_range(spell);
    if (range < 0)
        return (false);
    if (range < minRange)
        return (true);
    return (false);
}
int list_spells(bool toggle_with_I, bool viewing, int minRange)

    bool grey = false; // Needs to be greyed out?

        if (!viewing)
        {
            if (spell_mana(spell) > you.magic_points
                || _spell_no_hostile_in_range(spell, minRange))
            {
                grey = true;
            }
            else
                grey = false;
        }

                new ToggleableMenuEntry(_spell_base_description(spell),
                                        _spell_extra_description(spell),

                new ToggleableMenuEntry(_spell_base_description(spell, grey),
                                        _spell_extra_description(spell, grey),

}
static int _get_dist_to_nearest_monster()
{
    int minRange = LOS_RADIUS + 1;
    for (radius_iterator ri(you.pos(), LOS_RADIUS, true, false, true); ri; ++ri)
    {
        if (!in_bounds(*ri))
            continue;
        if (!see_grid(*ri))
            continue;
        const monsters *mon = monster_at(*ri);
        if (mon == NULL)
            continue;
        if (!player_monster_visible(mon)
            || mons_is_unknown_mimic(mon))
        {
            continue;
        }
        if (mons_wont_attack(mon))
            continue;
        int dist = grid_distance(you.pos(), *ri);
        if (dist < minRange)
            minRange = dist;
    }
    return (minRange);

bool cast_a_spell()

bool cast_a_spell(bool check_range)

        return (false);
    }
    if (you.magic_points < 1)
    {
        mpr("You don't have enough magic to cast spells.");

    const int minRange = (check_range ? _get_dist_to_nearest_monster() : -1);

            keyin = list_spells();

            keyin = list_spells(true, false, minRange);

    if (spell_mana( spell ) > you.magic_points)

    if (spell_mana(spell) > you.magic_points)

        return (false);
    }
    if (_spell_no_hostile_in_range(spell, minRange))
    {
        mpr("There are no visible monsters within range! (Use <w>Z</w> to cast anyway.)");

        // FIXME: Code duplication (see similar line below).
        int range_power = (powc == 0 ? calc_spell_power(spell, true) : powc);

        const int range = _calc_spell_range(spell, powc, false);

        const int range = spell_range(spell, range_power, false);

        beam.range = spell_range(spell, range_power, true);

        beam.range = _calc_spell_range(spell, powc, true);

                mpr( "Sorry, this spell works on others only." );

                mpr("Sorry, this spell works on others only.");

    if ( powercap == 0 )

    if (powercap == 0)

    if ( power >= powercap )

    if (power >= powercap)

    if ( power * 3 < powercap )

    if (power * 3 < powercap)

    if ( power * 3 < powercap * 2 )

    if (power * 3 < powercap * 2)

    ASSERT( numbars <= capbars );
    if ( numbars < 0 )

    ASSERT(numbars <= capbars);
    if (numbars < 0)

static int _calc_spell_range(spell_type spell, int power, bool real_cast)
{
    if (power == 0)
        power = calc_spell_power(spell, true);
    const int range = spell_range(spell, power, real_cast);
    return (range);
}

    const int cap = spell_power_cap(spell);
    const int power = calc_spell_power(spell, true);
    const int range = spell_range(spell, power, false);

    const int cap      = spell_power_cap(spell);
    const int range    = _calc_spell_range(spell);

    {

            + "<darkgrey>" + std::string(maxrange - range, '.')
            + "</darkgrey>";

               + "<darkgrey>" + std::string(maxrange - range, '.')
               + "</darkgrey>";
    }

    CMD_FORCE_CAST_SPELL,

        if ( keyin == '?' || keyin == '*' )

        if (keyin == '?' || keyin == '*')

                if ( talents[i].hotkey == keyin )

                if (talents[i].hotkey == keyin)

            if ( selected < 0 )

            if (selected < 0)

            "<w>z</w> : cast a spell\n"

            "<w>z</w> : cast a spell, fails if no visible monsters in range\n"
            "<w>Z</w> : cast a spell\n"

            "<w>Z</w> : Zap a wand\n"

            "<w>z</w> to cast spells (<w>z?</w> lists spells).\n",

            "<w>z</w>/<w>Z</w> to cast spells (<w>z?</w> lists spells).\n",

{CMD_FORCE_CAST_SPELL, "CMD_FORCE_CAST_SPELL"},

{'Z', CMD_FORCE_CAST_SPELL},

{'Z', CMD_ZAP_WAND},

    case CMD_FORCE_CAST_SPELL:

        if (!cast_a_spell())

        if (!cast_a_spell(cmd == CMD_CAST_SPELL))

v         CMD_EVOKE

v         CMD_EVOKE_WIELDED
V         CMD_EVOKE

Z         CMD_ZAP_WAND

          CMD_ZAP_WAND (deprecated, now uses CMD_EVOKE_ITEM instead)

V         CMD_FULL_VIEW

X         CMD_DISPLAY_MAP
^X        CMD_FULL_VIEW

^S        CMD_MARK_STASH

X         CMD_DISPLAY_MAP

^X        CMD_SAVE_GAME_NOW

^S        CMD_SAVE_GAME_NOW