Vídeos UT1 y UT0 - #3 - DEIM - Curso 25·26

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 instancia 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. 00:03:26

Por tanto, esta línea, por ejemplo, 00:03:27

este primer instant shade, 00:03:29

ya tiene lo que necesita para hacer la instancia. 00:03:30

Cuando solo se usa uno de los parámetros, 00:03:34

que además es la primera sobrecarga, 00:03:36

hacemos el instant shade solo dando un objeto 00:03:41

que es el original que se va a clonar, 00:03:45

que es lo que acabamos de hacer aquí. 00:03:47

Cuando yo ahora, no olvidéis de guardar, 00:03:49

siempre que hagáis algún cambio en el código 00:03:52

para que se ejecute, 00:03:53

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? 00:03:54

Se han generado dos naves y las dos, si nos damos cuenta, están, deshago y marco una en el 0, 0, 0. 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:15

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 00:05:30

ese instant sheet, está ahí preparado 00:05:32

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

es decir, voy a comentar 00:05:36

el resto y voy a ver 00:05:39

esta línea, según empieza 00:05:40

es verdad que aquí está 00:05:43

generando como una variable, si os fijáis 00:05:44

que le está poniendo un nombre que se llama instancia 00:05:46

que si no 00:05:48

vemos mal, aquí pone 00:05:50

gameObjectMyPrefab, está generando 00:05:52

una variable de un tipo de variable 00:05:54

que es gameObject, es decir 00:05:57

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, digamos, 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:41

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:54

Si yo ahora guardo y digo, a ver qué ocurre cuando yo ahora lanzo el juego, ¿no? Que solo se va a ejecutar esta línea en el start. Vamos a ver. Me voy a poner aquí a mi lado el for. Vale. Vale. Acabo de lanzar el juego y hay una nave en el 15, bueno, perdón, en el 000. Igual. Vale. 00:06:58

pues eso significa que crea una instancia en la posición, aquí os lo he comentado y está ya indicado, 00:07:22

crea una instancia en la posición del objeto de referencia y como hijo suyo. 00:07:29

Pero es verdad que está ocurriendo algo, si os dais cuenta, que es que aunque aquí he puesto dos parámetros, 00:07:33

my prefab y referencia, referencia si lo pensamos bien, me podéis contestar, ¿a qué se está refiriendo en este momento? 00:07:40

A el inobjet que has ubicado ahí vacío, ¿no? 00:07:54

No, tened en cuenta que yo he generado aquí una variable de tipo transform, y transform, si recordáis, es el primer componente que tiene las coordenadas de posición, rotación y escala de cualquier objeto, de casi cualquiera. 00:07:57

Todos suelen empezar teniendo ese componente, y luego muchos otros dependiendo de cuál sea la función. 00:08:10

Fijaos que yo en referencia, que es otra variable que he generado por medio de un campo serializado, no le he dado ninguna referencia. 00:08:16

Ahora mismo está vacía, es nula, no existe. Por eso la ha generado en el 000 y no es hija de nada, como pongo ahí que es. Si os fijáis, es exactamente el prefab, el 00, porque no tiene esa referencia. Es decir, ahora mismo esta línea está funcionando como esta primera, porque aquí lo que tiene es nada, no existe. 00:08:26

Para aprovechar esta sobrecarga y que tenga sentido meter dos variables aquí dentro, habría que decir cuál es esa referencia. Y ahora mismo pone ninguna y está esperando un objeto, un vínculo en este campo del tipo transform. 00:08:46

¿Eso qué significa lo de transform? Que si yo en este campo, igual que he hecho en este de aquí arriba, arrastro aquí la nave, vais a ver que pone esa nave prefab, es el mismo objeto, pero fijaos en dos cosas, 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:05

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, porque de esta variable solo está recogiendo lo relativo al transform del objeto. 00:09:27

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, aquí solo estamos cogiendo una parte de ese objeto, ese componente transform. 00:09:53

Esto me sirve, nuevamente el otro día, para introducir que las variables pueden ser de tipos casi ilimitados en relación con la cantidad de componentes que hay. 00:10:03

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

o que introduzcamos algo en este campo 00:11:21

de tipo RigidBody 00:11:24

un poco del tipo de la caja que hemos creado 00:11:26

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

veréis que 00:11:29

la nave prefab como no tiene 00:11:32

RigidBody 00:11:34

no lo va a coger porque si que tiene transform 00:11:34

si que se puede arrastrar como todos los 00:11:38

GameObjects un GameObject pero no 00:11:40

tiene un RigidBody por tanto 00:11:42

aunque yo intente, podéis hacer la prueba 00:11:43

arrastrar igual que si me deja 00:11:45

introducirlo en los otros dos campos 00:11:47

aquí no me deja 00:11:50

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í refiriéndonos 00:14:41

a la clase directamente, 00:14:44

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 por más cuestiones. Pero veis que lo importante de esto ahora mismo es que cuando ponemos un punto, vamos abriendo opciones hijas de ese primer elemento que hemos puesto. 00:15:09

Como lo que el otro día os dije de país, comunidad autónoma o estado, si fuera Estados Unidos, ciudad, punto calle, punto número, ¿vale? Si estas propiedades existieran configuradas, pues sería esta la forma, la sintaxis para ir accediendo, digamos, de un elemento a otro. 00:15:23

Pero para poder acceder, por ejemplo, al elemento ciudad, si no lo hemos configurado de otra forma, siempre hay que ir accediendo de un padre, digamos que reconozca o que hemos guardado como variable, como punto de partida y luego podemos ir llegando a los hijos. 00:15:44

¿Esto qué quiere decir? Que si hemos generado, y les 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:00

¿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, usables 00:17:17

a lo largo de todo el proyecto, pero también en momentos 00:17:19

nos puede interesar que esa variable 00:17:21

se cree al empezar el juego 00:17:23

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

qué 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 Instanced, que es que crea una instancia a la posición del objeto de referencia, que es este segundo que tenemos aquí, y como hijo suyo, es decir, de esta referencia. 00:18:02

todo esto yo me lo sé, aparte de porque 00:18:20

ya lo he usado más veces, porque os vuelvo a repetir 00:18:23

que si vamos pasando por las 00:18:25

sobrecargas, que en este 00:18:27

caso 00:18:29

es esta la que estamos usando 00:18:29

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

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

es otra forma de llamarlo 00:18:37

y bueno, si luego 00:18:38

es que no quiero liar más la madeja 00:18:40

necesita un objeto que es el que 00:18:43

va a referenciar y luego 00:18:45

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

clona el objeto existente y retorna el clon. Si quisiéramos saber más, esto ya lo comenté el otro día, 00:18:49

saber más de qué hace cada método, la buena forma de hacerlo es meternos en el API, en el manual de uso, 00:18:55

del código, desde el propio Google se puede hacer. Si ponemos el método o la propiedad que queramos consultar 00:19:05

Y ponemos Unity después, lo primero que va a poner va a ser, digamos, el acceso a cómo se usa este elemento o este método. 00:19:15

Aquí veis que vienen ya varias sobrecargas. 00:19:29

Y si vamos pasando, aquí pone Object Original, que aquí es lo mismo que ponía en el IntelliSense, que hemos visto antes en el código. 00:19:32

Y aquí sí que podemos ir más con detalle, por si tenemos dudas, ir viendo qué significa cada cosa. 00:19:39

Pues oye, es algo de tipo objeto de GameObject, no podemos meterle otra cosa, quiere un GameObject aquí. Y en original es el nombre que le ha dado a esta variable, digamos, a este parámetro que está esperando que hagamos algo con él, ¿vale? Y aquí si bajamos en los parámetros nos dice, vale, lo que yo ponga como original, que es en todas estas, en esta posición de los parámetros, dice un objeto existente del que quieras hacer una copia, ¿vale? Pues ya sabemos que aquí habría que meter ese objeto que queremos copiar, ¿vale? 00:19:44

Cuando pone parent, pues podemos ir a parent. 00:20:13

Padre que será asignado al nuevo objeto, ¿vale? 00:20:15

Pues aquí meteremos un transform, ¿vale? 00:20:19

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, 00:20:26

características de, en este caso, instantiate. 00:20:33

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 00:20:42

iréis entendiendo más todos los ejemplos 00:20:45

fijaos que luego incluso instantiate 00:20:47

bueno, yo lo he hecho así un poco a las bravas 00:20:49

pero incluso fijaos que instantiate 00:20:53

si lo vuelvo a declarar aquí 00:20:55

tiene más tipos, ¿vale? 00:20:56

con estas llavecicas que se abren aquí 00:20:58

y si me pongo encima 00:21:00

pues no da muchas descripciones 00:21:01

y en ese caso para desambiguar 00:21:04

para saber qué significa 00:21:06

pues tendríamos que meternos nuevamente 00:21:07

en el manual o en la API 00:21:09

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:11

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

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í 00:21:58

se puede cambiar a manual 00:21:59

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

del propio programa 00:22:02

os puede contar una descripción 00:22:04

que no está tan basada en el código 00:22:06

sino del uso 00:22:07

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

igual que el software en sí 00:22:12

el Unity no está en español 00:22:14

pero bueno 00:22:15

con poco a poco en inglés 00:22:16

es bastante técnico 00:22:18

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, ¿vale? 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, ¿vale? 00:22:20

Que me importaba ver un poco qué significan estos nombres que aparecen bajo original, position, veis en la sobrecarga, pone object original. 00:22:43

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, ¿vale? 00:22:54

Vuelvo aquí, ¿vale? 00:23:02

Si seguimos viendo esto, nos falta decirle cuál es la referencia de este prefab, ¿vale? 00:23:05

Y la referencia que nosotros queramos. Aquí la tenemos preparada, la variable, para usarla, pero todavía no lo estamos haciendo bien porque aquí os lo he puesto como ejemplo. La voy a quitar, ¿vale? Si dais a este circulito podéis decirle que no queréis ninguna, que es como estaba. 00:23:11

y claro, yo lo que voy a querer en cierto momento 00:23:27

es usar las capacidades 00:23:30

que me está dando 00:23:32

esa sobrecarga de Instantiate 00:23:32

para decirle yo el punto en el que quiero que se instancie 00:23:36

no quiero que se instancie a lo mejor en el 0, 0, 0 00:23:38

¿vale? 00:23:40

sino que yo quiero que se instancie donde 00:23:42

punto, ¿vale? estoy generando 00:23:44

un GameObject vacío, recordad 00:23:46

que igual que se pueden generar estos cubos 00:23:48

y estos elementos con los que habéis 00:23:50

hecho el prefab de la nave 00:23:51

puede generar un vacío, un empty 00:23:53

que es como los nulos en los softwares de 3D 00:23:56

que sirve simplemente para tener una referencia 00:23:58

en el espacio, no contiene nada más allá 00:24:00

de una referencia del espacio 00:24:02

y lo voy a llamar 00:24:04

borro este que he generado dos en el proceso 00:24:06

lo voy a llamar punto referencia 00:24:08

para saber bien que es ese 00:24:10

y ojo que cuando generamos un nuevo 00:24:12

empty object o cualquier elemento 00:24:14

puede no estar ubicado en el 0,0 00:24:16

que de partear no nos gustaría 00:24:19

nos lo pone en el centro del visor 00:24:20

donde estamos mirando, vale, ojo que suelen ir 00:24:22

ya a las posiciones 00:24:25

modificadas, si queremos 00:24:27

colocar algo en origen 00:24:29

en el 0,0, en los 3 00:24:31

puntos de ese componente, si le damos 00:24:33

a reset, se colocará ahí, ¿vale? 00:24:35

vale, esto lo he 00:24:38

hecho un poco para que veáis el punto de partida 00:24:39

pero, ahora lo que puedo hacer 00:24:41

es decir, no, yo quiero que este elemento, la nave 00:24:43

se instancie en el 00:24:45

y lo voy a meter a mano 00:24:47

menos 40 y en i 00:24:48

10, ¿vale? porque es donde 00:24:51

yo quiero que comience 00:24:53

y en Z incluso vamos a ponerle un 15 00:24:53

el punto que sea, da un poco igual 00:24:59

esto lo que nos va a permitir es que luego cuando nosotros digamos 00:25:01

que este GameObject, punto de referencia 00:25:05

y teniendo aquí abierta esta en el inspector 00:25:07

donde tenemos el código y las variables preparadas 00:25:11

arrastramos ese objeto 00:25:13

lo que va a hacer es coger el transform de este punto de referencia 00:25:16

que nosotros hemos ubicado donde queremos que esté 00:25:20

¿Vale? Entonces, ahora mismo ya tenemos preparada una referencia que se coge con esta variable referencia y que nosotros usamos aquí como segundo parámetro, ¿vale? Del instant shade. 00:25:22

si yo ahora ejecuto el juego 00:25:37

va a hacer dos cosas, como bien dice aquí 00:25:39

crea una estancia en la posición del objeto de referencia 00:25:41

en esta ubicación 00:25:44

que acabamos de poner 00:25:46

y como hijo suyo además, tiene una pequeña 00:25:47

sutileza 00:25:50

entonces, yo cuando ahora arranque el juego 00:25:51

vais a ver 00:25:54

que esa nave 00:25:54

primero se ha colocado, si recordáis 00:25:57

en este punto donde está 00:26:00

punto de referencia y además se ha hecho su hijo 00:26:01

¿vale? se llama hola 00:26:04

porque en el código hemos dicho 00:26:05

que la instancia 00:26:07

que el nombre de esa instancia sea 00:26:09

hola, vale 00:26:11

entonces ved que no es lo mismo 00:26:13

tener activo este 00:26:15

esta instanciación 00:26:17

bien referenciado todo 00:26:19

que simplemente generar el instant shade 00:26:21

a secas, vale, esto me sirve para que 00:26:24

poco a poco vayáis viendo que 00:26:25

lo que hay dentro de estos 00:26:27

paréntesis 00:26:29

en un método, vale 00:26:31

pues influye 00:26:33

un método o una función que son lo mismo 00:26:35

ya os comenté el otro día 00:26:38

que son digamos 00:26:40

operaciones de acción de algo que ocurre 00:26:42

en este caso vamos a instanciar 00:26:44

en este caso esto es otro método 00:26:46

que sirve para marcar 00:26:47

que va a ocurrir al empezar el juego 00:26:50

o al iniciarse este script 00:26:51

recordad que era cuando el objeto se iniciaba 00:26:53

y si veis cuando hay un método 00:26:55

tiene pues el nombre 00:26:58

de esa acción que va a hacer 00:27:00

y siempre va a ir a continuación 00:27:01

un paréntesis, ¿vale? A veces vacío, a veces lleno. 00:27:04

Pero cuando vemos una palabra que está escrita en mayúsculas, 00:27:08

la primera letra, y luego tiene paréntesis, 00:27:12

eso significa que estamos usando lo que se llama un método función. 00:27:15

Es decir, una acción que vamos a hacer. 00:27:18

¿Vale? Que no es lo mismo que si yo pongo 00:27:20

transform position igual a referencia. 00:27:22

Que esto básicamente, a ver, reference position, había que aprender. Esto ya os explicaré un poco más qué es, pero al final no es lo mismo decir, oye, instanciate aquí y tal cosa, que en esta línea que no vemos ni un solo paréntesis. 00:27:30

Esto significa que aquí no hay ningún método. Los paréntesis pueden indicar más cosas, pero en lo general son métodos o funciones, ¿vale? Ahora volveremos otra vez a los métodos. 00:27:49

Entonces, ya simplemente por terminar, esta explicación como de las sobrecargas que puede tener Instantiate, tenemos una tercera forma de instanciar, comento todo menos esta última, que yo sé que es, y borro todo lo relacionado con los comentarios, 00:28:00

que es que crea una instancia en el punto de referencia, pero sin rotación, ¿vale? 00:28:25

Vale, aquí si os fijáis tenemos tres elementos, y es igual que el anterior, en el sentido de que el primero de ellos es el prefab, ¿vale? 00:28:32

Y voy a ir a la API un segundo, de Instantiate, que la tenía por aquí abierta, si no me equivoco, aquí está, ¿vale? 00:28:41

Esta es la primera que hemos usado, esta es la segunda y ahora vamos a ir a esta tercera, ¿vale? Esta no la saltamos porque tampoco aporta mucho, pero aquí básicamente nos pide, ¿vale? Un objeto. Ahora, el segundo parámetro, aunque es parecido, es una posición, ¿vale? De tipo vector 3. Esto es verdad que todavía no lo hemos visto. 00:28:49

Y luego la rotación. Esto ahora mismo es un poco enrevesado y por eso no voy a meterme mucho. Volvemos a ello si queréis más adelante. Pero esta sobrecarga, al final, lo que me está pidiendo son otro tipo de valores. 00:29:12

Entonces, si os fijáis, incluso aquí, cuando vemos esta referencia, aquí no me está pidiendo un transform completo, como sí que hacía en la otra sobrecarga. Aquí me pedía el transform completo del objeto que iba a ser el padre. 00:29:26

Aquí me pide solo la posición. Entonces quiero que vayáis también teniendo en la cabeza que ciertos parámetros tienen más parámetros dentro, como hemos dicho antes, que podemos ir abriendo con punto. 00:29:44

Porque pensad una cosa, si me está pidiendo la posición de un elemento y yo tengo un transform en referencia, yo al final lo que estoy haciendo es, en este transform, estoy cogiendo todo lo que hay en este componente. 00:29:58

La posición, la rotación y la escala, que al final son tres valores de la posición, tres valores de la rotación y tres valores de la escala, ¿verdad? Entonces, cuando me piden solo la posición, vais a ver que al final lo que estoy haciendo aquí es decirle, vale, de este transform que yo he llamado reference, solo voy a coger la posición, porque si intento meter todo, esto me da fallo, porque dice, vale, no sé de todo lo que tiene dentro en la posición o en la rotación, 00:30:12

pues yo qué sé, si yo pongo aquí rotation, veis que puedo meter la rotación, ¿vale? 00:30:42

Me da fallo también por otras sutilezas, porque habría que ponerlo en ángulo Seuler, 00:30:50

básicamente, que es una cosa que ya veremos en este tema, ¿vale? 00:30:56

Pero veis que a medida que yo le voy dando la instrucción correcta, 00:30:59

esto me puede dar que algo se puede ejecutar o no, ¿vale? 00:31:03

Sutilezas, que a veces hay que ir pensando, ¿qué valores estoy guardando en este transform? 00:31:07

Bueno, pues estoy guardando los de posición, los de rotación, los de escala y aquí solo me pide posición, ¿vale? Y luego aquí, bueno, me pide la rotación, que esto sí que es verdad que es más avanzado, entonces no me voy a meter mucho, pero aquí básicamente con esta instrucción estoy diciéndole, cógeme la rotación que tenga por defecto el objeto, ¿vale? 00:31:11

Entonces yo cuando use 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:31:31

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:31:50

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:32:08

vale, vamos al tema 00:32:27

cero, voy a guardar 00:32:31

vale, recordad esta esterilla 00:32:34

esta pequeña 00:32:35

estrella y voy a ello 00:32:38

vale, tengo 00:32:39

aquí otro script que simplemente 00:32:42

va a servir para 00:32:44

para 00:32:44

practicar ahora, no va a tener 00:32:46

como hemos hecho ahora en InstanceAid que se ve 00:32:49

un resultado claro en el visor 00:32:51

pero me sirve para que vayamos entendiendo mejor 00:32:53

qué tipos de variables existen 00:32:55

y usos y aplicaciones que se pueden hacer. 00:32:57

De momento quizá un poco abstractas en el sentido de, pues solo estamos viendo sumas y restas, 00:32:59

pero luego es que esas sumas y restas, como dije el otro día, 00:33:04

puede ser como sube y baja el número de puntos que tiene un contador, ¿vale? 00:33:07

Y se va a basar un poco en lo mismo. 00:33:12

Entonces, recordad, a ver, que creo que alguien se ha metido, perdonad, 00:33:14

o se ha salido, no lo sé, vale. 00:33:19

recordad cómo se generaba un script 00:33:22

que es, lo voy a hacer en esta 00:33:25

carpeta de script que tengo aquí preparada 00:33:27

durante la tutoría, pues yo hago 00:33:29

este script 00:33:31

recordad que en este cesar script 00:33:32

podemos generar un script que vamos 00:33:35

a llamar 00:33:37

durante, recordad 00:33:38

que el nombre que vayamos 00:33:41

asignando aquí, luego debe ser el mismo 00:33:43

de la clase de dentro del script, esto ya lo he 00:33:45

dicho como en dos tutorías previas, por tanto 00:33:47

entiendo que no habrá 00:33:49

problema y además en el tema cero va poniendo buenas prácticas de cómo 00:33:51

escribir las los nombres de los scripts los nombres de las 00:33:56

de los métodos de las variables vale y habla de una cosa que es el pascal case 00:34:03

y el camel case vale cuando generamos una clase o lo que es lo mismo generamos 00:34:08

dentro de Unity un script 00:34:15

siempre, lo digo porque luego nos va a ayudar a que todo sea más fácil 00:34:18

de ir siguiendo, siempre deberíamos empezar a escribir el nombre del script 00:34:23

con mayúscula. Y a diferencia de 00:34:27

nuestro lenguaje del día a día, los espacios no existen 00:34:31

o no se usan correctamente cuando estamos escribiendo órdenes. 00:34:35

Si os fijáis, todo lo que os he ido enseñando antes no había espacios 00:34:39

había muy pocos 00:34:42

hasta que no termine de escribir esto no quiero 00:34:43

volver a enseñaros en script 00:34:46

pero vais a ver que normalmente 00:34:48

se escriben las palabras juntas 00:34:50

¿y cómo se distingue que una palabra 00:34:52

pues hay un espacio 00:34:54

entre ellos? en vez de dar el típico espacio 00:34:59

que hacemos con la barra espaciadora 00:35:01

lo que hacemos es empezar la siguiente palabra 00:35:02

con mayúscula durante 00:35:04

la tutoría 00:35:06

importante, lo que son tildes 00:35:08

y eñes 00:35:10

no las uséis nunca en nada relacionado con 00:35:12

programación, me explico 00:35:15

incluso aunque esto sea el nombre de un script 00:35:17

recordad que, vale, guardo 00:35:19

y se genera, que cuando yo genero 00:35:21

este script al final estoy realizando 00:35:23

un código cuyo nombre 00:35:25

de clase también está dentro 00:35:27

del código, si yo empiezo a poner tildes 00:35:29

esto va a empezar a dar ciertos 00:35:31

problemas, vale, y aunque ahora 00:35:33

parezca a lo mejor que no lo da 00:35:35

tarde o temprano lo va a dar, igual 00:35:36

sucede si ponemos una ñ 00:35:39

O si ponemos un signo que no esté reconocido, que pueda haber algunos. Entonces, atención. Fijaos que siempre he escrito con la primera letra mayúscula en lo que se llama Pascal Case. Pascal fue un, si no recuerdo mal, un matemático. Y como es un nombre propio, por eso se llama así, con mayúscula. Pascal Case. 00:35:40

Que no es lo mismo si nos fijamos a lo que hemos estado... Bueno, y fijaos también que los métodos, los de los paréntesis, también van con mayúsculas. Es decir, instantiate existe con mayúsculas, ¿vale? Pero si yo me pongo a buscarlos con minúscula, no existe. 00:36:02

Es decir, sí que intenta ayudarme diciéndome que esto está en mayúsculas, pero vais a ver que yo cuando lo ponga, me lo ponen en mayúsculas. Los métodos, esas palabras que sirven para indicar que se ejecute una acción, que van con estos paréntesis, siempre empiezan a escribirse con mayúsculas. 00:36:16

Y lo mismo, si Instanciate tuviera otra palabra, sería InstanciateDouble, yo que sé. 00:36:32

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

Si es solo una orden llamada InstanciateDouble, no hay espacio en el medio. 00:36:47

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

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:36:59

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:37:23

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. 00:37:47

Y las variables, por convención, se escriben del mismo modo, pero empezando en minúscula. Igual que instant set va con mayúscula, fijaos que my prefab, cuando lo hemos declarado aquí al principio, va con minúscula. 00:37:58

igual cuando queramos 00:38:12

separar 00:38:14

veis que el my bien, porque es el nombre 00:38:17

que le hemos dado a GameObject, pero este prefab aquí 00:38:19

no pinta nada, para que lo interprete 00:38:21

como el nombre de la caja, aunque sean dos palabras 00:38:23

distintas, empieza con minúscula 00:38:24

y para separar las palabras 00:38:26

hay que poner una mayúscula aquí 00:38:28

y os lo dije el otro día, y si no os habéis dado cuenta 00:38:30

fijaos, si está preparado esto 00:38:32

que aunque no dejemos esos espacios 00:38:34

el propio 00:38:37

el propio Unity 00:38:37

ya va viendo donde meter los espacios 00:38:41

aquí nos ha metido un espacio en donde 00:38:43

en el nombre del script no lo había, recordad 00:38:45

o incluso en 00:38:47

el my prefab, que es el 00:38:49

nombre de la variable que hemos puesto, la m 00:38:51

si la ha puesto en mayúsculas y ha puesto 00:38:53

este espacio, fijaos 00:38:55

que el propio software 00:38:56

sabe interpretarlo, entonces nosotros 00:38:58

nos tenemos que hacer a la forma en la que tenemos 00:39:00

que escribir el código, importante 00:39:03

es decir, recapitulando, las clases 00:39:04

barra, porque es lo mismo, scripts 00:39:07

Entonces, siempre comenzando con mayúsculas, los métodos, a medida que vayamos sabiendo cómo llamarlos o cómo crearlos, también en mayúsculas, ¿vale? Y lo que son las variables en minúsculas, ¿vale? La diferencia de esto es que esto es PascalCase porque empieza en mayúscula y esto es lo que se llama CamelCase. 00:39:09

Lo de camel porque aparece como la joroba de un camello. Esto también viene en los apuntes. Si os sirve para acordaros, pues camel case es cuando empieza en minúscula. Pascal case cuando es un nombre propio. Vamos un poco con durante la tutoría que son operaciones más básicas para ir viendo el tema cero. 00:39:30

Vale, sobre las variables el otro día estuvimos ya hablando bastante, y de hecho aquí volvemos a hablar, de hecho lo de camel case está aquí puesto, que hay que darle un nombre a la variable, que cada uno puede tener un tipo de valor, que es lo que el otro día estuvimos hablando, que eran los ints, los floats, los strings, las cadenas. 00:39:51

¿Recordáis esto, verdad? Esto ya lo hemos visto 00:40:09

Entonces más o menos 00:40:11

Hasta aquí lo tenemos 00:40:13

Hemos visto incluso ya tipos de variables 00:40:14

De tipo clase, ¿no? Como este GameObject 00:40:17

O este Transform en el que guardábamos 00:40:19

La referencia que cogíamos por el inspector 00:40:21

En el SerializeField 00:40:23

¿Sí? 00:40:24

Por ejemplo 00:40:27

Imaginaos que yo en el código 00:40:28

¿Vale? Aquí justo dentro de la clase 00:40:30

Recordad que las llaves delimitan 00:40:33

¿Qué hay dentro de cada 00:40:35

uno de los apartados del código vale y las clases vale cuando empezamos una 00:40:37

clase vamos generando estas variables como he dicho antes que luego podrán ser 00:40:45

usadas dentro de todo este bloque vale cuando vamos trabajando en un lenguaje 00:40:50

como cesar vale al final existe un proceso bueno una lógica que es el 00:40:56

encapsulamiento vale el encapsulamiento significa que dentro de estas llaves 00:41:03

de cada uno de los bloques, de esta o de esta, que es otro bloque, o de este, que es otro bloque, 00:41:07

podemos ir usando variables que queremos, nos puede interesar, que solo existan dentro de este bloque 00:41:13

o que existan en este bloque y por defecto también existen los de dentro. 00:41:18

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

Esto también lo iremos viendo. 00:41:28

Pero este concepto de encapsulamiento, si a alguien le interesa, existe. 00:41:30

y ya me sirve para explicar eso, que cuando 00:41:33

tenemos una clase que es donde vamos generando 00:41:36

todas las instrucciones que hay dentro de este script 00:41:38

pues ya vamos a lo mejor haciendo variables 00:41:40

y esto es el script de 00:41:42

el movimiento del jugador 00:41:44

imaginaos que fuera esta la función de este 00:41:46

script, que luego meteremos como 00:41:48

componente al GameObject del jugador 00:41:50

pues ese jugador a lo mejor 00:41:53

vamos a querer que tenga una vida inicial 00:41:56

¿no? y quiero que 00:41:58

esa vida inicial sea de 100 puntos 00:42:00

imaginaos vale esto veis que yo por defecto si pongo un 100 no sirve para nada me da falla 100 00:42:02

que no sabe que es incluso cuando empieza el juego yo puedo decir aquí 100 y punto y coma vale pero 00:42:10

me va a decir 100 que no tenéis que ir entendiendo que es que los números y los datos no existen en 00:42:18

el código no no son operativos hasta que no se encierran en una variable que es lo que ya vimos 00:42:26

el otro día, si queremos 00:42:31

generar una variable de la vida del 00:42:33

personaje que guarde un valor 100 00:42:35

¿qué habría que generar? 00:42:37

¿o cómo sería? 00:42:40

que esto el otro día un poco vimos 00:42:42

una variable, ¿no? 00:42:43

vale, ¿y cómo? dime un poco 00:42:48

¿cómo la genero? 00:42:50

pues pones int 00:42:52

vale, int, ahora la vemos 00:42:53

espacio, vida 00:42:56

o vidas 00:42:58

igual a 100 00:43:00

vale, mira, que me digas 00:43:00

esto así, significa que ya has aprendido como se 00:43:04

declara una variable muy bien 00:43:06

aprendido, así que vamos a ello 00:43:07

¿por qué ha sido int y no float? 00:43:09

o string o otra cosa 00:43:12

porque es un número entero, ¿vale? 00:43:13

entonces, también 00:43:15

esto habría que ver el juego, pero la vida 00:43:17

normalmente si tiene un valor como 00:43:19

100 que es el máximo, acabo de decir 00:43:21

y vamos a decir ya por defecto 00:43:23

que la muerte es que llega al cero, ¿vale? 00:43:26

pues normalmente 00:43:29

en un contador de eso no va a ir tan fino como ir a decimales 00:43:29

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:43:32

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

¿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:43:52

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:43:59

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:44:10

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:44:24

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:44:46

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

porque os he dicho también antes cuando hemos visto 00:45:10

lo de la instancia que guardamos 00:45:13

como variable, que se puede generar 00:45:15

incluso una instancia dentro de 00:45:17

un start, de un método 00:45:18

de un momento de acción, yo puedo decir 00:45:20

vale, esta variable vida se genera 00:45:23

aquí con un valor de 100 00:45:25

y luego decir vale 00:45:26

y en el update que vida 00:45:29

pase a llamarse, pase a valer 00:45:30

500, porque 00:45:33

cuando el primer frame queremos que sea 100 00:45:34

pero ya los siguientes 500, veis que 00:45:37

aquí vida da un fallo vale y esto es simple ya alguien me sabría decir el porqué a ver si eso 00:45:39

más o menos vamos se explica en el tema 0 pero oye vale os he dicho antes que existía este 00:45:46

encapsulamiento que servía para ir digamos generando bloques fijaos que cuando yo genero 00:45:52

la caja barra la variable le pongo el tipo de variable que es y yo he generado esta caja aquí 00:45:59

en el start. Y esto es un bloque, ¿vale? A diferencia de cuando lo generamos en la clase, que veis que comprende todo, aquí solo comprende esto. 00:46:04

Por tanto, cuando llamamos a esta variable en otro punto que no es de su bloque, pues no existe, ¿vale? Aquí podríamos incluso generar otra variable 00:46:12

llamada vida, que es una vida diferente a esta. Son dos variables distintas, ¿vale? Esto no es lo mismo que lo que habíamos hecho antes de decir, 00:46:22

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. Es decir, este 100 se está guardando en todo este tránsito. 00:46:30

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. 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í. 00:46:48

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:47:07

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:47:21

Si yo ahora ejecuto esta instrucción, lo primero es que probablemente desfalle o pase algo raro. Yo voy a la consola y no veo ni 100, ni 0, ni nada. ¿Por qué? A ver quién me lo sabe responder. Esto si habéis hecho la tarea 1 deberíais saberlo. 00:47:30

No has asignado el código, ¿no? 00:47:52

Efectivamente. 00:47:55

No hay ningún objeto dentro del juego, 00:47:56

ni le hemos dicho de otra forma que se ejecute, 00:47:59

no hay ningún objeto en el juego que tenga este script. 00:48:02

Por tanto, el script no se está ejecutando. 00:48:03

Es decir, no hay ningún momento start de nada 00:48:06

en donde se ejecute esto, ¿no? 00:48:08

Entonces, pues en punto referencia, 00:48:10

me da igual porque solo van a ser números, ¿vale? 00:48:14

Voy a asignar este durante la tutoría como componente, ¿vale? 00:48:16

A ver, he guardado, recordad que hay que guardar el script, ahí está, y ahora lanzo el juego. A ver, y ahora sí que cada fotograma está generando un 100. Aquí se van sumando hasta que llegue a 1000, que ya no sea más, pero aquí se van 100, 100, 100, 100. 00:48:21

¿Vale? Entendéis que al final lo que estamos consiguiendo es cambiar las variables en distintos puntos del código. Esto es importante entenderlo porque es lo que os he dicho antes. Si yo genero aquí la caja y aquí no existiera y guardo la caja aquí, al final vida no existe para el update porque está fuera del ámbito donde se ha generado esta caja. 00:48:36

Esto también es por algo que se llama los ámbitos 00:48:56

Que voy algunos pasos más adelante 00:49:00

Dentro del tema cero, aquí se habla de los ámbitos de las variables 00:49:04

Y habla un poquito de estos bloques y de estos ámbitos 00:49:08

Y un poco también de lo que os estoy comentando aquí 00:49:13

Igual este código es un poco más avanzado 00:49:16

Por eso lo estoy simplificando 00:49:19

Pero básicamente de lo que habla es que están las variables globales 00:49:20

que se declaran al comienzo y están disponibles en todo el script, 00:49:25

incluso dentro de las funciones, como sería el start y el update y aquí saludar. 00:49:27

Y luego las locales, que se declaran dentro de una función. 00:49:32

Y por eso solo están disponibles dentro de ella. 00:49:36

Por tanto, cuando más adelante hablemos, aquí he declarado una variable local, 00:49:39

porque está en un bloque muy concreto, una función, 00:49:45

y aquí las que se generan dentro de la clase son las variables que se llaman global. 00:49:49

¿Vale? 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, ¿no? 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, ¿no? Que es lo que hemos hecho con el prefab que hemos arrastrado, ¿vale? 00:49:55

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:50:22

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:50:40

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:51:06

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:51:25

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:51:44

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

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:52:04

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:52:18

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:52:30

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

como voy escribiendo las variables 00:52:56

es algo muy importante 00:52:57

y le asigno y le pongo un 00:52:59

5.8f 00:53:01

porque es un float 00:53:03

¿vale? vais a ver que yo cuando 00:53:05

bueno, ¿por qué da fallo? 00:53:08

porque he intentado guardar una variable float 00:53:10

en un int ¿vale? entonces 00:53:12

es importante los tipos 00:53:13

de variables como los vamos gestionando 00:53:16

cuando ahora vaya 00:53:17

al 00:53:19

al script tengo las dos variables 00:53:21

Veis que aquí en apariencia hacen lo mismo, pero si aterrizamos aquí, vemos que una es pública y eso será accesible desde otras clases. 00:53:23

De hecho, veis que la clase ya por defecto no 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:53:34

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. De hecho, lo voy a hacer muy rápido, aunque no entendamos tampoco. 00:53:44

Tengo el script durante la tutoría y el script Instanced Prefab que he preparado antes. 00:54:06

Imaginaos que yo quiero cambiar desde Instanced Prefab la variable con decimales. 00:54:11

Lo primero que habrá que hacer, igual que hemos hecho aquí, es decir, durante la tutoría, 00:54:18

y veis que ahora voy a generar una variable que se llama igual que otro script. 00:54:23

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

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

Es una caja que podemos crear, ¿no? 00:54:44

Entonces, por eso existe aquí una caja, y no da ningún fallo, que se llama durante la tutoría. 00:54:47

Y aquí lo puedo llamar como otro, en minúscula, porque es una variable, ¿vale? 00:54:51

Otro script. 00:54:57

Y aquí está preparado. 00:54:59

Y yo en el transform puedo decirle, oye, quiero que otro script acceder a sus propiedades. 00:54:59

Y vais a ver que yo, a medida que me vaya metiendo en sus propiedades con el punto, 00:55:06

como estoy apelando aquí, hay una variable suya de durante la tutoría que se llama variable con decimales. 00:55:11

Pues vais a ver que, cuando yo doy ya el punto, aquí existe una variable llamada variable con decimales. 00:55:17

Y yo puedo decir, oye, pues esto quiero que valga 10. 00:55:24

Y aquí está cambiando el valor. Si yo guardo esto, desde otro código estoy cambiando el valor de este 5,5. Y de hecho vais a ver cuando empiece el juego que variable con decimales, que por defecto debería ser 5,5, ahora como lo he cambiado, pues está cambiado. 00:55:28

Ahora os explico otra cosa. Como lo he cambiado en el componente, pues se ha quedado con otro comportamiento. 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:55:49

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:56:16

entonces, vuelvo a ejecutar 00:56:42

me está enseñando 5.5 00:56:45

pero bueno, esto que está haciendo 00:56:49

a ver un segundito 00:56:50

5.5, bla bla bla, me enseña esto 00:56:51

bien 00:56:55

pues 00:56:56

vale 00:57:01

un segundo, solo por probar si es esto 00:57:10

hasta luego Jesús 00:57:21

a ver, vale 00:57:22

hay otro problema 00:57:26

¿vale? que es por lo que se usa 00:57:28

el serialize fill en ocasiones 00:57:30

Que es que cuando tenemos aquí un script que vamos cambiando el valor, lo que vamos escribiendo aquí se sobreimpone a todo lo que vayamos cambiando. 00:57:31

Entonces, si aquí dejamos un valor ya puesto, que es diferente al que venía por defecto, se sobreescribe ese. 00:57:41

De hecho, veis que yo aquí pongo 33,2 y el que sale es 33,2. 00:57:49

En ese caso, habrá que ir operando de distinto modo, porque como está haciendo público, lo está variando aquí. Pero bueno, no debería... Perdona, porque esto en realidad lo estoy haciendo, pero porque veáis una cosa que no es ni siquiera esto. 00:57:53

a ver, espera un segundo, que ya es por saber 00:58:16

que estoy haciendo yo 00:58:19

y va a poner 33.2 00:58:20

porque es el que está sobre escribiendo 00:58:22

vale, este es el 00:58:25

típico problema que pasa cuando tenemos 00:58:27

un public 00:58:29

y al final lo que estamos haciendo 00:58:29

es cambiar el valor, igual que hemos hecho 00:58:33

con los valores 00:58:34

de estos puntos 00:58:36

lo estamos cambiando en el 00:58:38

editor, que es que básicamente 00:58:41

en el editor estamos marcando que tiene que hacer 00:58:42

Unity y está sobreponiéndose a lo que hace el código. Lo que me importa de todo esto es simplemente que veáis, ¿vale? 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, ¿cómo se llamaba? Igual que he podido acceder a variable con decimales, a variable serializada, otro script, ¿vale? No va a aparecer. 00:58:45

Es decir, no va a aparecer variable serializada e incluso aunque yo me ponga a intentar escribir que valga 20, yo que sé, me da fallo. ¿Por qué? Simplemente... Ah, y bueno, ya sé por qué no se está ejecutando, no estaba guardando creo. Vale, lo escribo bien. 00:59:12

durante la tutoría 00:59:29

yo aunque tengo esta variable aquí serializada 00:59:32

¿vale? no me la coge 00:59:35

¿por qué? porque es privada 00:59:36

hasta que yo no la haga pública 00:59:38

yo no voy a poder acceder 00:59:39

veis que ahora ya ha dejado de tener error 00:59:43

esto simplemente me sirve 00:59:44

lo mismo, todavía no sabemos aplicarlo 00:59:46

me sirve para que veáis que las variables 00:59:48

en ocasiones no se podrá acceder a ellas 00:59:50

o no se podrá ver en el editor 00:59:52

porque 00:59:55

no tienen el ámbito 00:59:55

el acceso al ámbito correcto, ¿vale? 00:59:58

Me estoy enrevesando mucho quizá con ciertas cosas 01:00:03

y vamos a volver a donde nos hemos quedado, 01:00:07

pero lo que me importa es que ya sabemos que cada bloque, 01:00:09

¿veis? 01:00:12

Irá dando fallo o no según el ámbito que tenga, 01:00:13

en dónde se declara esta caja, 01:00:17

que no es lo mismo declararla aquí al comienzo de la clase 01:00:19

que dentro del start, por ejemplo, ¿vale? 01:00:21

Luego, tenemos aquí un int 01:00:24

y hago aquí un float que es vida y power up, yo que sé, 01:00:26

que es como los puntos que va a dar a la vida el power up cuando lo recojamos. 01:00:37

Le voy a poner que 50, recupera media vida. 01:00:40

Lo suyo sería que si hubiera más de 100, pues el power up no te permitirá tener más de 100, 01:00:43

pero vamos a obviar eso de momento. 01:00:47

Lo que podemos hacer, el otro día dijimos, es que podemos hacer operaciones de vida más power up 01:00:49

y que esto signifique algo, pero lo mismo, hasta que no lo metemos dentro de un contexto, de una caja, 01:00:56

no va a dar ningún resultado. Voy a poner vida actual, que va a ser igual a la vida más power up. 01:01:03

Y esto da un problema ahora mismo. He generado dentro de start, porque digamos que solo lo voy a ejecutar en el start, 01:01:12

una variable llamada vida actual que me da error. ¿Y por qué pensáis que puede ser? 01:01:20

A ver si... Así rápido. Igual no caéis. 01:01:26

¿Pero por qué podría ser? ¿Qué error? 01:01:28

Porque realmente está bien configurado. 01:01:30

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

y estamos guardando dentro de otra caja tipo int estos dos valores, 01:01:33

que el otro día ya vimos que se podía operar de este modo. 01:01:39

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

A ver si lo podéis... 01:01:44

Simplemente también para que lo veáis. 01:01:48

Los tipos de cajas, cuando sumamos 100 más 50 da 150 y es un entero, ¿no? 01:01:49

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:01:57

¿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:02:12

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:02:32

Pero veis que el int no lo permite. 01:02:43

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:02:46

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:02:56

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:03:09

Simplemente lo que me sirve es que veáis 01:03:18

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

¿De dónde me viene esto? 01:03:22

Y es simplemente por el tipo de caja 01:03:23

Porque es más restrictiva del otro 01:03:25

Facilidad para saber identificar eso 01:03:27

Si os ponéis encima de un fallo y lo dejáis quieto 01:03:30

Os va a poner en la segunda línea 01:03:32

En este caso 01:03:35

No se puede convertir implícitamente el tipo float en int 01:03:35

Ya existe conversión explícita 01:03:38

Compruebe si le falta una conversión 01:03:41

Básicamente aquí lo que está diciendo es 01:03:42

Que no se puede convertir si no lo hacemos de manera explícita 01:03:43

a nosotros, como he hecho antes con una orden que se puede ejecutar, no se puede convertir 01:03:46

un float en int porque es que no cabe en esa caja, ¿vale? Importante. Importante también 01:03:51

eso, que el tipo de variable puede determinar qué puede haber dentro. Luego, el otro día 01:03:57

vimos también que había otro tipo, entiendo que entre, con todos estos problemas que pueden 01:04:02

ir surgiendo, lo que es un int y es un float, ¿no? Y cómo se escribe un float para que 01:04:08

no de error hasta aquí entiendo que bien y bueno así de fácil si yo ahora quisiera ver este valor 01:04:11

en la consola como que lo está recibiendo lo está ejecutando si veo vida actual y guardo 01:04:21

pues ahora al empezar el juego vamos a ver qué valor 150 con 5 perfecto a ver que algo hay por 01:04:30

aquí que a ver lo mismo puede ser varias cosas algo de lo que toca por ahí con decimales 01:04:45

con decimales eso es que bueno os acordáis que yo había puesto varias esto es básicamente fijaos la 01:04:55

que salía aquí vale nuevamente por lo de los hacerlo público no y operar mal yo borra las 01:05:04

variables que eran públicas para acceder desde aquí no y ahora vale dice 01:05:10

durante la tutoría otro script pero ahora ya no existen estas variables el 01:05:14

error aunque ha sido que hemos borrado aquí cosas está afectando a estas 01:05:17

variables que ahora no sabe dónde existen vale como no las queremos lo voy 01:05:21

a borrar pero ver que cuando comunicamos scripts entre sí al igualdo pueden 01:05:25

venir los errores porque estamos hablando entre unos y otros y esto sirve 01:05:29

también para hablar del ámbito que estamos hablando de que salga del bloque 01:05:33

Porque cuando empezamos a hacer códigos muy grandes, si empezamos a hacer todo público, que se puede hacer de un lado a otro, que suele parecer muy conveniente, muy cómodo al principio, como estamos comunicando distintos scripts, surgen este tipo de problemas, que es que, vale, estamos cambiando aquí un script, pero también estamos afectando a otros scripts. 01:05:37

Entonces, si no tenemos un control claro de qué está afectando a qué, o no lo restringimos con cosas privadas o lo redirigimos de otras formas, que ya iremos viendo también, pues al final lo que sucede es que empiezan a surgir estos fallos y ahora es bastante pequeño el código, pero nos puede volver un poco la cabeza del revés. 01:05:55

Bueno, y va a dar 15,5 si no me equivoco, ¿no? 150,5, perdón, pues ahí está, 150,5 con su decimal, ¿vale? 01:06:12

Imaginaos que yo quiero hacer una variable que se va a llamar nombre, ¿vale? Y esto es de repaso del otro día, voy a pasar rápida. 01:06:22

Y yo quiero que ponga mi nombre, que ponga Daniel, ¿vale? He creado aquí una variable y como genero una variable que ponga Daniel, ¿qué tendría que poner? 01:06:29

¿De qué tipo tiene que ser? Una variable de texto. Esto lo vimos el otro día. 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? 01:06:38

Que además pone, podemos usar, su valor se introduce delimitado por comillas, ¿vale? Vale, sí, bueno, esto es otra cosa. Va delimitado por comillas, ¿no? Si os acordáis, existe otro tipo de variable que se llama string, en donde puedo llamarlo nombre, ¿vale? 01:06:57

dado que así es como se va a llamar 01:07:17

aquí abajo cuando la mentemos 01:07:19

y esto va a significar que se llama 01:07:21

que yo quiero que aquí se guarde 01:07:23

el valor Daniel, entre comillas 01:07:25

¿vale? ahora yo cuando lance 01:07:27

el juego, esto lo vimos el otro día, no sé 01:07:29

si tenemos dudas de esto 01:07:31

es muy importante que 01:07:32

entendamos bien cómo funcionan las variables 01:07:35

aquí tenemos a Daniel 01:07:37

¿vale? que esto nuevamente 01:07:38

yo puedo declarar aquí 01:07:41

la variable y aquí 01:07:43

como está dentro del ámbito 01:07:45

en donde se ha declarado la variable 01:07:47

pues aquí es donde puedo decirle, aquí quiero 01:07:49

que se llame Daniel 01:07:51

y ahora pues el resultado será 01:07:52

el mismo, se verá Daniel 01:07:55

¿vale? 01:07:56

si queremos por ejemplo 01:07:59

que en cierto momento del juego, cuando 01:08:01

vayamos metiendo datos en un menú 01:08:03

pues por ejemplo podamos meter 01:08:05

nuestra edad, la edad importante 01:08:07

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

¿no? pues no ponemos decimales 01:08:11

25, este es el mismo ejemplo del otro día, lo doy 01:08:12

rápido recordad que como hemos visto antes dependiendo del tipo de variable 01:08:15

pues aquí se va a lanzar de una forma u otra eso que significa que si yo pongo 01:08:20

el nombre más recordad que esto es la concatenación de textos esto también 01:08:26

viene aquí explicado cuando vamos hilando strings con 01:08:32

números vale lo que va haciendo es concatenar ese texto es decir que no es 01:08:37

una soma como tal igual que el igual no es igual y sirve para asignar una 01:08:42

variable vale cuando hacemos nombre más edad vale que aquí no da ningún fallo al 01:08:45

final lo que está haciendo es poner un string daniel y luego un número vale 01:08:53

pero un número que en realidad no es un texto lo que pasa es que hay que 01:08:58

entender que cuando en una concatenación de elementos con este más cuando unimos 01:09:01

varios elementos unos de tipo texto el resto también se convierte en uno de 01:09:06

tipo texto, ¿vale? Pasan a ser 01:09:10

todo de tipo texto, igual que hemos hecho antes 01:09:12

con lo de convertir 01:09:14

el float en in, ¿vale? Daniel 25 01:09:16

no pone ningún espacio porque si 01:09:18

recordáis, también aquí dentro 01:09:20

podemos empezar con las comillas y las 01:09:21

comillas sirven siempre 01:09:24

para ir escribiendo nosotros 01:09:25

textos literales, no son cantidades que 01:09:28

se suman ni que se van a operar, son textos 01:09:30

literales, ahí pone la edad 01:09:32

de espacio, ¿vale? Porque 01:09:33

los espacios también son literales, concatenamos 01:09:36

Daniel, ¿no? 01:09:38

Y ahora concatenamos, es de 25, en este caso, años. 01:09:40

Esto cuando hagamos una UI para ir metiendo nuestro nombre al jugar, etc., es vital que vayamos conociendo cómo se declaran. 01:09:51

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, 01:10:02

incluso se puede ir cambiando durante el juego, o guardará el valor que introduzcamos nosotros en un menú, 01:10:07

en plan, ponerá nombre y ponemos Jesús, pues se guarda Jesús en esta caja y aquí sabe perfectamente 01:10:13

que lo que esté guardado en esta caja, que en ese caso será Jesús, y la edad pues la metemos también 01:10:20

y podrá ser 35, pues en ese momento cambiará para mostrar otro mensaje en otro punto del juego. 01:10:25

y la edad de Daniel es de 35 años. 01:10:31

Fijaos que aquí falta un espacio, básicamente porque 01:10:37

deberíamos decir que literalmente aquí haya un espacio 01:10:40

para que lo respete. 01:10:45

De hecho, es el mismo ejemplo de la semana pasada. 01:10:46

Hasta aquí más o menos vais pillando cómo funcionan los strings. 01:10:50

Quedarse con que se escriben con estas comillas 01:10:53

y es importante que lo interpreta como una cadena de textos literal. 01:10:56

Luego, por otro lado, existe un nuevo tipo de caja que el otro día no hablamos, que son las booleanas. 01:11:02

Y una booleana solo puede guardar dos valores, verdadero y falso. 01:11:09

Una booleana, cuando generamos una variable, será de tipo bool en este caso, para decir que es una booleana. 01:11:14

Y aquí voy a poner semáforo encendido, ¿vale? Y voy a decir por defecto que sea true o false, ¿vale? Tiene dos variables, es decir, que estas booleanas, las booleanas, se escribe así, pueden ser true o false, ¿vale? 01:11:20

Igualmente que siempre, cuando sabemos que algo es booleano, si yo pongo un 5, no es la caja que corresponde y da fallo. 01:11:42

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. 01:11:48

O lo que suele significar true, que está encendido, ¿vale? Que es verdadero esto que ocurre o es falso, ¿vale? 01:11:58

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

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:12:12

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

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:12:27

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

¿vale? si yo empiezo 01:12:50

el juego con la vida llena 01:12:52

pues aquí estará true 01:12:53

y entonces mientras esto sea true, pues el power up 01:12:55

no se va a poder coger, porque no nos 01:12:58

interesa, ¿vale? ahora ya iremos 01:13:00

viendo con las, y esto está aquí 01:13:02

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

de control, con los ifs principalmente 01:13:06

pero hay más, ¿vale? iremos 01:13:08

diciendo, dando condiciones para que una cosa 01:13:10

se ocurra 01:13:12

o no ocurra, ¿no? entonces 01:13:14

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

a este y baje a 25, cuando pongamos una condición, va a decir, vale, pues como baja de 25 y está 01:13:18

comprobando que ya no es 100, esto va a decir, pues ya no es, es falso, no está con el indicador 01:13:24

al máximo de vida. Y entonces en ese caso sí que le permitirá que cuando cojamos un 01:13:29

power up de suma de la vida para que pase de 25 hasta 75,5, ¿vale? Son como, ahí pone 01:13:33

pues eso, conmutadores, interruptores, semáforos, ¿vale? Pues un semáforo puede estar encendido 01:13:40

o apagado. Entonces las booleanas van a ser sobre todo muy útiles en el momento de ir 01:13:45

planteando ejecuciones e ir viendo si ciertas condiciones se están cumpliendo o no. Ya 01:13:54

veremos ejemplos de esto. También importante, en un debug log, si decimos que enseñe lo 01:14:00

que guarda indicador máximo vida, vais a ver que lo que enseña, en este caso es falso, 01:14:06

pues cuando ejecute el juego 01:14:11

pues falso, ¿vale? 01:14:13

lo pone, no es una cadena de texto, es 01:14:17

que no, está cumpliendo la condición 01:14:19

de hecho internamente el código 01:14:22

lo que está leyendo es que este valor vale 01:14:23

o 0 o 1, es verdad que lo traduce en 01:14:25

falso o verdadero, pero falso es 0 01:14:27

y verdadero es 1 01:14:29

de hecho el otro día os dije que si 01:14:30

una caja, una variable 01:14:33

no se inicializaba 01:14:35

es decir, no se le daba un valor, por defecto 01:14:37

valía 0, o en el caso de los textos 01:14:39

vale nulo, no tiene contenido. Entonces, si yo ahora ejecuto este debug log, como no tiene 01:14:42

nada en su interior, lo que va a mostrar es falso. En realidad es un cero, pero digamos 01:14:50

que la condición es falsa, que no es lo mismo, simplemente por ver que existe también. Si 01:15:00

ponemos true, lo que va a enseñar es true. A ver, espera, ahí está, true. Al final 01:15:05

lo que queremos conseguir es, y voy a abrir el código, que lo tenéis también, y así lo podéis revisar más adelante, 01:15:25

pero lo pongo aquí, era conseguir que una nave espacial en la que van impactando meteoritos vaya quitándole escudo, 01:15:31

vida, por decirlo de otra forma, hasta que muere. Y este es el código, hay más formas de plantearlo, 01:15:41

pero es un código que resuelve el enunciado. 01:15:48

Tenemos esta clase que se llama diagrama, 01:15:52

como se podría llamar un juego nave, porque es descriptivo, 01:15:54

y al final lo que estamos haciendo es generar un float con la energía del escudo, 01:15:59

que empezará al máximo, ahora mismo vale cero, 01:16:04

porque no lo hemos declarado solo. 01:16:08

Un número de vidas, porque el juego, aparte de que muera la nave, 01:16:10

va a haber varias vidas, pierdes una vez y te resta una vida, 01:16:14

Es decir, va a haber la vida del 100 a 0, por ejemplo, y luego tres vidas. Luego, la fuerza del impacto que va a ir restando dos vidas cuando se choquen estos meteoritos. Luego va a haber un booleano, un interruptor, como estábamos diciendo, que nos va a decir si estamos vivos o no. 01:16:17

que este interruptor básicamente lo que va a hacer es 01:16:35

que mientras estamos vivos va a ser 01:16:37

true, porque sí, estamos vivos 01:16:39

pero cuando nos muramos 01:16:41

va a decir que es falso, que estamos 01:16:42

muertos básicamente, si lo traducimos 01:16:45

a nuestro lenguaje, y en el momento en el que 01:16:47

este interruptor pasa a ser falso, es decir 01:16:49

que estamos muertos, pues el juego 01:16:51

va a saber decir, va a entender ya el código 01:16:53

que, pues oye, que el juego se ha acabado 01:16:55

porque no estamos vivos, hemos perdido toda la 01:16:57

energía y también todas las vidas 01:16:59

y luego aquí pues bueno, hay un mensaje 01:17:01

que vamos a ir dando como avisos en pantalla. 01:17:03

Si os fijáis, ya para ir viendo una especie de ejecución 01:17:08

o de puesta en algo menos abstracto, 01:17:12

¿qué es esto? 01:17:17

Cuando iniciamos el juego, cuando iniciamos el script, 01:17:18

lo que vamos a hacer es, en ese momento, 01:17:20

arranca el juego, arranca este script 01:17:22

y vamos a llenar las cajas que nos interesan en este momento 01:17:23

para darle un sentido también al juego. 01:17:27

Hasta este momento solo hemos generado espacios que rellenar. 01:17:29

Pero al empezar el juego nos decimos, oye, quiero que el escudo de la nave sea de 100. Y como se va a jugar con decimales, lo hemos planteado como un float. Esto hay que tenerlo en cuenta, como hemos visto después, para ir teniendo en cuenta problemas que puedan surgir. 01:17:32

que suelen ser fáciles de corregir, pero oye, que nos pueden traer de cabeza, pues tiende vida, ¿vale? 01:17:52

Y aunque no ponga decimales, como es un decimal, es decir, es un float, mejor dicho, ya pongo la F, ¿vale? 01:17:59

Si no la pongo, puede no dar problema, pero veis que ser correcto tampoco conlleva ningún castigo. 01:18:04

Luego, al comenzar el juego, ojo, estamos arrancando el juego y evidentemente arrancamos vivos. 01:18:13

Si empezamos muertos, pues ya sería mal asunto, ¿vale? 01:18:18

Luego, las vidas con las que arrancamos, ¿vale? 01:18:22

Igual que está la energía, pues tendremos tres vidas, ¿vale? 01:18:25

Y luego veis que hay en el start, al arrancar, una operación aquí que ¿qué es? 01:18:27

Por como os he dicho antes, bueno, en realidad lo pone aquí. 01:18:33

Pero veis que se escribe igual que el instant seed de antes. 01:18:37

Es verdad que no hay nada dentro del paréntesis, pero esto es un método o una función, ¿vale? 01:18:40

Los métodos y funciones, ¿vale? 01:18:45

de arrancar el juego pone quiero que haya un impacto e impacto si yo voy a cualquier otro 01:18:47

script vale si yo voy a leer durante la tutoría que estaba haciendo ahora y en estar yo pongo 01:18:53

esto de impacto veis que no existe no sale vale no existe no es como instancia instancia siempre 01:18:58

existe yo pongo instancia y ahí está esperando hay que poner sus paréntesis y ahora que está 01:19:08

y sí que obliga a que haya aquí unos parámetros, ¿no? 01:19:14

¿Vale? Como yo que sé, vamos a poner aquí, aunque dé fallo, 01:19:19

pues vamos a poner, bueno, no tenemos ninguno de tipo objeto, ¿vale? 01:19:22

No puedo poner ningún parámetro aquí porque va a dar fallo 01:19:25

porque nuevamente lo que nos está pidiendo es un GameObject, ¿vale? 01:19:29

Lo que hemos visto antes, que la primera sobrecarga, 01:19:33

su tipo tiene que ser de objeto, ¿vale? 01:19:36

Pero no sale el impacto que os estaba diciendo antes, 01:19:38

ni bien ni mal, no puedo hacer nada, 01:19:41

porque los métodos, lo que vamos a empezar a hacer también es que los creamos nosotros. 01:19:43

Es decir, bajo un nombre que nosotros ponemos, podremos ir, y veis que está aquí, 01:19:48

meter nosotros nuestras operaciones dentro de un bloque, en este caso, fijaos que es largo. 01:19:55

Y este bloque lo que va a hacer, que llega hasta aquí, el bloque impacto, hasta aquí, 01:19:59

todo esto es impacto, cuando yo ponga esta palabra, se va a ejecutar lo que hay aquí dentro. 01:20:04

entonces vais a ver 01:20:11

y esto también es importante, que por primera vez 01:20:13

cuando llegamos a un punto 01:20:15

aquí, saltamos 01:20:17

de aquí a aquí 01:20:19

en la ejecución, luego irá el update 01:20:21

que también tiene su impacto 01:20:23

pero primero 01:20:24

estamos llamando a este impacto 01:20:26

salta aquí y se va a reproducir lo que hay aquí 01:20:29

dentro 01:20:31

¿por qué instantiate 01:20:31

si existe y aquí 01:20:35

existe por ejemplo 01:20:37

si pongo el método instantiate 01:20:39

Como os he dicho antes, impacto no existía en el otro lado, 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 Mono Behavior, que os suene, que ya nos da operaciones prehechas. 01:20:40

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 Instanciate, vais a ver, a ver, me meto en esta, con el control volvemos a meternos, ¿vale? 01:20:58

Pone objeto instantiate, es una de las que ha cargado ya en la librería, ¿vale? Hay otra clase en otro sitio que está guardada en la librería Unity Engine, que cuando empezamos cualquier juego está aquí. 01:21:21

Si yo, por ejemplo, intentara poner Instantiate, como siempre ocurre y cualquier cosa, bueno, en esta como no lo voy a rellenar, me va a dar fallo siempre. Pero fijaos que este Instantiate funciona sin problema hasta que yo me cargo el, o lo comento mejor aún, comento el Unity Engine. 01:21:33

Y veis que Instantiate junto a otras muchas cosas, fijaos en las clases, dejan de funcionar, ¿vale? Entonces tenéis que ir entendiendo que existen las clases y los métodos que ya existen y luego los métodos que nosotros podemos ir haciendo para ir recopilando distintas acciones y que cada vez que pongamos esta frase, pues oye, haga todo esto. 01:21:53

Si yo quiero poner impacto varias veces en mi código, pues no tengo que escribir todas estas líneas, ya está recogido dentro de su propio bloque, ¿vale? Hasta aquí, ¿qué tal? 01:22:12

bueno 01:22:22

te has quedado en lo de impacto, entiendo, hasta aquí bien 01:22:24

sí, a ver, es que yo he estado 01:22:29

intentando hacerlo sin mirar esto que habías 01:22:31

puesto, conseguí no hallar ningún 01:22:33

error hasta lo de que me quedo sin escudo 01:22:35

que ya ahí colapsé 01:22:37

pero cuando meto el impacto 01:22:38

no me lo reconoce, me dice que no puede hacer un 01:22:40

buen impacto 01:22:43

ya he entrado ahí 01:22:44

me doy la tutoría tranquilamente y supongo que 01:22:46

lo sacaréis y no te pregunto 01:22:49

realmente todavía no hemos explicado 01:22:50

cómo se crea esto 01:22:53

Es decir, todavía no he explicado cómo se crea esto, es decir, que va más avanzada de lo que hemos explicado entonces, ¿vale? Así que bien. 01:22:55

Te quiero decir, solamente estoy como dejando caer muchas veces que cuando veamos una orden de este tipo con mayúscula y paréntesis, estamos llamando a un método y que hay métodos que ya vienen prehechos, ¿vale? 01:23:04

Por estas librerías y otros que no, que los hacemos nosotros. Ahora tenemos que aprender a hacerlo nosotros, ¿vale? 01:23:16

Pero hasta, aunque aquí llegamos y lo que pone aquí, invocamos a la función que realiza el impacto, es decir, que al empezar el juego estamos metiendo dentro de esta palabra impacto, pues que haya un impacto, que es lo que vamos a hacer aquí, ¿vale? 01:23:22

Vale, da igual ponerlo antes del void start o después. 01:23:37

¿El impacto te refieres esto? 01:23:41

Todo, o sea, las declaraciones de las variables. 01:23:43

Vale, las variables cuando son globales, ¿no? Como hemos dicho antes, pueden ir aquí o pueden ir al final. Y vais a ver que cuando las pongo al final, ¿vale? Dentro de la clase, pero al final todo funciona. ¿Por qué? Porque está dentro de la clase. 01:23:46

entonces todo lo que se va 01:24:02

metiendo en bloques inferiores 01:24:05

pues puede acceder a estas clases 01:24:07

pero sí que es verdad que es mucho 01:24:09

más intuitivo y es la convención 01:24:11

aparte, que esto vive mucho de convenciones 01:24:13

de que todas las, incluso 01:24:15

aunque luego sigamos picando código aquí abajo 01:24:17

y queramos crear una nueva variable 01:24:19

si queremos que sea global de toda la clase 01:24:21

subimos y la ponemos aquí 01:24:23

porque así de un vistazo rápido 01:24:25

tenemos todas las que son 01:24:27

globales ya englobadas 01:24:29

se puede mientras esté 01:24:30

dentro del bloque correspondiente 01:24:32

a donde queremos que funcione, que por eso he explicado 01:24:34

lo del encapsulamiento 01:24:36

funcionaría, pero la convención dice 01:24:37

que lo hagamos aquí 01:24:40

de hecho hay más convenciones 01:24:41

porque ahora mismo todas son private 01:24:43

y a veces iréis incluso viendo 01:24:45

o que 01:24:48

hay gente que dirá, siempre que creo una 01:24:50

variable private empiezo con una barra baja 01:24:52

para que así al ir cambiándolo 01:24:54

en el código 01:24:56

saber que es una variable privada 01:24:57

que no la voy a declarar mediante el inspector, sino que la voy a ir declarando yo siempre a mano en el código, 01:25:00

porque no se puede ir al editor de Unity y cambiarlo si es privada. 01:25:05

Luego hay gente, lo digo por si encontráis, que siempre que haga una variable global le pone m barra baja, 01:25:08

vamos, habría que ponerlo en todas, y todas las que va generando dentro de métodos o de niveles inferiores, 01:25:16

como este int, por ejemplo, pues va sin la barra baja. 01:25:21

Y esto sirve para saber cuáles son variables globales y distinguirlas de las que no. 01:25:24

pero esto ya son convenciones que van más adelante 01:25:27

es decir, que vamos primero a lo básico 01:25:30

vale, gracias 01:25:32

nada, perdona que 01:25:34

sé que me preguntas una cosa y te correspondo 01:25:35

con tres, no, no, no, no pasa nada 01:25:38

pero es que así van sonando las cosas 01:25:40

vale, entonces se puede 01:25:41

declarar incluso, fíjate, vale 01:25:44

la quito 01:25:46

de aquí, pero aquí dentro 01:25:48

vale, digamos que aquí hay un bloque que se cierra 01:25:50

aquí y aquí empieza otro 01:25:52

es decir, si lo declarara aquí en medio 01:25:53

también lo estoy declarando dentro de la clase y no da problema 01:25:55

pero claro, tú cuando luego quieras 01:25:58

descubrir dónde están las variables de toda 01:26:00

la clase, como empieces a 01:26:02

no organizarlo bien, te vuelves loco 01:26:04

por eso, justo debajo de clase 01:26:05

las que son variables globales se declaran 01:26:08

y además si trabajas 01:26:10

en un equipo, pues todos saben dónde están las variables 01:26:12

globales y todos están contentos de encontrarlos 01:26:14

rápido, ¿vale? 01:26:16

Hay gente que lo pone al final por lo mismo 01:26:18

porque saben que están al final 01:26:20

de la clase y lo encuentran antes, pero 01:26:22

como luego dentro de un mismo script 01:26:24

se pueden crear varias clases, que esta es otra cosa 01:26:27

se crea 01:26:29

la clase a continuación y si lo pones 01:26:31

justo debajo de donde se declara, pues más claro 01:26:33

el mejor sitio, vaya 01:26:35

vale 01:26:37

en el 01:26:38

en las variables 01:26:39

también habla de arrays 01:26:43

esto es más avanzado, vale 01:26:45

pero es simplemente para que también os suene 01:26:46

un array, que a veces se puede llamar matriz o arreglo 01:26:48

vale 01:26:51

Se pueden, dentro de una sola caja, meter muchos tipos de datos. Y de hecho, un array, para que os hagáis cuenta, cuando metemos, aunque no está declarado específicamente, a ver por qué no me está abriendo esto, aquí, 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:26:52

Como os he dicho antes, se están guardando un montón de valores, ¿vale? 01:27:18

Al final esto, si habéis estudiado matrices en matemáticas, esto es un poco parecido a una matriz. 01:27:21

Es decir, que hay muchas posiciones de esa variable, ¿vale? 01:27:26

Que os suene. 01:27:29

Esto es más avanzada, así que me lo salto ahora mismo, ¿vale? 01:27:31

Ya tendrá más sentido más adelante. 01:27:33

En esta sección, voy un poco en el orden ahora para ir resolviendo dudas. 01:27:36

Aquí veis lo que acabamos de hablar, de cómo se declaran las variables, 01:27:40

un poco pues inconvenientes que se pueden encontrar etcétera y hay otro otras digamos 01:27:43

instrucciones importantes otros operadores también vale que son estos que tenemos aquí 01:27:52

estos son bastante importantes porque se usan de vez en cuando y si no pues de pronto saltáis esto 01:27:57

porque no parece importante pero si lo es vale poner trucos de programador como un extra pero 01:28:04

No es una extra, es importante, ¿vale? 01:28:08

Es los operadores más más, los operadores menos menos, más igual y menos igual. 01:28:10

Me quedo en estos, ¿vale? 01:28:15

Hoy no voy a avanzar más de aquí, de las variables. 01:28:17

Y bueno, lo que hemos ido viendo de otras cosas. 01:28:22

En las variables acabamos de decir que existen estos operadores. 01:28:26

Lo dejo aquí, ¿vale? 01:28:29

El más más y el menos menos. 01:28:30

A ver, me voy al de durante la tutoría. 01:28:33

Y voy a simplificar un poco esto, ¿vale? 01:28:37

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, ¿vale? Para hacerlo más simple. 01:28:38

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, ¿vale? 01:28:48

¿Eso qué significa? Que a veces hacemos lo que se llaman bucles, ¿vale? Si vais más adelante se habla del for, del while, del while do, bueno, hay varios, más avanzado también, pero que lo que van haciendo esos bucles es ir recorriendo varios elementos y esos elementos van, digamos, siendo posiciones, ¿no? 01:29:00

Por ejemplo, imaginaos, por decirlo así, vemos el típico ranking de una recreativa antigua, ¿vale? Lo pongo aquí, ranking recreativa, a ver si sale lo que yo quiero que salga, que no lo sé, imágenes, ¿vale? Lo típico, los mejores cinco resultados, ¿vale? Y esta va a ser la primera posición, la segunda, la tercera, la cuarta, la quinta y ya no existen más. 01:29:22

entonces habrá un momento que nos va a ir interesando 01:29:44

que vaya, pues eso, muestra la 1 01:29:47

cuando muestra la 1, muestra la 2 01:29:49

cuando muestra la 2, muestra la 3 01:29:51

veis que va sumando progresivamente 01:29:53

en ese momento se usa este operador 01:29:54

más más, ¿vale? 01:29:57

que es una forma de simplificar 01:29:58

que sumamos 01:30:00

1 01:30:04

a la variable 01:30:05

¿vale? 01:30:07

¿esto qué significa? 01:30:09

que si yo ahora mismo pongo aquí vida 01:30:10

¿Qué me va a mostrar en consola? 01:30:13

27 01:30:22

No, 26 01:30:22

Vale, 25, le sumo 1 01:30:23

Y 26, vale, vamos a ello 01:30:26

26, perfecto 01:30:29

¿Vale? Esto luego habrá otras operaciones 01:30:33

Que puede sumar más más 01:30:35

5 veces, porque digamos que 5 veces 01:30:36

Pues irá pasando por las 5 posiciones 01:30:38

Para mostrar ese ranking 01:30:40

¿Vale? Es un operador muy importante 01:30:42

Si pones 4 más eso más 2 01:30:44

No, no 01:30:46

pregunto 01:30:47

no, no, no, es decir, si voy poniendo más 01:30:49

se vuelve loco 01:30:50

vale, esto es lo mismo 01:30:52

y esto es otra sintaxis que suele 01:30:55

dar problema al principio 01:30:57

¿vale? que es, que esto mismo 01:30:59

es la forma resumida de escribir esto 01:31:01

¿vale? y vais a decir, esto no tiene mucho 01:31:03

sentido, bueno, hasta que 01:31:05

lo tenga, ¿vale? 01:31:06

esto y esto 01:31:09

es exactamente lo mismo 01:31:11

¿vale? y vais a decir, ¿cómo vida 01:31:12

es igual a vida más uno? ¿no? 01:31:15

Si lo pensamos en álgebra humana, esto no tiene sentido porque estamos pensando como pensarían las matemáticas, ¿no? Las ecuaciones. 01:31:17

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 1. 01:31:25

Entonces, esto significa que lo que hay en esta caja, ¿vale? Es igual a lo que guarde la caja, ¿vale? Aquí está refiriéndose a abrir la caja y aquí se está refiriendo al contenido de la caja, ¿vale? 01:31:36

Aquí siempre hablamos de declarar la variable o llamar a una variable e inicializarla o cambiar el valor. El igual no es igual, no es un igual de matemáticas, es un asignador. 01:31:47

Entonces, vida es igual a vida más uno. Es decir, en esta caja vamos a guardar lo que valga vida más uno. 01:31:57

Y si volviéramos a poner aquí vida, pongo otra vez esta línea, cuando yo muestre otra vez la misma instrucción, no son lo mismo. 01:32:03

¿Vale? ¿Qué pensáis que va a poner ahora 01:32:14

en la consola? 01:32:16

Lo mismo, 26 01:32:18

Aquí 26, ¿vale? 01:32:20

Pero estoy diciéndole otra vez, recordad 01:32:22

Pero porque te coge 01:32:24

la segunda 01:32:26

orden que estás dando el resultado 01:32:28

de la primera y no el resultado 01:32:30

del que has declarado 01:32:32

Ahora lo explico, simplemente lo voy a enseñar para que me creáis 01:32:33

y luego os lo explico 01:32:36

Esto es 01:32:38

bastante simple y a la vez 01:32:40

bastante complicado veis que pone 26 y 27 volvemos a lo del encapsulamiento y 01:32:42

cuando se declaran las variables vale tenemos una variable global aquí arriba 01:32:47

vale con su caja y la inicial izamos con 25 como podría ser con cualquier valor 01:32:51

vale y vamos aquí y decimos vale en vida igual que en vez de antes decíamos ahora 01:32:57

vale 70 y lo decíamos así a las bravas entonces aquí enseña 70 no esto lo 01:33:02

vimos el otro día y lo hemos visto antes también quiero que sea lo que vale vida 01:33:06

más 1. Y aquí lo que está haciendo es 01:33:11

coger, todavía no lo hemos 01:33:13

asignado, está abierta la caja y aquí 01:33:15

hacemos la asignación. Está volviendo 01:33:17

a donde se declaró la variable, 01:33:19

coge este valor, 01:33:22

le suma 1 y lo guarda en vida. 01:33:24

Vale, y lo lee de arriba a abajo 01:33:26

y por eso suma 2. Y aquí lo aguarda como vida. 01:33:27

Pero es que cuando volvemos a esta caja, 01:33:30

vuelve a abrir la caja y aquí ya no vale 01:33:32

25 a estas alturas, vale a 26. 01:33:33

Vale. Y le sumamos 01:33:35

1. Y así progresivamente. Es decir, 01:33:37

si yo empezar a hacer esto, 01:33:39

Pues, sería 26, 27, 28, 29, ¿vale? Que es lo mismo, ¿vale? Os lo vuelvo a decir, en vez de escribir todo esto, es lo mismo que decir esto. Es a la caja, súmale 1, ¿vale? Es exactamente lo mismo. 01:33:41

Vale, pero si lo quisiera mencionar en otra caja que se vinculara con los 26, sí que le tendría que asignar como otro nombre a vida para que la otra cápsula te lo reconociera por 26 en vez de por 25, ¿o no? 01:33:56

No, aquí lo que va haciendo 01:34:07

claro, tú me estás hablando de abrir 01:34:09

otra variable distinta 01:34:11

claro, si tú abres otra variable pues 01:34:13

esto se llamará 01:34:15

muerte, no sé, y esto tendrá 01:34:16

otro valor, es decir, vida y muerte 01:34:19

son distintos 01:34:21

es decir, si yo 01:34:22

aquí digo muerte y le pongo 01:34:25

800 por poner un valor 01:34:27

muy distinto, aquí es que 01:34:29

muerte no está cambiando en ningún momento 01:34:31

es verdad que yo puedo ir aquí y decir muerte 01:34:33

¿vale? 01:34:35

Y aquí me va a enseñar vida 25 más 1, 26. 01:34:37

Ha guardado 26 en la caja en este momento. 01:34:42

Ahora vuelvo aquí, que ya vale 26, estoy llamando a la caja. 01:34:45

26 más 1, 27. 01:34:48

En este momento va a enseñar 27, ¿vale? 01:34:50

Vuelvo a llamar a la caja vida. 01:34:52

He guardado 27 aquí antes, ¿vale? 01:34:55

27 más 1, 28. 01:34:57

En este momento la caja vale 28 y aquí enseñará 28. 01:34:59

Y aquí valdrá 29. 01:35:01

Pero aquí no va a enseñar 29, 01:35:04

porque es que lo que le estoy diciendo que enseñe no es vida 01:35:05

no es lo que hay en la caja vida, es la caja muerte 01:35:08

entonces va a enseñar 26, 27, 28 01:35:10

y 800 01:35:12

vale, pero si yo lo pusiera fuera de esas 01:35:13

llaves 01:35:16

sí que tendría que declarar 01:35:17

de otra manera la vida más uno 01:35:20

para que me lo reconociera porque estaría 01:35:22

fuera de todas estas llaves 01:35:24

no sé si me explico 01:35:26

claro, pero tú donde has declarado la variable es 01:35:27

a comienzo, es global 01:35:30

entonces se va a poder usar en toda la clase 01:35:31

sin problema 01:35:34

El problema viene de que yo la declaro aquí, como está en el ámbito, aquí sí que funciona, ¿no? Pero si yo luego en el update pongo vida, pues es lo de antes. Aunque yo ponga vida más uno, es que no sabe que es vida porque está fuera de su ámbito, ¿vale? 01:35:35

Sin embargo, muerte sí, porque aquí muerte se va a poder poner. Muerte es igual a 55. ¿Vale? O mejor aún, mira. ¿Sí? ¿Me vas siguiendo? 01:35:55

Sí. 01:36:10

Vale, o mejor aún, voy a comentar esto para que en el Star no haga nada y no salgan muchos numerajos, pero imagínate que en el update, que recuerda que se va planteando en cada fotograma, quito lo de muerte 55, digo que cada fotograma me enseñe lo que vale muerte. 01:36:10

que esto por ejemplo puede servir para un contador 01:36:28

aquí 01:36:31

muerte 01:36:33

¿qué crees que va a pasar? 01:36:35

como la he declarado arriba 01:36:37

la puedo, como es global 01:36:39

la puedo hablar de muerte de esta variable 01:36:41

en cualquier lado, ¿qué va a ir pasando? 01:36:43

que va a sumar 801 01:36:46

802, 803 porque la has puesto 01:36:47

en el que se va cargando 01:36:50

por fotograma 01:36:52

exacto, empieza valiendo 800 01:36:53

en el fotograma siguiente le digo, ojo 01:36:55

súmale uno y me lo enseñas 01:36:57

y aquí guarda 801, porque está fuera del update 01:36:58

en el siguiente 01:37:01

801, súmale uno 01:37:03

pues enseñará 802 01:37:05

y guarda 802, y ahora vas a ver que tenemos 01:37:06

como una especie de contador 01:37:09

muy poco refinado, pero 01:37:10

vas a ver que cada fotograma 01:37:13

espera, perdón 01:37:15

vale, ahí 01:37:16

pues va a ir sumando 01:37:18

cada fotograma, que por segundo se ejecuta mucho fotograma 01:37:20

por eso va como a saltos 01:37:23

Pero sí que se están planteando, ¿vale? 01:37:25

¿Ves que van sumándose? 01:37:28

Sí. 01:37:30

¿Vale? Que no va de uno en uno. 01:37:30

Bueno, si vas parando sí van de uno en uno, 01:37:32

pero se juzguta más rápido del uno en uno. 01:37:34

¿Vale? 01:37:37

Entonces, pues mira, por ejemplo, 01:37:37

una aplicación práctica para hacer un contador. 01:37:39

Pues mira, el más más puede servir. 01:37:41

Y lo mismo, esto es igual a muerte más uno. 01:37:43

Es exactamente lo mismo. 01:37:46

Va a dar el mismo resultado. 01:37:48

Si quieres lo comprobamos, pero te lo digo yo. 01:37:49

Sí, sí, lo da. 01:37:51

Vale. 01:37:52

Y, vale, muerte más uno, vuelvo aquí a los apuntes, ¿vale? Este operador, importante que sepáis, bueno, esto lo apago, que ya está aquí usado, cuántas cosas, ¿vale? Y esto también, esto que estoy poniendo de vida igual vida más uno, también se puede poner con otra forma resumida que son estas, ¿vale? 01:37:52

Bueno, ojo, no he puesto el menos menos, pero el menos menos lo que va haciendo es restar uno, ¿vale? Cada vez que se invoque. Igual. Si queréis hacemos las pruebas, pero por no perder tiempo. Pero existe el más igual y el menos igual, ¿vale? 01:38:14

Si yo voy al más igual, lo que se puede hacer es, para no tener que repetir, que incluso es la confusión que nos viene siempre, en vez de poner muerte igual a muerte más uno, cuando se va a hacer una operación sobre la misma variable, sobre la propia variable, se puede hacer igual más uno. 01:38:26

¿Y esto qué significa? Que muerte pasa a valer lo que valga más 1 o más 7 en este caso, ¿vale? Ahora se van a ir sumando de 7 en 7, va a ir 807, 814, ¿vale? Y cada fotograma va a ir enseñándolo, ¿vale? ¿Por qué no lo está haciendo bien? Pues por una cosa muy simple, que es que he puesto igual más, no más igual, ¿vale? Importante. 01:38:44

¿no? he puesto igual más 01:39:10

y la operación es más igual 01:39:13

¿vale? ahora mismo 01:39:15

esta línea como no tiene sentido 01:39:17

¿vale? le estaba diciendo que era un 7 positivo 01:39:19

básicamente, entonces siempre vale 7 01:39:22

que no es lo mismo que 01:39:24

cada vez que dé una vuelta en este caso 01:39:25

vaya sumándole 7 01:39:27

ahora sí que va a ir 800, 800 01:39:28

7, va a ir 01:39:31

lo paro porque si no esto 01:39:33

se vuelve loco, ¿vale? 01:39:34

807, va sumando 7 en cada ocasión 01:39:37

que es la cifra que hemos puesto 01:39:39

si aquí lo pusiéramos 01:39:41

con el menos 01:39:44

aquí lo bueno es que podemos determinar que sean saltos más allá del 1 01:39:45

¿vale? porque en el más más sí que es 1 01:39:48

por ejemplo, aquí también podríamos poner 7 01:39:50

por ejemplo 01:39:52

si aquí ponemos que vaya restando 1 en cada fotograma 01:39:53

pues será 01:40:01

lo paro y voy para arriba 01:40:02

para ver lo que ha hecho 01:40:04

va restando 1 en cada vuelta 01:40:04

¿vale? 01:40:09

eso es importante, ¿qué tal hasta aquí? 01:40:11

bien 01:40:13

Sí, ¿no? Más o menos, ahí va. Hay una última cosa que quiero que sepáis, que es, que antes lo hemos visto, que es, por un lado, que cuando tenemos algún, a ver, que lo voy a tener que crear porque no lo tengo, cuando tenemos algún valor público o con serialized fill, como aquí, a ver, serialized fill, es decir, que lo asignamos, lo podemos asignar por el editor, ¿no? Como hemos hecho, pero en este caso es un número, ¿vale? 01:40:14

Yo aquí le he asignado 800 y esto lo voy a comentar para no complicarlo más. Yo aquí le estoy diciendo que esto vale 800 y yo voy al script durante la tutoría y pone 800. Y yo digo, bueno, no, 800 no, 950. 01:40:42

vale, es verdad que aunque 01:41:00

bueno, espera, y en el start 01:41:02

voy a decir que me enseñé que está 01:41:05

guardando muerte, porque si no 01:41:06

no sabemos que está interpretando internamente 01:41:08

el 01:41:11

programa, vale, cuando 01:41:11

empiece el juego enséame lo que vale muerte 01:41:14

y aquí yo he inicializado muerte 01:41:16

y pone 800, lo lógico 01:41:18

sería que pusiera 800, que era 01:41:21

el problema que estaba dando antes 01:41:22

yo cuando voy y arranco el juego 01:41:24

¿qué es lo que me pone? 01:41:26

950, vale 01:41:28

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. Aquí si no lo tuviera serializado y lo cambiara, lo que me va a enseñar es 1000. 01:41:30

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:41:48

Entonces lo que me va a enseñar es 1000. 01:41:59

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. 01:42:01

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? Como yo he cambiado el juego y le he dicho al arrancar la ejecución, ponmelo en 1000, ¿vale? 01:42:10

sobrescribe al empezar el juego 01:42:29

en un momento de ejecución lo que yo ya he hecho 01:42:31

tanto en la declaración inicial 01:42:34

¿vale? como en la sobrescriptura 01:42:35

que tenemos aquí, que sí que es verdad 01:42:38

que si no hiciera nada más 01:42:40

¿vale? como no hay un momento de ejecución 01:42:41

no hay un momento en el que lo vuelve a cambiar 01:42:43

pero tened ojo con que a veces 01:42:45

poner aquí las instrucciones puede dar 01:42:47

este tipo de problemas, que hay un orden de ejecución 01:42:49

¿vale? ya os iréis pegando con ello 01:42:51

no sé si me vais siguiendo pero eso 01:42:53

aquí al inicializar 01:42:56

aportamos un valor, pero luego hay momentos de ejecución, 01:42:57

como el start y el update, que pueden ir sobreescribiendo 01:43:00

valores. 01:43:03

Pero este sería el ice field. 01:43:04

Y el public también se puede variar dentro del propio script. 01:43:06

Y, de hecho, para que os hagáis una idea, 01:43:14

yo aquí pongo serializar el campo, ¿vale? 01:43:16

Lo inicializo como 800. 01:43:22

al empezar lo pongo en 1000 01:43:23

y quiero que la muerte 01:43:26

me lo vaya enseñando en el update 01:43:28

que cada fotograma me vaya enseñando esta cifra 01:43:29

y guardo, y vais a ver que pasa una cosa 01:43:31

que mezcla todo esto 01:43:34

que acabo de decir 01:43:36

yo arrancaré el juego, al arrancar 01:43:36

se me pone en 1000, sobre escribiendo 01:43:40

esto que está en 1132 01:43:41

a ver, placa 01:43:43

se pone 1000 01:43:45

y vale, pues 1000, me lo ha puesto 1000 incluso aquí 01:43:46

pero cuando yo ya he arrancado el juego 01:43:49

como digamos que esta orden ya se ha ejecutado 01:43:52

y no lo va a sobreescribir 01:43:55

al final lo que va a importar es 01:43:56

lo que yo vaya poniendo aquí 01:43:58

y veis que va cambiando el valor 01:44:00

y podría ir cambiando desde el editor a mano 01:44:01

ciertos valores 01:44:04

¿vale? que os suene 01:44:05

¿pero para qué? 01:44:07

pues por ejemplo imagínate que quieres probar 01:44:10

hacia donde se mueve una nave 01:44:12

de una forma intuitiva 01:44:14

porque tú cuando arrancas el juego 01:44:15

no puedes cambiar el código 01:44:18

el código, digamos que una vez arranca 01:44:19

no se puede cambiar, pero nos puede 01:44:21

interesar probar cosas que 01:44:23

sí que se ejecutan durante el juego, como esto 01:44:25

pero luego lo tendrías que cambiar 01:44:28

en el código, ¿no? es que estoy cambiando el código 01:44:29

aunque no lo parezca, o sea, aunque no salga 01:44:32

en el CESAR, es como si 01:44:34

estuviera cambiando, ¿no? claro, yo con este serial 01:44:35

I feel, estoy accediendo a esta 01:44:38

variable en todo momento 01:44:39

y siempre y cuando sea en un momento de 01:44:40

ejecución que se pueda ver 01:44:43

cómo voy cambiando el valor de muerte 01:44:45

yo en todo momento tengo abierta esta caja 01:44:47

en vez de cambiarlo como aquí, lo estoy cambiando 01:44:49

pero por el editor, en vivo 01:44:51

¿vale? 01:44:53

yo lo que vale muerte lo estoy cambiando 01:44:55

ahora mismo, en este mismo instante 01:44:57

muerte no vale ni 800 ni 1000 01:44:59

vale 1657 01:45:01

ya lo iréis viendo 01:45:02

sobre todo, mira, en el siguiente tema ya de hecho 01:45:05

tiene aplicaciones, así que ya lo veréis 01:45:07

¿vale? e importante, si en algún 01:45:08

momento queréis ir viendo como va 01:45:11

pues por ejemplo lo del más uno 01:45:13

que va cada fotograma, aquí vais 01:45:15

yendo fotograma a fotograma, aquí da igual 01:45:17

porque, mira, como está parado 01:45:19

el juego, si yo ahora cambio a 1896 01:45:21

al ir al siguiente 01:45:23

fotograma, pues 1896 01:45:25

¿vale? que en ocasiones 01:45:27

puede que queramos ir viendo 01:45:29

qué va pasando cada fotograma, en vez de aquí 01:45:30

una sucesión de 01:45:32

elementos, pues, continua 01:45:34

¿vale? que se puede detener el juego y se para ahí 01:45:37

y podemos ir fotograma a fotograma 01:45:39

ejecutándolo, ¿vale? 01:45:40

Hay una última cosa 01:45:43

muy importante que es 01:45:44

que cuando vayamos cambiando cosas en vivo 01:45:47

yo puedo decir, ay, yo arranco 01:45:49

el juego y se me ponen 1000 siempre 01:45:51

¿vale? y aquí empiezo a guardar 01:45:53

y vais a ver que yo cuando detengo 01:45:55

el juego me vuelve al otro valor que estaba 01:45:57

guardando antes de empezar, ¿no? por ejemplo 01:45:59

500, ¿no? arranco el juego 01:46:01

se va a sobreescribir a 1000, que es lo que 01:46:03

hace al arrancar el juego y me pongo 01:46:05

a cambiar esto a 192 01:46:07

y por lo que sea yo quiero que en 192 01:46:09

se 01:46:12

Se deja aquí, digamos, sobrescrito el valor. Veréis que cuando yo detenga la ejecución del juego, vuelve a 500, que es el que yo había metido a mano. 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:46:13

tengo aquí colocada la nave y quiero que se mueva 01:46:28

y lo voy a ir cambiando en tiempo real en estas coordenadas 01:46:32

quiero cambiarlo en estas coordenadas 01:46:34

todos estos cambios que yo voy haciendo 01:46:36

imaginaos que yo hay un momento que voy a decir 01:46:38

quiero que la nave se quede aquí, que la haya ajustado 01:46:44

pero como estoy en ejecución, durante la ejecución 01:46:46

los cambios que vayamos haciendo solo funcionan durante la ejecución 01:46:49

cuando yo pare, vuelve a los valores que tenía antes de la ejecución 01:46:52

Por tanto, cambios que hagamos en vivo, que es el siguiente tema que vamos a hacer, cuidado que se hacen y no se guardan. Por eso veréis que cuando yo le doy al play se oscurece un poco el área, se oscurece un poco el entorno, indicando que estamos dentro de la ejecución y un poco advirtiendo que el cambio que hagamos en los parámetros no se guardan. 01:46:57

¿Vale? Último consejo. Para cambiar este color y que sea aún más obvio cuándo podemos o no cambiar los elementos sin que se guarden, ¿vale? Dentro de Edits hay una pestaña de Preferencias. Creo que siempre confundo estas dos. En Preferencias, Edit Preferencias, están los colores del sistema. 01:47:18

Ya hay uno bastante interesante de modificar, que yo ya lo haría, 01:47:40

y esto se guarda siempre que no instaléis otra versión de Unity o vayáis a otro ordenador, etc. 01:47:46

Es decir, entre distintos juegos incluso que uséis la misma versión de Unity se va a mantener. 01:47:52

En vez de decirle que sea el tintado de este gris tan sutil que tenemos, 01:47:57

lo podemos exagerar a yo que sea un rojo de warning. 01:48:01

Cuando lo tengamos ahí configurado, el Play Mode Tint, el tinte de modo de juego, 01:48:04

ahora cuando ejecutemos el juego vais a ver que se tiñe de otro color 01:48:09

lo podéis poner más o menos llamativo 01:48:12

ahora todo cambio que vayamos haciendo mientras estemos en este modo 01:48:15

sabemos que cuando detengamos la ejecución del juego 01:48:18

placa, no ha servido para nada 01:48:23

excepto a lo mejor para tener clara la referencia 01:48:25