unsigned const char branch = (unsigned char) ((place >> 8) & 0xFF);

    const unsigned char branch = (unsigned char) ((place >> 8) & 0xFF);

        monster_level=branches[(int)you.where_are_you].mons_level_function(mcls);

        monster_level = your_branch().mons_level_function(mcls);

        return branches[(int)you.where_are_you].mons_rarity_function(mcls);

        return your_branch().mons_rarity_function(mcls);

        int prob = branches[(int)you.where_are_you].altar_chance;

        int prob = your_branch().altar_chance;

    if ( branches[(int)you.where_are_you].exit_stairs != NUM_FEATURES &&

    if ( your_branch().exit_stairs != NUM_FEATURES &&

                    grd[x][y] = branches[(int)you.where_are_you].exit_stairs;

                    grd[x][y] = your_branch().exit_stairs;

    if ( player_branch_depth() == branches[(int)you.where_are_you].depth &&

    if ( player_branch_depth() == your_branch().depth &&

    // been hooked up already in roguey_level()

    // been hooked up already in roguey_level())

    if ( branches[(int)you.where_are_you].has_shops )

    if ( your_branch().has_shops )

    if (player_in_branch( BRANCH_CRYPT ))
    {
        if (one_chance_in(3))
            mons_place( MONS_CURSE_SKULL, BEH_SLEEP, MHITNOT, false, 0, 0 );
        if (one_chance_in(7))
            mons_place( MONS_CURSE_SKULL, BEH_SLEEP, MHITNOT, false, 0, 0 );
    }

    if (subdepth == branches[(int)you.where_are_you].depth)

    if (subdepth == your_branch().depth)

// returns 1 if we should skip further generation,
// -1 if we should immediately quit, and 0 otherwise.

// returns BUILD_SKIP if we should skip further generation,
// BUILD_QUIT if we should immediately quit, and BUILD_CONTINUE
// otherwise.

    case BRANCH_LAIR:
        if (!one_chance_in(3))
            break;

        spotty_level(false, 100 + random2(500), false);
        return BUILD_SKIP;

        spotty_level(false, 100 + random2(500), false);
        return BUILD_SKIP;

    case BRANCH_LAIR:
        if (!one_chance_in(3))
        {
            spotty_level(false, 100 + random2(500), false);
            return BUILD_SKIP;
        }
        break;

static void builder_monsters(int level_number, char level_type, int mon_wanted)

// Place uniques on the level.
// There is a hidden dependency on the player's actual
// location (through your_branch().)
// Return the number of uniques placed.
static int place_uniques(int level_number, char level_type)

    int i = 0;
    int totalplaced = 0;

    int x,y;
    int lava_spaces, water_spaces;
    int aq_creatures;
    int swimming_things[4];

    // Unique beasties:
    if (level_number <= 0 || level_type != LEVEL_DUNGEON ||
        !your_branch().has_uniques)
        return 0;

    if (level_type == LEVEL_PANDEMONIUM 
            || player_in_branch(BRANCH_ECUMENICAL_TEMPLE))
        return;

    int num_placed = 0;

    for (i = 0; i < mon_wanted; i++)

    while(one_chance_in(3))

        if (place_monster( not_used, RANDOM_MONSTER, level_number, BEH_SLEEP,
                           MHITNOT, false, 1, 1, true, PROX_ANYWHERE, 250, 0,
                           no_monster_zones ))

        int which_unique = -1;   //     30 in total
        while(which_unique < 0 || you.unique_creatures[which_unique])

            totalplaced++;

            // sometimes, we just quit if a unique is already placed.
            if (which_unique >= 0 && !one_chance_in(3))
            {
                which_unique = -1;
                break;
            }
            which_unique = pick_unique(level_number);
        }
        // usually, we'll have quit after a few tries. Make sure we don't
        // create unique[-1] by accident.
        if (which_unique == -1)
            break;
        // note: unique_creatures 40 + used by unique demons
        if (place_monster( not_used, which_unique, level_number, 
                           BEH_SLEEP, MHITNOT, false, 1, 1, true,
                           PROX_ANYWHERE, 250, 0, no_monster_zones ))
        {
            ++num_placed;

    return num_placed;
}

    // Unique beasties:
    if (level_number > 0
        && you.level_type == LEVEL_DUNGEON  // avoid generating on temp levels
        && branches[(int)you.where_are_you].has_uniques)

static int place_monster_vector(int* montypes, int numtypes,
                                int level_number, int num_to_place)
{
    int result = 0;
    int not_used = 0;
    for (int i = 0; i < num_to_place; i++)

        while(one_chance_in(3))

        if (place_monster( not_used, montypes[random2(numtypes)],
                           level_number, BEH_SLEEP, MHITNOT, 
                           false, 1, 1, true, PROX_ANYWHERE, 250, 0,
                           no_monster_zones ))

            int which_unique = -1;   //     30 in total
            while(which_unique < 0 || you.unique_creatures[which_unique])
            {
                // sometimes, we just quit if a unique is already placed.
                if (which_unique >= 0 && !one_chance_in(3))
                {
                    which_unique = -1;
                    break;
                }
                which_unique = pick_unique(level_number);
            }
            // usually, we'll have quit after a few tries. Make sure we don't
            // create unique[-1] by accident.
            if (which_unique == -1)
                break;
            // note: unique_creatures 40 + used by unique demons
            if (place_monster( not_used, which_unique, level_number, 
                               BEH_SLEEP, MHITNOT, false, 1, 1, true,
                               PROX_ANYWHERE, 250, 0, no_monster_zones ))
            {
                totalplaced++;
            }

            ++result;

    return result;
}
                                

    // do aquatic and lava monsters:

static void place_aquatic_monsters(int level_number, char level_type)
{
    int lava_spaces = 0, water_spaces = 0;
    int swimming_things[4];

    lava_spaces = 0;
    water_spaces = 0;
    for (x = 0; x < GXM; x++)

    for (int x = 0; x < GXM; x++)

        for (y = 0; y < GYM; y++)

        for (int y = 0; y < GYM; y++)

            if (grd[x][y] == DNGN_LAVA && level_number > 6)
            {

            if (grd[x][y] == DNGN_LAVA)

            }
            else if (grd[x][y] == DNGN_DEEP_WATER
                     || grd[x][y] == DNGN_SHALLOW_WATER)
            {

            if (grd[x][y]==DNGN_DEEP_WATER || grd[x][y]==DNGN_SHALLOW_WATER)

            }

    if (lava_spaces > 49)

    if (lava_spaces > 49 && level_number > 6)

        for (i = 0; i < 4; i++)

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

            //mv: this is really ugly, but easiest
            //IMO generation of water/lava beasts should be changed,
            //because we want data driven code and not things like it

        aq_creatures = random2avg(9, 2) + (random2(lava_spaces) / 10);
        if (aq_creatures > 15)
            aq_creatures = 15;
        for (i = 0; i < aq_creatures; i++)
        {
            if (place_monster( not_used, swimming_things[ random2(4) ],
                               level_number, BEH_SLEEP, MHITNOT, 
                               false, 1, 1, true, PROX_ANYWHERE, 250, 0,
                               no_monster_zones ))
            {
                totalplaced++;
            }
            if (totalplaced > 99)
                break;
        }

        place_monster_vector(swimming_things, 4, level_number,
                             std::min(random2avg(9, 2) +
                                      (random2(lava_spaces) / 10), 15));

        for (i = 0; i < 4; i++)

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

            // mixing enums and math ticks me off !!! 15jan2000 {dlb}

            // swamp worms and h2o elementals generated below: {dlb}

        place_monster_vector(swimming_things, 4, level_number,
                             std::min(random2avg(9, 2) +
                                      (random2(water_spaces) / 10), 15));
    }
}

        aq_creatures = random2avg(9, 2) + (random2(water_spaces) / 10);

static void builder_monsters(int level_number, char level_type, int mon_wanted)
{
    int not_used = 0;
    if (level_type == LEVEL_PANDEMONIUM ||
        player_in_branch(BRANCH_ECUMENICAL_TEMPLE))
        return;
    for (int i = 0; i < mon_wanted; i++)
        place_monster( not_used, RANDOM_MONSTER, level_number, BEH_SLEEP,
                       MHITNOT, false, 1, 1, true, PROX_ANYWHERE, 250, 0,
                       no_monster_zones );

        if (aq_creatures > 15)
            aq_creatures = 15;

    place_uniques(level_number, level_type);
    place_aquatic_monsters(level_number, level_type);

        for (i = 0; i < aq_creatures; i++)
        {
            if (place_monster( not_used, swimming_things[ random2(4) ],
                               level_number, BEH_SLEEP, MHITNOT, 
                               false, 1, 1, true, PROX_ANYWHERE, 250, 0,
                               no_monster_zones ))
            {
                totalplaced++;
            }

    // Special handling
    if (player_in_branch( BRANCH_CRYPT ))
    {
        if (one_chance_in(3))
            mons_place( MONS_CURSE_SKULL, BEH_SLEEP, MHITNOT, false, 0, 0 );

            if (totalplaced > 99)
                break;
        }

        if (one_chance_in(7))
            mons_place( MONS_CURSE_SKULL, BEH_SLEEP, MHITNOT, false, 0, 0 );

Branch& your_branch();

#include "externs.h"

Branch& your_branch()
{
    return branches[static_cast<int>(you.where_are_you)];
}