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".
Hemos creado una instancia de forma manual. Ahora la duplicarfemos con el siguiente código en el fotograma 1:
/**************************************************
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));
}
Observe que las últimas profundidades están disponibles, por lo que el método regresa un "undefined".
El método mc.swapDepths()
Este método lo encontramos desde le Flash Player 5. Es muy util cuando necesitamos "encimar" los clips de película y las profundidades lo impiden. Su sintaxis es:
clipdePelicula.swapDepths(profundidad)
clipdePelicula.swapDepths(profundidad)
Hagamos un ciclo para intercambiar las profundidades utilizando este método:
/**************************************************
Ejercicio 05 para verificar las profundidades de los
clip de película.
Uso del método mc.swapDepths()
**************************************************/
bola.texto.text = "Manual "+bola.getDepth(); //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 "+mc.getDepth();
}
/*******************************************************
Una función sencilla para intercambiar las profundidades
********************************************************/
for(i=0; i<50; i++){
random1 = random(24);
random2 = random(24);
mi_mc = _root["bola"+random1];
mi_mc.swapDepths(random2);
mi_mc.texto.text = mi_mc;
}
for(i=0; i<25; i++){
mi_mc = _root["bola"+i];
mi_mc.texto.text = mi_mc + " Nivel "+mi_mc.getDepth();
}
Note que los clips de película siguen apareciendo en el mismo orden (bola0, bola1, etc). Lo que cambiamos fueron las profundidades, por lo se enciman unos sobre otros, Verifique y siempre los niveles mayores se enciman sobre los menores.
Por último verificaremos que las profundidades dependen de las líneas de tiempo, por lo que si tenemos dos clips de película, en la película tendremos tres líneas de tiempo (sumando la línea de tiempo principal), cada una de ellas con su propia pila de profundidades.
Por ejemplo, digamos que tenemos una película con dos clips de película, y en cada uno de ellos duplicamos un clip de película. Podemos tener una profundidad de 10 en ambas líneas de tiempo.
Si hacemos dos instancias, podemos colocar el siguiente código EN LA LINEA DE TIEMPO de cada clip (Las mayúsculas porque el código dentro del clip mandarái error).
y = _root.bola1._y;
x = _root.bola1._x;
for(i=0; i<5; i++){
mi_mc = bolaAzul.duplicateMovieClip("bola1"+i,10+i);
mi_mc._y = i * 15;
trace("El clip "+mi_mc+" tiene una profundidad de "+mi_mc.getDepth());
}
En el siguiente clip teclee el siguiente código:
y = _root.bola2._y;
x = _root.bola2._x;
for(i=0; i<5; i++){
mi_mc = bolaRoja.duplicateMovieClip("bola2"+i,10+i);
mi_mc._y = i * 15;
trace("El clip "+mi_mc+" tiene una profundidad de "+mi_mc.getDepth());
}
Como puede observar, las profundidades se repiten en ambos clips de películas, pero como pertenecen a diferentes líneas de tiempo, no hay conflicto. Recuerde que las profundidades se delimitan en relación a la línea de tiempo, es decir, primero se "enciman" dependiendo la profundidad en relación a la línea de tiempo, y dentro de cada una de esta, se enciman según su profundidad (o sea que es un encimadero).
