feawn_neutralise_plant(monster);

            feawn_neutralise_plant(monster);

        // going to ignore squares that are already occupied by non-fungi

        // Ignore squares that are already occupied by non-fungi.

        // We obviously saw some corpses since we only processed squares

        // We obviously saw some corpses, since we only processed squares

        mprf("%s grow%s from %snearby corpse%s.",
             (seen_mushrooms > 1 ? "Some toadstools"
                                   : "A toadstool"),
             (seen_mushrooms > 1 ? "s" : ""),
             (seen_corpses > 1)  ? "" : "a ",
             (seen_corpses > 1)  ? "s" : "");

        mushroom_spawn_message(seen_mushrooms, seen_corpses);

        return 0;

        return (0);

// Create a ring or partial ring around the caster.
// User is prompted to select a stack of fruit then plants are placed on open
// squares adjacent to the caster, of course 1 piece of fruit is consumed per
// plant so a complete ring may not be formed.
bool plant_ring_from_fruit()

// Prompt the user to select a stack of fruit from their inventory.  The
// user can optionally select only a partial stack of fruit (the count
// variable will store the number of fruit the user wants).  Return the
// index of the item selected in the user's inventory, or a negative
// number if the prompt failed (user canceled or had no fruit).
int _prompt_for_fruit(int & count, const char * prompt_string)

    int possible_count;
    int created_count = 0;
    int rc = prompt_invent_item("Use which fruit?",

    int rc = prompt_invent_item(prompt_string,

                                &possible_count);

                                &count);

        return 0;

        return (rc);
    // Return PROMPT_INAPPROPRIATE if the 'object selected isn't
    // actually fruit.
    if (!is_fruit(you.inv[rc]))
        return (PROMPT_INAPPROPRIATE);
    // Handle it if the user lies about the amount of fruit available.
    if (count > you.inv[rc].quantity)
        count = you.inv[rc].quantity;
    return (rc);
}
// Create a ring or partial ring around the caster.  The user is
// prompted to select a stack of fruit, and then plants are placed on open
// squares adjacent to the user.  Of course, one piece of fruit is
// consumed per plant, so a complete ring may not be formed.
bool plant_ring_from_fruit()
{
    int possible_count;
    int created_count = 0;
    int rc = _prompt_for_fruit(possible_count, "Use which fruit?");
    // Prompt failed?
    if (rc < 0)
        return (false);

    if ((int) adjacent.size() > possible_count)

    if ((int)adjacent.size() > possible_count)

        (possible_count < (int) adjacent.size()) ? possible_count
                                                 : adjacent.size();

        (possible_count < (int)adjacent.size()) ? possible_count
                                                : adjacent.size();

    {

    }

// Creates a circle of water around the target (radius is approximately 2)
// Turns normal floor tiles into shallow water and turns (unoccupied) shallow
// water into deep water.
// Chance of spawning plants or fungus on unoccupied dry floor tiles outside
// of the rainfall area
// Returns the number of plants/fungus created

// Create a circle of water around the target, with a radius of
// approximately 2.  This turns normal floor tiles into shallow water
// and turns (unoccupied) shallow water into deep water.  There is a
// chance of spawning plants or fungus on unoccupied dry floor tiles
// outside of the rainfall area.  Return the number of plants/fungi
// created.

        // Adjusting the shape of the rainfall slightly to make it look nicer.
        // I want a threshold of 2.5 on the euclidean distance so a threshold
        // of 6 prior to the sqrt is close enough.

        // Adjust the shape of the rainfall slightly to make it look
        // nicer.  I want a threshold of 2.5 on the euclidean distance,
        // so a threshold of 6 prior to the sqrt is close enough.

            // Maybe spawn a plant on (dry, open) squares that are in LOS but
            // outside the rainfall area.
            // In open space there are 213 squares in LOS, and we are
            // going to drop water on (25-4) of those, so if we want x plants
            // to spawn on average in open space the trial probability should
            // be x/192

            // Maybe spawn a plant on (dry, open) squares that are in
            // LOS but outside the rainfall area.  In open space, there
            // are 213 squares in LOS, and we are going to drop water on
            // (25-4) of those, so if we want x plants to spawn on
            // average in open space, the trial probability should be
            // x/192.

        // Turn regular floor squares only into shallow water

        // Turn regular floor squares only into shallow water.

            // Remove blood stains as well

            // Remove blood stains as well.

        // We can also turn shallow water into deep water, but we're just going
        // to skip cases where there is something on the shallow water.
        // Destroying items will probably annoy people and insta-killing
        // monsters is clearly out of the question.

        // We can also turn shallow water into deep water, but we're
        // just going to skip cases where there is something on the
        // shallow water.  Destroying items will probably be annoying,
        // and insta-killing monsters is clearly out of the question.

    if (spawned_count>0)

    if (spawned_count > 0)

    if(left.cost == right.cost)
        return coinflip();
    return left.cost < right.cost;

    if (left.cost == right.cost)
        return (coinflip());
    return (left.cost < right.cost);

// Given a monster (well it should be a plant/fungus) see if evolve_flora can
// upgrade it, and set up a monster_conversion structure for it.  Returns true
// (and fills in possible_monster) if input an be upgraded, and returns false
// otherwise.

// Given a monster (which should be a plant/fungus), see if
// evolve_flora() can upgrade it, and set up a monster_conversion
// structure for it.  Return true (and fill in possible_monster) if the
// monster can be upgraded, and return false otherwise.

        monster_conversion & possible_monster)

                         monster_conversion & possible_monster)

        return false;

        return (false);

    return true;

    return (true);

    int needed_fruit = 2;

    int rc;
    int available_count;
    int points_per_fruit = 8;
    int oklob_cost = 10;

    std::priority_queue<monster_conversion, std::vector<monster_conversion> >
                        available_targets;

    float approx_oklob_rate = float(points_per_fruit)/float(oklob_cost);

    int points = 15;

    char prompt_string[100];
    memset(prompt_string,0,100);
    sprintf(prompt_string,"Use which fruit (%1.1f oklob plants per fruit)?",
            approx_oklob_rate);
    rc = _prompt_for_fruit(available_count, prompt_string);
    // Prompt failed?
    if (rc < 0)
        return (false);
    int points = points_per_fruit * available_count;
    int starting_points = points;
    std::priority_queue<monster_conversion> available_targets;

    // Nothing available to upgrade.

        return (false);
    int rc;
    int available_count;
    rc = prompt_invent_item("Use which fruit (must have at least 2)?",
             MT_INVLIST, OSEL_SOME_FRUIT, true, true, true, '\0', -1,
             &available_count);
    if (prompt_failed(rc))

    {
        mpr("No flora in sight can be evolved.");

    dec_inv_item_quantity(rc, needed_fruit);

    }

        // Try to remove slowly dying in case we are upgrading a toadstool.

        // Try to remove slowly dying in case we are upgrading a
        // toadstool.

    // messaging...
    if (plants_evolved > 0)
    {
        mprf("%s can now spit acid.",
             (plants_evolved > 1 ? "Some plants" : "A plant"));
    }

    // How many pieces of fruit did we use up?
    int points_used = starting_points - points;
    int fruit_used = points_used / points_per_fruit;
    if (points_used % points_per_fruit)
        fruit_used++;

    if (toadstools_evolved > 0)

    // The player didn't have enough points to upgrade anything (probably
    // supplied only one fruit).
    if (!fruit_used)

        const bool plural = toadstools_evolved > 1;
        mprf("%s toadstool%s gain%s stability.",
             (plural ? "Some" : "A"),
             (plural ? "s"    : ""),
             (plural ? ""     : "s"));

        mpr("Not enough fruit to cause evolution.");
        return (false);

    dec_inv_item_quantity(rc, fruit_used);
    // Mention how many plants were used.
    if (fruit_used > 1)
        mprf("%d pieces of fruit are consumed!", fruit_used);
    else
        mpr("A piece of fruit is consumed!");

    if (fungi_evolved > 0)

    // Messaging for generated plants.
    if (plants_evolved > 1)
        mprf("%d plants can now spit acid.", plants_evolved);
    else if (plants_evolved == 1)
        mpr("A plant can now spit acid.");
    if (toadstools_evolved > 1)
        mprf("%d toadstools gained stability.", toadstools_evolved);
    else if (toadstools_evolved == 1)
        mpr("A toadstool gained stability.");
    if (fungi_evolved > 1)

        const bool plural = fungi_evolved > 1;
        mprf("The fungal %s can now pick up %s mycelia and move.",
             (plural ? "colonies" : "colony"),
             (plural ? "their"    : "its"));

        mprf("%d fungal colonies can now pick up their mycelia and move.",
             fungi_evolved);

    else if (fungi_evolved == 1)
        mpr("A fungal colony can now pick up its mycelia and move.");

}
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);
}

    if (plant->type != MONS_OKLOB_PLANT
        && plant->type != MONS_WANDERING_MUSHROOM
        && !testbits(plant->flags, MF_ATT_CHANGE_ATTEMPT))

    if ((plant->type != MONS_OKLOB_PLANT
        && plant->type != MONS_WANDERING_MUSHROOM)
        || testbits(plant->flags, MF_ATT_CHANGE_ATTEMPT))

        _feawn_plants_neutral();

        mpr("The plants of the dungeon cease their hostilities.", MSGCH_GOD);

    OSEL_FRUIT       = -13,
    OSEL_SOME_FRUIT  = -14

    OSEL_FRUIT       = -13

#define PROMPT_ABORT        -1
#define PROMPT_GOT_SPECIAL  -2
#define PROMPT_NOTHING      -3

#define PROMPT_ABORT         -1
#define PROMPT_GOT_SPECIAL   -2
#define PROMPT_NOTHING       -3
#define PROMPT_INAPPROPRIATE -4

        // This is really dumb. I don't want to talk about it. -cao
    case OSEL_SOME_FRUIT:
        return is_fruit(i) && i.quantity >= 2;

// must_exist is true (the default) will be an assigned item, with
// a positive quantity.

// must_exist is true, as it is by default, will be an assigned item,
// with a positive quantity.

            need_redraw = (keyin != '?' && keyin != '*');

            need_redraw = (keyin != '?' && keyin != '*')
                          && !(count && auto_list && isdigit(keyin));

            if (auto_list)
                need_redraw = true;

bool mushroom_spawn_message(int seen_targets, int seen_corpses);

                           int & seen_targers,

                           int & seen_targets,

        if (tries > 1 && count_known > size*size/6)

        if (tries > 1 && count_known > size * size / 6)

        return 0;

        return (0);

                mpr("A ring of toadstools grow before your very eyes.");

                mpr("A ring of toadstools grows before your very eyes.");

                // Going to expliclty override the die-off timer in this case
                // (this condition means we got called from fungal_bloom or
                // similar and are creating a lot of toadstools at once that
                // should die off quickly).

                // Going to explicitly override the die-off timer in
                // this case (this condition means we got called from
                // fungal_bloom() or similar, and are creating a lot of
                // toadstools at once that should die off quickly).

bool mushroom_spawn_message(int seen_targets, int seen_corpses)
{
    if (seen_targets > 0)
    {
        std::string what  = seen_targets  > 1 ? "Some toadstools"
                                              : "A toadstool";
        std::string where = seen_corpses  > 1 ? "nearby corpses" :
                            seen_corpses == 1 ? "a nearby corpse"
                                              : "the ground";
        mprf("%s grow%s from %s.",
             what.c_str(), seen_targets > 1 ? "" : "s", where.c_str());
        return (true);
    }
    return (false);
}

    if (seen_spawns > 0)
    {
        std::string base = seen_spawns > 1 ? "Some toadstools" : "A toadstool";
        if (see_grid(corpse.pos))
            mprf("%s grows from a nearby corpse.", base.c_str());
        else
            mprf("%s springs up from the ground.", base.c_str());
    }

    mushroom_spawn_message(seen_spawns, see_grid(corpse.pos) ? 1 : 0);