case MONS_TOADSTOOL:
        return TILEP_MONS_FUNGUS;

int binomial_generator(unsigned n_trials, unsigned trial_prob);

// Generate samples from a binomial distribution with n_trials and trial_prob
// probability of success per trial. trial_prob is a integer less than 100
// representing the % chancee of success.
// This just evaluates all n trials, there is probably an efficient way of
// doing this but I'm not much of a statistician. -CAO
int binomial_generator(unsigned n_trials, unsigned trial_prob)
{
    int count = 0;
    for (unsigned i = 0; i < n_trials; ++i)
        if (::x_chance_in_y(trial_prob, 100))
            count++;
    return count;
}

            if (mon->type == MONS_FUNGUS || mon->type == MONS_PLANT)

            if (mon->type == MONS_FUNGUS || mon->type == MONS_PLANT
                || mon->type == MONS_TOADSTOOL)

    if (mg.cls == MONS_TOADSTOOL)
    {
        // This enchantment is a timer that counts down until death.
        // These mushrooms should last longer than the lifespan of a corpse
        // (to avoid spawning mushrooms in the same place over and over), aside
        // from that the value is slightly randomized to avoid simultaneous
        // die-offs of mushroom rings.
        menv[id].add_ench(ENCH_SLOWLY_DYING);
    }

        case ENCH_SLOWLY_DYING:
        {
            const int actdur = speed_to_duration(speed)*levels;
            if (lose_ench_duration(i->first, actdur))
                monster_die(this,KILL_MISC,-1,true);
            break;
        }

        break;
    case ENCH_SLOWLY_DYING:
        // If you are no longer dying you must be dead
        if (decay_enchantment(me))
        {
            if (see_grid(this->position))
                mprf("A nearby %s withers and dies.", this->name(DESC_PLAIN, false).c_str());
            monster_die(this,KILL_MISC,-1,true);
        }

    "bug"

    "decay", "bug"

    case ENCH_SLOWLY_DYING:
        // This may be a little too direct but the randomization at the end
        // of this function is excessive for corpse mold. -cao
        return (2*FRESHEST_CORPSE + random2(10)) * speed_to_duration(mons->speed)
                * mons->speed/10;

{
    MONS_TOADSTOOL, 'f', BROWN, "toadstool",
    M_NO_EXP_GAIN | M_STATIONARY,
    MR_RES_POISON,
    0, 10, MONS_PLANT, MONS_TOADSTOOL, MH_PLANT, MAG_IMMUNE,
    { AT_NO_ATK, AT_NO_ATK, AT_NO_ATK, AT_NO_ATK },
    { 1, 2,2, 0 },
    1, 0, MST_NO_SPELLS, CE_NOCORPSE, Z_NOZOMBIE, S_SILENT, I_PLANT,
    HT_LAND, 10, DEFAULT_ENERGY, MONUSE_NOTHING, SIZE_TINY
},

    ENCH_SLOWLY_DYING,

    MONS_HARPY,                        //  197

    MONS_HARPY,
    MONS_TOADSTOOL,                    //  198

#include <queue>
#include <set>
#include <cmath>

}
// Spawn a ring of mushrooms around the input corpse (radius=1).
// Could try different radii/check for largest available but doesn't right now.
// Maybe there should be a message for this.
static int _mushroom_ring(item_def &corpse)
{
    ::adjacent_iterator adj(corpse.pos);
    int spawned_count=0;
    for ( ; adj; ++adj)
    {
        if (mons_class_can_pass(MONS_TOADSTOOL, grd(*adj))
            && !actor_at(*adj))
        {
            const int mushroom = create_monster(
                        mgen_data(MONS_TOADSTOOL,
                                  BEH_HOSTILE,
                                  0,
                                  0,
                                  *adj,
                                  MHITNOT,
                                  MG_FORCE_PLACE,
                                  GOD_NO_GOD,
                                  MONS_PROGRAM_BUG,
                                  0,
                                  corpse.colour),
                                  false);
            if (mushroom != -1)
                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).
int spawn_corpse_mushrooms(item_def &corpse, int target_count = 1)
{
    if (target_count == 0)
        return 0;
    int x_offset[] = {-1,-1,-1, 0, 0, 1, 1, 1};
    int y_offset[] = {-1, 0, 1,-1, 1,-1, 0, 1};
    int placed_targets = 0;
    std::queue<coord_def> fringe;
    std::set<int> visited_indices;
    // Slight chance of spawning a ring of mushrooms around the corpse (and
    // skeletonizing it) if the corpse square is unoccupied.
    if (!actor_at(corpse.pos) && one_chance_in(100))
    {
        if (see_grid(corpse.pos))
            mpr("A ring of toadstools grow before your very eyes.");
        corpse.special = 0;
        return _mushroom_ring(corpse);
    }
    // Can't figure out how to query the size of the xdim of the grid but who
    // cares.
    visited_indices.insert(10000*corpse.pos.y + corpse.pos.x);
    fringe.push(corpse.pos);
    while (!fringe.empty())
    {
        coord_def current = fringe.front();
        fringe.pop();
        actor * occupant = NULL;
        // is this square occupied by a non mushroom?
        if((occupant = actor_at(current))
           && occupant->mons_species() != MONS_TOADSTOOL)
        {
            continue;
        }
        if (!occupant)
        {
            const int mushroom = create_monster(
                        mgen_data(MONS_TOADSTOOL,
                                  BEH_HOSTILE,
                                  0,
                                  0,
                                  current,
                                  MHITNOT,
                                  MG_FORCE_PLACE,
                                  GOD_NO_GOD,
                                  MONS_PROGRAM_BUG,
                                  0,
                                  corpse.colour),
                                  false);
            if (mushroom != -1)
            {
                placed_targets++;
                if (see_grid(current))
                {
                    if (see_grid(corpse.pos))
                        mpr("A toadstool grows from a nearby corpse.");
                    else
                        mpr("A toadstool springs up from the ground.");
                }
            }
            else
                continue;
        }
        // We're done here if we place the desired number of mushrooms.
        if (placed_targets == target_count)
            break;
        // Randomize the order in which children are processed to a certain
        // extent.
        int idx = rand() % 8;
        for (int count = 0; count < 8; ++count)
        {
            idx= (idx + 1) % 8;
            coord_def temp(current.x + x_offset[idx], current.y + y_offset[idx]);
            int index = temp.x + temp.y * 10000;
            if (visited_indices.find(index) == visited_indices.end()
                && in_bounds(temp)
                && mons_class_can_pass(MONS_TOADSTOOL, grd(temp)))
            {
                visited_indices.insert(index);
                fringe.push(temp);
            }
        }
    }
    return placed_targets;

// 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.
static void _maybe_spawn_mushroom(item_def & corpse, int rot_time)
{
    // We won't spawn a mushroom within 10 turns of the corpse being created
    // or rotting away.
    int low_threshold  = 5;
    int high_threshold = FRESHEST_CORPSE - 5;
    if (corpse.special < low_threshold)
        return;
    int spawn_time = (rot_time > corpse.special ? corpse.special : rot_time);
    if (spawn_time > high_threshold)
        spawn_time = high_threshold;
    // So we're going to spawn one or more mushrooms over the lifetime of a
    // corpse here. For convenience we follow a binomial distribution. I think
    // the most useful analysis is in terms of the probability of a corpse
    // producing no mushrooms, although trial probability should just be hard
    // coded once a value is agreed on.
    // Expect this many trials over a corpse's lifetime since this function
    // is called once for every 10 units of rot_time.
    int step_size = 10;
    float total_trials = (high_threshold - low_threshold) / step_size;
    // chance of producing no mushrooms
    float p_failure = .5;
    float trial_prob_f = 1 - powf(p_failure,1.0f/total_trials);
    // The chance of producing mushrooms depends on the weight of the
    // corpse involved. Humans weigh 550 so we will take that as the
    // base factor here.
    float weight_factor = item_mass(corpse)/550.0f;
    trial_prob_f *= weight_factor;
    int trial_prob = static_cast<int>(100*trial_prob_f);
    int current_trials = spawn_time/step_size;
    int success_count = binomial_generator(current_trials, trial_prob);
    spawn_corpse_mushrooms(corpse, success_count);
}

        if (it.sub_type == CORPSE_BODY)
            _maybe_spawn_mushroom(it, rot_time);

%%%%
toadstool
A short-lived species of fungus typically found on or around decaying organic matter.