const coord_def pathfind(run_mode_type rt);

    coord_def pathfind(run_mode_type rt);

const coord_def travel_pathfind::pathfind(run_mode_type rmode)

coord_def travel_pathfind::pathfind(run_mode_type rmode)

}
static int _monster_natural_regen_roll(monsters *monster)
{
    // A HD divider ranging from 3 (at 1 HD) to 1 (at 8 HD).
    int divider =
        std::max(div_rand_round(15 - monster->hit_dice, 4), 1);
    // The undead have a harder time regenerating.
    switch (monster->holiness())
    {
    // The undead don't regenerate easily.
    case MH_UNDEAD:
        divider *= 4;
        break;
    // And golems have it worse.
    case MH_NONLIVING:
        divider *= 5;
        break;
    default:
        break;
    }
    const int regen_rate =
        std::max(div_rand_round(monster->hit_dice, divider), 1);
    return (random2(25) < regen_rate);

    
    // regenerate:

            && (grd[monster->x][monster->y] == DNGN_LAVA
                || (env.cgrid(monster->pos()) != EMPTY_CLOUD
                    && env.cloud[env.cgrid(monster->pos())].type
                       == CLOUD_FIRE)))

            && (grd(monster->pos()) == DNGN_LAVA
                || cloud_type_at(monster->pos()) == CLOUD_FIRE))
        

            && (grd[monster->x][monster->y] == DNGN_SHALLOW_WATER
                || grd[monster->x][monster->y] == DNGN_DEEP_WATER))

            && grid_is_watery(grd(monster->pos())))
        

            && env.cgrid[monster->x][monster->y] == EMPTY_CLOUD

            && env.cgrid(monster->pos()) == EMPTY_CLOUD

        || one_chance_in(25))

        
        || _monster_natural_regen_roll(monster))

    // Allow the victim to exhibit passive damage behaviour (royal jelly).
    victim->react_to_damage(damage_dealt);
    

coord_def find_newmons_square_contiguous(monster_type mons_class,
                                         const coord_def &start,
                                         int maxdistance = 3);

static dungeon_feature_type _monster_habitat_feature(int mtype)
{
    return ((mtype == RANDOM_MONSTER) ? DNGN_FLOOR
            : habitat2grid( mons_habitat_by_type(mtype) ));
}
class newmons_square_find : public travel_pathfind
{
private:
    dungeon_feature_type grid_wanted;
    coord_def start;
    int maxdistance;
    int best_distance;
    int nfound;
public:
    // Terrain that we can't spawn on, but that we can skip through.
    std::set<dungeon_feature_type> passable;
public:
    newmons_square_find(dungeon_feature_type grdw,
                        const coord_def &pos,
                        int maxdist = 0)
        :  grid_wanted(grdw), start(pos), maxdistance(maxdist),
           best_distance(0), nfound(0)
    {
    }
    coord_def pathfind()
    {
        set_floodseed(start);
        return travel_pathfind::pathfind(RMODE_EXPLORE);
    }
    
    bool path_flood(const coord_def &c, const coord_def &dc)
    {
        if (best_distance && traveled_distance > best_distance)
            return (true);
        
        if (!in_bounds(dc)
            || (maxdistance > 0 && traveled_distance > maxdistance))
        {
            return (false);
        }
        if (!grid_compatible(grid_wanted, grd(dc), true))
        {
            if (passable.find(grd(dc)) != passable.end())
                good_square(dc);
            return (false);
        }
        if (mgrd(dc) == NON_MONSTER && dc != you.pos()
            && one_chance_in(++nfound))
        {
            greedy_dist = traveled_distance;
            greedy_place = dc;
            best_distance = traveled_distance;
        }
        else
        {
            good_square(dc);
        }
        return (false);
    }
};
/*
 * Finds a square for a monster of the given class, pathfinding
 * through only contiguous squares of habitable terrain.
 */
coord_def find_newmons_square_contiguous(monster_type mons_class,
                                         const coord_def &start,
                                         int distance)
{
    newmons_square_find nmfind(_monster_habitat_feature(mons_class),
                               start, distance);
    const coord_def p = nmfind.pathfind();
    return (in_bounds(p)? p : coord_def(-1, -1));
}

    dungeon_feature_type spcw =
        ((mons_class == RANDOM_MONSTER) ? DNGN_FLOOR
         : habitat2grid( mons_habitat_by_type(mons_class) ));

    const dungeon_feature_type spcw = _monster_habitat_feature(mons_class);

}
static inline monster_type _royal_jelly_ejectable_monster()
{
    return static_cast<monster_type>(
        random_choose( MONS_ACID_BLOB,
                       MONS_AZURE_JELLY,
                       MONS_DEATH_OOZE,
                       -1 ) );
}
void monsters::react_to_damage(int damage)
{
    // The royal jelly objects to taking damage and will SULK. :-)
    if (type == MONS_ROYAL_JELLY && alive()
        && damage > 8 && random2(50) < damage)
    {
        const int tospawn =
            1 + random2avg(1 + std::min((damage - 8) / 8, 5), 2);
        mprf(MSGCH_DIAGNOSTICS, "Trying to spawn %d jellies.", tospawn);
        const beh_type sbehaviour = SAME_ATTITUDE(this);
        int spawned = 0;
        for (int i = 0; i < tospawn; ++i)
        {
            const monster_type jelly = _royal_jelly_ejectable_monster();
            coord_def jpos = find_newmons_square_contiguous(jelly, pos());
            if (!in_bounds(jpos))
                continue;
            
            const int nmons =
                mons_place( jelly, sbehaviour, foe, true, jpos.x, jpos.y,
                            you.level_type, PROX_ANYWHERE, MONS_PROGRAM_BUG,
                            0, false );
            
            if (nmons != -1 && nmons != NON_MONSTER)
            {
                // Don't allow milking the royal jelly.
                menv[nmons].flags |= MF_CREATED_FRIENDLY;
                spawned++;
            }
        }
        const bool needs_message =
            spawned && mons_near(this) && player_monster_visible(this);
        
        if (needs_message)
        {
            const std::string mname = name(DESC_CAP_THE);
            mprf("%s shudders%s.", mname.c_str(),
                 spawned >= 5 ? " alarmingly" :
                 spawned >= 3 ? " violently" :
                 spawned > 1 ? " vigorously" : "");
            if (spawned == 1)
                mprf("%s spits out another jelly.", mname.c_str());
            else
                mprf("%s spits out %s more jellies.",
                     mname.c_str(),
                     number_in_words(spawned).c_str());
        }
    }

    M_NO_SKELETON | M_SENSE_INVIS | M_ACID_SPLASH,

    M_NO_SKELETON | M_SENSE_INVIS | M_SPECIAL_ABILITY | M_ACID_SPLASH,

    { {AT_HIT, AF_ACID, 50}, AT_NO_ATK, AT_NO_ATK, AT_NO_ATK },
    { 21, 0, 0, 111 },

    { {AT_HIT, AF_ACID, 50}, {AT_HIT, AF_ACID, 30}, AT_NO_ATK, AT_NO_ATK },
    { 21, 0, 0, 230 },

    HT_LAND, 12, DEFAULT_ENERGY, MONUSE_EATS_ITEMS, SIZE_SMALL

    HT_LAND, 16, DEFAULT_ENERGY, MONUSE_EATS_ITEMS, SIZE_SMALL

        player_hurt_monster();

        player_hurt_monster();        

    void react_to_damage(int damage);

cloud_type cloud_type_at(const coord_def &pos);

}
cloud_type cloud_type_at(const coord_def &c)
{
    const int cloudno = env.cgrid(c);
    return (cloudno == EMPTY_CLOUD? CLOUD_NONE : env.cloud[cloudno].type);