Saltar navegación

Vídeos UT2 - #1 - 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 13 de noviembre de 2025 por Daniel M.

8 visualizaciones

Vídeo de apoyo para la apertura de la UT2 de DEIM

Más información Transcripción

Descargar la transcripción

Un tema dos es en el que ya se van introduciendo interacciones, pues eso, que ya podréis ir indicando mediante, en este caso, joystick, teclado o con el dispositivo que sea que capte inputs, entradas, interacciones, pues vais a poder ya asignar acciones, que es básicamente lo fundamental para que un videojuego sea tal, que sea interactivo. 00:00:07
Entonces, se habla de que en este punto, bueno, ya llevo unos años, digamos que dentro de Unity había un sistema tradicional de capturar, captar como captar, mejor dicho, esos inputs, había un método tradicional que se gestiona con lo que se llama los axes. 00:00:30
Entonces, si vamos a esta sección de Edit, en el menú Edit, Project Settings, hay una sección específica de lo que se llama el Input Manager. Input Manager, en oposición a Input System, creo que esto queda bastante destacado además en los apuntes, Input Manager es el sistema clásico de gestión que todavía sigue vigente, 00:00:51
pero es verdad que está siendo 00:01:13
reemplazado o complementado 00:01:16
se podría decir por otro sistema que es este 00:01:18
Input System que aquí vamos a 00:01:20
manejar de una forma un poco por encima 00:01:22
y lo pone el temario que ni siquiera es 00:01:24
hay un apartado que sí pues 00:01:26
lo que es la filosofía digamos pero luego 00:01:28
el uso es más avanzado y 00:01:30
en estas alturas de curso es complicada 00:01:32
es un sistema que está pensado para 00:01:34
gente que ya se lleva mejor 00:01:36
con Unity que nosotros en estos momentos 00:01:38
porque ya 00:01:40
A nivel de programación tiene más miga, que aún así, oye, si os ponéis también con los tutoriales, dejo bastante documentación creo para ir viendo las bondades. 00:01:42
Ese sistema lo que incorpora es que es mucho más versátil a la hora de detectar distintos inputs y esto es sobre todo en un momento en el que hay más dispositivos como la realidad virtual, 00:01:53
que va con gafas que van captando las inclinaciones, los movimientos, luego los móviles también con sus osciloscopios, acelerómetros, etc. 00:02:02
Bueno, pues había un momento que había muchas más formas de meter inputs que las que estaban planteadas por defecto mediante este input manager. 00:02:14
Eso es como una introducción. Cuando os metáis en estos axes vais a ver que, bueno, tiene varias opciones, se describe en el contenido de ese tema 2, pero vais a ver que hay momentos en el que dentro de cada uno de estos ejes, que estos son nombres que vamos dando a conjuntos, ¿vale? 00:02:23
pues eso basado sobre todo para para gamepads o teclado y ratón vale por eso falta un poco todo 00:02:52
lo más avanzado en cuanto a móviles y vr por ejemplo vale que también se puede hacer con 00:03:03
librerías que hay aparte vale que gestión los axis de otra forma pero bueno así por defecto 00:03:08
vais a ver pues eso que se refiere a teclas o botones de un teclado que también pueden ser 00:03:13
de un Gamepad, aunque aquí no lo ponga claramente. También puede ser el movimiento de un ratón 00:03:20
o ejes de un joystick, que realmente también se pueden asociar, dependiendo del dispositivo, 00:03:28
a teclas de un Gamepad. Entonces, cuando nosotros hacemos un axis de esto, por ejemplo, 00:03:34
este de horizontal, y vais a ver que ya viene prehecho, vienen varios prehechos para usarles, 00:03:41
porque son como los típicos, como este de movimiento, botón para movimiento negativo y positivo, 00:03:45
que son los dos ejes de dirección, por ejemplo, en un gamepad, cuando tenemos la cruceta, 00:03:51
cuando hablo de gamepad me refiero, por si acaso alguien no lo tiene claro, al mando de la Xbox o de la Playstation. 00:03:56
Cuando tenemos esa cruceta de dirección, al final son ejes opuestos, el orden de dirección. 00:04:02
Si movemos el joystick o la cruceta hacia la izquierda, pues es el valor negativo que indicará que, mediante la programación que ya iremos haciendo, que se mueve a la izquierda. 00:04:08
Si le damos a ese mismo eje, pero a la otra dirección, al positivo, por eso están estos contrapuestos, que en el teclado además vais a ver que se relacionan con la cruceta esta típica del WASD, de la W-A-S-D. 00:04:19
Cuando digo las teclas WAS, son la W para ir hacia adelante o subir, vamos, es la cruceta que tenemos aquí, que también se suele duplicar, esta cruceta se traslada a la W como la flecha de arriba, a la de izquierda, ese de abajo, de derecha, por si acaso. 00:04:32
Entonces, los suyos que uséis, de hecho, dupliquéis esta cruceta y esta, que es como viene por defecto además en los ejes 00:04:55
En este sentido tampoco deberíais trastear o variar demasiado los que ya vienen, que ya vienen preparados 00:05:05
En la horizontal vais a ver eso, que A y D se refieren a los laterales, las flechas en el teclado, las que corresponden a izquierda y derecha en este WASD 00:05:11
Pero también tiene la alternativa, bueno, se complementa con el orden del teclado aquí. Tanto si tocamos la tecla de la flecha izquierda como si tocamos la A, haría la misma acción mediante este horizontal y vertical vais a ver que es arriba, abajo o SW, que también son las correspondientes a WAST. 00:05:20
Entonces intentad que sea a través de esas 00:05:41
Bueno, este control de horizontal, si os dais cuenta, para ir de izquierda a derecha 00:05:46
Para el movimiento horizontal 00:05:50
Y en este momento está pensado para ser usado con teclas 00:05:52
Del teclado, por ejemplo 00:06:01
Si aquí pusiéramos joystick, estaríamos cancelando 00:06:06
que se usen ratón y tecla, pero no hay nada que impida, y si os dais cuenta, aquí hay una entrada que se llama horizontal, 00:06:10
un eje llamado horizontal, pero luego hay otro que se llama horizontal, y vais a ver que se pueden hacer diferentes entradas, 00:06:17
entonces si aquí hacemos otra llamada igual que se llama joystick, pues aquí podemos configurarlo de joystick, 00:06:26
y funcionan en base al mismo nombre, ¿vale? 00:06:32
Cuando ya veáis cómo se mete el nombre del axis por código que lo pone en el tema, 00:06:36
pues habrá que poner horizontal, dependiendo del input. 00:06:41
Si tocamos la tecla A, por ejemplo, va a saber que es la izquierda, por lo que le estamos determinando. 00:06:44
Pero si en la cruceta tocamos la tecla izquierda, se moverá a la izquierda. 00:06:50
Pero si además en los joystick le definimos otro, ¿vale? 00:06:54
Con estas acciones también que hay aquí, que también se explican, pues dependerá de qué detecte. 00:06:57
de qué entrada esté detectando. Entonces, no son excluyentes, se pueden poner ambas. 00:07:02
Entonces, básicamente, los ejes incluso se pueden duplicar y a un mismo control darle distintos. 00:07:08
Es decir, se puede poner ahora que mouseX también sea la A, que es lo que estaba. 00:07:17
Pues ya dependiendo del contexto donde se desencadene este comando, este eje llamado mouseX, 00:07:22
pues hará una acción u otra, pero eso ya irá en la programación que vayamos haciendo en el tema 2. 00:07:28
En el tema 2 de la tarea vais a ver que ya hay que mover la nave, que se mueva, sube, baja, izquierda, derecha y gira, rota sobre sí misma. 00:07:34
Esto al final son ejes preparados para ser usados con acciones que luego pongamos con el transform o con lo que hagamos, 00:07:45
o añadiendo fuerzas, como veremos en la física del tema 3, pero esto al final son como instrucciones de inputs. 00:07:51
Siempre que me compartáis el proyecto de Unity, lo digo porque más adelante también y probablemente en posteriores tareas os lo pida así, 00:08:05
yo voy a ver, al abrir aquí, al cargar el proyecto, voy a ver vuestros Project Settings como los habéis configurado. 00:08:13
Pero ojo, también si hacéis la cabeza en otro momento, a lo mejor lo que os pido es que me compartáis, 00:08:18
no el proyecto en sí, todo lo que es el proyecto, sino que me compartáis, por ejemplo, esto, una parte de vuestro videojuego, 00:08:23
de vuestra aplicación, como un package. Y un package, al final, lo que hace es guardar todo esto que tenemos aquí, 00:08:33
los scripts, los assets, incluso si nos metemos en las escenas, hasta la jerarquía y todo lo relacionado con la escena. 00:08:38
pero es verdad que lo que es el proyecto en sí, que es un orden superior, que está fuera de lo que es la escena 00:08:48
y todo se supedita a lo que vayamos poniendo aquí, eso ahí no lo voy a tener 00:08:54
entonces en ocasiones si me ponéis controles que se salen, en otros sí que ser específico 00:08:59
pues tenéis que hacer que la izquierda sea con tal tecla, si me vais a hacer algo diferente 00:09:04
deberíais indicarlo a lo mejor en el código mediante comentarios o en la entrega de la tarea me lo indicáis 00:09:11
si llegara el caso de eso 00:09:17
las escenas 00:09:19
estas escenas que vamos creando son como los distintos niveles 00:09:25
de nuestro juego 00:09:28
entonces dependiendo un poco del juego 00:09:29
las escenas pueden tener un funcionamiento 00:09:31
u otro 00:09:33
por ejemplo 00:09:35
si tienes un juego de puzles 00:09:38
y cada nivel 00:09:40
es independiente 00:09:41
es decir, es un Tetris 00:09:44
van cayendo las piezas y si superas 00:09:45
tal puntuación 00:09:48
pasas a otro escenario 00:09:50
a otra forma de la escena. Ahí lo que sería, sería cargar el siguiente escenario, una vez se ha llegado a esa puntuación, pues dice carga al siguiente nivel, 00:09:51
y el siguiente nivel lo que es, es otro escenario. 00:10:01
Hablábamos de que uno de los tipos de variables que se pueden generar son los booleanos, ¿no? 00:10:10
Por ejemplo, booleano es estar vivo, para decirle al jugador si está vivo o no. 00:10:14
Si lo que decíamos los booleanos son un 1 o un 0, que si es un 1 es un valor positivo, si es un 0 es un valor negativo 00:10:19
Básicamente lo que nos sirve esto es para sobre todo introducir condiciones que en las estructuras de control condicionales 00:10:29
Pues nos permitan que ocurran ciertas acciones o no ocurran esas acciones y ocurran otras 00:10:36
Entonces, por ejemplo, si empezamos el juego y decimos que al arrancar ya por defecto lo inicializamos como true, si por algún motivo queremos que haya una opción, queremos que ocurra algo que pasa a ser lo opuesto, es decir, cuando estamos escribiendo el código no en todo momento a medida que vamos haciendo operaciones sabemos si vivo vale verdadero o falso. 00:10:41
Pero sí que nos puede interesar, por ejemplo, al activar un interruptor, y de hecho lo voy a llamar interruptor, que es mejor ejemplo, cuando vamos a una habitación puede que al decirle pulsa aquí no sea la acción la que queramos decirle si se enciende o se apaga. 00:11:07
Igual cuando vamos a cierto momento no queremos decirle no, cuando tú pulses aquí queremos que valga falso. ¿Por qué? Porque un interruptor normalmente si lo que hacemos es pulsarlo, lo que hacemos es activar o desactivar. Si está activado, desactiva, si está desactivado, activa. Hace la operación opuesta. 00:11:25
Hay un operador que no estaba visto y es interesante que conozcáis, que es este de la exclamación como para indicar contrario a, como lo opuesto a. 00:11:43
Entonces, si ponemos aquí interruptor, lo que estamos diciendo es que dentro de la variable interruptor, que en este momento vale true, pues se guarde lo contrario a lo que tenga. 00:11:57
este operador en este caso 00:12:08
en este contexto no tendría sentido por ejemplo 00:12:10
con variables de tipo numérico 00:12:12
porque no puede decir lo contrario a 5 00:12:14
pues bueno, en nuestra cabeza 00:12:16
podríamos decir el negativo en R5 00:12:18
pero no es eso, un negativo y un positivo 00:12:20
no es estrictamente lo contrario 00:12:22
tampoco, entonces 00:12:24
sirve sobre todo para las booleanas 00:12:26
entonces este operador es muy importante 00:12:28
porque va a haber operaciones que a lo mejor 00:12:30
estamos haciendo un montón de cosas y lo que queremos 00:12:32
no es que sea decir en ese momento 00:12:34
Si yo pulso, lo pongo con texto cotidiano, coloquial. Si yo pulso, quiero que lo que valga aquí pase a ser lo contrario. Esto se consigue con ese operador de contrario. 00:12:36
¿Vale? Entonces, ¿qué ocurre? Que cuando llegamos aquí y tú pulsas, pues el interruptor pasa, en este caso, a ser falso. Si en el momento que llegáramos el interruptor valiera falso, pasaría a ser verdadero. 00:12:58
Lo hago con un ejemplo muy rápido, pero como siempre, si yo aquí hago un debug log y digo que vale interruptor para ver qué valor tiene, si yo ahora le vinculo el script, que tiene que ser este de explicaciones porque creo que no tengo otro script aplicado. 00:13:13
Vale, perfecto. Y borro este que lo tenía antes de las pruebas. Remove. Si yo ahora lanzo este script, va a poner true, porque es lo que tenemos guardado. True, enséñame lo que vale interruptor. 00:13:38
Por lo contrario, si yo pongo que interruptor, lo que había puesto antes, sea lo opuesto a interruptor, pues veréis que ahora lo que va a indicar, guardo lo que va a indicar y vuelvo a ejecutar, lo que va a indicar ahora es falso. 00:13:53
¿Vale? ¿Esto qué significa? Bueno, pues si hacemos esto en el update, por ejemplo, ¿vale? Vais a ver que lo que va a estar es alternando todo el rato entre uno y otro, vaya, fotograma, fotograma, va a ir alternando, true, false, true, false, true, false, lo vais viendo, bueno, no para de ejecutarse, pero eso, es una consecución de apagarse, encenderse, apagarse, encenderse, ¿vale? 00:14:08
Que sepáis que esta lógica existe porque habrá ocasiones en las que es útil. Esta exclamación también sirve para las condiciones. Por ejemplo, imaginaos, voy a alestar de nuevo. 00:14:33
Y yo pongo una condición que es if, ponemos si interruptor es igual a verdadero, ¿vale? Pues entonces voy a poner una instrucción que sea que se muestre un mensaje, no voy a poner el valor, sino que ponga un mensaje de está encendido. 00:14:54
¿Sí? Entonces, ahora mismo, como se cumple esa condición de que interruptor es true porque nada lo ha cambiado, pues llega aquí y dice, ¿interruptor es igual a true? Sí. Pues vale, voy a mostrar, el texto está encendido. 00:15:14
¿Vale? ¿Qué ocurre? Que si aquí ponemos, y esto también solo sirve para las booleanas 00:15:26
Bueno, cuando digo solo, siempre puede haber excepciones, pero esto sobre todo se usa para las booleanas 00:15:36
Os podéis encontrar que la condición sea esta, pone sí, interruptor solo 00:15:40
Y dice, vale, pero interruptor igual a qué 00:15:45
Cuando se está hablando en la condición, se está poniendo una variable que es booleana 00:15:47
solo con poner interruptor 00:15:52
significa que si interruptor es verdadero 00:15:54
es decir, interruptor sí o interruptor 00:15:56
existe, es lo mismo 00:15:58
que poner lo que estaba puesto 00:16:00
antes, es decir, podéis llegar aquí 00:16:02
y es exactamente lo mismo, si interruptor 00:16:04
existe, es true 00:16:06
pues 00:16:08
vais a ver que ahora cuando 00:16:09
lanzo pone otra vez el encendido 00:16:12
de hecho, si yo pusiera 00:16:14
si interruptor es true 00:16:16
y si no 00:16:18
Bueno, pues pongo interruptor está apagado, ¿vale? Para que veáis que funciona. Pues vais a ver que ahora lo que va a mostrar no es está encendido. Bueno, perdón, va a mostrar está encendido. 00:16:19
Si yo aquí pusiera false, voy a agrandar esto para que no moleste tanto, vais a ver que ahora la condición no se cumple y pasa aquí. Aquí no pone ningún operador de este tipo, ni de diferente, ni de nada. 00:16:33
Entonces, cuando yo le dé, vais a ver que lo que está mostrando es que está apagado. Lo hago para que lo veáis y vais a ver que ahora pone que está apagado. Simplemente que a veces veréis esta instrucción como algo suelto y significa que está diciendo que si esto es un booleano verdadero. Eso existe. 00:16:55
Que no es lo mismo que si nos encontramos esto, que os he dicho lo opuesto. Si pone esto es lo opuesto a que exista interruptor, por tanto que sea falsa. Ahora vais a ver que cuando llegamos aquí la condición que se va a ejecutar es esta, porque realmente es lo contrario a interruptor, por tanto es falso. 00:17:16
Y vais a ver que ahora lo que va a poner es está encendido porque se aplica esa condición. Vamos a verlo nuevamente, guardo aquí, y le doy y va a poner está encendido. Entonces, ojo porque eso puede ocurrir en ocasiones. 00:17:35
¿Vale? Luego también el operador de la exclamación, y ya no solo... Bueno, lo voy a hacer con booleano y luego lo hago con un número. ¿Vale? También existe el operador diferente a true. ¿Vale? 00:17:52
Y aquí lo que estamos diciendo, a diferencia de cuando ponemos los dos iguales, que es el comparativo de igual, es el comparativo de diferencia. Ahora dice si interruptor no es true, que es este caso, pues está encendido. ¿Se va a cumplir? Sí, porque al ser falso no es true. Que sepáis que la exclamación también se usa para eso. Y está encendido, se cumple y por tanto está ahí. 00:18:10
¿Qué ocurre? Y sigo hablando de este operador de exclamación, que es muy importante, porque lo encontraréis o lo necesitaréis. Si yo pongo un valor int, que es un número, yo que sé, valor, voy a llamarlo valor, y es un 5. 00:18:35
Si llego aquí y la condición es valor es diferente a 5, esto no se va a ejecutar, porque estamos diciendo que si el valor es diferente a 5, que se jute está encendido. 00:18:49
voy a poner, si valor es diferente a 5, es diferente a 5, si no, pues es igual a 5, ¿no? Si no, evag.log, bueno, ahora lo escribo mejor, vale 5 y aquí cierro y cierro, ¿vale? 00:19:07
Ahora mismo el valor es 5, llega aquí y dice, ¿es diferente de 5? No, por tanto no va a poner que es diferente de 5, porque efectivamente vale 5, ¿vale? Entonces veis que con esta operación filtramos que algo sea igual o diferente, porque en ocasiones lo que nos puede interesar es que algo precisamente sea diferente a los distintos valores que podamos tener en el juego, ¿no? 00:19:32
entonces yo cuando lanzo ahora esto 00:19:51
va a poner vale 5 00:19:54
que no es lo mismo que si aquí 00:19:56
pusiéramos pues 00:19:58
igual a 5, pues la que lanzaría es 00:19:59
esta, luego hay otra cosa que también 00:20:02
os podéis encontrar y se usa mucho para 00:20:04
prevenir que ocurran errores en el código 00:20:06
pues ya habréis notado que esta línea 00:20:08
roja sale mucho y si sale 00:20:10
esa línea roja da problemas de ejecución del juego 00:20:12
por tanto no pueden funcionar 00:20:14
es usar 00:20:16
el concepto de null 00:20:18
Y nulo en programación significa algo que no existe. ¿Qué quiere decir esto? Que a lo mejor, por ejemplo, tenemos aquí, sería LicePill, y esto ya os suena, y creemos un GameObject, cuando hagáis la práctica, la tarea de instanciación, una instancia. 00:20:19
Y puede ser que en cierto momento nosotros digamos, instantiate, voy a copiarlo de otro lado que lo tengo ya hecho y así no tardo de más. 00:20:42
instanciate 00:20:57
bueno, sí, instanciate 00:21:02
y voy a ir a la 00:21:05
más básica que sería instanciar 00:21:06
intento hacer esto y lanzo el juego 00:21:12
vale 00:21:14
va a poner error 00:21:15
¿por qué? porque hay una instancia 00:21:18
vale, esto que hemos dejado aquí está vacío 00:21:20
y no existe, entonces no sabe qué hacer 00:21:23
y pone la variable 00:21:25
la instancia de la clase explicaciones tut 4 no ha sido asignado y el juego se detiene no es que se 00:21:26
puede hacer mucho más es que hay un error grave no a veces para evitar eso porque en ocasiones 00:21:34
podemos estar haciéndolo en ocasiones no se puede hacer una condicional de que algo exista vale mira 00:21:39
de hecho lo está aconsejando ahí porque está detectando que algo pasa si ponemos y de hecho 00:21:46
con el tabulador, como me salía la sugerencia, pulso el tabulador y lo pongo, ¿vale? 00:21:51
Podemos hacer que haya un comparativo de que algo exista o no, y aquí decimos, 00:21:58
sí, nosotros hemos hecho esta variable y debería existir, ¿vale? 00:22:02
Y en teoría la vamos a usar y por eso la hemos creado, pero en ocasiones a lo mejor estamos jugando un juego 00:22:06
y le decimos, cuando le demos al botón izquierdo del ratón, que dispare balas de nuestra arma, ¿no? 00:22:10
Y en ocasiones puede ser que no haya balas 00:22:16
Porque la bala sea un prefab 00:22:19
Que se lanza la bala físicamente 00:22:20
A lo mejor al arrancar el juego 00:22:23
No hemos cogido ningún powerup 00:22:24
Ningún ítem que sea el de adquirir balas 00:22:26
Entonces está vacío 00:22:29
Si no lo hemos contemplado 00:22:30
Puede que llegue el caso en el que ocurra esto 00:22:32
Estoy poniendo como un ejemplo que pudiera ocurrir esto 00:22:34
Hasta que no cojamos bala 00:22:36
No estamos rellenando este GameObject 00:22:37
Para luego instanciar esas balas 00:22:39
Entonces si estamos dando a la condición de 00:22:40
Sí, pulsa, y cuando pulses que se lance la bala 00:22:43
Va a dar error porque va a decir, vale, si yo estoy haciendo esa operación, pero no instancionada porque no hay nada y sale este mismo error que estábamos viendo antes. En ocasiones, aquí podemos poner luego más condiciones en plan, si pulso gatillo, ¿vale? Estoy hablando físico para que lo entendamos, ¿vale? Esta condición. 00:22:46
que se ejecute lo que hay aquí, ¿no? Tenemos esto y que se ejecute aquí, ¿vale? Pero este error es porque no está declarada la variable, ni hay un método ni nada. 00:23:04
Pero en ocasiones, para directamente evitarnos el error de que algo no funcione, porque aquí instancia no estaría funcionando todavía porque no existe, no está asignada, 00:23:16
Si ponemos esto de aquí, y lo voy a poner así para que lo veamos como antes, recordad que yo antes cuando no he puesto esta condición y solo he puesto la línea de instancia, daba error porque no encontraba la instancia. 00:23:27
Pero ahora si decimos, oye, si la instancia es igual a null, no existe, ¿vale? Haz esto. Esto no tiene sentido porque lo que queremos decir es precisamente, si instancia existe, si instancia es diferente a null, 00:23:39
Es decir, de verdad hemos asignado algo, ejecuta la instanciación, ¿vale? Vais a ver que ahora cuando lo hago, ¿vale? Aunque no está instanciando nada, es decir, está pasando por esta condición, ¿no? 00:23:54
Me explico. Llega aquí el código y dice, ¿instancia es diferente a nul? No, es igual a nul, porque no existe. Entonces pasa esto y no hay ningún problema. Con esta línea aquí hemos evitado que haya un problema, que salga el error grave y se detenga. 00:24:13
Si instancia es igual a nul, es decir, que no hemos asignado nada, aquí ponemos debug log que ponga no hay objeto asignado. 00:24:29
asignado, ¿vale? Y luego lo que hacemos aquí es, si ocurre lo contrario, que es con este else, es decir, si ocurre lo contrario, pues que se instancia, es decir, 00:24:50
si se hubiera asignado, pues habrá que instanciar. En este caso estamos todavía en el momento, aquí me falta una llave, ¿vale? Estamos en el momento en el que no se ha 00:25:02
instanciado nada. Y aquí debe de faltar otra llave, por lo que veo. Esta llave. Vale. Esta llave que, de hecho, se puede eliminar porque he puesto alguna de más. 00:25:11
Entonces, ahora mismo estamos en el caso de que no existe esta instancia. Por eso va a poner no hay objeto asignado. Y yo aquí, a ver, tengo que guardar. 00:25:22
Importante el script. Y ahora yo lanzo el juego y me va a poner ese mensaje porque no tiene nada que asignar. No hay otro objeto asignado, pero como 00:25:33
Luego salta esta operación que remite instancia, la salta y no hay error, ¿vale? En el momento en el que arrastremos, por ejemplo, un prefab ahí, pues yo qué sé, aquí tengo algún prefab, mira, pues la nave, la asigno, ¿vale? Porque sería lightfield y cuando lanzo, ahora vais a ver que lo que hace es, si voy aquí, pues lo que ha hecho es la instancia, ese clon de esta nave que tenía yo preparada. 00:25:40
¿por qué? porque ha llegado aquí, ha dicho si instancia es igual a null, no, no es igual a null 00:26:05
sí que tiene algo, por tanto lo que tengo que hacer es instanciar 00:26:09
¿vale? y veis que en todo momento se puede ir enfocando en que sea igual, diferente 00:26:13
ahora si es diferente a null lo que va a hacer es poner esto 00:26:19
porque como sí tiene algo, aunque luego se va a saltar las siguientes condiciones 00:26:23
porque ya se ha cubierto la primera, pero yo ahora cuando lanzo el juego 00:26:27
me va a poner otra vez el texto, no ha hecho ninguna instanciación 00:26:31
y me ha puesto no hay objeto asignado, ¿vale? 00:26:34
Veis que estos operadores son muy importantes porque son los que van a ir 00:26:36
marcando qué se ejecuta y qué no durante el código. 00:26:40
En su momento, veríais en los vídeos que se hablaba de que 00:26:50
todas las acciones que se hagan durante el juego, 00:26:55
durante la ejecución del juego, cuando se da a play, ¿vale? 00:26:59
No se guardan, simplemente son acciones que podemos hacer aquí para probar. 00:27:02
Voy a hacer un ejemplo rápido. Voy a hacer que esto sí se instancie, ya que lo tengo aquí preparado. No pongo ni condición. Está asignado y se instancia la nave. Esto cuando tengáis que mover cosas y usar el transform va a ser importante, por eso lo digo. 00:27:08
Voy a poner este ente object en el que he puesto la instanciación en el 0, 0, 0, para que esté en un punto de origen. Lo que he hecho ha sido resetear con estos tres puntitos, se puede resetear el componente. 00:27:24
Ahora lo que va a hacer es instanciar, y voy a ponerme el game aquí al lado para tener la escena y el game, instanciar la nave en el punto 0, 0 porque es donde está básicamente el nulo. 00:27:40
Yo luego puedo estar haciendo pruebas e ir viendo a ver qué pasa si yo pongo la nave aquí o si la subo. Vais a ver que yo, cuando detenga la ejecución, nada de eso se ha guardado. No se ha guardado ni el clon que se ha emitido ni los valores del clon. 00:27:52
Si lo hiciera en juego también, que sí que se ve aquí, ¿vale? Y empiezo a decir, en vez de mover la nave voy a mover el nulo que origina esa nave, ¿vale? Que es independiente porque no lo ha hecho su hijo, como podéis ver, ¿vale? Y voy probando y digo, yo quiero que la nave, como se va a instanciar donde esté este nulo cuando arrancamos el juego, lo voy a colocar ahí, ¿vale? Y dice, ese es el punto que quiero. 00:28:09
Cuando paró la ejecución, veis que vuelve al punto en el que estaba antes. 00:28:31
Entonces, mientras estamos probando el juego en su reproducción, tened cuidado que todo lo que vayáis cambiando, todos los valores, se pierden. 00:28:36
Entonces, para advertir de que eso está ocurriendo, hay una indicación visual, que yo creo que lo indiqué, pero me parece relevante en este momento del curso verlo, 00:28:45
que es que si vamos a Edit y Preferencias, hay una sección que se llama Colors, que es con lo que se asignan los colores que se muestran ciertas cuestiones de la interfaz. 00:28:54
Y hay uno, un valor que se llama Play Mode Tint, y por defecto viene en un gris, que veréis si no lo habéis cambiado, que cuando activáis este Play en vuestros casos, 00:29:07
se pone un poquito más gris la pantalla 00:29:15
pero casi no se nota 00:29:18
os sugiero que aquí pongáis un color 00:29:19
más o menos chillón, vale, voy a poner 00:29:22
ahora un verde para que veáis, que lo que hace 00:29:24
una vez ya lo asignáis es que al darle 00:29:26
al play, se colorea 00:29:28
esto de otra forma para saber que en ese 00:29:30
momento estamos en la reproducción, porque es muy fácil 00:29:32
pensar que no estamos en la reproducción, ponernos 00:29:34
a tocar valores y de pronto anda 00:29:36
pero si está en reproducción y paramos 00:29:38
y todo lo que habíamos trasteado 00:29:39
no se ha guardado, vale 00:29:42
Entonces os recomiendo para estar como alerta o prevenidos de que estamos en el momento de editar, que pongáis un color que tampoco sea super excidente y moleste, pero que marque. Yo me lo pongo rojo como de alerta y así colorea todo. 00:29:43
y sé que todos los cambios que está haciendo en este momento son temporales y que, por ejemplo, y esto ocurre mucho, a lo mejor sí que sabemos que es aquí donde queremos colocar este nulo, 00:30:00
sabemos que al parar se va a ir al traste y entonces lo que tenemos que hacer es apuntarnos estos valores para luego replicarlos o con clic derecho copiar el valor, 00:30:10
lo copiáis, lo tenéis ahí 00:30:23
y ahora, lo que pasa es que esto vale con algún valor 00:30:25
no con todos, y ahora podéis ir y pegarlo 00:30:27
y ahí lo tenéis, y ahora se ha colocado 00:30:29
donde habéis hecho esta preview 00:30:31
esta prueba, ¿vale? antes, mientras 00:30:33
estaba en vivo, y también porque en ocasiones 00:30:35
vais a ir viendo que estas pruebas las hacéis 00:30:36
porque al darle a ejecutar el juego, efectivamente 00:30:39
se van a mover cosas, lo que tengáis 00:30:41
ya previsto que se mueva 00:30:43
entonces, las pruebas las queréis hacer en vivo 00:30:45
pero cuando paréis el juego 00:30:47
eso, todo lo que estéis ajustando 00:30:49
lo vais a tener que reajustar, por eso 00:30:50
también, y mira, me sirve también de ejemplo 00:30:53
si por ejemplo estáis en esto 00:30:55
y decís aquí en este momento 00:30:57
ah, vale, pues voy a asignar 00:30:58
lo he vaciado el 00:31:00
que referencia a esta instanciación 00:31:01
digo, voy a asignar la nave 00:31:04
y lo pongo ahí, vale 00:31:05
y luego digo, ya lo he hecho 00:31:07
y sigues haciendo cosas aquí, y tocas 00:31:09
y dices, que bien, ya lo he asignado 00:31:12
cuando salgáis de aquí, fijaos que está en 00:31:14
none, vale, entonces eso 00:31:16
que mientras estéis en este 00:31:18
modo de trabajar 00:31:19
no se están guardando las cosas 00:31:21
en el tema 2 00:31:25
se habla ya de los vectores 3 00:31:32
los vector 3, los vector 2 00:31:34
cómo se opera 00:31:37
en las primeras 00:31:37
tutorías grabadas ya se hablaba 00:31:42
cómo sumar y restar valores, etc 00:31:44
pero aparecerá ya 00:31:46
el concepto de sumar vectores que son 00:31:49
digamos valores, matrices 00:31:51
con distintos 00:31:52
elementos 00:31:53
Sí que me gustaría hablar de una cosa que es parecida o relacionada con los vectores multidimensionales, que tienen varias propiedades, pero que no es exactamente lo mismo, que es algo que viene introducido en el tema cero, pero que tampoco se ahonda demasiado, que es el concepto de array. 00:31:55
Y esto lo voy a explicar con ejemplos rápidos, que luego más adelante habría otras formas quizás mejores de hacerlas, pero me sirve y bueno, también se podría hacer de este modo, pero os digo pues eso, una forma de conseguir algo. 00:32:22
Imaginaos que estáis en un juego y vosotros tenéis cuatro armas posibles. Hay cuatro armas en el juego. Con un array, por ejemplo, lo que hace es, dentro de una sola variable, poder agrupar o poder tener recogidos varios valores distintos. 00:32:41
Si un número, si un int guarda un valor, por ejemplo, 5, en un array lo que se va a poder hacer es guardar varios valores. 00:33:01
Por ejemplo, y esto vamos a ver cómo se nos da. Se puede crear un array de un número de dimensiones determinada. 00:33:16
Por ejemplo, este. Y 5 aquí. Y vais a ver que la estructura de un array básicamente es una sucesión de valores separados por coma. 00:33:28
Y esa sucesión de valores tiene un orden también. Entonces, dentro de este array llamado armas, que de momento lo voy a llamar número, 00:33:41
luego ponemos el ejemplo de armas, estamos diciéndole que dentro de esta variable no solo se guarde un valor numérico, 00:33:48
sino que se guarden varios. Y yo en cualquier momento voy a poder entrar en ese variable que tiene bolsillos, vamos a decir así, esa caja subdividida, que dentro tiene valores. 00:33:54
¿Cómo se accede a los valores de un array y cómo se guardan? La forma de inicializar un array es, si declaramos un array, después del nombre de la variable hay que poner este corchete vacío. 00:34:05
No hay que poner nada ahí, ¿vale? Y luego, como hacemos siempre, ponemos el nombre de la caja, ¿vale? De la variable. Este es el tipo, ¿vale? Podrá ser in, string, booleano, lo que sea. Y luego la variable. Con este corchete decimos que no solo va a haber un valor, que va a haber un array, que va a haber varios guardados. 00:34:19
Si queremos decir cuántos compartimentos o cuántas subdivisiones tiene ya, incluso ya con los valores, se puede hacer ya desde el momento de la declaración. De esta forma. Con esta forma de mostrarlo, lo que hacemos es ya incluir que ya en el primer valor que guarda este array valdrá 1, el segundo valdrá 2, el tercero valdrá 3 y el cuarto 5. 00:34:36
¿Vale? Entonces llega el momento en el que, por ejemplo, podemos decir, ¿vale? Ahora ahondamos más en algunas cosas. Podemos decir debug log y quiero mostrar el valor que está dentro de la variable números en su posición 2. 00:35:01
vais a ver que para declarar después del tipo de variable 00:35:17
hay que poner este corchetillo, estas llavecitas 00:35:20
estos corchetes, mejor dicho, y luego cuando queramos 00:35:23
hablar o usar ese array 00:35:26
como variable, habrá que poner el nombre de variable 00:35:30
los corchetes y dentro de los corchetes la posición que queramos usar 00:35:32
¿vale? entonces 00:35:35
¿qué pensáis que va a mostrar consola? porque estamos poniendo 00:35:37
un debug log, que va a poner qué número va a mostrar 00:35:41
la consola, si yo doy a play 00:35:44
el número que muestra es 0, si os fijáis 00:35:48
aquí lo tenéis, ¿vale? ¿por qué? porque las posiciones de un array 00:35:52
¿vale? y normalmente todo lo que tenga varias dimensiones suele ser así, siempre empieza por 0 00:35:56
es decir, la primera posición que se refiere en este caso a esto es 0 00:36:01
entonces, por ejemplo en este, si hacemos este código 00:36:04
lo que va a mostrar es un, ¿vale? bueno, fijaos, yo estoy saliendo todo el rato, cambiando de pantalla 00:36:09
me doy cuenta rápidamente de que estoy en play porque veo esto rojo, ¿vale? 00:36:13
Es que es útil también para eso. 00:36:17
Le vuelvo a dar, ahora que he guardado, y lo que muestra es 1, ¿no? 00:36:18
Si yo mostrara la posición 3, y guardo y vuelvo, ¿cuál sería la 3 según esta lógica? 00:36:22
¿Qué valor mostraría? 00:36:30
3 sería 5, ¿no? 00:36:33
0, la posición 0, la posición 1, la posición 2, la posición 3, ¿vale? 00:36:34
Mostraría un 5, vamos a verlo, pero ya os adelanto que debería. 5, ¿vale? ¿Qué ocurriría si ponemos aquí un 5? Dentro de estas cajas lo que sucede es que tiene un número de compartimentos predefinidos en algún momento al inicio y que además no se puede variar en el tiempo. 00:36:39
Es decir, en este caso ya hemos declarado que este array es de cuatro dimensiones, ¿vale? O de cuatro posiciones. La de dimensiones igual no es el término más correcto. Posiciones, tiene cuatro posiciones. 00:37:05
Si pedimos que tenga más, no es que vaya a decir cero, porque como no existe, no. Lo que va a dar es un dato, esto de índice fuera del rango, ¿vale? 00:37:18
Entonces, ojo, cuando vayáis a usar en algún momento Arrays, tened muy en cuenta que si nos salimos del rango que tiene, puede dar problemas. 00:37:27
Entonces, esto lo digo porque hay otra forma de declarar un Array, y esto lo comento para poner la otra, que sería, por ejemplo, poner int, digo que es un Array, números, 00:37:38
y yo no sé los valores, pero sí sé que va a tener cuatro posiciones, como tenía este de antes, ¿vale? 00:37:51
Y se declararía así, ¿vale? Entonces, aquí ahora mismo sí que vais a ver que si pongo dos, 00:37:59
¿el valor cuál va a ser? En este caso sí que existen los compartimentos, ¿vale? 00:38:05
Y no están cargados de nada, de cero, ¿vale? Pero sí que existen. 00:38:10
Entonces, ahora cuando digo el valor 2, lo que va a mostrar es que vale 0, porque es el valor por defecto que viene. 00:38:14
Entonces, eso, que sepáis que los arrays tienen valores, un número de cajas, digamos, de compartimentos predefinidos por, o que lo declaramos, 00:38:22
o de forma explícita con los valores, o de forma explícita, pero solo con el número de posiciones que tiene, ¿vale? 00:38:31
Y luego aquí es donde podemos ir operando como con cualquier cosa, con cualquier variable y decirle, vale, en este punto, ahora mismo todo vale 0, pero en este punto la variable que está en la posición 1, que ojo, la 1 sería la que está aquí, no la primera que se ve. 00:38:36
¿Vale? Importante, que eso sí es importante que lo tengamos en cuenta. Pues esta que valga a 2, ¿vale? Y entonces ya se ha guardado dentro de números de esta variable, como siempre, porque está dentro del ámbito adecuado, que la posición 1 va a valer 2. 00:38:52
Por eso yo ahora si muestro números 1 o incluso me salgo del start, lo he declarado aquí, he dado el valor aquí, se ha guardado en una caja que es una variable global y luego en el update lo pongo aquí, lo que va a mostrar es fotograma tras fotograma el valor 2. 00:39:09
Y vais a ver que 2, 2, 2, 2, pues no para ahí de sumarse todo el rato y ahí lo tenemos. 00:39:30
Esta lógica de los arrays es importante porque aunque no funcionan exactamente como un array, 00:39:36
y ya saldrán casos en los que un array es necesario, ya más o menos sabemos cómo funcionan. 00:39:43
Entiendo que se entiende un poco mejor que a lo mejor en los apuntes, aunque esté explicado también. 00:39:49
Bien, si os dais cuenta, al final cuando tenemos valores con varias posiciones guardadas, ¿vale? Como este transform position vais a ver que al final tiene tres valores guardados, el de x, el de y y el de z, pero son tres valores distintos numéricos, ¿vale? 00:39:53
Todo esto se basa en valores multiposición, que pueden guardar varios valores en sí. En sí el position es más un strut, el vector 3 es un strut, pero un poco el funcionamiento es parecido al de un array. 00:40:11
Cuando veáis que trabajáis con coordenadas o con posiciones o con direcciones, esto en el tema 2, estoy adelantando, vais a ver que existe esto del vector 3 y el vector 2. 00:40:29
Y un vector 3 al final, que es un tipo de variable que se puede generar como in, bool, etc., también puede ser posiciones. Y vais a ver que vais a tener que, new vector 3, vale, dame un segundo, new vector 3, 0, 1, a ver si me deja y no da problemas, ¿vale? 00:40:41
¿Vale? Vais a ver que para decir estas posiciones que son vectores 3 como las que maneja el transform, ¿vale? Al final la lógica es un poco lo mismo. Poner valores separados por coma y en el orden adecuado, ¿sí? 00:41:03
Cuando vais a ver también, que esto también se explica, que cuando estamos trabajando con Vector3, cuando generamos variables con más de un valor, ¿vale? Tenemos que ir como generando instancias, ¿vale? Ahora que hemos usado instancias de GameObjects, generando instancias de variables, ¿vale? 00:41:17
Por eso vais a ver que cuando tengáis que hablar o poner un valor de un vector 3 en mitad de un código, vais a tener que poner esta palabra new, ¿vale? 00:41:37
Porque un vector 3, como es un valor múltiple, guarda varios valores, hay que generar una nueva instancia que guarda varios valores. 00:41:45
Lo que vamos a poder hacer con un vector 3 es decirle, vale, yo quiero que este objeto que tenga este script, ¿vale? 00:41:53
cuando arranque el juego se ponga en esta posición, ¿vale? Porque le estamos pasando un valor que es un vector 3 de en x 0, en y 5 y en z 1, ¿vale? 00:42:00
Si yo guardo y ejecuto este código vais a ver que quien tiene el código que es este juego que ahora está en menos 8 y 15 con 25, al arrancarlo se va a poner en 0, 5, 1, ¿vale? 00:42:13
Que son las posiciones que habíamos pasado por este valor. ¿Vale? Veis que un poco lo que está haciendo es colocar cada uno de estos números en la cajita correspondiente a su posición. 00:42:23
Los valores pueden ir cambiando durante el tiempo. Cuando yo pongo este, pongo yo que sé, varios valores, lo voy a llamar así, ¿vale? A este array. 00:42:33
new, y voy a poner new int, ¿vale? 00:42:48
Veis que cuando estoy declarando, lo que os he dicho antes, 00:42:51
una nueva variable multiposición, vamos a decir, como un array, 00:42:55
para generar, digamos, valores de esa variable, 00:43:03
es muy normal tener que poner este operador de new. 00:43:08
Si no, vais a ver también que da error, ¿vale? 00:43:12
Cuando dé un error en algo multiposición y digáis por qué pasa, probablemente es que falta este new. Las cinco posiciones que tiene esta array valen cero, ¿no? Existen, pero valen cero. No van a dar error si las llamamos, pero valen cero. 00:43:16
Nosotros luego podemos ir diciendo int en su posición 1, que es lo que había hecho antes, vale 4. La posición 1 vale 4. En la posición 2, incluso te lo indica ahí, vale 0. 00:43:28
Ahí estamos cambiando los valores que hay aquí. Entonces nosotros incluso podemos decir debug log y podemos decir que nos muestre varios valores y se podría poner 0, aquí varios valores, 1, etc. 00:43:55
Podemos ir poniendo los diferentes. Voy a poner los dos primeros. Entonces, cuando muestre esto, varios valores, esto lo está mostrando con un número, hay que hacer otro debug log aquí. 00:44:20
¿Vale? Pero aquí podemos ir viendo los distintos valores, habría que hacer distintos debug logs, no se pueden condensar todos en uno así. Si vamos mostrando los distintos debug logs y vamos cambiando el valor que muestran, ahí se me ha colado un 6, ¿vale? 00:44:39
Si yo ahora lo ejecuto, vais a ver que no todos los números que ponen son 0. El primero será 0, el segundo será 4, el tercero será 0, el siguiente será 0 también, voy a ponerle un 7 mejor, ¿vale? Y 0. Entonces, aquí hemos cambiado los valores ya durante la ejecución del juego. 00:44:57
Entonces yo si lanzo esto 00:45:12
0, 4, 0, 7, 0 00:45:15
Entonces aquí hemos creado el cajón 00:45:18
Pero lo hemos cambiado después 00:45:20
Incluso después podemos decir 00:45:21
Vale, y que varios valores 3 00:45:23
Una vez 00:45:25
Ya lo ha impreso en pantalla 00:45:27
En consola 00:45:29
Vas a valer 00:45:30
Vale, entonces 00:45:34
Lo que ponemos aquí 00:45:35
0, 4, 0, 7, 0 00:45:40
y a ver que no está mostrándolo 00:45:45
vale, y me falta poner otra vez el debug log 00:45:46
de 3, que es el que estoy cambiando 00:45:48
y vais a ver que ahora va a haber otra línea 00:45:50
que va a añadir un 8 00:45:52
va a poner otra línea que es un 8 y lo hemos cambiado 00:45:54
en dinámico, claro 00:45:56
y se pueden concatenar, lo que pasa 00:45:57
es que si los concatenamos 00:46:04
como son números, habría que convertirlos 00:46:07
en texto, vale, pero 00:46:09
bueno, igual me equivoco, pero si yo 00:46:10
los concateno así, vale 00:46:12
pongo este 00:46:14
lo que va a hacer es sumarse 00:46:18
lo que sí se puede hacer es decirle 00:46:20
que aquí haya un espacio 00:46:23
y como esto ya lo ha convertido 00:46:25
en texto, pues ahí sí que lo haría 00:46:27
pero bueno, vamos a poner un espacio 00:46:29
y una coma 00:46:31
ahí, ¿vale? 00:46:32
y ahora sí que lo va a mostrar, 0 y 4 que son los dos 00:46:35
primeros valores que tenemos 00:46:37
el 0 que no hemos dicho nada y el 4 00:46:38
que si una vez se han dicho cuántas 00:46:40
posiciones tiene un array, pues imagínate, hemos dicho que hay 5 valores de armas, 5 00:46:48
armas posibles, y luego de pronto durante el juego quieres que haya 7. Ese tipo de operación 00:46:55
no se puede hacer con un array, no se puede decir que a lo largo del juego, no que va 00:47:02
a cambiar los valores de estas 5 posiciones, sino que de pronto pase a tener 7 posiciones. 00:47:05
Para eso existe otro concepto parecido, pero bueno, tiene más funcionalidad y es más 00:47:11
complejo que es el de lista, list en Unity, voy a buscarlo aquí, vale, entonces bueno aquí por ejemplo si buscáis ahí documentación, las listas si son un elemento que permite reordenar con otros comandos, cambiar el número, la longitud de posiciones, vale, a ver, bueno mira de hecho aquí hay una explicación que dirá, las listas son muy parecidas a los arrays, vale, y es, tiene otra sintaxis y es más 00:47:16
elaborado, por eso no hablamos de ello 00:47:46
ahora, pero también existen las listas 00:47:48
los arrays sí que es verdad que una vez se dice 00:47:50
el número de posiciones, no hay forma 00:47:52
fácil de cambiarlo, por ejemplo 00:47:54
otra cosa importante, que esto 00:47:56
no lo he puesto, pero si yo esta 00:47:58
variable array, si esta array 00:48:00
mejor dicho que variable, digo que sea un serialize 00:48:02
fill, y lo vemos 00:48:04
aquí, vale, guardo y voy 00:48:06
aquí, vais a ver 00:48:08
que se genera 00:48:10
a nivel visual, ¿no? 00:48:12
como hemos hecho en otros momentos 00:48:14
las posiciones de un array de 5, veis que empieza por el 0, tiene 5 posiciones, 5 posibles, y empieza por 0, por eso acaba siempre con un 1 menos, con un valor menos. 00:48:15
Están aquí vacías porque recordad que hasta que no arranquemos el código el script no se ejecuta y te pone aquí los valores, y aquí es lo mismo, 00:48:29
Aquí podemos ir cambiando los valores en vivo, etcétera, que cuando los paremos van a volver al cero porque, una vez más, esto ya se dijo seguro en alguna de las grabaciones, estos valores varían los del código, siempre y cuando el código después no vuelvan a cambiar en ejecución estos valores, ¿vale? 00:48:37
Hay un orden. Por defecto, nosotros aquí podemos decir que esto valga 5, pero al arrancar el juego ha habido una combinación. ¿Por qué? Porque como en ningún momento del código solo se han creado las cajas, pero no se dice que valga explícitamente 0, este valor lo hemos cambiado aquí, con la edición que hemos hecho de este valor mediante el inspector. 00:48:55
Pero luego al arrancar el juego sí que se dice al iniciar el script que la posición 1 y 3 adquiera estos valores y por eso hace esta combinatoria. Vale 0 todo, pero estamos cambiando por el editor esto y por el código esto. 00:49:20
Esto es lo mismo que cuando aquí estamos cambiando los valores de las posiciones. Aquí estamos cambiando posiciones. Si en el código no decimos explícitamente que adquiera otra posición, donde se irán colocando los elementos y la rotación, etc., si os fijáis es el mismo comportamiento. 00:49:38
es lo que estamos cambiando en el inspector. Esto no deja de ser, al final, una clase, un script que se llama transform y que se ha programado para que tenga estos huecos, 00:49:54
igual que nosotros aquí estamos programando otra variable para que tenga estos huecos. Y aquí incluso se pueden ir cambiando órdenes, etc., de manera visual, 00:50:05
que cuando yo arranque, pues ahora yo el que he cambiado a mano es esta posición 2, pero las otras dos por código nuevamente lo que están haciendo es lo que tienen que hacer, 00:50:13
que es proporcionar unos valores. Y si yo luego después de mostrar esto como he hecho antes, le digo que aquí varios valores 1 valga 100, 00:50:25
Pues en la posición 1, primero momentáneamente pondrá 4, pero finalmente la que se va a quedar es el 100. Ahí lo tienes. Aquí nos ha impreso 0 y 4, que son los valores que habíamos pedido al principio, pero tened en cuenta eso, el orden de ejecución. 00:50:37
Bien, si yo creo un array de booleanas y le digo que sea de 5 valores, quiero que también veáis que esto, dependiendo del tipo de variable con la que se compone ese array, ¿vale? Veis que ahora las casillas son de sí o no, de clicar o no, ¿vale? 00:50:55
Y esta se ha puesto positiva, a ver, porque ya estaba por defecto, ¿vale? Aquí podéis cambiar también el número de valores del array, ¿vale? Pero en el editor, si lo cambiáis, es decir, si lo cambiáis luego durante la ejecución, esto va a dar problemas. 00:51:14
Entonces, si tenemos varias armas y por ejemplo lo que hacemos es un array de GameObjects, que son por ejemplo el prefab del arma, vamos a poner eso como ejemplo, cuando veamos ese array aquí vais a ver que sorprendentemente lo que nos está pidiendo, y fijaos que aunque yo estoy cambiando el código aquí, el inspector es independiente. 00:51:33
Si aquí ponemos 5, como estos varios valores, que es el nombre de la variable, recordadlo, lo que va a hacer es esperar GameObjects, es decir, esperar prefabs, por ejemplo, o las armas. 00:51:56
Tú sí que es verdad que mientras no cambies el número de compartimentos que tengamos aquí, puede haber un momento del juego que lo que hagamos es que en vez de estar cubo, se sustituya por nave prefab. 00:52:10
Eso se puede ir haciendo. Y luego tú ya dices, lo que quiero mostrar es el valor, el arma, el GameObject que está en varios valores, posición 2, que es la nave. 00:52:19
Vamos a hablar de vector primero, yo que sé, pongo un nombre así identificativo, y vector segundo. 00:52:36
Aquí he creado dos variables, que si las pusiera visibles en el inspector para que lo veamos como es esto realmente, que igual es la forma más fácil 00:52:49
Si yo voy a ver que es esto de vector 3 y solo lo he puesto en vector primero que sea visible, vais a ver que al final lo que nos está mostrando es vector primero 00:53:00
Y cuando es un vector 3, lo que hace es que ya los vectores están relacionados con dimensiones, con ejes, mejor dicho. X, Y, Z, ¿vale? De hecho, también, para que veáis que existe, existe vector 2, que lo que tendrá será solo dos dimensiones, X e Y, por ejemplo, que se usará en juegos 2D, por ejemplo. 00:53:09
O en juegos 3D, pero solo para tener dos. Incluso existe un vector 4, que si le doy, me pone x, y, z, w, que cuando leáis el tema va a tener relación con eso de los quaternions, lo va a sonar. 00:53:32
Un vector 3, al final, lo que nos permite también es guardar ya valores desde el principio. Nuevamente, como es un valor compuesto por varios, y veis que cuando me pongo encima pone que es de tipo strut, y un strut es una especie de constructor de valores múltiples, no me quieren revesar con esto. 00:53:49
Cuando tenemos una variable de tipos, como lo que hemos dicho antes con los arrays, de diferentes valores, que guarda varios valores, hay que poner esta palabra nuevo cuando vayamos a inicializarlo o en muchas ocasiones usarlo. 00:54:10
Yo digo que esto valga estos valores. Ahora mismo tenemos un valor aquí que se inicializa como 5, 1, 5. ¿Qué significa esto? Que yo puedo ir luego a el componente transform y decirle que la posición sea vector primero. 00:54:23
Y lo que estamos diciendo aquí es que coja los valores de este vector que tenemos aquí 00:54:42
Yo cuando voy a este elemento, lo que he hecho antes 00:54:48
Si le doy play, aunque esté en menos 11 y 0 en posición 00:54:52
Al arrancar el juego, me lo está poniendo en 0, 0, 0 00:54:56
A ver, esperad un segundo, transform position vector primero 00:55:01
¿Por qué no me lo está cogiendo? 00:55:05
No se está inicializando bien. Voy a quitar esto un segundo. Guardo. Y ahora sí debería ir. Vale, 5, 1, 5. Cuidado cuando a veces pongáis serialize fill o que sea público y declaráis aquí las variables en vez de en el inspector porque se pueden sobreescribir y aparecer problemas como que no funcionan ciertas cosas. 00:55:10
Ser conscientes de ello. Entonces, cuando ya iremos viendo que al final lo que vamos a ir haciendo en los juegos en gran medida es ir introduciéndonos en estos componentes e ir cambiando sus valores. 00:55:39
Dentro de un componente luego puede haber subcomponentes o propiedades. En este caso, la forma de atacar o de actuar sobre los elementos del transform es poniendo esta palabra reservada que es transform, 00:55:53
que es, digamos, de los pocos componentes que tiene su propia palabra y no hay que capturarlos, cuando vayáis trabajando vais a ver que vais a tener que, cuando queréis, por ejemplo, aludir a un componente tipo BoxCollider, por ejemplo, vais a tener que hacer primero una captura del componente para decirle voy a actuar sobre este componente y sobre Istrigger, por ejemplo. 00:56:14
Pero cuando estamos afectando sobre el transform, con poner la palabra transform punto y la propiedad sobre la que queremos actuar, por ejemplo, la escala local, local scale, que es la escala, pues podemos decir que sea también vector primero. 00:56:38
Y vais a ver que ahora mismo estamos actuando al iniciar el juego sobre, y vais a ver que además son iguales la escala, sobre la escala y sobre la posición de forma similar. 00:56:58
Entonces, esto es lo que nos va a permitir luego es también que podamos ir haciendo operaciones con vectores, que son, volvemos a ver, valores combinatorios, 00:57:12
es decir, valores múltiples que se pueden combinar o se pueden sumar o se pueden restar, que devuelvan vectores más complejos o combinaciones de vectores. 00:57:23
Por ejemplo, si yo ahora un vector resultado, igual que podíamos sumar números en un tercer, es decir, en número 1, número 2, en un número resultado, 00:57:32
Esto ya está en otras tutorías. Si yo aquí pongo que vector resultado, que ahora mismo está vacío, valga lo que es vector primero más vector segundo, lo que va a hacer es sumar los valores de ambos vectores. 00:57:44
Pues ahora mismo como vector segundo es 0, 0, 0 porque no hemos puesto ningún valor y por tanto no lo hemos inicializado. 00:58:06
Y ojo, se puede inicializar también aquí, por ejemplo, decir vector segundo al arrancar el juego pasa a valer vector 3. 00:58:12
Si vais a ver ahora una cosita de nuevo, que es que vector segundo vale un vector 3 de 0, 5 y 7, por ejemplo. 00:58:23
Y bueno, me falta poner un punto y coma, mejor aquí. 00:58:33
Vale, da problemas. Vais a ver que cuando estamos operando con vectores hay que poner, a diferencia de con los números sin, por ejemplo, que pones aquí 5 y se acabó porque es solo un valor, como aquí estamos operando con varios valores, pues hay que poner que es un vector 3 que recoge estos tres valores. 00:58:35
Y recordad que cuando metemos valores brutos, como hacemos aquí o como os he dicho antes, al ser una estructura tenemos que inicializar o instanciar un nuevo vector 3. Y ahora este vector segundo pasa a valer 0, 5 y 7. 00:58:51
Entonces, ahora mismo, las operaciones entre vectores, que es lo que vamos a conseguir con vector resultado, 00:59:07
en este caso estamos sumando, veis que con el nombre de las variables, aquí no hay ningún número, 00:59:14
los vectores primero y segundo. 00:59:18
¿Qué resultado va a dar esto? 00:59:20
¿Qué va a devolver la consola? 00:59:23
Las operaciones entre vectores, de suma y resta, lo que hacen es sumarse entre sí las posiciones. 00:59:26
Es decir, la primera posición se suma con la primera, la primera de aquí se suma con esta, 00:59:33
¿Vale? Resultando en este caso, por ejemplo, en 5, 6, 12. Vamos a verlo. Si nos fijáis, 5, 6, 12. Y veréis además que dentro de un vector 3, por defecto, los valores son floats. 00:59:37
¿Vale? Entonces, no tengáis miedo por poner aquí 5.5 y, ojo, recordad, como es float, separado con punto y con coma. Digo, por punto y poniendo la f de float, ¿vale? Para que no dé error. 00:59:54
Ahora pasaría a valer 5,5 y aquí voy a poner 1,5. Pasaría 5,5 más 1,5, 7, 6, 12. Serían los valores. Esto es importante porque va a ser lo que nos va a ir determinando las sumas y operaciones de los distintos interacciones que hagamos. 01:00:07
7, 6, 12, ¿vale? Lo mismo con las restas, las restas se restan entre valores, pues aquí sería 5 con 5, y aquí pongo un menos, 5 con 5 menos 1 con 5, pues sería 4, 1 menos 5 sería menos 4, y 5 menos 7 menos 2, es decir, 4 menos 4 y menos 2, guardamos, y esto da 4 menos 4 menos 2, ¿vale? 01:00:30
estas operaciones van a ser muy importantes a medida que vayáis haciendo porque al final todos nuestros valores del transform por ejemplo de posición, rotación y escala 01:00:56
pues se van actualizando y desactualizando en función a vectores que van afectando uno a otro pues sumando para ampliar la dirección o la velocidad o la posición 01:01:06
o restando para decrementarla. Entonces esto es importante entender cómo funcionan los vectores 3. 01:01:14
Una última cosa, también se habla en el tema, ¿qué pasa si yo lo multiplico? Los vectores entre sí no se pueden multiplicar. Sí se puede multiplicar un vector, por ejemplo, por un número, y lo que vais a ver es que lo que va a hacer es multiplicar por ese número cada uno de los valores. 01:01:21
Por ejemplo, aquí, vector primero, que es este de aquí, por 2 sería 5,5 por 2, 11, 2 y 10. 01:01:37
Bueno, yo guardo y va a ser 11, 2, 10, hemos dicho. Guardo, ejecuto, 11, 2, 10. Ahí está. 01:01:44
Pero no se puede multiplicar un vector por otro. Para eso hay algunas funciones más avanzadas que vienen al tema, que sirven para hacer este tipo de operaciones. 01:01:52
Entonces que sepáis que si en algún momento queréis multiplicar cada valor por su correspondiente, no se puede de esta forma. 01:02:04
Materias:
Imagen y Sonido
Niveles educativos:
▼ Mostrar / ocultar niveles
  • Formación Profesional
    • Ciclo formativo de grado superior
      • Primer Curso
      • Segundo Curso
Subido por:
Daniel M.
Licencia:
Todos los derechos reservados
Visualizaciones:
8
Fecha:
13 de noviembre de 2025 - 17:10
Visibilidad:
Clave
Centro:
IES CIFP a Distancia Ignacio Ellacuría
Duración:
1h′ 02′ 17″
Relación de aspecto:
1.78:1
Resolución:
1920x1080 píxeles
Tamaño:
411.39 MBytes

Del mismo autor…

Ver más del mismo autor

EducaMadrid, Plataforma Educativa de la Comunidad de Madrid

Plataforma Educativa EducaMadrid