POT_SPEED, POT_MIGHT, POT_INVISIBILITY,

                              POT_SPEED, POT_MIGHT, POT_AGILITY, POT_BRILLIANCE, POT_INVISIBILITY,

    case POT_AGILITY:       potion_msg += "(agility)"; break;
    case POT_BRILLIANCE:    potion_msg += "(brilliance)"; break;

             you.dex, you.intel};

             you.dex - (you.duration[DUR_AGILITY] ? 5 : 0),
             you.intel - (you.duration[DUR_BRILLIANCE] ? 5 : 0)};

        && (mons_is_plant(monster)
            || monster->mons_species() == MONS_GIANT_SPORE)
        && !mons_is_summoned(monster)
        && !mons_wont_attack(monster)
        && !testbits(monster->flags, MF_ATT_CHANGE_ATTEMPT))

        && monster->attitude == ATT_HOSTILE
        && feawn_neutralises(monster)
        && !testbits(monster->flags, MF_ATT_CHANGE_ATTEMPT)
        && !player_under_penance())

        if (!player_under_penance())
        {
            // We must call remove_auto_exclude before neutralizing the
            // plant because remove_auto_exclude only removes exclusions
            // it thinks were caused by auto-exclude, and
            // auto-exclusions now check for ATT_HOSTILE.  Oh, what a
            // tangled web, etc.
            remove_auto_exclude(monster, false);

        // We must call remove_auto_exclude before neutralizing the
        // plant because remove_auto_exclude only removes exclusions
        // it thinks were caused by auto-exclude, and
        // auto-exclusions now check for ATT_HOSTILE.  Oh, what a
        // tangled web, etc.
        remove_auto_exclude(monster, false);

            feawn_neutralise_plant(monster);
            monster->flags |= MF_ATT_CHANGE_ATTEMPT;

        feawn_neutralise_plant(monster);
        monster->flags |= MF_ATT_CHANGE_ATTEMPT;

            stop_running();
        }

        stop_running();

            env.show_col(e) = BLUE;

            // Translates between colours used for shallow and deep water,
            // if not using the normal LIGHTCYAN / BLUE. The ripple uses
            // the deep water colour.
            unsigned short base_colour = env.grid_colours(monster->pos());
            static const unsigned short ripple_table[] =
                {BLUE,          // BLACK        => BLUE (default)
                 BLUE,          // BLUE         => BLUE
                 GREEN,         // GREEN        => GREEN
                 CYAN,          // CYAN         => CYAN
                 RED,           // RED          => RED
                 MAGENTA,       // MAGENTA      => MAGENTA
                 BROWN,         // BROWN        => BROWN
                 DARKGREY,      // LIGHTGREY    => DARKGREY
                 DARKGREY,      // DARKGREY     => DARKGREY
                 BLUE,          // LIGHTBLUE    => BLUE
                 GREEN,         // LIGHTGREEN   => GREEN
                 BLUE,          // LIGHTCYAN    => BLUE
                 RED,           // LIGHTRED     => RED
                 MAGENTA,       // LIGHTMAGENTA => MAGENTA
                 BROWN,         // YELLOW       => BROWN
                 LIGHTGREY};    // WHITE        => LIGHTGREY
            env.show_col(e) = ripple_table[base_colour & 0x0f];

    if (you.duration[DUR_BRILLIANCE])
        prop_int += 5;
    if (you.duration[DUR_AGILITY])
        prop_dex += 5;

        const int brilliant = you.duration[DUR_BRILLIANCE] ? 5 : 0;
        const int agile = you.duration[DUR_AGILITY] ? 5 : 0;

        if ((you.intel - stat_loss) > 0)

        if ((you.intel - brilliant - stat_loss) > 0)

        if ((you.dex - stat_loss) > 0)

        if ((you.dex - agile - stat_loss) > 0)

    // Apply Brilliance factor here.
    if (you.duration[DUR_BRILLIANCE])
        fail_reduce = fail_reduce * 67 / 100;

            // Merfolk should be able to control-tele into deep water.

                    && (you.species != SP_MERFOLK
                        || grd(you.pos()) != DNGN_DEEP_WATER)

                   && (you.species != SP_MERFOLK
                       || grd(you.pos()) != DNGN_DEEP_WATER)

// Can also turn zombies into skeletons and destroy ghouls/rotting hulks

    bool kills = false;

        // Ignore squares that are already occupied by non-fungi.
        if (actor_at(*i) && !actor_at(*i)->mons_species() == MONS_TOADSTOOL)

        actor *target = actor_at(*i);
        if (target && (target->atype() == ACT_PLAYER
                       || target->is_summoned()))
        {

        }
        monsters * mons = monster_at(*i);

        if (mons && mons->mons_species() != MONS_TOADSTOOL)
        {
            switch (mons_genus(mons->mons_species()))
            {
            case MONS_ZOMBIE_SMALL:
                // Maybe turn a zombie into a skeleton.
                if (mons_skeleton(mons_zombie_base(mons)))
                {
                    processed_count++;
                    monster_type skele_type = MONS_SKELETON_LARGE;
                    if (mons_zombie_size(mons_zombie_base(mons)) == Z_SMALL)
                        skele_type = MONS_SKELETON_SMALL;
                    if (mons->visible())
                    {
                        mprf("%s flesh rots away.",
                        mons->name(DESC_NOCAP_ITS).c_str());
                    }
                    mons->upgrade_type(skele_type,true,true);
                    behaviour_event(mons, ME_ALERT, MHITYOU);
                    continue;
                }
                // Else fall through and destroy the zombie.
                // Ghoul type monsters are always destroyed.
            case MONS_GHOUL:
            {
                if (mons->visible())
                {
                    mprf("The %s rots away and dies.",
                         mons->name(DESC_PLAIN).c_str());
                }
                coord_def pos = mons->pos();
                int colour    = mons->colour;
                int corpse    = monster_die(mons, KILL_MISC, NON_MONSTER, true);
                kills = true;
                // If a corpse didn't drop, create a toadstool.
                // If one did drop, we will create toadstools from it as usual
                // later on.
                if (corpse < 0)
                {
                    const int mushroom = create_monster(
                                mgen_data(MONS_TOADSTOOL,
                                          BEH_HOSTILE,
                                          0,
                                          0,
                                          pos,
                                          MHITNOT,
                                          MG_FORCE_PLACE,
                                          GOD_NO_GOD,
                                          MONS_PROGRAM_BUG,
                                          0,
                                          colour),
                                          false);
                    if (mushroom != -1)
                        seen_mushrooms++;
                    processed_count++;
                    continue;
                }
                break;
            }
            default:
                continue;
            }
        }

        // We obviously saw some corpses, since we only processed squares
        // in LOS.
        ASSERT(seen_corpses > 0);

    if (kills)
        mprf("That felt like a moral victory.");

    if (plant != -1 && see_grid(target))
        mpr("A plant grows up from the ground.");

    if (plant != -1)
    {
        env.mons[plant].flags |= MF_ATT_CHANGE_ATTEMPT;
        if (see_grid(target))
            mpr("A plant grows up from the ground.");
    }

                                      BEH_HOSTILE,

                                      BEH_GOOD_NEUTRAL,

                create_monster(mgen_data(MONS_GIANT_SPORE,
                                         behavior,
                                         0,
                                         0,
                                         *rad,
                                         MHITNOT,
                                         MG_FORCE_PLACE));

                int rc = create_monster(mgen_data(MONS_GIANT_SPORE,
                                                  behavior,
                                                  0,
                                                  0,
                                                  *rad,
                                                  MHITNOT,
                                                  MG_FORCE_PLACE));

                if (rc!=-1)
                    env.mons[rc].flags |= MF_ATT_CHANGE_ATTEMPT;

        current_plant->flags |= MF_ATT_CHANGE_ATTEMPT;

        DUR_MIGHT, DUR_FIRE_SHIELD, DUR_ICY_ARMOUR, DUR_REPEL_MISSILES,

        DUR_MIGHT, DUR_AGILITY, DUR_BRILLIANCE, DUR_FIRE_SHIELD, DUR_ICY_ARMOUR, DUR_REPEL_MISSILES,

        contamination++;
    }
    if (you.duration[DUR_BRILLIANCE])
    {
        potion_effect(POT_BRILLIANCE, pow);

    if (you.duration[DUR_AGILITY])
    {
        potion_effect(POT_AGILITY, pow);
        contamination++;
    }

            case POT_AGILITY:
            case POT_BRILLIANCE:

#i-agility POT_AGILITY
#i-brilliance POT_BRILLIANCE
i-gain-dexterity POT_AGILITY
i-gain-intelligence POT_BRILLIANCE

bool feawn_passthrough(const monsters * target);
bool feawn_protects(const monsters * target);
bool feawn_protects_species(int mc);
bool feawn_neutralises(const monsters * target);

    case GOD_FEAWN:

    if (you.religion == GOD_FEAWN)
    {
        if (you.duration[DUR_SLOW] < you.duration[DUR_PRAYER])
            slow_player(you.duration[DUR_PRAYER]);
        mprf(MSGCH_GOD, "You feel in touch with plants.");
    }

            case GOD_FEAWN: 
                // plant god only cares about plants

            case GOD_FEAWN:

                if (you.religion == GOD_FEAWN && !mons_is_plant(victim))

                if (you.religion == GOD_FEAWN && !feawn_protects(victim))

            && (mons_is_plant(monster)
                || monster->mons_species() == MONS_GIANT_SPORE))

            && mons_is_plant(monster))

    if (!mons_is_plant(plant)

    if (!plant
        || !feawn_neutralises(plant)
        || plant->attitude != ATT_HOSTILE

    }
    if (you.can_see(plant))
    {
        mprf(MSGCH_GOD, "%s ignores you.",
             plant->name(DESC_CAP_THE).c_str());

}
// During prayer feawn allows worshipers to walk on top of stationary plants
// and fungi.
bool feawn_passthrough(const monsters * target)
{
    return (target && you.religion == GOD_FEAWN
            && you.duration[DUR_PRAYER]
            && mons_is_plant(target)
            && mons_is_stationary(target));

// Feawn worshipers are on the hook for most plants and fungi, but not
// toadstools and giant spores because they die too easily.
//
// If feawn worshipers kill a protected monster they lose piety,
// if they attack a friendly one they get penance,
// if a friendly one dies they lose piety.
bool feawn_protects_species(int mc)
{
    return (mons_class_is_plant(mc)
            && mc != MONS_TOADSTOOL
            && mc != MONS_GIANT_SPORE);
}
bool feawn_protects(const monsters * target)
{
    return target && feawn_protects_species(target->mons_species());
}
// Feawn neutralizes most plants and fungi but skips toadstools to prevent
// message spam (and killing them doesn't even cause piety loss).
bool feawn_neutralises(const monsters * target)
{
    return (target && mons_is_plant(target)
            && target->mons_species() != MONS_TOADSTOOL);
}

            return (mons_class_is_plant(species));

            return feawn_protects_species(species);

        retval = (mons_is_plant(mon));

        retval = (feawn_protects(mon));

                            || mons_is_submerged( &menv[ mgrd(p) ])));

                            || mons_is_submerged( &menv[ mgrd(p) ])
                            || feawn_passthrough(&menv[mgrd(p)])));

    if (you.duration[DUR_AGILITY]) 
        ev += 5;

    // Brilliance Potion
    ma += 6 * (you.duration[DUR_BRILLIANCE] ? 1 : 0);

    if (you.duration[DUR_AGILITY]) 
        stealth += 50;

    if (you.duration[DUR_BRILLIANCE])
        mpr("You are brilliant.");
    if (you.duration[DUR_AGILITY])
        mpr("You are agile.");

    if (you.duration[DUR_BRILLIANCE])
        result += 5;

    if (you.duration[DUR_AGILITY])
        result += 5;

        || stat == STAT_STRENGTH && you.duration[DUR_MIGHT])

        || stat == STAT_STRENGTH && you.duration[DUR_MIGHT]
        || stat == STAT_INTELLIGENCE && you.duration[DUR_BRILLIANCE]
        || stat == STAT_DEXTERITY && you.duration[DUR_AGILITY])

    const bool boosted_int = you.duration[DUR_DIVINE_STAMINA];
    const bool boosted_dex = you.duration[DUR_DIVINE_STAMINA];

    const bool boosted_int = you.duration[DUR_DIVINE_STAMINA]
                                || you.duration[DUR_BRILLIANCE];
    const bool boosted_dex = you.duration[DUR_DIVINE_STAMINA]
                                || you.duration[DUR_AGILITY];

    if (you.duration[DUR_BRILLIANCE])
        status.push_back("brilliance");
    if (you.duration[DUR_AGILITY])
        status.push_back("agile");

        if (you.duration[DUR_BRILLIANCE])
            mod = -5;

        if (you.duration[DUR_AGILITY])
            mod = -5;

    if (killer == KILL_MISC)
        killer = KILL_MON;

    beam.thrower      = killer;

    beam.thrower      = (monster->attitude == ATT_FRIENDLY ? KILL_YOU : KILL_MON);

                if (mons_is_plant(monster))

                if (feawn_protects(monster))

            if (pet_kill && mons_is_plant(monster))

            if (pet_kill && feawn_protects(monster))

                && mon->attitude != ATT_FRIENDLY)

                && mon->attitude != ATT_FRIENDLY
                && mon->attitude != ATT_GOOD_NEUTRAL)

            if (monster->pos() + mmov == you.pos())
            {
                ASSERT(!crawl_state.arena);
                if (!mons_friendly(monster))
                {
                    // If it steps into you, cancel other targets.
                    monster->foe = MHITYOU;
                    monster->target = you.pos();
                    monster_attack(monster);
                    if (mons_is_batty(monster))
                    {
                        monster->behaviour = BEH_WANDER;
                        _set_random_target(monster);
                    }
                    DEBUG_ENERGY_USE("monster_attack()");
                    mmov.reset();
                    continue;
                }
            }

            // FIXME: looks like the lack of a check on 'submerged' here is the
            // reason monsters can attack submerged monsters they happen to
            // walk into -cao

                    continue;
                }
            }
            if (monster->pos() + mmov == you.pos())
            {
                ASSERT(!crawl_state.arena);
                if (!mons_friendly(monster))
                {
                    // If it steps into you, cancel other targets.
                    monster->foe = MHITYOU;
                    monster->target = you.pos();
                    monster_attack(monster);
                    if (mons_is_batty(monster))
                    {
                        monster->behaviour = BEH_WANDER;
                        _set_random_target(monster);
                    }
                    DEBUG_ENERGY_USE("monster_attack()");
                    mmov.reset();

// Monsters Feawn cares about - plants and fungi except for giant spores
// and toadstools.

// Plant or fungus really

    return (mc != MONS_GIANT_SPORE
               && mc != MONS_TOADSTOOL
               && (mons_genus(mc) == MONS_PLANT
                   || mons_genus(mc) == MONS_FUNGUS));

    return (mons_genus(mc) == MONS_PLANT
            || mons_genus(mc) == MONS_FUNGUS);

        // of this function is excessive for corpse mold. -cao

        // of this function is excessive for toadstools. -cao

                                            612, POT_AGILITY,
                                            612, POT_BRILLIANCE,

    case POT_AGILITY:           return "agility";
    case POT_BRILLIANCE:        return "brilliance";

        case POT_AGILITY:
        case POT_BRILLIANCE:

    bool destroyed = (chance == 0) ? false :
        (one_chance_in(chance) && one_chance_in(item->plus));

    bool destroyed = (chance == 0) ? false : (one_chance_in(chance)
                                              && one_chance_in(item->plus + 1));

                                   40,  POT_AGILITY,
                                   40,  POT_BRILLIANCE,

        did_god_conduct(DID_STIMULANTS, 4 + random2(4), was_known);
        break;
    }
    case POT_BRILLIANCE:
    {
        const bool were_brilliant = you.duration[DUR_BRILLIANCE] > 0;
        mprf(MSGCH_DURATION, "You feel %s all of a sudden.",
             were_brilliant ? "clever" : "more clever");
        if (were_brilliant)
            contaminate_player(1, was_known);
        else
            modify_stat(STAT_INTELLIGENCE, 5, true, "");
        you.duration[DUR_BRILLIANCE] += (35 + random2(pow)) / factor;
        if (you.duration[DUR_BRILLIANCE] > 80)
            you.duration[DUR_BRILLIANCE] = 80;
        did_god_conduct(DID_STIMULANTS, 4 + random2(4), was_known);
        break;
    }
    case POT_AGILITY:
    {
        const bool were_agile = you.duration[DUR_AGILITY] > 0;
        mprf(MSGCH_DURATION, "You feel %s all of a sudden.",
             were_agile ? "agile" : "more agile");
        if (were_agile)
            contaminate_player(1, was_known);
        else
            modify_stat(STAT_DEXTERITY, 5, true, "");

        you.duration[DUR_AGILITY] += (35 + random2(pow)) / factor;
        if (you.duration[DUR_AGILITY] > 80)
            you.duration[DUR_AGILITY] = 80;
        you.redraw_evasion = true;

    ABIL_FEAWN_PLANTWALK,

    ABIL_FEAWN_SUNLIGHT,
    ABIL_FEAWN_RAIN,                        // 245

    ABIL_FEAWN_SUNLIGHT,                    // 245
    ABIL_FEAWN_RAIN,

    DUR_BRILLIANCE,
    DUR_AGILITY,

    POT_BRILLIANCE,
    POT_AGILITY,

        }
        else if (which_god == GOD_FEAWN )
        {
            have_any = true;
            std::string buf = "You can speed up decomposition.";
            _print_final_god_abil_desc(which_god, buf,
                                       ABIL_FEAWN_FUNGAL_BLOOM);
            buf = "You can pass through plants during prayer.";
            _print_final_god_abil_desc(which_god, buf,
                                       ABIL_FEAWN_PLANTWALK);

of one who drinks it.
%%%%
potion of brilliance
A magic potion which greatly increases the intelligence and magical power

potion of agility
A magic potion which greatly increases the dexterity and evasiveness
of one who drinks it.
%%%%

    void affect_cell();

    void affect_cell(bool avoid_self = false);

void bolt::affect_cell()

void bolt::affect_cell(bool avoid_self)

    bool avoid_monster = (avoid_self && this->thrower == KILL_MON_MISSILE);
    bool avoid_player  = (avoid_self && this->thrower != KILL_MON_MISSILE);

            if (can_affect_wall_monster(mon))

            if (can_affect_wall_monster(mon) && !avoid_monster)

            else

            else if (!avoid_monster)

    // We don't want to hit a monster in a wall square twice.

    if (!still_wall)
        if (monsters* m = monster_at(pos()))
            affect_monster(m);

    bool hit_player = false;

    if (found_player())

    if (found_player() && !avoid_player)
    {

        hit_player = true;
    }

    // We don't want to hit a monster in a wall square twice.
    // Also stop single target beams from affecting a monster if they already
    // affected the player on this square. -cao
    if ((!hit_player || this->is_beam || this->is_explosion)
         && !still_wall && !avoid_monster)
    {
        if (monsters* m = monster_at(pos()) )
            affect_monster(m);
    }

    bool avoid_self = (!aimed_at_feet && (!is_explosion || !in_explosion_phase));

        // Take *one* step, so as not to hurt the source.
        ray.advance_through(target);

            affect_cell();

            affect_cell(avoid_self);

        range_used++;

        if (!avoid_self)
            range_used++;

        avoid_self = false;

    // Confusion effect for spore explosions
    if (flavour == BEAM_SPORE && hurted && you.holiness() != MH_UNDEAD)
        potion_effect( POT_CONFUSION, 1);

        && mons_is_plant(mon))

        && feawn_protects(mon))

    if (engulfs && this->flavour == BEAM_SPORE
        && mons_class_holiness(mon->type) == MH_NATURAL)
    {
        apply_enchantment_to_monster(mon);
    }

    // goes out of scope. -cao
    if (you.religion == GOD_FEAWN && flavour == BEAM_SPORE)

    // goes out of scope.
    //
    // Also exempting miscast explosions from this conduct -cao
    if (you.religion == GOD_FEAWN
        && (flavour == BEAM_SPORE
            || beam_source == NON_MONSTER
               && aux_source.find("your miscasting") != std::string::npos))
    {

    }

        corpse = monster_die(mon, thrower, beam_source_as_target());

    {
        // Prevent spore explosions killing plants from being registered as
        // a feawn misconduct. Deaths can trigger the ally dying or plant
        // dying conducts, but spore explosions shouldn't count for either of
        // those.
        //
        // FIXME: Should be a better way of doing this. For now we are just
        // falsifying the death report... -cao
        if(you.religion == GOD_FEAWN && this->flavour == BEAM_SPORE
           && feawn_protects(mon))
        {
            if (mon->attitude==ATT_FRIENDLY)
                mon->attitude = ATT_HOSTILE;
            corpse = monster_die(mon, KILL_MON, beam_source_as_target());
        }
        else
            corpse = monster_die(mon, thrower, beam_source_as_target());
    }

    case BEAM_SPORE:

    if (_decrement_a_duration(DUR_AGILITY, "You feel a little less agile now."))
        modify_stat(STAT_DEXTERITY, -5, true, "agility running out");
    if (_decrement_a_duration(DUR_BRILLIANCE, "You feel a little less clever now."))
        modify_stat(STAT_INTELLIGENCE, -5, true, "brilliance running out");
	

          if (feawn_passthrough(targ_monst))
              targ_monst = NULL;

    { ABIL_FEAWN_PLANTWALK, "Plant Walking", 0, 0, 0, 0, ABFLAG_NONE },

    case ABIL_FEAWN_PLANTWALK:
        // Activated via prayer elsewhere.
        break;