explosion(beam);

            beam.explode();

            int wpn = you.equip[EQ_WEAPON];
            if (wpn != -1
                && you.inv[wpn].base_type == OBJ_WEAPONS
                && get_weapon_brand( you.inv[wpn] ) == SPWPN_ORC_SLAYING

            if (you.weapon()
                && you.weapon()->base_type == OBJ_WEAPONS
                && get_weapon_brand( *you.weapon() ) == SPWPN_ORC_SLAYING

int maybe_random2( int x, bool random_factor );

}
// Returns random2(x) if random_factor is true, otherwise the mean.
int maybe_random2( int x, bool random_factor )
{
    if (random_factor)
        return random2(x);
    else
        return x / 2;

    beam.use_target_as_pos = true;

    explosion(beam, false, true);

    beam.explode();

    fire_beam(beem);

    beem.fire();

    fire_beam(beem);

    beem.fire();

        explosion(beam, hole, true);

        beam.explode(true, hole);

    beam.affects_items = false;

    if (explosion(beam, false, false, true, true, false) > 0)

    if (beam.explode(false))

        fire_beam( beam );

        beam.fire();

        fire_beam(beem);

        beem.fire();

    fire_beam(beem);

    beem.fire();

        explosion(beam);

        beam.explode();

#ifdef USE_TILE

#endif

        const bool need_more =
            foe && (foe == &you || see_grid(foe->pos()));
        explosion(pbolt, false, false, true, true, need_more);

        const bool need_more = foe && (foe == &you || see_grid(foe->pos()));
        pbolt.explode(need_more);

        fire_beam(pbolt);

        pbolt.fire();

    fire_beam( pbolt );

    pbolt.fire();

        fire_beam(pbolt);

        pbolt.fire();

    beam.pos          = monster->pos();

    explosion(beam, false, false, true, true, mons_near(monster));

    // FIXME: show_more == mons_near(monster)
    beam.explode();

            fire_beam(beem);

            beem.fire();

            fire_beam(beem);

            beem.fire();

            fire_beam(beem);

            beem.fire();

        fire_beam(beem);

        beem.fire();

            if (niceWand || beem.name != "0" || beem.obvious_effect)

            if (niceWand || !beem.is_enchantment() || beem.obvious_effect)

        break;                  // to damage routine at end {dlb}

        break;

            mons_ench_f2(monster, beam);

            beam.apply_enchantment_to_monster(monster);

        break;                  // to damage routine at end {dlb}

        break;

        break;                  // to damage routine at end {dlb}

        break;

        break;                  // to damage routine at end {dlb}

        break;

        break;                  // to damage routine at end {dlb}

        break;

            mons_ench_f2(monster, beam);

            beam.apply_enchantment_to_monster(monster);

        break;              // to damage routine at end {dlb}

        break;

    bolt beam_temp;
    beam_temp.flavour = BEAM_CONFUSION;
    mons_ench_f2( this, beam_temp );

    enchant_monster_with_flavour(this, BEAM_CONFUSION, strength);

    bolt paralysis;
    paralysis.flavour = BEAM_PARALYSIS;
    mons_ench_f2(this, paralysis);

    enchant_monster_with_flavour(this, BEAM_PARALYSIS, strength);

    bolt petrif;
    petrif.flavour = BEAM_PETRIFY;
    mons_ench_f2(this, petrif);

    enchant_monster_with_flavour(this, BEAM_PETRIFY, strength);

    bolt slow;
    slow.flavour = BEAM_SLOW;
    mons_ench_f2(this, slow);

    enchant_monster_with_flavour(this, BEAM_SLOW, strength);

    {
        // XXX FIXME Extract haste() function from mons_ench_f2().
        bolt beem;
        beem.target = pos();
        beem.flavour = BEAM_HASTE;
        mons_ench_f2(this, beem);
        if (beem.obvious_effect)

        if (enchant_monster_with_flavour(this, BEAM_HASTE))

    }

    {
        // XXX FIXME Extract go_invis() function from mons_ench_f2().
        bolt beem;
        beem.target = pos();
        beem.flavour = BEAM_INVISIBILITY;
        mons_ench_f2(this, beem);
        if (beem.obvious_effect)

        if (enchant_monster_with_flavour(this, BEAM_INVISIBILITY))

    }

        fire_beam(pbolt);

        pbolt.fire();

        hit = (affect(pbolt, pbolt.target, &item) != 0);

        pbolt.use_target_as_pos = true;
        pbolt.affect_cell();

            beam_drop_object(pbolt, &item, pbolt.target);

            pbolt.drop_object();

        fire_beam(pbolt);

        pbolt.fire();

        fire_beam(pbolt);

        pbolt.fire();

        explosion(beam);

        beam.explode();

// Returns random2(x) if random_factor is true, otherwise the mean.
static int maybe_random2( int x, bool random_factor )
{
    if (random_factor)
        return random2(x);
    else
        return x / 2;
}

        fire_beam(beam);

        beam.fire();

            mons_ench_f2( def, beam_temp );

            beam_temp.apply_enchantment_to_monster(def);

    bolt beam;
    // The scroll of immolation doesn't affect items.
    beam.affects_items = (caster != IMMOLATION_SCROLL);

    bolt beam;

    // The scroll of immolation doesn't affect items.
    explosion(beam, false, false, true, true, true,
              caster != IMMOLATION_SCROLL);

    beam.explode();

                explosion(boom);

                boom.explode();

    beam.delay   = 50; // Make beam animation slower than normal.

    beam.draw_delay = 50; // Make beam animation slower than normal.

    beam.fire();

    fire_beam(beam);

typedef FixedArray<int, 19, 19> explosion_map;

    coord_def   pos;                   // actual position

    char        ex_size;               // explosion radius (0==none)

    int         ex_size;               // explosion radius (0==none)

    bool        affects_items;         // hits items on ground/inventory

    int         delay;                 // delay used when drawing beam.

    int         draw_delay;            // delay used when drawing beam.

    bool        dropped_item;          // item has been dropped
    coord_def   item_pos;              // position item was dropped at
    int         item_index;            // mitm[index] of item

    bool        use_target_as_pos; // pos() should return ::target
    bool        auto_hit;

#ifdef USE_TILE
    int         tile_beam;
#endif

    // A constructor to try and fix some of the bugs that occur because
    // this struct never seems to be properly initialized.  Definition
    // is over in beam.cc.

    bool is_enchantment() const; // no block/dodge, but mag resist
    void set_target(const dist &);

    bool is_enchantment() const; // no block/dodge, use magic resist
    void set_target(const dist &targ);

    kill_category whose_kill() const;

    // Returns member short_name if set, otherwise some reasonble string

    void fire();
    // Returns member short_name if set, otherwise some reasonable string

    // Assume that all saving throws are failed, actually apply
    // the enchantment.
    mon_resist_type apply_enchantment_to_monster(monsters* mon);
    // Return whether any affected cell was seen.
    bool explode(bool show_more = true, bool hole_in_the_middle = false);
private:
    void do_fire();
    coord_def pos() const;
    // Lots of properties of the beam.
    bool is_blockable() const;
    bool is_superhot() const;
    bool is_fiery() const;
    bool affects_wall(dungeon_feature_type wall) const;
    bool is_bouncy(dungeon_feature_type feat) const;
    bool can_affect_wall_monster(const monsters* mon) const;
    bool stop_at_target() const;
    bool invisible() const;
    bool has_saving_throw() const;
    bool is_harmless(const monsters *mon) const;
    bool harmless_to_player() const;
    bool is_reflectable(const item_def *item) const;
    bool nasty_to(const monsters* mon) const;
    bool nice_to(const monsters* mon) const;
    bool found_player() const;
    int beam_source_as_target() const;
    int range_used_on_hit() const;
    std::string zapper() const;
    std::set<std::string> message_cache;
    void emit_message(msg_channel_type chan, const char* msg);
    void step();
    void hit_wall();
    // Functions which handle actually affecting things. They all
    // operate on the beam's current position (i.e., whatever pos()
    // returns.)
public:
    void affect_cell();
    void affect_wall();
    void affect_monster( monsters* m );
    void affect_player();
    void affect_ground();
    void affect_place_clouds();
    void affect_place_explosion_clouds();
    void affect_endpoint();
    // Stuff when a monster or player is hit.
    void affect_player_enchantment();
    void tracer_affect_player();
    void tracer_affect_monster(monsters* mon);
    bool handle_statue_disintegration(monsters* mon);
    void apply_bolt_paralysis(monsters *monster);
    void apply_bolt_petrify(monsters *monster);
    void enchantment_affect_monster(monsters* mon);
    mon_resist_type try_enchant_monster(monsters *mon);
    void tracer_enchantment_affect_monster(monsters* mon);
    void tracer_nonenchantment_affect_monster(monsters* mon);
    void update_hurt_or_helped(monsters *mon);
    bool attempt_block(monsters* mon);
    void handle_stop_attack_prompt(monsters* mon);
    bool determine_damage(monsters* mon, int& preac, int& postac, int& final);
    void monster_post_hit(monsters* mon, int dmg);
    bool misses_player();
    void initialize_fire();
    void apply_beam_conducts();
    void choose_ray();
    void draw(const coord_def& p);
    void bounce();
    void reflect();
    void fake_flavour();
    void digging_wall_effect();
    void fire_wall_effect();
    void nuke_wall_effect();
    void drop_object();
    void finish_beam();
    bool fuzz_invis_tracer();
    void internal_ouch(int dam);
    // Various explosion-related stuff.
    void refine_for_explosion();
    void explosion_draw_cell(const coord_def& p);
    void explosion_affect_cell(const coord_def& p);
    void determine_affected_cells(explosion_map& m, const coord_def& delta,
                                  int count, int r,
                                  bool stop_at_statues, bool stop_at_walls);

void fire_beam(bolt &pbolt);

/* FIXME: remove this

*/

// Return whether the effect was visible.
bool enchant_monster_with_flavour(monsters* mon, beam_type flavour,
                                  int powc = 0);

mon_resist_type mons_ench_f2(monsters *monster, bolt &pbolt);

int affect(bolt &beam, const coord_def& p = coord_def(),
           item_def *item = NULL, bool affect_items = true);
void beam_drop_object( bolt &beam, item_def *item = NULL,
                       const coord_def& where = coord_def() );

static FixedArray < int, 19, 19 > explode_map;

static bool _affects_wall(const bolt &beam, int wall_feature);
static bool _isBouncy(bolt &beam, unsigned char gridtype);
static int _beam_source(const bolt &beam);
static std::string _beam_zapper(const bolt &beam);
static bool _beam_term_on_target(bolt &beam, const coord_def& p);
static void _beam_explodes(bolt &beam, const coord_def& p);
static int  _affect_wall(bolt &beam, const coord_def& p);
static int  _affect_place_clouds(bolt &beam, const coord_def& p);
static void _affect_place_explosion_clouds(bolt &beam, const coord_def& p);
static int  _affect_player(bolt &beam, item_def *item = NULL,
                           bool affect_items = true);
static int  _affect_monster(bolt &beam, monsters *mon, item_def *item = NULL);
static mon_resist_type _affect_monster_enchantment(bolt &beam, monsters *mon);
static void _beam_paralyses_monster( bolt &pbolt, monsters *monster );
static void _beam_petrifies_monster( bolt &pbolt, monsters *monster );
static int  _range_used_on_hit(bolt &beam);
static void _explosion1(bolt &pbolt);
static void _explosion_map(bolt &beam, const coord_def& p,
                           int count, int r);
static void _explosion_cell(bolt &beam, const coord_def& p, bool drawOnly,
                            bool affect_items = true);

static bool _nasty_beam(monsters *mon, const bolt &beam);
static bool _nice_beam(monsters *mon, const bolt &beam);

static bool _beam_is_blockable(bolt &pbolt)

bool bolt::is_blockable() const

    return (!pbolt.is_beam && !pbolt.is_explosion
            && pbolt.flavour != BEAM_ELECTRICITY);

    return (!is_beam && !is_explosion && flavour != BEAM_ELECTRICITY);

// Kludge to suppress multiple redundant messages for a single beam.
static void _beam_mpr(msg_channel_type channel, const char *s, ...)

void bolt::emit_message(msg_channel_type chan, const char* m)

    va_list args;
    va_start(args, s);
    char buf[500];
    vsnprintf(buf, sizeof buf, s, args);
    va_end(args);
    std::string message = buf;
    if (beam_message_cache.find(message) == beam_message_cache.end())
        mpr(message.c_str(), channel);

    const std::string message = m;
    if (message_cache.find(message) == message_cache.end())
        mpr(m, chan);

    beam_message_cache.insert(message);

    message_cache.insert(message);

static kill_category _whose_kill(const bolt &beam)

kill_category bolt::whose_kill() const

    if (YOU_KILL(beam.thrower))

    if (YOU_KILL(thrower))

    else if (MON_KILL(beam.thrower))

    else if (MON_KILL(thrower))

        if (beam.beam_source == ANON_FRIENDLY_MONSTER)

        if (beam_source == ANON_FRIENDLY_MONSTER)

        if (!invalid_monster_index(beam.beam_source))

        if (!invalid_monster_index(beam_source))

            const monsters *mon = &menv[beam.beam_source];

            const monsters *mon = &menv[beam_source];

    beam.dropped_item   = false;             // no item droped yet

    fire_beam(pbolt);

    pbolt.fire();

    // FIXME: can this be removed?

    _zappy(ztype, power, pbolt);

    pbolt.dropped_item  = false;

    fire_beam(pbolt);

    pbolt.fire();

    // Tracers shouldn't drop items.
    ASSERT(!pbolt.dropped_item);

        // Incoming power is highly dependant on mass (see spells3.cc).

        // Incoming power is highly dependent on mass (see spells3.cc).

static bool _affect_mon_in_wall(bolt &pbolt, item_def *item,
                                const coord_def& where)

bool bolt::can_affect_wall_monster(const monsters* mon) const

    UNUSED(item);
    int mid = mgrd(where);

    const bool superconductor = (grd(mon->pos()) == DNGN_METAL_WALL
                                 && flavour == BEAM_ELECTRICITY);
    if (mons_wall_shielded(mon) && !superconductor)
        return (false);

    if (mid == NON_MONSTER)

    if (is_bouncy(grd(mon->pos())))

    if (pbolt.is_enchantment()
        || (!pbolt.is_explosion && !pbolt.is_big_cloud
            && (grd(where) == DNGN_METAL_WALL
                || pbolt.flavour != BEAM_ELECTRICITY)))
    {
        if (!mons_wall_shielded(&menv[mid]))
            return (true);
    }

    if (is_enchantment() || (!is_explosion && !is_big_cloud))
        return (true);

/*
 * Beam pseudo code:
 *
 * 1. Calculate stepx and stepy - algorithms depend on finding a step axis
 *    which results in a line of rise 1 or less (ie 45 degrees or less)
 * 2. Calculate range.  Tracers always have max range, otherwise the beam
 *    will have somewhere between range and rangeMax
 * 3. Loop tracing out the line:
 *      3a. Check for walls and wall affecting beams
 *      3b. If no valid move is found, try a fuzzy move
 *      3c. If no valid move is yet found, try bouncing
 *      3d. If no valid move or bounce is found, break
 *      4. Check for beam termination on target
 *      5. Affect the cell which the beam just moved into -> affect()
 *      6. If the beam was reflected during affect() then return, since
 *         a recursive call to fire_beam() took care of the rest.
 *      7. Decrease remaining range appropriately
 *      8. Check for early out due to aimed_at_feet
 *      9. Draw the beam
 *10. Drop an object where the beam 'landed'
 *11. Beams explode where the beam 'landed'
 *12. If no message generated yet, send "nothing happens" (enchantments only)
 *
 */

bool bolt::invisible() const
{
    return (type == 0 || is_enchantment());
}

void fire_beam(bolt &pbolt)

void bolt::initialize_fire()

    ASSERT(pbolt.flavour > BEAM_NONE && pbolt.flavour < BEAM_FIRST_PSEUDO);
    ASSERT(!pbolt.drop_item || pbolt.item);
    ASSERT(!pbolt.dropped_item);

    ASSERT(flavour > BEAM_NONE && flavour < BEAM_FIRST_PSEUDO);
    ASSERT(!drop_item || item);
    ASSERT(range >= 0);

    pbolt.real_flavour = pbolt.flavour;

    real_flavour = flavour;

    const bool beam_invisible =
        pbolt.type == 0 || (!pbolt.name.empty() && pbolt.name[0] == '0');

    // Fix some things which the tracer might have set.
    range_used = 0;
    in_explosion_phase = false;
    use_target_as_pos = false;

    ASSERT(pbolt.flavour != BEAM_VISUAL
           || (!beam_invisible && pbolt.colour != BLACK));

    message_cache.clear();

    const int reflections = pbolt.reflections;
    if (reflections == 0)

    // seen might be set by caller to supress this.
    if (!seen && see_grid(source) && range > 0 && !invisible() )

        // We aren't being recursively called, so initialize some stuff.
        beam_message_cache.clear();
        pbolt.range_used = 0;

        seen = true;
        const int midx = mgrd(source);

        // pbolt.seen might be set by caller to supress this.
        if (!pbolt.seen && see_grid(pbolt.source) && pbolt.range > 0
            && !beam_invisible)

        if (flavour != BEAM_VISUAL
            && !is_tracer
            && !YOU_KILL(thrower)
            && !crawl_state.is_god_acting()
            && (midx == NON_MONSTER || !you.can_see(&menv[midx])))

            pbolt.seen = true;
            int midx = mgrd(pbolt.source);
            if (pbolt.flavour != BEAM_VISUAL && !pbolt.is_tracer
                && !YOU_KILL(pbolt.thrower) && !crawl_state.is_god_acting()
                && (midx == NON_MONSTER || !you.can_see(&menv[midx])))
            {
                mprf("%s appears from out of thin air!",
                     article_a(pbolt.name, false).c_str());
            }

            mprf("%s appears from out of thin air!",
                 article_a(name, false).c_str());

    ASSERT(pbolt.range >= 0 && pbolt.range_used >=0);
    ASSERT(pbolt.range_used <= pbolt.range);

    if (pbolt.range == pbolt.range_used && pbolt.range > 0)
    {
#ifdef DEBUG
        mprf(MSGCH_DIAGNOSTICS, "fire_beam() called on already done beam "
             "'%s' (item = '%s')", pbolt.name.c_str(),
             pbolt.item ? pbolt.item->name(DESC_PLAIN).c_str() : "none");

#if DEBUG_DIAGNOSTICS
    mprf( MSGCH_DIAGNOSTICS, "%s%s%s [%s] (%d,%d) to (%d,%d): "
          "ty=%d col=%d flav=%d hit=%d dam=%dd%d range=%d",
          (is_beam) ? "beam" : "missile",
          (is_explosion) ? "*" :
          (is_big_cloud) ? "+" : "",
          (is_tracer) ? " tracer" : "",
          name.c_str(),
          source.x, source.y,
          target.x, target.y,
          type, colour, flavour,
          hit, damage.num, damage.size,
          range);

        return;
    }

}

    if (!pbolt.is_tracer && reflections == 0 && YOU_KILL(pbolt.thrower))

void bolt::apply_beam_conducts()
{
    if (!is_tracer && YOU_KILL(thrower))

        switch(pbolt.flavour)

        switch (flavour)

            did_god_conduct(DID_UNHOLY, 2 + random2(3), pbolt.effect_known);

            did_god_conduct(DID_UNHOLY, 2 + random2(3), effect_known);

}

    bool beamTerminate;     // Has beam been 'stopped' by something?
    coord_def &testpos(pbolt.pos);
    bool did_bounce = false;
    cursor_control coff(false);

void bolt::choose_ray()
{
    if (!chose_ray || reflections > 0)
    {
        ray.fullray_idx = -1;   // to quiet valgrind
        find_ray( source, target, true, ray, 0, true );
    }
}

    // [ds] Forcing the beam out of explosion phase here - currently
    // no caller relies on the beam already being in_explosion_phase.
    // This fixes beams being in explosion after use as a tracer.
    pbolt.in_explosion_phase = false;

// Draw the bolt at p if needed.
void bolt::draw(const coord_def& p)
{
    if (is_tracer || is_enchantment() || !see_grid(p))
        return;
    // We don't clean up the old position.
    // First, most people like to see the full path,
    // and second, it is hard to do it right with
    // respect to killed monsters, cloud trails, etc.
    const coord_def drawpos = grid2view(p);

    int tile_beam = -1;

    if (tile_beam == -1)
        tile_beam = tileidx_bolt(*this);

    if (pbolt.item && !pbolt.is_tracer && pbolt.flavour == BEAM_MISSILE)

    if (tile_beam != -1 && in_los_bounds(drawpos))

        const coord_def diff = pbolt.target - pbolt.source;
        tile_beam = tileidx_item_throw(*pbolt.item, diff.x, diff.y);

        tiles.add_overlay(p, tile_beam);
        delay(draw_delay);

    else

#if DEBUG_DIAGNOSTICS
    mprf( MSGCH_DIAGNOSTICS, "%s%s%s [%s] (%d,%d) to (%d,%d): "
          "ty=%d col=%d flav=%d hit=%d dam=%dd%d range=%d",
          (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);

    {
        // bounds check
        if (in_los_bounds(drawpos))
        {
#ifndef USE_TILE
            cgotoxy(drawpos.x, drawpos.y);
            put_colour_ch(
                colour == BLACK ? random_colour() : element_colour(colour),
                type);

    // init
    pbolt.aimed_at_feet = (pbolt.target == pbolt.source);
    pbolt.msg_generated = false;
    ray_def ray;

            // Get curses to update the screen so we can see the beam.
            update_screen();
            delay(draw_delay);
        }
    }
}

    if (pbolt.chose_ray)
        ray = pbolt.ray;
    else

void bolt::bounce()
{
    ray_def old_ray  = ray;
    bolt    old_bolt = *this;
    do

        ray.fullray_idx = -1;   // to quiet valgrind
        find_ray( pbolt.source, pbolt.target, true, ray, 0, true );
    }

        do {
            ray.regress();
        } while (grid_is_solid(grd(ray.pos())));
        bounce_pos = ray.pos();
        ray.advance_and_bounce();
        range_used += 2;
    } while (range_used < range && grid_is_solid(grd(ray.pos())));

    if (!pbolt.aimed_at_feet)
        ray.advance_through(pbolt.target);

    if (!grid_is_solid(grd(ray.pos())))
        _munge_bounced_bolt(old_bolt, *this, old_ray, ray);
}

    // Give chance for beam to affect one cell even if aimed_at_feet.
    beamTerminate = false;

void bolt::fake_flavour()
{
    if (real_flavour == BEAM_RANDOM)
        flavour = static_cast<beam_type>(random_range(BEAM_FIRE, BEAM_ACID));
    else if (real_flavour == BEAM_CHAOS)
        flavour = _chaos_beam_flavour();
}

    // Before we start drawing the beam, turn buffering off.
#ifdef WIN32CONSOLE
    bool oldValue = true;
    if (!pbolt.is_tracer)
        oldValue = set_buffering(false);
#endif
    while (!beamTerminate)

void bolt::digging_wall_effect()
{
    const dungeon_feature_type feat = grd(pos());
    if (feat == DNGN_ROCK_WALL || feat == DNGN_CLEAR_ROCK_WALL)

        testpos = ray.pos();
        // Random beams: randomize before affect().
        if (pbolt.real_flavour == BEAM_RANDOM)
            pbolt.flavour = static_cast<beam_type>(
                                random_range(BEAM_FIRE, BEAM_ACID));
        else if (pbolt.real_flavour == BEAM_CHAOS)
            pbolt.flavour = _chaos_beam_flavour();

        grd(pos()) = DNGN_FLOOR;
        // 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(pos());

        // Shooting through clouds affects accuracy.
        if (env.cgrid(testpos) != EMPTY_CLOUD)
            pbolt.hit = std::max(pbolt.hit - 2, 0);

        // Blood does not transfer onto floor.
        if (is_bloodcovered(pos()))
            env.map(pos()).property &= ~(FPROP_BLOODY);

        // See if tx, ty is blocked by something.
        if (grid_is_solid(grd(testpos)))

        if (!msg_generated)

            // First, check to see if this beam affects walls.
            if (_affects_wall(pbolt, grd(testpos)))

            if (!silenced(you.pos()))

                // Should we ever get a tracer with a wall-affecting
                // beam (possible I suppose), we'll quit tracing now.
                if (!pbolt.is_tracer)
                {
                    (void) affect(pbolt, testpos);
                    if (pbolt.reflections > reflections)
                        return;
                }
                // If it's still a wall, quit.
                if (grid_is_solid(grd(testpos)))
                    break;      // breaks from line tracing

                mpr("You hear a grinding noise.", MSGCH_SOUND);
                obvious_effect = true;

            else
            {
                // BEGIN bounce case.  Bouncing protects any monster
                // in the wall.
                if (!_isBouncy(pbolt, grd(testpos)))
                {
                    // Affect any monster that might be in the wall.
                    (void) affect(pbolt, testpos);
                    if (pbolt.reflections > reflections)
                        return;

                    
            msg_generated = true;
        }
    }
    else if (grid_is_wall(feat))
    {
        finish_beam();
    }
}

                    do
                    {
                        ray.regress();
                        pbolt.bounce_pos = ray.pos();
                    }
                    while (grid_is_solid(grd(ray.pos())));

void bolt::fire_wall_effect()
{
    // Fire only affects wax walls.
    if (grd(pos()) != DNGN_WAX_WALL)
    {
        finish_beam();
        return;
    }

                    testpos = ray.pos();
                    break;          // breaks from line tracing
                }

    if (!is_superhot())
    {
        // No actual effect.
        if (flavour != BEAM_HELLFIRE)
        {
            if (see_grid(pos()))
            {
                emit_message(MSGCH_PLAIN,
                             "The wax appears to soften slightly.");
            }
            else if (player_can_smell())
                emit_message(MSGCH_PLAIN, "You smell warm wax.");
        }
    }
    else
    {
        // Destroy the wall.
        grd(pos()) = DNGN_FLOOR;
        if (see_grid(pos()))
            emit_message(MSGCH_PLAIN, "The wax bubbles and burns!");
        else if (player_can_smell())
            emit_message(MSGCH_PLAIN, "You smell burning wax.");
            
        place_cloud(CLOUD_FIRE, pos(), random2(10)+15, whose_kill(), killer());
            
        obvious_effect = true;
    }
    finish_beam();
}

                did_bounce = true;
                pbolt.bounces++;

void bolt::nuke_wall_effect()
{
    const dungeon_feature_type feat = grd(pos());

                // bounce
                ray_def old_ray  = ray;
                bolt    old_bolt = pbolt;
                do
                {
                    do
                    {
                        ray.regress();
                        pbolt.bounce_pos = ray.pos();
                    }
                    while (grid_is_solid(grd(ray.pos())));

    if (feat == DNGN_ROCK_WALL
        || feat == DNGN_WAX_WALL
        || feat == DNGN_CLEAR_ROCK_WALL)
    {
        // FIXME: Blood *does* transfer to the floor here?
        grd(pos()) = DNGN_FLOOR;
        if (player_can_hear(pos()))
        {
            mpr("You hear a grinding noise.", MSGCH_SOUND);
            obvious_effect = true;
        }
    }
    else if (feat == DNGN_ORCISH_IDOL || feat == DNGN_GRANITE_STATUE)
    {
        grd(pos()) = DNGN_FLOOR;

                    ray.advance_and_bounce();
                    pbolt.range_used += 2;
                }
                while (pbolt.range_used < pbolt.range
                       && grid_is_solid(grd(ray.pos())));

        // Blood does not transfer onto floor.
        if (is_bloodcovered(pos()))
            env.map(pos()).property &= ~(FPROP_BLOODY);
            
        if (player_can_hear(pos()))
        {
            if (!see_grid(pos()))
                mpr("You hear a hideous screaming!", MSGCH_SOUND);
            else
            {
                mpr("The statue screams as its substance crumbles away!",
                    MSGCH_SOUND);
            }
        }
        else if (see_grid(pos()))
            mpr("The statue twists and shakes as its substance crumbles away!");

                if (!grid_is_solid(grd(ray.pos())))
                    _munge_bounced_bolt(old_bolt, pbolt, old_ray, ray);

        if (feat == DNGN_ORCISH_IDOL && beam_source == NON_MONSTER)
            did_god_conduct(DID_DESTROY_ORCISH_IDOL, 8);
        
        obvious_effect = true;
    }
    finish_beam();
}

                if (pbolt.range_used >= pbolt.range)
                    break;

void bolt::finish_beam()
{
    range_used = range;
}

                testpos = ray.pos();
            } // end else - beam doesn't affect walls
        } // endif - are we in a wall wall?

void bolt::affect_wall()
{
    if (flavour == BEAM_DIGGING)
        digging_wall_effect();
    else if (is_fiery())
        fire_wall_effect();
    else if (flavour == BEAM_DISINTEGRATION || flavour == BEAM_NUKE)
        nuke_wall_effect();

        // At this point, if grd(testpos) is still a wall, we
        // couldn't find any path: bouncy, fuzzy, or not - so break.
        if (grid_is_solid(grd(testpos)))
            break;

    if (grid_is_solid(pos()))
        finish_beam();
}

        const bool was_seen = pbolt.seen;
        if (!was_seen && pbolt.range > 0 && !beam_invisible
            && see_grid(testpos))
        {
            pbolt.seen = true;
        }

coord_def bolt::pos() const
{
    if (in_explosion_phase || use_target_as_pos)
        return target;
    else
        return ray.pos();
}

        if (pbolt.flavour != BEAM_VISUAL && !was_seen && pbolt.seen
            && !pbolt.is_tracer)

void bolt::hit_wall()
{
    const dungeon_feature_type feat = grd(pos());
    ASSERT( grid_is_solid(feat) );
        
    if (affects_wall(feat))
        affect_wall();
    else if (is_bouncy(feat) && !in_explosion_phase)
        bounce();
    else
    {
        // Affect a creature in the wall, if any.
        if (!invalid_monster_index(mgrd(pos())))
            affect_monster( &menv[mgrd(pos())] );
        // Regress for explosions: blow up one step earlier.
        if (is_explosion && !in_explosion_phase)

            mprf("%s appears from out of your range of vision.",
                 article_a(pbolt.name, false).c_str());

            do {
                ray.regress();
            } while (grid_is_solid(ray.pos()));
            finish_beam();

    }
}

        // Check for "target termination"
        // occurs when beam can be targetted at empty
        // cell (e.g. a mage wants an explosion to happen
        // between two monsters).

void bolt::affect_cell()
{
    // Shooting through clouds affects accuracy.
    if (env.cgrid(pos()) != EMPTY_CLOUD)
        hit = std::max(hit - 2, 0);
        
    fake_flavour();

        // In this case, don't affect the cell - players and
        // monsters have no chance to dodge or block such
        // a beam, and we want to avoid silly messages.
        if (testpos == pbolt.target)
            beamTerminate = _beam_term_on_target(pbolt, testpos);

    const coord_def old_pos = pos();
    const bool was_solid = grid_is_solid(grd(pos()));
    if (was_solid)
    {
        const int mid = mgrd(pos());

        // Affect the cell, except in the special case noted
        // above -- affect() will early out if something gets
        // hit and the beam is type 'term on target'.
        if (!beamTerminate || !pbolt.is_explosion)

        // Some special casing.
        if (!invalid_monster_index(mid))

            if (!pbolt.affects_nothing)

            monsters* const mon = &menv[mid];
            if (can_affect_wall_monster(mon))
                affect_monster(mon);
            else

                (void) affect(pbolt, testpos);
                if (pbolt.reflections > reflections)
                    return;

                mprf("The %s protects %s from harm.",
                     raw_feature_description(grd(mon->pos())).c_str(),
                     mon->name(DESC_NOCAP_THE).c_str());

        ASSERT(pbolt.reflections == reflections);

        
        // Note that this can change the ray position
        // and the solidity of the wall.
        hit_wall();
    }

        if (pbolt.beam_cancelled)
            return;

    // We don't want to hit a monster in a wall square twice.
    const bool still_wall = (was_solid && old_pos == pos());
    if (!still_wall && !invalid_monster_index(mgrd(pos())))
        affect_monster( &menv[mgrd(pos())] );

        // Always decrease range by 1.
        pbolt.range_used++;

    // If the player can ever walk through walls, this will
    // need special-casing too.
    if (found_player())
        affect_player();

        // Check for range termination.
        if (pbolt.range_used >= pbolt.range)
            beamTerminate = true;

    if (!grid_is_solid(grd(pos())))
        affect_ground();
}

        // Special case - beam was aimed at feet.
        if (pbolt.aimed_at_feet)
            beamTerminate = true;

// This saves some important things before calling fire().
void bolt::fire()
{
    if (is_tracer)
    {
        bolt boltcopy = *this;
        do_fire();

        // Reset chaos beams so that it won't be considered an invisible
        // enchantment beam for the purposes of animation.
        if (pbolt.real_flavour == BEAM_CHAOS)
            pbolt.flavour = pbolt.real_flavour;

        target = boltcopy.target;
        source = boltcopy.source;
        aimed_at_spot = boltcopy.aimed_at_spot;
        range_used = boltcopy.range_used;
        bounces = boltcopy.bounces;
        bounce_pos = boltcopy.bounce_pos;
        reflections = boltcopy.reflections;
        reflector = boltcopy.reflector;
        auto_hit = boltcopy.auto_hit;
        ray = boltcopy.ray;
    }
    else
        do_fire();
}

        // Actually draw the beam/missile/whatever, if the player can see
        // the cell.
        if (!pbolt.is_tracer && !pbolt.is_enchantment() && see_grid(testpos))
        {
            // We don't clean up the old position.
            // First, most people like to see the full path,
            // and second, it is hard to do it right with
            // respect to killed monsters, cloud trails, etc.

void bolt::do_fire()
{
    initialize_fire();
    
    if (range <= range_used && range > 0)
    {
#ifdef DEBUG
        mprf(MSGCH_DIAGNOSTICS, "fire_beam() called on already done beam "
             "'%s' (item = '%s')", name.c_str(),
             item ? item->name(DESC_PLAIN).c_str() : "none");
#endif
        return;
    }

            // Draw new position.
            coord_def drawpos = grid2view(testpos);

    apply_beam_conducts();
    cursor_control coff(false);

            if (tile_beam == -1)
                tile_beam = tileidx_bolt(pbolt);

    tile_beam = -1;

            if (tile_beam != -1 && in_los_bounds(drawpos))
            {
                tiles.add_overlay(testpos, tile_beam);
                delay(pbolt.delay);
            }
            else
#endif
            // bounds check
            if (in_los_bounds(drawpos))
            {
#ifndef USE_TILE
                cgotoxy(drawpos.x, drawpos.y);
                put_colour_ch(
                    pbolt.colour == BLACK ? random_colour()
                                          : element_colour(pbolt.colour),
                    pbolt.type );

    if (item && !is_tracer && flavour == BEAM_MISSILE)
    {
        const coord_def diff = target - source;
        tile_beam = tileidx_item_throw(*item, diff.x, diff.y);
    }

                // Get curses to update the screen so we can see the beam.
                update_screen();

                delay(pbolt.delay);

    msg_generated = false;
    if (target == source)
    {
        auto_hit = true;
        aimed_at_spot = true;
        use_target_as_pos = true;
    }
    else
    {
        choose_ray();
        // Take *one* step, so as not to hurt the source.
        ray.advance_through(target);
    }

#ifdef MISSILE_TRAILS_OFF
                // mv: It's not optimal but is usually enough.
                if (!pbolt.is_beam)
                    viewwindow(true, false);

#ifdef WIN32CONSOLE
    // Before we start drawing the beam, turn buffering off.
    bool oldValue = true;
    if (!is_tracer)
        oldValue = set_buffering(false);

            }

        }

    while (true)
    {
        affect_cell();

        if (!did_bounce)
            ray.advance_through(pbolt.target);
        else
            ray.advance(true);
    } // end- while !beamTerminate

        range_used++;
        if (range_used >= range)
            break;

    // The beam has finished, and terminated at tx, ty.

        if (beam_cancelled)
            return;

    // Leave an object, if applicable.
    if (pbolt.drop_item && pbolt.item && !pbolt.dropped_item)
        beam_drop_object(pbolt);

        if (stop_at_target() && pos() == target)
            break;

    // Check for explosion.  NOTE that for tracers, we have to make a copy
    // of target co-ords and then reset after calling this -- tracers should
    // never change any non-tracers fields in the beam structure. -- GDL
    coord_def targetcopy = pbolt.target;

        const bool was_seen = seen;
        if (!was_seen && range > 0 && !invisible() && see_grid(pos()))
            seen = true;

    _beam_explodes(pbolt, testpos);

        if (flavour != BEAM_VISUAL && !was_seen && seen && !is_tracer)
        {
            mprf("%s appears from out of your range of vision.",
                 article_a(name, false).c_str());
        }

    if (pbolt.is_tracer)
    {
        pbolt.target = targetcopy;

        // Reset chaos beams so that it won't be considered an invisible
        // enchantment beam for the purposes of animation.
        if (real_flavour == BEAM_CHAOS)
            flavour = real_flavour;
        // Actually draw the beam/missile/whatever, if the player can see
        // the cell.
        draw(pos());
        // A bounce takes away the meaning from the target.
        if (bounces == 0)
            ray.advance_through(target);
        else
            ray.advance(true);

    // The beam has terminated.
    affect_endpoint();
    // Tracers need nothing further.
    if (is_tracer)
        return;

    if (pbolt.is_enchantment() && pbolt.real_flavour != BEAM_CHAOS)

    if (!msg_generated && !obvious_effect && is_enchantment()
        && real_flavour != BEAM_CHAOS && YOU_KILL(thrower))

        if (!pbolt.is_tracer && !pbolt.msg_generated && !pbolt.obvious_effect
            && YOU_KILL(pbolt.thrower))
        {
            canned_msg(MSG_NOTHING_HAPPENS);
        }

        canned_msg(MSG_NOTHING_HAPPENS);

    if (!pbolt.is_tracer && !invalid_monster_index(pbolt.beam_source))

    // Reactions if a monster zapped the beam.
    if (!invalid_monster_index(beam_source))

        if (pbolt.foe_hurt == 0 && pbolt.fr_hurt > 0)

        if (foe_hurt == 0 && fr_hurt > 0)

        else if (pbolt.foe_helped > 0 && pbolt.fr_helped == 0)

        else if (foe_helped > 0 && fr_helped == 0)

        const monsters *mon = &menv[pbolt.beam_source];
        if (pbolt.foe_hurt > 0 && !mons_wont_attack(mon)

        const monsters *mon = &menv[beam_source];
        if (foe_hurt > 0 && !mons_wont_attack(mon)

            you.pet_target = pbolt.beam_source;

            you.pet_target = beam_source;

    if (!pbolt.is_tracer)
        set_buffering(oldValue);

    set_buffering(oldValue);

            poison_monster(monster, _whose_kill(pbolt));

            poison_monster(monster, pbolt.whose_kill());

                    poison_monster(monster, _whose_kill(pbolt), 2, true);

                    poison_monster(monster, pbolt.whose_kill(), 2, true);

            poison_monster(monster, _whose_kill(pbolt), 4);

            poison_monster(monster, pbolt.whose_kill(), 4);

                poison_monster(monster, _whose_kill(pbolt));

                poison_monster(monster, pbolt.whose_kill());

                mons_ench_f2(monster, beam);

                beam.apply_enchantment_to_monster(monster);

}
// Monster has probably failed save, now it gets enchanted somehow.
// * Returns MON_RESIST if monster is unaffected due to magic resist.
// * Returns MON_UNAFFECTED if monster is immune to enchantment.
// * Returns MON_AFFECTED in all other cases (already enchanted, etc).
mon_resist_type mons_ench_f2(monsters *monster, bolt &pbolt)
{
    switch (pbolt.flavour)      // put in magic resistance
    {
    case BEAM_SLOW:
        // try to remove haste, if monster is hasted
        if (monster->del_ench(ENCH_HASTE))
        {
            if (simple_monster_message(monster,
                                       " is no longer moving quickly."))
            {
                pbolt.obvious_effect = true;
            }
            return (MON_AFFECTED);
        }
        // not hasted, slow it
        if (!monster->has_ench(ENCH_SLOW)
            && !mons_is_stationary(monster)
            && monster->add_ench(mon_enchant(ENCH_SLOW, 0, _whose_kill(pbolt))))
        {
            if (!mons_is_paralysed(monster) && !mons_is_petrified(monster)
                && simple_monster_message(monster, " seems to slow down."))
            {
                pbolt.obvious_effect = true;
            }
        }
        return (MON_AFFECTED);
    case BEAM_HASTE:
        if (monster->del_ench(ENCH_SLOW))
        {
            if (simple_monster_message(monster, " is no longer moving slowly."))
                pbolt.obvious_effect = true;
            return (MON_AFFECTED);
        }
        // Not slowed, haste it.
        if (!monster->has_ench(ENCH_HASTE)
            && !mons_is_stationary(monster)
            && monster->add_ench(ENCH_HASTE))
        {
            if (!mons_is_paralysed(monster) && !mons_is_petrified(monster)
                && simple_monster_message(monster, " seems to speed up."))
            {
                pbolt.obvious_effect = true;
            }
        }
        return (MON_AFFECTED);
    case BEAM_HEALING:
        if (YOU_KILL(pbolt.thrower))
        {
            if (cast_healing(5 + pbolt.damage.roll(), monster->pos()) > 0)
                pbolt.obvious_effect = true;
            pbolt.msg_generated = true; // to avoid duplicate "nothing happens"
        }
        else if (heal_monster( monster, 5 + pbolt.damage.roll(), false ))
        {
            if (monster->hit_points == monster->max_hit_points)
            {
                if (simple_monster_message(monster,
                                           "'s wounds heal themselves!"))
                {
                    pbolt.obvious_effect = true;
                }
            }
            else if (simple_monster_message(monster, " is healed somewhat."))
                pbolt.obvious_effect = true;
        }
        return (MON_AFFECTED);
    case BEAM_PARALYSIS:
        _beam_paralyses_monster(pbolt, monster);
        return (MON_AFFECTED);
    case BEAM_PETRIFY:
        _beam_petrifies_monster(pbolt, monster);
        return (MON_AFFECTED);
    case BEAM_CONFUSION:
        if (!mons_class_is_confusable(monster->type))
            return (MON_UNAFFECTED);
        if (monster->add_ench( mon_enchant(ENCH_CONFUSION, 0,
                               _whose_kill(pbolt)) ))
        {
            // Put in an exception for things you won't notice becoming
            // confused.
            if (simple_monster_message(monster, " appears confused."))
                pbolt.obvious_effect = true;
        }
        return (MON_AFFECTED);
    case BEAM_INVISIBILITY:
    {
        // Store the monster name before it becomes an "it" -- bwr
        const std::string monster_name = monster->name(DESC_CAP_THE);
        if (!monster->has_ench(ENCH_INVIS)
            && monster->add_ench(ENCH_INVIS))
        {
            // A casting of invisibility erases backlight.
            monster->del_ench(ENCH_BACKLIGHT);
            // Can't use simple_monster_message() here, since it checks
            // for visibility of the monster (and it's now invisible).
            // -- bwr
            if (mons_near( monster ))
            {
                mprf("%s flickers %s",
                     monster_name.c_str(),
                     player_monster_visible(monster) ? "for a moment."
                                                     : "and vanishes!" );
                if (!player_monster_visible(monster))
                {
                    // Also turn off autopickup.
                    Options.autopickup_on = false;
                    mpr("Deactivating autopickup; reactivate with Ctrl-A.",
                        MSGCH_WARN);
                    if (Options.tutorial_left)
                    {
                        learned_something_new(TUT_INVISIBLE_DANGER);
                        Options.tut_seen_invisible = you.num_turns;
                    }
                }
            }
            pbolt.obvious_effect = true;
        }
        return (MON_AFFECTED);
    }
    case BEAM_CHARM:
        if (player_will_anger_monster(monster))
        {
            simple_monster_message(monster, " is repulsed!");
            return (MON_OTHER);
        }
        if (monster->add_ench(ENCH_CHARM))
        {
            // Put in an exception for fungi, plants and other things
            // you won't notice becoming charmed.
            if (simple_monster_message(monster, " is charmed."))
                pbolt.obvious_effect = true;
        }
        return (MON_AFFECTED);
    default:
        break;
    }
    return (MON_AFFECTED);
}
// degree is ignored.
static void _slow_monster(monsters *mon, int /* degree */)
{
    bolt beam;
    beam.flavour = BEAM_SLOW;
    mons_ench_f2(mon, beam);