// If in a labyrinth, always teleport well away from the centre.
        // (Check done for the straight line, no pathfinding involved.)
        bool need_distance_check = false;
        coord_def centre;
        if (you.level_type == LEVEL_LABYRINTH)
        {
            bool success = false;
            for (int xpos = 0; xpos < GXM; xpos++)
            {
                for (int ypos = 0; ypos < GYM; ypos++)
                {
                    centre = coord_def(xpos, ypos);
                    if (!in_bounds(centre))
                        continue;

                    if (grd(centre) == DNGN_ESCAPE_HATCH_UP)
                    {
                        success = true;
                        break;
                    }
                }
                if (success)
                    break;
            }
            need_distance_check = success;
        }

               || env.cgrid(newpos) != EMPTY_CLOUD);

               || env.cgrid(newpos) != EMPTY_CLOUD
               || need_distance_check && (newpos - centre).abs() < 34*34);

bool player_wearing_slot( int eq );

}
bool player_wearing_slot(int eq)
{
    if (you.equip[eq] == -1)
        return (false);
    return (you_tran_can_wear(you.inv[you.equip[eq]]));

        if (you.equip[i] == -1 || !you_tran_can_wear(you.equip[i]))

        if (!player_wearing_slot(i))

        const int eq = you.equip[i];
        if (eq == -1 || !you_tran_can_wear(eq))

        if (!player_wearing_slot(i))

        const int eq = you.equip[i];

static void item_corrode( int itco );

static void _item_corrode( int itco );

    const bool wearing_cloak = (you.equip[EQ_CLOAK] != -1);

    const bool wearing_cloak = player_wearing_slot(EQ_CLOAK);

        if (you.equip[splc] == -1)

        if (!player_wearing_slot(splc))

            item_corrode( you.equip[splc] );

            _item_corrode( you.equip[splc] );

    if (hand_thing == -1)

    if (hand_thing == -1 && you_tran_can_wear(EQ_GLOVES, true))

        item_corrode( hand_thing );

        _item_corrode( hand_thing );

void item_corrode( int itco )

void _item_corrode( int itco )

                && !one_chance_in(5))

                 && !one_chance_in(5))

        // the embedded equation may look funny, but it actually works well

        // The embedded equation may look funny, but it actually works well

}

    return;
}                               // end item_corrode()

//    if (you.level_type == LEVEL_LABYRINTH)
//        forget_map(you.species == SP_MINOTAUR ? 12 : 25);

// Checks whether a given grid has at least one neighbour surrounded
// entirely by non-floor.
static bool _has_no_floor_neighbours(const coord_def &pos, bool recurse = false)
{
    for (int x = -1; x <= 1; x++)
        for (int y = -1; y <= 1; y++)
        {
            if (x == 0 && y == 0)
                continue;
            const coord_def p = pos + coord_def(x, y);
            if (!in_bounds(p))
                return (true);
            if (recurse)
            {
                if (grd(p) == DNGN_FLOOR)
                    return (false);
            }
            else if (_has_no_floor_neighbours(p, true))
                return (true);
        }
    return (recurse);
}
// Change the borders of the labyrinth to another (undiggable) wall type.
static void _change_labyrinth_border(const dgn_region &region,
                                     const dungeon_feature_type wall)
{
    const coord_def &end = region.pos + region.size;
    for (int y = region.pos.y-1; y <= end.y; ++y)
        for (int x = region.pos.x-1; x <= end.x; ++x)
        {
            const coord_def c(x, y);
            if (!in_bounds(c)) // paranoia
                continue;
            if (grd(c) == wall || !grid_is_wall(grd(c)))
                continue;
            // All border grids have neighbours without any access to floor.
            if (_has_no_floor_neighbours(c))
                grd[x][y] = wall;
        }
}

    _change_labyrinth_border(lab, DNGN_METAL_WALL);