enum attack_final_effect_flavor
{
    FINEFF_LIGHTNING_DISCHARGE
};
struct attack_final_effect
{
    attack_final_effect_flavor flavor;
    coord_def location;
};

    std::vector<attack_final_effect> final_effects;

    bool player_monattk_final_hit_effects(bool mondied);

      miscast_target(NULL)

      miscast_target(NULL), final_effects()

// Effects that occur after all other effects, even if the monster is dead.
// For example, explosions that would hit other creatures, but we want
// to deal with only one creature at a time, so that's handled last.
// You probably want to call player_monattk_hit_effects instead, as that
// function calls this one.

bool melee_attack::player_monattk_final_hit_effects(bool mondied)
{
    for (unsigned int i = 0; i < final_effects.size(); ++i)
    {
        switch (final_effects[i].flavor)
        {
        case FINEFF_LIGHTNING_DISCHARGE:
            if (see_cell(final_effects[i].location))
                mpr("Electricity arcs through the water!");
            conduct_electricity(final_effects[i].location, attacker);
            break;
        }
    }
    return mondied;
}
// Returns true if the combat round should end here.

        return (true);

        return player_monattk_final_hit_effects(true);

        return (!defender->alive());

        return player_monattk_final_hit_effects(!defender->alive());

        return (true);

        return player_monattk_final_hit_effects(true);

        return (true);

        return player_monattk_final_hit_effects(true);

    return (false);

    return player_monattk_final_hit_effects(false);

            // Check for arcing in water, and add the final effect.
            const coord_def& pos = defender->pos();
            // We know the defender is neither airborne nor electricity
            // resistant, from above, but is it on water?
            if (feat_is_water(grd(pos)))
            {
                attack_final_effect effect;
                effect.flavor = FINEFF_LIGHTNING_DISCHARGE;
                effect.location = pos;
                final_effects.push_back(effect);
            }

void conduct_electricity(coord_def where, actor *attacker);

}
static bool _conduct_electricity_hit(bolt& beam, actor* victim, int dmg, int corpse)
{
    if (!victim->alive() || victim->res_elec() > 0 || victim->airborne())
        return (false);
    return (true);
}
static bool _conduct_electricity_damage(bolt &beam, actor* victim,
                                        int &dmg, std::string &dmg_msg)
{
    dmg = (10 + random2(15)) / 2;
    return false;

static bool _conduct_electricity_aoe(bolt& beam, const coord_def& target)
{
    if (feat_is_water(grd(target)))
        return true;

    return false;
}
void conduct_electricity(coord_def where, actor *attacker)
{
    const char *aux = "arcing electricity";
    bolt beam;
    beam.flavour       = BEAM_ELECTRICITY;
    beam.type          = dchar_glyph(DCHAR_FIRED_BURST);
    beam.damage        = dice_def(1, 15);
    beam.target        = where;
    beam.name          = "electric current";
    beam.colour        = LIGHTCYAN;
    beam.aux_source    = aux;
    beam.ex_size       = 1;
    beam.is_explosion  = true;
    beam.effect_known  = true;
    beam.affects_items = false;
    beam.aoe_funcs.push_back(_conduct_electricity_aoe);
    beam.hit_funcs.push_back(_conduct_electricity_hit);
    beam.damage_funcs.push_back(_conduct_electricity_damage);
    if (attacker == &you)
    {
        beam.thrower     = KILL_YOU;
        beam.beam_source = NON_MONSTER;
    }
    else
    {
        beam.thrower     = KILL_MON;
        beam.beam_source = attacker->mindex();
    }
    beam.explode(false, true);
}

typedef bool (*explosion_aoe_func)(bolt& beam, const coord_def& target);

    std::vector<explosion_aoe_func> aoe_funcs; // Function for if the
                                               // explosion only affects
                                               // certain grid positions.

    // Hmm, I think we're OK.
    m(delta + centre) = std::min(count, m(delta + centre));

    // Check if it passes the callback functions.
    bool hits = true;
    for (unsigned int i = 0; i < aoe_funcs.size(); ++i)
        hits = (*aoe_funcs[i])(*this, loc) && hits;
    if (hits) {
        // Hmm, I think we're OK.
        m(delta + centre) = std::min(count, m(delta + centre));
    }

               range_funcs(), damage_funcs(), hit_funcs(),

               range_funcs(), damage_funcs(), hit_funcs(), aoe_funcs(),