stop_running();
        }
    }
}
void feawn_neutralise(monsters* monster)
{
    if (you.religion == GOD_FEAWN && mons_is_plant(monster)
        && !mons_is_summoned(monster)
        && !mons_wont_attack(monster)
        && !testbits(monster->flags, MF_ATT_CHANGE_ATTEMPT))
    {
        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);
            monster->flags |= MF_ATT_CHANGE_ATTEMPT;
            feawn_neutralise_plant(monster);

            feawn_neutralise(monster);

        if (mons_class_is_stationary(monster->type))
            continue;

bool prioritize_adjacent(coord_def & target, std::vector<coord_def> & candidates)

bool prioritise_adjacent(coord_def & target, std::vector<coord_def> & candidates)

    mprf("found %d hostiles", mons_positions.size());

        prioritize_adjacent(you.pos(), adjacent);
        //::update_screen();

        prioritise_adjacent(you.pos(), adjacent);

void corpse_spores()

// Destroy corpses in the player's LOS (first corpse on a stack only)
// and make 1 giant spore per corpse.  Spores are given the input as
// their starting behavior; the function returns the number of corpses
// processed.
int corpse_spores(beh_type behavior)

    int count = 0;

                count++;

                                         BEH_FRIENDLY,

                                         behavior,

    return (count);

        coord_def target_square = current_plant->pos();

        // Remove the original plant.
        // XXX: Why do we destroy the old and create a new plant
        //      rather than simply upgrade the old plant?
        monster_die(current_plant, KILL_MISC, NON_MONSTER, true);

        rc = create_monster(mgen_data(new_species,
                                      BEH_FRIENDLY, 0, 0, target_square,
                                      MHITNOT, MG_FORCE_PLACE, GOD_FEAWN));

        current_plant->upgrade_type(new_species, true, true);
        current_plant->god = GOD_FEAWN;
        current_plant->attitude = ATT_FRIENDLY;
        current_plant->flags |= MF_CREATED_FRIENDLY;

void feawn_neutralise_plant(monsters *plant);

bool is_neutral_plant(const monsters* mon);

        snprintf(info,INFO_SIZE,"you promote decomposition%s",

        snprintf(info,INFO_SIZE, "you promote decomposition%s",

        dislikes.push_back("you destroy plants");

        dislikes.push_back("you or your allies destroy plants");

        dislikes.push_back("you practice necromancy");

        dislikes.push_back("you use necromancy");

}
bool is_neutral_plant(const monsters* mon)
{
    return (mon->alive() && mons_is_plant(mon)
            && mon->attitude == ATT_GOOD_NEUTRAL);

    else if (you.religion == GOD_FEAWN)
        return is_neutral_plant(mon);

        case DID_UNHOLY:

                    simple_god_message(" forgives your blasphemy, just this "
                                       "once.");

                    simple_god_message(" forgives your inadvertent necromancy, "
                                       "just this once.");

        case DID_UNHOLY:

       case DID_KILL_PLANT:
       case DID_ALLY_KILLED_PLANT:
           // Piety loss but no penance for killing a plant.
           if (you.religion == GOD_FEAWN)
           {
               retval = true;
               piety_change = -level;
           }
           break;

                // Converted allies (marked as TSOites) can be martyrs.
                if (victim->god == GOD_SHINING_ONE)
                    break;

            case GOD_ZIN: // in contrast to TSO, who doesn't mind martyrs

            case GOD_ZIN:
                // Converted allies (marked as TSOites) can be martyrs.
                if (victim->god == GOD_SHINING_ONE)
                    break;
            case GOD_FEAWN: // plant god only cares about plants
                if (!mons_is_plant(victim))
                    break;

    // to be implemented -CAO

    const god_type god = GOD_FEAWN;
    // We have 3 forms of retribution, but players under penance will be
    // spared the 'you are now surrounded by oklob plants, please die' one.
    const int retribution_options = you.religion == GOD_FEAWN ? 2 : 3;
    switch (random2(retribution_options))
    {
    case 0:
        // Try and spawn some hostile giant spores, if none are created
        // fall through to the elemental miscast effects.
        if (corpse_spores(BEH_HOSTILE))
        {
            simple_god_message(" produces spores.", GOD_FEAWN);
            break;
        }
    case 1:
    {
        // Elemental miscast effects.
        simple_god_message(" invokes the elements against you.", GOD_FEAWN);
        spschool_flag_type stype = SPTYP_NONE;
        switch (random2(4))
        {
        case 0:
            stype= SPTYP_ICE;
            break;
        case 1:
            stype = SPTYP_EARTH;
            break;
        case 2:
            stype = SPTYP_FIRE;
            break;
        case 3:
            stype = SPTYP_AIR;
            break;
        };
        MiscastEffect(&you, -god, stype, 5 + you.experience_level,
                      random2avg(88, 3), "the wrath of Feawn");
        break;
    }
    case 2:
        // We are going to spawn some oklobs but first we need to find
        // out a little about the situation.
        std::vector<std::vector<coord_def> > radius_points;
        collect_radius_points(radius_points,you.pos(),env.no_trans_show);
        unsigned free_thresh = 30;
        mgen_data temp(MONS_OKLOB_PLANT,
                       BEH_HOSTILE, 0, 0,
                       coord_def(),
                       MHITNOT,
                       MG_FORCE_PLACE,
                       GOD_FEAWN);
        // If we have a lot of space to work with (the circle with
        // radius 6 is substantially unoccupied), we can do something
        // flashy.
        if (radius_points[5].size() > free_thresh)
        {
            int seen_count;
            temp.cls = MONS_PLANT;
            place_ring(radius_points[0],
                       you.pos(),
                       temp,
                       1, radius_points[0].size(),
                       seen_count);
            temp.cls = MONS_OKLOB_PLANT;
            place_ring(radius_points[5],
                       you.pos(),
                       temp,
                       random_range(3, 8), 1,
                       seen_count);
        }
        // Otherwise we do something with the nearest neighbors
        // (assuming the player isn't already surrounded).
        else if (!radius_points[0].empty())
        {
            unsigned target_count = random_range(2, 8);
            if (target_count < radius_points[0].size())
                prioritise_adjacent(you.pos(), radius_points[0]);
            else
                target_count = radius_points[0].size();
            unsigned i = radius_points[0].size() - target_count;
            for(; i < radius_points[0].size(); ++i)
            {
                temp.pos = radius_points[0].at(i);
                temp.cls = coinflip() ?
                           MONS_WANDERING_MUSHROOM : MONS_OKLOB_PLANT;
                create_monster(temp,false);
            }
            god_speaks(god, "Plants grow around you in an ominous manner.");
            return (false);
        }
    }

    return success;

    return (success);

    return apply_to_all_dungeons(_holy_beings_on_level_attitude_change);

    return (apply_to_all_dungeons(_holy_beings_on_level_attitude_change));

    return success;

    return (success);

    return apply_to_all_dungeons(_evil_beings_on_level_attitude_change);

    return (apply_to_all_dungeons(_evil_beings_on_level_attitude_change));

    return success;

    return (success);

    return apply_to_all_dungeons(_chaotic_beings_on_level_attitude_change);

    return (apply_to_all_dungeons(_chaotic_beings_on_level_attitude_change));

    return success;

    return (success);

    return apply_to_all_dungeons(_magic_users_on_level_attitude_change);

    return (apply_to_all_dungeons(_magic_users_on_level_attitude_change));

        }
        return (true);
    }
    return (false);
}
static bool _feawn_plants_on_level_hostile()
{
    for (int i = 0; i < MAX_MONSTERS; ++i)
    {
        monsters *monster = &menv[i];
        if (monster->alive()
            && mons_is_plant(monster))
        {
#ifdef DEBUG_DIAGNOSTICS
            mprf(MSGCH_DIAGNOSTICS, "Plant hostility: %s on level %d, branch %d",
                 monster->name(DESC_PLAIN).c_str(),
                 static_cast<int>(you.your_level),
                 static_cast<int>(you.where_are_you));
#endif
            // You can potentially turn an oklob or whatever neutral
            // again by going back to Feawn.
            if (testbits(monster->flags, MF_ATT_CHANGE_ATTEMPT))
                monster->flags &= ~MF_ATT_CHANGE_ATTEMPT;
            monster->attitude = ATT_HOSTILE;
            monster->del_ench(ENCH_CHARM, true);
            behaviour_event(monster, ME_ALERT, MHITYOU);
            // For now WAS_NEUTRAL stays.

    }

    return (true);
}
static bool _feawn_plants_hostile()
{
    if (apply_to_all_dungeons(_feawn_plants_on_level_hostile))
    {
        mpr("The plants of the dungeon turn on you!", MSGCH_GOD);

static bool _feawn_plants_on_level_neutral()
{
    for (int i = 0; i < MAX_MONSTERS; ++i)
    {
        monsters *monster = &menv[i];
        feawn_neutralise_plant(monster);
    }
    return (true);
}
static bool _feawn_plants_neutral()
{
    if (apply_to_all_dungeons(_feawn_plants_on_level_neutral))
    {
        mpr("The plants of the dungeon cease their hostilities." , MSGCH_GOD);
        return (true);
    }
    return (false);
}

}
void feawn_neutralise_plant(monsters *plant)
{
    if (plant->type != MONS_OKLOB_PLANT
        && plant->type != MONS_WANDERING_MUSHROOM
        && !testbits(plant->flags, MF_ATT_CHANGE_ATTEMPT))
    {
        return;
    }
    if (you.can_see(plant))
    {
        mprf(MSGCH_GOD, "%s ignores you.",
             plant->name(DESC_CAP_THE).c_str());
    }
    plant->attitude = ATT_GOOD_NEUTRAL;
    plant->flags   |= MF_WAS_NEUTRAL;

    slime->god      = GOD_JIYVA;

    // Prevent assertion if the slime was previously worshipping a
    // different god, rather than already worshipping Jiyva or being an
    // atheist.
    slime->god = GOD_NO_GOD;

        _inc_penance(old_god, 30);
        break;
    case GOD_FEAWN:
        _feawn_plants_hostile();

        divine_retribution(old_god);

             return (mons_genus(species) == MONS_JELLY
                     || mons_genus(species) == MONS_GIANT_EYEBALL
                     || species == MONS_GIANT_SPORE
                     || species == MONS_GIANT_ORANGE_BRAIN);

            return (mons_class_is_slime(species));
        case GOD_FEAWN:
            return (mons_class_is_plant(species));

    // Feawn hates undead, but will accept demonspawn.
    if (which_god == GOD_FEAWN && you.holiness() == MH_UNDEAD)
        return (false);

    else if (you.religion == GOD_FEAWN)
    {
        mpr("You can call upon Feawn to speed up the decay of corpses.",
            MSGCH_GOD);
        _feawn_plants_neutral();
    }

    return retval;

    if (god == GOD_FEAWN)
        retval = (mons_is_plant(mon));
    return (retval);

                if (mons_is_plant(monster))
                {
                    did_god_conduct(DID_KILL_PLANT, monster->hit_dice,
                                    true, monster);
                }

                && !mons_is_god_gift(monster)

            if (pet_kill && mons_is_plant(monster))
            {
                did_god_conduct(DID_ALLY_KILLED_PLANT, 1 + (monster->hit_dice / 2),
                                true, monster);
            }

            // fight back.
            if (mons_class_flag(mon->type, M_NO_EXP_GAIN))

            // fight back, so don't bother having them do so.  If you
            // worship Feawn, create a ring of friendly plants, and try
            // to break out of the ring by killing a plant, you'll get
            // a warning prompt and penance only once.  Without the
            // hostility check, the plant will remain friendly until it
            // dies, and you'll get a warning prompt and penance once
            // *per hit*.  This may not be the best way to address the
            // issue, though. -cao
            if (mons_class_flag(mon->type, M_NO_EXP_GAIN)
                && mon->attitude != ATT_FRIENDLY)
            {

            }

bool mons_class_is_slime(int mc);

bool mons_class_is_plant(int mc);
bool mons_is_plant(const monsters *mon);

bool mons_class_is_slime(int mc)
{
    return (mons_genus(mc) == MONS_JELLY
            || mons_genus(mc) == MONS_GIANT_EYEBALL
            || mons_genus(mc) == MONS_GIANT_ORANGE_BRAIN);
}

    return (mons_genus(mon->type) == MONS_JELLY
            || mons_genus(mon->type) == MONS_GIANT_EYEBALL
            || mons_genus(mon->type) == MONS_GIANT_ORANGE_BRAIN);

    return (mons_class_is_slime(mon->type));
}
// Monsters Feawn cares about - plants and fungi except for giant spores
// and toadstools.
bool mons_class_is_plant(int mc)
{
    return (mc != MONS_GIANT_SPORE
               && mc != MONS_TOADSTOOL
               && (mons_genus(mc) == MONS_PLANT
                   || mons_genus(mc) == MONS_FUNGUS));
}
bool mons_is_plant(const monsters *mon)
{
    return (mons_class_is_plant(mon->type));

            && _mon_needs_auto_exclude(mon, sleepy))

            && _mon_needs_auto_exclude(mon, sleepy)
            && mon->attitude == ATT_HOSTILE)

    DID_KILL_PLANT,                     // Feawn
    DID_ALLY_KILLED_PLANT,              // Feawn

struct mgen_data;
int place_ring(std::vector<coord_def> & ring_points,
                coord_def & origin,
                mgen_data & prototype,
                int n_arcs,
                int arc_occupancy,
                int & seen_count);

// Collect lists of points that are within LOS (under the given env map),
// unoccupied, and not solid (walls/statues).
void collect_radius_points(std::vector<std::vector<coord_def> > &radius_points,
                           coord_def & origin, env_show_grid & losgrid);

            || mon->has_ench(ENCH_BERSERK)

    // comparison. We want a min queue so we have to use a > operation here.

    // comparison.  We want a min queue so we have to use a > operation
    // here.

        return left.second > right.second;

        return (left.second > right.second);

        theta += 2*PI;

        theta += 2 * PI;

    float arc_angle = 2*PI / n_arcs;

    float arc_angle = 2 * PI / n_arcs;

    if (theta >= 2*PI)
        theta -= 2*PI;

    if (theta >= 2 * PI)
        theta -= 2 * PI;

// Place a partial ring of toadstools around the given corpse. returns the
// number of mushrooms spawned. A return of 0 indicates no mushrooms were
// placed -> some sort of failure mode was reached.
static int _mushroom_ring(item_def &corpse, int & seen_count)

int place_ring(std::vector<coord_def> & ring_points,
                coord_def & origin,
                mgen_data & prototype,
                int n_arcs,
                int arc_occupancy,
                int & seen_count)

    std::random_shuffle(ring_points.begin(),
                        ring_points.end());

    // minimum number of mushrooms spawned on a given ring
    unsigned min_spawn = 2;

    int target_amount = ring_points.size();
    int spawned_count = 0;
    seen_count = 0;
    std::vector<int> arc_counts(n_arcs, arc_occupancy);
    for (unsigned i = 0;
         spawned_count < target_amount && i < ring_points.size();
         i++)
    {
        int direction = _arc_decomposition(ring_points.at(i)
                                           - origin, n_arcs);

    // highest radius we will allow. 8 is LOS
    const int max_radius = LOS_RADIUS;

        if (arc_counts[direction]-- <= 0)
            continue;

    seen_count = 0;

        prototype.pos = ring_points.at(i);
        const int mushroom = create_monster(prototype, false);

    // Just want to associate a point with a distance here for convenience
    typedef std::pair<coord_def, int> coord_dist;

        if (mushroom != -1)
        {
            spawned_count++;
            if (see_grid(ring_points.at(i)))
                seen_count++;
        }
    }

    return (spawned_count);
}
// Collect lists of points that are within LOS (under the given env map),
// unoccupied, and not solid (walls/statues).
void collect_radius_points(std::vector<std::vector<coord_def> > &radius_points,
                           coord_def & origin, env_show_grid & losgrid)
{

    radius_points.clear();
    radius_points.resize(LOS_RADIUS);
    // Just want to associate a point with a distance here for convenience.
    typedef std::pair<coord_def, int> coord_dist;

    // larger radii.
    // Generally we will visit points in order of distance to the origin
    // (not path distance) under distance=sqrt(x^2+y^2-1);

    // larger radii.  We will visit points in order of increasing euclidean
    // distance from the origin (not path distance).

    coord_dist origin(corpse.pos, 0);

    fringe.push(coord_dist(origin, 0));

    fringe.push(origin);

    int max_distance = max_radius * max_radius - 1;

    int current_r = 1;
    int current_thresh = current_r * (current_r + 1);

    std::vector<coord_def> radius_points[max_radius];

    int max_distance = LOS_RADIUS * LOS_RADIUS;

    int max_visited = 0;

        fringe.pop();
        int idx = current.first.x + current.first.y * X_WIDTH;
        if (!visited_indices.insert(idx).second)
            continue;
        // we're done here once we hit a point that is farther away from the

        // We're done here once we hit a point that is farther away from the

        if (current.second > max_visited)
            max_visited = current.second;

        fringe.pop();

        float current_distance =current.second ? sqrtf(current.second + 1) : 0;

        int bound = static_cast<int> (current_distance + 0.5);

        int idx = current.first.x + current.first.y * X_WIDTH;
        if (!visited_indices.insert(idx).second)
            continue;

        // We don't include radius 0 as an option. This is also a good place
        // to check if the squares is already occupied since we want to search
        // past occupied squares but don't want to place toadstools on them.
        if (bound > 0 && !actor_at(current.first))

        while (current.second > current_thresh)

            radius_points[bound - 1].push_back(current.first);

            current_r++;
            current_thresh = current_r * (current_r + 1);

        // We don't include radius 0.  This is also a good place to check if
        // the squares are already occupied since we want to search past
        // occupied squares but don't want to consider them valid targets.
        if (current.second && !actor_at(current.first))
            radius_points[current_r - 1].push_back(current.first);

            coord_def local = temp.first - origin.first;

            // If the grid is out of LOS, skip it.
            if (!see_grid(losgrid, origin, temp.first))
                continue;

            temp.second = local.x * local.x + local.y * local.y - 1;

            coord_def local = temp.first - origin;

            // Don't link to nodes with a smaller absolute distance from the
            // origin than the current node. This is some sort of connectivity
            // constraint, in general we don't want parts of a ring to be
            // connected via a higher radius since rings were supposedly
            // created by outwards expansion.
            if (temp.second < max_visited)
                continue;

            temp.second = local.abs();

                && mons_class_can_pass(MONS_TOADSTOOL, grd(temp.first)))

                && !grid_is_solid(temp.first))

}
// Place a partial ring of toadstools around the given corpse.  Returns
// the number of mushrooms spawned.  A return of 0 indicates no
// mushrooms were placed -> some sort of failure mode was reached.
static int _mushroom_ring(item_def &corpse, int & seen_count)
{
    // minimum number of mushrooms spawned on a given ring
    unsigned min_spawn = 2;

    seen_count = 0;
    std::vector<std::vector<coord_def> > radius_points;
    env_show_grid losgrid;
    losight(losgrid, grd, corpse.pos, true);
    collect_radius_points(radius_points,corpse.pos, losgrid);

    int chosen_idx = random2(LOS_RADIUS);

    int chosen_idx = random2(max_radius);
    // Excluding radius 1 rings because they don't look particularly good
    // (or at least they don't look good with target_arc_len=2sqrt(2)
    // they look ok with arc_len=2, but that doesn't seem very good for
    // higher radii, maybe there should be a more complicated relationship
    // between radius and target arc length, but whatever).
    int min_idx=1;
    for (int i = 2; i < max_radius; i++, chosen_idx++)

    unsigned max_size = 0;
    for (unsigned i = 0; i < LOS_RADIUS; ++i)

        chosen_idx = chosen_idx % max_radius;
        if (chosen_idx >= min_idx
            && radius_points[chosen_idx].size() >= min_spawn)

        if (radius_points[i].size() >= max_size)

           break;

            max_size = radius_points[i].size();
            chosen_idx = i;

    // Couldn't find enough valid points at any radius?

    chosen_idx = random2(chosen_idx + 1);
    // Not enough valid points?

        return 0;

        return (0);

    std::random_shuffle(radius_points[chosen_idx].begin(),
                        radius_points[chosen_idx].end());

    mgen_data temp(MONS_TOADSTOOL,
                  BEH_HOSTILE, 0, 0,
                  coord_def(),
                  MHITNOT,
                  MG_FORCE_PLACE,
                  GOD_NO_GOD,
                  MONS_PROGRAM_BUG,
                  0,
                  corpse.colour);

    int target_amount = radius_points[chosen_idx].size();
    int spawned_count = 0;

    float target_arc_len = 2 * sqrtf(2.0f);

    float target_arc_len=2*sqrtf(2.0f);
    //float target_arc_len = 2;
    int n_arcs = static_cast<int> (ceilf(2*PI * (chosen_idx + 1)

    int n_arcs = static_cast<int> (ceilf(2 * PI * (chosen_idx + 1)

    int mushrooms_per_arc = 1;
    std::vector<int> arc_counts(n_arcs, mushrooms_per_arc);
    for (unsigned i = 0;
         spawned_count < target_amount && i < radius_points[chosen_idx].size();
         i++)
    {
        int direction = _arc_decomposition(radius_points[chosen_idx].at(i)
                                           - origin.first, n_arcs);
        if (arc_counts[direction]-- <= 0)
            continue;

        const int mushroom = create_monster(
                             mgen_data(MONS_TOADSTOOL,
                                       BEH_HOSTILE, 0, 0,
                                       radius_points[chosen_idx].at(i),
                                       MHITNOT,
                                       MG_FORCE_PLACE,
                                       GOD_NO_GOD,
                                       MONS_PROGRAM_BUG,
                                       0,
                                       corpse.colour),
                                       false);

    int spawned_count = place_ring(radius_points[chosen_idx], corpse.pos, temp,
                                   n_arcs, 1, seen_count);

        if (mushroom != -1)
        {
            spawned_count++;
            if (see_grid(radius_points[chosen_idx].at(i)))
                seen_count++;
        }
    }
    return spawned_count;

    return (spawned_count);

// Try to spawn 'target_count' mushrooms around the position of 'corpse'.
// Returns the number of mushrooms actually spawned.
// Mushrooms radiate outwards from the corpse following bfs with 8-connectivity.
// Could change the expansion pattern by using a priority queue for
// sequencing (priority = distance from origin under some metric).

// Try to spawn 'target_count' mushrooms around the position of
// 'corpse'.  Returns the number of mushrooms actually spawned.
// Mushrooms radiate outwards from the corpse following bfs with
// 8-connectivity.  Could change the expansion pattern by using a
// priority queue for sequencing (priority = distance from origin under
// some metric).

    int c_size=8;

    int c_size = 8;

    // skeletonizing it) if the corpse square is unoccupied.

    // skeletonising it) if the corpse square is unoccupied.

        // give up and just place a toadstool on top of the corpse (probably)
        int res=_mushroom_ring(corpse, ring_seen);

        // give up and just place a toadstool on top of the corpse (probably).
        int res = _mushroom_ring(corpse, ring_seen);

            corpse.special=0;

            corpse.special = 0;

            else if (ring_seen >0)

            else if (ring_seen > 0)

            return res;

            return (res);

    visited_indices.insert(X_WIDTH*corpse.pos.y + corpse.pos.x);

    visited_indices.insert(X_WIDTH * corpse.pos.y + corpse.pos.x);

        // is this square occupied by a non mushroom?

        // Is this square occupied by a non mushroom?

                    int dist = static_cast<int> (sqrtf(offset.abs()) + 0.5);

                    int dist = static_cast<int>(sqrtf(offset.abs()) + 0.5);

                {

                }

        // We're done here if we place the desired number of mushrooms.

        // We're done here if we placed the desired number of mushrooms.

        // wish adjacent_iterator had a random traversal

        // Wish adjacent_iterator had a random traversal.

            coord_def temp=current + Compass[permutation[count]];

            coord_def temp = current + Compass[permutation[count]];

    return placed_targets;

    return (placed_targets);

    int low_threshold  = 5;

    int low_threshold = 5;

    // chance of producing no mushrooms (not really because of weight_factor
    // below)
    float p_failure = .5;

    // Chance of producing no mushrooms (not really because of weight_factor
    // below).
    float p_failure = 0.5f;

    // corpse involved. Humans weigh 550 so we will take that as the

    // corpse involved.  Humans weigh 550 so we will take that as the

    float weight_factor = item_mass(corpse)/550.0f;

    float weight_factor = item_mass(corpse) / 550.0f;

    int trial_prob = static_cast<int> (100* trial_prob_f );

    int trial_prob = static_cast<int>(100 * trial_prob_f);

    return trial_prob;

    return (trial_prob);

// Randomly decide whether or not to spawn a mushroom over the given corpse
// Assumption: this is called before the rotting away logic in update_corpses.
// Some conditions in this function may set the corpse timer to 0, assuming
// that the corpse will be turned into a skeleton/destroyed on this update.

// Randomly decide whether or not to spawn a mushroom over the given
// corpse.  Assumption: this is called before the rotting away logic in
// update_corpses.  Some conditions in this function may set the corpse
// timer to 0, assuming that the corpse will be turned into a
// skeleton/destroyed on this update.

    // We won't spawn a mushroom within 10 turns of the corpse being created

    // We won't spawn a mushroom within 10 turns of the corpse's being created

    // beam_source can be -GOD_ENUM_VALUE or one of the miscast sources from
    // spl-mis.h (values are strictly greater than NON_MONSTER in that case)
    // for explosions generated by miscast effects. -cao

    // Worshippers of Feawn may shoot past friendly plants.
    if (!is_explosion && !is_enchantment()
        && this->attitude == ATT_FRIENDLY
        && you.religion == GOD_FEAWN
        && mons_genus(mon->mons_species()) == MONS_PLANT
        && mon->mons_species() != MONS_GIANT_SPORE
        && mon->attitude == ATT_FRIENDLY)

    // Feawn worshippers can fire through monsters of the same alignment.
    // This means Feawn-worshipping players can fire through allied plants,
    // and also means that feawn worshiping oklob plants can fire through
    // plants with the same attitude.
    bool originator_worships_feawn=false;
    // Checking beam_source to decide whether the player or a monster
    // fired the beam (so we can check their religion).  This is complicated
    // by the fact that this beam may in fact be an explosion caused by a
    // miscast effect.  In that case the value of beam_source may be negative
    // (god induced miscast) or greater than NON_MONSTER (various other miscast
    // sources).  So we check whether or not this is an explosion, and also the
    // range of beam_source before attempting to reference env.mons with it.
    // -cao
    if (!is_explosion && this->beam_source == NON_MONSTER)
        originator_worships_feawn = (you.religion == GOD_FEAWN);
    else if (!is_explosion && beam_source >= 0 && beam_source < MAX_MONSTERS)
        originator_worships_feawn = (env.mons[beam_source].god == GOD_FEAWN);
    if (!is_enchantment()
        && attitude == mon->attitude
        && originator_worships_feawn
        && mons_is_plant(mon))

        // FIXME: Messaging is kind of problematic here.

            simple_god_message(" protects your plant from harm.", GOD_FEAWN);

        {
            // FIXME: Could use a better message, something about dodging that
            // doesn't sound excessively weird would be nice.
            mprf(MSGCH_GOD, "Feawn protects %s plant from harm.",
                 attitude == ATT_FRIENDLY ? "your" : "a");
        }

    // We'll say giant spore explosions don't trigger the ally attack conduct
    // for Feawn worshipers.  Mostly because you can accidentally blow up a
    // group of 8 plants and get placed under penance until the end of time
    // otherwise.  I'd prefer to do this elsewhere but the beam information
    // goes out of scope. -cao
    if (you.religion == GOD_FEAWN && flavour == BEAM_SPORE)
        conducts[0].enabled = false;

            return (false);
        break;
    case GOD_FEAWN:
        // Anti-necromancy god: nothing involving necromancy or
        // necromantic spell use.
        if (brand == SPWPN_DRAINING || brand == SPWPN_PAIN
             || brand == SPWPN_VAMPIRICISM)
        {

        }