Tutoría 3 - DEIM - UT1 y 0 - Curso 24·25

Al final de la tarea, una vez teníamos el script realizado, hay que conseguir que al lanzar el juego, dado que se ubica en el start, si no me equivoco, aquí está descrito, solo se hará una vez y se instanciará ese prefab, que es la nave, una sola vez. 00:00:02

Es cierto que, y abro aquí un código, lo pongo por aquí, que dependiendo de qué sobrecarga hayas usado del método Instantiate, hará una opción u otra. 00:00:16

El otro día dijimos, veis que aquí hay tres formas, pasarán tres cosas y se instanciarán tres naves y cada una tiene unas diferentes consecuencias. 00:00:29

Cuando empezamos a escribir el método instantiate, a ver si quiere, empieza a escribir ya incorrectamente, cuando abrimos estos paréntesis que definen a las funciones o métodos, teníamos estas sobrecargas que nos iban indicando qué propiedades está esperando. 00:00:40

En principio las tres primeras, digamos las cuatro primeras casi, son las que más se utilizan. Bueno, cada una tiene sus propias consecuencias, pero no es lo mismo, no es exactamente lo mismo, suele estar todo relacionado y instantiate sirve para generar un clon de lo que se haya referenciado, pero no es lo mismo realizar, y ahora aquí paso a ejecutar tres si queréis, 00:01:00

una instancia en la que solo se le pasa un parámetro 00:01:26

que es el objeto 00:01:29

que hemos 00:01:30

introducido, digamos 00:01:32

capturado a través del 00:01:34

serialized field, que recordemos que es 00:01:36

que luego, una vez tenemos 00:01:38

este script, a ver, perdonad 00:01:41

que es 00:01:43

importante cuando queramos ver 00:01:44

lo relativo a un 00:01:46

a un script, no olvidar 00:01:49

que ese script tiene que ser 00:01:51

componente de alguno de los elementos que están 00:01:52

en la escena ejecutándose vale por tanto voy a poner este instante prefab vale que es el script 00:01:54

que estaba revisando hace un segundito está aquí está siempre fab y perdón en inglés instancia 00:02:02

prefab si yo guardo vale tengo aquí 3 instancia y diferentes cada uno tiene sus particularidades 00:02:08

como acabo de decir y cuando yo ejecuto no en el estar se van a generar los tres o eso debería 00:02:17

hacer, vamos a darle a play y 00:02:24

a ver si lo hace 00:02:26

no hace nada y de hecho da fallo, ¿por qué? 00:02:27

porque ya que os tengo aquí 00:02:32

y entiendo que habéis estado con la tarea, ¿por qué no 00:02:34

¿por qué no se ha instanciado nada? 00:02:36

¿por qué da error? que esto ya lo vimos 00:02:38

el otro día y bueno, si habéis hecho la tarea pues 00:02:42

lo tendréis 00:02:44

claro 00:02:47

¿por qué no lo tienes instanciado, no? 00:02:48

¿a qué te refieres? porque yo aquí 00:02:51

básicamente 00:02:53

ya tengo 00:02:54

un instancy de myPrefab 00:02:56

que está aquí preparado y debería 00:02:58

instanciar ese prefab. Pero no tienes vinculado 00:03:00

Unity en la columna de la derecha. 00:03:02

Efectivamente. Es genial. 00:03:05

Aquí, si nos damos cuenta, se han 00:03:06

generado los campos para introducir 00:03:08

pues, ojo, qué es 00:03:10

mi prefab y qué GameObject 00:03:12

es el que quiero instanciar. Aquí es donde 00:03:14

podemos arrastrar este prefab 00:03:16

y pues está 00:03:18

aquí preparado y ahora todo lo que en el código 00:03:20

tenga una variable referenciada 00:03:22

con mi prefab, con myPrefab, 00:03:24

pues se refiere a ese objeto. Por tanto, esta línea, por ejemplo, este primer instant shade, ya tiene lo que necesita para hacer la instancia. 00:03:26

Cuando solo se usa uno de los parámetros, que además es la primera sobrecarga, ¿vale? Hacemos el instant shade solo dando un objeto que es el original que se va a clonar, 00:03:34

que es lo que acabamos de hacer aquí, ¿vale? Cuando yo ahora, no olvidéis de guardar siempre que hagáis algún cambio en el código para que se ejecute, 00:03:47

¿Vale? Yo ahora cuando lance el juego, al menos una nave tiene que aparecer, ¿vale? Y de hecho se han generado alguna más. Y ve, de hecho, que si nos fijamos, a ver, tenemos una aquí, tenemos otra aquí, las estoy moviendo, bueno, perdonad que estoy cogiendo partes de la nave, de este prefab si la arrastro para acá y de este prefab para acá, ¿vale? Se han generado dos naves y las dos, si nos damos cuenta, están, deshago y marco una en el 000, ¿vale? 00:03:54

Por tanto, una de estas naves, básicamente esta primera, es la primera que ha aparecido, porque recordad que el código, como os dije el otro día, a medida que lo vayamos complicando, esto no es así, pero en este momento sí que lo es, el código se va ejecutando de arriba a abajo. 00:04:22

Entonces la primera nave que se genera en la jerarquía de objetos, que si os dais cuenta a medida que voy incorporando se van añadiendo de arriba a abajo, la primera nave se hacía referencia a esa. 00:04:40

Es verdad que aquí tenemos otros dos Instantiates que no se están produciendo. 00:04:53

como ya os comenté 00:05:00

para hacer pruebas de que funciona y que no 00:05:02

y esto me sirve un poco para explicar 00:05:05

que un mismo método como este InstanceAid 00:05:06

tiene varias sobrecargas y cada una 00:05:09

tiene unas consecuencias 00:05:10

que es lo que iba diciendo del principio 00:05:12

ahora si guardo y lanzo el juego 00:05:14

pues nuevamente 00:05:16

como el prefab está ahí 00:05:18

instanciado pues 00:05:22

placa y aquí tenemos la nave 00:05:24

por tanto este InstanceAid 00:05:26

primero está funcionando 00:05:29

Bueno, pues ya si quisiéramos usar ese instant sheet, está ahí preparado 00:05:30

Vamos a ver qué pasa con el resto 00:05:34

Es decir, voy a comentar el resto y voy a ver 00:05:36

Esta línea, según empieza, es verdad que aquí está generando como una variable 00:05:40

Si os fijáis, que le está poniendo un nombre que se llama instancia 00:05:46

Que si no vemos mal, aquí pone GameObjectMyPrefab 00:05:48

Está generando una variable de un tipo de variable que es GameObject 00:05:54

Es decir, una clase, un conjunto de código que se refiere a todo lo relativo a los GameObjects. 00:05:58

Si ya habéis estado estudiando, un GameObject en Unity se refiere a cada uno, 00:06:06

da igual que sea la cámara, la luz, un cubo, cualquier geometría. 00:06:10

Todo lo que vamos teniendo aquí introducido genéricamente se llama como un GameObject. 00:06:14

Esta cajita hecha de alambre, que no está rellena, es un GameObject aquí representado. 00:06:18

Que no es lo mismo que meter un prefab que veis que sí que está lleno. 00:06:26

Pero en genérico, todo lo que se va introduciendo aquí son GameObjects. 00:06:28

Por eso, cuando queremos referenciar a un objeto, usamos esta clase GameObject que usamos como tipo de la variable. 00:06:32

Y por eso, todo lo que metamos en esta caja, si recordáis la analogía que hacía el otro día con cajas, 00:06:40

si lo que queremos es que recoja ese GameObject, pues habrá que usar la clase GameObject. 00:06:47

Voy a seguir y ahora vamos al transform y vemos un par de cosas 00:06:52

Si yo ahora guardo y digo, a ver qué ocurre cuando yo ahora lanzo el juego, ¿no? 00:06:58

Que solo se va a ejecutar esta línea en el start 00:07:03

Vamos a ver 00:07:05

Me voy a poner aquí a mi lado 00:07:06

Vale, acabo de lanzar el juego y hay una nave en el 15, bueno, perdón, en el 000, igual 00:07:10

¿vale? pues eso significa 00:07:21

que crea una instancia 00:07:24

en la posición, aquí os lo he comentado 00:07:26

y está ya indicado, crea una instancia en la posición 00:07:28

del objeto de referencia y como 00:07:30

hijo suyo, pero es verdad que 00:07:32

está ocurriendo algo, si os dais cuenta 00:07:34

que es que, aunque aquí he puesto 00:07:36

dos parámetros 00:07:38

¿vale? my prefab y referencia 00:07:39

referencia, si lo pensamos bien 00:07:42

me podéis contestar 00:07:44

a qué se está refiriendo en este momento 00:07:45

a la línea de objeciones que has ubicado 00:07:47

hay vacío, ¿no? 00:07:55

No, tened en cuenta que yo he generado aquí una variable 00:07:57

de tipo transform, y transform, si recordáis, 00:08:00

es el primer componente que tiene las coordenadas 00:08:04

de posición, rotación y escala de cualquier objeto, 00:08:06

de casi cualquiera. 00:08:09

Todos suelen empezar teniendo ese componente, 00:08:10

y luego muchos otros dependiendo de cuál sea la función. 00:08:13

Fijaos que yo en referencia, que es otra variable 00:08:16

que he generado por medio de un campo serializado, 00:08:20

no le he dado ninguna referencia, ahora mismo está vacía 00:08:24

es nula, no existe 00:08:27

por eso la ha generado 00:08:28

en el 0.0.0 y no es hija de nada 00:08:31

como pongo ahí que es 00:08:33

si os fijáis es exactamente el prefab 00:08:34

el 0.0 00:08:37

porque no tiene esa referencia, es decir, ahora mismo 00:08:38

esta línea está funcionando como esta 00:08:41

primera, porque aquí lo que tiene 00:08:42

es nada, no le existe 00:08:45

para aprovechar esta sobrecarga y que tenga 00:08:46

sentido meter 00:08:48

dos variables aquí dentro 00:08:49

Pues habría que decir cuál es esa referencia 00:08:52

Y ahora mismo pone ninguna y está esperando un objeto, un vínculo, digamos, en este campo del tipo transform 00:08:57

¿Eso qué significa lo de transform? 00:09:05

Que si yo en este campo, igual que he hecho en este de aquí arriba, arrastro aquí la nave 00:09:08

Vais a ver que pone esa nave prefab, es el mismo objeto 00:09:12

Pero fijaos en dos cosas 00:09:16

Primero cambia el icono y cambia, también da como una indicación de qué es lo que está cogiendo de esta referencia que hemos metido ahí. 00:09:18

Si os fijáis además, esto no sé si lo dije el otro día, este iconito es el mismo que el del componente transform, 00:09:27

porque de esta variable solo está recogiendo lo relativo al transform del objeto. 00:09:32

De este, por ejemplo, no se va a poder decir, si este GameObject tiene un componente de otro tipo, haz tal. 00:09:39

No podremos hacer ningún tipo de operación en algo que no sea el componente transform de ese objeto. 00:09:46

Igual que aquí accedemos al objeto completo, que aquí lo hemos hecho para que se instancie completamente, 00:09:53

aquí solo estamos cogiendo una parte de ese objeto, ese componente transform. 00:09:58

Esto me sirve, nuevamente el otro día, para introducir que las variables pueden ser de tipos casi ilimitados 00:10:03

en relación con la cantidad de componentes que hay. 00:10:10

Es decir, aquí si yo busco, no hay un transform porque como ya viene aplicado no está preparado, pero también os dije el otro día que, por ejemplo, lo vais a ver en la lección 3, existe este RigidBody. 00:10:13

pues yo si por ejemplo 00:10:26

en este objeto que le he añadido un RigidBody 00:10:28

quisiera en algún momento 00:10:31

cambiar las propiedades del componente 00:10:32

RigidBody, esto ya lo iremos viendo 00:10:34

que es básicamente 00:10:36

lo que activa el motor de físicas de 00:10:38

Unity, siempre va a haber 00:10:40

la posibilidad de 00:10:42

imaginaos que yo también puedo hacer 00:10:44

una variable, fijaos que está aquí preparada 00:10:46

y RigidBody2D es otro tipo de variable 00:10:48

pues haremos una 00:10:50

variable de tipo 00:10:52

físicas, yo que sé, recordad que 00:10:54

esto es el tipo de variable y esto 00:10:56

es el nombre, que podemos poner el que queramos 00:10:58

que asignamos a esta 00:11:00

caja que recoge lo de variable 00:11:02

y ahora fijaos que si 00:11:04

bueno, si yo guardo lo primero 00:11:06

recordad la estrellita de aquí 00:11:08

si yo guardo y vuelvo 00:11:10

a ir al objeto en el que he puesto 00:11:12

el script, ahora hay otra 00:11:14

bueno, tiene que estar este rigidbody 00:11:16

para poder referenciarlo ahora, pero ahora está 00:11:17

esperando otro 00:11:20

que introduzcamos algo en este campo 00:11:21

de tipo RigidBody, un poco del tipo 00:11:24

de la caja que hemos creado 00:11:27

si yo aquí arrastro ahora la nave 00:11:28

veréis que la nave prefab 00:11:29

como no tiene RigidBody 00:11:33

no lo va a coger 00:11:34

porque sí que tiene transform, sí que se puede 00:11:36

arrastrar como todos los GameObjects 00:11:39

un GameObject, pero no tiene un RigidBody 00:11:40

por tanto, aunque yo intente 00:11:43

podéis hacer la prueba, arrastrar 00:11:45

igual que si me deja introducirlo en los otros 00:11:46

dos campos, aquí no me deja 00:11:49

sí que podré, por ejemplo, meter el propio GameObject del script 00:11:51

fijaos que si yo lo arrastro, sí me deja, ¿por qué? 00:11:55

porque tiene un RigidBody al cual yo podré acceder luego para cambiar variables 00:11:58

y veis que además el iconito, en estos componentes que ya vienen generados directamente por Unity 00:12:03

pues les ponen estos iconitos para facilitar 00:12:08

veis que aunque la caja parece que es un poco lo mismo 00:12:11

esto ya profundizaremos más 00:12:14

luego al final cada variable tiene su tipo 00:12:19

aquí lo que estamos haciendo en esta línea 00:12:21

es crear sin pasar por el comienzo 00:12:23

de la clase, que es donde vamos generando 00:12:27

lo que se llama las variables miembro 00:12:31

que son variables que podréis usar en todo el código 00:12:33

porque su ámbito, esto si ya habéis visto 00:12:36

ahora vamos un poco a esto, pero si ya habéis leído el tema 0 00:12:38

cosa que deberíais haber hecho, al menos una pasada 00:12:41

hay un tipo de variables que si se ubican al comienzo 00:12:44

de la clase podrán ser luego empleadas 00:12:49

por cualquier método, en este caso start 00:12:52

lo que también se puede hacer es declarar 00:12:54

es decir, construir esta caja dentro ya de un método 00:12:58

no dentro de la clase en general, sino dentro de un método 00:13:01

de su propio bloque, entonces estamos generando 00:13:04

una caja de tipo GameObject 00:13:06

que estamos llamando instancia y a diferencia 00:13:09

de aquí, lo que estamos 00:13:13

haciendo es que en ningún momento hemos 00:13:15

creado un serialize que te 00:13:17

permita arrastrar y saber 00:13:19

que esta caja se llena con un objeto 00:13:21

que metes por el inspector, no 00:13:23

aquí lo que estamos haciendo es 00:13:25

rellenar la caja instancia 00:13:27

de tipo GameObject con la instancia 00:13:28

que generamos, es decir 00:13:31

que si yo en esta instancia 00:13:33

luego cambio alguno de sus 00:13:34

parámetros, ahora lo vemos 00:13:37

no está refiriéndose a 00:13:38

nada que hemos capturado por 00:13:41

el inspector, sino que hemos llenado la caja directamente con una instrucción 00:13:42

que hemos dado aquí. ¿Esto qué significa? 00:13:47

Un ejemplo rápido. Veremos que hay un montón de instrucciones y recordad 00:13:52

esto lo vimos el otro día, que había un operador al escribir 00:13:56

sentencias, que es el punto. 00:13:59

Esto lo indiqué, por ejemplo, cuando ponemos transform, podemos acceder a la 00:14:02

posición de un objeto si escribimos position, porque estamos 00:14:07

accediendo a las 00:14:11

propiedades del transform 00:14:14

lo único es que, como ya os dije 00:14:16

que como el transform es tan utilizado 00:14:18

porque es todo lo que se refiere a las coordenadas 00:14:19

de los GameObjects, pues han 00:14:21

generado, aparte de la clase transform 00:14:23

que siempre se describe en las clases con mayúscula 00:14:25

empezando por mayúscula 00:14:28

importante, esto también lo pone las buenas prácticas 00:14:29

en el tema cero, han generado 00:14:31

una propiedad 00:14:33

que se llama transform con minúscula 00:14:35

que es el nombre en el que se da 00:14:38

a las propiedades como por ejemplo 00:14:39

positian. No estamos aquí 00:14:41

refiriéndonos a la clase directamente, 00:14:43

sino que es una especie de... 00:14:45

Es un poco ambiguo porque al final es la misma 00:14:47

palabra, pero las mayúsculas 00:14:49

y las minúsculas tienen influencia al escribir 00:14:51

código. Entonces, una manera de simplificar 00:14:53

y, digamos, no tener que acceder 00:14:56

a una clase que es como una entidad superior, 00:14:57

sino de meter una operación 00:15:00

que se puede hacer de manera más simple, 00:15:01

podemos acceder a las propiedades 00:15:03

del transform con este transform en minúscula 00:15:05

y luego al ir poniendo el positian, pues podemos decir 00:15:07

igual a 10 que va a dar fallo porque por más cuestiones pero veis que lo 00:15:09

importante de esto ahora mismo es que cuando ponemos un punto 00:15:15

vamos abriendo opciones hijas de ese primer elemento que hemos puesto como lo 00:15:19

que el otro día os dije de país comunidad autónoma vale o estado si fuera 00:15:24

eeuu ciudad punto calle punto número vale si estas propiedades existieran 00:15:30

configuradas vale pues sería esta la forma la sintaxis para ir accediendo 00:15:37

digamos de un elemento a otro pero para poder acceder por ejemplo al elemento 00:15:41

ciudad si no lo hemos configurado de otra forma siempre que hay que ir 00:15:47

accediendo de un padre digamos que reconozca o que hemos guardado como 00:15:51

variable como punto de partida y luego podemos ir 00:15:55

llegando a los hijos esto qué quiere decir que si hemos generado y les 00:15:59

Comento esto que tengo aquí. Si hemos generado un GameObject que llamamos instancia, que será esa instancia que hemos generado, luego podremos acceder, esto también es ir sabiendo poco a poco más y más herramientas, podemos acceder, por ejemplo, al nombre de esa instancia. 00:16:04

¿Eso qué significa? Que si decimos, vale, aparte de guardar esta instancia con el nombre de instancia, yo quiero que esta instancia tenga el nombre, ¿vale? El nombre del objeto, del GameObject y que se llame hola, ¿vale? Voy a probar a ejecutarlo y ahora vemos su utilidad de esta línea. 00:16:20

Si yo arranco este juego, vais a ver, bueno, lo primero que algo se cae porque le puse el Rigipodi, ¿vale? 00:16:39

Ya veis que al meter un componente está haciendo algo. 00:16:49

Pero lo importante, la nave ahora no se llama clon como se llamaba antes, ahora se llama hola. 00:16:51

Y aquí está dentro todo lo de la nave, el prefab que habíamos ejecutado, ¿vale? 00:16:56

Fijaos, y esto me sirve para ir introduciendo que las variables se pueden ir creando en muchos sitios, 00:17:00

que aquí he puesto varias juntas 00:17:05

y si por ejemplo examináis 00:17:07

que esto también lo iremos viendo en el script 00:17:09

de la unidad 0 de la tarea que os he dejado 00:17:11

como referencia 00:17:13

habrá variables que se van generando al principio 00:17:15

para tenerlas todas digamos 00:17:17

usables a lo largo de todo el proyecto 00:17:18

pero también en momentos nos puede interesar 00:17:20

que esa variable se cree al empezar el juego 00:17:23

¿vale? en este momento se crea esta instancia 00:17:25

de tipo GameObject 00:17:27

y aquí hemos generado una instancia 00:17:28

que ojo todavía no hemos resuelto 00:17:31

que diferencia hay entre esto y esto 00:17:33

Porque no hemos asignado nada de referencia 00:17:35

Bueno, está ahí preparado 00:17:37

Pero no lo hemos llegado a hacer 00:17:38

A ver, que detengo esto 00:17:40

Y aquí está esperando 00:17:43

A que sigamos trabajando 00:17:47

Ahora sí que está cogiendo una referencia 00:17:48

Ahora usamos a conveniencia 00:17:51

Lo que queramos, pero lo importante es 00:17:53

Que una vez guardamos 00:17:55

Una instancia de tipo GameObject 00:17:57

También podemos acceder a las propiedades de ese GameObject 00:17:58

Como acabamos de hacer aquí 00:18:01

Entonces, vamos a hacer un poco la lógica que pone aquí que tiene usar esta sobrecarga de instancia 00:18:02

Que es que crea una instancia a la posición del objeto de referencia 00:18:11

Que es este segundo que tenemos aquí 00:18:14

Y como hijo suyo, es decir, de esta referencia 00:18:16

Todo esto yo me lo sé, aparte de porque ya lo he usado más veces 00:18:20

Porque, os vuelvo a repetir, que si vamos pasando por las sobrecargas 00:18:24

que en este caso 00:18:29

es esta, la que estamos usando 00:18:29

nos pide un GameObject, aquí lo pone 00:18:33

como Object, cuando pone Object significa GameObject 00:18:35

es otra forma de llamarlo 00:18:37

y bueno, si luego 00:18:38

bueno, es que no quiero liar más 00:18:40

la madeja, necesita un objeto 00:18:43

que es el que va a referenciar y luego 00:18:45

un transform que va a ser ese padre 00:18:47

y pone, clona el objeto existente y retorna 00:18:48

el clon, si quisiéramos 00:18:51

saber más, esto ya lo comenté el otro 00:18:53

día, saber más de 00:18:55

que hace cada método 00:18:57

la buena forma de hacerlo es 00:18:59

meternos en el API 00:19:01

en el manual de uso 00:19:02

del código 00:19:05

en el propio 00:19:06

desde el propio Google se puede hacer 00:19:08

si ponemos el método 00:19:11

o la propiedad que queramos consultar 00:19:13

y ponemos Unity después 00:19:15

lo primero que va a poner 00:19:16

va a ser 00:19:18

el acceso 00:19:19

a cómo se 00:19:23

usa este elemento 00:19:25

o este método, aquí veis que vienen 00:19:28

ya varias sobrecargas 00:19:30

y si vamos pasando, aquí pone 00:19:31

object original 00:19:34

que aquí es lo mismo que ponía en el IntelliSense 00:19:35

que hemos visto antes en el código, y aquí sí que 00:19:38

podemos ir más con detalle, por si 00:19:40

tenemos dudas, ir viendo qué significa 00:19:42

cada cosa, pues oye, es algo de tipo objeto 00:19:44

de GameObject, no podemos meterle otra cosa 00:19:46

quiere un GameObject, aquí 00:19:47

y en original es el nombre que le ha dado 00:19:49

a esta variable, digamos 00:19:52

a este parámetro que está esperando que hagamos algo con él, ¿vale? 00:19:54

Y aquí si bajamos en los parámetros nos dice, vale, lo que yo ponga como original, 00:19:57

que es en todas estas, en esta posición de los parámetros, dice un objeto existente 00:20:01

del que quieras hacer una copia, ¿vale? Pues ya sabemos que aquí habría que meter 00:20:05

ese objeto que queremos copiar, ¿vale? Cuando pone parent, pues podemos ir a parent. 00:20:10

Padre que será asignado al nuevo objeto, ¿vale? Pues aquí meteremos un transform, ¿vale? 00:20:16

Y ese será padre en este caso. 00:20:22

Podemos hacer igual con más tipos. 00:20:24

Para que vayáis viendo cómo se usa, aquí os puedo ir diciendo más, pues más, digamos, características de, en este caso, Instance 8. 00:20:26

Y si vais bajando incluso podréis ir viendo ejemplos, ¿vale? 00:20:35

El problema de los ejemplos igual a estas alturas es que son siempre más avanzados, 00:20:38

pero a medida que vayáis teniendo más bagaje iréis entendiendo más todos los ejemplos. 00:20:42

Fijaos que luego incluso Instantiate, bueno, yo lo he hecho así un poco a las bravas, pero incluso fijaos que Instantiate, si lo vuelvo a declarar aquí, tiene más tipos, ¿vale? Con estas llavecicas que se abren aquí y si me pongo encima, pues no da muchas descripciones y en ese caso, para desambiguar, para saber qué significa, pues tendríamos que meternos nuevamente en el manual o en la API, ¿vale? 00:20:47

Aquí más abajo están las declaraciones de este estático, que es diferente. En vez de un objeto tiene una referencia de tipo. Esto ahora mismo nos da un poco igual, pero sí que me sirve para que vayáis viendo que las sobrecargas se pueden ir entendiendo mejor si vamos viendo este manual. 00:21:12

Y luego, importante, aquí arriba en la documentación de Unity, que es a donde os va a referenciar si ponéis la propiedad, el parámetro, la función seguida de Unity en Google, podéis acceder al API, que es donde os va a decir el uso, digamos, a nivel de programación, como estamos haciendo ahora mismo, y también al manual. 00:21:33

al manual, bueno, es el manual del programa 00:21:51

para acceder al manual de esta operación 00:21:55

en vez de hacerlo desde aquí, se puede cambiar a manual 00:21:58

que si tiene una sección en el manual del propio programa 00:22:00

pues os puede contar una descripción que no está tan basada 00:22:04

en el código, sino del uso 00:22:07

esto lamentablemente no suele estar en español 00:22:08

igual que el software en sí, el Unity no está en español 00:22:12

pero bueno, con poco a poco en inglés 00:22:15

Es bastante técnico, pero bueno, se puede ir traduciendo y veis que aquí un poco ya va explicando qué hace. Nuevamente, estas explicaciones a veces pueden pecar un poco de muy técnicas en el momento que nos encontramos, pero sí que nos puede dar ciertas pistas. A lo mejor hay líneas que empieza a hablar de herencia, de bueno, behavior. Bueno, pues esto no sé, si seguimos seguramente algo iremos pillando y poco a poco podremos seguir avanzando. 00:22:18

Que me importaba ver un poco qué significan estos nombres que aparecen bajo original, position, ¿veis? En la sobrecarga pone object original. Pues original es un nombre que sirve de referencia para luego ver en la API qué significa o qué te está pidiendo en cada momento. 00:22:42

¿Vale? Vuelvo aquí 00:23:01

¿Vale? ¿Qué tal hasta aquí? 00:23:03

Más o menos me vais siguiendo 00:23:06

Doy vueltas que poco a poco 00:23:07

Se irán completando ¿Vale? 00:23:10

Que de primera es muy complicado explicar todo 00:23:11

Vale 00:23:14

Vamos a quedarnos con lo más mundano 00:23:16

De todo esto ¿Vale? 00:23:18

Que es que estamos generando una variable de tipo GameObject 00:23:20

Y dentro de esa caja 00:23:23

¿Vale? Llamada instancia 00:23:24

Si esto 00:23:26

Claro 00:23:28

Bueno me está diciendo un compañero 00:23:30

que es un poco complicado acordarse de todo 00:23:32

esto, lo dije el primer día 00:23:34

va a ser una constante iteración 00:23:36

va a haber que ir volviendo todo el rato 00:23:38

a lo mismo e ir machacándolo 00:23:40

es importante 00:23:41

no sé si lo estáis haciendo, leer bien los temas 00:23:43

e ir intentando hacer las tareas, poco a poco 00:23:45

pues 00:23:48

acordarse es ir teniendo 00:23:49

conciencia de cómo era 00:23:52

pero una vez vamos usando las cosas 00:23:53

varias veces, y ya os digo, con el uso de la app 00:23:55

y del IntelliSense, por eso soy tan 00:23:58

pesado con ir entendiendo 00:24:00

Cuando escribimos algo aquí, ¿qué significa? Si ponemos invoke, yo a lo mejor no sé qué es invoke, pero me suena que algo se usaba y aquí podemos ir sabiendo, cuando es un método, podemos ir sabiendo qué cosas son, deduciéndolo o metiéndonos en la API. 00:24:02

Y poco a poco iremos salvando todo, ya veréis. Si seguimos viendo esto, nos falta decirle cuál es la referencia de este prefab. Y la referencia que nosotros queramos. Aquí la tenemos preparada, la variable, para usarla, pero todavía no lo estamos haciendo bien. 00:24:18

Porque aquí os lo he puesto como ejemplo 00:24:35

La voy a quitar, ¿vale? 00:24:38

Si dais a este circulito podéis decirle 00:24:41

Que no queréis ninguna, que es como estaba 00:24:43

Y claro, yo lo que voy a querer en cierto momento 00:24:45

Es usar las capacidades 00:24:47

Que me está dando 00:24:49

Esa sobrecarga de Instanciate 00:24:50

Para decirle yo el punto en el que quiero que se instancie 00:24:53

No quiero que se instancie a lo mejor en el 0, 0, 0 00:24:55

¿Vale? 00:24:58

Sino que yo quiero que se instancie donde 00:24:59

Punto, ¿vale? 00:25:01

Estoy generando un GameObject vacío 00:25:03

recordad que igual que se puede generar estos cubos y estos elementos con los que habéis hecho el prefab de la nave 00:25:05

puede generar un vacío, un empty, que es como los nulos en los software de 3D 00:25:11

que sirve simplemente para tener una referencia en el espacio 00:25:15

no contiene nada más allá de una referencia del espacio 00:25:18

y lo voy a llamar, borro este que he generado dos en el proceso 00:25:21

lo voy a llamar punto referencia para saber bien que es ese 00:25:25

y ojo que cuando generamos un nuevo empty object o cualquier elemento 00:25:29

puede no estar ubicado en el 00 que de partida no nos gustaría. 00:25:34

Nos lo pone en el centro del visor donde estamos mirando. 00:25:38

Ojo que suelen ir ya a las posiciones modificadas. 00:25:41

Si queremos colocar algo en origen en el 00, en los tres puntos de ese componente, 00:25:46

si le damos a Reset, se colocará ahí. 00:25:52

Esto lo he hecho un poco para que veáis el punto de partida. 00:25:56

Pero ahora lo que puedo hacer es decir, no, yo quiero que este elemento, la nave, 00:25:58

se instancie en el 00:26:02

y lo voy a meter a mano 00:26:04

menos 40 y en i 00:26:06

10, ¿vale? porque es donde 00:26:08

yo quiero que comience 00:26:10

si, y en z incluso 00:26:11

vamos a ponerle un 15 00:26:14

el punto que sea, da un poco 00:26:16

igual, esto lo que nos va a 00:26:18

permitir es que luego cuando nosotros 00:26:20

digamos que este GameObject 00:26:22

punto de referencia, ¿vale? 00:26:24

y teniendo aquí abierta 00:26:25

en el inspector donde tenemos el código 00:26:28

y las variables preparadas 00:26:30

arrastramos ese objeto, lo que va a hacer es coger el transform de este punto de referencia 00:26:31

que nosotros hemos ubicado donde queremos que esté. 00:26:37

Entonces, ahora mismo ya tenemos preparada una referencia que se coge con esta variable referencia 00:26:41

y que nosotros usamos aquí como segundo parámetro del InstanceAid. 00:26:47

Si yo ahora ejecuto el juego, va a hacer dos cosas, como bien dice aquí. 00:26:55

crea una instancia en la posición del objeto de referencia 00:26:59

en esta ubicación 00:27:01

que acabamos de poner 00:27:04

y como hijo suyo además, tiene una pequeña 00:27:04

sutileza 00:27:07

entonces, yo cuando ahora arranque el juego 00:27:08

vais a ver 00:27:11

que esa nave 00:27:12

primero se ha colocado, si recordáis 00:27:15

en este punto donde está 00:27:17

punto de referencia y además se ha hecho su hijo 00:27:18

¿vale? se llama hola 00:27:21

porque en el código hemos dicho 00:27:23

que la instancia 00:27:25

que el nombre de esa instancia sea hola vale entonces ver que no es lo mismo tener activo 00:27:26

este esta instancia acción bien referenciado todo que simplemente generar el instante a secas vale 00:27:34

esto me sirve para que poco a poco vayáis viendo que lo que hay dentro de estos paréntesis en un 00:27:42

método vale pues influye un método o una función que son lo mismo ya os comenté el otro día que 00:27:50

son digamos operaciones de acción de algo que ocurre en este caso vamos a instanciar en este 00:27:58

caso esto es otro método que sirve para marcar qué va a ocurrir al empezar el juego o al iniciarse 00:28:04

este script no recordad que era cuando el objeto se iniciaba y si veis cuando hay un método tiene 00:28:10

el nombre de esa acción que va a hacer 00:28:16

y siempre va a ir a continuación 00:28:18

un paréntesis. 00:28:21

A veces vacío, a veces lleno. 00:28:23

Pero cuando vemos 00:28:26

una palabra que está escrita en mayúsculas 00:28:27

la primera letra 00:28:29

y luego tiene paréntesis, eso significa 00:28:31

que estamos usando lo que se llama un método función. 00:28:33

Es decir, una acción que vamos a hacer. 00:28:35

Que no es lo mismo que si yo pongo 00:28:38

transform 00:28:39

position 00:28:41

igual a 00:28:42

referencia, ¿vale? 00:28:44

Que esto, básicamente, a ver, reference position, había que 00:28:49

aprender, ¿vale? 00:28:53

Esto ya os explicaré un poco más qué es, ¿vale? 00:28:57

Pero al final no es lo mismo decir, oye, instanciate aquí y 00:28:59

tal cosa, que en esta línea que no vemos ni un solo paréntesis. 00:29:04

Esto significa que aquí no hay ningún método. 00:29:07

Los paréntesis pueden indicar más cosas, pero en lo general son 00:29:09

métodos o funciones 00:29:12

¿vale? ahora volveremos otra vez 00:29:15

a los métodos 00:29:17

entonces, ya simplemente por terminar 00:29:18

esta 00:29:21

explicación como de las sobrecargas 00:29:23

de las sobrecargas que puede tener Instantiate 00:29:25

ya a ver un segundo que esto 00:29:27

este, vale 00:29:29

tenemos una tercera 00:29:30

forma de instanciar, vale, comento todo 00:29:32

menos esta última, que yo sé 00:29:35

que es, y borro 00:29:37

todo lo relacionado con 00:29:38

con los comentarios 00:29:40

que es que crea una instancia en el punto de referencia 00:29:43

pero sin rotación 00:29:46

¿vale? 00:29:47

vale, aquí si os fijáis tenemos 00:29:49

tres elementos y es igual que 00:29:51

el anterior en el sentido de que 00:29:53

primero, el primero de ellos es 00:29:55

el prefab ¿vale? y voy a ir a la API un segundo 00:29:57

de 00:30:00

Instantiate, la tenía por aquí 00:30:01

abierta si no me equivoco, aquí está 00:30:04

¿vale? esta es la primera que hemos usado 00:30:06

esta es la segunda y ahora 00:30:08

vamos a ir a esta tercera, ¿vale? Esta no la saltamos porque tampoco aporta mucho, pero 00:30:09

aquí básicamente nos pide, ¿vale? Un objeto. Ahora, el segundo parámetro, aunque es parecido, 00:30:16

es una posición, ¿vale? De tipo vector 3. Esto es verdad que todavía no lo hemos visto. 00:30:24

Y luego la rotación. Esto ahora mismo es un poco enrevesado y por eso no voy a meterme 00:30:30

mucho volvemos a ello si queréis más adelante pero esta sobrecarga al final lo que me está 00:30:35

pidiendo son otro tipo de valores entonces si os fijáis incluso aquí cuando vemos esta referencia 00:30:40

aquí no me está pidiendo un transform un transform completo como como si que hacía en la otra 00:30:50

sobrecarga vale aquí me pedía el transform completo del objeto que iba a ser el padre aquí me pide 00:30:56

solo la posición. Entonces quiero que vayáis también teniendo en la cabeza que ciertos 00:31:02

parámetros tienen más parámetros dentro, como hemos dicho antes, que podemos ir abriendo 00:31:10

con punto. Porque pensad una cosa, si me está pidiendo la posición de un elemento y yo 00:31:15

tengo un transform en referencia, yo al final lo que estoy haciendo es, en este transform 00:31:20

estoy cogiendo todo lo que hay en este componente, la posición, la rotación y la escala, que 00:31:26

Al final son tres valores de la posición, tres valores de la rotación y tres valores de la escala, ¿verdad? 00:31:32

Entonces, cuando me piden solo la posición, vais a ver que al final lo que estoy haciendo aquí es decirle, 00:31:38

vale, de este transform que yo he llamado reference, solo voy a coger la posición. 00:31:45

Porque si intento meter todo, esto me da fallo porque dice, vale, no sé que de todo lo que tiene dentro en la posición o en la rotación, 00:31:50

Pues yo que sé, si yo pongo aquí rotation, veis que puedo meter la rotación. Me da fallo también por otras sutilezas, porque habría que ponerlo en ángulo Seuler, básicamente, que es una cosa que ya veremos en este tema. 00:31:59

Pero veis que a medida que yo le voy dando la instrucción correcta, esto me puede dar que algo se puede ejecutar o no. 00:32:15

Sutilezas. Que a veces hay que ir pensando, ¿qué valores estoy guardando en este transform? 00:32:25

Pues estoy guardando los de posición, los de rotación, los de escala, y aquí solo me pide posición. 00:32:29

Y luego aquí me pide la rotación, que esto sí que es verdad que es más avanzado, entonces no me voy a meter mucho. 00:32:35

Pero aquí básicamente con esta instrucción estoy diciéndole, cógeme la rotación que tenga por defecto. 00:32:40

el objeto. Entonces yo cuando use esta forma de este método de instanciación, vais a ver que a diferencia de antes, cuando yo lo genero, me lo genera la posición, pero ahora no es hijo de nada, no es hijo del punto de referencia como ocurría antes, que lo usaba como padre. 00:32:45

E igualmente, como no estoy poniendo que esta instancia sea una caja a la que yo puedo cambiar el nombre, pues no se llama hola, se llama nave prefab clon, que es el nombre genérico que ha cogido del objeto. Cuando le hemos metido aquí el objeto, como se llama nave prefab, pues dice, vale, por de nave prefab he hecho un clon. 00:33:07

Hasta aquí un poco lo relacionado con Instantiate. Cuando ya vayáis entendiendo cómo se usan más métodos, pues Instantiate lo iréis entendiendo mucho mejor. Voy a otro archivo que tengo aquí preparado para ir al tema 0, que es el que me interesa en esta tutoría, si no tenéis más dudas de la tarea del tema 1. 00:33:26

Vale, vamos al tema cero. Voy a guardar, ¿vale? Recordad esta estrella, esta pequeña estrella y voy a ello. 00:33:44

Vale, tengo aquí otro script que simplemente va a servir para practicar ahora. 00:33:56

No va a tener, como hemos hecho ahora en InstanceAid, que se vea un resultado claro en el visor, 00:34:05

Pero me sirve para que vayamos entendiendo mejor qué tipos de variables existen y usos y aplicaciones que se pueden hacer. De momento quizá un poco abstractas en el sentido de, pues solo estamos viendo sumas y restas, pero luego es que esas sumas y restas, como dije el otro día, puede ser como sube y baja el número de puntos que tiene un contador. 00:34:09

Y se va a basar un poco en lo mismo. Recordad cómo se generaba un script. Lo voy a hacer en esta carpeta de script que tengo aquí preparada durante la tutoría. 00:34:28

Pues yo hago este script. 00:34:46

Recordad que en este Cesar script podemos generar un script que vamos a llamar durante. 00:34:49

Recordad que el nombre que vayamos asignando aquí luego debe ser el mismo de la clase de dentro del script. 00:34:56

Esto ya lo he dicho como en dos tutorías previas, por tanto entiendo que no habrá problema. 00:35:03

Y además en el tema cero va poniendo buenas prácticas de cómo escribir los nombres de los scripts, los nombres de los métodos, de las variables, ¿vale? Y habla de una cosa que es el Pascal case y el Camel case, ¿vale? 00:35:08

Cuando generamos una clase o lo que es lo mismo, generamos dentro de Unity un script, siempre, ¿vale? Lo digo porque luego nos va a ayudar a que todo sea más fácil de ir siguiendo, siempre deberíamos empezar a escribir el nombre del script con mayúscula, ¿vale? 00:35:27

Y, a diferencia de nuestro lenguaje del día a día, los espacios no existen o no se usan correctamente cuando estamos escribiendo órdenes. Si os fijáis, todo lo que os he ido enseñando antes no había espacios. Había muy pocos. Hasta que no termine de escribir esto no quiero volver a enseñaros un script. 00:35:45

Pero vais a ver que normalmente se escriben las palabras juntas. ¿Y cómo se distingue que una palabra, pues hay un espacio entre ellos? En vez de dar el típico espacio que hacemos con la barra espaciadora, lo que hacemos es empezar la siguiente palabra con mayúscula durante la tutoría. 00:36:05

importante, lo que son 00:36:24

tildes y eñes 00:36:26

no las uséis nunca 00:36:28

en nada relacionado con programación 00:36:30

me explico, incluso 00:36:32

aunque esto sea el nombre de un script, recordad 00:36:34

que, vale, guardo y se genera 00:36:36

que cuando yo genero este script, al final 00:36:38

estoy realizando un código 00:36:40

cuyo nombre de clase 00:36:42

también está dentro del código 00:36:44

si yo empiezo a poner tildes, esto va a 00:36:45

empezar a dar ciertos problemas, vale 00:36:48

y aunque ahora parezca a lo mejor 00:36:50

que no lo da, tarde o temprano 00:36:52

no lo va a dar. Igual sucede si ponemos una ñ o si ponemos un signo que no esté reconocido, 00:36:54

que puede haber algunos. Entonces, atención, fijaos que siempre he escrito con la primera 00:37:02

letra mayúscula en lo que se llama Pascal Case. Pascal fue un, si no recuerdo mal, un 00:37:08

matemático y como es un nombre propio, por eso se llama así, con mayúscula, Pascal 00:37:13

Case, que no es lo mismo si nos fijamos a lo que hemos estado... Bueno, y fijaos también 00:37:18

que los métodos, los de los paréntesis, también van con mayúsculas. 00:37:22

Es decir, instantiate existe con mayúsculas, ¿vale? 00:37:25

Pero si yo me pongo a buscarlos con minúscula, no existe. 00:37:29

Es decir, sí que intenta ayudarme diciéndome que esto está en mayúsculas, 00:37:33

pero vais a ver que yo cuando lo ponga, me lo ponen en mayúsculas, ¿vale? 00:37:36

Los métodos, esas palabras que sirven para indicar que se ejecute una acción, 00:37:39

que van con estos paréntesis, siempre empiezan a escribirse con mayúsculas. 00:37:46

Y lo mismo, si instantiate tuviera otra palabra, sería instantiate double, yo que sé. 00:37:49

Pues no se separa, no se separa así, porque esto significa hacer dos instrucciones distintas o otro tipo de orden. 00:37:54

Si es solo una orden llamada instantiate double, no hay espacio en el medio. 00:38:03

Se van separando, digamos, marcando la separación de palabras con esta mayúscula, que va separando estas palabras. 00:38:08

Del mismo modo, si pongo el script que hemos estado viendo antes, si os fijáis, ojo, las clases, y os recuerdo que siempre digo que esto es una clase, el nombre que le ponemos al script es una clase. 00:38:15

Y estos son clases que os recuerdo que si le dais con la letra control os podéis meter, ¿vale? Esto es simplemente curiosidad. Y podéis ver todo el código que digamos ya alguien ha preparado para que nosotros podamos usarlo, ¿vale? Vuelvo aquí. Entonces, cuando generamos clases, fijaos cómo es la gramática de esta declaración del tipo de variable que es una clase, ¿no? Como hemos dicho antes. Una G mayúscula y para separar, mayúscula, ¿no? 00:38:39

Y luego aquí hay un espacio que si yo no pusiera significa que es todo la misma palabra, ¿vale? Y daría fallo porque significa otra cosa. Cuidado, los espacios se usan, se deben usar cuando se deben usar. Y las variables, ¿vale? Por convención se escriben del mismo modo pero empezando en minúscula, ¿vale? 00:39:03

Igual que instant set va con mayúscula, fijaos que my prefab, cuando lo hemos declarado aquí al principio, va con minúscula, ¿vale? Igual cuando queramos separar, veis que el my bien, porque es el nombre que le hemos dado a GameObject, pero este prefab aquí no pinta nada para que lo interprete como el nombre de la caja. 00:39:22

Aunque sean dos palabras distintas, empieza con minúscula y para separar las palabras hay que poner una mayúscula aquí. 00:39:40

Y os lo dije el otro día, y si no os habéis dado cuenta, fijaos si está preparado esto, que aunque no dejemos esos espacios, 00:39:47

el propio Unity ya va viendo dónde meter los espacios. 00:39:53

Aquí nos ha metido un espacio en donde en el nombre del script no lo había, recordad. 00:39:59

o incluso en el MyPrefab, que es el nombre de la variable que hemos puesto, 00:40:03

la MSI la ha puesto en mayúsculas y ha puesto este espacio. 00:40:09

Fijaos que el propio software sabe interpretarlo. 00:40:12

Entonces nosotros nos tenemos que hacer a la forma en la que tenemos que escribir el código. 00:40:16

Importante. 00:40:20

Es decir, recapitulando, las clases, barra, porque es lo mismo, scripts, 00:40:22

siempre comenzando con mayúsculas, 00:40:26

los métodos, a medida que vayamos sabiendo cómo llamarlos 00:40:29

o cómo crearlos. También en mayúsculas, ¿vale? Y lo que son las variables en minúsculas, ¿vale? 00:40:32

La diferencia de esto es que esto es PascalCase porque empieza en mayúscula y esto es lo que se llama CamelCase. 00:40:41

Lo de camel porque aparece como la joroba de un camello, ¿vale? Esto también viene en los apuntes. 00:40:47

Si os sirve para acordaros, pues CamelCase es cuando empieza en minúscula. PascalCase cuando es un nombre propio, ¿vale? 00:40:52

vamos un poco con 00:40:57

durante la tutoría 00:41:00

que son digamos operaciones 00:41:02

más básicas para ir viendo el tema 00:41:04

cero, vale, sobre las variables 00:41:06

el otro día estuvimos ya hablando 00:41:08

bastante y de hecho aquí volvemos a hablar 00:41:10

de hecho lo de camel case está aquí puesto 00:41:12

que hay que darle un nombre 00:41:14

a la variable, que cada uno puede tener 00:41:16

un tipo de valor, que es lo que el otro 00:41:18

día estuvimos hablando que eran los 00:41:20

ints, los floats, los strings 00:41:22

las cadenas, recordáis esto, ¿verdad? 00:41:24

Esto ya lo hemos visto. Más o menos hasta aquí lo tenemos. Hemos visto incluso ya tipos de variables de tipo clase, como este GameObject o este Transform en el que guardábamos la referencia que cogíamos por el inspector en el SerializeField. 00:41:26

¿Sí? Por ejemplo, imaginaos que yo en el código, ¿vale? Aquí, justo dentro de la clase, recordad que las llaves delimitan qué hay dentro de cada uno de los apartados del código, ¿vale? 00:41:41

Y las clases, ¿vale? Cuando empezamos una clase, vamos generando estas variables, como he dicho antes, que luego podrán ser usadas dentro de todo este bloque. 00:41:58

Cuando vamos trabajando en un lenguaje como C-SARP, al final existe un proceso, una lógica, que es el encapsulamiento. 00:42:08

El encapsulamiento significa que dentro de estas llaves, de cada uno de los bloques, de esta o de esta, que es otro bloque, o de este, que es otro bloque, 00:42:21

podemos ir usando variables que queremos, nos puede interesar, que solo existan dentro de este bloque o que existan en este bloque 00:42:29

y por defecto también existen los de dentro. 00:42:36

El encapsulamiento sirve para que, digamos, partes del código se puedan comunicar entre sí o no. 00:42:39

Esto también lo iremos viendo. 00:42:45

Pero este concepto de encapsulamiento, si a alguien le interesa, existe. 00:42:46

Y ya me sirve para explicar eso, que cuando tenemos una clase, 00:42:51

que es donde vamos generando todas las instrucciones que hay dentro de este script, 00:42:53

pues ya vamos, a lo mejor, haciendo variables. 00:42:57

Si esto es el script del movimiento del jugador, 00:42:59

imaginaos que fuera esta la función de este script, 00:43:03

que luego meteremos como componente 00:43:05

al GameObject del jugador 00:43:07

pues ese jugador 00:43:09

a lo mejor vamos a querer que 00:43:12

tenga una vida inicial 00:43:13

y quiero que esa vida inicial 00:43:14

sea de 100 puntos, imaginaos 00:43:17

vale, esto 00:43:19

veis que yo por defecto si pongo 00:43:21

un 100 no sirve para nada, me da 00:43:23

falla, 100 que no sabe 00:43:25

que es, incluso cuando empieza el juego 00:43:27

yo puedo 00:43:29

decir aquí 100 y punto 00:43:31

y coma, ¿vale? Pero me va a decir 100 que 00:43:33

¿no? Tenéis que ir 00:43:35

entendiendo que es que 00:43:37

los números y los datos 00:43:38

no existen en el 00:43:41

código, no son operativos 00:43:43

hasta que no se encierran en una variable 00:43:45

que es lo que ya vimos el otro día 00:43:47

Si queremos generar una variable 00:43:48

de la vida del personaje que guarde 00:43:51

un valor 100 00:43:53

¿qué habría que generar? 00:43:54

¿Cómo sería? Que esto el otro día 00:43:57

un poco vimos 00:43:59

Una variable, ¿no? 00:44:00

vale, y como, dime un poco 00:44:04

que, como la genero 00:44:06

pues pones int 00:44:08

vale, int, ahora la vemos 00:44:09

espacio, vale 00:44:12

vida, muy bien 00:44:13

igualación, y punto y coma 00:44:15

vale, mira, que me digas esto 00:44:18

así, significa que ya has aprendido como se declara 00:44:20

una variable, muy bien, ha aprendido 00:44:22

así que vamos a ello 00:44:24

¿por qué ha sido int y no float? 00:44:25

o string o otra cosa, porque es un 00:44:28

número entero, vale, entonces 00:44:30

Entonces también esto habría que ver el juego, pero la vida normalmente si tiene un valor como 100 que es el máximo acabo de decir y vamos a decir ya por defecto que la muerte es que llega al cero, pues normalmente en un contador de eso no va a ir tan fino como ir a decimales. 00:44:32

Entonces, para no complicar al programa, pues no declaramos un float, que si no recordamos, para refrescar un float, era un parámetro, una variable, perdonad, con decimales, ¿vale? 00:44:48

Imaginaos que quisiera guardar una con decimales, y en ese caso, pues podríamos decir cosas como 5 con 5, ¿no? 00:45:01

¿Vale? Esto lo recordamos del otro día, que la f sirve para indicar que este punto al final es el separador de los decimales. 00:45:08

Y si no lo ponemos, o ponemos una coma, veis que ya empieza a dar errores, o si no ponemos el punto también, el F también empieza a dar errores, ¿vale? La sintaxis hay que aprenderla. 00:45:15

Entonces, tenemos aquí una variable que es vida 100, y esto significa que en este script ya podremos ir, en cualquier momento, ir diciendo que la vida, cuando arranca el juego, la vida del personaje es 100, ¿vale? 00:45:26

Y veis que yo tengo esta vida y es verdad que cuando declaramos una variable, que es darle una forma a la caja y un nombre, ¿vale? También la inicializamos o podemos decir, ¿vale? Que la vida, cuando arranque el juego dentro de esa caja al empezar, ¿vale? Tenga un 100, ¿no? Que esto lo vimos el otro día también. 00:45:40

Ahora es verdad que hemos guardado este dato, pero como el dato está declarado aquí arriba, todos los cambios que vayamos haciendo se estarán guardando en la caja que está aquí arriba. 00:46:02

¿Eso qué significa? Que antes os he hablado de que existían bloques para ir declarando las variables, incluso usándolas. 00:46:18

porque os he dicho también antes cuando hemos visto 00:46:26

lo de la instancia que guardamos 00:46:29

como variable, que se puede generar 00:46:31

incluso una instancia dentro de 00:46:33

un start, de un método 00:46:35

de un momento de acción, yo puedo decir 00:46:36

vale, esta variable vida se genera 00:46:39

aquí con un valor de 100 00:46:41

y luego decir vale 00:46:42

y en el update que vida 00:46:45

pase a llamarse, pase a valer 00:46:47

500, porque 00:46:49

cuando el primer frame queremos que sea 100 00:46:51

pero ya los siguientes 500, veis que aquí 00:46:53

vida da un fallo. Y esto es simple. ¿Alguien me sabría decir el por qué? A ver si eso más o menos, vamos, se explica en el tema cero, pero oye. 00:46:55

Vale, os he dicho antes que existía este encapsulamiento que servía para ir, digamos, generando bloques. Fijaos que cuando yo genero la caja, barra la variable, 00:47:07

le pongo el tipo de variable que es. Y yo he generado esta caja aquí, en el start. Y esto es un bloque. A diferencia de cuando lo generamos en la clase, que veis que comprende todo, aquí solo comprende esto. 00:47:17

Por tanto, cuando llamamos a esta variable en otro punto que no es de su bloque, pues no existe. Aquí podríamos incluso generar otra variable llamada vida, que es una vida diferente a esta. 00:47:29

Son dos variables distintas. Esto no es lo mismo que lo que habíamos hecho antes de decir, yo genero, declaro esta variable aquí arriba y ahora existe esta caja preparada en todo este ámbito y aquí es donde digo, vida 100 y aquí el 100 se está guardando aquí arriba. 00:47:40

Es decir, este 100 se está guardando en todo este tránsito. Si yo aquí, por ejemplo, dijera, voy a enseñar por consola, esto ya lo vimos el otro día, que es el debug log, voy a querer que me vaya en cada fotograma enseñando lo que vale vida. 00:48:01

Y veis que no me da ningún fallo. Me está enseñando vida, que está aquí creada la caja y la he cargado con un valor aquí. Es verdad que este ámbito donde he dicho que vale 100, y vais a ver que lo que me va a mostrar es 100, que este valor de 100 lo he generado aquí y este 100 ya está fuera del bloque. 00:48:16

Pero es que la caja donde está guardando los valores sí está fuera y sí que está en la cápsula, digamos, en el bloque, que luego permite que se comunique con una inferior, que es el update. 00:48:37

Si yo ahora ejecuto esta instrucción, lo primero es que probablemente desfalle o pase algo raro. 00:48:47

Yo voy a la consola y no veo ni 100, ni 0, ni nada. ¿Por qué? A ver quién me lo sabe responder. 00:48:55

Esto si habéis hecho la tarea 1 deberíais saberlo. 00:49:07

No has asignado el código, ¿no? 00:49:09

efectivamente, no hay ningún objeto 00:49:11

dentro del juego, ni le hemos 00:49:14

dicho de otra forma que se ejecute 00:49:16

no hay ningún objeto en el juego que tenga este script 00:49:17

por tanto el script no se está ejecutando 00:49:20

es decir, no hay ningún momento start 00:49:22

de nada en donde se ejecute 00:49:24

esto, ¿no? entonces 00:49:26

pues en punto 00:49:27

referencia, me da igual porque solo van a ser números 00:49:29

¿vale? voy a asignar 00:49:32

este durante la tutoría como 00:49:33

componente, ¿vale? 00:49:35

a ver, he guardado 00:49:38

recordad que hay que guardar el script 00:49:39

ahí está, y ahora lanzo el juego 00:49:41

a ver, y ahora sí que 00:49:43

cada fotograma está generando 00:49:45

un 100, aquí se van sumando hasta que llega a 1000 00:49:47

que ya no sea más, pero aquí 00:49:49

se van 100, 100, 100, 100, vale 00:49:51

entendéis que al final lo que estamos 00:49:53

consiguiendo es cambiar las variables 00:49:55

en distintos puntos del 00:49:57

código, esto es importante entenderlo 00:49:59

porque es lo que os he dicho antes 00:50:01

si yo genero aquí la caja y aquí no existiera 00:50:03

y guardo la caja aquí 00:50:06

al final vida no existe para el update 00:50:07

Porque está fuera del ámbito donde se ha generado esta caja. Esto también es por algo que se llama los ámbitos, que voy algunos pasos más adelante. Dentro del tema cero, aquí se habla de los ámbitos de las variables. 00:50:09

Y habla un poquito de estos bloques y de estos ámbitos y un poco también de lo que os estoy comentando aquí, ¿vale? Igual este código es un poco más avanzado, por eso lo estoy simplificando, pero básicamente de lo que habla es que están las variables globales que se declaran al comienzo y están disponibles en todo el script, incluso dentro de las funciones, como sería el start y el update y aquí saludar, ¿vale? 00:50:24

Y luego las locales, que se declaran dentro de una función, y por eso solo están disponibles dentro de ella, ¿vale? Por tanto, cuando más adelante hablemos, aquí he declarado una variable local, porque está en un bloque muy concreto, una función, y aquí las que se generan dentro de la clase son las variables que se llaman globales, ¿vale? 00:50:48

Es verdad que el otro día ya os dejé caer también que cuando, y voy a quitar esta variable global y vuelve a dar este fallo, os dije que por defecto si una variable, y bueno vuelvo al de instanciar, si una variable le ponemos serialize fill es cuando conseguimos que podamos referenciar o capturar cosas desde el inspector, que es lo que hemos hecho con el prefab que hemos arrastrado. 00:51:12

¿Vale? Y también os dije otra forma de hacerlo que era poniendo delante la palabra public, pública. ¿Vale? Vais a ver que yo cuando ponga public aquí, a ver si quiere, a ver, public, uy va, espera, que algo he hecho y he abierto. 00:51:38

A ver qué está pasando. Vale, cuando también tengamos... No, está bien. A ver, un segundo. Vale. Cuando tengamos variables públicas, aunque ahora me esté dando fallo, ya veremos que esto no sucede cuando lo hagamos en otros momentos. 00:51:56

Voy a volver a declararla como variable global. Cuando es pública, significa que va a trascender su propia cápsula e incluso en otros scripts distintos, en otras clases que tengamos, podremos acceder a esta variable. 00:52:22

Esto es más avanzado, pero me sirve para entender que por defecto, si no pone nada aquí, como hemos tenido hasta ahora, como me ha dicho Elisa, las variables son privadas. Es lo mismo poner esto de private que no poner nada, porque se entiende que una variable que no declaramos su ámbito es privada. 00:52:42

Cuando es privada es cuando ocurre esto que os estoy diciendo de que se encierra en su cápsula y solo se puede referenciar a esta variable en su bloque. 00:53:00

Cuando la ponemos en pública, además Unity tiene la, aparte de permitir que en otros scripts podamos acceder, 00:53:11

Si yo ahora mismo, por ejemplo, pusiera... Bueno, es que es un poco avanzado esto, ya lo veremos. Si pusiera un acceso a esta clase, podría acceder a variable con decimales desde otro punto, desde otro código. 00:53:20

Pero aparte tiene la capacidad de que cuando guardamos y volvemos a Unity, vais a ver que ahora existe esa variable igual que con el serializeField, que lo podemos aquí modificar. 00:53:34

Venía por defecto el 5.5 que está declarado aquí, pero aquí lo podemos modificar, si os fijáis. Está preparada. Esto significa que no es lo mismo, para que veáis y leéis una cosa, que no es lo mismo poner serialize fill de tipo in, lo que sea, y variable serializada. 00:53:47

también me sirve para que veáis 00:54:10

como voy escribiendo las variables 00:54:12

es algo muy importante 00:54:14

y le asigno y le pongo un 00:54:15

5.8f 00:54:17

porque es un float 00:54:20

¿vale? vais a ver que yo cuando 00:54:21

bueno, ¿por qué da fallo? 00:54:24

porque he intentado guardar una variable float 00:54:26

en un int ¿vale? entonces 00:54:28

es importante los tipos 00:54:30

de variables como los vamos gestionando 00:54:32

cuando ahora vaya 00:54:34

al 00:54:36

al script tengo las dos variables 00:54:37

Veis que aquí en apariencia hacen lo mismo, pero si aterrizamos aquí, vemos que una es pública, ¿vale? Y eso será accesible desde otras clases. De hecho, veis que la clase ya por defecto nos la declara pública también, para que podamos comunicarnos con esta clase en otros puntos del juego, con esta script en otros puntos del juego, en otros códigos. 00:54:40

Pero esta, realmente, al no poner nada del ámbito, en realidad privada, no podremos acceder a esta variable desde otros puntos del script. De los scripts. De este sí, porque está dentro de su ámbito, pero no podremos ir a otros códigos que se llamen tal cual. 00:55:01

De hecho, lo voy a hacer muy rápido, ¿vale? Aunque no entendamos tampoco. Tengo el script durante la tutoría y el script Instanced Prefab que he preparado antes. Imaginaos que yo quiero cambiar desde Instanced Prefab la variable con decimales. 00:55:18

Pues lo primero que habrá que hacer, igual que hemos hecho aquí, es decir, durante la tutoría, y veis que ahora voy a generar una variable que se llama igual que otro script. 00:55:33

Y es que recordad, al final las clases, como os he dicho aquí, se corresponden con el nombre de los componentes. 00:55:45

Y cuando arrastramos un script como componente, al final, igual que existe transform, pues existe el componente durante la tutoría. 00:55:52

Es una caja que podemos crear, ¿no? Entonces por eso existe aquí una caja y no da ningún fallo que se llama durante la tutoría y aquí lo puedo llamar como otro, en minúscula porque es una variable, ¿vale? Otro script. 00:56:00

Y aquí está preparado. Y yo en el transform puedo decirle, oye, quiero que otro script acceder a sus propiedades. Y vais a ver que yo a medida que me vaya metiendo en sus propiedades con el punto, como estoy apelando aquí, hay una variable suya de durante la tutoría que se llama variable con decimales. 00:56:14

Pues vais a ver que, cuando yo doy el punto, aquí existe una variable llamada variable con decimales. Y yo puedo decir, oye, pues esto quiero que valga 10. Y aquí está cambiando el valor, ¿vale? 00:56:32

Si yo guardo esto desde otro código, estoy cambiando el valor de este 5,5, ¿vale? 00:56:47

Y de hecho vais a ver cuando empiece el juego, ¿vale? 00:56:54

Que variable con decimales, que por defecto debería ser 5,5, ahora como lo he cambiado, pues está cambiado. 00:56:58

Ahora os explico otra cosa. 00:57:06

Como lo he cambiado en el componente, pues se ha quedado con otro comportamiento. 00:57:07

Pero yo cuando arranco el juego y pasa por ese start, vais a ver que vale. A ver, hazme caso. Claro, lo he cambiado aquí. Un segundito. Variable con decimales durante la tutoría. Instanced prefab. Y no se está ejecutando porque nuevamente este instanced prefab ahora no está en ninguno de los objetos. 00:57:12

Ah, pues sí, sí que está. A ver, está en script retainer. Entonces, bueno, vamos a hacer otra cosa porque no lo está cambiando en el editor, pero sí que lo está cambiando realmente. Si aquí decimos en el update, borro esto, que en vez de enseñarme la vida me enseña lo que vale variable con decimales, ¿vale? Vais a ver que lo que pone cada fotograma es 10 y no el 5,5 que está ahí. 00:57:33

Vale, entonces, vuelvo a ejecutar, me está enseñando 5.5, pero bueno, ¿esto qué está haciendo? A ver, un segundito, ¿eh? 5.5, bla, bla, bla, me enseña esto, bien, pues, vale, un segundo, solo por probar si es esto, hasta luego, Jesús. 00:57:58

hay otro problema 00:58:38

que es por lo que se usa 00:58:44

el serialize fill en ocasiones 00:58:46

que es que cuando tenemos aquí 00:58:48

un script que vamos cambiando 00:58:50

el valor, lo que vamos escribiendo 00:58:52

aquí se sobre impone 00:58:54

a todo lo que vayamos cambiando 00:58:55

entonces, si aquí dejamos 00:58:57

un valor ya puesto 00:58:59

que es diferente al que venía por defecto 00:59:01

se sobre escribe ese 00:59:03

de hecho veis que yo aquí pongo 33.2 00:59:04

y el que sale es 33.2 00:59:07

En ese caso, habrá que ir operando de distinto modo, porque como está haciendo público, lo está variando aquí. 00:59:09

Pero bueno, no debería... Perdona, porque esto en realidad lo estoy haciendo, pero por que veáis una cosa que no es ni siquiera esto. A ver, espera un segundo, que ya es por saber qué estoy haciendo yo. 00:59:19

A ver, papá, iba a ponerte entre 3 con 2, claro, porque es el que está sobreescribiendo. 00:59:36

Vale, este es el típico problema que pasa cuando tenemos un public, ¿vale? 00:59:42

Y al final lo que estamos haciendo es cambiar el valor, igual que hemos hecho con los valores de estos puntos, ¿vale? 00:59:47

Lo estamos cambiando en el editor, que es que básicamente en el editor estamos marcando qué tiene que hacer Unity y está sobreponiéndose a lo que hace el código. 00:59:55

Lo que me importa de todo esto es simplemente que veáis, esto suele tener otro uso, pero lo que me interesa es que veáis que variable serializada como es private, si yo voy aquí durante la tutoría e intento acceder a variable con decimales, a variable serializada, otro script, no va a aparecer. 01:00:04

Es decir, no va a aparecer variable serializada e incluso aunque yo me ponga a intentar escribir que valga 20, yo qué sé, me da fallo. ¿Por qué? Simplemente... 01:00:29

Ah, y bueno, ya sé por qué no se está ejecutando, no estaba guardando, creo. Vale, lo escribo bien. 01:00:41

Durante la tutoría, yo aunque tengo esta variable aquí serializada, no me la coge. ¿Por qué? Porque es privada. 01:00:47

Hasta que yo no la haga pública, yo no voy a poder acceder. 01:00:54

Veis que ahora ya ha dejado de tener error. 01:00:59

Esto simplemente me sirve, que lo mismo, todavía no sabemos aplicarlo, 01:01:01

me sirve para que veáis que las variables en ocasiones no se podrá acceder a ellas 01:01:05

o no se podrá ver en el editor porque no tienen el ámbito, el acceso al ámbito correcto. 01:01:09

Perfecto. Voy, me estoy enrevesando mucho quizá con ciertas cosas y vamos a volver a donde nos hemos quedado con el ISA. Pero lo que me importa es que ya sabemos que cada bloque, ¿veis? Irá dando fallo o no según el ámbito que tenga, en donde se declara esta caja. Que no es lo mismo declararla aquí al comienzo de la clase que dentro del start, por ejemplo. 01:01:17

¿vale? Luego 01:01:40

tenemos aquí un int 01:01:41

y hago aquí un float que es 01:01:43

vida 01:01:45

y 01:01:48

power 01:01:49

up, yo que sé 01:01:52

que es como los puntos que va a dar a la vida 01:01:53

el power up cuando lo recojamos, le voy a poner 01:01:56

que 50, recupera media vida ¿no? 01:01:58

Lo suyo sería que si hubiera 01:02:00

más de 100, pues el power up no te permitirá 01:02:02

tener más de 100, pero vamos a obviar eso de momento 01:02:04

¿vale? Lo que podemos 01:02:06

hacer el otro día dijimos es que podemos hacer operaciones de vida más power up 01:02:08

vale y que esto pues signifique algo no pero lo mismo hasta que no lo metemos 01:02:13

dentro de un contexto de una caja vale no va a dar ningún resultado voy a poner 01:02:18

vida actual y de actual que va a ser igual a la vida 01:02:23

más power up vale y esto da un problema ahora mismo he generado dentro de estar 01:02:28

Porque digamos que solo lo voy a ejecutar en el start 01:02:33

Una variable llamada vida actual que deneda error 01:02:36

¿Y por qué pensáis que puede ser? 01:02:40

A ver, así rápido, igual no caéis 01:02:43

Pero ¿por qué podría ser que dé error? 01:02:45

Porque realmente está bien configurado 01:02:47

Hemos hecho las cajas, le hemos dado unos valores 01:02:49

Y estamos guardando dentro de otra caja tipo int 01:02:51

Estos dos valores 01:02:54

Que el otro día ya vimos que se podía operar de este modo 01:02:56

¿Por qué pensáis que da fallo? 01:02:58

A ver si lo podéis 01:03:01

por los paréntesis 01:03:02

¿qué paréntesis? 01:03:09

entre, o sea, tendrías que poner 01:03:12

entre paréntesis vida más power up 01:03:13

vale, lo hago, esto en matemática 01:03:15

los paréntesis es para dar el orden de ejecución 01:03:18

de las operaciones 01:03:20

pero aquí sería, es indistinto 01:03:21

hacer esto que esto, ¿vale? 01:03:24

me digo que ese no es el problema, vaya, pero vaya 01:03:25

que buen intento, me encanta que participéis, por favor 01:03:27

vale, simplemente también para que 01:03:30

lo veáis, los tipos de cajas 01:03:32

cuando 01:03:33

Cuando sumamos 100 más 50 da 150 y es un entero, ¿no? Pero es verdad que aunque sea un entero, esto lo hemos generado como un float, es decir, está esperando decimales. Y una vez tenemos decimales en una operación, como sucede en PowerApp, ya no podemos meterlo en un float, en un int, perdón, hay que meterlo en un float. 01:03:36

¿Por qué? Porque será susceptible a meter decimales. Porque pensad que si yo hubiera puesto esto, ¿vale? ¿Qué podría ser? Aquí el int jamás va a saber qué meter en esta caja porque se sale de su rango. ¿Vale? Vais a ver que si yo pongo float, el fallo deja de suceder. ¿Vale? Importante. Hay, digamos, tipos de variables más restrictivas que otras. 01:03:55

Y esto, por lógica, en el caso de los números, por ejemplo, es el que más flexibilidad va a tener, pues es el que permite tanto tener números enteros como decimales. 01:04:15

Pero veis que el int no lo permite. 01:04:26

Hay formas de resolver esto, como hacer conversiones, pero bueno, esto sí que es más avanzado, lo usaremos más adelante, como es transformar un objeto en otro tipo de variable. 01:04:29

Con esto, poniendo entre paréntesis el tipo de variable al que queremos convertir otra, hemos dicho que el 50.5, bueno, pues que como vamos a operar y nos interesa por lo que sea que sea un int, pues que lo convierta en un int redondeando. 01:04:39

Siempre redondea la baja en este caso, pero estamos haciendo lo que se llama una conversión explícita. Estamos diciéndole cómo convertirlo. 01:04:52

simplemente lo que me sirve es que veáis 01:05:01

que a veces os pueden dar fallos que decís 01:05:03

¿de dónde me viene esto? 01:05:05

y es simplemente por el tipo de caja 01:05:07

porque es más restrictiva del otro 01:05:08

facilidad para saber identificar eso 01:05:10

si os ponéis encima de un fallo y lo dejáis quieto 01:05:13

os va a poner en la segunda línea en este caso 01:05:15

no se puede convertir implícitamente el tipo float en int 01:05:18

ya existe conversión explícita 01:05:22

compruebe si le falta una conversión 01:05:24

básicamente aquí lo que está diciendo es 01:05:25

que no se puede convertir 01:05:26

si no lo hacemos de manera explícita nosotros 01:05:28

Como he hecho antes con una orden que se puede ejecutar 01:05:30

No se puede convertir un float en int 01:05:33

Porque es que no cabe en esa caja 01:05:35

¿Vale? 01:05:37

Importante 01:05:38

Importante también 01:05:38

Eso 01:05:40

Que el tipo de variable puede determinar 01:05:41

Qué puede haber dentro 01:05:43

Luego, el otro día vimos también 01:05:44

Que había otro tipo 01:05:46

Entiendo que entre 01:05:47

Con todos estos problemas que pueden ir surgiendo 01:05:48

Lo que es un int y es un float, ¿no? 01:05:51

Y cómo se escribe un float 01:05:53

Para que no dé error 01:05:54

Hasta aquí entiendo que bien, ¿no? 01:05:55

Y bueno, así de fácil 01:06:00

Si yo ahora quisiera ver este valor en la consola, como que lo está recibiendo, lo está ejecutando. 01:06:02

Si veo vida actual y guardo, pues ahora al empezar el juego vamos a ver qué valor. 01:06:11

150,5. 01:06:22

Perfecto. 01:06:24

Vale. 01:06:25

A ver que algo hay por aquí. 01:06:26

A ver, lo mismo. 01:06:29

Pueden ser varias cosas, algo de lo que he tocado por ahí. 01:06:31

variable con decimales 01:06:33

variable con decimales, eso es que 01:06:36

ah bueno, os acordáis que yo había puesto 01:06:39

varias 01:06:42

esto es básicamente, fijaos 01:06:43

la que salía aquí, nuevamente por lo de los 01:06:59

hacerlo público o no y operar mal, yo he borrado las variables 01:07:03

que eran públicas para acceder desde aquí 01:07:06

y ahora, dice durante la tutoría otro script 01:07:07

pero ahora ya no existen estas variables, el error 01:07:11

aunque ha sido que hemos borrado aquí cosas 01:07:13

está afectando a estas variables que ahora 01:07:16

no saben dónde existen, ¿vale? 01:07:18

como no las queremos, lo voy a borrar, pero ved 01:07:19

que cuando comunicamos scripts entre sí 01:07:21

¿vale? y guardo, pueden venir los errores 01:07:24

porque estamos hablando entre unos y otros 01:07:26

y esto sirve también 01:07:28

para hablar del ámbito que estamos hablando 01:07:29

de que salga del bloque, porque cuando empezamos a hacer 01:07:32

códigos muy grandes, si 01:07:34

empezamos a hacer todo público, que se puede 01:07:36

hacer desde un lado a otro, que suele 01:07:38

parecer muy conveniente, muy 01:07:40

cómodo al principio, como estamos 01:07:42

comunicando distintos scripts, surgen este tipo 01:07:44

de problemas, que es que, vale, estamos cambiando aquí un script 01:07:46

pero también estamos afectando a otros 01:07:48

scripts. Entonces, si no tenemos un control 01:07:50

claro de qué está afectando a qué 01:07:52

o no lo restringimos con cosas privadas 01:07:53

o lo redirigimos de otras formas 01:07:56

que ya iremos viendo también, pues 01:07:57

al final lo que sucede es que 01:08:00

empiezan a surgir estos fallos y ahora es 01:08:01

bastante pequeño el código, pero nos puede 01:08:03

volver un poco la cabeza del revés. 01:08:06

Bueno, iba a dar 15,5 01:08:08

si no me equivoco, ¿no? 01:08:10

150 con 5, perdón, pues ahí está 01:08:11

150 con 5, con su decimal 01:08:13

¿vale? 01:08:15

imaginaos que yo quiero hacer una variable 01:08:18

que se va a llamar 01:08:19

nombre, ¿vale? y esto es de repaso del otro día 01:08:21

voy a pasar rápido 01:08:23

y yo quiero que ponga mi nombre 01:08:24

que ponga Daniel, ¿vale? 01:08:27

he creado aquí una variable y como 01:08:30

genero una variable que ponga Daniel 01:08:31

¿qué tendría que poner? 01:08:33

¿de qué tipo tiene que ser? una variable de texto 01:08:35

esto lo vimos el otro día 01:08:37

A ver, vuelvo a la unidad 0, que la tengo por aquí. Aquí, ¿vale? En las variables, pues ponemos las numéricas, int y float y luego lar de tipo string, ¿no? ¿Qué más pone? Podemos usar, su valor se introduce delimitado por comillas, ¿vale? Vale, sí, bueno, esto es otra cosa. 01:08:46

va delimitado por comillas, ¿no? 01:09:08

Si os acordáis, existe otro tipo de variable que se llama string, 01:09:11

en donde puedo llamarlo nombre, ¿vale? 01:09:15

Dado que así es como se va a llamar aquí abajo cuando la mentemos. 01:09:17

Y esto va a significar que se llama, 01:09:22

que yo quiero que aquí se guarde el valor Daniel, entre comillas, ¿vale? 01:09:24

Ahora yo cuando lance el juego, esto lo vimos el otro día. 01:09:28

No sé si tenemos dudas de esto. 01:09:31

Es muy importante que entendamos bien cómo funcionan las variables. 01:09:34

Aquí tenemos a Daniel, ¿vale? Que esto nuevamente yo puedo declarar aquí la variable y aquí, como está dentro del ámbito en donde se ha declarado la variable, pues aquí es donde puedo decirle, aquí quiero que se llame Daniel, ¿vale? Y ahora el resultado será el mismo, se verá Daniel, ¿vale? 01:09:37

si queremos por ejemplo 01:09:57

que en cierto momento del juego 01:10:01

cuando vayamos metiendo datos en un menú 01:10:02

pues por ejemplo podamos meter 01:10:05

nuestra edad, la edad importante 01:10:07

pues siempre va a ser un entero 01:10:09

pues no ponemos decimales 01:10:11

25, este es el mismo ejemplo del otro día 01:10:12

lo doy rápido, recordad que 01:10:15

como hemos visto antes 01:10:17

dependiendo del tipo de variable 01:10:19

pues aquí se va a lanzar de una forma 01:10:20

u otra, eso que significa 01:10:23

que si yo pongo 01:10:24

nombre, más, recordad que esto es la concatenación 01:10:26

de textos, esto también viene aquí explicado 01:10:31

declarando variables, aquí se va hablando un poco 01:10:34

de lo que vamos hablando, ahora vamos a hablar de booleano, pero vais a ver 01:10:39

que en Unity, a ver si no me equivoco 01:10:43

viene por aquí 01:10:46

vale, empezar 01:10:48

bueno, todo lo que os estoy comentando está más o menos recogido por aquí 01:10:54

y aquí se habla de cómo se van 01:10:58

bueno, aquí lo de que se ignoran los espacios en blanco, las líneas, que también lo hemos visto 01:11:03

que cuando vamos sumando distintos, aquí están los operadores 01:11:08

de hecho seguro que está aquí, cuando vamos hilando strings con 01:11:12

números, lo que va haciendo es concatenar ese texto 01:11:16

Es decir, que no es una soma como tal, igual que el igual no es igual y sirve para asignar una variable, cuando hacemos nombre más edad, que aquí no da ningún fallo, al final lo que está haciendo es poner un string Daniel y luego un número, pero un número que en realidad no es un texto. 01:11:20

Lo que pasa es que hay que entender que cuando en una concatenación de elementos, con este más, cuando unimos varios elementos, unos de tipo texto, el resto también se convierte en uno de tipo texto, ¿vale? Pasan a ser todo de tipo texto, igual que hemos hecho antes con lo de convertir el floating in, ¿vale? 01:11:39

Daniel 25, no pone ningún espacio porque si recordáis también aquí dentro podemos empezar con las comillas y las comillas sirven siempre para ir escribiendo nosotros textos literales, no son cantidades que se suman ni que se van a operar, son textos literales. 01:11:56

A mí poner la edad de espacio, ¿vale? Porque los espacios también son literales. Concatenamos Daniel, ¿no? Y ahora concatenamos es de 25, en este caso, años. ¿Vale? Esto cuando hagamos una UI para ir metiendo nuestro nombre al jugar, etc., es vital que vayamos conociendo cómo se declaran. 01:12:12

Yo ahora lo que voy a ver es la edad de, aquí hemos dejado una especie de variable que yo podría ir cambiando el valor, incluso se puede ir cambiando durante el juego, o guardará el valor que introduzcamos nosotros en un menú, en plan, ponerá la nombre y ponemos Jesús, pues se guarda Jesús en esta caja y aquí sabe perfectamente que lo que esté guardado en esta caja, que en ese caso será Jesús, y la edad pues la metemos también y podrá ser 35, pues en ese momento cambiará para mostrar otro mensaje en otro punto del juego. 01:12:41

y la edad de Daniel es de 35 años 01:13:11

fijaos que aquí falta un espacio 01:13:16

básicamente porque 01:13:17

deberíamos 01:13:19

decir que literalmente aquí haya 01:13:21

un espacio para que lo respete 01:13:23

vale, hasta aquí, de hecho es el mismo 01:13:25

ejemplo de la semana pasada, hasta aquí más o menos 01:13:27

vais pillando cómo funcionan los strings 01:13:30

quedarse con que se 01:13:31

escriben con estos 01:13:33

ah, mira, alguien me lo había escrito 01:13:35

antes con estas comillas vale y es importante que lo interpreta como una 01:13:39

cadena de textos literal luego por otro lado existe un nuevo tipo 01:13:45

de caja que el otro día no hablamos que son las booleanas vale y una booleana 01:13:51

sólo puede guardar dos valores verdadero y falso vale una booleana cuando 01:13:54

generamos una variable pues será de tipo pool en este caso para que decir que es 01:14:01

una booleana, y aquí voy a poner semáforo encendido, ¿vale? 01:14:05

Y voy a decir por defecto que sea true o false, ¿vale? 01:14:12

Tiene dos variables, es decir, que estas booleanas, las booleanas, 01:14:18

se escribe así, pueden ser true o false, ¿vale? 01:14:23

Igualmente que siempre, cuando sabemos que algo es booleano, 01:14:27

si yo pongo un 5, no es la caja que corresponde y da fallo. 01:14:30

Si yo hasta ahora pongo José, ¿vale? Entre comillas, como haría un string, da fallo, porque en esta caja booleana, llamada semáforo encendido, solo puede estar, o lo que suele significar true, que está encendido, ¿vale? Que es verdadero esto que ocurre o es falso, ¿vale? 01:14:33

Lo mismo, esto en el tema, cuando hablamos de las variables, lo siguiente que pone aquí es booleanos. 01:14:50

Pueden adoptar solo dos valores predefinidos, muy útiles para crear lo que se llaman interruptores o para indicar que algo está ocurriendo o no. 01:14:57

Estas booleanas se usan mucho y por eso he puesto lo de semáforo, sirven para decir si algo está ocurriendo o no. 01:15:06

Y cuando hagamos condicional es decir, como he dicho antes, si la vida del personaje ya es 100, no se le puede cargar el power up, porque está superando la cifra máxima que damos. 01:15:12

A veces podemos decir, oye, mientras el personaje tenga, y voy a poner indicador, en vez de semáforo, indicador máximo, vida. 01:15:24

¿vale? si yo empiezo 01:15:35

el juego con la vida llena 01:15:37

pues aquí estará true 01:15:38

y entonces mientras esto sea true, pues el power up 01:15:40

no se va a poder coger, porque no nos 01:15:43

interesa, ¿vale? ahora ya iremos 01:15:45

viendo con las, y esto está aquí 01:15:47

introducido, ¿vale? para que lo tengáis, con las estructuras 01:15:49

de control, con los ifs principalmente 01:15:51

pero hay más, ¿vale? iremos 01:15:53

diciendo, dando condiciones para que una cosa 01:15:55

se ocurra 01:15:57

o no ocurra, ¿no? entonces 01:15:59

en el momento que le demos un golpe 01:16:01

a este y baje a 25 01:16:03

cuando pongamos una condición 01:16:05

va a decir, vale, pues como baja de 25 01:16:07

y está comprobando que ya no es 100 01:16:09

esto va a decir, pues ya no es falso 01:16:10

no está con el indicador al máximo de vida 01:16:13

y entonces en ese caso sí que le permitirá 01:16:14

que cuando cojamos un power up de suma de la vida 01:16:17

para que pase de 25 01:16:19

hasta 75,5 01:16:21

¿vale? son como 01:16:23

ahí pone pues eso, conmutadores 01:16:24

interruptores, semáforos, ¿vale? 01:16:26

pues un semáforo puede estar encendido o apagado 01:16:29

¿vale? entonces 01:16:31

las booleanas van a ser sobre todo muy útiles en el momento de 01:16:33

pues de ir planteando ejecuciones e ir viendo si ciertas condiciones se van se 01:16:38

están cumpliendo no vale ya veremos ejemplos de esto también importante vale 01:16:44

en un de backlog si decimos que enseñe lo que guarda indicador máximo vida vais 01:16:49

a ver que lo que enseña vale en este caso es falso pues cuando ejecute el 01:16:53

juego, pues falso. Lo pone. No es una cadena de texto, es que no está cumpliendo la condición. 01:16:58

De hecho, internamente el código lo que está leyendo es que este valor vale o 0 o 1. Es verdad 01:17:07

que lo traduce en falso o verdadero, pero falso es 0 y verdadero es 1. De hecho, el otro día os dije 01:17:12

que si una caja, una variable, no se inicializaba, es decir, no se le daba un valor, por defecto valía 01:17:17

cero, o en el caso de los textos 01:17:25

vale nulo, no tiene contenido 01:17:27

entonces, si yo ahora 01:17:28

ejecuto este 01:17:31

debug log, como no tiene 01:17:33

nada en su interior 01:17:35

lo que va a mostrar es 01:17:36

falso, ¿vale? en realidad 01:17:38

es un cero, pero digamos 01:17:43

que la condición es falsa, que no es lo mismo 01:17:45

simplemente por ver que existe también 01:17:47

si ponemos true, ¿vale? pues lo que 01:17:49

va a enseñar es true 01:17:51

a ver, espera, ahí está 01:17:57

true, ¿vale? todos sabéis 01:17:59

leído aunque no lo hayáis empezado a hacer el enunciado de la tarea 0 y lo 01:18:01

que se quiere conseguir vale si no leerlo vale y lo entenderéis mejor lo 01:18:05

que voy a decir ahora pero como doy por supuesto que sí que lo habéis leído 01:18:12

porque es una de las cosas que os pedía para la tutoría de hoy vale 01:18:15

al final lo que queremos conseguir es y voy a abrir el código que lo tenéis 01:18:20

también y así lo podéis revisar más adelante pero lo pongo aquí vale era 01:18:23

conseguir que una nave espacial en la que van impactando meteoritos vaya quitándole escudo, 01:18:29

vida, por decirlo de otra forma, hasta que muere. Y este es el código, hay más formas de plantearlo, 01:18:36

pero es un código que resuelve el enunciado. Tenemos esta clase que se llama diagrama, 01:18:44

como se podría llamar juego nave, porque es descriptivo, y al final lo que estamos haciendo 01:18:49

es generar 01:18:55

un float con la energía del escudo 01:18:57

que empezará al máximo 01:18:59

ahora mismo vale 0 01:19:00

porque no lo hemos declarado solo 01:19:03

un número de vidas 01:19:05

porque el juego aparte de que muera la nave 01:19:07

va a haber varias vidas 01:19:09

pierdes una vez y te resta una vida 01:19:11

va a haber la vida de 100 a 0 01:19:13

por ejemplo y luego 3 vidas 01:19:15

luego la fuerza 01:19:17

del impacto que va a ir restando 2 vidas 01:19:19

cuando se choquen estos meteoritos 01:19:21

luego va a haber un booleano 01:19:23

un interruptor 01:19:25

como estábamos diciendo, que nos va a decir 01:19:27

si estamos vivos o no, que este interruptor 01:19:29

básicamente lo que va a hacer es 01:19:31

que mientras estamos vivos va a ser true 01:19:33

porque sí, estamos vivos, pero cuando 01:19:35

nos muramos va a decir 01:19:37

que es falso, que estamos muertos 01:19:39

básicamente, si lo traducimos a nuestro lenguaje 01:19:41

y en el momento en el que este interruptor 01:19:43

pasa a ser falso, es decir, que estamos muertos 01:19:45

pues el juego va a saber decir 01:19:47

va a entender ya el código que 01:19:49

pues oye, que el juego se ha acabado porque no estamos 01:19:51

vivos. Hemos perdido toda la energía y 01:19:53

también todas las vidas. Y luego aquí 01:19:55

hay un mensaje 01:19:57

que vamos a ir dando como 01:19:59

avisos en pantalla. 01:20:01

Si os fijáis, ya para ir 01:20:03

viendo una especie de ejecución 01:20:05

o de puesta en 01:20:07

algo menos 01:20:09

abstracto, ¿qué es esto? 01:20:11

Cuando iniciamos el juego, cuando iniciamos 01:20:13

el script, lo que vamos a hacer es, en ese momento 01:20:15

arranca el juego, arranca este script 01:20:17

y vamos a llenar las cajas que nos 01:20:19

interesan en este momento para darle un sentido 01:20:21

también al juego, hasta este momento 01:20:23

solo hemos generado espacios que rellenar 01:20:25

pero al empezar el juego nos decimos 01:20:27

oye, quiero que el escudo 01:20:29

de la nave sea de 100 01:20:31

¿vale? y como se va 01:20:33

a jugar con decimales 01:20:35

¿vale? pues lo hemos 01:20:36

planteado como un float ¿vale? 01:20:39

esto hay que tenerlo en cuenta como hemos visto después para 01:20:41

pues para ir 01:20:43

teniendo en cuenta problemas que puedan 01:20:45

surgir ¿vale? que suelen ser fáciles de corregir 01:20:47

pero oye, que nos pueden 01:20:49

traer de cabeza, pues tiende 01:20:51

vida, ¿vale? y aunque no ponga decimales 01:20:53

como es un decimal, es decir, es un float 01:20:55

mejor dicho, ya pongo la F, ¿vale? 01:20:57

si no la pongo 01:20:59

puede no dar problema, pero veis que 01:21:00

ser correcto tampoco 01:21:03

conlleva ningún 01:21:05

castigo, ¿vale? luego 01:21:07

al comenzar el juego, ojo, estamos 01:21:09

arrancando el juego y evidentemente 01:21:11

pues arrancamos vivos, si empezáramos muertos 01:21:13

pues ya sería mal asunto, ¿vale? 01:21:15

luego, las vidas 01:21:17

con las que arrancamos, ¿vale? igual que está la energía 01:21:19

pues tendremos tres vidas vale y luego veis que hay en el estar al arrancar una operación aquí 01:21:21

que es por como os he dicho antes como bueno en realidad lo pone aquí pero veis que se escribe 01:21:27

igual que el instante de antes es verdad que no hay nada dentro del paréntesis pero esto es un 01:21:34

método o una función vale los métodos y funciones vale al arrancar el juego pone quiero que haya un 01:21:38

impacto e impacto si yo voy a cualquier otro script vale si yo voy a leer 01:21:46

durante la tutoría que estaba haciendo ahora y en start yo pongo esto de 01:21:51

impacto veis que no existe no sale vale no 01:21:54

existe no es como instancia instancia siempre 01:21:59

existe yo pongo instancia y ahí está esperando 01:22:03

hay que poner su paréntesis y ahora que está y sí que obliga a que haya aquí 01:22:07

unos parámetros 01:22:11

como yo que sé 01:22:14

vamos a poner aquí, aunque dé fallo 01:22:16

pues vamos a poner, bueno no tenemos ninguno de tipo 01:22:18

objeto, no puedo poner ningún 01:22:20

parámetro aquí 01:22:22

porque va a dar fallo, porque nuevamente lo que nos 01:22:23

está pidiendo es un GameObject 01:22:26

lo que hemos visto antes 01:22:28

que la primera sobrecarga, su tipo 01:22:29

tiene que ser objeto 01:22:32

pero no sale el impacto, que os estaba diciendo 01:22:33

antes, ni bien ni mal 01:22:36

no puedo hacer nada, porque los métodos 01:22:38

Lo que vamos a empezar a hacer también es que los creamos nosotros, es decir, bajo un nombre que nosotros ponemos, ¿vale? Podremos ir, y veis que está aquí, meter nosotros nuestras operaciones dentro de un bloque, en este caso, fijaos que es largo. 01:22:40

Y este bloque lo que va a hacer, que llega hasta aquí, el bloque impacto, hasta aquí, todo esto es impacto, cuando yo ponga esta palabra, ¿vale? Se va a ejecutar lo que hay aquí dentro. 01:22:55

Entonces, vais a ver, y esto también es importante, que por primera vez, cuando llegamos a un punto aquí, ¿vale? Saltamos de aquí a aquí en la ejecución. 01:23:07

Luego irá el update, que también tiene su impacto. Pero primero estamos llamando a este impacto, salta aquí y se va a reproducir lo que hay aquí dentro. 01:23:17

¿Por qué instantiate sí existe? Y aquí existe, por ejemplo, si pongo el método instantiate, como os he dicho antes, impacto no existía en el otro lado. 01:23:28

Porque como os he dicho, en varias ocasiones, cuando empezamos cualquier script, tiene unas librerías y también hereda ciertos comportamientos, que es esto del MonoBehaviour, que os suene, que ya nos da operaciones prehechas. 01:23:39

Es decir, para que leemos más, cuando, a ver, un segundico, a ver si lo pone claramente aquí. Bueno, existe la clase objeto, ¿vale? Que cuando yo me meto en Instantiate, vais a ver, a ver, me meto en esta, con el control volvemos a meternos, ¿vale? 01:23:54

pone objeto instancia es una de las que ha cargado ya en la librería vale hay otra clase en otro 01:24:17

sitio que está guardada en la librería unity engine que cuando empezamos cualquier juego 01:24:22

está aquí si yo por ejemplo intentará poner instancia como siempre ocurre y cualquier cosa 01:24:28

bueno en esta como no como no lo voy a rellenar no me va a dar fallo siempre pero fijaos que 01:24:35

Este instantiate funciona sin problema hasta que yo me cargo el, o lo comento mejor aún, comento el Unity Engine. 01:24:40

Y veis que instantiate junto a otras muchas cosas, fijaos en las clases, dejan de funcionar, ¿vale? 01:24:48

Entonces, tenéis que ir entendiendo que existen las clases y los métodos que ya existen 01:24:55

y luego los métodos que nosotros podemos ir haciendo para ir recopilando distintas acciones 01:25:00

y que cada vez que pongamos esta frase, pues, oye, haga todo esto. 01:25:04

si yo quiero poner impacto varias veces 01:25:07

en mi código, pues no tengo que escribir 01:25:10

todas estas líneas, ya está recogido 01:25:12

dentro de su propio bloque 01:25:13

¿hasta aquí qué tal? 01:25:15

bueno 01:25:20

te has quedado en lo de impacto, hasta aquí bien 01:25:20

sí, a ver, es que yo he estado 01:25:24

intentando hacerlo sin mirar esto que habías puesto 01:25:26

conseguí no dar ningún error 01:25:29

hasta lo de que me quedo sin escudo 01:25:31

que ya ahí colapsé 01:25:33

pero cuando meto el impacto no me lo 01:25:34

reconoce, me dice que no puedo hacer un boite 01:25:37

impacto, ya he entrado 01:25:39

ahí, me doy la tutoría 01:25:41

tranquilamente y supongo que 01:25:43

lo sacareis y no te pregunto 01:25:45

realmente todavía no hemos explicado 01:25:46

cómo se crea esto, es decir 01:25:49

todavía no he explicado cómo se crea esto 01:25:51

es decir, que estoy 01:25:53

más avanzada de lo que hemos explicado 01:25:53

entonces, ¿vale? así que bien 01:25:56

te quiero decir, solamente estoy 01:25:59

como dejando caer muchas veces que 01:26:01

cuando veamos una 01:26:03

orden de este tipo con mayúscula 01:26:04

y paréntesis, estamos llamando 01:26:06

un método y que hay métodos que ya vienen 01:26:08

prehechos, ¿vale? Por estas librerías 01:26:10

y otros que no, que los hacemos nosotros. 01:26:12

Ahora tenemos que aprender a hacerlos nosotros. 01:26:15

¿Vale? Pero hasta... 01:26:17

Aunque... 01:26:19

Aquí llegamos y lo que pone aquí, invocamos a la función 01:26:20

que realiza el impacto. Es decir, 01:26:23

que al empezar el juego, 01:26:24

estamos metiendo dentro de esta palabra impacto 01:26:26

pues que haya un impacto, 01:26:28

que es lo que vamos a hacer aquí. ¿Vale? 01:26:30

Vale. ¿Da igual ponerlo 01:26:33

antes del Void Start o después? 01:26:34

¿El impacto te refieres a esto? 01:26:37

Todo. O sea, las declaraciones de las variables. 01:26:38

Vale. Las variables, cuando son globales, ¿no? Como hemos dicho antes, pueden ir aquí o pueden ir al final. 01:26:42

Y vais a ver que cuando las pongo al final, ¿vale? Dentro de la clase, pero al final todo funciona. 01:26:50

¿Por qué? Porque está dentro de la clase. 01:26:56

Entonces, todo lo que se va metiendo en bloques inferiores, pues puede acceder a estas clases. 01:26:59

pero sí que es verdad que es mucho más intuitivo 01:27:04

y es la convención aparte 01:27:07

que esto vive mucho de convenciones 01:27:09

de que todas las, incluso aunque luego 01:27:11

sigamos picando código aquí abajo y queramos 01:27:13

crear una nueva variable, si queremos 01:27:15

que sea global de toda la clase, subimos 01:27:17

y la ponemos aquí, porque así 01:27:19

de un vistazo rápido 01:27:21

tenemos todas las que son globales ya 01:27:22

englobadas, se puede mientras 01:27:25

esté dentro del bloque 01:27:27

correspondiente a donde queremos que funcione 01:27:29

que por eso he explicado lo del encapsulamiento 01:27:31

funcionaría, pero la convención dice que 01:27:33

lo hagamos aquí, ¿vale? De hecho hay 01:27:36

más convenciones, ¿vale? Porque ahora mismo 01:27:38

todas son private y a 01:27:40

veces iréis incluso viendo 01:27:42

o que 01:27:43

hay gente que dirá, siempre que creo una variable 01:27:45

private empiezo con una barra baja 01:27:48

para que así al ir cambiándolo 01:27:50

en el código, ¿vale? Saber 01:27:52

que es una variable privada, que no 01:27:54

la voy a declarar mediante el inspector, sino 01:27:56

que la voy a ir declarando yo siempre a mano 01:27:58

en el código, porque no se puede ir al 01:28:00

editorio Unity y cambiarlo si es privada, ¿no? 01:28:02

Luego hay gente, lo digo 01:28:04

por si encontráis, que siempre que haga 01:28:05

una variable global, le pone 01:28:07

m barra baja, vamos, habría 01:28:09

que ponerlo en todas, y todas las que va generando 01:28:12

dentro de métodos 01:28:13

o de niveles inferiores, como este int, por ejemplo, 01:28:16

pues va sin la barra baja. 01:28:18

Y esto sirve para saber cuáles son variables globales 01:28:20

y distinguirlas de las que no. Pero esto 01:28:22

ya son convenciones que van más adelante, 01:28:23

es decir, que vamos primero a lo básico. 01:28:26

Vale. Gracias. 01:28:28

Nada, perdona, que sé 01:28:30

Que me preguntas una cosa y te correspondo con tres. 01:28:31

No, no, no, no pasa nada. 01:28:34

Pero es que así van sonando las cosas. 01:28:35

Vale. 01:28:37

Entonces, se puede declarar incluso, fíjate, ¿vale? 01:28:38

La quito de aquí, pero aquí dentro, ¿vale? 01:28:43

Digamos que aquí hay un bloque que se cierra aquí y aquí empieza otro. 01:28:46

Es decir, si lo declarara aquí en medio, también lo estoy declarando dentro de la clase y no da problema. 01:28:49

Pero claro, tú cuando luego quieras descubrir dónde están las variables de toda la clase, 01:28:54

como empieces a no organizarlo bien, te vuelves loco. 01:28:58

Por eso, justo debajo de clase, las que son variables globales se declaran y además si trabajas en un equipo, pues todos saben dónde está la variable globales y todos están contentos de encontrarlo rápido. 01:29:01

Hay gente que lo pone al final por lo mismo, porque saben que están al final de la clase y lo encuentran antes. 01:29:13

Pero como luego dentro de un mismo script se pueden crear varias clases, que esta es otra cosa, se crea la clase a continuación y si lo pones justo debajo de donde se declara, pues más claro, el mejor sitio, vaya. 01:29:19

Vale, hasta aquí más o menos me vais siguiendo, ¿no? Más o menos. Vale, voy a seguir unos 10 minutillos más o 20, ¿vale? Pero voy a ver porque a veces me escriben las dudas aquí y necesito verlo por mi cuenta. 01:29:32

Vale, en las variables también habla de arrays, esto es más avanzado, pero es simplemente para que también os suene un array, que a veces se puede llamar matriz o arreglo, se pueden dentro de una sola caja meter muchos tipos de datos. 01:29:54

Y de hecho, un array, para que os hagáis cuenta, cuando metemos, aunque no está declarado específicamente, cuando generamos una variable, por ejemplo, de transform, no estamos metiendo un dato como los números que metemos, un 10, o Daniel, o 5. 01:30:13

Como os he dicho antes, se están guardando un montón de valores, ¿vale? 01:30:36

Al final esto, si habéis estudiado matrices en matemáticas, esto es un poco parecido a una matriz. 01:30:39

Es decir, que hay muchas posiciones de esa variable, ¿vale? 01:30:44

Que os suene. 01:30:47

Esto es más avanzada, así que me lo salto ahora mismo, ¿vale? 01:30:49

Ya tendrá más sentido más adelante. 01:30:51

En esta sección, voy un poco en el orden ahora para ir resolviendo dudas. 01:30:54

Aquí veis lo que acabamos de hablar, de cómo se declaran las variables, 01:30:58

un poco inconvenientes que se pueden encontrar, etc. 01:31:01

Y hay otras, digamos, instrucciones importantes, 01:31:07

otros operadores también, que son estos que tenemos aquí. 01:31:12

Estos son bastante importantes porque se usan de vez en cuando 01:31:15

y si no, pues de pronto saltáis esto porque no parece importante, 01:31:18

pero sí lo es. 01:31:23

Pone el truco de programador como un extra, 01:31:24

pero no es un extra, es importante. 01:31:26

Es los operadores más más, los operadores menos menos, más igual y menos igual. Me quedo en estos. Hoy no voy a avanzar más de aquí, de las variables y lo que hemos ido viendo de otras cosas. 01:31:27

En las variables acabamos de decir que existen estos operadores. Lo dejo aquí. El más más y el menos menos. A ver, me voy al de durante la tutoría. 01:31:44

Y voy a simplificar un poco esto. En indicador máximo de vida era un booleano. Me voy a cargar todo lo que ya no me interese y me voy a quedar con un int, por ejemplo, para hacerlo más simple. 01:31:54

Cuando estamos en cualquier punto del código puede haber momentos en los que queremos que una variable vaya sumando progresivamente de uno en uno su valor. 01:32:06

vale eso qué significa que a veces hacemos lo que se llaman bucles vale si vais más adelante se habla 01:32:17

del ford del wild del wild bueno hay varios más avanzado también pero que lo que van haciendo esos 01:32:23

bucles es ir recorriendo varios elementos y esos elementos van digamos siendo posiciones pues por 01:32:32

ejemplo imaginaos por decirlo así vemos el típico ranking de una recreativa antigua vale lo pongo 01:32:41

aquí ranking recreativa a ver si sale lo que yo quiero que salga que no lo sé imágenes vale lo 01:32:47

típico lo mejor es 5 resultados vale y esta va a ser la primera posición la segunda tercera cuarta 01:32:55

la quinta y ya no existen más entonces habrá un momento que nos va a ir interesando que vaya pues 01:33:00

eso muestra la 1 cuando muestra la 1 muestra la 2 cuando muestra la 2 muestra la 3 veis que va 01:33:06

sumando progresivamente. En ese momento se usa este operador 01:33:11

más más, ¿vale? Que es una forma de simplificar 01:33:15

que sumamos 1 01:33:18

a la variable, ¿vale? 01:33:23

¿Esto qué significa? Que si yo ahora mismo pongo aquí vida, 01:33:27

¿vale? ¿Qué me va a mostrar en consola? 01:33:31

27, no, 26. A ver, lo pongo, vale 25, 01:33:40

le sumo 1 y 26 01:33:43

vale, vamos a ello 01:33:46

26, perfecto, vale 01:33:46

esto luego habrá otras operaciones que puede sumar 01:33:51

más más 5 veces, porque digamos 01:33:54

que 5 veces, pues irá pasando 01:33:56

por las 5 posiciones para mostrar ese ranking 01:33:57

vale, es un operador muy importante 01:34:00

si pones 4 más eso 01:34:02

más 2, no, no 01:34:04

pregunto, no, no, no 01:34:05

si voy poniendo más 01:34:07

se vuelve loco, da fallo, vale 01:34:08

vale, esto es lo mismo 01:34:11

Y esto es otra sintaxis que suele dar problema al principio, ¿vale? Que esto mismo es la forma resumida de escribir esto, ¿vale? Y vais a decir, esto no tiene mucho sentido. Bueno, hasta que lo tenga, ¿vale? Esto y esto es exactamente lo mismo, ¿vale? 01:34:13

Y vais a decir, ¿cómo vida es igual a vida más uno, no? Si lo pensamos en álgebra humana, eso no tiene sentido porque estamos pensando como pensarían las matemáticas, ¿no? Las ecuaciones. 01:34:32

Pero recordad que aquí lo que estamos haciendo es, esta caja, esta variable, ¿vale? Es igual, ¿vale? Se le asigna lo que ya vale ahora mismo más uno. 01:34:43

Entonces, esto significa que lo que hay en esta caja es igual a lo que guarde la caja. 01:34:54

Aquí está refiriéndose a abrir la caja y aquí se está refiriendo al contenido de la caja. 01:35:00

Aquí siempre hablamos de declarar la variable o llamar a una variable e inicializarla o cambiar el valor. 01:35:05

El igual no es igual, no es un igual de matemáticas, es un asignador. 01:35:10

Entonces, vida es igual a vida más uno. 01:35:15

Es decir, en esta caja vamos a guardar lo que valga vida más uno. 01:35:17

Y si volviéramos a poner aquí vida, pongo otra vez esta línea, ¿vale? Cuando yo muestre otra vez la misma instrucción, no son lo mismo, ¿vale? ¿Qué pensáis que va a poner ahora en la consola? 01:35:20

Lo mismo, 26. 01:35:36

Aquí 26, ¿vale? Pero estoy diciéndole otra vez, recordad, esta... 01:35:39

¿Y te coge la segunda orden que estás dando el resultado de la primera y no el resultado del que has declarado? 01:35:44

Vale, ahora lo explico. Simplemente lo voy a enseñar para que me creáis y luego os lo explico. 01:35:51

Esto es bastante simple y a la vez bastante complicado. Veis que pone 26 y 27. 01:35:57

Volvemos a lo del encoapsulamiento y cuando se declaran las variables. 01:36:03

Tenemos una variable global aquí arriba, con su caja, y la inicializamos con 25, 01:36:07

como podría ser con cualquier valor. 01:36:13

Y vamos aquí y decimos, vale, en vida, igual que antes decíamos ahora vale 70, 01:36:15

y lo decíamos así a las bravas, entonces aquí en señal 70, 01:36:21

esto lo vimos el otro día y lo hemos visto antes también, 01:36:24

quiero que sea lo que vale vida más 1. 01:36:27

Y aquí lo que está haciendo es coger, todavía no lo hemos asignado, 01:36:30

está abierta la caja y aquí hacemos la asignación. 01:36:34

está volviendo a donde se declaró la variable, coge este valor, le suma 1 y lo guarda en vida. 01:36:36

Vale, y lo lee de arriba a abajo y por eso suma 2. 01:36:44

Y aquí lo aguarda como vida. 01:36:46

Pero es que cuando volvemos a esta caja, vuelve a abrir la caja y aquí ya no vale 25 a estas alturas, vale a 26. 01:36:48

Vale. 01:36:53

Y le sumamos 1. 01:36:54

Y así progresivamente, es decir, si yo empezara a hacer esto, pues sería 26, 27, 28, 29, ¿vale? 01:36:56

que es lo mismo, ¿vale? 01:37:02

os lo vuelvo a decir, en vez de escribir todo esto 01:37:05

es lo mismo que decir esto 01:37:07

es a la caja, súmale uno 01:37:08

¿vale? es exactamente lo mismo 01:37:11

vale, pero si lo quisiera 01:37:13

mencionar en otra caja 01:37:15

que se vinculara con los 26, sí que le tendría 01:37:17

que asignar como otro nombre a vida 01:37:19

para que la otra cápsula te lo 01:37:21

reconociera por 26 en vez de por 25, ¿o no? 01:37:23

no, aquí lo que va 01:37:26

haciendo, claro, tú me estás hablando 01:37:27

de abrir otra variable distinta 01:37:29

Claro, si tú abres otra variable, pues esto se llamará muerte, no sé, y esto tendrá otro valor. Es decir, vida y muerte son distintos. Es decir, si yo aquí digo muerte y le pongo 800 por poner un valor muy distinto, aquí es que muerte no está cambiando en ningún momento. 01:37:31

Es verdad que yo puedo ir aquí y decir muerte. Y aquí me va a enseñar vida 25 más 1, 26. Ha guardado 26 en la caja en este momento. Ahora vuelvo aquí, que ya vale 26. Estoy llamando a la caja. 26 más 1, 27. En este momento va a enseñar 27. 01:37:51

¿vale? vuelvo a llamar 01:38:09

a la caja vida, he guardado 27 01:38:11

aquí antes, ¿vale? 27 más 01:38:13

1, 28, en este momento 01:38:15

la caja vale 28 y aquí enseñará 28 01:38:17

y aquí valdrá 29 01:38:19

pero aquí no va a enseñar 29 01:38:21

porque es que lo que le estoy diciendo que enseñe no es 01:38:23

vida, no es lo que hay en la caja vida 01:38:25

es la caja muerte, entonces va a enseñar 01:38:27

26, 27, 28 y 800 01:38:29

vale, pero si yo lo pusiera 01:38:31

fuera de esas llaves 01:38:33

sí que tendría que 01:38:35

declarar de otra manera la vida 01:38:37

más uno para que me lo reconociera 01:38:39

porque estaría fuera de todas 01:38:41

estas llaves, no sé si me explico 01:38:43

claro, pero tú donde has declarado la variable 01:38:45

es a comienzo, es global 01:38:47

entonces se va a poder usar en toda 01:38:49

la clase, sin problema 01:38:51

el problema viene 01:38:52

de que yo 01:38:55

la declaro aquí 01:38:56

como está en el ámbito, aquí sí que funciona 01:38:58

¿no? pero si yo luego en el 01:39:01

update pongo 01:39:03

vida, pues es lo de antes 01:39:05

aunque yo ponga vida más uno 01:39:07

es que no sabe que es vida 01:39:09

porque está fuera de su ámbito 01:39:11

¿vale? 01:39:12

sin embargo muerte sí 01:39:14

porque muerte está aquí 01:39:16

muerte se va a poder poner 01:39:17

muerte es igual a 55 01:39:18

¿vale? 01:39:21

o mejor aún, mira 01:39:24

¿sí? ¿me vas siguiendo? 01:39:25

sí 01:39:27

vale, o mejor aún 01:39:28

voy a comentar esto 01:39:29

para que en el start no haga nada 01:39:32

y no salgan muchos numerajos 01:39:33

pero imagínate que en el update 01:39:35

que recuerda que se va planteando en cada fotograma, quito lo de muerte 55, 01:39:37

digo que cada fotograma me enseñe lo que vale muerte, que esto por ejemplo puede servir para un contador. 01:39:44

Aquí, muerte. ¿Qué crees que va a pasar? Como la he declarado arriba, como es global, 01:39:51

puedo hablar de muerte de esta variable en cualquier lado, ¿qué va a ir pasando? 01:39:59

que va a sumar 801, 802, 803 01:40:03

porque lo has puesto 01:40:07

en el que se va cargando por fotograma 01:40:08

exacto, empieza valiendo 01:40:11

800, en el fotograma siguiente le digo 01:40:13

ojo, súmale 1 y me lo enseñas 01:40:14

y aquí guarda 801 01:40:16

porque está fuera del update 01:40:18

en el siguiente, 801, súmale 1 01:40:19

vale, pues enseñará 802 01:40:23

y guarda 802 01:40:24

y ahora vas a ver que tenemos como una especie de contador 01:40:26

muy poco refinado 01:40:28

pero vas a ver que cada fotograma 01:40:30

Espera, ¿verdad? 01:40:33

Sí. 01:40:34

¿Vale? 01:40:35

Ahí. 01:40:36

Pues va a ir sumando. 01:40:37

Cada fotograma que por segundo se ejecuta mucho fotograma, ¿vale? 01:40:38

Por eso va como a saltos. 01:40:41

Pero sí que se están planteando, ¿vale? 01:40:43

¿Ves que van sumándose? 01:40:47

Sí. 01:40:48

¿Vale? 01:40:48

Que no va de uno en uno. 01:40:49

Bueno, si vas parando sí van de uno en uno, 01:40:50

pero se ejecuta más rápido del uno en uno. 01:40:52

¿Vale? 01:40:55

Entonces, pues mira, por ejemplo, una aplicación práctica. 01:40:55

Pues para hacer un contador, pues mira, el más más puede servir. 01:40:58

Y lo mismo. 01:41:01

Esto es igual a muerte más uno. Es exactamente lo mismo. Va a dar el mismo resultado. Si quieres lo comprobamos, pero te lo digo yo. 01:41:01

Sí, sí, lo da. 01:41:09

Vale. Y, vale, muerte más uno. Vuelvo aquí a los apuntes. ¿Vale? Este operador, importante que sepáis cómo... Bueno, esto lo apago, que ya está aquí usado. 01:41:09

¿cuántas cosas? ¿vale? 01:41:20

y esto también, esto que estoy poniendo 01:41:23

de vida más 01:41:26

vida igual, vida más uno 01:41:27

también se puede poner con otra forma resumida que son estas 01:41:29

¿vale? bueno, ojo 01:41:32

no he puesto el menos menos, pero el menos menos lo que va haciendo 01:41:33

es restar uno, ¿vale? cada vez que se invoque 01:41:36

igual, si queréis hacemos las pruebas 01:41:37

pero por no perder tiempo 01:41:39

pero existe el más igual y el menos igual 01:41:41

¿vale? si yo voy al más igual 01:41:43

lo que se puede hacer 01:41:46

es para no tener que repetir, que incluso es 01:41:48

La confusión que nos viene siempre, en vez de poner muerte igual a muerte más 1, cuando se va a hacer una operación sobre la misma variable, sobre la propia variable, se puede hacer igual más 1. 01:41:50

¿Y esto qué significa? Que muerte pasa a valer lo que valga más 1 o más 7 en este caso. 01:42:02

Ahora se van a ir sumando de 7 en 7. Va a ir 807, 814 y cada fotograma va a ir enseñándolo. 01:42:10

vale, ¿por qué no lo está haciendo bien? 01:42:17

pues por una cosa muy simple 01:42:23

que es que he puesto igual más 01:42:24

no más igual, ¿vale? importante 01:42:26

he puesto igual más 01:42:28

y la operación es 01:42:31

más igual 01:42:32

ahora mismo esta línea como no tiene sentido 01:42:33

¿vale? le estaba diciendo 01:42:37

que era un 7 positivo básicamente 01:42:39

entonces siempre vale 7, que no es lo mismo 01:42:40

que cada vez que dé una vuelta 01:42:42

en este caso vaya sumándole 7 01:42:44

ahora sí que va a ir 01:42:46

800, 800, 7 01:42:48

va a ir, lo paro porque si no esto 01:42:50

se vuelve loco 01:42:52

vale, 807, va sumando 01:42:54

7 en cada ocasión, que es la cifra que hemos 01:42:56

puesto, vale 01:42:58

si aquí lo pusiéramos con el 01:43:00

menos, aquí lo bueno es que podemos determinar 01:43:03

que sean saltos más allá del 1 01:43:04

vale, porque en el más más sí que es 1 01:43:06

por ejemplo, aquí también podríamos poner 7 01:43:08

por ejemplo, si aquí 01:43:10

ponemos que vaya restando 1 en cada fotograma 01:43:12

pues será 01:43:19

lo paro y voy para arriba para ver lo que ha hecho 01:43:19

va restando uno en cada vuelta 01:43:22

¿vale? 01:43:27

eso es importante, ¿qué tal hasta aquí? 01:43:29

bien 01:43:31

más o menos, ahí va 01:43:32

para el próximo día 01:43:34

me quedo con 01:43:37

esto siguiente, con el último ¿vale? 01:43:38

esta página más o menos estaría vista 01:43:41

falta de los arrays, que los arrays 01:43:42

lo vemos poco después 01:43:45

y tardaré un poco en hablar de ellos 01:43:46

pero aquí hay otra línea 01:43:49

que sirve para invertir booleanos 01:43:50

Pero bueno, ya lo veremos cuando veamos la aplicación más aplicada, por decirlo así. 01:43:52

Entonces, hasta aquí que esta página más o menos la deberíais ir ya entendiendo. 01:43:59

Entonces, hay una última cosa que quiero que sepáis, que es, que antes lo hemos visto, que es, por un lado, 01:44:06

que cuando tenemos algún, a ver, que lo voy a tener que crear porque no lo tengo, 01:44:14

Cuando tenemos algún valor público o con serialize fill, como aquí, es decir, que lo asignamos, lo podemos asignar por el editor, como hemos hecho, pero en este caso es un número, yo aquí le he asignado 800 y esto lo voy a comentar para no complicarlo más. 01:44:17

Yo aquí le estoy diciendo que esto vale 800 01:44:38

Y yo voy 01:44:41

Y voy al script durante la tutoría 01:44:42

Y vale, pone 800 01:44:44

Y yo le digo, bueno, no, 800 no 01:44:45

950 01:44:48

¿Vale? 01:44:51

Es verdad que aunque, bueno, espera 01:44:52

Y en el start voy a decir que me enseñé 01:44:54

Que está guardando muerte 01:44:56

Porque si no, no sabemos que está interpretando 01:44:58

Internamente el 01:45:00

El programa 01:45:02

¿Vale? Cuando empiece el juego, enséame lo que vale muerte 01:45:04

Y aquí yo he inicializado muerte, pone 800, lo lógico sería que pusiera 800, ¿vale? Que era el problema que estaba dando antes. Yo cuando voy y arranco el juego, ¿qué es lo que me pone? 950, ¿vale? 01:45:06

Quiero que entendáis que los códigos, igual que si aquí pongo 800 y al arrancar el juego, aunque aquí la haya declarado, luego ponga muerte, igual a 1000. 01:45:20

Aquí, si no lo tuviera serializado y lo cambiara, lo que me va a enseñar es 1000, porque aunque aquí esté de comienzo inicializado como 800, luego al arrancar el juego, digamos que hay una operación posterior, que es que al arrancar el juego, pues oye, me dice que vale 1000. 01:45:33

Entonces, lo que me va a enseñar es 1000. Pero hay algo más allá incluso, que es que todo lo que hagamos en el inspector, más allá del código, más cercano, digamos, a la ejecución, sobrescribe a lo que vamos haciendo en el código. Por tanto, podremos ir variando, ¿veis? Verás que vuelve a salir, aquí ha salido el 1000, porque es verdad que cuando arranca el juego, aunque yo haya cambiado esto, ¿vale? 01:45:49

Como yo he cambiado el juego y le he dicho al arrancar la ejecución, ponmelo en 1000, ¿vale? 01:46:14

Sobrescribe al empezar el juego, en un momento de ejecución, lo que yo ya he hecho tanto en la declaración inicial, ¿vale? 01:46:20

Como en la sobrescriptura que tenemos aquí, que sí que es verdad que si no hiciera nada más, ¿vale? 01:46:27

Como no hay un momento de ejecución, no hay un momento en el que lo vuelve a cambiar. 01:46:32

Pero tened ojo con que a veces poner aquí las instrucciones puede dar este tipo de problemas, que hay un orden de ejecución, ¿vale? 01:46:35

ya os iréis pegando con ello 01:46:42

no sé si me vais siguiendo pero eso 01:46:44

aquí al inicializar pues damos un valor 01:46:46

pero luego hay momentos de ejecución 01:46:48

con el start y el update 01:46:50

que pueden ir sobre escribiendo valores 01:46:52

pero este serialize field 01:46:54

perdonad por el joder 01:46:58

y el public 01:46:59

también se puede variar dentro 01:47:00

del propio 01:47:02

del propio 01:47:04

script y de hecho para que os hagáis 01:47:06

una idea yo aquí 01:47:08

pongo 01:47:10

serializar 01:47:11

el campo 01:47:13

lo inicializo como 800 01:47:15

al empezar lo pongo en 1000 01:47:17

y quiero que la muerte 01:47:19

me lo vaya enseñando en el update 01:47:21

que cada fotograma me vaya enseñando esta cifra 01:47:23

y guardo, y vais a ver que pasa una cosa 01:47:25

que mezcla todo esto 01:47:27

que acabo de decir 01:47:29

yo arrancaré el juego 01:47:30

al arrancar se me pone en 1000 01:47:32

sobre escribiendo esto que está en 1132 01:47:34

a ver, placa 01:47:37

se pone en 1000 01:47:39

Y vale, pues 1000 01:47:40

Me lo ha puesto 1000 incluso aquí 01:47:42

Pero cuando yo ya he arrancado el juego 01:47:43

Como digamos que esta orden ya se ha ejecutado 01:47:45

Y no lo va a sobreescribir 01:47:49

Al final lo que va a importar es 01:47:50

Lo que yo vaya poniendo aquí 01:47:52

Y veis que va cambiando el valor 01:47:53

Y podría ir cambiando desde el editor a mano 01:47:55

Ciertos valores 01:47:58

¿Vale? Que os suene 01:47:59

¿Pero para qué? 01:48:01

Pues por ejemplo, imagínate que quieres probar 01:48:03

Hacia donde se mueve una nave 01:48:06

De una forma intuitiva 01:48:07

Porque tú cuando arrancas el juego 01:48:09

No puedes cambiar el código 01:48:12

El código, digamos que una vez arranca 01:48:13

No se puede cambiar 01:48:15

Pero nos puede interesar probar cosas 01:48:16

Que sí que se ejecutan durante el juego 01:48:18

Como esto 01:48:21

Pero luego lo tendrías que cambiar en el código, ¿no? 01:48:21

Es que estoy cambiando el código, aunque no lo parezca 01:48:24

O sea, aunque no salga en el CESAR 01:48:26

Es como si estuviera cambiando, ¿no? 01:48:28

Claro, yo con este serialize field 01:48:30

Estoy accediendo a esta variable en todo momento 01:48:32

Y siempre y cuando sea 01:48:34

En un momento de ejecución 01:48:36

que se pueda ver cómo voy cambiando 01:48:37

el valor de muerte, yo en todo momento 01:48:40

tengo abierta esta caja. En vez de cambiarlo 01:48:41

como aquí, lo estoy cambiando, pero por el 01:48:43

editor, en vivo. 01:48:45

¿Vale? Yo lo que vale 01:48:48

muerte, lo estoy cambiando ahora mismo. 01:48:49

En este mismo instante, muerte 01:48:51

no vale ni 800 ni 1000, vale 01:48:53

1657. 01:48:55

Ya lo iréis viendo. Mira, en el siguiente 01:48:57

tema ya, de hecho, tiene aplicaciones, así que 01:48:59

ya lo veréis. ¿Vale? E importante, 01:49:01

si en algún momento queréis ir 01:49:04

viendo cómo va, pues por ejemplo, lo 01:49:05

del más uno que va cada fotograma aquí vais yendo fotograma fotograma aquí da igual porque mira 01:49:07

cómo está parado el juego si yo ahora cambio a 1896 al ir al siguiente fotograma por 1896 vale 01:49:13

que en ocasiones puede que queramos ir viendo qué va pasando cada fotograma en vez de aquí 01:49:21

una sucesión de elementos pues continua vale que se puede detener el juego y se para ahí y 01:49:26

Y podemos seguir fotograma a fotograma ejecutándolo. 01:49:33

Y ya, última cosa. 01:49:36

Bueno, hasta aquí qué tal, más o menos. 01:49:38

Sé que son muchas cosas, pero bueno, 01:49:39

veis que están escritas en el tema también. 01:49:41

Y en los vídeos de Álvaro Holguera también se ven ciertas cosas 01:49:43

que estoy hablando aquí. 01:49:46

Esto es un mejunje de cosas, 01:49:48

pero que poco a poco iréis asimilando. 01:49:50

Al menos los que vayáis siguiendo las clases. 01:49:54

Hay una última cosa muy importante, 01:49:57

que es que cuando vayamos cambiando cosas en vivo 01:49:59

yo puedo decir, yo arranco el juego y se me ponen 1000 siempre 01:50:03

y aquí empiezo a guardar 01:50:06

y vais a ver que yo cuando detengo el juego 01:50:09

me vuelve al otro valor que estaba guardando antes de empezar 01:50:11

por ejemplo, 500, arranco el juego 01:50:14

se va a sobreescribir a 1000, que es lo que hace al arrancar el juego 01:50:17

y me pongo a cambiar esto a 192 01:50:20

y por lo que sea yo quiero que en 192 01:50:23

se deje aquí sobreescrito el valor 01:50:25

Veréis que cuando yo detenga la ejecución del juego, vuelve a 500, que es el que yo había metido a mano. 01:50:29

Esto significa que hay cambios que podemos ir haciendo en el... o más fácil, mirad, si me estoy yendo por las ramas. 01:50:35

Tengo aquí colocada la nave y quiero que se mueva, y lo voy a ir cambiando en tiempo real, en estas coordenadas. 01:50:42

Quiero cambiarlo en estas coordenadas. 01:50:48

Todos estos cambios que yo voy haciendo, imaginaos que yo hay un momento que voy a decir, quiero que la nave se quede aquí. 01:50:50

que la he ajustado, pero como estoy en ejecución 01:50:58

durante la ejecución 01:51:01

los cambios que vayamos haciendo solo funcionan 01:51:02

durante la ejecución, cuando yo pare 01:51:05

vuelve a los valores 01:51:07

que tenía antes de la ejecución 01:51:09

por tanto, cambios que hagamos en vivo 01:51:10

que en el siguiente tema vamos a hacer 01:51:12

cuidado que se hacen 01:51:14

y no se guardan 01:51:16

por eso veréis que cuando yo le doy 01:51:18

al play, se oscurece un poco el área 01:51:21

se oscurece un poco el entorno 01:51:22

indicando que estamos dentro 01:51:25

de la ejecución y un poco advirtiendo que el cambio que hagamos en los parámetros, pues no se guardan, ¿vale? 01:51:27

Último consejo. Para cambiar este color y que sea aún más obvio cuándo podemos o no cambiar los elementos 01:51:33

sin que se guarden, ¿vale? Dentro de Edits hay una pestaña de Preferencias. Creo que siempre confundo estas dos. 01:51:39

En preferencias, edit preferencias, están los colores del sistema. Ya hay uno bastante interesante de modificar, que yo ya lo haría, y esto se guarda siempre que no instaléis otra versión de Unity o vayáis a otro ordenador, etc. 01:51:48

Es decir, entre distintos juegos incluso que uséis la misma versión de Unity se va a mantener, en vez de decirle que sea el tintado de este gris tan sutil que tenemos, lo podemos exagerar a un rojo de warning. Cuando lo tengamos ahí configurado, el Play Mode Tint, el tinte de modo de juego, ahora cuando ejecutemos el juego vais a ver que se tiñe de otro color. Lo podéis poner más o menos llamativo. 01:52:05

ahora, todo cambio que vayamos haciendo 01:52:28

mientras estemos en este modo 01:52:30

sabemos que 01:52:31

cuando detengamos la ejecución del juego 01:52:34

placa, no ha servido para nada 01:52:36

excepto a lo mejor para tener clara 01:52:38

la referencia de donde queremos ubicar algo 01:52:40

en este caso, etc 01:52:42

entonces es importante que a lo mejor 01:52:43

cambies ya 01:52:46

en edit 01:52:47

preferencias, este color 01:52:49