Es muy importante recalcar que las profundidades se maneja por "linea de tiempo", es decir, la línea de tiempo principal tiene su "snack" o pila de profundidades, y cada uno de los clips de películas, por tener su propia línea de tiempo independiente, también tienen su propia pila de profundidades.
En otras palabras, si tenemos una película con dos clips de película, tendremos tres pilas de profundidad: la de la línea de tiempo principal y cada una en cada clip de película.
Recuerde que tenemos instancias manuales (hechas, colocadas y nombradas por nosotros, e instancias automticas o dinámicas, hechas, colocadas y nombradas por medio de "attachMovieClip" o por "duplicateMoviClip", en cualquiera de sus variaciones.
Como se vieron en los ejemplos anteriores, al momento de crear dinámicamente una instancia, le asignamos una profundidad. Dicha profundidad es un número entero que puede ir de 0 a 1,048,575.
Flash asigna un número a las instancias manuales que inicia en el -16384, por lo una línea de tiempo puede tener 1,064,960 niveles.
Para administrar la pila o "stack" de profundidades contamos con los siguientes métodos (que veremos a detalle más adelante en esta sección):
Método Disponibilidad
mc.getNextHighestDepth() Flash Player 7
mc.getInstanceAtDepth() Flash Player 7
mc.getDepth() Flash Player 6
mc.swapDepths() Flash Player 5
Un clip de película con un nivel superior aparecerá arriba de un clip de película con una profundidad menor. Es decir, el clip de película con profundidad 2 aparece sobre el de profundidad 1.
Ejemplo: En una película en blanco dibuje un pequeño círculo y con la tecla F8 conviértalo en una Clip de Película. Nombrelo "bola". En el panel de propiedades nombre a la instancia como "bola".
Edite el clip con boble clic. En la parte superior derecha cree un pequeño texto dinámico, y nómbrelo "texto".
/**************************************************
Ejercicio 1 para verificar las profundidades de los
clip de película.
**************************************************/
bola.texto.text = "Manual"; //Nombramos al clip original como "manual"
x = _root.bola._x + 10; //Copiamos la coordenada "x" del clip original
y = _root.bola._y + 10; //Copiamos la coordenada "y" del clip original
/**************************************************
Duplicamos 25 veces al clip original
**************************************************/
for(i=0; i<25; i++) {
//Note que la profundiad va del 0 al 24
duplicateMovieClip("bola", "bola"+i, i);
//Variamos las coordenadas para que no se encimen los clips
mc = _root["bola"+i];
mc._x = x + i * 10;
mc._y = y + i * 10;
//Copiamos la profundiad al texto
mc.texto.text = i;
}
Observe que la instancia hecha de forma manual aparece debajo de la primer instancia creada de forma dinámica, en este caso, la de nivel 0, y así de forma simultánea hasta la última.
Recuerde que solo se puede tener uno y solo un clip de película por nivel, por lo que si asignamos el mismo nivel a dos clips de películas, el nuevo clip sustituye al existente previamente.
Método mc.getNextHighestDepth()
Este método nos da la siguiente profundidad o nivel disponible en la pila de la línea de tiempo. Este método funciona para el Flash Player 7, así que si su aplicación va a correr en un Player anterior, no funcionará.
Para una asignación automática, deberá teclear el siguiente código:
/**************************************************
Ejercicio 02 para verificar las profundidades de los
clip de película.
Uso del método mc.getNextHighestDepth()
**************************************************/
bola.texto.text = "Manual"; //Nombramos al clip original como "manual"
x = _root.bola._x + 10; //Copiamos la coordenada "x" del clip original
y = _root.bola._y + 10; //Copiamos la coordenada "y" del clip original
/**************************************************
Duplicamos 25 veces al clip original
**************************************************/
for(i=0; i<25; i++) {
//Note ahora que la profundiad va del 1 al 25
//con el método mc.getNextHighestDepth()
duplicateMovieClip("bola", "bola"+i, _root.getNextHighestDepth());
//Variamos las coordenadas para que no se encimen los clips
mc = _root["bola"+i];
mc._x = x + i * 10;
mc._y = y + i * 10;
//Copiamos la profundiad al texto
//Vaciamos el contenido del método _root.getNextHighestDepth()
mc.texto.text = "Nivel "+_root.getNextHighestDepth();
}
El método mc.getDepth()
Este método está disponible desde el Flash Player 6, Su funcionalidad es indicarnos la profundidad del clip de película regresándonos un número entero. Su sintaxis es:
clipdePelicula.getDepth()
En nuestro ejemplo, sustituyamos este método para la etiqueta de la profundidad:
/**************************************************
Ejercicio 03 para verificar las profundidades de los
clip de película.
Uso del método mc.getDepth()
**************************************************/
bola.texto.text = "Manual "+bola.getDepth(); //Profundidad -16383
x = _root.bola._x + 10; //Copiamos la coordenada "x" del clip original
y = _root.bola._y + 10; //Copiamos la coordenada "y" del clip original
/**************************************************
Duplicamos 25 veces al clip original
**************************************************/
for(i=0; i<25; i++) {
//Note ahora que la profundiad va del 1 al 25
//con el método mc.getNextHighestDepth()
duplicateMovieClip("bola", "bola"+i, _root.getNextHighestDepth());
//Variamos las coordenadas para que no se encimen los clips
mc = _root["bola"+i];
mc._x = x + i * 10;
mc._y = y + i * 10;
//Copiamos la profundiad al texto
//Vaciamos el contenido del método _root.getNextHighestDepth()
mc.texto.text = "Nivel "+mc.getDepth();
}
Observe que el clip de película hecha de forma manual tiene la profanidad -16383, y las creadas de forma automática, inician en la profundidad "0".
El método mc.getInstanceAtDepth()
Este método está disponible desde el Flash Player 7, por lo que si su aplicación corre en un Player anterior, no va a funcionar.
Con este método extraemos el clip de película que ocupa determinada profundidad. Su sintaxis es:
clipdePelicula.getInstanceAtDepth(nivel)
Por ejemplo, hagamos un ciclo para verificar este método:
/**************************************************
Ejercicio 04 para verificar las profundidades de los
clip de película.
Uso del método mc.getInstanceAtDepth()
**************************************************/
bola.texto.text = "Manual "+bola.getDepth();
x = _root.bola._x + 10; //Copiamos la coordenada "x" del clip original
y = _root.bola._y + 10; //Copiamos la coordenada "y" del clip original
/**************************************************
Duplicamos 25 veces al clip original
**************************************************/
for(i=0; i<25; i++) {
//Note ahora que la profundiad va del 1 al 25
//con el método mc.getNextHighestDepth()
duplicateMovieClip("bola", "bola"+i, _root.getNextHighestDepth());
//Variamos las coordenadas para que no se encimen los clips
mc = _root["bola"+i];
mc._x = x + i * 10;
mc._y = y + i * 10;
//Copiamos la profundiad al texto
//Vaciamos el contenido del método _root.getNextHighestDepth()
mc.texto.text = "Nivel "+mc.getDepth();
}
/*****************************************************
Usamos un ciclo hasta 30 para revisar el método
mc.getInstanceAtDepth()
******************************************************/
for(i=0; i<30; i++){
trace("En la profundiad "+i+" está el clip "+_root.getInstanceAtDepth(i));
}
