bool spell_is_direct_explosion(spell_type spell);

// Checks if the spell is an explosion that can be placed anywhere even without
// an unobstructed beam path, such as fire storm.
bool spell_is_direct_explosion(spell_type spell)
{
    return (spell == SPELL_FIRE_STORM || spell == SPELL_HELLFIRE_BURST);
}

     false,

     true,

#if 0
// last updated 24may2000 {dlb}
/* ***********************************************************************
 * called from: ability - spell
 * *********************************************************************** */
char cast_greater_healing(void);
// last updated 24may2000 {dlb}
/* ***********************************************************************
 * called from: ability
 * *********************************************************************** */
char cast_greatest_healing(void);
// last updated 24may2000 {dlb}
/* ***********************************************************************
 * called from: ability - spell
 * *********************************************************************** */
char cast_lesser_healing(void);
#endif

void setup_fire_storm(const actor *source, int pow, bolt &beam);

void cast_fire_storm(int pow, bolt &beam)

void setup_fire_storm(const actor *source, int pow, bolt &beam)

    beam.beam_source  = MHITYOU;
    beam.thrower      = KILL_YOU_MISSILE;

    beam.beam_source  = source->mindex();
    // XXX: Should this be KILL_MON_MISSILE?
    beam.thrower      =
        source->atype() == ACT_PLAYER? KILL_YOU_MISSILE : KILL_MON;

}
void cast_fire_storm(int pow, bolt &beam)
{
    setup_fire_storm(&you, pow, beam);

int player::mindex() const
{
    return (MHITYOU);
}

bolt mons_spells(int spell_cast, int power);

bolt mons_spells(monsters *mons, spell_type spell_cast, int power);

void setup_mons_cast(const monsters *monster, bolt &pbolt, int spell_cast);

void setup_mons_cast(monsters *monster, bolt &pbolt,
                     spell_type spell_cast);

#include "spells1.h"

static bool _los_free_spell(spell_type spell_cast)
{
    return spell_cast == SPELL_HELLFIRE_BURST
        || spell_cast == SPELL_BRAIN_FEED
        || spell_cast == SPELL_SMITING
        || spell_cast == SPELL_FIRE_STORM
        || spell_cast == SPELL_AIRSTRIKE;
}

    if (spell_cast == SPELL_HELLFIRE_BURST || spell_cast == SPELL_BRAIN_FEED
        || spell_cast == SPELL_SMITING)

    if (_los_free_spell(spell_cast) && !spell_is_direct_explosion(spell_cast))

                direct_effect(pbolt);

                direct_effect(monster, spell_cast, pbolt, &you);

        mons_direct_effect(pbolt, monster_index(monster));

        direct_effect(monster, spell_cast, pbolt, monster->get_foe());

    case SPELL_CONJURE_BALL_LIGHTNING:
    {
        const int n = 2 + random2(monster->hit_dice / 4);
        for (int i = 0; i < n; ++i)
        {
            create_monster(mgen_data(MONS_BALL_LIGHTNING,
                                     SAME_ATTITUDE(monster), 2,
                                     monster->pos(), monster->foe));
        }
        return;
    }

    fire_beam(pbolt);

    if (spell_is_direct_explosion(spell_cast))
    {
        const actor *foe = monster->get_foe();
        const bool need_more =
            foe && (foe == &you || see_grid(foe->pos()));
        explosion(pbolt, false, false, true, true, need_more);
    }
    else
        fire_beam(pbolt);

void setup_mons_cast(const monsters *monster, bolt &pbolt, int spell_cast)

void setup_mons_cast(monsters *monster, bolt &pbolt,
                     spell_type spell_cast)

    // Convenience for the hapless innocent who assumes that this
    // damn function does all possible setup. [ds]
    if (!pbolt.target_x && !pbolt.target_y)
    {
        pbolt.target_x = monster->target_x;
        pbolt.target_y = monster->target_y;
    }

    if (spell_cast == SPELL_HELLFIRE_BURST
        || spell_cast == SPELL_BRAIN_FEED
        || spell_cast == SPELL_SMITING)
    {                           // etc.

    if (_los_free_spell(spell_cast))
    {

        case SPELL_HELLFIRE_BURST:
            pbolt.type = DMNBM_HELLFIRE;
            break;

            break;

            return;

            return;
        default:
            // Other spells get normal setup:

        return;

    case SPELL_CONJURE_BALL_LIGHTNING:

    bolt theBeam         = mons_spells(spell_cast, power);

    bolt theBeam         = mons_spells(monster, spell_cast, power);

    pbolt.ex_size        = theBeam.ex_size;
    pbolt.foe_ratio      = theBeam.foe_ratio;

    // Convenience for the hapless innocent who assumes that this
    // damn function does all possible setup. [ds]
    if (!pbolt.target_x && !pbolt.target_y)
    {
        pbolt.target_x = monster->target_x;
        pbolt.target_y = monster->target_y;
    }

bolt mons_spells( int spell_cast, int power )

bolt mons_spells( monsters *mons, spell_type spell_cast, int power )

        beam.is_explosion = true;
        break;
    case SPELL_FIRE_STORM:
        setup_fire_storm(mons, power / 2, beam);
        beam.foe_ratio = random_range(40, 55);
        break;
    case SPELL_ICE_STORM:
        beam.name           = "great blast of cold";
        beam.colour         = BLUE;
        beam.range          = 9 + random2(5);
        beam.damage         = calc_dice( 10, 18 + power / 2 );
        beam.damage.num     = 0;                  // only does explosion damage
        beam.hit            = 20 + power / 10;    // 50: 25   100: 30
        beam.ench_power     = power;              // used for radius
        beam.type           = dchar_glyph(DCHAR_FIRED_ZAP);
        beam.flavour        = BEAM_ICE;           // half resisted
        beam.is_explosion   = true;
        beam.foe_ratio      = random_range(40, 55);
        break;
    case SPELL_HELLFIRE_BURST:
        beam.aux_source   = "burst of hellfire";
        beam.name         = "hellfire";
        beam.ex_size      = 1;
        beam.flavour      = BEAM_HELLFIRE;

        beam.type         = dchar_glyph(DCHAR_FIRED_ZAP);
        beam.colour       = RED;
        beam.thrower      = KILL_MON;
        beam.aux_source.clear();
        beam.is_beam      = false;
        beam.is_tracer    = false;
        beam.hit          = 20;
        beam.damage       = mons_foe_is_mons(mons) ? dice_def(5, 7)
                                                   : dice_def(3, 20);

    bolt theBeam      = mons_spells(mzap, power);

    bolt theBeam      = mons_spells(monster, mzap, power);

static spell_type _get_draconian_breath_spell( const monsters *monster )

static spell_type _get_draconian_breath_spell( monsters *monster )

                    fire_tracer(monster, beem);

                    const bool explode = spell_is_direct_explosion(spell_cast);
                    fire_tracer(monster, beem, explode);

bool mons_self_destructs(const monsters *m);

bool mons_foe_is_mons(const monsters *mons);

/**
 * Returns true if the given monster's foe is also a monster.
 */
bool mons_foe_is_mons(const monsters *mons)
{
    const actor *foe = mons->get_foe();
    return foe && foe->atype() == ACT_MONSTER;
}

            case SPELL_ICE_STORM:
            case SPELL_FIRE_STORM:

}
bool mons_self_destructs(const monsters *m)
{
    return (m->type == MONS_GIANT_SPORE || m->type == MONS_BALL_LIGHTNING);

    case SPELL_BRAIN_FEED:
        return (foe != &you);

    case SPELL_MIASMA:

            || hspell_pass[i] == SPELL_HELLFIRE_BURST)

            || hspell_pass[i] == SPELL_HELLFIRE_BURST
            || hspell_pass[i] == SPELL_FIRE_STORM)

    const int index = item.index();
    unlink_item(index);
    inv[slot] = index;

    const int item_index = item.index();
    unlink_item(item_index);
    inv[slot] = item_index;

    int index = inv[eslot];
    if (index == NON_ITEM)

    int item_index = inv[eslot];
    if (item_index == NON_ITEM)

        if (!unequip(mitm[index], eslot, near))

        if (!unequip(mitm[item_index], eslot, near))

    const std::string iname = mitm[index].name(DESC_NOCAP_A);
    if (!move_item_to_grid(&index, x, y))

    const std::string iname = mitm[item_index].name(DESC_NOCAP_A);
    if (!move_item_to_grid(&item_index, x, y))

            equip(mitm[index], eslot, near);

            equip(mitm[item_index], eslot, near);

        mitm[index].flags |= ISFLAG_DROPPED_BY_ALLY;

        mitm[item_index].flags |= ISFLAG_DROPPED_BY_ALLY;

    const int mindex = (mslot == NUM_MONSTER_SLOTS) ? NON_ITEM : inv[mslot];
    return (mindex == NON_ITEM ? NULL : &mitm[mindex]);

    const int mi = (mslot == NUM_MONSTER_SLOTS) ? NON_ITEM : inv[mslot];
    return (mi == NON_ITEM ? NULL : &mitm[mi]);

}
int monsters::mindex() const
{
    return (monster_index(this));

       SPELL_POLYMORPH_OTHER,
       SPELL_SHADOW_CREATURES,

       SPELL_SUMMON_HORRIBLE_THINGS,
       SPELL_SUMMON_HORRIBLE_THINGS,

       SPELL_LIGHTNING_BOLT,
       SPELL_BOLT_OF_COLD,

       SPELL_ICE_STORM,
       SPELL_CONJURE_BALL_LIGHTNING,

       SPELL_SUMMON_DEMON,
       SPELL_TELEPORT_SELF,

       SPELL_BLINK,
       SPELL_BLINK,

       SPELL_BOLT_OF_FIRE,

       SPELL_FIRE_STORM,

       SPELL_FIREBALL,

       SPELL_HASTE,

       SPELL_SUMMON_DEMON,

       SPELL_SYMBOL_OF_TORMENT,

    MR_RES_POISON | MR_RES_FIRE | MR_RES_COLD | MR_RES_ELEC,

    MR_RES_POISON | MR_RES_FIRE | mrd(MR_RES_COLD | MR_RES_ELEC, 3),

    { 19, 0, 0, 250 },

    { 19, 0, 0, 360 },

    MR_RES_ELEC | MR_RES_POISON | MR_RES_HELLFIRE,

    MR_RES_ELEC | MR_RES_POISON | mrd(MR_RES_HELLFIRE, 3),

    SPELL_FIRE_STORM,
    SPELL_ICE_STORM,

        if (one_chance_in(25))
            spells[0] = SPELL_FIRE_STORM;

            spells[0] = SPELL_ICE_STORM;
        if (one_chance_in(25))

    virtual int       mindex() const = 0;

    int mindex() const;

    int mindex() const;

void direct_effect(struct bolt &pbolt);

void direct_effect(monsters *src, spell_type spl, bolt &pbolt, actor *defender);

void direct_effect(struct bolt &pbolt)

void direct_effect(monsters *source, spell_type spell,
                   bolt &pbolt, actor *defender)

    int damage_taken = 0;

    const bool mons_defender = defender->atype() == ACT_MONSTER;
    monsters *mdef = mons_defender? dynamic_cast<monsters*>(defender) : NULL;

    monsters* source = NULL;

    if (mdef)
    {
        // annoy the target
        behaviour_event(mdef, ME_ANNOY, monster_index(source));
    }

    if (pbolt.beam_source != NON_MONSTER)
        source = &menv[pbolt.beam_source];

    switch (pbolt.type)

    int damage_taken = 0;
    switch (spell)

    case DMNBM_HELLFIRE:
        pbolt.aux_source   = "burst of hellfire";
        pbolt.name         = "hellfire";
        pbolt.ex_size      = 1;
        pbolt.flavour      = BEAM_HELLFIRE;
        pbolt.is_explosion = true;
        pbolt.type         = dchar_glyph(DCHAR_FIRED_ZAP);
        pbolt.colour       = RED;
        pbolt.thrower      = KILL_MON_MISSILE;
        pbolt.aux_source.clear();
        pbolt.is_beam      = false;
        pbolt.is_tracer    = false;
        pbolt.hit          = 20;
        pbolt.damage       = dice_def( 3, 20 );
        explosion( pbolt );
        break;
    case DMNBM_SMITING:
        mpr( "Something smites you!" );

    case SPELL_SMITING:
        if (mons_defender)
            simple_monster_message(dynamic_cast<monsters*>(defender),
                                   " is smitten.");
        else
            mpr( "Something smites you!" );

        pbolt.flavour    = BEAM_MISSILE;

    case DMNBM_BRAIN_FEED:
        // lose_stat() must come last {dlb}
        if (one_chance_in(3)
            && lose_stat(STAT_INTELLIGENCE, 1, source))

    case SPELL_BRAIN_FEED:
        if (!mons_defender)

            mpr("Something feeds on your intellect!");
            xom_is_stimulated(50);

            // lose_stat() must come last {dlb}
            if (one_chance_in(3)
                && lose_stat(STAT_INTELLIGENCE, 1, source))
            {
                mpr("Something feeds on your intellect!");
                xom_is_stimulated(50);
            }
            else
                mpr("Something tries to feed on your intellect!");

        else
            mpr("Something tries to feed on your intellect!");

    default:
        ASSERT(false);

        ouch(damage_taken, pbolt.beam_source, KILLED_BY_BEAM,
             pbolt.aux_source.c_str());
    }
    return;
}                               // end direct_effect()
// monster-to-monster
void mons_direct_effect(struct bolt &pbolt, int i)
{
    // note the translation here - important {dlb}
    int o = menv[i].foe;
    monsters *monster = &menv[o];
    int damage_taken = 0;
    // annoy the target
    behaviour_event(monster, ME_ANNOY, i);
    switch (pbolt.type)
    {
    case DMNBM_HELLFIRE:
        simple_monster_message(monster, " is engulfed in hellfire.");
        pbolt.name    = "hellfire";
        pbolt.flavour = BEAM_LAVA;
        damage_taken  = 5 + random2(10) + random2(5);
        damage_taken  = mons_adjust_flavoured(monster, pbolt, damage_taken);
        break;
    case DMNBM_SMITING:
        simple_monster_message(monster, " is smitten.");
        pbolt.name    = "smiting";
        pbolt.flavour = BEAM_MISSILE;
        damage_taken += 7 + random2avg(11, 2);
        break;
    case DMNBM_BRAIN_FEED:  // Not implemented here (nor, probably, can be).
        break;
    case DMNBM_MUTATION:
        if (mons_holiness(monster) != MH_NATURAL
            || mons_immune_magic(monster))
        {
            simple_monster_message(monster, " is unaffected.");
        }
        else if (check_mons_resist_magic( monster, pbolt.ench_power ))
            simple_monster_message(monster, " resists.");

        if (mdef)
            mdef->hurt(source, damage_taken);

            monster_polymorph(monster, RANDOM_MONSTER);
        break;
    }
    // Apply damage and handle death, where appropriate {dlb}
    if (damage_taken > 0)
    {
        hurt_monster(monster, damage_taken);
        if (monster->hit_points < 1)
            monster_die(monster, KILL_MON_MISSILE, i);

            ouch(damage_taken, pbolt.beam_source, KILLED_BY_BEAM,
                 pbolt.aux_source.c_str());

    return;

Unbalance

Imbalance

void fire_tracer( const monsters *monster, struct bolt &pbolt );

void fire_tracer( const monsters *monster, struct bolt &pbolt,
                  bool explode_only = false );

        mprf( MSGCH_DIAGNOSTICS, "%s%s%s (%d,%d) to (%d,%d): "

        mprf( MSGCH_DIAGNOSTICS, "%s%s%s [%s] (%d,%d) to (%d,%d): "

                 (pbolt.is_beam) ? "beam" : "missile",
                 (pbolt.is_explosion) ? "*" :
                 (pbolt.is_big_cloud) ? "+" : "",
                 (pbolt.is_tracer) ? " tracer" : "",
                 pbolt.source_x, pbolt.source_y,
                 pbolt.target_x, pbolt.target_y,
                 pbolt.type, pbolt.colour, pbolt.flavour,
                 pbolt.hit, pbolt.damage.num, pbolt.damage.size,
                 pbolt.range);

              (pbolt.is_beam) ? "beam" : "missile",
              (pbolt.is_explosion) ? "*" :
              (pbolt.is_big_cloud) ? "+" : "",
              (pbolt.is_tracer) ? " tracer" : "",
              pbolt.name.c_str(),
              pbolt.source_x, pbolt.source_y,
              pbolt.target_x, pbolt.target_y,
              pbolt.type, pbolt.colour, pbolt.flavour,
              pbolt.hit, pbolt.damage.num, pbolt.damage.size,
              pbolt.range);

void fire_tracer(const monsters *monster, bolt &pbolt)

void fire_tracer(const monsters *monster, bolt &pbolt, bool explode_only)

    pbolt.foe_ratio     = 80;        // default - see mons_should_fire()

    // Foe ratio for summoning greater demons & undead -- they may be
    // summoned, but they're hostile and would love nothing better
    // than to nuke the player and his minions.
    if (mons_att_wont_attack(pbolt.attitude)
        && !mons_att_wont_attack(monster->attitude))

    // If there's a specifically requested foe_ratio, honour it.
    if (!pbolt.foe_ratio)

        pbolt.foe_ratio = 25;

        pbolt.foe_ratio     = 80;        // default - see mons_should_fire()
        // Foe ratio for summoning greater demons & undead -- they may be
        // summoned, but they're hostile and would love nothing better
        // than to nuke the player and his minions.
        if (mons_att_wont_attack(pbolt.attitude)
            && !mons_att_wont_attack(monster->attitude))
        {
            pbolt.foe_ratio = 25;
        }

    fire_beam(pbolt);

    if (explode_only)
        explosion(pbolt, false, false, true, true, false);
    else
        fire_beam(pbolt);

            || thrower == KILL_YOU_MISSILE && !see_grid(mon->x, mon->y))

            || (thrower == KILL_YOU_MISSILE && !see_grid(mon->x, mon->y)))

        // Is this a self-detonating monster? Don't consider it either way
        // if it is.
        if (mons_self_destructs(mon))
            return (BEAM_STOP);