(testbits( flags, SPFLAG_TARGET ) ? DIR_TARGET :
             testbits( flags, SPFLAG_GRID )   ? DIR_TARGET :
             testbits( flags, SPFLAG_DIR )    ? DIR_DIR    : DIR_NONE);

            (testbits( flags, SPFLAG_TARGET )        ? DIR_TARGET :
             testbits( flags, SPFLAG_GRID )          ? DIR_TARGET :
             testbits( flags, SPFLAG_DIR )           ? DIR_DIR
                                                     : DIR_NONE);

        stinking_cloud(powc, beam);

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

    struct dist spelld;

    beem.name = "potion";
    beem.colour = you.inv[potion].colour;
    beem.range = 9;
    beem.rangeMax = 9;
    beem.type = dchar_glyph(DCHAR_FIRED_FLASK);

    beem.name        = "potion";
    beem.colour      = you.inv[potion].colour;
    beem.range       = 9;
    beem.rangeMax    = 9;
    beem.type        = dchar_glyph(DCHAR_FIRED_FLASK);

    beem.thrower = KILL_YOU_MISSILE;

    beem.thrower     = KILL_YOU_MISSILE;
    beem.is_beam     = false;

    beem.is_beam = false;
    beem.is_tracer = false;

    beem.hit = you.dex / 2 + roll_dice( 2, you.skills[SK_THROWING] / 2 + 1 );
    beem.damage = dice_def( 1, 0 );  // no damage, just producing clouds
    beem.ench_power = pow;           // used for duration only?

    beem.hit        = you.dex / 2 + roll_dice( 2, you.skills[SK_THROWING] / 2 + 1 );
    beem.damage     = dice_def( 1, 0 );  // no damage, just producing clouds
    beem.ench_power = pow;               // used for duration only?

    beem.flavour = BEAM_POTION_STINKING_CLOUD;

    beem.flavour    = BEAM_POTION_STINKING_CLOUD;

        beem.effect_known = false;

        beem.effect_known = false;

        beem.effect_known = false;

        case 0:   beem.flavour = BEAM_POTION_FIRE;            break;
        case 1:   beem.flavour = BEAM_POTION_COLD;            break;
        case 2:   beem.flavour = BEAM_POTION_POISON;          break;
        case 3:   beem.flavour = BEAM_POTION_MIASMA;          break;
        default:  beem.flavour = BEAM_POTION_RANDOM;          break;

        case 0:   beem.flavour = BEAM_POTION_FIRE;   break;
        case 1:   beem.flavour = BEAM_POTION_COLD;   break;
        case 2:   beem.flavour = BEAM_POTION_POISON; break;
        case 3:   beem.flavour = BEAM_POTION_MIASMA; break;
        default:  beem.flavour = BEAM_POTION_RANDOM; break;

        beem.effect_known = false;

    }
    // Fire tracer.
    beem.source_x      = you.x_pos;
    beem.source_y      = you.y_pos;
    beem.can_see_invis = player_see_invis();
    beem.smart_monster = true;
    beem.attitude      = ATT_FRIENDLY;
    beem.fr_count      = 0;
    beem.is_tracer     = true;
    fire_beam(beem);
    if (beem.fr_count > 0)
    {
        // We don't want to fire through friendlies.
        canned_msg(MSG_OK);
        return (false);

    // Really fire.
    beem.is_tracer = false;

    // both old and new code use up a potion:

    // Use up a potion.

    const bool rotten = food_is_rotten(mitm[corpse]);

    const bool rotten      = food_is_rotten(mitm[corpse]);

    const bool power_up = (rotten && big_monster);

    const bool power_up    = (rotten && big_monster);

       }

        }

int stinking_cloud(int pow, bolt &beam);

bool stinking_cloud(int pow, bolt &beam);

int stinking_cloud( int pow, bolt &beem )

bool stinking_cloud( int pow, bolt &beem )

    beem.name = "ball of vapour";
    beem.colour = GREEN;
    beem.range = 6;
    beem.rangeMax = 6;
    beem.damage = dice_def( 1, 0 );
    beem.hit = 20;
    beem.type = dchar_glyph(DCHAR_FIRED_ZAP);
    beem.flavour = BEAM_MMISSILE;
    beem.ench_power = pow;

    beem.name        = "ball of vapour";
    beem.colour      = GREEN;
    beem.range       = 6;
    beem.rangeMax    = 6;
    beem.damage      = dice_def( 1, 0 );
    beem.hit         = 20;
    beem.type        = dchar_glyph(DCHAR_FIRED_ZAP);
    beem.flavour     = BEAM_MMISSILE;
    beem.ench_power  = pow;

    beem.thrower = KILL_YOU;

    beem.thrower     = KILL_YOU;
    beem.is_beam     = false;

    beem.is_beam = false;
    beem.is_tracer = false;

    // Fire tracer.
    beem.source_x      = you.x_pos;
    beem.source_y      = you.y_pos;
    beem.can_see_invis = player_see_invis();
    beem.smart_monster = true;
    beem.attitude      = ATT_FRIENDLY;
    beem.fr_count      = 0;
    beem.is_tracer     = true;

    return (1);
}                               // end stinking_cloud()

    if (beem.fr_count > 0)
    {
        // We don't want to fire through friendlies.
        canned_msg(MSG_OK);
        return (false);
    }
    // Really fire.
    beem.is_tracer = false;
    fire_beam(beem);
    return (true);
}

    // needs to be done this way because of friendly/neutral enchantments

    // Needs to be done this way because of friendly/neutral enchantments.

    if (you.confused())
        return (false);

        // listed in the form: "your rat", "Blork the orc"

        // Listed in the form: "your rat", "Blork the orc".

    if (!you.confused() && prompt)

    if (prompt)

bool is_bad_item(const item_def &item);
bool is_dangerous_item( const item_def& item );

bool is_bad_item(const item_def &item, bool temp = false);
bool is_dangerous_item( const item_def& item, bool temp = false);

    if (is_useless_item(item) || is_dangerous_item(item))
        return (false);

bool is_bad_item(const item_def &item)

bool is_bad_item(const item_def &item, bool temp)

        case SCR_SUMMONING:
            // Summoning will always produce hostile monsters if you worship
            // a good god. (Use temp to allow autopickup to prevent monsters
            // from reading it.)
            return (temp && is_good_god(you.religion));

        // Well, strictly poison is not that bad if you're poison resistant...

            return (true);

            return (true);

            // Poison is not that bad if you're poison resistant.
            return (!player_res_poison()
                    || !temp && you.species == SP_VAMPIRE);

                    && (you.species != SP_VAMPIRE

                    && (temp || you.species != SP_VAMPIRE

bool is_dangerous_item(const item_def &item)

bool is_dangerous_item(const item_def &item, bool temp)

            return (true);

            return (true);

            return (!player_mutation_level(MUT_TORMENT_RESISTANCE)
                    || !temp && you.species == SP_VAMPIRE);

                    || you.species == SP_VAMPIRE

                    || temp && you.species == SP_VAMPIRE

    case OBJ_BOOKS:
        // The Tome of Destruction is certainly risky.
        return (item.sub_type == BOOK_DESTRUCTION);

        if (is_bad_item(item))

        if (is_bad_item(item, temp))

        case SCR_TORMENT:
            return (player_mutation_level(MUT_TORMENT_RESISTANCE)
                    || !temp && you.species == SP_VAMPIRE);

        switch (item.sub_type)
        {
        case POT_CONFUSION:
        case POT_SLOWING:
        case POT_DEGENERATION:
        case POT_DECAY:
        case POT_PARALYSIS:
        case POT_POISON:
        case POT_STRONG_POISON:
        case POT_MUTATION:
            // Certainly not useless if it can be used for attacking.
            return (!player_knows_spell(SPELL_EVAPORATE));
        }

        // No potion is useless if it can be used for Evaporate.
        if (player_knows_spell(SPELL_EVAPORATE))
            return (false);
        // Apart from Evaporate, mummies can't use potions.

        // Do a second switch for the other potions.

                       && you.hunger_state >= HS_SATIATED);

                            && you.hunger_state < HS_SATIATED);

        case POT_POISON:
        case POT_STRONG_POISON:
            // If you're poison resistant, poison is only useless.
            return player_res_poison();

        if (is_bad_item(item))

        if (is_bad_item(item, temp))

        if (you.species == SP_MUMMY || you.species == SP_GHOUL)

        switch (item.sub_type)

            switch (item.sub_type)
            {
            case AMU_RAGE:
            case RING_REGENERATION:
            case RING_SUSTENANCE:
            case RING_HUNGER:
            case RING_LIFE_PROTECTION:
                return (true);
            }
        }

        case AMU_RAGE:
            return (you.is_undead
                        && (!temp || you.species == SP_VAMPIRE
                                     && you.hunger_state <= HS_SATIATED)
                    || you.religion == GOD_TROG);

        if (item.sub_type == RING_SEE_INVISIBLE)

        case RING_LIFE_PROTECTION:
        case RING_HUNGER:
        case RING_REGENERATION:
        case RING_SUSTENANCE:
            return (you.is_undead
                    && (!temp || you.species == SP_VAMPIRE
                                 && you.hunger_state == HS_STARVING));
        case RING_SEE_INVISIBLE:

        if (item.sub_type == RING_POISON_RESISTANCE)
        {
            return (you.species != SP_VAMPIRE
                    && player_mutation_level(MUT_POISON_RESISTANCE));
        }

        case RING_POISON_RESISTANCE:
            return (player_res_poison()
                    && (temp || you.species != SP_VAMPIRE));

        if (item.sub_type == AMU_CONTROLLED_FLIGHT)

        case AMU_CONTROLLED_FLIGHT:

        if (you.religion == GOD_TROG)
        {
            return (item.sub_type == RING_WIZARDRY
                    || item.sub_type == AMU_RAGE);

        case RING_WIZARDRY:
            return (you.religion == GOD_TROG);
        default:
            return (false);

        return (false);

    if (is_dangerous_item(item))

    if (is_dangerous_item(item, temp))

    if (is_bad_item(item))

    if (is_bad_item(item, temp))

// special front function for zap_animation to interpret enchantment flavours

// Special front function for zap_animation to interpret enchantment flavours.

 *  if item is NULL, there is no physical object being thrown that could

 *  If item is NULL, there is no physical object being thrown that could

        {

        }

            {

            }

            // early out for tracer/no side effects

            // Early out for tracer/no side effects.

            simple_monster_message(monster, mons_immune_magic(monster) ?
                                   " is unaffected." : " resists.");

            simple_monster_message(monster,
                                   mons_immune_magic(monster)? " is unaffected."
                                                             : " resists.");

            simple_monster_message(monster, mons_immune_magic(monster) ?
                                   " is unaffected." : " resists.");

            simple_monster_message(monster,
                                   mons_immune_magic(monster)? " is unaffected."
                                                             : " resists.");

    switch (pbolt.flavour)      /* put in magic resistance */

    switch (pbolt.flavour)      // put in magic resistance

    case BEAM_SLOW:         /* 0 = slow monster */

    case BEAM_SLOW:

    case BEAM_HASTE:                  // 1 = haste

    case BEAM_HASTE:

        // not slowed, haste it

        // Not slowed, haste it.

    case BEAM_HEALING:         /* 2 = healing */

    case BEAM_HEALING:

    case BEAM_PARALYSIS:                  /* 3 = paralysis */

    case BEAM_PARALYSIS:

    case BEAM_CONFUSION:                   /* 4 = confusion */

    case BEAM_CONFUSION:

    case BEAM_INVISIBILITY:               /* 5 = invisibility */

    case BEAM_INVISIBILITY:

    case BEAM_CHARM:             /* 9 = charm */

    case BEAM_CHARM:

    }                           /* end of switch (beam_colour) */

    }

/*
 * Used by monsters in "planning" which spell to cast. Fires off a "tracer"
 * which tells the monster what it'll hit if it breathes/casts etc.
 *
 * The output from this tracer function is four variables in the beam struct:
 * fr_count, foe_count: a count of how many friends and foes will (probably)
 * be hit by this beam
 * fr_power, foe_power: a measure of how many 'friendly' hit dice it will
 * affect, and how many 'unfriendly' hit dice.
 *
 * Note that beam properties must be set, as the tracer will take them
 * into account, as well as the monster's intelligence.
 *
 */

//
//  Used by monsters in "planning" which spell to cast. Fires off a "tracer"
//  which tells the monster what it'll hit if it breathes/casts etc.
//
//  The output from this tracer function is four variables in the beam struct:
//  fr_count, foe_count: a count of how many friends and foes will (probably)
//  be hit by this beam
//  fr_power, foe_power: a measure of how many 'friendly' hit dice it will
//  affect, and how many 'unfriendly' hit dice.
//
//  Note that beam properties must be set, as the tracer will take them
//  into account, as well as the monster's intelligence.
//

        if (beam.is_tracer)          // tracers always stop on walls.

        if (beam.is_tracer)          // Tracers always stop on walls.

        // if it's still a wall, quit - we can't do anything else to a

        // If it's still a wall, quit - we can't do anything else to a

    // first check: FIRE/COLD over water/lava

    // First check: FIRE/COLD over water/lava.

    // sticky flame

    // Sticky flame.

    // simple cases for scroll burns

    // Simple cases for scroll burns.

    // more complex (geez..)

    // More complex (geez..)

    // potions exploding

    // Potions exploding.

    // spore pops

    // Spore pops.

// return amount of range used up by affectation of this monster

// Returns amount of range used up by affectation of this monster.

            if (beam.thrower == KILL_YOU_MISSILE)

            if (beam.thrower == KILL_YOU_MISSILE || beam.thrower == KILL_YOU)

                if (!_beam_is_harmless(beam, mon))

                if (!beam.fr_count && !_beam_is_harmless(beam, mon))

                        mpr("Test2");

        if (beam.thrower == KILL_YOU_MISSILE)

        if (beam.thrower == KILL_YOU_MISSILE || beam.thrower == KILL_YOU)

            if (!_beam_is_harmless(beam, mon))

            if (!beam.fr_count && !_beam_is_harmless(beam, mon))

        // wow, permanent enslaving

        // Wow, permanent enslaving!

        // already friendly

        // Already friendly.

    // everything else?

    // Everything else?

// extra range used on hit

// Extra range used on hit.

    // generic explosion

    // Generic explosion.

    // plant spit

    // Plant spit.

    // early out for tracer

    // Early out for tracer.

    // take care of non-enchantments

    // Take care of non-enchantments.

    // now for some non-hurtful enchantments

    // Now for some non-hurtful enchantments.