Tutoría 2 - DEIM - UT1 y 0 - Curso 23·24 - 28 Noviembre

el final de la tarea una vez teníamos el script realizado hay que conseguir pues que al lanzar el 00:00:00

juego dado que se ubica en el start si no me equivoco aquí está descrito sólo se hará una 00:00:05

vez y se instanciará ese prefab que es la nave una sola vez es cierto que y abro aquí un código 00:00:11

lo pongo por aquí que dependiendo de qué sobrecarga hayas usado del método instantiate hará 00:00:17

una opción u otra vale el otro día dijimos vale veis que aquí hay tres formas pasarán tres cosas 00:00:25

y se instanciarán tres naves y cada una tiene digamos unas diferentes consecuencias cuando 00:00:32

empezamos a escribir el método instantiate a ver si quiere que no empeza a escribir ya 00:00:39

incorrectamente vale cuando abrimos estos paréntesis que definen a las funciones o 00:00:44

métodos teníamos estas sobrecargas que nos iba indicando qué pues qué propiedades está esperando 00:00:49

no en principio las tres primeras digamos las cuatro primeras casi son las que más se utilizan 00:00:57

bueno cada una tiene sus propias sus propias pues eso consecuencias pero no es lo mismo no es 00:01:05

exactamente lo mismo suele estar todo relacionado y instantiate pues sirve para generar un clon 00:01:12

de lo que se haya referenciado pero no es lo mismo realizar y ahora aquí paso a ejecutar tres si 00:01:17

queréis la una instancia en el que sólo se le pasa un parámetro que es el objeto que hemos 00:01:23

introducido digamos capturada a través del serialize fill que recordemos que es que luego 00:01:30

una vez tenemos este script a ver perdonad que es importante cuando queramos ver lo relativo a un 00:01:36

a un script no olvidar que ese script tiene que ser componente de alguno de los elementos que 00:01:46

están en la escena ejecutándose vale por tanto voy a poner este instantiate prefab vale que es el 00:01:52

script que estaba revisando hace un segundete este de aquí instantiate prefab 00:01:59

perdonad mi inglés instantiate prefab si yo guardo vale tengo aquí tres 00:02:04

instantiate diferentes cada uno tiene sus particularidades como acabo de decir y cuando 00:02:09

yo ejecuto en el start se van a generar los tres o eso debería hacer vamos a dar la play y a ver si 00:02:17

lo hace no hace nada y de hecho da fallo porque porque ya que os tengo aquí y entiendo que 00:02:24

habéis estado con la tarea porque no porque no se ha instanciado nada porque da error 00:02:32

que esto ya lo vimos el otro día y bueno y si habéis hecho la tarea pues 00:02:39

lo tendréis claro porque no lo tienes instanciado no a qué te refieres porque yo aquí básicamente 00:02:43

ya tengo un instancia de my prefab que está aquí preparado y debería instanciar ese prefab 00:02:52

pero no lo tienes vinculado en unity en la columna de la derecha es genial aquí si nos 00:02:58

damos cuenta vale se han generado los campos para introducir pues pues ojo que es mi prefab 00:03:04

no y que gameobject es el que quiero instanciar aquí es donde podemos arrastrar este prefab y 00:03:10

pues está aquí preparado y ahora todo lo que en el código tenga una variable referenciada con mi 00:03:16

prefab pues se refiere a ese objeto por tanto esta línea por ejemplo este primer instantiate 00:03:22

ya tiene lo que necesita para hacer la instancia cuando sólo se usa uno de los parámetros que 00:03:27

además es la primera la primera sobrecarga vale es vale hacemos el instantiate sólo con dando 00:03:33

un objeto que es el original que se va a clonar que es lo que acabamos de hacer aquí vale cuando 00:03:42

yo ahora no olvidéis de guardar siempre que hagáis algún cambio en el código para que se ejecute vale 00:03:47

yo ahora cuando lanza el juego al menos una nave tiene que aparecer vale y de hecho se han generado 00:03:53

alguna más y ver de hecho que si nos fijamos a ver tenemos una aquí tenemos otra aquí las estoy 00:03:57

moviendo bueno perdonad que estoy cogiendo partes de la nave de este prefab si la arrastro para acá 00:04:04

y de este prefab para acá vale se han generado dos naves y las dos si nos damos cuenta están 00:04:10

deshago y marco una en el 0 0 0 vale por tanto una de estas naves básicamente esta primera vale 00:04:16

es la primera que ha aparecido porque recordad que el código como os dije el otro día a menos 00:04:24

de a medida que lo vayamos complicando esto no es así pero en este momento sí que lo es el código 00:04:29

se va ejecutando de arriba abajo entonces la primera nave que se genera en la jerarquía de 00:04:36

objetos vale que si os dais cuenta a medida que voy incorporando pues se van añadiendo de arriba 00:04:42

abajo la primera nave se hacía hacía referencia a esa es verdad que aquí tenemos otros dos 00:04:46

instant seats vale que pues no se están no se están produciendo como ya os comenté para hacer 00:04:51

pruebas de qué funciona y qué no vale y esto me sirve un poco para explicar que un mismo método 00:05:01

como este instancia y tiene varias sobrecargas y cada una tiene unas consecuencias que lo que 00:05:05

no ahora si guardo y lanzó el juego pues nuevamente 00:05:11

como el prefab está instanciado pues placa y aquí tenemos la nave vale por tanto este instant 00:05:18

seat primero está funcionando bueno pues ya si quisieramos usar ese instant seat está ahí preparado 00:05:26

vamos a ver qué pasa con el resto es decir voy a comentar el resto y voy a ver esta línea según 00:05:32

empieza es verdad que aquí está generando como una variable si os fijáis no que le está poniendo 00:05:40

un nombre que se llama instancia que si no vemos mal aquí pone game object may prefab no está generando 00:05:44

una variable de un tipo de variable que es game object es decir una clase vale un digamos una 00:05:52

un conjunto de código que se refiere a todo lo relativo a los game objects si ya habéis estado 00:05:59

estudiando un game object en unity se refiere a cada uno da igual que sea la cámara la luz un cubo 00:06:04

cualquier geometría vale todo lo que vamos teniendo aquí introducido genéricamente se llama como un 00:06:10

game object esta cajita digamos hecha de alambre no que no está rellena es un game object aquí 00:06:15

representado que no es lo mismo que meter un prefab que veis que sí que está lleno pero en 00:06:22

genérico todo lo que se va introduciendo aquí son game objects por eso cuando queremos referenciar 00:06:26

un objeto usamos esta clase game object que usamos como tipo de la variable y por eso todo lo que 00:06:33

metamos en esta caja si recordáis la analogía que hacía el otro día con cajas vale si lo que 00:06:39

queremos es que recoja ese game object vale pues habrá que usar la clase game object voy a seguir 00:06:45

y ahora vamos al transform y vemos un par de cosas si yo ahora guardo y digo a ver a ver qué ocurre 00:06:52

cuando yo ahora lanzó el juego no que sólo se va a ejecutar esta línea en el start vamos a ver 00:06:59

y me voy a poner aquí a mi lado el juego vale acabo de lanzar el juego y hay una nave en el 15 00:07:05

a buena perdón en el 0 0 0 igual vale pues eso significa que crea una instancia en la posición 00:07:14

aquí os lo he comentado y está ya indicado crea una instancia la posición del objeto de referencia 00:07:24

y como hijo suyo pero es verdad que está ocurriendo algo si os dais cuenta que es que 00:07:28

aunque aquí he puesto dos parámetros vale my prefab y referencia referencia si lo pensamos 00:07:34

bien me podéis contestar a qué se está refiriendo en este momento 00:07:41

ahí vacío no tener en cuenta que yo he generado aquí una variable de tipo transform y transform 00:07:45

sin si recordáis es el primer componente que tiene las coordenadas de posición rotación y escala de 00:07:59

cualquier objeto de casi cualquiera todos suelen empezar teniendo ese componente y luego muchos 00:08:05

otros dependiendo de cuál sea la función vale fijaos que yo en referencia que es otra variable 00:08:11

que he generado por medio de un campo serializado no le he dado ninguna referencia ahora mismo está 00:08:17

vacía es nula no existe por eso la ha generado en el 0 0 0 y no es hija de nada como pongo ahí que 00:08:24

es si os fijáis es exactamente el prefab el 0 0 porque no tiene esa referencia es decir ahora 00:08:31

mismo esta línea está funcionando como esta primera porque aquí lo que tiene es nada no 00:08:38

lo existe no para aprovechar esta sobrecarga y que tenga sentido meter dos dos variables aquí 00:08:43

dentro pues habría que decir cuál es ese cuál es esa referencia vale y ahora mismo pone ninguna 00:08:49

y está esperando un objeto un vínculo no digamos en este campo del tipo transform eso que significa 00:08:56

que si yo en este campo igual que hecho en este de aquí arriba arrastro aquí la nave vais a ver 00:09:05

que pone esa nave prefab es el mismo objeto pero fijaos en dos cosas primero cambia el icono no y 00:09:11

cambia también da como una indicación de qué es lo que está cogiendo de esta referencia que hemos 00:09:18

metido ahí si os fijáis además esto no sé si lo dije el otro día este iconito es el mismo que el 00:09:24

del componente transform porque de este de esta variable sólo está recogiendo lo relativo al 00:09:28

transform del objeto vale de este por ejemplo no se va a poder decir si este game object tiene 00:09:34

un componente otro tipo a tal no podremos hacer ningún tipo de operación en algo que no sea 00:09:42

el componente transform de su objeto igual que aquí accedemos al objeto completo vale que aquí 00:09:47

lo hemos hecho para que se instancie completamente aquí sólo estamos cogiendo una parte de ese objeto 00:09:53

ese componente transform esto me sirve nuevamente el otro día para introducir que las variables 00:09:59

pueden ser de tipos casi ilimitados en relación con la cantidad de componentes que hay es decir 00:10:04

aquí si yo busco no hay un transform porque como ya viene aplicado no está preparado pero también 00:10:11

os dije el otro día que por ejemplo no vais a ver en la elección 3 existe este rigidbody pues yo 00:10:18

si por ejemplo en este objeto que le añadió un rigidbody quisiera en algún momento cambiar las 00:10:24

propiedades del componente rigidbody vale esto ya lo iremos viendo que es básicamente lo que 00:10:30

activa el motor de físicas de unity siempre va a haber la posibilidad no de si confirmadme que me 00:10:36

escucháis que un compañero acaba de decir que no yo creo que está entrando el audio a ver si debería 00:10:45

entrar bien si me oís a mí sí Jesús yo sí te oí hola buenas tardes qué tal no oigo mi entrecortado 00:10:52

no sé si se oye yo mi conexión o el resto que lo confirme no lo sé supongo que será a lo mejor 00:11:04

algo relacionado con tu yo digo bien aunque me pone que tiene buena conexión no sé igual 00:11:15

nada igual es una tontería si es un portátil a mí me pasa esto es una chorrada cuando no lo 00:11:22

tengo conectado a la luz no creo que sea eso pero hoy nada espero que se solucione eso imaginaos 00:11:29

que yo también puedo hacer una variable fijaos que está aquí preparado y rigidbody 2d es otro 00:11:40

tipo de variable no pues haremos una variable de tipo físicas yo que sé recordad que esto es el 00:11:43

tipo de variable y esto es el nombre que podemos poner el que queramos que asignamos a esta caja 00:11:51

que recoge lo de variable y ahora fijaos que si bueno si yo guardo lo primero recordar la 00:11:57

estrellita de aquí si yo guardo y vuelvo a ir al objeto en el que he puesto el script ahora 00:12:03

hay otra bueno tiene que estar este rigidbody para poder referenciarlo ahora pero ahora está 00:12:09

esperando otro que metan que introduzcamos algo en este campo de tipo rigidbody no un poco del 00:12:14

tipo de la caja que hemos creado si yo aquí arrastro ahora la nave vale veréis que la nave 00:12:20

prefab como no tiene rigidbody vale no lo va a coger porque sí que tiene transform sí que se puede 00:12:26

arrastrar como todos los gameobjects un gameobject pero no tiene un rigidbody por tanto aunque yo 00:12:33

intente podéis hacer la prueba arrastrar igual que si me deja introducirlo en las otras dos en 00:12:38

los otros dos campos aquí no me deja sí que podré por ejemplo meter el propio gameobject del script 00:12:43

fijaos que si yo el arrastro si me deja porque porque tiene un rigidbody al cual yo podría 00:12:49

acceder luego para cambiar variables y veis que además el iconito vale en estos componentes que 00:12:55

ya vienen generados directamente por unity pues les ponen estos iconitos para facilitar veis que 00:13:00

aunque la caja aunque parece que es un poco lo mismo esto ya profundizaremos más luego al final 00:13:05

cada variable tiene su tipo no aquí lo que estamos haciendo en esta línea es crear sin pasar por el 00:13:13

comienzo de la clase vale que es donde vamos generando lo que se llaman las variables miembro 00:13:21

que son variables que podréis usar en todo el código porque su ámbito vale esto si ya habéis 00:13:27

visto ahora vamos un poco a esto pero si ya habéis leído el tema cero cosa que deberíais haber hecho 00:13:32

al menos una pasada hay un tipo de variables que si se ubican al comienzo de la clase podrán ser 00:13:37

luego empleadas por cualquier método en este caso estar vale lo que también se puede hacer es declarar 00:13:45

es decir construir esta caja dentro ya de un método no dentro de la clase en general sino dentro de un 00:13:51

método de su propio bloque entonces estamos generando una caja de tipo game object vale 00:13:58

que estamos llamando instancia y a diferencia de aquí lo que estamos haciendo es que en ningún 00:14:04

momento hemos creado un serialize que te permita arrastrar y saber que esta caja se llena con un 00:14:10

objeto que metes por el inspector no aquí lo que estamos haciendo es rellenar la caja instancia 00:14:17

de tipo game object con la instancia que generamos es decir que si yo en esta instancia luego cambio 00:14:22

alguno de sus parámetros ahora lo vemos no está refiriéndose a nada que hemos capturado por el 00:14:30

inspector sino que hemos llenado la caja directamente con una instrucción que hemos dado aquí vale hasta 00:14:37

aquí me vais siguiendo 00:14:44

vale esto qué significa un ejemplo rápido vale veremos que hay un montón de instrucciones y 00:14:51

recordar esto lo vimos el otro día que había un operador al escribir sentencias que es el punto 00:14:57

vale que esto lo indiqué por ejemplo cuando ponemos transform podemos acceder a la posición 00:15:04

de un objeto pues si escribimos position vale porque estamos accediendo a las propiedades del 00:15:10

transform vale lo único es que como ya os dije que como el transform es tan utilizado porque es todo 00:15:17

lo que se refiere a los GameObjects pues han generado a parte de la clase transform que 00:15:22

siempre se escriben las clases con mayúscula empezando por mayúscula vale importante esto 00:15:28

también lo pone las buenas prácticas en el tema cero ha generado una propiedad vale que se llama 00:15:32

transform con minúscula que es el nombre en el que se da a las propiedades como por ejemplo 00:15:39

position no estamos aquí refiriéndonos a la clase directamente sino que es una especie de es un poco 00:15:43

ambiguo porque al final es la misma palabra pero las mayúsculas y las minúsculas tienen influencia 00:15:50

al escribir código entonces una manera de simplificar y digamos no tener que acceder a 00:15:55

una clase que es como una entidad superior sino de meter una operación que se puede hacer de manera 00:16:00

más simple vale podemos acceder a las propiedades del transform con este transform en minúscula y 00:16:05

luego al ir poniendo el position pues podemos decir igual a 10 que va a dar fallo porque por más 00:16:10

cuestiones pero veis que lo importante de esto ahora mismo es que cuando ponemos un punto vamos 00:16:15

abriendo opciones hijas de ese primer elemento que hemos puesto como lo que el otro día os dije de 00:16:22

país comunidad autónoma vale o estado si fuera eeuu ciudad punto calle punto número vale si estas 00:16:28

propiedades existieran configuradas vale pues sería esta la forma la sintaxis para ir accediendo 00:16:38

digamos de un elemento a otro pero para poder acceder por ejemplo elemento ciudad si no lo 00:16:44

hemos configurado de otra forma siempre que hay que ir accediendo de un padre digamos que reconozca 00:16:51

o que hemos guardado como variable como punto de partida y luego podemos ir llegando a los hijos 00:16:56

esto que quiere decir que si hemos generado y les comento esto que tengo aquí si hemos generado un 00:17:02

game object que llamamos instancia vale que será esa instancia que hemos generado luego podremos 00:17:09

acceder esto también es ir sabiendo poco a poco más y más herramientas podemos acceder por ejemplo 00:17:14

al nombre de esa instancia eso qué significa que si decimos vale aparte de guardar esta instancia 00:17:22

con el nombre de instancia yo quiero que esta instancia tenga el nombre vale el nombre del 00:17:27

objeto del game object y que se llame hola vale voy a probar a ejecutarlo y ahora vemos útil 00:17:33

esta línea si yo arranco este este juego vais a ver bueno lo primero que algo se cae porque le puse 00:17:39

el rigidbody vale ya veis que al meter un componente está haciendo algo pero lo importante la nave ahora 00:17:50

no se llama clon como se llamaba antes ahora se llama hola y aquí está dentro todo lo de la 00:17:55

nave el prefab que habíamos ejecutado vale fijaos y esto me sirve para ir introduciendo que las 00:17:59

variables se pueden ir creando en muchos sitios que aquí he puesto varias juntas y si por ejemplo 00:18:05

examináis que esto también lo iremos viendo el script de la unidad 0 de la tarea que os he dejado 00:18:10

como referencia habrá variables que se van generando al principio para tenerlas todas digamos 00:18:16

usables a lo largo de todo el proyecto pero también en momentos nos puede interesar que 00:18:21

esa variable se cree al empezar el juego vale en este momento se crea esta instancia de tipo 00:18:25

gameobject y aquí hemos generado una instancia que ojo todavía no hemos resuelto qué diferencia 00:18:30

hay entre esto y esto porque no hemos asignado nada de referencia bueno está ahí preparado 00:18:36

pero no lo hemos llegado a hacer a ver que detengo esto vale y aquí está esperando a que 00:18:40

sigamos trabajando vale ahora sí que está cogiendo una referencia ahora usamos a conveniencia lo que 00:18:50

queramos pero lo importante es que una vez guardamos una instancia de tipo gameobject 00:18:56

también podemos acceder a las propiedades de ese gameobject como acabamos de hacer aquí vale 00:19:01

entonces vamos a hacer un poco la lógica que pone aquí que tiene usar esta sobrecarga de 00:19:06

instancia que es que crea una instancia la posición del objeto de referencia que es este 00:19:13

segundo que tenemos aquí vale y como hijo suyo es decir de este de esta referencia vale todo 00:19:17

esto yo me lo sé aparte de porque ya lo usa más veces porque os vuelvo a repetir que si vamos 00:19:24

pasando por las sobrecargas que en este caso es esta la que estamos usando vale nos pide un 00:19:28

gameobject aquí lo pone como object cuando pone object significa gameobject vale es otra forma 00:19:36

de llamarlo y bueno si luego bueno es que no quiero liar mal la madeja necesita un objeto que 00:19:40

es el que va a referenciar y luego un transporte va a ser ese padre pone clona el objeto existente 00:19:47

y retorna el clon si quisiéramos saber más esto ya lo comenté el otro día saber más de qué hace 00:19:52

cada método la buena forma de hacerlo es meternos en el API vale en el manual de uso del código 00:20:00

en el propio desde el propio google se puede hacer si ponemos el método o la propiedad que 00:20:09

queramos consultar y ponemos unity después lo primero que va a poner va a ser digamos el acceso 00:20:16

no al a cómo se usa este este elemento o este método aquí veis que vienen ya varias sobrecargas 00:20:25

no y si vamos pasando aquí pone object original vale que aquí es lo mismo que ponía en el intel 00:20:33

y sens que hemos visto antes en el código y aquí sí que podemos ir más con detalle por si tenemos 00:20:40

dudas ir viendo qué significa cada cosa pues oye es algo de tipo objeto de gameobject no podemos 00:20:44

meterle otra cosa quiere un gameobject aquí y en original es el nombre que le ha dado esta variable 00:20:49

digamos a este parámetro que está esperando que hagamos algo con él vale y aquí si bajamos en 00:20:55

los parámetros nos dice vale lo que yo ponga como original que es en todas estos en esta posición 00:21:01

de los parámetros dice un objeto existente que del que quieras hacer una copia vale pues ya sabemos 00:21:05

que aquí habría que meter ese objeto que queremos copiar vale cuando pone paren pues podemos ir a 00:21:11

paren padre que será asignado al nuevo objeto vale pues aquí meteremos un transform vale y ese 00:21:17

será padre en este caso podemos hacer igual con más tipos para que vayáis viendo cómo se usa aquí 00:21:24

os puede ir diciendo más pues más digamos características de en este caso instantiate 00:21:30

y si vais bajando incluso podréis ir viendo ejemplos vale el problema de los ejemplos igual 00:21:37

a estas alturas es que son siempre más avanzados pero a medida que vayáis teniendo más bagaje 00:21:42

iréis entendiendo más todos los ejemplos fijaos que luego incluso instantiate bueno yo lo he hecho 00:21:48

así un poco a las bravas pero incluso fijaos que instantiate si lo vuelvo a declarar aquí tiene 00:21:53

más tipos vale con estas llavecitas que se abren aquí y si me pongo encima pues no da muchas 00:21:59

descripciones y en ese caso para desambiguar para saber qué significa pues tendríamos que meternos 00:22:05

nuevamente en el manual o en la API vale aquí más abajo pues están las declaraciones de este estático 00:22:10

vale que es es diferente vale en vez de un objeto tiene una referencia de tipo bueno esto ahora mismo 00:22:18

nos da un poco igual pero sí sí que me sirve para que vayáis viendo que las sobrecargas se pueden 00:22:25

ir como entendiendo mejor si vamos viendo este este manual vale y luego importante aquí arriba 00:22:31

en la documentación de unity que es a donde va a referenciar si ponéis el la propiedad del parámetro 00:22:37

la función seguido de unity en google podéis acceder al API que es donde os va a decir el 00:22:42

uso digamos a nivel de programación vale como estamos haciendo ahora mismo y también al manual 00:22:48

vale al manual los bueno es el manual del programa para acceder al manual de esta operación vale en 00:22:53

vez de hacerlo desde aquí pues se puede cambiar a manual no que si tiene una sección en el manual 00:23:00

digamos de del propio programa pues os puede contar una descripción que no está tan basada 00:23:04

en el código sino del uso tal cual esto lamentablemente no suele estar en español vale igual 00:23:09

que el software en sí en unity no está en español pero bueno con poco a poco en inglés es bastante 00:23:15

técnico pero bueno se puede ir traduciendo y veis que aquí un poco ya va explicando qué hace 00:23:22

nuevamente estas explicaciones a veces pueden pecar un poco de muy técnicas en el momento que 00:23:26

nos encontramos pero sí que nos puede dar ciertas pistas vale a lo mejor hay líneas que empieza a 00:23:32

hablar de herencia de bueno behavior bueno pues esto no sé si seguimos seguramente algo iremos 00:23:37

pillando y poco a poco podremos seguir avanzando vale que me importaba ver un poco pues qué qué 00:23:42

significan estos nombres que aparecen bajo original position veis en la sobrecarga pone 00:23:49

original pues original es un nombre que sirve de referencia para luego ver en el lab en la 00:23:55

api qué significa o qué te está pidiendo en cada momento vale vuelvo aquí 00:24:00

vale qué tal hasta aquí más o menos me vais siguiendo doy vueltas que poco a poco se irán 00:24:07

completando vale que de primera son muy complicado explicar todo más o menos me seguís 00:24:13

más o menos vale vamos a quedarnos con lo más mundano de todo esto vale que es que estamos 00:24:25

generando una variable de tipo game object y dentro de esa caja vale llamada instancia 00:24:32

si esto claro bueno me está diciendo un compañero que es un poco complicado acordarse de todo esto 00:24:39

lo dije el primer día va a ser un constante una constante iteración va a haber que ir volviendo 00:24:45

todo el rato a lo mismo e ir machacándolo no es importante no sé si lo estáis haciendo leer bien 00:24:51

los temas e ir intentando hacer las tareas poco a poco pues no acordarse es digamos ir teniendo 00:24:57

conciencia de cómo era pero una vez vamos usando las cosas varias veces y ya os digo con el uso de 00:25:03

la app y de la inteligencia por eso soy tan pesado digamos con ir entendiendo cómo cuando escribimos 00:25:09

algo aquí pues qué significa no si ponemos invoke pues yo a lo mejor no sé qué es invoke pero me 00:25:14

suena que algo se usaba y aquí podemos ir sabiendo cuando es un método podemos ir sabiendo qué cosas 00:25:21

son deduciéndolo o metiéndonos en la api y poco a poco iremos salvando todo ya veréis vale si 00:25:27

seguimos viendo esto nos falta decirle cuál es la referencia de este prefab vale y la referencia que 00:25:35

nosotros queramos aquí la tenemos preparada la variable para usarla pero todavía no lo estamos 00:25:41

haciendo bien porque aquí os lo he puesto como ejemplo la voy a quitar vale si dais a este 00:25:46

circulito podéis decirle que no creen ninguna que es como estaba y claro yo lo que voy a querer en 00:25:53

cierto momento es usar las capacidades que me está dando ese esa sobrecarga de instantiate para 00:25:58

decirle yo el punto en el que quiero que se instancia no quiero que existancia a lo mejor 00:26:05

en el 0 0 0 vale sino que yo quiero que se instancie donde punto vale estoy generando un 00:26:08

gameobject vacío recordad que igual que se puede generar estos cubos y estos elementos con los que 00:26:15

habéis hecho el prefab de la nave puede generar un vacío un empty que es como los nulos en los 00:26:20

software de 3d que sirve simplemente para tener una referencia de la espacia no contiene nada 00:26:26

más allá de una referencia del espacio y lo voy a llamar el borro este que genera 2 en el proceso 00:26:30

voy a llamar punto referencia para saber bien qué es ese y ojo que cuando generamos un nuevo 00:26:37

entiendo cualquier elemento puede no estar ubicado en el 0 0 que de partida no me gustaría no lo pone 00:26:43

en el centro del visor donde estamos mirando vale ojo que suelen ir ya a las posiciones modificadas 00:26:50

si queremos colocar algo en origen en el 0 0 en los tres puntos de ese componente si le vamos a 00:26:57

reset se colocará y vale vale esto lo he hecho un poco para que veáis el punto de partida pero 00:27:04

ahora lo que puedo hacer es decir no yo quiero que este elemento la nave se instancie en él y lo voy 00:27:10

a meter a mano menos 40 y en y 10 vale porque es donde yo quiero que comience si ya acepta incluso 00:27:17

vamos a ponerle un 15 el punto que sea está un poco igual esto lo que nos va a permitir es que 00:27:26

luego cuando nosotros digamos que este gameobject punto de referencia vale y sin teniendo aquí abierta 00:27:32

está en el inspector de donde tenemos el código las variables preparadas arrastramos ese objeto 00:27:39

vale lo que va a hacer es coger el transform de este punto referencia que nosotros hemos ubicado 00:27:45

donde queremos que esté vale entonces ahora mismo ya tenemos preparada una referencia que se coge con 00:27:50

esta variable referencia y que nosotros usamos aquí como segundo parámetro vale de del instant 00:27:57

seat si yo ahora ejecuto el juego va a hacer dos cosas como bien dice aquí crea una estancia la 00:28:06

posición del objeto de referencia está los puntos en esta ubicación que acabamos de poner y como hijo 00:28:11

suyo además tiene una pequeña sutileza entonces yo cuando ahora arranque el juego vais a ver 00:28:17

que esa nave primero se ha colocado si recordáis en este punto donde está punto referencia y además 00:28:23

se ha hecho su hijo vale se llama hola porque en el código hemos dicho que la instancia que el nombre 00:28:32

de esa instancia sea hola vale entonces vez que no es lo mismo tener activo este esta instanciación 00:28:39

bien referenciado todo que simplemente generar instancia a secas vale esto me sirve para que 00:28:48

poco a poco vaya viviendo que la que hay dentro de estos paréntesis en un método vale pues influye 00:28:54

un método o una función que son lo mismo ya comenté el otro día que son digamos operaciones 00:29:04

de acción de algo que ocurre en este caso vamos a instanciar en este caso esto es otro método 00:29:11

que sirve para marcar que va a ocurrir al empezar el juego o al iniciarse este script no recordad 00:29:16

que era cuando el objeto se iniciaba y si veis cuando hay un método tiene pues el nombre de 00:29:23

esa acción que va a hacer y siempre va a ir a continuación un paréntesis vale a veces vacío 00:29:29

a veces lleno pero cuando vemos una palabra que está escrita en mayúsculas la primera letra y 00:29:36

luego tiene paréntesis eso significa que estamos usando lo que se llama un método función es decir 00:29:42

una acción que vamos a hacer vale que no es lo mismo que si yo pongo transform position igual a 00:29:47

referencia vale que esto básicamente a ver reference position había que poner 00:29:57

vale esto ya os explicaré un poco más que es vale pero al final no es lo mismo decir oye 00:30:04

instanciate aquí y tal cosa que en esta línea que no vemos ni un solo paréntesis esto significa 00:30:14

que aquí no hay ningún método los paréntesis pueden indicar más cosas pero lo general son 00:30:19

métodos o funciones vale ahora volveremos otra vez a los métodos entonces ya simplemente por 00:30:25

terminar este esta aplicación como de las sobrecargas de las sobrecargas que puede tener 00:30:32

instanciate y a ver un segundo que esto esté vale tenemos una tercera forma de instanciar vale 00:30:38

comentó todo menos esta última que yo sé que es y borro todo lo relacionado con con los comentarios 00:30:46

que es que crea una instancia en el punto de referencia pero sin rotación vale vale aquí si 00:30:55

os fijáis tenemos tres elementos y es igual que el anterior en el sentido de que primero el primero 00:31:02

de ellos es el prefab vale y voy a ir a la API un segundo de instanciate que la tenía por aquí 00:31:08

abierta si no me equivoco aquí está vale esta es la primera que hemos usado esta es la segunda y 00:31:15

ahora vamos a ir a esta tercera vale esta no la saltamos porque tampoco aporta mucho pero aquí 00:31:21

básicamente nos pide vale un objeto ahora el segundo parámetro aunque es parecido es una 00:31:27

posición vale y de tipo vector 3 esto es verdad que todavía no lo hemos visto lo veréis a partir 00:31:36

de mañana que abro un nuevo tema vale como está anunciado y luego la rotación está ahora mismo 00:31:42

es un poco enrevesado y por eso no voy a meterme mucho volvemos a ello si queréis más adelante 00:31:48

pero esta sobrecarga al final lo que me está pidiendo son otro tipo de valores entonces si 00:31:53

os fijáis incluso aquí cuando vemos esta referencia aquí no me está pidiendo un transform un transform 00:32:00

completo como como si que hacía en la otra sobrecarga vale aquí me pedía el transform completo 00:32:09

del objeto que iba a ser el padre aquí me pide sólo la posición vale entonces quiero que vayáis 00:32:16

también teniendo en la cabeza que ciertos parámetros tienen más parámetros dentro como hemos dicho 00:32:21

antes que podemos ir abriendo con punto porque he pensado una cosa si me está pidiendo la posición 00:32:29

de un elemento y yo tengo un transform en referencia no yo al final lo que estoy haciendo es en este 00:32:34

transform vale estoy cogiendo todo lo que hay en este componente la posición la rotación y la 00:32:41

escala que al final son tres valores de la posición tres valores de la rotación y tres valores de la 00:32:47

escala verdad entonces cuando me piden sólo la posición vais a ver que al final lo que estoy 00:32:52

haciendo aquí es decirle vale de este transform que yo he llamado reference vale sólo voy a 00:32:59

coger la posición porque si intento meter todo esto me da fallo porque está en dice vale no sé 00:33:04

que de todo lo que tiene dentro en la posición o en la rotación pues yo que sé la 00:33:11

pues si yo pongo aquí rotation veis que puedo meter la rotación vale me da fallo también por 00:33:19

otras sutilezas pero si es porque habría que ponerlo en ángulo cellular básicamente que es 00:33:24

una cosa que ya veremos en este tema vale pero veis que a medida que yo le voy dando la instrucción 00:33:30

correcta esto me puede dar que algo se puede ejecutar o no vale sutilezas que a veces hay 00:33:36

que ir pensando qué valores estoy guardando en este transform pues estoy guardando en los de 00:33:42

posición los de rotación los de escala y aquí sólo me pide posición vale y luego aquí bueno me pide 00:33:47

la rotación que esto sí que es verdad que más avanzado entonces no me voy a meter mucho pero 00:33:53

aquí básicamente con esta instrucción estoy diciéndole cógeme la rotación que tenga por defecto 00:33:56

el objeto vale entonces yo cuando usé esta forma de este método de instanciación vais a ver que a 00:34:03

diferencia de antes cuando yo lo generó me lo genera la posición pero ahora no es hijo de nada 00:34:12

no es hijo de el punto de referencia como ocurría antes vale que lo usaba como padre e igualmente 00:34:18

como no estoy poniendo que esta instancia sea una caja a la que yo puedo cambiar el nombre pues no 00:34:24

se llama hola se llama pues nave prefab clon que es el nombre genérico que ha cogido de del objeto 00:34:29

cuando le hemos metido aquí el objeto como se llama nave prefab pues dice vale por de nave prefab 00:34:36

he hecho un clon ya está vale sé que esto os sonará complicado pero quiero que vayáis viendo un poco 00:34:41

en la forma de funcionar de los métodos vale también porque lisa me ha preguntado algo sobre 00:34:47

la tarea y un poco para completar esto de la tarea ahora voy a volver a cosas más básicas 00:34:51

digamos del tema cero pero hasta aquí más o menos me vais siguiendo más o menos más o menos vale yo 00:34:57

entiendo que ahora mismo os digo acepta el cosa y no la sabéis hacer pero si me interesa vamos más 00:35:04

allá de lo que se pedía la tarea que eso entiendo que sí pero digamos hacerlo de más formas es lo 00:35:10

que poco a poco quiero que vayáis entendiendo vale porque esto se irá complicando progresivamente 00:35:15

vale para aquellos que lo bueno y para vosotros también para aquellos que lo estáis viendo en 00:35:20

diferido y para vosotros mismos os vuelvo a sugerir y nunca serán pocas veces que os diga 00:35:25

que vayáis leyendo los temas según se van lanzando y vayáis intentando hacer las tareas sino cada vez 00:35:31

se va a volver todo más complicado de coger el ritmo vale y dudas que tengáis pues me las vais 00:35:36

diciendo vale hasta aquí un poco lo relacionado con instantiate vale cuando ya vais entendiendo 00:35:42

cómo se usan más métodos pues instantiate lo iréis entendiendo mucho mejor vale voy a otro 00:35:50

archivo que tengo aquí preparado para ir al tema cero que es el que me interesa en esta 00:35:55

tutoría si no tenéis más dudas de la tarea del tema 1 no sé si ya la habéis realizado si la 00:35:59

habéis entregado todavía no yo digo hasta el domingo si no me equivoco no no voy a ir viendo 00:36:09

quién la entrega y quién no que es cuando cierro vale perfecto daniel estás en ello pues pues pues 00:36:14

ánimo yo creo que con los vídeos y siguiendo pues pues podéis ir haciéndolo vale vamos al tema 00:36:20

voy a guardar vale recordado esta estrella está esta pequeña estrella y voy a ello vale 00:36:32

tengo aquí otro script que simplemente va a servir para para practicar ahora no va a tener 00:36:41

como hemos hecho ahora en instantiate que se vea un resultado claro en el visor pero me sirve para 00:36:48

que vayamos entendiendo mejor qué tipos de variables existen y usos y aplicaciones que se 00:36:54

pueden hacer de momento quizá un poco abstractas en el sentido de pues solo estamos viendo sumas y 00:36:58

restas pero luego es que esas sumas y restas como dije el otro día puede ser como sube y baja el 00:37:03

número de puntos que tiene un contador vale y se va a basar un poco en lo mismo entonces recordar 00:37:08

a ver que creo que alguien se ha metido perdona os ha salido no lo sé vale recordad cómo se generaba 00:37:15

un script que es lo voy a hacer en esta carpeta de script que tengo aquí preparada de durante la 00:37:24

tutoría pues yo hago mis este script no recordad que en este cesar script podemos generar un script 00:37:29

que vamos a llamar durante recordad que el nombre que vayamos asignando aquí luego debe ser el mismo 00:37:37

de la clase de dentro del script esto ya lo he dicho como en dos tutorías previas por tanto entiendo 00:37:45

que no habrá problema y además en el tema 0 va poniendo buenas prácticas de cómo escribir 00:37:50

las los nombres de los scripts los nombres de las de los métodos de las variables vale y habla de 00:37:56

una cosa que es el pascal case y el camel case vale cuando generamos una clase o lo que es lo 00:38:06

mismo generamos en dentro de unity un script siempre vale lo digo porque luego nos va a ayudar 00:38:14

a que todo sea más fácil de ir siguiendo siempre deberíamos empezar a escribir el nombre del script 00:38:21

con mayúscula vale y a diferencia de nuestro lenguaje del día a día los espacios no existen 00:38:27

o no se usan correctamente vale cuando estamos escribiendo órdenes si os fijáis todo lo que 00:38:35

os he ido enseñando antes no había espacios o práctica había muy pocos ahora hasta que no 00:38:39

termine escribir esto no quiero volver a enseñaros en script pero vais a ver que normalmente se 00:38:44

escriben las palabras juntas y cómo se distingue que una palabra pues es la pues hay un espacio 00:38:50

entre ellos en vez de dar al típico espacio que hacemos con la barra espaciadora lo que hacemos 00:38:58

es empezar la siguiente palabra con mayúscula durante la tutoría importante lo que son tildes 00:39:03

y éñes no las uséis nunca en nada relacionado con programación me explico incluso aunque esto 00:39:10

sea el nombre de un script recordad que vale guardo y se genera que cuando yo genero esta 00:39:18

script al final estoy realizando un código cuya nombre el cuyo nombre de clase también está dentro 00:39:23

del código si yo empiezo a poner tildes esto va a empezar a dar ciertos problemas vale y aunque 00:39:29

ahora parezca lo mejor que no lo da tarde o temprano lo va a dar igual sucede si ponemos una 00:39:34

ñ o si ponemos un signo que no esté reconocido vale que pueda haber algunos vale entonces atención 00:39:40

fijaos que siempre he escrito con la primera letra mayúscula en lo que se llama pascal que 00:39:48

es pascal fue un si no me acuerdo si no recuerdo mal un matemático y como es un nombre propio por 00:39:53

eso se llama así con mayúscula pascal que es que no es lo mismo si nos fijamos a lo que hemos estado 00:39:59

bueno y fijaos también que los métodos los de los paréntesis también van con mayúsculas es decir 00:40:04

instantiate existe con mayúsculas vale pero si yo me pongo a buscar los con minúscula no existe 00:40:09

firme sí que intenta ayudarme diciéndome que esto está mayúsculas pero vais a ver que yo cuando lo 00:40:16

ponga me lo ponen mayúsculas vale los métodos esas palabras que sirven para indicar que se ejecute 00:40:21

una acción que van con estos paréntesis siempre empiezan a escribirse con mayúsculas y lo mismo 00:40:28

si instantiate tuviera otra palabra sería instantiate double yo que sé pues no se separa no 00:40:32

se separa así porque esto significa hacer dos instrucciones distintas o otro tipo de orden 00:40:39

vale si es solo una orden llamada instantiate double no hay espacio en el medio se van separando 00:40:46

digamos marcando la diferencia la separación de palabras con esta mayúscula no que va separando 00:40:52

estas palabras del mismo modo si pongo el script que hemos estado viendo antes vale un segundo que 00:40:58

lo tengo por aquí en los preparados el de instantiate lo vuelvo a abrir si quiere 00:41:03

a ver que le está costando un poquito 00:41:10

y no sé por qué aquí está instantiate vale aquí lo estamos viendo si os fijáis ojo las clases y os 00:41:19

recuerdo que siempre digo que esto es una clase luego el nombre que le ponemos al script es una 00:41:29

clase y estos son clases que os recuerdo que si le dais con la letra control os podéis meter vale 00:41:33

esto es simplemente curiosidad y podéis ver todo el código que digamos ya alguien ha preparado para 00:41:39

que nosotros podamos usarlo vale vuelvo aquí entonces cuando generamos clases fijaos cómo 00:41:43

es la gramática de esta declaración del tipo de variable que es una clase no como hemos dicho 00:41:49

antes una g mayúscula y para separar mayúscula no y luego aquí hay un espacio que si yo no pusiera 00:41:54

significa que es todo la misma palabra vale y daría fallo porque significa otra cosa cuidado 00:42:01

los espacios se usan se deben usar cuando se deben usar y las variables vale por convención se escriben 00:42:06

del mismo modo pero empezando en minúscula vale igual que instantiate va con mayúscula fijaos 00:42:14

que may prefab cuando lo hemos declarado aquí al principio va con minúscula vale igual cuando 00:42:19

queramos separar veis que el may bien porque es el nombre que le hemos dado a GameObject pero 00:42:25

este prefab aquí no pinta nada para que lo interprete como el nombre de la caja aunque sean 00:42:31

dos palabras distintas empieza con minúscula y para separar las palabras hay que poner una 00:42:35

mayúscula aquí y os lo dije el otro día y si no os habéis dado cuenta fijaos si está preparado 00:42:40

esto que aunque no dejemos esos espacios el propio el propio unity ya va viendo dónde meter los 00:42:45

espacios aquí nos ha metido un espacio en donde en el nombre del script no lo había recordado o 00:42:53

incluso en el may prefab vale que es el nombre de la variable que hemos puesto la m si la ha 00:42:58

puesto en mayúsculas y ha puesto este espacio vale fijaos que el propio software sabe interpretarlo 00:43:04

entonces nosotros nos tenemos que hacer a la forma en la que tenemos que escribir el código 00:43:11

vale importante es decir recapitulando las clases barra porque lo mismo scripts siempre comenzando 00:43:14

con mayúsculas los métodos a medida que vayamos sabiendo cómo llamarlos o cómo crearlos también 00:43:21

en mayúsculas vale y lo que son las variables en minúsculas vale la diferencia de esto es que 00:43:29

esto es pascal que es porque empieza en mayúscula y esto es lo que se llama camel case lo de camel 00:43:37

porque aparece como la joroba de un camello vale esto también viene en los apuntes si os sirve 00:43:42

para acordaros pues camel case es cuando empieza en minúscula pascal que es cuando es un nombre 00:43:47

propio vale vamos un poco con durante la tutoría que son digamos operaciones más básicas para ir 00:43:51

viendo el tema cero el tema cero de vosotros todos lo habéis echado un vistazo ya al tema cero 00:44:00

sí vale qué tal os parecerá bastante árido entiendo 00:44:08

a ver que si mucho un poco sí pero despacio exacto daniel lo ha dicho un poco sí es árido 00:44:12

yo os aseguro que cuando hubiera entrado a dar este curso a recibir este curso si fuera alumno 00:44:22

lo hubiera leído no me hubiera enterado de mucho vale la cosa es eso poco a poco vale y para eso 00:44:28

estoy yo aquí y para eso está que lo podemos leer varias veces que eso también es muy importante por 00:44:34

eso os digo siempre que este tema cero es transversal al curso vale porque es algo que 00:44:38

iremos entendiendo poco a poco vale bueno tenéis aquí dos secciones primeras que 00:44:42

en plan me he centrado más las demás lecciones bueno realmente sólo hay otra más las demás no 00:44:50

en la otra elección no pero si era el objetivo que primero vierais la ut1 vale que entendierais 00:44:56

un poco pues cómo se navega por la interfaz de unity qué partes tiene cómo se genera un script 00:45:04

pues escribir vuestro primer script hacer vuestro primer prefab oye son bastantes cosas y ya vais 00:45:10

aunque aunque a lo mejor todavía no se es consciente ya poniendo un juego ciertas cosas 00:45:15

de aquí vale pero ya os digo iremos pasando por todo esto para ir viendo más pormenorizadamente 00:45:20

que es mañana ya os digo mañana se abre el tema 2 por favor y poniéndoos con él ya según lo vaya 00:45:24

abriendo vale cuanto antes nos pongamos antes tendremos duda y antes podremos ir avanzando que 00:45:31

es como se supone que hay que hacer el curso vale sobre las variables el otro día estuvimos ya 00:45:37

hablando bastante y de hecho aquí volvemos a hablar de hecho lo de camel case está aquí puesto que hay 00:45:43

que darle un nombre vale a la variable que cada uno puede tener un tipo de valor que es lo que 00:45:48

el otro día estuvimos hablando que eran los ins los floats los strings las cadenas recordáis esto 00:45:53

ya lo hemos visto más o menos hasta aquí lo tenemos doy un repaso rápido o lo sabemos lo que 00:46:00

es cada cosa hemos visto incluso ya tipos de variables de tipo clase no como este game object 00:46:08

o este transform en el que guardábamos la referencia que cogíamos por el inspector en el serialize 00:46:14

field si por ejemplo imaginaos que yo en el código vale aquí justo dentro de la clase recordad que 00:46:19

las llaves delimitan que hay dentro de cada uno de los apartados del código vale y las clases vale 00:46:29

cuando empezamos una clase vamos generando estas variables como he dicho antes que luego podrán 00:46:39

ser usadas dentro de todo este bloque vale cuando vamos trabajando en un lenguaje como cesar vale 00:46:45

al final existe un proceso bueno una lógica que es el encapsulamiento vale el encapsulamiento 00:46:53

significa que dentro de estas llaves vale de cada uno de los bloques de ésta o de ésta que es otro 00:47:00

bloque o de éste que es otro bloque podemos ir usando variables que queremos nos puede interesar 00:47:05

que sólo existan dentro de este bloque o que existan este bloque y por defecto pues también 00:47:11

existen los de dentro vale el encapsulamiento sirve para que digamos partes del código se 00:47:16

puedan comunicar entre sí o no vale esto también lo iremos viendo pero este concepto de encapsulamiento 00:47:22

si a alguien le interesa existe y ya me sirve para explicar eso que cuando tenemos una clase 00:47:26

que es donde vamos generando todas las instrucciones que hay dentro de este script pues ya vamos a lo 00:47:32

mejor haciendo variables y esto es el script de el movimiento del jugador vale imaginaos que fuera 00:47:36

esta la función de este script que luego meteremos como componente al GameObject del jugador no 00:47:43

pues ese jugador a lo mejor vamos a querer que tenga una vida inicial no y creo que esa vida 00:47:49

inicial sea de 100 puntos imaginaos vale esto veis que yo por defecto si pongo un 100 no sirve para 00:47:56

nada me da falla 100 que no sabe que es incluso cuando empieza el juego yo puedo decir aquí 100 00:48:03

y punto y coma vale pero me va a decir 100 que no tenéis que ir entendiendo que es que los números 00:48:11

y los datos no existen en el código no son operativos hasta que no se encierran en una 00:48:19

variable que es lo que ya vimos el otro día si queremos generar una variable de la vida del 00:48:25

personaje que guarde un valor 100 que habría que generar o cómo sería que esto del otro día un poco vimos 00:48:30

una variable no vale y cómo dime un poco que cómo la generó pues pones y nt vale y nt ahora 00:48:41

vemos vale espacio vale vida muy bien vida igual a 100 y punto y coma vale mira que me digas esto 00:48:50

así significa que ya se ha aprendido cómo se declara una variable muy bien aprendido así que 00:48:59

vamos a ello porque ha sido int y no float o string otra cosa porque es un número entero vale 00:49:03

entonces también esto habría que ver el juego pero la vida normalmente si tiene un valor como 100 que 00:49:10

es el máximo acabo de decir y vamos a decir ya por defecto que la muerte es que llega al 0 vale 00:49:17

pues normalmente en un contador de eso no va a ir tan fino como ir a decimales entonces para no 00:49:24

complicar al programa pues no declaramos un float que si no recordamos si para refrescar 00:49:28

un float era un parámetro una variable perdonad con decimales vale imaginaos que quisiera guardar 00:49:34

una con decimales y en ese caso pues podríamos decir cosas como 5 con 5 no vale esto lo recordamos 00:49:41

del otro día que la f sirve para indicar que este punto al final es el separador de los decimales y 00:49:48

si no lo ponemos o ponemos una coma veis que ya empieza a dar errores o si no ponemos el punto 00:49:54

también el efe también empieza a dar errores vale la sintaxis hay que aprenderla entonces tenemos 00:50:01

aquí una variable que es vida 100 y esto significa que en este script ya podremos ir en cualquier 00:50:06

momento e ir diciendo que la vida cuando arranca el juego la vida del personaje es 100 vale y veis 00:50:12

que yo tengo esta vida y es verdad que cuando generamos una declaramos una variable que es 00:50:20

darle una forma a la caja y un nombre vale también la inicializamos o podemos decir vale que la vida 00:50:25

cuando arranque el juego dentro de esa caja al empezar vale tenga un 100 no que esto lo vimos 00:50:33

el otro día también ahora es verdad vale que hemos guardado este dato pero como es aquí en este estar 00:50:40

al empezar pero como el dato está declarado aquí arriba todos los cambios que vayamos haciendo vale 00:50:48

se estarán guardando en la caja que está aquí arriba eso que significa que antes os he hablado 00:50:54

de que existían bloques para ir pues declarando las variables incluso usándolas no porque os he 00:50:59

dicho también antes cuando hemos visto lo de la instancia que guardamos como variable que se puede 00:51:06

generar incluso una instancia dentro de un estar de un método no de un momento de acción yo puedo 00:51:12

decir vale esta variable vida se genera aquí con un valor de 100 vale y luego decir vale y en el 00:51:18

update que vida pase a llamarse en pase a valer 500 vale porque cuando el primer frame queremos 00:51:24

que sea 100 pero ya los siguientes 500 veis que aquí vida da un fallo vale y esto es simple ya 00:51:31

alguien me sabría decir el por qué a ver si eso más o menos vamos se explica en el tema 0 pero oye 00:51:37

si no lo explico yo pero oye que igual hay alguien que 00:51:49

nadie nadie adivina vale os he dicho antes que existía este encapsulamiento que servía para ir 00:51:54

digamos generando bloques fijaos que cuando yo genero la caja barra la variable le pongo el tipo 00:52:01

de variable que es y yo he generado esta caja aquí en el start y esto es un bloque vale a diferencia 00:52:08

de cuando lo generamos a la clase que veis que comprende todo aquí sólo comprende esto por tanto 00:52:14

cuando llamamos a esta variable en otro punto que no es de su bloque pues no existe vale aquí 00:52:19

podríamos incluso generar otra variable llamada vida que es una vida diferente a esta son dos 00:52:24

variables distintas vale esto no es lo mismo que lo que habíamos hecho antes de decir vale yo genero 00:52:31

declaro esta variable aquí arriba y ahora existe digamos esta caja preparada en todo este ámbito 00:52:37

y aquí es donde digo vale vida 100 y aquí pues el 100 se está guardando aquí arriba es decir este 00:52:44

100 se está guardando en todo este tránsito si yo aquí por ejemplo dijera voy a enseñar por 00:52:51

consola esto ya lo vimos otro día que es el debug log voy a querer que me vaya en cada fotograma 00:52:58

enseñando lo que vale vida y veis que no me da ningún fallo me está enseñando vida que está aquí 00:53:05

creada la caja y la he cargado con un valor aquí vale es verdad que en este ámbito donde he dicho 00:53:10

que vale 100 vale y vais a ver que lo que me va a mostrar el 100 que este valor de 100 00:53:16

lo he generado aquí y este 100 ya está fuera del bloque pero es que la caja donde está guardando 00:53:23

los valores si está fuera y sí que está en la cápsula digamos en el bloque que luego permite 00:53:29

que se comunique con una inferior que es el update no si yo ahora ejecuto esta instrucción 00:53:34

lo primero es que probablemente de fallo pase algo raro yo voy a la consola y no 00:53:40

veo ni 100 ni cero ni nada porque a ver quién me lo sabe responder 00:53:47

esto si habéis hecho la tarea 1 deberíais saberlo no has asignado el código no efectivamente no hay 00:53:56

ningún objeto dentro del juego ni le hemos dicho de otra forma que se ejecute no hay ningún objeto 00:54:02

en el juego que tenga este script por tanto el script no se está ejecutando es decir no hay 00:54:08

ningún momento start de nada en donde se ejecute esto no entonces pues en punto referencia me da 00:54:12

igual porque sólo van a ser números vale voy a asignar este durante la tutoría como componente 00:54:20

vale a ver he guardado recordad que hay que guardar el script ahí está y ahora lanza el 00:54:27

juego a ver y ahora sí que cada fotograma está generando un 100 y se van sumando hasta que llegue 00:54:33

a 1000 que ya no sea más pero aquí son 100 100 100 vale entendéis que al final lo que estamos 00:54:39

consiguiendo es cambiar las variables en distintos puntos del código esto es importante entenderlo 00:54:45

porque es lo que os he dicho antes si yo genero aquí la caja y aquí no existiera y guardo la 00:54:51

caja aquí al final vida no existe para el update porque está fuera del ámbito donde se ha generado 00:54:56

esta caja vale esto también es por algo que se llama los ámbitos que voy un algunos pasos más 00:55:02

adelante dentro del tema 0 aquí se habla de los ámbitos de las variables y habla un poquito de 00:55:10

estas bueno pues de estos bloques y de estos ámbitos y un poco también de lo que os estoy 00:55:15

comentando aquí vale igual está sintax este código es un poco más avanzado por eso lo estoy 00:55:21

simplificando pero básicamente de lo que habla es que están las variables globales que se declaran 00:55:26

al comienzo y están disponibles en todo el script incluso dentro de las funciones como sería el 00:55:31

estar y el update y aquí saludar vale y luego las locales perdón que se declaran dentro de 00:55:35

una función y por eso sólo están disponibles dentro de ella vale por tanto para cuando más 00:55:41

adelante hablemos aquí he declarado una variable local porque está en un bloque muy concreto una 00:55:48

función y aquí las que se generan dentro de la clase son las variables que se llaman globales 00:55:55

es verdad que el otro día ya os deje caer también que cuando y voy a quitar esta variable global y 00:56:04

vuelve a dar este fallo no os dije que por defecto si una variable y bueno vuelvo al de instanciar 00:56:11

si una variable le ponemos sería el ice field es cuando conseguimos que podamos referenciar o 00:56:17

capturar cosas desde el inspector no que es lo que hemos hecho con el prefax que hemos arrastrado 00:56:23

vale y también nos dije otra forma de hacerlo que era poniendo delante la palabra public 00:56:27

pública vale vais a ver que yo cuando ponga public aquí 00:56:33

a ver si quiere 00:56:37

pero que algo he hecho y he abierto 00:56:43

el que está pasando 00:56:48

vale cuando también tengamos 00:56:52

no está bien en un segundo 00:57:00

cuando tengamos variables públicas aunque ahora me esté dando fallo vale ya veremos que esto no 00:57:02

sucede cuando lo hagamos en otros momentos voy a volver a declararla como variable global vale 00:57:07

cuando es pública significa que va a trascender vale ahora os digo el por qué sucede esto va a 00:57:13

trascender su propia cápsula e incluso en otros scripts distintos vale en otros en otras clases 00:57:19

que tengamos podremos acceder a esta variable vale esto es más avanzado pero me sirve para 00:57:25

entender que por defecto si no pone nada aquí como hemos tenido hasta ahora como me ha dicho el 00:57:30

isa las variables son privadas vale es lo mismo poner esto de private que no poner nada vale 00:57:35

porque se entiende que una variable que no declaramos su ámbito es privada cuando es privada 00:57:42

es cuando ocurre esto que os estoy diciendo de que pues se encierra digamos la cápsula 00:57:48

y sólo se puede referenciar a esta variable en su bloque vale cuando la ponemos en pública 00:57:53

además unity tiene la aparte de permitir que en otros scripts podamos acceder vale si yo ahora 00:57:58

mismo por ejemplo pusiera bueno es que es un poco avanzado esto ya lo veremos vale si pusiera un 00:58:08

acceso a esta clase podría acceder a variable con decimales desde otro punto no desde el 00:58:14

podría acceder a variable con decimales desde otro punto no desde otro código vale pero aparte 00:58:20

tiene la capacidad de que cuando guardamos y volvemos a unity vais a ver que ahora existe 00:58:25

esa variable igual que con el serialize fill vale que lo podemos aquí modificar venía por defecto 00:58:32

el 5 con 5 que está declarado aquí vale pero aquí lo podemos modificar si os fijáis vale está 00:58:37

preparada esto significa que no es lo mismo vale para que veáis y lees una cosa que no es lo mismo 00:58:43

poner serialize fill tipo in lo que sea y variable serializada también me sirve para que veáis cómo 00:58:49

voy escribiendo las variables es algo muy importante y la signo y le pongo un 5 con 8 00:59:02

porque es un float vale vais a ver que yo cuando bueno porque da fallo porque he intentado guardar 00:59:09

una variable float en un int vale entonces es igual es importante los tipos de variables cómo 00:59:17

los vamos gestionando cuando ahora vaya al al escribir tengo las dos variables veis que aquí 00:59:22

en apariencia hacen lo mismo pero si nos si aterrizamos aquí vemos que una es pública vale 00:59:30

y eso será accesible desde otras clases de hecho veis que la clase ya por defecto no la declara 00:59:37

pública también para que podamos comunicarnos con esta clase en otros puntos de del juego con 00:59:42

este script en otros puntos del juego en otros códigos pero ésta realmente al no poner nada 00:59:48

del ámbito vale en realidad privada no podremos acceder a esta variable desde otros puntos del 00:59:53

script vale de los scripts de este sí porque está dentro de su ámbito pero no podremos ir a otros 01:00:00

códigos que se llamen tal cual lo he hecho lo voy a hacer muy rápido vale aunque no entendamos 01:00:05

tampoco tengo el script durante la tutoría y el script instancia y prefab que he preparado antes 01:00:11

imaginaos que yo quiero cambiar desde instancia y prefab la variable variable con decimales por 01:00:16

lo primero que habrá que hacer igual que hemos hecho aquí vale es decir durante la tutoría y 01:00:24

veis que ahora voy a generar una variable que se ama igual que otro script y es que recordad al 01:00:30

final las clases vale como os he dicho aquí se corresponde con el nombre de los componentes y 01:00:37

cuando arrastramos un script como componente al final igual que existe transform pues existe 01:00:42

el componente durante la tutoría es una caja que podemos crear entonces por eso existe aquí una 01:00:48

caja y no da ningún fallo que se llama durante la tutoría y aquí lo puedo llamar como otro y en 01:00:54

minúscula porque es una variable vale otro script y aquí está preparado y yo en el transform 01:01:01

puedo decirle oye quiero que otro script vale acceder a sus propiedades y vais a ver que yo 01:01:06

a medida que me vaya metiendo en sus propiedades con el punto como estoy apelando aquí hay una 01:01:13

variable suya de durante la tutoría se llama variable con decimales pues vais a ver que yo 01:01:18

doy al punto aquí existe una variable llamada variable con decimales y yo puedo decir oye pues 01:01:24

esto quiero que valga 10 y aquí está cambiando el valor vale si yo guardo esto desde otro código 01:01:31

estoy cambiando el valor de este 5 con 5 vale y de hecho vais a ver cuando empiece el juego vale 01:01:39

que variable con decimales que por defecto debería ser 5 con 5 ahora como lo he cambiado pues está 01:01:48

cambiado cuando lo como ahora os explico otra cosa como lo he cambiado en él en el componente pues se 01:01:54

ha quedado con otro comportamiento pero yo cuando arranco el juego y pasa por ese start vais a ver 01:02:00

que vale a ver hazme caso claro lo he cambiado aquí un segundito tú tú tú tú variable con decimales 01:02:05

durante la tutoría instant si prefa vale y no se está ejecutando porque nuevamente este instant 01:02:13

si prefa ahora no está en ninguno de los objetos a por si sí que está a ver está en script retainer 01:02:20

vamos a hacer otra cosa porque no lo está cambiando en el editor pero sí que lo está cambiando 01:02:30

realmente si aquí decimos en el update borro esto que en vez de enseñarme la vida me enseña lo que 01:02:34

vale variable con decimales vale vais a ver que lo que pone cada fotograma es 10 y no el 5 con 5 01:02:42

que está ahí vale entonces vuelvo a ejecutar 01:02:48

5 con 5 pero bueno esto que está haciendo a ver un segundito 5 con 5 bla bla bla me enseña esto 01:02:54

vale 01:03:15

vale genial jesús 01:03:18

un segundo solo por probar si es esto hasta luego jesús 01:03:28

vale hay otro problema vale que es por lo que se usa el serialize fill en ocasiones que es que 01:03:34

cuando tenemos aquí un script que vamos cambiando el valor vale lo que vamos escribiendo aquí se 01:03:42

sobre impone a todo lo que vayamos cambiando entonces si aquí dejamos un valor ya puesto que 01:03:48

es diferente al que venía por defecto se sobre escribe esa vale de hecho veis que yo aquí pongo 01:03:55

33 con 2 y el que sale es 33 con 2 vale en ese caso habrá que ir operando de distinto modo porque 01:04:00

como está haciendo público lo está variando aquí pero bueno no así no debería no debería 01:04:10

pero porque esto en realidad lo estoy haciendo pero por porque veáis una cosa que no es ni 01:04:20

siquiera esto pero un segundo que ya es por saber que estoy haciendo yo 01:04:25

iba a ponerte entre 3 con 2 claro porque el ser que está sobre escribiendo vale este es el típico 01:04:30

problema que pasa cuando tenemos un public vale y al final lo que estamos haciendo es cambiar el 01:04:36

valor igual que hemos hecho con él con los valores de estos puntos vale lo estamos cambiando en él en 01:04:42

el editor que es que básicamente en el editor estamos marcando que tiene que hacer unity y 01:04:50

está sobreponiéndose a lo que hace el código lo que me importa de todo esto es simplemente que 01:04:55

veáis vale esto suele tener otro uso pero lo que me interesa es que veáis que variable serializada 01:04:59

como es private si yo voy aquí a durante la tutoría e intento acceder a cómo se llamaba igual 01:05:06

que he podido acceder a variable con decimales a variable será serializada otro script 01:05:13

vale no va a aparecer es decir no va a aparecer variable serializada e incluso aunque yo me ponga 01:05:20

a intentar escribir que valga 20 yo que sé me da fallo porque simplemente hay bueno ya sé por qué 01:05:26

no se está ejecutando no estaba guardando creo vale lo escribo bien en durante la tutoría yo 01:05:35

aunque tengo esta variable aquí serializada vale no me la coge porque porque es privada hasta que 01:05:42

yo no la haga pública yo no voy a poder acceder veis que ahora ya ha dejado de tener error esto 01:05:48

simplemente me sirve que lo mismo todavía no sabemos aplicarlo me sirve para que veáis que 01:05:54

las variables en ocasiones no se podrá acceder a ellas o no se podrá ver en el editor porque 01:05:59

bueno pues porque no tienen el ámbito el acceso al ámbito correcto vale voy me estoy enrevesando 01:06:05

mucho quizá con ciertas cosas y vamos a volver a donde nos hemos quedado con elisa pero lo que 01:06:14

me importa es que ya sabemos que cada bloque veis irá dando fallo o no según el ámbito que tenga 01:06:19

en donde se declara esta caja que no es lo mismo declararla aquí al comienzo de la clase que dentro 01:06:27

del estar por ejemplo vale luego tenemos aquí un int y algo aquí un float que es en vida y 01:06:32

yo que sé que es como los puntos que va a dar a la vida el power up cuando lo recojamos le voy 01:06:44

a poner que 50 recupera media vida no lo suyo sería que se hubiera más de 100 pues el power 01:06:50

up no te permitiera tener más de 100 pero vamos a obviar eso de momento vale lo que podemos hacer 01:06:56

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

esto pues signifique algo no pero lo mismo hasta que no lo metemos dentro de un contexto de una 01:07:07

caja vale no va a dar ningún resultado voy a poner vida actual y de actual que va a ser igual a la 01:07:12

vida más power up vale y esto da un problema ahora mismo he generado dentro de estar porque digamos 01:07:20

que sólo lo voy a ejecutar en el estar una variable llamada vida actual que da error vale 01:07:27

y porque pensáis que puede ser así rápido igual no caes pero porque podría ser que de error porque 01:07:34

realmente está bien configurado hemos hecho las cajas le hemos dado unos valores y estamos guardando 01:07:40

dentro de otra caja tipo int estos valores estos dos valores que el otro día ya vimos que se podía 01:07:45

operar de este modo porque pensáis que da falla si lo podéis 01:07:51

por los paréntesis qué paréntesis entre entre paréntesis vida más power up vale lo hago esto 01:08:00

en matemáticas los paréntesis es para dar el orden de ejecución de las operaciones pero aquí sería es 01:08:10

indistinto a hacer esto que esto vale me digo que ese no es el problema ya pero vaya que buen 01:08:16

intento me encanta que participéis por favor vale simplemente también para que lo veáis los tipos 01:08:21

de cajas cuando sumamos 100 más 50 da 150 y es un entero no pero es verdad que aunque sea un entero 01:08:26

esto lo hemos generado como un flow act es decir está esperando decimales y una vez tenemos decimales 01:08:35

en una operación como sucede en power up ya no podemos meterlo en un float en un in perdón hay que 01:08:41

meterlo en un flow por qué porque será susceptible a meter decimales porque pensad que si yo hubiera 01:08:47

puesto esto vale que podría ser aquí el link jamás va a saber qué meter en esta caja porque 01:08:53

se salen de su rango vale vais a ver que si yo pongo float el fallo deja de suceder vale importante 01:08:59

hay digamos tipos de variables más restrictivas que otras y esto por lógica en el caso de los 01:09:05

números por ejemplo es pues el que más flexibilidad va a tener pues es el que permite tanto tener 01:09:12

números enteros como decimales pero veis que el int no lo permite hay formas de resolver esto 01:09:17

cómo hacer conversiones pero bueno esto sí que es más avanzado lo usaremos más adelante cómo es 01:09:23

transformar un objeto en otro tipo de variable con esto poniendo entre paréntesis el tipo de 01:09:29

variable al que queremos convertir otra hemos dicho que el 50 con 5 bueno pues que como vamos 01:09:35

a operar y nos interesa por lo que sea que sea un int pues que lo convierta en un in redondeando 01:09:40

vale siempre redondea la baja en este caso pero estamos haciendo lo que se llama una conversión 01:09:45

explícita vale estamos diciéndole cómo convertirlo vale simplemente lo que me sirve es que veáis que 01:09:51

a veces os pueden dar fallos que decís de dónde me viene esto y es simplemente por el tipo de caja 01:09:57

porque es más restrictiva del otro problema facilidad para saber identificar eso si os ponéis 01:10:01

encima de un fallo y lo dejáis quieto vale os va a poner en la segunda línea en este caso no se puede 01:10:07

convertir implícitamente el tipo float en int ya existe conversión explícita compruebe si le falta 01:10:12

una conversión básicamente aquí lo que está diciendo es que no se puede convertir si no lo 01:10:17

hacemos de manera explícita nosotros como he hecho antes con una orden que se puede ejecutar 01:10:22

no se puede convertir un float en int porque es que no cabe en esa caja vale importante importante 01:10:26

también eso que el tipo de variable puede determinar que puede haber dentro luego el otro día vimos 01:10:33

también que había otro tipo entiendo que entre con todos estos problemas que pueden surgiendo lo que 01:10:39

es un int y es un float y cómo se escribe un float para que no de error hasta aquí entiendo que bien 01:10:45

y bueno así de fácil si yo ahora quisiera ver este valor en la consola como que lo está 01:10:53

recibiendo lo está ejecutando si veo vida actual y guardo pues ahora al empezar el juego vamos a ver qué valor 01:10:59

150 con 5 perfecto a ver que algo hay por aquí que a ver lo mismo puede ser varias cosas algo 01:11:10

de lo que toca por ahí con decimales con decimales eso es que bueno os acordáis que yo había puesto 01:11:25

varias 01:11:35

esto es básicamente fijaos la que salía aquí vale nuevamente por lo de los hacerlo público 01:11:50

no y operar mal yo borrar las variables que eran públicas para acceder desde aquí no y ahora vale 01:11:56

dice durante la tutoría otro script pero ahora ya no existen estas variables el error aunque ha 01:12:02

sido que hemos borrado aquí cosas está afectando a estas variables que ahora no sabe dónde existen 01:12:07

vale como no las queremos lo voy a borrar pero ve que cuando comunicamos scripts entre sí vale 01:12:12

guardo pueden venir los errores porque estamos hablando entre unos y otros y esto sirve también 01:12:17

para hablar del ámbito que estamos hablando de que salga del bloque porque cuando empezamos a 01:12:22

hacer códigos muy grandes si empezamos a hacer todo público que se puede hacer desde un lado 01:12:27

a otro que suele parecer muy conveniente muy cómodo al principio como estamos comunicando 01:12:32

distintos scripts surgen este tipo de problemas que es que vale estamos cambiando aquí un script 01:12:37

pero también estamos afectando a otros scripts entonces si no tenemos un control claro de que 01:12:41

está afectando aquí o no lo restringimos con cosas privadas o lo redirigimos de otras formas 01:12:46

que ya iremos viendo también pues al final lo que sucede es que empiezan a surgir estos fallos y 01:12:50

ahora es bastante pequeño el código pero nos puede volver un poco la cabeza del revés bueno 01:12:56

iba a dar 15 con 5 si no me equivoco no 150 con 5 perdón pues ahí está 150 con 5 con su decimal 01:13:01

imaginaos que yo quiero hacer una variable que se va a llamar nombre vale y esto es de repaso del 01:13:10

otro día voy a pasar rápida y yo quiero que ponga mi nombre que ponga daniel vale he creado aquí una 01:13:16

variable y como genero una variable que ponga daniel que tendría que poner de qué tipo tiene 01:13:23

que ser una variable de texto esto lo vimos el otro día a ver vuelvo a la unidad cero que la 01:13:29

tengo por aquí aquí vale en las variables pues ponemos las numéricas in y float y luego la de 01:13:43

tipo string no podemos usar su valor se introduce delimitado por comillas vale vale sí bueno esto es 01:13:50

otra cosa va delimitado por comillas no se os acordáis existe otro tipo de variable que se 01:14:00

llama string en donde puedo llamarlo nombre vale dado que así es como se va a llamar aquí abajo 01:14:06

cuando la mentemos y esto va a significar que se llama que yo quiero que aquí se guarde el valor 01:14:13

daniel entre comillas vale ahora yo cuando lancé el juego esto lo vimos el otro día no sé si tenemos 01:14:19

dudas de esto es muy importante que entendamos bien que cómo funcionan las variables tenemos 01:14:25

a daniel vale que esto nuevamente yo puedo declarar aquí la variable y de aquí como está dentro del 01:14:31

ámbito de donde se ha creado declarado la variable pues aquí es donde puedo decirle aquí quiero que 01:14:39

se llame daniel vale y ahora pues el resultado será mismo será el mismo se verá daniel vale 01:14:44

si queremos por ejemplo que en cierto momento del juego cuando vayamos metiendo datos en un menú 01:14:52

pues por ejemplo podamos meter nuestra edad la edad importante pues siempre va a ser un entero 01:14:58

no podemos decimales 25 este es el mismo ejemplo del otro día lo doy rápido recordad que como 01:15:04

hemos visto antes dependiendo del tipo de variable pues aquí se va a lanzar de una forma u otra eso 01:15:11

que significa que si yo pongo nombre más recordad que esto es la concatenación de textos esto también 01:15:17

viene aquí explicado tú declarando variables aquí se va hablando un poco de lo que vamos 01:15:26

hablando ahora vamos a hablar de booleano pero vais a ver que en unity a ver si no me equivoco viene por aquí 01:15:32

empezar bueno todo lo que se esté comentando está más o menos recogido por aquí y aquí se 01:15:46

habla de cómo se habla de cómo se van bueno aquí lo de que se ignoran los espacios en blanco las 01:15:53

líneas vale que también lo hemos visto que cuando vamos sumando distintos aquí están los operadores 01:16:00

de hecho seguro que está aquí cuando vamos hilando strings con números vale lo que va haciendo es 01:16:05

concatenar ese texto es decir que no es una suma como tal igual que el igual no es igual y sirve 01:16:12

para asignar una variable vale cuando hacemos nombre más edad vale que aquí no da ningún fallo 01:16:17

al final lo que está haciendo es poner un string daniel y luego un número vale pero un número que 01:16:24

en realidad no es un texto lo que pasa es que hay que entender que cuando en una concatenación de 01:16:31

elementos con este más cuando unimos varios elementos unos de tipo texto el resto también 01:16:37

se convierte en uno de tipo texto vale pasan a ser todo de tipo texto igual que hemos hecho antes 01:16:41

con lo de convertir el flote en in vale daniel 25 no pone ningún espacio porque si recordáis 01:16:46

también aquí dentro podemos empezar a con las comillas y las comillas sirven siempre para ir 01:16:53

escribiendo nosotros textos literales no son cantidades que se suman y que se van a operar 01:16:59

son textos literales y poner la edad de espacio vale porque los espacios también son literales 01:17:03

concatenamos daniel no y ahora concatenamos es de 25 en este caso 01:17:09

años vale esto cuando hagamos una ui para operar para ir pues eso metiendo nuestro nombre a jugar 01:17:22

etcétera es vital que vayamos conociendo cómo se declaran yo ahora lo que voy a ver es la edad 01:17:30

aquí hemos dejado una especie de variable que yo podré ir cambiando el valor incluso se puede ir 01:17:36

cambiando durante el juego o guardará el valor que introduzcamos nosotros en un menú en plan 01:17:41

poner a la nombre y ponemos jesús pues se guarda jesús en esta caja y aquí sabe perfectamente que 01:17:45

lo que se guarda en esta caja en ese caso será jesús y la edad pues la metemos también y podrá 01:17:53

ser 35 pues en ese momento cambiará para mostrar otro mensaje en otro punto de del juego vale lanzó 01:17:57

y la edad de daniel es de 35 años fijaos que aquí falta un espacio básicamente porque 01:18:06

deberíamos decir que literalmente aquí haya un espacio para que lo respete vale hasta aquí esto 01:18:13

de hecho es el mismo ejemplo de la semana pasada hasta aquí más o menos vais pillando cómo 01:18:20

funcionan los strings quedarse con que se ve escriben con estos 01:18:23

a mí alguien me lo había escrito antes con estas comillas vale y es importante que lo interpreta 01:18:29

como una cadena de textos literal luego por otro lado existe un nuevo tipo de caja que el otro día 01:18:37

no hablamos que son las booleanas vale y una booleana sólo puede guardar dos valores verdadero 01:18:44

y falso vale una booleana cuando generamos una variable pues será de tipo bull en este caso 01:18:50

para que decir que es una booleana y aquí voy a poner semáforo encendido y voy a decir por 01:18:57

defecto que sea true o false vale tiene dos variables es decir que estas booleanas pueden 01:19:06

las booleanas así pueden ser true o false vale igualmente que siempre cuando sabemos que algo 01:19:14

booleano si yo pongo un 5 no es la caja que corresponde y da fallo si yo hasta ahora pongo 01:19:23

jose vale entre comillas como haría un string da fallo porque en esta caja booleana llamada 01:19:28

semáforo encendido sólo puede estar o lo que suele significar true que está encendido vale 01:19:34

que es verdadero esto que ocurre o es falso vale lo mismo esto en el tema en el tema cuando hablamos 01:19:40

de las variables lo siguiente que pone aquí es booleanos pueden adoptar sólo dos valores 01:19:48

predefinidos muy útiles para crear lo que se llaman interruptores o para indicar que algo 01:19:52

está ocurriendo no estas booleanas se usan mucho y por eso puesto lo de semáforo sirven para decir 01:19:57

si algo está ocurriendo o no vale y cuando hagamos condicionales decir como he dicho antes si la vida 01:20:04

del personaje ya es 100 no se le puede cargar el power up porque está superando la cifra máxima 01:20:10

a veces podemos decir oye mientras el personaje tenga y voy a poner indicador en vez de semáforo 01:20:17

indicador máximo vida vale si yo empiezo el juego con la vida llena pues aquí estará true y entonces 01:20:25

mientras esto sea true pues el power up no se va a poder coger porque no nos interesa vale ahora 01:20:34

ya iremos viendo con las y esto está aquí introducido vale para que lo tengáis con las 01:20:39

estructuras de control con los ships principalmente pero hay más vale iremos diciendo dando condiciones 01:20:44

para que una cosa se ocurra o no ocurra no entonces en el momento que le demos un golpe a este y baje 01:20:49

a 25 cuando pongamos una condición va a decir vale pues como baja de 25 y está comprobando que 01:20:57

ya no es 100 esto va a decir pues ya no es falso no está con el indicador al máximo de vida y 01:21:03

entonces en ese caso sí que le permitirá que cuando cojamos un power up de suma de la vida 01:21:08

para que pase de 25 hasta 75 con 5 vale son como ahí pone pues eso conmutadores interruptores 01:21:12

semáforos vale pues un semáforo puede estar encendido o apagado vale entonces las booleanas 01:21:20

van a ser sobre todo muy útiles en el momento de pues de ir planteando ejecuciones e ir viendo 01:21:26

si ciertas condiciones se van se están cumpliendo no vale ya veremos ejemplos de esto también 01:21:34

importante vale en un debug log si decimos que enseñe lo que guarda indicador máximo vida 01:21:41

vais a ver que lo que enseña vale en este caso es falso pues cuando ejecute el juego 01:21:46

pues falso vale lo pone no es una cadena de texto es que no está cumpliendo la condición de hecho 01:21:54

internamente el código lo que está leyendo es que este valor vale o 0 o 1 es verdad que lo traduce 01:22:00

en falso verdadero pero falso es 0 y verdadero es 1 de hecho el otro día os dije que si una caja 01:22:05

una variable no se inicializaba es decir no se le da un valor por defecto valía 0 o en el caso de 01:22:13

los textos vale nulo no no tiene contenido no entonces si yo ahora ejecuto esta este debug 01:22:19

log como no tiene nada en su interior lo que va a mostrar es 01:22:26

falso vale en realidad es un 0 pero digamos que la condición es falsa que no es lo mismo vale 01:22:34

simplemente por ver que existe también si ponemos true vale pues lo que va a enseñar es 01:22:41

true a ver espera ahí está true vale hasta aquí qué tal sé que todo empieza a ser un poco abstracto 01:22:45

ahora le quito un poquito de abstracción a esto de todos modos hasta aquí más o menos me vais 01:22:59

siguiendo si más o menos vale todos habéis leído aunque no lo hayáis empezado a hacer el enunciado 01:23:05

de la tarea 0 y lo que se quiere conseguir vale si no leerlo vale y lo entenderéis mejor lo que voy 01:23:13

a decir ahora pero como doy por supuesto que sí que lo habéis leído porque es una de las cosas 01:23:22

que os pedía para la tutoría de hoy vale al final lo que queremos conseguir es y voy a abrir el código 01:23:25

que lo tenéis también y así lo podéis revisar más adelante lo pongo aquí vale era conseguir que una 01:23:32

nave espacial una nave espacial en la que van impactando meteoritos pues vaya quitándole escudo 01:23:39

no vida por decirlo de otra forma hasta que muere no y este es el código hay más formas de plantearlo 01:23:45

pero es un código que resuelve el enunciado lo tenéis en el aula virtual lo podéis bajar y meterlo 01:23:53

entonces para que vayáis viendo cómo se construye simplemente y vais a ver además que está muy 01:23:58

comentado tenemos esta clase que se llama diagrama como se podría llamar un juego nave vale porque 01:24:03

el descriptivo y al final lo que estamos haciendo es generar un float con la energía del escudo vale 01:24:09

que empezará al máximo ahora vemos cuando ahora mismo vale 0 porque no lo hemos declarado solo 01:24:16

un número de vidas vale porque el juego pues aparte de que muera la nave pues va a haber varias vidas 01:24:22

no pierdes una vez y te resta una vida es decir va a haber la vida del 100 a 0 por ejemplo y luego 01:24:28

pues tres vidas vale luego la fuerza del impacto que va a ir restando dos vidas cuando se choquen 01:24:33

estos meteoritos luego va a haber un booleano vale un interruptor como estábamos diciendo que nos va 01:24:39

a decir si estamos vivos o no que este interruptor básicamente lo que va a hacer es que mientras 01:24:46

estamos vivos va a ser true porque si estamos vivos pero cuando nos muramos va a decir que es 01:24:50

falso que estamos muertos básicamente no si lo traducimos a nuestro lenguaje y en el momento 01:24:57

en el que este interruptor pasa a ser falso es decir que estemos muertos pues el juego va a saber 01:25:01

decir va a entender ya el código que pues oye que el juego se ha acabado porque no estamos vivos 01:25:06

hemos perdido toda la energía y también todas las vidas y luego aquí pues bueno hay un mensaje 01:25:11

de que vamos a ir dando como avisos a en pantalla vale si os fijáis ya para ir viendo una especie de 01:25:16

ejecución o de puesta en en algo menos abstracto no que es esto cuando iniciamos el juego cuando 01:25:23

iniciamos el script lo que vamos a hacer es en ese momento arranca el juego arranca este script y 01:25:32

vamos a llenar en las cajas que nos interesa en este momento para darle un sentido también al 01:25:37

juego hasta este momento sólo hemos generado espacios que rellenar pero a empezar el juego 01:25:41

cuando decimos oye quiero que el escudo de la nave sea de 100 vale y como se va a jugar con 01:25:46

decimales vale pues lo hemos planteado como un float vale esto hay que tenerlo en cuenta como 01:25:53

hemos visto después para pues para ir teniendo en cuenta problemas que puedan surgir vale que 01:25:59

suelen ser fáciles de corregir pero hoy que nos pueden traer de cabeza pues tiene vida vale y 01:26:05

aunque no ponga decimales como es un decimal es decir es un float mejor dicho ya pongo la f vale 01:26:11

si no la pongo puede no dar problema pero veis que ser correcto tampoco conlleva ningún ningún 01:26:16

castigo vale luego al comenzar el juego ojo estamos arrancando el juego y evidentemente 01:26:25

pues arrancamos vivos si empezamos muertos pues ya sería mal asunto vale luego las vidas con las 01:26:30

que arrancamos vale igual que está la energía pues tendremos tres vidas vale y luego veis que 01:26:36

hay en el estar al arrancar una operación aquí que qué es por cómo se ha dicho antes como bueno 01:26:41

en realidad lo pone aquí pero veis que se escribe igual que el instanci de antes es verdad que no 01:26:48

hay nada dentro del paréntesis pero esto es un método o una función vale los métodos y funciones 01:26:53

vale al arrancar el juego pone quiero que haya un impacto e impacto si yo voy a cualquier otro script 01:26:59

si yo voy a leer durante la tutoría que estaba haciendo ahora y en estar yo pongo esto de impacto 01:27:07

veis que no existe no sale vale no existe no es como instancié que instancié siempre existe 01:27:13

no yo pongo instancié y ahí está esperando sus paréntesis y ahora está y sí que obliga a que 01:27:21

haya aquí unas unos parámetros no vale como yo que sé vamos a poner aquí aunque de fallo pues vamos 01:27:27

a poner bueno no tenemos ninguno de tipo objeto vale no puedo poner ningún parámetro aquí porque 01:27:35

va a dar fallo porque nuevamente lo que nos está pidiendo es un GameObject lo que hemos visto antes 01:27:41

que la primera sobrecarga su tipo tiene que ser de objeto vale pero no sale el impacto que os 01:27:47

estaba diciendo antes ni bien ni mal no puedo hacer nada porque los métodos lo que vamos a empezar a 01:27:52

hacer también es que los creamos nosotros es decir bajo un nombre que nosotros ponemos vale 01:27:59

podremos ir y veis que está aquí meter nosotros nuestras operaciones dentro de un bloque en este 01:28:04

caso fijaos que es largo y este bloque lo que va a hacer que llega hasta aquí el bloque impacto 01:28:10

hasta aquí todo esto es impacto cuando yo ponga esta palabra vale se va a ejecutar lo que hay 01:28:16

aquí dentro entonces vais a ver y esto también es importante que por primera vez cuando llegamos 01:28:23

a un punto aquí vale saltamos de aquí a aquí en la ejecución luego irá el update que también 01:28:29

tiene su impacto vale pero primero hemos estamos llamando a este impacto salta aquí y se va a 01:28:36

reproducir lo que hay aquí dentro porque instantiate si existe y aquí existe por ejemplo si pongo el 01:28:43

método instantiate como os he dicho antes el impacto no existía en el otro lado porque como 01:28:52

os he dicho en varias ocasiones ya cuando empezamos cualquier script tiene unas librerías 01:28:57

y también hereda ciertos comportamientos que es esto del mono behavior bueno que os suene 01:29:02

que ya digamos que nos da operaciones preechas es decir para que leemos más cuando 01:29:08

a ver si lo pone claramente aquí 01:29:15

bueno existe la clase objeto vale que cuando yo me meto en instantiate vais a ver a ver me meto en 01:29:23

esta con el control volvemos a meternos vale pone objeto instantiate es una de las que ha cargado 01:29:31

ya en la librería vale hay otra clase en otro sitio que está guardada en la librería unity 01:29:36

engine que cuando empezamos cualquier juego está aquí si yo por ejemplo intentara poner instantiate 01:29:43

como siempre ocurre y cualquier cosa bueno en esta como no como no lo voy a rellenar no me va a dar 01:29:48

fallos siempre pero fijaos que este instantiate funciona sin problema hasta que yo me cargo 01:29:55

o lo comentó mejor aún comentó el unity engine y instantiate junto a otras muchas cosas fijaos 01:30:02

en las clases dejan de funcionar vale entonces tenéis que ir entendiendo que existen las clases 01:30:09

y los métodos que ya existen y luego los métodos que nosotros podemos ir haciendo para ir recopilando 01:30:15

distintas acciones y que cada vez que pongamos esta frase pues hoy haga todo esto si yo quiero 01:30:20

poner impacto varias veces en mi código pues no tengo que escribir todas estas líneas ya 01:30:25

está recogido dentro de su propio bloque vale hasta aquí qué tal 01:30:30

bueno 01:30:36

hasta aquí bien si a ver es que yo he estado intentando hacerlo sin mirar esto que había 01:30:39

expuesto conseguiría ningún error hasta lo de que me quedo sin escudo que ya y colapsé pero cuando 01:30:46

meto el impacto no me lo reconoce me dice que no puede hacer un buey de impacto ya ha entrado ahí 01:30:52

la tutoría tranquilamente y supongo que lo sacareis y no te pregunto realmente todavía no te no hemos 01:30:58

explicado cómo se crea esto es decir todavía no ha explicado cómo se crea esto es decir que estoy 01:31:05

que va más avanzada de lo que hemos explicado entonces vale así que bien te quiero decir 01:31:11

solamente estoy como dejando caer muchas veces que cuando veamos una orden de este tipo con 01:31:17

mayúscula y paréntesis estamos llevando un método y que hay métodos que ya vienen prehechos 01:31:23

vale por estas librerías y otros que no que los hacemos nosotros ahora tenemos que aprender a 01:31:28

hacerlo nosotros vale pero hasta aunque aunque aquí llegamos y lo que pone que invocamos a la 01:31:33

función que realiza el impacto es decir que al empezar el juego estamos metiendo dentro de esta 01:31:39

palabra impacto pues que haya un impacto que es lo que vamos a hacer aquí vale vale da igual 01:31:45

ponerlo antes del voy a estar o después el impacto te refieres esto las declaraciones de las variables 01:31:51

vale las variables cuando son globales no como hemos dicho antes pueden ir aquí o pueden ir al 01:31:59

final y vais a ver que cuando las pongo al final vale dentro de la clase pero al final todo funciona 01:32:06

porque porque está dentro de la clase entonces todo lo que se va metiendo en bloques inferiores 01:32:13

pues puede acceder a estas clases pero sí que es verdad que es mucho más intuitivo y es la 01:32:20

convención aparte que esto vive mucho de convenciones de que todas las incluso aunque 01:32:25

luego sigamos picando código aquí abajo y queramos crear una nueva variable si queremos que sea global 01:32:30

de toda la clase subimos y la ponemos aquí porque así de un vistazo rápido tenemos todas las que 01:32:35

son globales ya englobadas se puede mientras esté en dentro del bloque correspondiente donde queremos 01:32:42

que funcione que por eso he explicado lo del encapsulamiento funcionaría pero la convención 01:32:47

dice que lo hagamos aquí vale de hecho hay más convenciones vale porque ahora mismo todas son 01:32:52

private ya a veces iréis incluso viendo o que hay gente que dirá siempre que creo una variable 01:32:57

private empiezo con una barra baja para que así al ir cambiándolo en el código vale saber que es 01:33:05

una variable privada que no la voy a declarar mediante el inspector sino que la voy a ir 01:33:11

declarando yo siempre a mano en el código porque no se puede ir al editorio unity cambiarlo si es 01:33:16

privada no luego hay gente lo digo por por si encontráis que siempre que haga una variable 01:33:20

global le pone m barra baja vamos habría que ponerlo en todas y todas las que va generando 01:33:25

dentro de métodos o de niveles inferiores como este in por ejemplo pues va sin la barra baja y 01:33:31

esto sirve para saber cuáles son variables globales y distinguir las de las que no pero 01:33:37

esto ya son convenciones que va más adelante es decir que vamos primero a lo básico nada perdona 01:33:40

que me preguntas una cosa y te correspondo con tres no no no pero es que así van sonando las 01:33:48

cosas entonces se puede declarar incluso fíjate vale la quito de aquí pero aquí dentro vale 01:33:54

digamos que aquí hay un bloque que se cierra aquí y aquí empieza otro es decir si lo declarar aquí 01:34:03

también lo estoy declarando dentro de la clase y no da problema pero claro tú cuando luego quieras 01:34:08

descubrir dónde están las variables de toda la clase como empieces a no organizarlo bien te vuelve 01:34:12

loco por eso justo debajo de clase la que son las que son variables globales se declaran y además si 01:34:18

trabajas en un equipo pues todos saben dónde está la variable globales y todos están contentos de 01:34:24

encontrarlo rápido hay gente que lo pone al final por lo mismo porque saben que están al final de 01:34:28

la clase y lo encuentran antes pero como luego dentro mismo es que se pueden crear varias clases 01:34:35

que esta es otra cosa se crea la clase a continuación y si lo pone justo debajo de 01:34:40

donde se declara pues más claro el mejor sitio vaya vale vale vale hasta aquí más o menos me 01:34:46

vais siguiendo no más o menos vale 01:34:56

voy a seguir unos 10 minutillos más o 20 vale pero voy a ver porque a veces me escribí las 01:35:03

dudas aquí no necesito verlo por mi cuenta vale en él en las variables también habla a raíz esto 01:35:09

es más avanzado vale pero es simplemente para que también os suene un array que a veces se puede 01:35:20

llamar matriz o arreglo vale se pueden dentro de una sola caja meter muchos tipos de datos y de 01:35:25

hecho un array para que os hagáis en cuenta cuando metemos aunque no está declarado específicamente 01:35:31

a ver por qué no me está abriendo esto aquí cuando generamos una variable por ejemplo de transform 01:35:41

no estamos metiendo un dato como en los números que metemos un 10 o daniel o 5 como os he dicho 01:35:47

antes se están guardando un montón de valores vale al final esto si habéis estudiado matrices 01:35:54

en matemáticas esto es un poco parecido a una matriz es decir que hay muchas posiciones de 01:35:58

esa variable vale que os suene esto es más avanzada así que me lo salto ahora mismo vale 01:36:03

ya tendrá más sentido más adelante en esta sección voy un poco en el orden ahora para para ir 01:36:08

resolviendo dudas aquí veis lo que acabamos de hablar de cómo se declara la variable es un poco 01:36:14

pues inconvenientes que se pueden encontrar etcétera y hay otro otras digamos instrucciones 01:36:20

importantes otros operadores también vale que son estos que tenemos aquí estos son bastante 01:36:29

importantes porque se usan de vez en cuando y si no pues de pronto saltáis esto porque no parece 01:36:33

importante pero si lo es para poner trucos de programador como un extra pero no es una 01:36:39

es importante vale es los operadores más más los operadores menos menos más igual y menos igual 01:36:44

me quedo en estos vale no avanzó hoy no voy a avanzar más de aquí de las variables y bueno 01:36:50

lo que hemos ido viendo de otras cosas en las variables acabamos de decir que existen estos 01:36:57

operadores lo dejo aquí vale el más más y el menos menos a ver me voy al de durante la 01:37:04

tutoría y voy a simplificar un poco esto vale en indicador máximo de vida era un booleano me voy 01:37:10

a cargar todo lo que ya no me interese y me voy a quedar con un y por ejemplo vale para hacerlo 01:37:18

más simple cuando estamos en cualquier punto del código puede haber momentos en los que queremos 01:37:22

que una variable vaya sumando progresivamente de uno en uno su valor vale eso que significa 01:37:27

que a veces hacemos lo que se llaman bucles vale si vais más adelante se habla del for del while 01:37:36

de wildo bueno hay varios más avanzado también pero que lo que van haciendo esos bucles es ir 01:37:42

recorriendo varios elementos y esos elementos van digamos siendo posiciones no pues por ejemplo 01:37:50

imaginaos por decirlo así vemos el típico ranking de una recreativa antigua vale lo pongo aquí 01:37:58

ranking recreativa a ver si sale lo que yo quiero que salga que no lo sé imágenes vale lo típico 01:38:05

los mejores cinco resultados vale y esta va a ser la primera posición la segunda tercera la cuarta 01:38:12

la quinta y ya no existen más entonces habrá un momento que nos va a ir interesando que vaya pues 01:38:17

eso muestra la 1 cuando muestra la 1 muestra la 2 cuando muestra la 2 muestra la 3 veis que va 01:38:23

sumando progresivamente en ese momento se usa este operador más más vale que es una forma de 01:38:28

simplificar que sumamos 1 a la variable vale esto que significa que si yo ahora mismo pongo 01:38:35

aquí vida vale que me va a mostrar en consola 01:38:47

27 no 26 a ver lo pongo vale 25 le sumó 1 y 26 vale vamos a ello 01:38:56

26 perfecto vale esto luego habrá otras operaciones que puede sumar más más cinco veces porque digamos 01:39:06

que cinco veces pues irá pasando por las cinco posiciones para mostrar ese ranking vale es un 01:39:13

operador muy importante si pones cuatro más eso más dos no no no no no si voy poniendo más se vuelve 01:39:18

loco da fallo vale vale esto es lo mismo y esto es otra sintaxis que suele dar problema al principio 01:39:27

vale que es que esto mismo es la forma resumida de escribir esto vale y vais a decir esto no 01:39:34

tiene mucho sentido bueno hasta que hasta que lo tenga vale esto y esto es exactamente lo mismo 01:39:39

vale y vais a decir como vida es igual a vida más uno no si lo pensamos en álgebra humana 01:39:47

eso no tiene sentido porque estamos pensando como pensarían lo la matemática no las las 01:39:54

ecuaciones pero recordad que aquí lo que estamos haciendo es esta caja esta variable vale es igual 01:39:59

vale se le asigna lo que ya vale ahora mismo más uno entonces esto significa que lo que hay en esta 01:40:06

caja vale es igual a lo que guarde la caja vale aquí está refiriéndose a abrir la caja y aquí 01:40:13

se está refiriendo al contenido de la caja vale aquí siempre hablamos declarar la variable o llamar 01:40:19

a una variable e inicializarla o cambiar el valor no el igual no es igual no es un igual de matemáticas 01:40:24

es un asignador entonces vida es igual a vida más uno es decir en esta caja vamos a guardar lo que 01:40:30

valga vida más uno y si volviéramos a poner aquí vida pongo otra vez esta línea vale cuando yo 01:40:37

muestre otra vez la misma instrucción no son lo mismo vale qué pensáis que va a poner ahora en 01:40:46

la cosa en la consola lo mismo 26 aquí 26 vale pero estoy diciéndole otra vez recordar está pero 01:40:51

porque te coge en la segunda segunda orden que estás dando el resultado de la primera y no el 01:41:01

resultado del que has declarado vale ahora lo explico simplemente lo voy a enseñar para que me 01:41:07

creáis luego os lo explico que esto es bastante simple y a la vez bastante complicado veis que 01:41:11

pone 26 y 27 volvemos a lo del encapsulamiento y cuando se declaran las variables vale tenemos 01:41:18

una variable global aquí arriba vale con su caja y la inicializamos con 25 como podría ser con 01:41:24

cualquier valor vale y vamos aquí y decimos vale en vida igual que en vez de antes decíamos ahora 01:41:31

vale 70 y lo decíamos así a las bravas entonces aquí en señal 70 no esto lo vimos el otro día y 01:41:37

lo hemos visto antes también quiero que sea lo que vale vida más 1 y aquí lo que está haciendo es 01:41:43

coger todavía no lo hemos asignado está abierta la caja y aquí hacemos la asignación está volviendo 01:41:48

a donde se declaró la variable coge este valor le suma 1 y lo guardan vida y lo leer arriba abajo y 01:41:55

por eso sumado y aquí lo guarda como vida pero es que cuando volvemos a esta caja vuelve a abrir la 01:42:02

caja y aquí ya no vale 25 a estas alturas vale a 26 y le sumamos uno y así progresivamente es 01:42:07

decir si yo empezar a hacer esto pues sería 26 27 28 29 vale que es lo mismo vale lo vuelvo a 01:42:14

decir en vez de escribir todo esto es lo mismo que decir esto es a la caja súmale 1 vale es 01:42:23

exactamente lo mismo vale pero si lo quisiera mencionar en otra caja que se vinculara con los 01:42:29

26 sí que le tendrías que asignar como otro nombre a vida para que la otra cápsula te lo 01:42:35

reconociera por 26 en vez de por 25 o no no aquí lo que va haciendo claro tú me estás hablando de 01:42:40

abrir otra variable distinta claro si tú abres otra variable pues esto se llamará muerte no sé 01:42:46

y esto tendrá otro valor es decir vida y muerte son distintos es decir si yo aquí digo muerte y 01:42:53

le pongo 800 por poner un valor muy distinto aquí es que muerte no está cambiando en ningún momento 01:43:02

vale es verdad que yo puedo ir aquí decir muerte y aquí me va a enseñar vida 25 más 1 26 ha guardado 01:43:08

26 en la caja en este momento ahora vuelvo aquí que ya vale 26 estoy llamando a la caja 26 más 1 01:43:18

27 en este momento va a enseñar 27 vale vuelvo a llamar a la caja vida he guardado 27 aquí antes 01:43:24

27 más 1 28 en este momento la caja vale 28 y aquí enseñará 28 y aquí valdrá 29 pero aquí no va 01:43:31

a enseñar 29 porque es que lo que le estoy diciendo que enseñen no es vida no es lo que 01:43:40

hay en la caja muerte entonces va a enseñar 26 27 28 y 800 vale pero si yo lo pusiera fuera de 01:43:44

esas llaves sí sí que tendría que declarar de otra manera la vida más uno para que me lo reconociera 01:43:51

porque estaría fuera de todas estas llaves sobre la no sé si me explico claro pero tú donde has 01:43:58

declarado la variable es al comienzo es global entonces se va a poder usar en toda la clase sin 01:44:04

problema el problema viene de que yo la declara aquí como está en el ámbito aquí sí que funciona 01:44:09

no pero si yo luego en el update pongo vida pues es lo de antes aunque yo ponga vida más uno es que 01:44:18

no sabe que es vida porque está fuera de su ámbito vale sin embargo muerte sí porque muerte 01:44:27

está aquí muerte se va a poder poner muerte es igual a 55 vale o mejor aún mira si me va siguiendo 01:44:33

sí vale o mejor aún voy a comentar esto para que en el estar no haga nada y no os haga muchos 01:44:44

numerajos pero imagínate que en el update que recuerda que se va se va planteando en cada 01:44:51

fotograma vale quito lo de muerte 55 digo que cada fotograma me enseña lo que vale muerte que esto por 01:44:57

ejemplo puede servir para un contador aquí muerte qué crees que va a pasar como la declarado arriba 01:45:05

la puedo como es global la puedo hablar de muerte de esta variable en cualquier lado que va a ir 01:45:14

pasando que va a asumir 801 802 803 porque lo has puesto cada fotograma exacto empieza valiendo 01:45:20

800 en el fotograma siguiente le digo ojo súmale 1 y me lo enseñas y aquí guarda 801 porque está 01:45:30

fuera del update en el siguiente 801 súmale 1 vale pues se señalará 802 y guarda 802 y ahora 01:45:36

vas a ver que tenemos como una especie de contador muy poco refinado pero a saber que 01:45:43

cada fotograma pero sí vale ahí va a ir sumando cada fotograma que por segundo se ejecuta mucho 01:45:49

fotograma vale por eso va como a saltos pero sí que se están sí que se están planteando vale 01:45:58

vez que va sumándose que no va de uno en uno bueno si vas parando si van de uno en uno pero 01:46:03

se ejecuta más rápido del uno en uno vale entonces pues mira por ejemplo una aplicación practicamos 01:46:09

para hacer un contador pues mira el más más puede servir y lo mismo esto es igual a muerte 01:46:15

más uno es exactamente lo mismo va a dar el mismo resultado si quieres lo comprobamos pero si lo da 01:46:20

vale y vale muerte más uno vuelvo aquí a los apuntes vale este operador importante que sepáis 01:46:26

como bueno esto lo apago que ya está aquí usado cuántas cosas vale y esto también esto que estoy 01:46:34

poniendo de vida más vida igual vida más uno también se puede poner con otra forma resumida 01:46:42

que son éstas vale bueno ojo no he puesto el menos menos pero el menos menos lo que va haciendo 01:46:48

restar uno vale cada vez que se invoque igual si queréis hacemos las pruebas pero por no perder 01:46:53

tiempo pero existe el más igual y el menos igual vale si yo voy al más igual lo que se puede hacer 01:46:57

es para no tener que repetir que incluso es la confusión que nos viene siempre en vez de poner 01:47:05

muerte igual a muerte más uno cuando se va a hacer una operación sobre la misma variable sobre 01:47:10

la propia variable se puede hacer igual más uno y esto que significa que muerte pasa a valer lo 01:47:15

que valga más uno o más siete en este caso vale ahora se van a ir sumando de 7 en 7 va a ir 807 01:47:22

814 vale y cada fotograma va a ir enseñándolo 01:47:30

vale porque no lo está haciendo bien pues por una cosa muy simple que es que he puesto igual 01:47:38

más no más igual vale importante no he puesto igual más y la operación es más igual ahora mismo esta 01:47:43

línea como no tiene sentido vale le está diciendo que era un 7 positivo básicamente entonces siempre 01:47:53

vale 7 que no es lo mismo que que cada vez que de una vuelta en este caso vaya sumándole 7 01:47:58

ahora sí que va a ir 800 807 va a ir lo paro porque si no es todo se vuelve loco vale 807 01:48:04

va sumando 7 en cada ocasión que es la cifra que hemos puesto vale si aquí lo pusiéramos con el 01:48:13

menos aquí lo bueno es que podemos determinar que sean saltos más allá del 1 vale porque en el más 01:48:20

más y que es 1 por ejemplo aquí también podríamos poner 7 por ejemplo si aquí ponemos que vaya 01:48:24

restando 1 en cada fotograma pues era lo paro y voy para arriba para ver lo que ha hecho 01:48:30

se haciendo más restando 1 en cada vuelta vale eso es importante qué tal hasta aquí 01:48:41

bien si no más o menos iba 01:48:48

para el próximo día me quedo con esto siguiente con el último vale esta página más o menos estaría 01:48:53

vista en falta de los arrays que los arrays lo vemos poco después y tardaré un poco en hablar 01:48:59

de ellos pero aquí hay otra línea que sirve para invertir booleanos pero bueno ya lo veremos cuando 01:49:06

cuando veamos la aplicación más aplicada por decirlo así entonces hasta aquí que 01:49:11

esta página más o menos la debería y si ya entendiendo vale entonces hay una última cosa 01:49:18

que quiero que sepáis que es que antes lo hemos visto que es por un lado que cuando tenemos algún 01:49:26

a ver que lo voy a tener que crear porque no lo tengo cuando tenemos algún valor público o con 01:49:32

sería la isfil como aquí a ver sería la isfil es decir que lo asignamos lo podemos asignar por 01:49:37

el editor no como hemos hecho pero en este caso es un número vale yo aquí le ha asignado 800 y 01:49:45

esto lo voy a comentar vale para no complicarlo más vale yo aquí le estoy diciendo que esto vale 01:49:52

800 vale y yo voy y voy a la escritura ante la tutoría y vale 800 vale y yo digo bueno no 800 01:49:57

950 vale es verdad que aunque bueno y en el start voy a decir que me enseñé que está guardando 01:50:06

muerte porque si no no sabemos que está interpretando internamente el programa vale cuando 01:50:14

empiece el juego enséame lo que vale muerte y aquí yo inicializar inicializado muerte pone 800 lo lógico 01:50:22

sería que pusiera 800 que era el problema que estaba dando antes yo cuando voy y arranco el 01:50:28

juego que es lo que me pone 950 vale quiero que entendáis que los códigos vale igual que si aquí 01:50:33

pongo 800 y al arrancar el juego aunque aquí la haya declarado luego ponga muerte igual a 1000 01:50:42

vale aquí si no lo tuviera serializado y lo cambiara vale lo que me va a enseñar es 1000 01:50:50

porque al arrancar aquí este de comienzo declara inicializado como 800 luego al arrancar el juego 01:50:55

digamos que hay una operación posterior que es que al arrancar el juego pues oye me dice que vale 01:51:01

1000 entonces lo que me va a enseñar es 1000 pero hay algo más allá incluso que es que todo lo que 01:51:06

hagamos en el inspector más allá del código más cercano digamos a la ejecución sobrescribe a lo 01:51:11

que vamos haciendo en el código por tanto podremos ir variando veis verá que vuelve a salir aquí ha 01:51:16

salido el 1000 porque es verdad que cuando arranca el juego aunque yo haya cambiado esto vale 01:51:22

como yo he cambiado el juego y le he dicho al arrancar la ejecución ponmelo en 1000 vale 01:51:29

sobre escribe al empezar el juego en un momento de ejecución lo que yo haya hecho tanto en la 01:51:36

declaración inicial vale como en la sobrescriptura que tenemos aquí que sí que es verdad que si no 01:51:42

hiciera nada más vale como no hay un momento de ejecución no hay un momento en el que lo vuelve 01:51:47

a cambiar pero tener ojo con que a veces poner aquí las instrucciones puede dar este tipo de 01:51:52

problemas que hay un orden de ejecución ya os iréis pegando con ello no sé si me vais siguiendo 01:51:57

pero eso aquí al inicializar pues damos un valor pero luego hay momentos de ejecución con el estar 01:52:02

y el update que van pueden ir sobre escribiendo valores pero este sería el y se realiza o de 01:52:08

serialize fil pero no es por el joder y el public también se puede variar dentro de el propio del 01:52:14

propio script y de hecho para que os hagáis una idea yo aquí pongo serializar el campo vale lo 01:52:22

inicialice como 800 al empezar lo pongo en 1000 y quiero que el mío la muerte me lo vaya enseñando 01:52:33

en el update que cada fotograma me vaya enseñando esta cifra y guardo y vais a ver qué pasa una 01:52:39

cosa que mezcla todo esto que acabo de decir yo arrancar el juego al arrancar se me pone en 1000 01:52:44

sobre escribiendo esto que está en 1132 no a ver placa se pone 1000 y vale por 1000 me la ha puesto 01:52:51

1000 incluso aquí pero cuando yo ya he arrancado el juego como digamos que esta orden ya se ha 01:53:00

ejecutado y no lo va a sobre escribir al final lo que va a importar es lo que yo vaya poniendo aquí 01:53:05

y veis que va cambiando el valor y podría ir cambiando desde el editor a mano ciertos valores 01:53:10

vale que suene pero para qué pues por ejemplo imagínate que quieres probar hacia dónde se 01:53:16

mueve una nave de una forma intuitiva vale porque tú cuando acaba cuando arrancas el juego no puedes 01:53:24

cambiar el código el código digamos que una vez arranca no se puede cambiar pero nos puede 01:53:29

interesar probar cosas que sí que se ejecutan durante el juego como esto que se está cambiando 01:53:34

el código no es que estoy cambiando el código aunque no lo parezca aunque no salga en el césar 01:53:39

es como si estuviera cambiando claro yo con este sería la fil estoy accediendo a esta variable en 01:53:45

todo momento y siempre y cuando sea en un momento de ejecución que se pueda ver cómo voy cambiando 01:53:51

el valor de muerte yo en todo momento tengo abierta esta caja en vez de cambiarlo como aquí 01:53:57

lo estoy cambiando pero por el editor en vivo vale yo lo que vale muerte lo estoy cambiando 01:54:01

ahora mismo en este mismo instante muerte no vale ni 800 ni 1000 vale 1657 ya lo iré viendo 01:54:08

sobre todo mira en el siguiente tema ya de hecho tiene aplicaciones así que ya lo veréis vale e 01:54:16

importante si en algún momento queréis ir viendo cómo va pues por ejemplo lo del más uno que va a 01:54:20

cada fotograma aquí vais yendo fotograma fotograma aquí da igual porque mira como está parado el 01:54:26

juego si yo ahora cambio a 1896 al ir al siguiente fotograma pues 1896 vale que en ocasiones puede 01:54:32

que queramos ir viendo qué va pasando cada fotograma en vez de aquí una sucesión de 01:54:40

elementos pues continúa vale que se puede detener el juego y se para ahí y podemos ir fotograma 01:54:44

fotograma ejecutándolo vale y ya última cosa bueno hasta aquí qué tal más o menos sé que son muchas 01:54:51

cosas pero bueno veis que están escritas en el tema también y en los vídeos de álvaro holguera 01:54:57

también se ven ciertas cosas que estoy hablando aquí vale que esto es un mejunje de cosas pero 01:55:02

que poco a poco iréis asimilando al menos los que vayáis siguiendo las clases hay una última cosa 01:55:08

muy importante que es que cuando vayamos cambiando cosas en vivo yo puedo decir ahí yo arranco el 01:55:15

juego y se me pone en 1000 siempre vale y aquí empiezo a guardar y vais a ver que yo cuando detengo 01:55:22

el juego me vuelve al otro valor que estaba guardando antes de empezar no por ejemplo 500 01:55:28

no arranco el juego se va sobre escribir a 1000 que es lo que hace al arrancar el juego y me pongo 01:55:33

a cambiar esto a 192 y por lo que sea yo quiero que en 192 se deje aquí digamos sobre escrito el 01:55:38

valor veréis que cuando yo detenga la ejecución del juego vuelve a 500 que es el que yo había 01:55:46

metido a mano esto significa que hay cambios que podemos ir haciendo en el o más fácil mirad si me 01:55:51

estoy yendo por las ramas tengo aquí colocada la nave y quiero que se mueva y lo voy a ir cambiando 01:55:57

en tiempo real en estas coordenadas vale quiero cambiarlo en estas coordenadas todos estos cambios 01:56:03

que yo voy haciendo vale todos estos cambios que yo voy haciendo imaginaos que yo hay un momento 01:56:08

que voy a decir quiero que la nave se quede aquí que la he ajustado pero como estoy en ejecución 01:56:13

durante la ejecución los cambios que vamos haciendo sólo funciona durante la ejecución cuando yo pare 01:56:18

vuelve a los valores que tenía antes de la ejecución vale por tanto cambios que hagamos en vivo el 01:56:25

siguiente tema vamos a hacer cuidado que se hacen y no se guardan vale por eso veréis que cuando yo 01:56:30

le doy al play se oscurece un poco el área vale se oscurece un poco el entorno vale indicando que 01:56:37

estamos dentro de la ejecución y un poco advirtiendo que cambio que hagamos en los parámetros pues no 01:56:43

se guardan vale último consejo para cambiar este color y que sea aún más obvio cuando podemos o 01:56:47

no cambiar los elementos sin que se guarden vale dentro de edits hay una pestaña de preferencias 01:56:55

creo que siempre confundo estas dos en preferencias edit preferencias están los colores del sistema 01:57:04

vale ya hay uno bastante interesante de modificar que yo ya lo haría y esto se guarda siempre que 01:57:10

no instaléis otra versión de unity o vayáis a otro ordenador etcétera es decir entre distintos 01:57:18

juegos incluso que uséis la misma versión de unity se va a mantener en vez de decirle que 01:57:24

sea el tintado de este gris tan sutil que tenemos lo podemos exagerar a ello que sea un rojo de 01:57:28

cuando lo tengamos ahí configurado el play mode tint el tinte de modo de juego ahora cuando ejecutemos 01:57:34

el juego vais a ver que se tiñe de otro color lo podéis poner más o menos llamativo ahora todo 01:57:40

cambio que vayamos haciendo mientras estemos en este modo vale sabemos que cuando detengamos 01:57:46

la ejecución del juego placa no ha servido para nada excepto a lo mejor para tener clara la 01:57:52

referencia de dónde queremos ubicar algo en este caso etcétera vale entonces es importante que a 01:57:57

lo mejor cambies ya en edit preferencias este color ponerlo en algo intermedio no tan rojo 01:58:02

saturado porque al final este color se añade al que tiene ya la interfaz pues yo que sé algo así 01:58:12

rosadito y cuando le deis pues ya os marca que estáis como en el momento warning 01:58:16

bueno sé que os he dicho muchas cosas la grandísima mayoría están en los apuntes 01:58:24

realmente de una forma quizá menos desarrollada no claramente pero bueno que espero que poco a 01:58:30

poco vayáis teniendo un poquito más de información y la vais ubicando bien cuando arranque mañana el 01:58:37

tema 2 vais a ver que hay más tipos de variables aún los usos y vais a empezar a implementar cosas 01:58:43

que hemos estado viendo y hasta ahora son un poco abstractas vale y empezaremos a ver los 01:58:51

condicionales las funciones etcétera poco a poco vale vale qué tal mucha sobrecarga de cosas 01:58:56

un poco vale bueno estamos en noviembre pues queda mucho y yo intento meter un poco de caña 01:59:05

porque sí porque si no esto se va a complicar como el año pasado una locura tan con tu asignatura 01:59:14

no pero como que al final se acumula mucho a final de curso a que mejor ir poco a poco yo 01:59:22

en este módulo en el montaje no lo digo tanto pero en este módulo creo que fue de las primeras 01:59:27

frases que dije como no la llevéis al día va a costar mucho mucho y bueno y si os queréis 01:59:31

dedicar a algo de desarrollo de juegos pues con más razón 01:59:36

Tutoría 2 - DEIM - UT1 y 0 - Curso 23·24 - 28 Noviembre - Contenido educativo

Del mismo autor…

Videoreseña de Nicole y Gema

3.012026-ProyectoAD-IreneTorres

Villancico Navidad

Tutoría 3 - DEIM UT0 - Curso 25·26 - 14 de enero de 2026

MOTIVACIÓN KENA

RAPA NUI MOTIVACIÓN MOAI

Expresiones Algebraicas I