Saltar navegación

Vídeos UT2 - #4 - DEIM - Curso 25·26 - Contenido educativo

Ajuste de pantalla

El ajuste de pantalla se aprecia al ver el vídeo en pantalla completa. Elige la presentación que más te guste:

Subido el 10 de diciembre de 2025 por Daniel M.

6 visualizaciones

Vídeo sobre consejos para superar la UT2

Más información Transcripción

Descargar la transcripción

En este vídeo vamos a hablar de algunos aspectos o algunos puntos de la tarea de la unidad 2 que suelen entrañar más dificultades o quizá ha llegado un cierto punto, pues puede suponer dificultades, lo cual es obvio en estas alturas del curso y bueno, porque tiene su complejidad. 00:00:01
Bueno, para ubicar un poco voy a hablar 00:00:20
Bueno, ya tenemos una nave que se va moviendo hacia arriba, hacia abajo 00:00:24
Y como indica la tarea, claro, para que no se vaya escapando de los obstáculos 00:00:31
Que pueden acabar con el juego 00:00:37
Pues habrá que poner unos límites para que la nave no lo supere superiormente 00:00:40
Ni tampoco atraviese el suelo 00:00:44
En un primer momento cuando se persigue hacer algo en este sentido, es verdad que se suele pensar en, al limitar quizá lo que hay que hacer es decir, bueno, si supera voy a indicar a la nave y voy cambiando la posición. 00:00:46
Bueno, pues decir que en cierto momento cuando superamos 23 en Y o al bajar hasta menos 2 en este caso, más o menos aproximadamente, pues habría que decir que no pueda continuar desde ese punto. 00:01:06
Intentar algo relacionado con, si llegas a este punto, fijar el límite como un valor concreto. 00:01:20
Pero hay otra forma de enfocarlo que en este caso es mejor, bueno, entiendo que ya más o menos sabemos hacer que la nave suba, baje y se gire, por lo que hemos visto en otros vídeos, pero en el propio método update puede haber un método que es el que uso para mover nave, que para que se ejecute el translate, tanto en vertical como en horizontal, 00:01:28
Y eso dependerá de la variable en la que estamos guardando, fijaos en el nombre, las interacciones en estos getAxis, de subir y bajar, que hemos definido como axis, 00:01:53
pues poner una condición de cuándo debe aplicarse este Translate, este movimiento en el espacio. 00:02:08
Más que intentar definir si llega a tal altura, se tiene que quedar a tal altura, bueno, pues si llega a 50, se tiene que quedar en el 50, lo que se puede es, digamos, restringir que la condición, con una condición, ¿no?, pues que se ejecute directamente el movimiento. 00:02:17
Y para eso, ¿qué se puede hacer? Pues en el update también, que en cada fotograma existan estos límites con los que, en un método que hemos creado posteriormente, definir en base a booleanas, una que sirve para limitar en el plano vertical, en la subida o bajada de la nave en el eje Y o en el horizontal. 00:02:35
son dos variables que he creado en este código como globales, que empiezan siendo verdaderas, se encuentran en el límite horizontal o dentro del límite vertical, 00:03:00
que hará que se mueva esa nave, que permitirá que la condición se ejecute para que se mueva la nave, pues lo que voy a hacer es fijar que estos in-limits, 00:03:12
birds o horizontales, estos límites, estas booleanas que se han creado, pues vayan activándose o desactivándose según la condición. 00:03:21
Y las condiciones, como ya vimos, pueden tener conectores para que en un solo if pueda haber una condición o varias o obligar, aunque aquí no nos interesa, obligar a que se aplique una u otra, tenga que darse una u otra y no las dos a la vez. 00:03:29
Estos operadores se ven en la primera unidad, en la UT0, pero con estos dos ampersands se puede vincular varias condiciones. 00:03:47
Una es obvia, que es decir, que el transform position en I, es decir, la posición en I del objeto que tiene este script, que es la propia nave, 00:03:57
pues que si en I supera un límite vertical que hemos fijado, pues en ese caso, añadiendole que además se esté pulsando el axis, 00:04:05
se esté dando la interacción superior a 0, que sería el eje positivo de subida, 00:04:16
dentro del axis, recordemos que va entre el 1 y el menos 1, 00:04:22
tiene un valor positivo y uno negativo. 00:04:26
Bueno, pues en el vertical el positivo será la W, 00:04:28
si estamos usando la combinación de teclas WAST. 00:04:30
Aquí estaríamos diciendo que si supera cierto límite en el eje Y, 00:04:35
que ahora vemos cómo se ha definido, 00:04:39
y además estoy intentando subir porque este movimiento vertical, 00:04:41
de esta interacción estoy intentando subir con la W, pues diré, oye, eres falso, y por tanto el movimiento no se aplicará. 00:04:45
Básicamente el límite es que la nave se desactiva y no va hacia arriba. 00:04:54
Lo mismo no tendría nada que ver si aquí cambiáramos la condición y pusiéramos menor, 00:04:58
porque significaría que aunque haya sobrepasado ese límite por arriba, por eso esta indicación, 00:05:03
además de mayúsculas, para que se vea claro, en este caso, si yo sigo dándole hacia arriba, 00:05:07
aunque haya superado el límite, ¿vale? Pues ya la condición cambia completamente. 00:05:12
Lo que quiero en este caso, igual que luego lo haré al revés, es si supero por arriba el límite e intento seguir subiendo, ¿vale? 00:05:18
Bloquéame con este booleano el movimiento. Por el contrario, si esto no se cumple y lo que estoy es por debajo del límite vertical 00:05:27
y además estoy intentando bajar, ¿vale? Ahora es el menos, también lo bloqueo. 00:05:34
Tampoco quiero que la nave se desplace en el eje Y, sino, siempre que esté dentro de esos límites y no esté pulsando las teclas, pues sí permitirá el movimiento. Igual que si, aunque se haya, y a veces sucede, en ocasiones se puede superar un umbral, ¿vale? Una posición, porque por la propia inercia del movimiento, al subir mucho o al bajar, ¿vale? De la propia inercia se puede traspasar un punto que se había marcado como el límite, ¿vale? 00:05:37
A lo mejor este limit bird down, que es esta variable global también, que se ha puesto 5 porque al ver la escena es el punto NGI que veo que es a partir del cual más abajo no quiero que baje la nave porque está el suelo, igual que aquí pongo un 30, ¿vale? 00:06:03
Esto es escoger y ver la escena y probar si la nave, en qué momento yo quiero que sea el límite de subir o bajar. 00:06:20
Si yo subo, subo, subo, quiero que el límite esté alrededor del 23 por arriba y del menos 2 por abajo. 00:06:35
Esto se traduce en estos límites que estarán desplazados seguramente porque la propia nave también tiene su desplazamiento propio. 00:06:43
Hemos puesto el 5. También es cierto que ya hay una traslación de 7 en el padre que se traslada al hijo y por eso el límite inferior es menos 2. 00:06:59
que si le sumamos 7 es el 5 que hemos fijado 00:07:12
y si subimos y le sumamos 7 es el 30 00:07:15
que hay en este límite marcado 00:07:19
os doy un truco, vale, aquí lo tenéis 00:07:22
os doy un pequeño truco, esto sería ajustarlo a mano 00:07:25
y ver que cuando, bueno, pues que si yo por ejemplo aquí le digo 00:07:28
que sea menos 10, aunque yo vea un suelo 00:07:31
pues, y reinicio, vale, guardo y reinicio 00:07:33
aunque vea un suelo, pues vais a ver que la nave 00:07:37
Bueno, tiene un límite físico que es el collider que cuenta, ¿vale? Pero bueno, que veis que si intento seguir bajando, bajará hasta que ya haya un punto que no baje, ¿vale? Que coincide con el 1, que si consideramos la posición, bueno, el 1 no, perdón, el menos 17, ¿vale? Que si le sumamos los 7 que hemos visto, pues daría ese menos 10. 00:07:41
En ese caso es ir probando las posiciones hasta que tenga coherencia con los límites que hemos establecido. En este momento hemos determinado que es 5 para la altura inferior y 30 para la superior. 00:08:06
Y con eso, lo mismo, aunque se haya superado el límite, si yo en cierto momento he superado ese límite, pero lo que quiero es bajar sin ningún problema, esto no se cumplirá la condición y el booleano será verdadero. 00:08:20
Entonces, nuevamente, si volvemos al movimiento de la nave, siempre que esté en verdadero, en true, el booleano se cumplirá la condición para que haya esta traslación, este movimiento en el espacio 00:08:34
Lo mismo pasa en el límite horizontal 00:08:49
Aquí pongo un detalle, simplemente para que lo veáis, que es que aunque en una booleana no se ponga, esto ya se dijo en otro vídeo, no se ponga la condición de verdadero o falso 00:08:51
Bueno, por defecto, si aparece la booleana aquí sin ningún comparativo posterior, se entiende que es si es verdadero. Es decir, si esta booleana guarda un verdadero. Un poco lo mismo que aquí, pero de forma más simple, más simplificada. 00:09:00
Igual que si cuando vemos un if no hay llaves posteriormente, si solo hay una línea de instrucciones, solo hay un punto y coma, se va a ejecutar 00:09:15
Es lo mismo básicamente que si aquí pusiéramos estas llaves, es exactamente lo mismo, solo que es otra forma simplificada de escribir lo mismo 00:09:23
Entonces con estas limitaciones que se van poniendo es con lo que se puede ir delimitando que la nave se mueva o no 00:09:32
Se puede hacer de más formas, pero probablemente esta sea una de las más simples para, bueno, pues eso, con algunas líneas dentro de este método, pues comprobar si está existiendo esa posibilidad de que se mueva la nave o no. 00:09:41
En el eje horizontal, que vais a ver que lo que se hace es, como derecha-izquierda, digamos, si hemos centrado bien la nave, que era una de las cosas, si os acordáis, que se decía en la UT1 que la nave estuviera centrada para que la distancia también se cree centrada, etc., pues al final es simétrico lo que es el eje X, el desplazamiento horizontal, el máximo al que puede ir, porque aparece en el centro del suelo y llegará un punto que ya no me interesa que vaya hacia la derecha o hacia la izquierda. 00:09:56
Y si lo calculamos desde el 0, pues es, por ejemplo, el más 20 o el menos 20, pueden ser el mismo valor solo con el signo cambiado, ¿no? Entonces, estas dos condiciones que veíamos aquí antes se pueden trasladar aquí simplemente con él, la misma variable, pues invirtiendo el valor, ¿no? Poniéndolo en negativo. 00:10:25
luego, pues lo mismo, si quiero ir 00:10:42
si estoy a la derecha y quiero 00:10:45
seguir yendo a la derecha, más allá del límite 00:10:47
pues, ojo, que no te va a dejar falso 00:10:49
igual a la izquierda 00:10:51
¿no? y lo bueno 00:10:53
es que aquí con un único, igual que aquí 00:10:55
hemos tenido que hacer el de dan o up, dos variables 00:10:57
distintas para definir arriba y abajo 00:10:59
porque no existe esa simetría 00:11:01
con un mismo, una misma 00:11:03
variable de 00:11:05
un número, ¿no? un float o un int 00:11:06
se puede indicar 00:11:09
tanto el lado derecho como el izquierdo. 00:11:10
Otro, ahora que empiezan los códigos a tener un poquito más de longitud, 00:11:14
otro truco que se puede ver es si quiero ir a donde se ha declarado esta variable, 00:11:19
porque me he olvidado de cuál es o porque quiero cambiar el valor, 00:11:25
dándole al control, se pone la indicación en azul, está hipervínculo, 00:11:28
al clicar nos lleva a donde está declarada, por si por ejemplo lo quisiéramos cambiar. 00:11:34
Este 30 o este 40, como hemos visto, sirve de 40 a la derecha y menos 40 a la izquierda. Con un único valor, una única variable, se puede conseguir. 00:11:38
Hay un aspecto, bueno, aparte de que tenga aquí preparados más métodos, etc., este check limits, que es con lo que voy aplicando las booleanas, realmente está mal planteado. 00:11:48
Funciona, ¿vale? Está funcionando, pero fijaos que los límites que la booleana, que luego sirve para definir o para que la condición se dé de si la nave se mueve o no, se ejecuta realmente después de mover nave, ¿vale? 00:11:58
Que es la que estoy viendo aquí, que hace efectivamente eso. ¿Vale? Esto también sirve para que hablemos, primero, de que el orden adecuado o más certero, ¿no? 00:12:12
sería este, que primero establezca si esto es verdadero o falso y luego ya se haga el movimiento, pero también sirve porque aunque en ocasiones lo pongamos mal, implica que nuevamente si nos empeñamos en solo poner el límite como condición para que se dé o no una condición, 00:12:20
si hemos comprobado después 00:12:40
de cuando se está haciendo este método 00:12:42
es decir, se ha movido la nave en fotograma 00:12:44
antes en el fotograma, que la aplicación 00:12:46
de este check limits, se pueden dar 00:12:48
casos en los que, bueno, pues se haya 00:12:50
traspasado el umbral en ese momento 00:12:52
entonces, bueno, recordad que podéis 00:12:54
concatenar o podéis 00:12:56
excluir condiciones entre sí 00:12:58
en un único if, ¿vale? y es muy interesante 00:13:00
ir contando que 00:13:02
las condiciones, pues, pueden ser 00:13:04
pueden ser varias 00:13:06
Luego, por otro lado, acerca de las corrutinas, otro de los aspectos importantes es que cuando se están instanciando estos pivotes, estos obstáculos, para empezar, como ya vimos, la nave no se tiene que desplazar en profundidad. 00:13:08
En los endless runner, en esta tipología de juego, en esta categoría, normalmente lo que se mueven son los... el fondo, ¿no? Y el personaje es el que va a izquierda, derecha o salta, o se mueve hacia arriba o abajo, pero no es el que se desplaza en infinito. Esto puede darse de otras formas, pero es una forma común de que ocurra. 00:13:30
Entonces es bastante frecuente que existan elementos que tengan que ir hacia cámara. Si nos fijamos, aquí tengo un instanciador, un código que instancia este prefab que tengo del obstáculo, de hecho es el mismo que se incluye como material de la tarea, es por si lo quisierais usar, y se van instanciando los distintos. 00:13:50
Se crea un GameObject con el serial exfil al que vinculamos este obstáculo y posteriormente lo que se va a realizar es abrir o iniciar, empezar en el start, para que no se vayan iniciando distintas corrutinas, se empieza una corrutina llamada crear obstáculo. 00:14:13
Recordemos que para definir, para declarar una corrutina se debe hacer con esta interfaz de tipo enumerator, que básicamente lo que más nos interesa es que tiene esta instrucción posteriormente del GIL y más instrucciones. 00:14:30
Lo bueno de las corrutinas es que permite ir espaciando o ir provocando en diferido la ejecución del código. Es decir, dar pausas a que se ejecute el código. Igual que en el update está continuamente ejecutándose fotograma tras fotograma, en el enumerator al comenzar la corrutina empieza, como cualquier método, a leer lo que tiene en su interior, de arriba a abajo. 00:14:46
¿Qué ocurre? Que llegado a un cierto punto con esta instrucción del yield return, y en el tema pone también que si quisiéramos que se ejecutara cada fotograma se podría poner como nulo, pero bueno, eso en ciertos momentos puede servir para que funcione como una especie de update paralelo, pero no aprovecha su potencialidad. 00:15:14
Tenemos esta instrucción de newWaitForSeconds, que como argumento, dentro de sus paréntesis, podemos introducir, aquí he puesto intervalo, para hacer un cálculo de velocidad, que puede ser dos valores que quiero relacionar, 00:15:38
Para que si el juego se va relacionando con la velocidad a la que se mueven los obstáculos y lo pongo en una variable que comparto con otros scripts, 00:15:53
que también defina el intervalo de tiempo entre una instancia y la siguiente del obstáculo, pero aquí no olvidemos que dentro de un wait for seconds se puede poner cuatro. 00:16:01
Es decir, un número que identifica el número de segundos, se expresan segundos, que va a tardar en detenerse en esta línea de la instrucción y continuar. 00:16:11
¿Qué ocurre? Que normalmente estos enumerators, estas corrutinas, se suelen encerrar en bucles más que nada porque no nos suele interesar que se ejecute una vez y acabe, 00:16:27
sino que vuelva a, después de pasado, en este caso, estos cuatro segundos, como while true es un bucle infinito, pero yo estoy deteniendo conscientemente, volverá al comienzo y seguirá ejecutándose. 00:16:37
A la vez, más que a la vez, digamos, buscando el momento dentro de la ejecución de cada fotograma del update, por ejemplo, pero irá buscando el momento en el que pasados cuatro segundos vuelva a ejecutarse esto. Entonces, podemos ir marcando el tiempo que tarda el código en continuar, el código dentro de este fragmento en continuar dándose. Por eso se dan estas condiciones de while true para irlo deteniendo cada cierto tiempo. 00:16:49
Entonces, al final los obstáculos es una instanciación, se crea un punto de instanciación del obstáculo que se coloca en el espacio y lo que se puede hacer, como vienen de profundidad, lo que es el eje Y y el eje Z, yo ya defino con relación a la nave, con el propio Nulo, con el propio GameObject vacío, 00:17:16
se puede indicar a qué distancia y en qué altura se van a instanciar los pivotes 00:17:40
porque no van a estar flotando, entonces como siempre van a estar posados en el suelo 00:17:47
pues se puede definir que siempre lo haga desde la misma altura y desde la misma profundidad 00:17:50
porque al final se van a estar desplazando, me da un poco igual en este caso que esté más alejado 00:17:55
lo que sí que no me da igual como estáis viendo, porque si no el juego sería simplísimo 00:18:00
es la posición en X en horizontal que tiene, ¿no? 00:18:04
Para que tenga sentido que lo vayamos esquivando o no. 00:18:11
Entonces, como sugiere el enunciado de la tarea, 00:18:14
se puede usar unos operadores que son el de random range 00:18:17
que sirve para aleatorizar valores, ¿vale? 00:18:20
Cuando ponemos un random.range entre sus paréntesis 00:18:23
podemos poner dos valores, uno mínimo y otro máximo. 00:18:26
Bueno, si nos ponemos encima del range, 00:18:31
Si os fijáis en la leindita que pone, el primer argumento será el valor mínimo, el segundo será el mayor máximo y entre esos se irán generando valores intermedios. 00:18:32
Entre menos 40 o 40, esta variable que he declarado aquí e inicializado con este random rates irá guardando en su interior valores aleatorios. 00:18:45
Lo irá haciendo cada vez que llegue a este punto. Entonces, cada vez que dé la vuelta, creará otro número aleatorio, que es el que luego usaremos como posición en X para que salga esa instancia del obstáculo. 00:18:54
Si os fijáis, aquí se declara y además se irá reiniciando cada vez que se dé este bucle, cada 4 segundos en este caso, en el que habrá un balón randomX aleatorio entre estos valores y luego un vector nuevo que se crea que fijará, primero, que conserve la posición en Y y en Z del objeto. 00:19:08
En este caso, como el script está aplicado a este punto de instanciación, cogerá las coordenadas que pongamos de altura en i, en este caso un 0, no queremos que se eleve, y en z, que se ha desplazado 200 en profundidad. 00:19:30
Si yo lo alejo, los obstáculos en este caso se irán generando desde más lejos. Pero lo que va cambiando en cada iteración es la posición de X, porque está cogiendo el valor aleatorio que en cada vuelta se va generando. 00:19:46
Una vez que tenemos eso, se instancia el obstáculo, que es el GameObject que se ha incluido, ese prefab del obstáculo, y lo que se indica como posición es precisamente este vector 3 que se va generando. 00:20:07
Entonces, en cada vuelta decimos que se genere este prefab otra vez, ¿vale? Se generará infinitas veces en esta posición, que irá cambiando solo en el eje X y, bueno, como ya vimos también en una de las declaraciones del Instance 8, en una de las sobrecargas, si queremos poner un vector 3 como segundo valor para la posición y no es el transform de otro padre, etc., bueno, pues hay que incluir una rotación, que si no queremos que sea afectada, valdría con esta instrucción de quaternion.com. 00:20:20
Que lo que hace es coger la rotación nula, que tampoco se ve afectada. Entonces, gracias a este enumerator, se va una y otra vez con esta pausa de 4 segundos en esta línea, pues se lanzará en el start y generará una primera instancia, esperará 4 segundos y al acabar el bucle dice, anda, si esto todavía se está cumpliendo, volvemos a hacerlos, instancia, esperará otros 4 segundos y así indefinidamente a menos que la paremos de alguna forma. 00:20:50
Si queremos que este no sea un bucle infinito, que en esencia es lo que hace while true, se pueden poner bucles for, ¿vale? 00:21:20
Para que tenga un número de iteraciones máxima o habría que poner alguna condición que pare la corrutina. 00:21:27
Si ponemos un contador, una variable que cada vuelta vaya sumando uno, ¿vale? 00:21:33
Pues llegará a un punto que aquí se podría poner también una condición si la variable tal es mayor de 10. 00:21:39
Bueno, aquí he puesto variable, digo, estoy poniendo pseudocódigo, es decir, palabras para que nos entendamos, no están declaradas. Pues en este caso se puede decir que haga un stop corrutín o un stop all corrutín, si entonces lo que hace es parar esta corrutina. 00:21:45
Bueno, pues con esto se puede conseguir que los obstáculos se estén instanciando indefinidamente 00:21:58
Y con este tiempo de instanciación, con este tiempo que hay entre uno 00:22:06
En este caso una ejecución del bucle y el siguiente 00:22:10
Porque aquí se detiene en esta línea, dentro del enumerator 00:22:15
El update, el start, el resto del código se seguirá ejecutando con lo que corresponde 00:22:20
Pero dentro de este marco, de esta cápsula, de este enumerator 00:22:23
Aquí se va a aplicar una pausa con el valor de este paréntesis. Luego, otra de las cuestiones es que cada obstáculo, cuando se instancia, los propios prefabs también pueden tener sus scripts aplicados, para que cuando sean instanciados ya puedan tener su código incluido. 00:22:27
Si vamos a este, que cada vez que se instancia, vamos a verlo, uno de los obstáculos, ¿vale? 00:22:48
Fijaos que ya tiene este movedor obstáculos, ¿vale? 00:22:54
En todos, es el mismo, ¿vale? 00:22:58
Cada uno de manera independiente, se van generando las instancias y tienen su código. 00:23:00
Dentro de ese código, ¿vale? 00:23:05
Es desde el que se podría, en este caso nos interesa más, voy a borrar el start que está vacío, ¿vale? 00:23:07
con el update, añadir un transform translate que vaya en profundidad hacia la pantalla, hacia cámara, ¿vale? 00:23:12
Por eso este vector 3 back, que básicamente es un 0, 0, y en el eje Z, un menos 1, que lo que hace es acercarse hacia cámara, ¿no? 00:23:18
Viendo los gizmos que tenemos, pues si el Z es el valor de la profundidad, de alejarse, los valores positivos, los negativos, 00:23:26
lo que harán es que se vaya acercando hacia la nave. 00:23:34
Bueno, pues ahí con un translate que en cada update, en cada fotograma va moviendo de uno en uno 00:23:37
y aparte cambiamos la velocidad que vayamos poniendo y equilibrando posteriormente con este DeltaTen 00:23:43
como hemos hecho ya en otras muestras del translate, pues en cada fotograma se irá desplazando el obstáculo 00:23:49
sin hacer nada más. El propio obstáculo tiene ya automáticamente, nada lo detiene en este caso, 00:23:55
una traslación, un movimiento hacia la cámara. ¿Qué ocurre? Que cuando traspasa la cámara, podemos calcular un punto a partir del cual 00:24:00
este GameObject que tiene el código y que es una script independiente en cada obstáculo, por tanto se irá aplicando a cada uno de los obstáculos 00:24:11
que se han generado, que se han clonado, pues decimos que se destruya. Esto sobre todo se hace para que no se convierta esto en una sucesión 00:24:21
Voy a ir al código previo y voy a decir que la estanciación sea más rápida para ver más ejemplos, que sea cada un segundo. Voy a guardar esto y lo que vamos a conseguir es que cuando cada pivote supere en Z el menos 10, pues se destruya. 00:24:29
Haga ese ejercicio de destruirse. Por tanto, podemos estar viendo este pivote. Me voy a alejar un poco para ir viendo. Vamos viendo este pivote. Fijaos cómo traspasa la cámara que está justo detrás de la nave y cuando llega al menos uno, por ejemplo, vamos a poner este, fijaos en el Z, se van destruyendo. 00:24:49
Aquí parece que están siempre los mismos, pero bueno, a la que se borra uno está apareciendo el siguiente, por eso es de continuo. Pero fijaos que se están desplazando en Z hasta que al superar menos 10, dentro de su código se indica, oye, destruyete, has llegado a menos 10, ya no te necesitamos. 00:25:12
Si no se pusiera esta instrucción del destroy, aquí se irían sumando y sumando obstáculos que además se irían moviendo cada uno. Cuando llegara un punto ya que se han realizado tantas instancias de este obstáculo, que pudiera llegar a un número infinito de obstáculos, claro, la reproducción del juego y el procesamiento se va a ir viendo penalizada. 00:25:27
Por ello, bueno, pues tiene que llegar un momento en el que se vayan eliminando las copias que ya no sean útiles. 00:25:50
Aquí, por ejemplo, hay algo a observar, que es que fijaos que las copias, sobre todo cuando están a la derecha, 00:25:56
desaparecen de forma muy abrupta y desaparece la sombra. 00:26:02
Bueno, pues igual lo que nos interesa es que en vez de que sean Z, pues sean menos 40. 00:26:06
Con esta declaración se puede indicar en qué punto van a desaparecer. 00:26:11
Fijaos que está el obstáculo trasladándose y cuando llega a menos 40, ahora desplazado al menos 10, al menos 40, desaparece y se borra. Aquí desaparece porque ya no hay nada que leer en el inspector, pero de este modo vamos controlando el número de instancias que tenemos. 00:26:19
Entiendo que con estas indicaciones 00:26:36
Bueno, pues más o menos ya podéis ir superando 00:26:41
La tarea, resolviéndola 00:26:44
Si tenéis dudas o queréis que veamos algo en el foro 00:26:47
Pues simplemente tenéis que indicarlo 00:26:50
Así que nada, muchas gracias y ánimo con la tarea 00:26:53
Materias:
Imagen y Sonido
Niveles educativos:
▼ Mostrar / ocultar niveles
  • Formación Profesional
    • Ciclo formativo de grado superior
      • Segundo Curso
Subido por:
Daniel M.
Licencia:
Todos los derechos reservados
Visualizaciones:
6
Fecha:
10 de diciembre de 2025 - 19:56
Visibilidad:
Clave
Centro:
IES CIFP a Distancia Ignacio Ellacuría
Duración:
27′ 05″
Relación de aspecto:
1.78:1
Resolución:
1920x1080 píxeles
Tamaño:
305.53 MBytes

Del mismo autor…

Ver más del mismo autor

EducaMadrid, Plataforma Educativa de la Comunidad de Madrid

Plataforma Educativa EducaMadrid