int power =
            (you.skills[SK_SPELLCASTING] / 2)
            + (fail_rate_check? 0 : player_mag_abil(false));

    int power = (you.skills[SK_SPELLCASTING] / 2)
                 + (fail_rate_check? 0 : player_mag_abil(false));

        if (!spell_direction( spd, beam, dir, targ, needs_path, prompt ))

        if (!spell_direction(spd, beam, dir, targ, needs_path, prompt))

        if (!zapping(ZAP_MAGIC_DARTS, powc, beam))

        if (!zapping(ZAP_MAGIC_DARTS, powc, beam, true))

        fireball(powc, beam);

        if (!fireball(powc, beam))
            return (SPRET_ABORT);

        if (!zapping( ZAP_STRIKING, powc, beam ))

        if (!zapping(ZAP_STRIKING, powc, beam, true))

        if (!zapping(ZAP_DIGGING, powc, beam))

        if (!zapping(ZAP_DIGGING, powc, beam, true))

        if (!zapping(ZAP_FIRE, powc, beam))

        if (!zapping(ZAP_FIRE, powc, beam, true))

        if (!zapping(ZAP_COLD, powc, beam))

        if (!zapping(ZAP_COLD, powc, beam, true))

        if (!zapping(ZAP_LIGHTNING, powc, beam))

        if (!zapping(ZAP_LIGHTNING, powc, beam, true))

        if (!zapping(ZAP_MAGMA, powc, beam))

        if (!zapping(ZAP_MAGMA, powc, beam, true))

        if (!zapping(ZAP_POLYMORPH_OTHER, powc, beam))

        if (!zapping(ZAP_POLYMORPH_OTHER, powc, beam, true))

        if (!zapping(ZAP_SLOWING, powc, beam))

        if (!zapping(ZAP_SLOWING, powc, beam, true))

        zapping(ZAP_HASTING, powc, beam);

        if (!zapping(ZAP_HASTING, powc, beam, true))
            return (SPRET_ABORT);

        if (!zapping(ZAP_PARALYSIS, powc, beam))

        if (!zapping(ZAP_PARALYSIS, powc, beam, true))

        if (!zapping(ZAP_CONFUSION, powc, beam))

        if (!zapping(ZAP_CONFUSION, powc, beam, true))

        zapping(ZAP_INVISIBILITY, powc, beam);

        if (!zapping(ZAP_INVISIBILITY, powc, beam, true))
            return (SPRET_ABORT);

        if (!zapping(ZAP_FLAME, powc, beam))

        if (!zapping(ZAP_FLAME, powc, beam, true))

        if (!zapping(ZAP_FROST, powc, beam))

        if (!zapping(ZAP_FROST, powc, beam, true))

        if (!zapping(ZAP_VENOM_BOLT, powc, beam))

        if (!zapping(ZAP_VENOM_BOLT, powc, beam, true))

        if (!zapping(ZAP_TELEPORTATION, powc, beam))

        if (!zapping(ZAP_TELEPORTATION, powc, beam, true))

        if (!zapping(ZAP_NEGATIVE_ENERGY, powc, beam))

        if (!zapping(ZAP_NEGATIVE_ENERGY, powc, beam, true))

        if (!zapping(ZAP_CRYSTAL_SPEAR, powc, beam))

        if (!zapping(ZAP_CRYSTAL_SPEAR, powc, beam, true))

        if (!zapping(ZAP_BEAM_OF_ENERGY, powc, beam))

        if (!zapping(ZAP_BEAM_OF_ENERGY, powc, beam, true))

        if (!zapping( ZAP_POISON_ARROW, powc, beam ))

        if (!zapping(ZAP_POISON_ARROW, powc, beam, true))

        if (!zapping( ZAP_MYSTIC_BLAST, powc, beam ))

        if (!zapping(ZAP_MYSTIC_BLAST, powc, beam, true))

        if (!zapping(ZAP_ENSLAVEMENT, powc, beam))

        if (!zapping(ZAP_ENSLAVEMENT, powc, beam, true))

        if (!zapping(ZAP_PAIN, powc, beam))

        if (!zapping(ZAP_PAIN, powc, beam, true))

        if (!zapping(ZAP_STICKY_FLAME, powc, beam))

        if (!zapping(ZAP_STICKY_FLAME, powc, beam, true))

        if (!zapping(ZAP_DISPEL_UNDEAD, powc, beam))

        if (!zapping(ZAP_DISPEL_UNDEAD, powc, beam, true))

        if (!zapping(ZAP_LIGHTNING, powc, beam))

        if (!zapping(ZAP_LIGHTNING, powc, beam, true))

        if (!zapping(ZAP_CLEANSING_FLAME, powc, beam))

        if (!zapping(ZAP_CLEANSING_FLAME, powc, beam, true))

        cast_bone_shards(powc, beam);

        if (!cast_bone_shards(powc, beam))
            return (SPRET_ABORT);

        if (!zapping(ZAP_BANISHMENT, powc, beam))

        if (!zapping(ZAP_BANISHMENT, powc, beam, true))

        if (!zapping(ZAP_DEGENERATION, powc, beam))

        if (!zapping(ZAP_DEGENERATION, powc, beam, true))

        if (!zapping(ZAP_STING, powc, beam))

        if (!zapping(ZAP_STING, powc, beam, true))

        // should only be available from:

        // Should only be available from:

        if (!zapping(ZAP_HELLFIRE, powc, beam))

        if (!zapping(ZAP_HELLFIRE, powc, beam, true))

        if (!zapping(ZAP_IRON_BOLT, powc, beam))

        if (!zapping(ZAP_IRON_BOLT, powc, beam, true))

        if (!zapping(ZAP_STONE_ARROW, powc, beam))

        if (!zapping(ZAP_STONE_ARROW, powc, beam, true))

        if (!zapping(ZAP_ELECTRICITY, powc, beam))

        if (!zapping(ZAP_ELECTRICITY, powc, beam, true))

        if (!zapping(ZAP_ORB_OF_ELECTRICITY, powc, beam))

        if (!zapping(ZAP_ORB_OF_ELECTRICITY, powc, beam, true))

        if (!zapping(ZAP_DEBUGGING_RAY, powc, beam))

        if (!zapping(ZAP_DEBUGGING_RAY, powc, beam, true))

        if (!zapping(ZAP_AGONY, powc, beam))

        if (!zapping(ZAP_AGONY, powc, beam, true))

        if (!zapping(ZAP_DISRUPTION, powc, beam))

        if (!zapping(ZAP_DISRUPTION, powc, beam, true))

        if (!zapping(ZAP_DISINTEGRATION, powc, beam))

        if (!zapping(ZAP_DISINTEGRATION, powc, beam, true))

        if (!zapping(ZAP_ORB_OF_FRAGMENTATION, powc, beam))

        if (!zapping(ZAP_ORB_OF_FRAGMENTATION, powc, beam, true))

        if (!zapping(ZAP_ICE_BOLT, powc, beam))

        if (!zapping(ZAP_ICE_BOLT, powc, beam, true))

        if (!zapping(ZAP_ICE_STORM, powc, beam))

        if (!zapping(ZAP_ICE_STORM, powc, beam, true))

        if (!zapping(ZAP_FLAME_TONGUE, powc, beam))

        if (!zapping(ZAP_FLAME_TONGUE, powc, beam, true))

        if (!zapping(ZAP_SLEEP, sleep_power, beam))

        if (!zapping(ZAP_SLEEP, sleep_power, beam, true))

        if (!zapping(ZAP_BACKLIGHT, powc + 10, beam))

        if (!zapping(ZAP_BACKLIGHT, powc + 10, beam, true))

        cast_sandblast(powc, beam);

        if (!cast_sandblast(powc, beam))
            return (SPRET_ABORT);

void cast_sandblast(int powc, bolt &beam);

bool cast_sandblast(int powc, bolt &beam);

void cast_sandblast(int pow, bolt &beam)

bool cast_sandblast(int pow, bolt &beam)

        big = (wpn.base_type == OBJ_MISSILES)
            && (wpn.sub_type == MI_STONE || wpn.sub_type == MI_LARGE_ROCK);

        big = (wpn.base_type == OBJ_MISSILES
               && (wpn.sub_type == MI_STONE || wpn.sub_type == MI_LARGE_ROCK));

    if (big)

    bool success = zapping(big ? ZAP_SANDBLAST
                               : ZAP_SMALL_SANDBLAST, pow, beam, true);
    if (big && success)

    zapping(big ? ZAP_SANDBLAST : ZAP_SMALL_SANDBLAST, pow, beam);

    return (success);

int cast_bone_shards(int power, bolt &);

bool cast_bone_shards(int power, bolt &);

int cast_bone_shards(int power, bolt &beam)

bool cast_bone_shards(int power, bolt &beam)

                    || you.inv[you.equip[EQ_WEAPON]].base_type != OBJ_CORPSES)

        || you.inv[you.equip[EQ_WEAPON]].base_type != OBJ_CORPSES)

        if (!player_tracer(ZAP_BONE_SHARDS, power, beam))
            return (false);

int fireball(int power, bolt &beam);

bool fireball(int power, bolt &beam);

int fireball(int power, bolt &beam)

bool fireball(int power, bolt &beam)

    zapping(ZAP_FIREBALL, power, beam);
    return (1);

    if (!zapping(ZAP_FIREBALL, power, beam, true))
        return (false);
    return (true);

    beam.ex_size = 2 + (random2(powc) > 75);
    beam.flavour = BEAM_LAVA;
    beam.type = dchar_glyph(DCHAR_FIRED_ZAP);
    beam.colour = RED;
    beam.beam_source = MHITYOU;
    beam.thrower = KILL_YOU_MISSILE;

    beam.name         = "great blast of fire";
    beam.ex_size      = 2 + (random2(powc) > 75);
    beam.flavour      = BEAM_LAVA;
    beam.type         = dchar_glyph(DCHAR_FIRED_ZAP);
    beam.colour       = RED;
    beam.beam_source  = MHITYOU;
    beam.thrower      = KILL_YOU_MISSILE;

    beam.is_beam = false;
    beam.is_tracer = false;

    beam.is_beam      = false;
    beam.is_tracer    = false;

    beam.ench_power = powc;     // used for radius
    beam.name = "great blast of fire";
    beam.hit = 20 + powc / 10;
    beam.damage = calc_dice( 9, 20 + powc );

    beam.ench_power   = powc;     // used for radius
    beam.hit          = 20 + powc / 10;
    beam.damage       = calc_dice( 9, 20 + powc );

    beam.name = "lightning arc";
    beam.aux_source = "chain lightning";
    beam.beam_source = MHITYOU;
    beam.thrower = KILL_YOU_MISSILE;
    beam.range = 8;
    beam.rangeMax = 8;
    beam.hit = AUTOMATIC_HIT;
    beam.type = dchar_glyph(DCHAR_FIRED_ZAP);
    beam.flavour = BEAM_ELECTRICITY;

    beam.name           = "lightning arc";
    beam.aux_source     = "chain lightning";
    beam.beam_source    = MHITYOU;
    beam.thrower        = KILL_YOU_MISSILE;
    beam.range          = 8;
    beam.rangeMax       = 8;
    beam.hit            = AUTOMATIC_HIT;
    beam.type           = dchar_glyph(DCHAR_FIRED_ZAP);
    beam.flavour        = BEAM_ELECTRICITY;

    beam.is_beam = false;            // since we want to stop at our target
    beam.is_explosion = false;
    beam.is_tracer = false;

    beam.is_beam        = false;       // since we want to stop at our target
    beam.is_explosion   = false;
    beam.is_tracer      = false;

    if ( si > 1 )

    if (si > 1)

    return si;

    return (si);

    // Assumed visible from now on

    // Assumed visible from now on.

    if ( mons_is_mimic(mon.type) && mon.type != MONS_GOLD_MIMIC )

    if (mons_is_mimic(mon.type) && mon.type != MONS_GOLD_MIMIC)

    if ( !mons_is_unique(mon.type) )

    if (!mons_is_unique(mon.type))

            (mons_friendly(&mon)) ? result = "Your "
                                  : result = "The ";

            result = (mons_friendly(&mon) ? "Your "
                                          : "The ");

            (mons_friendly(&mon)) ? result = "your "
                                  : result = "the ";

            result = (mons_friendly(&mon) ? "your "
                                          : "the ");

        return ZAP_DEBUGGING_RAY;

        return (ZAP_DEBUGGING_RAY);

        if ( one_chance_in(20) )

        if (one_chance_in(20))

        if ( one_chance_in(17) )

        if (one_chance_in(17))

    return result;

    return (result);

// XXX: name strings in most of the following are currently unused!

// XXX: Name strings in most of the following are currently unused!

    // monsters that don't differentiate between torso and general.

    // monster types (monsters don't differentiate between torso and general).

// if this changes then those items will have to have special code

// If this changes then those items will have to have special code

    // compare with enum comments, to catch changes

    // Compare with enum comments, to catch changes.

// (e.g., scrolls don't have know-cursedness.)

// (e.g., scrolls don't have know-cursedness).

    switch ( item.base_type )

    switch (item.base_type)

    if ( is_artefact(item) )
    {

    if (is_artefact(item))

    }

// Return the enchantment limit of a piece of armour

// Return the enchantment limit of a piece of armour.

// doesn't include animal skin (only skins we can make and enchant)

// Doesn't include animal skin (only skins we can make and enchant).

// used to distinguish shiny and embroidered

// Used to distinguish shiny and embroidered.

// returns number of sizes off

// Returns number of sizes off (0 if fitting).

// returns true if armour fits size (shape needs additional verification)

// Returns true if armour fits size (shape needs additional verification).

            // Cannot swim in heavy armour

            // Cannot swim in heavy armour.

// if known is true, only returns true for *known* weapons of electrocution

// If known is true, only returns true for *known* weapons of electrocution.

             && !is_random_artefact( it )
             && !is_fixed_artefact( it )
             && get_weapon_brand( it ) == SPWPN_ELECTROCUTION

             && !is_random_artefact(it)
             && !is_fixed_artefact(it)
             && get_weapon_brand(it) == SPWPN_ELECTROCUTION

    // artefacts cannot be enchanted (missiles can't be artefacts)

    // Artefacts cannot be enchanted (missiles can't be artefacts).

        && (is_fixed_artefact( wpn )
            || is_random_artefact( wpn )))

        && (is_fixed_artefact(wpn)
            || is_random_artefact(wpn)))

    if ( wpn.plus >= 9
         || wpn.base_type == OBJ_WEAPONS && wpn.plus2 >= 9 )

    if (wpn.plus >= 9
        || wpn.base_type == OBJ_WEAPONS && wpn.plus2 >= 9)

        return (uncurse && item_cursed( wpn )); // ?EW may uncurse items

        return (uncurse && item_cursed( wpn )); // ?EW may uncurse items.

    // only equipped items should be affected
//    if (!item_is_equipped(arm))
//        return (false);

    // artefacts cannot be enchanted
    if (is_fixed_artefact( arm )
        || is_random_artefact( arm ))

    // Artefacts cannot be enchanted.
    if (is_fixed_artefact(arm)
        || is_random_artefact(arm))

        return (uncurse && item_cursed( arm )); // ?EA may uncurse artefacts

        return (uncurse && item_cursed(arm)); // ?EA may uncurse artefacts.

    // Nor can highly enchanted items
    if ( arm.plus >= 2
         && (arm.sub_type >= ARM_CLOAK && arm.sub_type <= ARM_BOOTS
             || is_shield(arm)) )

    // Nor can highly enchanted items.
    if (arm.plus >= 2
        && (arm.sub_type >= ARM_CLOAK && arm.sub_type <= ARM_BOOTS
            || is_shield(arm)))

        return (uncurse && item_cursed( arm )); // ?EA may uncurse items

        return (uncurse && item_cursed(arm)); // ?EA may uncurse items.

        // zero value weapons must be placed specially -- see make_item() {dlb}

        // Zero value weapons must be placed specially -- see make_item() {dlb}

}                               // end rare_weapon()

}

}                               // end vorpal_type()

}

}                               // end damage_type()

}

}                               // end does_damage_type()

}

// give hands required to wield weapon for a torso of "size"

// Give hands required to wield weapon for a torso of "size".

        // size is the level where we can use one hand for one end

        // Size is the level where we can use one hand for one end.

            ret = HANDS_TWO; // HANDS_HALF once double-ended is implemented

            ret = HANDS_TWO; // HANDS_HALF once double-ended is implemented.

        // adjust handedness for size only for non-whip melee weapons

        // Adjust handedness for size only for non-whip melee weapons.

// returns melee skill of item

// Returns melee skill of item.

    // this is used to mark that only fighting applies.

    // This is used to mark that only fighting applies.

// front function for the above when we don't have a physical item to check

// Front function for the above when we don't have a physical item to check.

}                               // end weapon_skill()

}

// returns range skill of the item

// Returns range skill of the item.

// front function for the above when we don't have a physical item to check

// Front function for the above when we don't have a physical item to check.

}                               // end weapon_skill()

}

    // Note: ret currently measured in halves (see skill factor)

    // Note: ret currently measured in halves (see skill factor).

    // weapons of reaching are naturally a bit longer/flexier

    // Weapons of reaching are naturally a bit longer/flexier.

    // only consider additional modifications if we have a positive base:

    // Only consider additional modifications if we have a positive base:

        // make sure things can't get too insane

        // Make sure things can't get too insane.

    // Note: this is always a bonus

    // Note: this is always a bonus.

// returns number of sizes off

// Returns number of sizes off.

// Returns number of sizes away from being a usable weapon

// Returns number of sizes away from being a usable weapon.

    return ((fit < -2) ? fit + 2 : (fit > 1) ? fit - 1 : 0);

    return ((fit < -2) ? fit + 2 :
            (fit >  1) ? fit - 1 : 0);

    return ((ret >= 0) ? ret + 1 : (ret > -6) ? 0 : ret + 5);

    return ((ret >= 0) ? ret + 1 :
            (ret > -6) ? 0
                       : ret + 5);

// Returns true if weapon is usable as a tool
// Note that we assume that tool usable >= wieldable

// Returns true if weapon is usable as a tool.
// Note that we assume that tool usable >= wieldable.

// Returns true if weapon is usable as a weapon

// Returns true if weapon is usable as a weapon.

// Returns the you.inv[] index of our wielded weapon or -1 (no item, not wield)

// Returns the you.inv[] index of our wielded weapon or -1 (no item, not wield).

// decide if something is launched or thrown

// Decide if something is launched or thrown.

                         const item_def &missile)

                          const item_def &missile)

// returns true if item has an associated launcher

// Returns true if item has an associated launcher.

// returns true if item can be reasonably thrown without a launcher

// Returns true if item can be reasonably thrown without a launcher.

// returns food value for one turn of eating

// Returns food value for one turn of eating.

    // XXX: this needs to be better merged with the mutation system

    // XXX: This needs to be better merged with the mutation system.

    return (item.special < 100) && ((item.base_type == OBJ_CORPSES &&
                                     item.sub_type == CORPSE_BODY) ||
                                    (item.base_type == OBJ_FOOD &&
                                     item.sub_type == FOOD_CHUNK));

    return (item.special < 100) && (item.base_type == OBJ_CORPSES
                                       && item.sub_type == CORPSE_BODY
                                    || item.base_type == OBJ_FOOD
                                       && item.sub_type == FOOD_CHUNK);

// returns true if item counts as a tool for tool size comparisons and msgs

// Returns true if item counts as a tool for tool size comparisons and msgs.

            // truncate to the nearest 5 and reduce the item mass:

            // Truncate to the nearest 5 and reduce the item mass:

// Note that this function, an item sizes in general aren't quite on the

// Note that this function, and item sizes in general aren't quite on the

// returns true if we might be interested in dumping the colour

// Returns true if we might be interested in dumping the colour.

    if ( !teleport )

    if (!teleport)

    else

    else {

    }

        // lower accuracy if held in a net (needs testing)

        // Lower accuracy if held in a net (needs testing).

        // for all launched weapons, maximum effective specific skill

        // For all launched weapons, maximum effective specific skill

        exDamBonus = exDamBonus > 0? random2(exDamBonus + 1)
                                   : -random2(-exDamBonus + 1);
        exHitBonus = lnchHitBonus > 0? random2(lnchHitBonus + 1)
                                     : -random2(-lnchHitBonus + 1);

        exDamBonus = (exDamBonus > 0   ? random2(exDamBonus + 1)
                                       : -random2(-exDamBonus + 1));
        exHitBonus = (lnchHitBonus > 0 ? random2(lnchHitBonus + 1)
                                       : -random2(-lnchHitBonus + 1));

        // removed 2 random2(2)s from each of the learning curves, but

        // Removed 2 random2(2)s from each of the learning curves, but

            // strength is good if you're using a nice sling.

            // Strength is good if you're using a nice sling.

            // add skill for slings.. helps to find those vulnerable spots

            // Add skill for slings... helps to find those vulnerable spots.

            // now kill the launcher damage bonus

            // Now kill the launcher damage bonus.

            // blowguns take a _very_ steady hand;  a lot of the bonus
            // comes from dexterity.  (Dex bonus here as well as below)

            // Blowguns take a _very_ steady hand;  a lot of the bonus
            // comes from dexterity.  (Dex bonus here as well as below).

            // no extra damage for blowguns

            // No extra damage for blowguns.

            // now kill the launcher damage and ammo bonuses

            // Now kill the launcher damage and ammo bonuses.

            // strength is good if you're using a nice bow

            // Strength is good if you're using a nice bow.

            // cap; reduced this cap, because we don't want to allow

            // Cap; reduced this cap, because we don't want to allow

            // add in skill for bows.. help you to find those vulnerable spots.

            // Add in skill for bows - helps you to find those vulnerable spots.

            // now kill the launcher damage bonus

            // Now kill the launcher damage bonus.

        // Slings and Darts train Throwing a bit

        // Slings and Darts train Throwing a bit.

        // special cases for flame, frost, poison, etc.
        // check for venom brand (usually only available for blowguns)

        // Special cases for flame, frost, poison, etc.
        // check for venom brand.

            // poison brand the ammo

            // Poison brand the ammo.

        /* the chief advantage here is the extra damage this does
         * against susceptible creatures */

        // The chief advantage here is the extra damage this does
        // against susceptible creatures.

        /* Note: weapons & ammo of eg fire are not cumulative
         * ammo of fire and weapons of frost don't work together,
         * and vice versa */

        // Note: weapons & ammo of eg fire are not cumulative
        // ammo of fire and weapons of frost don't work together,
        // and vice versa.

            if ( !teleport
                 && !item_ident(you.inv[throw_2], ISFLAG_KNOW_PLUSES)
                 && random2(100) < shoot_skill )

            if (!teleport
                && !item_ident(you.inv[throw_2], ISFLAG_KNOW_PLUSES)
                && random2(100) < shoot_skill)

        // missiles only use inv_plus

        // Missiles only use inv_plus.

        // all weapons that use 'throwing' go here..

        // All weapons that use 'throwing' go here.

            // elves with elven weapons

            // Elves with elven weapons.

            // give an appropriate 'tohit' -
            // hand axes and clubs are -5
            // daggers are +1
            // spears are -1
            // rocks are 0

            // Give an appropriate 'tohit':
            // * hand axes and clubs are -5
            // * daggers are +1
            // * spears are -1
            // * rocks are 0

            // dwarves/orcs with dwarven/orcish weapons
            if ( (get_equip_race(item) == ISFLAG_DWARVEN
                  && player_genus(GENPC_DWARVEN)) ||
                 (get_equip_race(item) == ISFLAG_ORCISH
                  && you.species == SP_HILL_ORC))

            // Dwarves/orcs with dwarven/orcish weapons.
            if (get_equip_race(item) == ISFLAG_DWARVEN
                   && player_genus(GENPC_DWARVEN)
                || get_equip_race(item) == ISFLAG_ORCISH
                   && you.species == SP_HILL_ORC)

            // now, exDamBonus is a multiplier.  The full multiplier

            // Now, exDamBonus is a multiplier.  The full multiplier

                // Nets use throwing skill
                // They don't do any damage!

                // Nets use throwing skill.  They don't do any damage!

                // but accuracy is important for this one

                // ... but accuracy is important for this one.

                // Nets train throwing

                // Nets train throwing.

        if ( !teleport
             && !item_ident(you.inv[throw_2], ISFLAG_KNOW_PLUSES)
             && random2(100) < you.skills[SK_THROWING] )

        if (!teleport
            && !item_ident(you.inv[throw_2], ISFLAG_KNOW_PLUSES)
            && random2(100) < you.skills[SK_THROWING])

    // range, dexterity bonus, possible skill increase for silly throwing

    // Range, dexterity bonus, possible skill increase for silly throwing.

    // only add bonuses if we're throwing something sensible

    // Only add bonuses if we're throwing something sensible.

    // Add in bonus (only from Portal Projectile for now)

    // Add in bonus (only from Portal Projectile for now).

    // create message

    // Create message.

    // ensure we're firing a 'missile'-type beam

    // Ensure we're firing a 'missile'-type beam.

    // mark this item as thrown if it's a missile, so that we'll pick it up

    // Mark this item as thrown if it's a missile, so that we'll pick it up

    if ( did_return )

    if (did_return)

        // Fire beam in reverse

        // Fire beam in reverse.

        // Player saw the item return

        // Player saw the item return.

        // should have returned but didn't

        // Should have returned but didn't.

        {

        }

    // throwing and blowguns are silent

    // Throwing and blowguns are silent

    // but any monster nearby can see that something has been thrown:

    // ... but any monster nearby can see that something has been thrown:

    const zap_type type_zapped = static_cast<zap_type>(wand.zap());

    zap_type type_zapped = static_cast<zap_type>(wand.zap());
    bool random = false;

        random = true;

    // zapping() updates beam
    if (!zapping( static_cast<zap_type>(type_zapped),
                  30 + roll_dice(2, you.skills[SK_EVOCATIONS]), beam ))

    // Check whether we may hit friends, use "safe" values for random effects
    // (highest possible range, and unresistable beam flavour).
    if (!player_tracer(random ? ZAP_DEBUGGING_RAY : type_zapped,
                       2 * (you.skills[SK_EVOCATIONS] - 1), beam,
                       random ? 17 : 0))

    // zapping() updates beam
    zapping( type_zapped, 30 + roll_dice(2, you.skills[SK_EVOCATIONS]), beam );

            // non-controlleable

        if ( power_level == 2 )

        if (power_level == 2)

    if ( spell_direction( target, beam ) )

    if (spell_direction(target, beam) && player_tracer(ztype, power/4, beam))

bool zapping( zap_type ztype, int power, struct bolt &pbolt );

bool zapping( zap_type ztype, int power, struct bolt &pbolt,
              bool needs_tracer = false, std::string msg = "" );

bool player_tracer( zap_type ztype, int power, struct bolt &pbolt,
                    int range = 0 );

bool zapping(zap_type ztype, int power, bolt &pbolt)

static void _beam_set_default_values(bolt &beam, int power)
{
    beam.range          = 8 + random2(5);    // default for "0" beams (I think)
    beam.rangeMax       = 0;
    beam.hit            = 0;                 // default for "0" beams (I think)
    beam.damage         = dice_def( 1, 0 );  // default for "0" beams (I think)
    beam.type           = 0;                 // default for "0" beams
    beam.flavour        = BEAM_MAGIC;        // default for "0" beams
    beam.ench_power     = power;
    beam.obvious_effect = false;
    beam.is_beam        = false;             // default for all beams.
    beam.is_tracer      = false;             // default for all player beams
    beam.thrower        = KILL_YOU_MISSILE;  // missile from player
    beam.aux_source.clear();                 // additional source info, unused
}
// If needs_tracer is true, we need to check the beam path for friendly
// monsters for *player beams* only! If allies are found, the player is
// prompted to stop or continue.
bool zapping(zap_type ztype, int power, bolt &pbolt, bool needs_tracer,
             std::string msg)

    // all of the following might be changed by zappy():
    pbolt.range          = 8 + random2(5);    // default for "0" beams (I think)
    pbolt.rangeMax       = 0;
    pbolt.hit            = 0;                 // default for "0" beams (I think)
    pbolt.damage         = dice_def( 1, 0 );  // default for "0" beams (I think)
    pbolt.type           = 0;                 // default for "0" beams
    pbolt.flavour        = BEAM_MAGIC;        // default for "0" beams
    pbolt.ench_power     = power;
    pbolt.obvious_effect = false;
    pbolt.is_beam        = false;             // default for all beams.
    pbolt.is_tracer      = false;             // default for all player beams
    pbolt.thrower        = KILL_YOU_MISSILE;  // missile from player
    pbolt.aux_source.clear();                 // additional source info, unused

    // All of the following settings might be changed by _zappy().
    _beam_set_default_values(pbolt, power);
    // For player bolts, check whether tracer goes through friendlies.
    // NOTE: Whenever zapping() is called with a randomized value for power,
    // player_tracer should be called directly with the highest power possible
    // respecting current skill, experience level etc.
    if (needs_tracer && pbolt.thrower == KILL_YOU_MISSILE
        && !player_tracer(ztype, power, pbolt))
    {
        return (false);
    }

    if (pbolt.thrower == KILL_YOU_MISSILE)
    {
        pbolt.is_tracer = true;
        // XXX: rangeMax needs to be set appropriately for the tracer!
        pbolt.attitude  = ATT_FRIENDLY;
        pbolt.source_x  = you.x_pos;
        pbolt.source_y  = you.y_pos;
        fire_beam(pbolt);

    if (!msg.empty())
        mpr(msg.c_str());

        if (pbolt.fr_count > 0 && !yesno("Really fire through this friendly "
                                         "creature?", true, 'n'))
        {
            canned_msg(MSG_OK);
            you.turn_is_over = false;
            return (false);
        }
        pbolt.is_tracer = false;
    }

        mpr("You hear a mighty clap of thunder!");

        mpr("You hear a mighty clap of thunder!", MSGCH_SOUND);

// pbolt needs to be initialized for tracing: with the the maximum range,
// and the flavour to allow for completely resistant monsters.
static void _get_max_range( zap_type z_type, int power, bolt &pbolt )
{
    // sorted by range
    switch (z_type)
    {
    case ZAP_SMALL_SANDBLAST:
        pbolt.rangeMax       = 2;
        pbolt.flavour        = BEAM_FRAG;                     // extra AC resist
        break;
    case ZAP_SANDBLAST:
        if (power > 50)
            power = 50;
//      pbolt.range          = 2 + random2(power) / 20;
        pbolt.rangeMax       = 2 + (power-1) / 20; // max 4
        pbolt.flavour        = BEAM_FRAG;                     // extra AC resist
        break;
    case ZAP_FLAME_TONGUE:
        if (power > 25)
            power = 25;
//      pbolt.range          = 1 + random2(2) + random2(power) / 10;
        pbolt.rangeMax       = 2 + (power-1) / 10; // max 4
        pbolt.flavour        = BEAM_FIRE;
        break;
    case ZAP_CLEANSING_FLAME:
        pbolt.name           = "golden flame";
        pbolt.rangeMax       = 7;
        pbolt.flavour        = BEAM_HOLY;
        pbolt.is_explosion   = true;
        break;
    case ZAP_MAGMA:
        pbolt.rangeMax       = 8;
        pbolt.flavour        = BEAM_LAVA;
        pbolt.is_beam        = true;
        break;
    case ZAP_IRON_BOLT:
        pbolt.rangeMax       = 9;
        pbolt.flavour        = BEAM_MMISSILE;               // unresistable
        break;
    case ZAP_CRYSTAL_SPEAR:
        pbolt.rangeMax       = 9;
        pbolt.flavour        = BEAM_MMISSILE;                // unresistable
        break;
    case ZAP_SPIT_POISON:
        if (power > 50)
            power = 50;
//      pbolt.range          = 3 + random2( 1 + power / 2 );
        pbolt.rangeMax       = 3 + power / 2;
        if (pbolt.rangeMax > 9)
            pbolt.rangeMax = 9;
        pbolt.flavour        = BEAM_POISON;
        break;
    case ZAP_BREATHE_FIRE:
        if (power > 50)
            power = 50;
//      pbolt.range          = 3 + random2( 1 + power / 2 );
        pbolt.rangeMax       = 3 + power / 2;
        if (pbolt.rangeMax > 9)
            pbolt.rangeMax = 9;
        pbolt.flavour        = BEAM_FIRE;
        pbolt.is_beam        = true;
        break;
    case ZAP_BREATHE_FROST:
        if (power > 50)
            power = 50;
//      pbolt.range          = 3 + random2( 1 + power / 2 );
        pbolt.rangeMax       = 3 + power / 2;
        if (pbolt.rangeMax > 9)
            pbolt.rangeMax = 9;
        pbolt.flavour        = BEAM_COLD;
        pbolt.is_beam        = true;
        break;
    case ZAP_BREATHE_ACID:
        if (power > 50)
            power = 50;
//      pbolt.range          = 3 + random2( 1 + power / 2 );
        pbolt.rangeMax       = 3 + power / 2;
        if (pbolt.rangeMax > 9)
            pbolt.rangeMax = 9;
        pbolt.flavour        = BEAM_ACID;
        pbolt.is_beam        = true;
        break;
    case ZAP_BREATHE_POISON:    // leaves clouds of gas
        if (power > 50)
            power = 50;
//      pbolt.range          = 3 + random2( 1 + power / 2 );
        pbolt.rangeMax       = 3 + power / 2;
        if (pbolt.rangeMax > 9)
            pbolt.rangeMax = 9;
        pbolt.flavour        = BEAM_POISON;
        pbolt.is_beam        = true;
        break;
    case ZAP_BREATHE_POWER:
        if (power > 50)
            power = 50;
//      pbolt.range          = 6 + random2( 1 + power / 2 );
        pbolt.rangeMax       = 6 + power / 2;
        if (pbolt.rangeMax > 9)
            pbolt.rangeMax = 9;
        pbolt.flavour        = BEAM_MMISSILE;                  // unresistable
        pbolt.is_beam        = true;
        break;
    case ZAP_BREATHE_STEAM:
        pbolt.rangeMax       = 9;
        pbolt.flavour        = BEAM_STEAM;
        pbolt.is_beam        = true;
        break;
    case ZAP_STRIKING:
    case ZAP_MAGIC_DARTS:
    case ZAP_STONE_ARROW:
    case ZAP_MYSTIC_BLAST:
        pbolt.rangeMax       = 12;
        pbolt.flavour        = BEAM_MMISSILE;               // unresistable
        break;

    case ZAP_STING:
    case ZAP_POISON_ARROW:
        pbolt.rangeMax       = 12;
        pbolt.flavour        = BEAM_POISON;
        break;
    case ZAP_FLAME:
    case ZAP_STICKY_FLAME:
        pbolt.rangeMax       = 12;
        pbolt.flavour        = BEAM_FIRE;
        break;
    case ZAP_FROST:
        pbolt.rangeMax       = 12;
        pbolt.flavour        = BEAM_COLD;
        break;
    case ZAP_ICE_BOLT:
        pbolt.rangeMax       = 12;
        pbolt.flavour        = BEAM_ICE;                     // half resistable
        break;
    case ZAP_ELECTRICITY:
        pbolt.rangeMax       = 13;
        pbolt.flavour        = BEAM_ELECTRICITY;           // beams & reflects
        pbolt.is_beam        = true;
        break;
    case ZAP_DISRUPTION:
    case ZAP_DISINTEGRATION:
        pbolt.name           = "0";
        pbolt.rangeMax       = 14;
        pbolt.flavour        = BEAM_DISINTEGRATION;
        break;
    case ZAP_PAIN:
        pbolt.name           = "0";
        pbolt.rangeMax       = 14;
        pbolt.flavour        = BEAM_PAIN;
        break;
    case ZAP_DISPEL_UNDEAD:
        pbolt.name           = "0";
        pbolt.rangeMax       = 14;
        pbolt.flavour        = BEAM_DISPEL_UNDEAD;
        break;
    case ZAP_FIRE:
        pbolt.rangeMax       = 16;
        pbolt.flavour        = BEAM_FIRE;
        pbolt.is_beam        = true;
        break;
    case ZAP_BONE_SHARDS:
        pbolt.rangeMax       = 16;
        pbolt.flavour        = BEAM_MAGIC;                      // unresisted
        pbolt.is_beam        = true;
        break;
    case ZAP_COLD:
        pbolt.rangeMax       = 16;
        pbolt.flavour        = BEAM_COLD;
        pbolt.is_beam        = true;
        break;
    case ZAP_NEGATIVE_ENERGY:
        pbolt.rangeMax       = 16;
        pbolt.flavour        = BEAM_NEG;                     // drains levels
        pbolt.is_beam        = true;
        break;
    case ZAP_BEAM_OF_ENERGY:    // bolt of innacuracy
        pbolt.range          = 16;
        pbolt.flavour        = BEAM_ENERGY;                    // unresisted
        pbolt.is_beam        = true;
        break;
    case ZAP_VENOM_BOLT:
        pbolt.rangeMax       = 17;
        pbolt.flavour        = BEAM_POISON;
        pbolt.is_beam        = true;
        break;
    case ZAP_LIGHTNING:
        pbolt.rangeMax       = 17;
        pbolt.flavour        = BEAM_ELECTRICITY;           // beams & reflects
        pbolt.is_beam        = true;
        break;
    // enchantments
    case ZAP_ENSLAVEMENT:
        pbolt.name           = "0";
        pbolt.rangeMax       = 11;
        pbolt.flavour        = BEAM_CHARM;
        break;
    case ZAP_BANISHMENT:
        pbolt.name           = "0";
        pbolt.rangeMax       = 11;
        pbolt.flavour        = BEAM_BANISH;
        break;
    case ZAP_DEGENERATION:
        pbolt.name           = "0";
        pbolt.rangeMax       = 11;
        pbolt.flavour        = BEAM_DEGENERATE;
        break;
    case ZAP_ENSLAVE_UNDEAD:
        pbolt.name           = "0";
        pbolt.rangeMax       = 11;
        pbolt.flavour        = BEAM_ENSLAVE_UNDEAD;
        break;
    case ZAP_CONTROL_DEMON:
        pbolt.name           = "0";
        pbolt.rangeMax       = 11;
        pbolt.flavour        = BEAM_ENSLAVE_DEMON;
        break;
    case ZAP_SLEEP:
        pbolt.name           = "0";
        pbolt.rangeMax       = 11;
        pbolt.flavour        = BEAM_SLEEP;
        break;
    case ZAP_BACKLIGHT:
        pbolt.name           = "0";
        pbolt.rangeMax       = 11;
        pbolt.flavour        = BEAM_BACKLIGHT;
        break;
    case ZAP_SLOWING:
        pbolt.name           = "0";
        pbolt.rangeMax       = 12;
        pbolt.flavour        = BEAM_SLOW;
        break;
    case ZAP_HASTING:
        pbolt.name           = "0";
        pbolt.rangeMax       = 12;
        pbolt.flavour        = BEAM_HASTE;
        break;
    case ZAP_PARALYSIS:
        pbolt.name           = "0";
        pbolt.rangeMax       = 12;
        pbolt.flavour        = BEAM_PARALYSIS;
        break;
    case ZAP_CONFUSION:
        pbolt.name           = "0";
        pbolt.rangeMax       = 12;
        pbolt.flavour        = BEAM_CONFUSION;
        break;
    case ZAP_INVISIBILITY:
        pbolt.name           = "0";
        pbolt.rangeMax       = 12;
        pbolt.flavour        = BEAM_INVISIBILITY;
        break;
    case ZAP_HEALING:
        pbolt.name           = "0";
        pbolt.rangeMax       = 12;
        pbolt.flavour        = BEAM_HEALING;
        break;
    case ZAP_TELEPORTATION:
        pbolt.name           = "0";
        pbolt.rangeMax       = 13;
        pbolt.flavour        = BEAM_TELEPORT;
        break;
    case ZAP_POLYMORPH_OTHER:
        pbolt.name           = "0";
        pbolt.rangeMax       = 13;
        pbolt.flavour        = BEAM_POLYMORPH;
        break;
    case ZAP_AGONY:
        pbolt.name           = "0agony";
        pbolt.rangeMax       = 14;
        pbolt.flavour        = BEAM_PAIN;
        break;
    case ZAP_DIGGING:
        pbolt.name           = "0";
//        pbolt.range          = 3 + random2( power / 5 ) + random2(5);
        pbolt.rangeMax       = 6 + power / 5;
        pbolt.flavour        = BEAM_DIGGING;
        pbolt.is_beam        = true;
        break;
    // explosions
    case ZAP_FIREBALL:
        pbolt.name           = "fireball";
        pbolt.rangeMax       = 12;
        pbolt.flavour        = BEAM_FIRE;                      // fire
        pbolt.is_explosion   = true;
        break;
    case ZAP_ICE_STORM:
        pbolt.name           = "great blast of cold";
        pbolt.rangeMax       = 13;
        pbolt.ench_power     = power;              // used for radius
        pbolt.flavour        = BEAM_ICE;           // half resisted
        pbolt.is_explosion   = true;
        break;
    case ZAP_ORB_OF_FRAGMENTATION:                      // cap 150
        pbolt.name           = "metal orb";
        pbolt.rangeMax       = 16;
        pbolt.flavour        = BEAM_FRAG;                     // extra AC resist
        pbolt.is_explosion   = true;
        break;
    case ZAP_HELLFIRE:
        pbolt.rangeMax       = 16;
        pbolt.flavour        = BEAM_HELLFIRE;
        pbolt.is_explosion   = true;
        break;
    case ZAP_ORB_OF_ELECTRICITY:                        // cap 150
        pbolt.name           = "orb of electricity";
        pbolt.rangeMax       = 20;
        pbolt.flavour        = BEAM_ELECTRICITY;
        pbolt.is_explosion   = true;
        break;
    case ZAP_DEBUGGING_RAY:
    default: // buggy beam
        pbolt.rangeMax       = 16;
        pbolt.flavour        = BEAM_MMISSILE;                  // unresistable
        break;
    }
}
// FIXME: Also needs to check for fleeing monster with TSO and neutrals for
//        all good gods.
bool player_tracer( zap_type ztype, int power, bolt &pbolt, int range)
{
    _beam_set_default_values(pbolt, power);
    pbolt.name = "unimportant";
    _get_max_range(ztype, power, pbolt);
    // override range if necessary
    if (range > 0)
        pbolt.rangeMax = range;
    pbolt.is_tracer     = true;
    pbolt.source_x      = you.x_pos;
    pbolt.source_y      = you.y_pos;
    pbolt.beam_source   = 0;
    pbolt.can_see_invis = player_see_invis();
    pbolt.smart_monster = true;
    pbolt.attitude      = ATT_FRIENDLY;
    // init tracer variables
    pbolt.foe_count     = pbolt.fr_count = 0;
    pbolt.foe_power     = pbolt.fr_power = 0;
    pbolt.fr_helped     = pbolt.fr_hurt  = 0;
    pbolt.foe_helped    = pbolt.foe_hurt = 0;
    pbolt.foe_ratio     = 100;
    fire_beam(pbolt);
    // Should only happen if the player answered 'n' to one of those
    // "Fire through friendly?" prompts.
    if (pbolt.fr_count > 0)
    {
        canned_msg(MSG_OK);
        you.turn_is_over = false;
        return (false);
    }
    // Set to non-tracing for actual firing.
    pbolt.is_tracer = false;
    return (true);
}

// *do not* call this function directly (duh - it's static), need to
// see zapping() for default values not set within this function {dlb}

// Need to see zapping() for default values not set within this function {dlb}

    // give chance for beam to affect one cell even if aimed_at_feet.

    // Give chance for beam to affect one cell even if aimed_at_feet.

            // first, check to see if this beam affects walls.

            // First, check to see if this beam affects walls.

                // should we ever get a tracer with a wall-affecting

                // Should we ever get a tracer with a wall-affecting

                // if it's still a wall, quit.

                // If it's still a wall, quit.

        // at this point, if grd[tx][ty] is still a wall, we

        // At this point, if grd[tx][ty] is still a wall, we

        // check for "target termination"

        // Check for "target termination"

        // between two monsters)

        // between two monsters).

        // in this case, don't affect the cell - players and

        // In this case, don't affect the cell - players and

        // affect the cell, except in the special case noted

        // Affect the cell, except in the special case noted

                pbolt.flavour =
                    static_cast<beam_type>(
                        random_range(BEAM_FIRE, BEAM_ACID) );

                pbolt.flavour = static_cast<beam_type>(
                                    random_range(BEAM_FIRE, BEAM_ACID));

        // always decrease range by 1

        // Always decrease range by 1.

        // check for range termination

        // Check for range termination.

        // special case - beam was aimed at feet

        // Special case - beam was aimed at feet.

        // actually draw the beam/missile/whatever,

        // Actually draw the beam/missile/whatever,

            // we don't clean up the old position.

            // We don't clean up the old position.

            if (tile_beam != -1 && in_los_bounds(drawx, drawy) &&
                (tx != you.x_pos || ty != you.y_pos))

            if (tile_beam != -1 && in_los_bounds(drawx, drawy)
                && (tx != you.x_pos || ty != you.y_pos))

    // check for explosion.  NOTE that for tracers, we have to make a copy

    // Check for explosion.  NOTE that for tracers, we have to make a copy

    // canned msg for enchantments that affected no-one, but only if the

    // Canned msg for enchantments that affected no-one, but only if the

// returns damage taken by a monster from a "flavoured" (fire, ice, etc.)

// Returns damage taken by a monster from a "flavoured" (fire, ice, etc.)

            // put in an exception for things you won't notice becoming confused.

            // Put in an exception for things you won't notice becoming
            // confused.

            // put in an exception for fungi, plants and other things you won't
            // notice becoming charmed.

            // Put in an exception for fungi, plants and other things
            // you won't notice becoming charmed.

        beam.foe_count++;

        if (beam.thrower != KILL_YOU_MISSILE)
            beam.foe_count++;

    // generic - all explosion-type beams can be targeted at empty space,

    // Generic - all explosion-type beams can be targeted at empty space,

    // conditions: beam is missile and not tracer.

    // Conditions: beam is missile and not tracer.

            // player or monster on position is caught in net

            // Player or monster on position is caught in net.

                // if no trapping net found mark this one

                // If no trapping net found mark this one.

    // extra range used by hitting something

    // Extra range used by hitting something.

    // line of sight never affects anything

    // Line of sight never affects anything.

// return amount of extra range used up by affectation of this wall.

// Returns amount of extra range used up by affectation of this wall.

            // blood does not transfer onto floor

            // Blood does not transfer onto floor.

            // blood does not transfer onto floor

            // Blood does not transfer onto floor.

// return amount of extra range used up by affectation of the player

// Returns amount of extra range used up by affectation of the player.

        // check can see player
        if (beam.can_see_invis || !you.invisible() || _fuzz_invis_tracer(beam))

        // Check whether thrower can see player, unless thrower == player.
        if (beam.thrower != KILL_YOU_MISSILE
            && (beam.can_see_invis || !you.invisible()
                || _fuzz_invis_tracer(beam)))

                beam.foe_count++;
                beam.foe_power += you.experience_level;

                if (beam.thrower != KILL_YOU_MISSILE)
                {
                    beam.foe_count++;
                    beam.foe_power += you.experience_level;
                }

    // use beamHit, NOT beam.hit, for modification of tohit.. geez!

    // Use beamHit, NOT beam.hit, for modification of tohit.. geez!

                // beams can be dodged

                // Beams can be dodged.

                    // some training just for the "attempt"

                    // Some training just for the "attempt".

                    // Beam from player rebounded and hit player

                    // Beam from player rebounded and hit player.

                    // Beam from an ally or neutral

                    // Beam from an ally or neutral.

        // regardless of affect, we need to know if this is a stopper

        // Regardless of affect, we need to know if this is a stopper

    // Roll the damage

    // Roll the damage.

    // if the beam is an actual missile or of the MMISSILE type (Earth magic)
    // might bleed on the floor

    // If the beam is an actual missile or of the MMISSILE type (Earth magic)
    // might bleed on the floor.

    if (mons_atts_aligned(beam.attitude, mons_attitude(mon)))

    if (!mons_atts_aligned(beam.attitude, mons_attitude(mon)))

            // Harmful beam from this monster rebounded and hit the monster

            // Harmful beam from this monster rebounded and hit the monster.

            // can't see this monster, ignore it

            // Can't see this monster, ignore it.

            // enchant case -- enchantments always hit, so update target immed.
            if (mons_atts_aligned(beam.attitude, mons_attitude(mon)))

            // Enchant case -- enchantments always hit, so update target immed.
            if (!mons_atts_aligned(beam.attitude, mons_attitude(mon)))

                beam.foe_count += 1;
                beam.foe_power += mons_power(mons_type);

                if (beam.thrower != KILL_YOU_MISSILE)
                {
                    beam.foe_count += 1;
                    beam.foe_power += mons_power(mons_type);
                }

                beam.fr_count += 1;
                beam.fr_power += mons_power(mons_type);

                bool count_friend = true;
                if (beam.thrower == KILL_YOU_MISSILE)
                {
                    snprintf(info, INFO_SIZE, "Really fire through %s?",
                             mon->name(DESC_NOCAP_THE).c_str());
                    if (!yesno(info))
                    {
                        beam.fr_count = 1;
                        return (BEAM_STOP);
                    }
                    else
                        count_friend = false;
                }
                if (count_friend)
                {
                    beam.fr_count += 1;
                    beam.fr_power += mons_power(mons_type);
                }

        // nasty enchantments will annoy the monster, and are considered
        // naughty (even if a monster might resist)

        // Nasty enchantments will annoy the monster, and are considered
        // naughty (even if a monster might resist).

    // we need to know how much the monster _would_ be hurt by this, before

    // We need to know how much the monster _would_ be hurt by this, before

    // check monster resists, _without_ side effects (since the

    // Check monster resists, _without_ side effects (since the

        if (hurt_final > 0)

        // Check only if actual damage, but always count friends for player.
        if (hurt_final > 0 || beam.thrower == KILL_YOU_MISSILE)

            // monster could be hurt somewhat, but only apply the

            // Monster could be hurt somewhat, but only apply the

            if (mons_atts_aligned(beam.attitude, mons_attitude(mon)))

            if (!mons_atts_aligned(beam.attitude, mons_attitude(mon)))

                beam.foe_count += 1;
                beam.foe_power += 2 * hurt_final * mons_power(mons_type) / hurt;

                if (beam.thrower != KILL_YOU_MISSILE)
                {
                    // Counting foes is only important for monster tracers.
                    beam.foe_count += 1;
                    beam.foe_power += 2 * hurt_final * mons_power(mons_type)
                                                        / hurt;
                }

                beam.fr_count += 1;
                beam.fr_power += 2 * hurt_final * mons_power(mons_type) / hurt;

                bool count_friend = true;
                if (beam.thrower == KILL_YOU_MISSILE)
                {
                    snprintf(info, INFO_SIZE, "Really fire through %s?",
                             mon->name(DESC_NOCAP_THE).c_str());
                    if (!yesno(info))
                    {
                        beam.fr_count = 1;
                        return (BEAM_STOP);
                    }
                    else
                    {
                        // Don't count friends we don't want counted.
                        count_friend = false;
                    }
                }
                if (count_friend)
                {
                    beam.fr_count += 1;
                    beam.fr_power += 2 * hurt_final * mons_power(mons_type)
                                                       / hurt;
                }

        // either way, we could hit this monster, so return range used

        // Either way, we could hit this monster, so return range used.

    // player beams which hit friendlies or good neutrals will annoy

    // Player beams which hit friendlies or good neutrals will annoy

        // if the PLAYER cannot see the monster, don't tell them anything!

        // If the PLAYER cannot see the monster, don't tell them anything!

    // note that hurt_final was calculated above, so we don't need it again.

    // Note that hurt_final was calculated above, so we don't need it again.

    // doFlavouredEffects = false above)

    // doFlavouredEffects = false above).

    // if the beam is an actual missile or of the MMISSILE type (Earth magic)
    // might bleed on the floor

    // If the beam is an actual missile or of the MMISSILE type (Earth magic)
    // might bleed on the floor.

    // non-beams can only affect one thing (player/monster)

    // Non-beams can only affect one thing (player/monster).

    // hellfire stops for nobody!

    // Hellfire stops for nobody!

    // lava doesn't go far, but it goes through most stuff

    // Lava doesn't go far, but it goes through most stuff.

    // If it isn't lightning, reduce range by a lot

    // If it isn't lightning, reduce range by a lot.

        pbolt.flavour = BEAM_FRAG;     // sets it from pure damage to shrapnel (which is absorbed extra by armour)

        pbolt.flavour = BEAM_FRAG;     // Sets it from pure damage to shrapnel
                                       // (which is absorbed extra by armour).

        if (see_grid(x,y) || (x == you.x_pos && y == you.y_pos))

        if (see_grid(x,y) || x == you.x_pos && y == you.y_pos)

            if (!(silenced(x,y) || silenced(you.x_pos, you.y_pos)))

            if (silenced(x,y) || silenced(you.x_pos, you.y_pos))
                pbolt.msg_generated = false;
            else