static bool _is_native_in_branch(const monsters *monster,
                                 const branch_type branch);

        return (_is_native_in_branch(mon, BRANCH_ORCISH_MINES));

        return (mons_is_native_in_branch(mon, BRANCH_ORCISH_MINES));

        return (_is_native_in_branch(mon, BRANCH_ELVEN_HALLS));

        return (mons_is_native_in_branch(mon, BRANCH_ELVEN_HALLS));

        return (_is_native_in_branch(mon, BRANCH_HIVE));

        return (mons_is_native_in_branch(mon, BRANCH_HIVE));

// Returns true for monsters that obviously (to the player) feel
// "thematically at home" in a branch.  Currently used for native
// monsters recognizing traps and patrolling branch entrances.
static bool _is_native_in_branch(const monsters *monster,
                                 const branch_type branch)
{
    switch (branch)
    {
    case BRANCH_ELVEN_HALLS:
        return (mons_species(monster->type) == MONS_ELF);
    case BRANCH_ORCISH_MINES:
        return (mons_species(monster->type) == MONS_ORC);
    case BRANCH_SHOALS:
        return (mons_species(monster->type) == MONS_CYCLOPS
                || mons_species(monster->type) == MONS_MERFOLK
                || mons_species(monster->type) == MONS_MERMAID);
    case BRANCH_SLIME_PITS:
        return (mons_species(monster->type) == MONS_JELLY);
    case BRANCH_SNAKE_PIT:
        return (mons_species(monster->type) == MONS_NAGA
                || mons_species(monster->type) == MONS_SNAKE);
    case BRANCH_HALL_OF_ZOT:
        return (mons_species(monster->type) == MONS_DRACONIAN);
    case BRANCH_TOMB:
        return (mons_species(monster->type) == MONS_MUMMY);
    case BRANCH_HIVE:
        return (monster->type == MONS_KILLER_BEE_LARVA
                || monster->type == MONS_KILLER_BEE
                || monster->type == MONS_QUEEN_BEE);
    case BRANCH_HALL_OF_BLADES:
        return (monster->type == MONS_DANCING_WEAPON);
    default:
        return false;
    }
}
// randomize potential damage

// Randomize potential damage.

        && (_is_native_in_branch(monster, you.where_are_you)

        && (mons_is_native_in_branch(monster, you.where_are_you)

            return false; // square is blocked

            return (false); // Square is blocked.

            // test for corridor-like environment

            // Test for corridor-like environment.

        return true;

        return (true);

    menv[id].attitude = ATT_HOSTILE;

    menv[id].attitude  = ATT_HOSTILE;

        return (false);
    // Monsters that can't open doors, won't be able to pass them.
    if ((grd(p) == DNGN_CLOSED_DOOR || grd(p) == DNGN_SECRET_DOOR)
        && mons_itemuse(montype) < MONUSE_OPEN_DOORS)

//        mprf("Feature %d is not a habitable grid.", grd(p));

        return (false);
    }
    // Your friends only know about doors you know about, unless they feel
    // at home in this branch.
    if (grd(p) == DNGN_SECRET_DOOR && mons_friendly(mons)
        && (mons_intel(mons->type) < I_NORMAL
            || !mons_is_native_in_branch(mons, you.where_are_you)))
    {

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

//        mpr("There's a trap here!");
        if (!_can_place_on_trap(montype, env.trap[trap].type))

        trap_type tt = env.trap[trap].type;
        if (tt == TRAP_ZOT && grd(p) != DNGN_UNDISCOVERED_TRAP
            && mons_friendly(mons))

//            mpr("Monster can't be placed on trap.");

        // Monsters cannot travel over teleport traps.
        if (!_can_place_on_trap(montype, tt))
            return (false);

//    mprf("Grid (%d, %d) is traversable.", p.x, p.y);

// Assumes that grids that really cannot be entered don't even get here.
// (Checked by traversable().)

    // Doors need to be opened.
    if (grd(npos) == DNGN_CLOSED_DOOR || grd(npos) == DNGN_SECRET_DOOR)
        return 2;

    // TODO: Make traps/shallow water more expensive, etc.

    // Moving from floor to water (or vice versa) is a bit more expensive.
    // The deep water checks are only done in case of amphibious monsters.
    if ((grd(pos) == DNGN_SHALLOW_WATER || grd(pos) == DNGN_DEEP_WATER)
           && grid_compatible(grd(npos), DNGN_FLOOR)
        || (grd(npos) == DNGN_SHALLOW_WATER || grd(npos) == DNGN_DEEP_WATER)
           && grid_compatible(grd(pos), DNGN_FLOOR))
    {
        return 2;
    }
    // Try to avoid (known) traps.
    //
    const int trap = trap_at_xy(npos.x, npos.y);
    if (trap >= 0)
    {
        // A monster can be considered to know a trap if
        // a) they're hostile
        // b) they're friendly and *you* know about the trap (and told them)
        // c) they're friendly and know the terrain
        bool knows_trap = (!mons_friendly(mons)
                           || grd(npos) != DNGN_UNDISCOVERED_TRAP
                           || mons_intel(mons->type) >= I_NORMAL
                              && mons_is_native_in_branch(mons,
                                                          you.where_are_you));
        trap_type tt = env.trap[trap].type;
        if (tt == TRAP_ALARM || tt == TRAP_ZOT)
        {
            // Your allies take extra precautions to avoid known alarm traps.
            if (knows_trap && mons_friendly(mons))
                return (3);
            // To hostile monsters, these traps are completely harmless.
            return 1;
        }
        if (knows_trap)
        {
            const int montype = mons_is_zombified(mons) ? mons_zombie_base(mons)
                                                        : mons->type;
            // Mechanical traps can be avoided by flying, as can shafts, and
            // tele traps are never traversable anyway.
            if (!_mons_airborne(montype, -1, false))
                return 2;
        }
        return 1;
    }

bool mons_is_native_in_branch(const monsters *monster,
                              const branch_type branch);

}
// Returns true for monsters that obviously (to the player) feel
// "thematically at home" in a branch.  Currently used for native
// monsters recognizing traps and patrolling branch entrances.
bool mons_is_native_in_branch(const monsters *monster,
                              const branch_type branch)
{
    switch (branch)
    {
    case BRANCH_ELVEN_HALLS:
        return (mons_species(monster->type) == MONS_ELF);
    case BRANCH_ORCISH_MINES:
        return (mons_species(monster->type) == MONS_ORC);
    case BRANCH_SHOALS:
        return (mons_species(monster->type) == MONS_CYCLOPS
                || mons_species(monster->type) == MONS_MERFOLK
                || mons_species(monster->type) == MONS_MERMAID);
    case BRANCH_SLIME_PITS:
        return (mons_species(monster->type) == MONS_JELLY);
    case BRANCH_SNAKE_PIT:
        return (mons_species(monster->type) == MONS_NAGA
                || mons_species(monster->type) == MONS_SNAKE);
    case BRANCH_HALL_OF_ZOT:
        return (mons_species(monster->type) == MONS_DRACONIAN);
    case BRANCH_TOMB:
        return (mons_species(monster->type) == MONS_MUMMY);
    case BRANCH_HIVE:
        return (monster->type == MONS_KILLER_BEE_LARVA
                || monster->type == MONS_KILLER_BEE
                || monster->type == MONS_QUEEN_BEE);
    case BRANCH_HALL_OF_BLADES:
        return (monster->type == MONS_DANCING_WEAPON);
    default:
        return (false);
    }

        mg.behaviour = BEH_SLEEP;

    if ( !player_in_branch(BRANCH_CRYPT) ) // no water creatures in the Crypt

    if ( !player_in_branch(BRANCH_CRYPT) ) // No water creatures in the Crypt.

    // first, set base tile for grids {dlb}:

    // First, set base tile for grids {dlb}: