if (!force
        && (!you.turn_is_over || random2(30) < you.skills[SK_STEALTH]))
    {

    if (!force && (!you.turn_is_over || random2(30) < you.skills[SK_STEALTH]))
        return;
    // Friendly or neutral monsters don't shout.
    if (!force && (mons_friendly(monster) || mons_neutral(monster)))

    }

    const shout_type type = mons_shouts(monster->type);

    shout_type  s_type = mons_shouts(monster->type, false);

    if (!force && (mons_friendly(monster) || mons_neutral(monster))
        || (type == S_SILENT && !player_monster_visible(monster))
        || (type != S_SILENT && (silenced(you.x_pos, you.y_pos)
                                 || silenced(monster->x, monster->y))))

    if (s_type == S_SILENT && !player_monster_visible(monster)
        || s_type != S_SILENT && (silenced(you.x_pos, you.y_pos)
                                  || silenced(monster->x, monster->y)))

    int         noise_level = get_shout_noise_level(type);
    std::string default_msg_key;

    std::string default_msg_key = "";

    switch (type)

    switch (s_type)

    case NUM_SHOUTS:
    case S_RANDOM:
        default_msg_key = "__BUGGY";

    case S_SILENT:
        // No default message.

    case S_DEMON_TAUNT:
        default_msg_key = "__DEMON_TAUNT";
        break;

        default_msg_key = "";

        default_msg_key = "__BUGGY";

    // Use get_monster_data(monster->type) to bypass mon_shouts()
    // replacing S_RANDOM with a random value.
    if (mons_is_demon( monster->type ) && coinflip()
        && (type != S_SILENT ||
            get_monster_data(monster->type)->shouts == S_RANDOM))
    {
        noise_level     = 8;
        default_msg_key = "__DEMON_TAUNT";
    }

    // Now that we have the message key, get a random verb and noise level
    // for pandemonium lords.
    if (s_type == S_DEMON_TAUNT)
        s_type = mons_shouts(monster->type, true);

    {

    else if ((msg == "" || msg == "__NONE")
             && mons_shouts(monster->type) == S_SILENT)

    }
    else if (s_type == S_SILENT && (msg == "" || msg == "__NONE"))
    {

    }

        msg = do_mon_str_replacements(msg, monster);

        msg = do_mon_str_replacements(msg, monster, s_type);

        if (mons_shouts(monster->type) == S_SILENT || param == "VISUAL")

        if (s_type == S_SILENT || param == "VISUAL")

    const int noise_level = get_shout_noise_level(s_type);

// returns 0 if the point is not near stairs
// returns 1 if the point is near unoccupied stairs
// returns 2 if the point is near player-occupied stairs

// Returns 0 if the point is not near stairs.
// Returns 1 if the point is near unoccupied stairs.
// Returns 2 if the point is near player-occupied stairs.

                // shouldn't happen for escape hatches

                // Shouldn't happen for escape hatches.

                // is it a branch stair?

                // Is it a branch stair?

// returns true if something is said

// Returns true if something is said.

    {

    }

    {

    }

    // (2) take care of non-drac random monsters

    // (2) Take care of non-draconian random monsters.

                // don't generate monsters on top of teleport traps

                // Don't generate monsters on top of teleport traps.

                       continue;

                        continue;

                // check whether there's a stair
                // and whether it leads to another branch
                pval = near_stairs(pos, 1,
                                   *stair_type, place.branch);

                // Check whether there's a stair
                // and whether it leads to another branch.
                pval = near_stairs(pos, 1, *stair_type, place.branch);

                // no monsters spawned in the Temple

                // No monsters spawned in the Temple.

                // found a position near the stairs!

                // Found a position near the stairs!

            {   // give up and try somewhere else

            {
                // Give up and try somewhere else.

                    // monsters don't come from outside the dungeon

                    // Monsters don't come from outside the dungeon.

                        // in that case lev_mons stays as it is

                        // In that case lev_mons stays as it is.

            // now pick a monster of the given branch and level

            // Now pick a monster of the given branch and level.

// A short function to check the results of near_stairs().
// Returns 0 if the point is not near stairs.
// Returns 1 if the point is near unoccupied stairs.
// Returns 2 if the point is near player-occupied stairs.
static int _is_near_stairs(coord_def &p)
{
    int result = 0;
    for (int i = -1; i <= 1; i++)
        for (int j = -1; j <= 1; j++)
        {
            if (!in_bounds(p))
                continue;
            const dungeon_feature_type feat = grd(p);
            if (is_stair(feat))
            {
                // Shouldn't matter for escape hatches.
                if (grid_is_escape_hatch(feat))
                    continue;
                // Should there be several stairs, don't overwrite the
                // player on stairs info.
                if (result < 2)
                    result = (p == you.pos()? 2 : 1);
            }
        }
    return result;
}

    int pval = 0;

    // (1) early out (summoned to occupied grid)

    // (1) Early out (summoned to occupied grid).

    mg.cls =
        resolve_monster_type(mg.cls, mg.proximity, mg.base_type,
                             mg.pos, mg.map_mask,
                             &stair_type, &mg.power);

    mg.cls = resolve_monster_type(mg.cls, mg.proximity, mg.base_type,
                                  mg.pos, mg.map_mask,
                                  &stair_type, &mg.power);

    // (3) decide on banding (good lord!)

    // (3) Decide on banding (good lord!)

    // Returns 2 if the monster is placed near player-occupied stairs.
    int pval = _is_near_stairs(mg.pos);

        // for some cases disallow monsters on stairs

        // For some cases disallow monsters on stairs.

            || (pval == 2

            || (pval == 2 // Stairs occupied by player.

    // (4) for first monster, choose location.  This is pretty intensive.

    // (4) For first monster, choose location.  This is pretty intensive.

    // player shoved out of the way?

    // Player shoved out of the way?

        // try to pick px, py that is

        // Try to pick px, py that is

            // placement already decided for PROX_NEAR_STAIRS

            // Placement already decided for PROX_NEAR_STAIRS.

            // don't generate monsters on top of teleport traps
            // (how did they get there?)

            // Don't generate monsters on top of teleport traps.
            // (How did they get there?)

            // check proximity to player

            // Check proximity to player.

                    // swap the monster and the player spots, unless the

                    // Swap the monster and the player spots, unless the

                    if (grd(mg.pos) == DNGN_LAVA ||
                        grd(mg.pos) == DNGN_DEEP_WATER)

                    if (grd(mg.pos) == DNGN_LAVA
                        || grd(mg.pos) == DNGN_DEEP_WATER)

    // message to player from stairwell/gate appearance?

    // Message to player from stairwell/gate appearance?

        // special case: must update the view for monsters created in player LOS

        // Special case: must update the view for monsters created
        // in player LOS.

    // now, forget about banding if the first placement failed, or there's too
    // many monsters already, or we successfully placed by stairs

    // Now, forget about banding if the first placement failed, or there are
    // too many monsters already, or we successfully placed by stairs.

    // (5) for each band monster, loop call to place_monster_aux().

    // (5) For each band monster, loop call to place_monster_aux().

        const int band_id =
            _place_monster_aux( band_template, false );

        const int band_id = _place_monster_aux( band_template, false );

    // placement of first monster, at least, was a success.

    // Placement of first monster, at least, was a success.

        mg.cls = pick_zot_exit_defender();

        mg.cls    = pick_zot_exit_defender();

    // translate level_type

    // Translate level_type.

        // make summoned being aware of player's presence

        // Make summoned being aware of player's presence.

    return ((mtype == RANDOM_MONSTER) ? DNGN_FLOOR
            : habitat2grid( mons_habitat_by_type(mtype) ));

    if (mtype == RANDOM_MONSTER)
        return DNGN_FLOOR;
    return habitat2grid( mons_habitat_by_type(mtype) );

    // is surrounded by water of lava this function would work.  -- bwr

    // is surrounded by water or lava this function would work.  -- bwr

    if (!(mg.force_place()
          && in_bounds(mg.pos)
          && mons_class_can_pass(mg.cls, grd(mg.pos))
          && mgrd(mg.pos) == NON_MONSTER
          && mg.pos != you.pos()))

    int type = (mons_class_is_zombified(mg.cls) ? mg.base_type
                                                : mg.cls);
    if (!mg.force_place()
        || !in_bounds(mg.pos)
        || mgrd(mg.pos) != NON_MONSTER
        || mg.pos == you.pos()
        || !mons_class_can_pass(type, grd(mg.pos)))

        mg.pos = find_newmons_square(mg.cls, mg.pos);

        mg.pos = find_newmons_square(type, mg.pos);

    // determine whether creating a monster is successful (summd != -1) {dlb}:
    // then handle the outcome {dlb}:

    // Determine whether creating a monster is successful (summd != -1) {dlb}:
    // then handle the outcome. {dlb}:

    // the return value is either -1 (failure of some sort)
    // or the index of the monster placed (if I read things right) {dlb}

    // The return value is either -1 (failure of some sort)
    // or the index of the monster placed (if I read things right). {dlb}

    S_BELLOW,               // bellow (?)

    S_BELLOW,               // bellow (yaks)

    S_WHINE,                // irritating whine (mosquito)

    S_WHINE,                // irritating whine (mosquitos)

    S_DEMON_TAUNT,          // for pandemonium lords
    NUM_SHOUTS,

    NUM_SHOUTS,

    NUM_LOUDNESS,

shout_type mons_shouts(int mclass);

shout_type mons_shouts(int mclass, bool demon_shout = false);

                                    const monsters* monster);

                                    const monsters* monster, int s_type = -1);

enum mon_body_shape {

enum mon_body_shape
{

// Only the beast uses S_RANDOM for noise type.
// Pandemonium lords can also get here but they can use almost anything.
static bool _shout_fits_monster(int type, int shout)
{
    if (shout == NUM_SHOUTS || shout >= NUM_LOUDNESS)
        return (false);

shout_type mons_shouts(int mc)

    // For demon lords almost everything is fair game.
    // It's only used for the shouting verb ("say", "whine", "roar", ...)
    // anyway.
    if (type != MONS_BEAST)
        return (shout != S_BUZZ && shout != S_WHINE);
    switch (shout)
    {
    // 2-headed ogres, bees or mosquitos never fit.
    case S_SHOUT2:
    case S_BUZZ:
    case S_WHINE:
    // The beast cannot speak.
    case S_DEMON_TAUNT:
    // Silent is boring.
    case S_SILENT:
        return (false);
    default:
        return (true);
    }
}
// If demon_shout is true, we're trying to find a random loudness for
// a pandemonium lord trying to shout.
shout_type mons_shouts(int mc, bool demon_shout)

    if (u == S_RANDOM)
        u = static_cast<shout_type>(random2(NUM_SHOUTS));

    // Pandemonium lords use this to get the noises.
    if (u == S_RANDOM || demon_shout && u == S_DEMON_TAUNT)
    {
        const int max_shout = (u == S_RANDOM ? NUM_SHOUTS : NUM_LOUDNESS);
        do
        {
            u = static_cast<shout_type>(random2(max_shout));
        }
        while (!_shout_fits_monster(mc, u));
    }

                                    const monsters* monster)

                                    const monsters* monster, int s_type)

    // replace with "you are" for atheists

    // Replace with "you are" for atheists.

    // replace with species specific insults

    // Replace with species specific insults.

        "breathes", // S_VERY_SOFT
        "whispers", // S_SOFT
        "says",     // S_NORMAL
        "shouts",   // S_LOUD
        "screams"   // S_VERY_LOUD

        "sneers",       // S_DEMON_TAUNT
        "buggily says", // NUM_SHOUTS
        "breathes",     // S_VERY_SOFT
        "whispers",     // S_SOFT
        "says",         // S_NORMAL
        "shouts",       // S_LOUD
        "screams"       // S_VERY_LOUD

    if (mons_shouts(monster->type) >= NUM_SHOUTS)

    if (s_type < 0 || s_type >= NUM_LOUDNESS || s_type == NUM_SHOUTS)
        s_type = mons_shouts(monster->type);
    if (s_type < 0 || s_type >= NUM_LOUDNESS || s_type == NUM_SHOUTS)

        msg = replace_all(msg, "@says@",
                          sound_list[mons_shouts(monster->type)]);

    {
        msg = replace_all(msg, "@says@", sound_list[s_type]);
    }

    1, 2, MST_GHOST, CE_NOCORPSE, Z_NOZOMBIE, S_RANDOM, I_HIGH,

    1, 2, MST_GHOST, CE_NOCORPSE, Z_NOZOMBIE, S_DEMON_TAUNT, I_HIGH,

    {

    }

        mspec.fix_mons = strip_tag(mon_str, "fix_mons");

        mspec.fix_mons       = strip_tag(mon_str, "fix_mons");

        mspec.patrolling = strip_tag(mon_str, "patrolling");

        mspec.patrolling     = strip_tag(mon_str, "patrolling");

            mspec.mid = nspec.mid;

            mspec.mid     = nspec.mid;

            mspec.number = nspec.number;

            mspec.number  = nspec.number;

    {
        { MONS_PROGRAM_BUG, MONS_PROGRAM_BUG },
        { MONS_ZOMBIE_SMALL, MONS_ZOMBIE_LARGE },
        { MONS_SKELETON_SMALL, MONS_SKELETON_LARGE },

    {     // small               // large
        { MONS_PROGRAM_BUG,      MONS_PROGRAM_BUG },
        { MONS_ZOMBIE_SMALL,     MONS_ZOMBIE_LARGE },
        { MONS_SKELETON_SMALL,   MONS_SKELETON_LARGE },

    bool fixup = false;

    bool fixup   = false;

        const int mid = mspec.mid;

        const int  mid = mspec.mid;

            // Don't place a unique monster a second time.
            // (Boris is handled specially.)

            const habitat_type habitat = mons_habitat_by_type(mid);

            const int type = mons_class_is_zombified(mid) ? mspec.monbase
                                                          : mid;
            const habitat_type habitat = mons_habitat_by_type(type);

                    // Override existing markers.
                    env.markers.remove_markers_at(coord_def(i, j), MAT_ANY);

    // mpr("lake");

                {

                    // Override markers. (No underwater portals, please.)
                    env.markers.remove_markers_at(coord_def(i, j), MAT_ANY);
                }

        coord_def place = find_newmons_square(mspec.mid, coord_def(x, y));

        int type = mspec.mid;
        if (mons_class_is_zombified(mspec.mid))
            type = mspec.monbase;
        coord_def place = find_newmons_square(type, coord_def(x, y));

        mpr("Unable to place monster");

        mpr("Unable to place monster.");

    // Need to set a name for the player ghost

    // Need to set a name for the player ghost.

        mpr( "Make player ghost which species? (case-sensitive) ", MSGCH_PROMPT );

        mpr("Make player ghost which species? (case-sensitive) ", MSGCH_PROMPT);