return TILE_FLOOR_NORMAL;

        return TILE_FLOOR_NORMAL;

       return TILE_DNGN_EXIT_ABYSS;

        return TILE_DNGN_EXIT_ABYSS;

       return TILE_DNGN_ENTER;

        return TILE_DNGN_ENTER;

       return TILE_DNGN_RETURN;

        return TILE_DNGN_RETURN;

       return TILE_DNGN_PORTAL;

        return TILE_DNGN_PORTAL;

       return TILE_DNGN_DRY_FOUNTAIN;

        return TILE_DNGN_DRY_FOUNTAIN;

    int seen_mushrooms=0;
    int seen_corpses=0;

    int seen_mushrooms  = 0;
    int seen_corpses    = 0;

    int processed_count=0;
    for(radius_iterator i(you.position, LOS_RADIUS);i;++i)

    int processed_count = 0;
    for (radius_iterator i(you.position, LOS_RADIUS); i; ++i)

        if(actor_at(*i) && !actor_at(*i)->mons_species() == MONS_TOADSTOOL)

        if (actor_at(*i) && !actor_at(*i)->mons_species() == MONS_TOADSTOOL)

        for(stack_iterator j(*i); j; ++j)

        for (stack_iterator j(*i); j; ++j)

            if(j->base_type == OBJ_CORPSES && j->sub_type == CORPSE_BODY)

            if (j->base_type == OBJ_CORPSES && j->sub_type == CORPSE_BODY)

                corpse_on_pos = true;

                corpse_on_pos  = true;

                int target_count = 1 + binomial_generator(20,trial_prob);

                int target_count = 1 + binomial_generator(20, trial_prob);

                // either turn this corpse into a skeleton or destroy it
                if(mons_skeleton(j->plus))

                // Either turn this corpse into a skeleton or destroy it.
                if (mons_skeleton(j->plus))

            if(corpse_on_pos && see_grid(*i))

            if (corpse_on_pos && see_grid(*i))

    if(seen_mushrooms > 0)

    if (seen_mushrooms > 0)

        std::string base=seen_mushrooms >  1 ? "Some toadstools" : "A toadstool";

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

        // we obviously saw some corpses since we only processed squares in LOS
        if(seen_corpses>1)
        {
            mprf("%s grow from nearby corpses.", base.c_str());
        }
        else
            mprf("%s grow from a nearby corpse.", base.c_str());

        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" : "");

    return processed_count;

    return (processed_count);

    if(actor_at(target) || !mons_class_can_pass(MONS_PLANT, grd(target) ))

    if (actor_at(target) || !mons_class_can_pass(MONS_PLANT, grd(target)))

    if(plant != -1 && see_grid(target) )

    if (plant != -1 && see_grid(target))

    return plant != -1;

    return (plant != -1);

    direction( spelld, DIR_TARGET, TARG_ENEMY, LOS_RADIUS, false, false,
               false, true, "Select sunlight destination", NULL,
               true);

    direction(spelld, DIR_TARGET, TARG_ENEMY, LOS_RADIUS, false, false,
              false, true, "Select sunlight destination", NULL,
              true);

    if(!spelld.isValid)
        return false;

    if (!spelld.isValid)
        return (false);

    int evap_count=0;
    int plant_count=0;

    int evap_count  = 0;
    int plant_count = 0;

    // uncomfortable level of code duplication here but the explosion code in
    // bolt subjects the input radius to r*(r+1) for the threshold and
    // since r is an integer we can never get just the 4-connected neighbors.

    // FIXME: Uncomfortable level of code duplication here but the explosion
    // code in bolt subjects the input radius to r*(r+1) for the threshold and
    // since r is an integer we can never get just the 4-connected neighbours.

    for(int i=0;i<c_size;i++)

    for (int i = 0;i < c_size; ++i)

        coord_def target=base;
        target.x+=x_offset[i];
        target.y+=y_offset[i];

        coord_def target = base;
        target.x += x_offset[i];
        target.y += y_offset[i];

        if(!in_bounds(target) || grid_is_solid(grd(target)))

        if (!in_bounds(target) || grid_is_solid(grd(target)))

        actor * victim = actor_at(target);

        actor *victim = actor_at(target);

        // If this is a water square we will evaporate it

        // If this is a water square we will evaporate it.

        switch (int(ftype))

        switch (ftype)

            ftype=DNGN_FLOOR;

            ftype = DNGN_FLOOR;

            break;
        default:

        if(grd(target)!=ftype)

        if (grd(target) != ftype)

            if(see_grid(target))

            if (see_grid(target))

        monsters * monster_vic = monster_at(target);

        monsters *monster_vic = monster_at(target);

        // because it will affect trapdoor spiders not just fish).
        if(monster_vic)

        // because it will affect trapdoor spiders, not just fish).
        if (monster_vic)

        if(victim)

        if (victim)

            if(!monster_vic)

            if (!monster_vic)

        else if(one_chance_in(100)
                && ftype  >= DNGN_FLOOR_MIN
                && ftype  <= DNGN_FLOOR_MAX )

        else if (one_chance_in(100)
                 && ftype >= DNGN_FLOOR_MIN
                 && ftype <= DNGN_FLOOR_MAX)

            // create a plant.
            int plant=create_monster(mgen_data
                                 (MONS_PLANT,
                                  BEH_HOSTILE,
                                  0,
                                  0,
                                  target,
                                  MHITNOT,
                                  MG_FORCE_PLACE, GOD_FEAWN));

            // Create a plant.
            const int plant = create_monster(mgen_data(MONS_PLANT,
                                                       BEH_HOSTILE,
                                                       0,
                                                       0,
                                                       target,
                                                       MHITNOT,
                                                       MG_FORCE_PLACE,
                                                       GOD_FEAWN));

            if(plant!=-1 && see_grid(target))
            {

            if (plant != -1 && see_grid(target))

            }

    if(plant_count)
        mprf("%s grows in the sunlight.",
             (plant_count > 1 ? "Some plants": "A plant"));

    if (plant_count)
    {
        mprf("%s grow%s in the sunlight.",
             (plant_count > 1 ? "Some plants": "A plant"),
             (plant_count > 1 ? "": "s"));
    }

    if(evap_count)

    if (evap_count)

    return true;

    return (true);

    int idx=origin.x+origin.y*X_WIDTH;

    int idx = origin.x + origin.y * X_WIDTH;

    while(!fringe.empty() )

    while (!fringe.empty())

        for(unsigned i=0;i<targets.size();i++)

        for (unsigned i = 0; i < targets.size(); ++i)

            if(current.first == targets[i])

            if (current.first == targets[i])

                distances[i]=current.second;

                distances[i] = current.second;

        for(adjacent_iterator adj_it(current.first); adj_it;++adj_it)

        for (adjacent_iterator adj_it(current.first); adj_it; ++adj_it)

           idx=adj_it->x+adj_it->y*X_WIDTH;
           if(see_grid(*adj_it)
              && !grid_is_solid(env.grid(*adj_it))
              && exclusion.insert(idx).second)
           {
               monsters * temp = monster_at(*adj_it);
               if(!temp || (temp->attitude==ATT_HOSTILE
                            && temp->mons_species()!=MONS_PLANT
                            && temp->mons_species()!=MONS_TOADSTOOL
                            && temp->mons_species()!=MONS_FUNGUS))
               {
                   fringe.push(point_distance(*adj_it, current.second+1));
               }
           }

            idx = adj_it->x + adj_it->y * X_WIDTH;
            if (see_grid(*adj_it)
                && !grid_is_solid(env.grid(*adj_it))
                && exclusion.insert(idx).second)
            {
                monsters * temp = monster_at(*adj_it);
                if (!temp || (temp->attitude == ATT_HOSTILE
                              && temp->mons_species() != MONS_PLANT
                              && temp->mons_species() != MONS_TOADSTOOL
                              && temp->mons_species() != MONS_FUNGUS))
                {
                    fringe.push(point_distance(*adj_it, current.second+1));
                }
            }

    // consider a matrix where the points of origin form the rows and

    // Consider a matrix where the points of origin form the rows and

    if(origin_to_target)

    if (origin_to_target)

    std::vector<int> current_distances(targets.size(),0);
    for(unsigned i=0;i<origins.size();i++)

    std::vector<int> current_distances(targets.size(), 0);
    for (unsigned i = 0; i < origins.size(); ++i)

        for (unsigned j = 0; j < current_distances.size(); ++j)
            current_distances[j] = INT_MAX;

        for(unsigned j=0;j<current_distances.size();j++)
            current_distances[j]=INT_MAX;

        // so we got the distance from a point of origin to one of the

        // So we got the distance from a point of origin to one of the

        if(origin_to_target)

        if (origin_to_target)

            // the minimum of current_distances is points(i)
            int min_dist=current_distances[0];
            for(unsigned j=1;i<current_distances.size();i++)
            {
                if(current_distances[j] < min_dist)

            // The minimum of current_distances is points(i)
            int min_dist = current_distances[0];
            for (unsigned j = 1; i < current_distances.size(); ++i)
                if (current_distances[j] < min_dist)

            }
            distances[i]=min_dist;

            distances[i] = min_dist;

            for(unsigned j=0;j< targets.size();j++)

            for (unsigned j = 0; j < targets.size(); ++j)

                if(i==0)
                    distances[j]=current_distances[j];
                else
                {
                    if(current_distances[j] < distances[j])
                        distances[j] = current_distances[j];
                }

                if (i == 0)
                    distances[j] = current_distances[j];
                else if (current_distances[j] < distances[j])
                    distances[j] = current_distances[j];

    for( ; los_it; ++los_it)

    for ( ; los_it; ++los_it)

        if(hostile && hostile->attitude == ATT_HOSTILE)

        if (hostile && hostile->attitude == ATT_HOSTILE)

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

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

    if(mons_positions.empty())

    if (mons_positions.empty())

        return true;

        return (true);

    if(squares_to_monsters)

    if (squares_to_monsters)

    for(unsigned i=0;i<possible_moves.size();i++)

    for (unsigned i = 0; i < possible_moves.size(); ++i)

        possible_moves[i].first = candidates[i];

        possible_moves[i].first  = candidates[i];

    std::sort(possible_moves.begin(), possible_moves.end(), less_second<point_distance>);

    std::sort(possible_moves.begin(), possible_moves.end(),
              less_second<point_distance>);

    for(unsigned i=0;i<candidates.size();i++)
        candidates[i]=possible_moves[i].first;

    for (unsigned i = 0; i < candidates.size(); ++i)
        candidates[i] = possible_moves[i].first;

    return true;

    return (true);

// Create a ring or partial ring around the caster

// Create a ring or partial ring around the caster.

    int created_count=0;

    int created_count = 0;

    if(prompt_failed(rc))

    if (prompt_failed(rc))

    for(adjacent_iterator adj_it(you.pos()); adj_it; ++adj_it)

    for (adjacent_iterator adj_it(you.pos()); adj_it; ++adj_it)

        if(mons_class_can_pass(MONS_PLANT, env.grid(*adj_it))
           && !actor_at(*adj_it))

        if (mons_class_can_pass(MONS_PLANT, env.grid(*adj_it))
            && !actor_at(*adj_it))
        {

        }

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

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

    unsigned target_count = possible_count < int(adjacent.size()) ? possible_count : adjacent.size();

    unsigned target_count =
        (possible_count < (int) adjacent.size()) ? possible_count
                                                 : adjacent.size();

    for(unsigned i=0;i<target_count;i++)
    {
        if(create_plant(adjacent[i]))

    for (unsigned i = 0; i < target_count; ++i)
        if (create_plant(adjacent[i]))

    }

    return created_count;

    return (created_count);

    int spawned_count=0;

    int spawned_count = 0;

        // adjusting the shape of the rainfall slightly to make it look nicer.

        // Adjusting the shape of the rainfall slightly to make it look nicer.

        int rain_thresh=6;
        coord_def local=*rad-target;

        int rain_thresh = 6;
        coord_def local = *rad - target;

        if(local.abs() > rain_thresh)

        if (local.abs() > rain_thresh)

            // maybe spawn a plant on (dry, open) squares that are in LOS but

            // Maybe spawn a plant on (dry, open) squares that are in LOS but

            if(x_chance_in_y(5,192)
               && !actor_at(*rad)
               && ftype  >= DNGN_FLOOR_MIN
               && ftype  <= DNGN_FLOOR_MAX )

            if (x_chance_in_y(5, 192)
                && !actor_at(*rad)
                && ftype  >= DNGN_FLOOR_MIN
                && ftype  <= DNGN_FLOOR_MAX)

                int plant=create_monster(mgen_data

                const int plant = create_monster(mgen_data

                if(plant!=-1)

                if (plant != -1)

        if(ftype>=DNGN_FLOOR_MIN && ftype<=DNGN_FLOOR_MAX)

        if (ftype >= DNGN_FLOOR_MIN && ftype <= DNGN_FLOOR_MAX)

        else if(!actor_at(*rad)
           && igrd(*rad) == NON_ITEM
           && ftype == DNGN_SHALLOW_WATER)

        else if (!actor_at(*rad)
                 && igrd(*rad) == NON_ITEM
                 && ftype == DNGN_SHALLOW_WATER)

    if(spawned_count>0)

    if (spawned_count>0)

        mprf("%s grow in the rain.",
             (spawned_count > 1 ? "Some plants" : "A plant"));

        mprf("%s grow%s in the rain.",
             (spawned_count > 1 ? "Some plants" : "A plant"),
             (spawned_count > 1 ? "" : "s"));

    return spawned_count;

    return (spawned_count);

    radius_iterator rad(you.pos(),LOS_RADIUS, true,true,true);
    for( ; rad; ++rad)

    for (radius_iterator rad(you.pos(), LOS_RADIUS, true, true, true); rad;
         ++rad)

        for(stack_iterator stack_it(*rad); stack_it; ++stack_it)

        for (stack_iterator stack_it(*rad); stack_it; ++stack_it)

            if(stack_it->base_type == OBJ_CORPSES
               && stack_it->sub_type == CORPSE_BODY)

            if (stack_it->base_type == OBJ_CORPSES
                && stack_it->sub_type == CORPSE_BODY)

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

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

                if(mons_skeleton(stack_it->plus))

                if (mons_skeleton(stack_it->plus))

        // explicitly making this comparison unstable. I'm not clear on the

        // Explicitly making this comparison unstable. I'm not clear on the

        if(left.second == right.second)

        if (left.second == right.second)

        return left.second < right.second;

        return (left.second < right.second);

    int points=15;
    int plant_cost = 10;
    int toadstool_cost = 1;
    int fungus_cost = 5;

    int points         = 15;
    int plant_cost     = 10;
    int toadstool_cost =  1;
    int fungus_cost    =  5;

    radius_iterator rad(you.pos(), LOS_RADIUS, true, true, true);
    for ( ; rad; ++rad)

    for (radius_iterator rad(you.pos(), LOS_RADIUS, true, true, true); rad;
         ++rad)

        monsters * target=monster_at(*rad);
        int cost=0;
        if(!target)

        monsters * target = monster_at(*rad);
        if (!target)

        switch(target->mons_species())

        int cost = 0;
        switch (target->mons_species())

        };

        };
        if(cost!=0)
            available_targets.push(std::pair<monsters * ,int>(target,cost));

        if (cost != 0)
            available_targets.push(std::pair<monsters *, int>(target, cost));

    if(available_targets.empty() )
        return false;

    if (available_targets.empty())
        return (false);

                           '\0', -1, &available_count);

                            '\0', -1, &available_count);

    if(prompt_failed(rc))
        return false;

    if (prompt_failed(rc))
        return (false);

    int plants_evolved = 0;

    int plants_evolved     = 0;

    int fungi_evolved = 0;

    int fungi_evolved      = 0;

    while(!available_targets.empty() && points > 0)

    while (!available_targets.empty() && points > 0)

        // can we afford this thing?
        if(current_target.second > points)

        // Can we afford this thing?
        if (current_target.second > points)

        points-=current_target.second;

        points -= current_target.second;

        // remove the original plant

        // Remove the original plant.

        switch(base_species)

        switch (base_species)

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

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

        // we can potentially upgrade toadstools a second time
        if(base_species == MONS_TOADSTOOL && rc != -1)

        // We can potentially upgrade toadstools a second time.
        if (base_species == MONS_TOADSTOOL && rc != -1)

    if(plants_evolved > 0)

    if (plants_evolved > 0)

    if(toadstools_evolved>0)

    if (toadstools_evolved>0)

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

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

    if(fungi_evolved > 0)

    if (fungi_evolved > 0)

        bool multiple = fungi_evolved > 1;

        const bool multiple = fungi_evolved > 1;

    return true;

    return (true);

                 verbose ? " via the <w>f</w> command" : "");

                 verbose ? " via the <w>a</w> command" : "");

            if (you.religion == GOD_FEAWN && known)

            if (you.religion == GOD_FEAWN)

                piety_change = -level;
                penance = level;
                retval = true;
            }
            else
            {
                simple_god_message(" forgives your blasphemy, just this once.");

                if (known)
                {
                    piety_change = -level;
                    penance = level;
                    retval = true;
                }
                else
                {
                    simple_god_message(" forgives your blasphemy, just this once.");
                }

            // else fall-through

       && !mon->has_ench(ENCH_BERSERK)
       && mon->mons_species() != MONS_GIANT_SPORE )

        && !mon->has_ench(ENCH_BERSERK)
        && mon->mons_species() != MONS_GIANT_SPORE )

    if(item.base_type != OBJ_FOOD)
        return false;

    if (item.base_type != OBJ_FOOD)
        return (false);

        return true;

        return (true);

    return false;

    return (false);

        {

        }

    if(pos.x == 0 && pos.y != 0)

    if (pos.x == 0 && pos.y != 0)

    if(theta < 0)

    if (theta < 0)

    if(theta >= 2*PI)

    if (theta >= 2*PI)

        if(!visited_indices.insert(idx).second)

        if (!visited_indices.insert(idx).second)

        if(current.second > max_distance)

        if (current.second > max_distance)

        if(current.second > max_visited)

        if (current.second > max_visited)

        if(bound > 0 && !actor_at(current.first))

        if (bound > 0 && !actor_at(current.first))

            if(temp.second < max_visited)

            if (temp.second < max_visited)

            if(visited_indices.find(idx) == visited_indices.end()
               && in_bounds(temp.first)
               && mons_class_can_pass(MONS_TOADSTOOL, grd(temp.first)))

            if (visited_indices.find(idx) == visited_indices.end()
                && in_bounds(temp.first)
                && mons_class_can_pass(MONS_TOADSTOOL, grd(temp.first)))
            {

            }

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

        if (chosen_idx >= min_idx
            && radius_points[chosen_idx].size() >= min_spawn)
        {
           break;
        }

    if(radius_points[chosen_idx].size() < min_spawn)

    if (radius_points[chosen_idx].size() < min_spawn)

        if(arc_counts[direction] <= 0)

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

        arc_counts[direction]--;

        if(mushroom != -1)

        if (mushroom != -1)

            if(see_grid(radius_points[chosen_idx].at(i)))

            if (see_grid(radius_points[chosen_idx].at(i)))

        if(res)

        if (res)

            if(see_grid(corpse.pos))

            if (see_grid(corpse.pos))

            else if(ring_seen > 1)

            else if (ring_seen > 1)

        if((occupant = actor_at(current))
           && occupant->mons_species() != MONS_TOADSTOOL)

        if ((occupant = actor_at(current))
            && occupant->mons_species() != MONS_TOADSTOOL)

                if(distance_as_time)

                if (distance_as_time)

    if(seen_spawns > 0)

    if (seen_spawns > 0)

        if(see_grid(corpse.pos))

        if (see_grid(corpse.pos))

        if(!sunlight())
            return false;

        if (!sunlight())
            return (false);

        if(!plant_ring_from_fruit())
            return false;

        if (!plant_ring_from_fruit())
            return (false);

        if(!evolve_flora())
            return false;

        if (!evolve_flora())
            return (false);