Tutoría 1 - DEIM - UT1 y 0 - Curso 23·24 - 16 Noviembre

Bueno, pues bienvenidos a esta primera tutoría. Como os estaba comentando, para aquellos, estaba 00:00:00

hablando un poco con los compañeros, para aquellos que lo estáis viendo en diferido, etcétera, 00:00:06

por favor, este módulo lo aconsejo en todos, pero en este módulo especialmente os sugiero que vayáis 00:00:10

un poco con el tema realidad a medida que se van proponiendo las tutorías para ir viendo los 00:00:18

errores o los problemas o todo lo que os suponga un problema de comprensión, digamos en el momento, 00:00:23

porque vamos al concepto de programación y va a ser, bueno, pues quien no haya programado nunca 00:00:30

pues tiene que irlo asimilando poco a poco y es un poco el recorrido que vamos a hacer estos meses. 00:00:35

Bueno, en la anterior tutoría inicial ya se habló de cómo instalar Unity, el Unity Hub, 00:00:40

el Unity Editor, un poco los paneles, esa parte la voy a dar un poco por supuesta y voy a proceder 00:00:48

un poco a ir resolviendo dudas de la tarea 1, especialmente a partir de cuando entramos en el 00:00:54

código que es al instanciar. Voy a compartir pantalla. Entiendo que veis el Unity Editor, ¿verdad? 00:01:01

Si me podéis confirmar, porfa. Sí, vale, genial. Vale, en esta práctica hay una parte que a no ser 00:01:11

que tengáis problemas claros, no me voy a meter mucho, que es la creación del prefab, porque creo 00:01:19

que está suficientemente bien explicada dentro de las dudas que os puedan surgir, que por favor si 00:01:26

tenéis alguna me vais diciendo. Sí que hay un concepto, que es el de prefab, que yo tengo aquí 00:01:32

por ejemplo preparada mi nave, que quizá cuando vais siguiendo un poco las instrucciones pues 00:01:38

o pasáis por alto, porque también es normal, o que pueden generar dudas. Al final un prefab 00:01:44

no deja de ser un objeto, como se explica, que está guardado para poder ser reutilizado en 00:01:50

distintas partes de proyectos o instanciado. Instanciado es generar copias de un mismo objeto. 00:01:57

Y lo voy a usar de referencia en varios momentos. Por ejemplo, si en un videojuego, y perdonad que 00:02:05

remita a videojuegos violentos, pero es que suelen abundar mucho, cuando disparamos una bala con la 00:02:10

metralleta, imaginaos que cada bala es un objeto, que ese proyectil va volando por el aire. Bueno, 00:02:16

pues tenemos ya un prefab de esa bala y lo que vamos haciendo es lanzar copias de esa bala, 00:02:22

de una única bala. A lo mejor tenemos prefabs de bala de jopeta, bala de metralleta, yo que sé, 00:02:26

pero al final, a menos que lo hagamos con otra finalidad, va a ser ese prefab que se va duplicando. 00:02:32

Como hemos visto los prefabs, y tengo aquí uno preparado en el panel de proyectos y lo puedo 00:02:39

importar, meter en el proyecto, incluso meterlo dentro de la jerarquía, vais a ver que viene 00:02:45

marcado con este texto azul, con la cajita azul. En el panel proyecto vais a ver, normalmente, 00:02:49

ya la geometría del prefab. Por ejemplo, aquí veis la nave. Y atención, porque aquí podemos 00:02:57

hacer zoom y hay una forma, que no es que haya un menú de ver en modo lista ni en modo visualización, 00:03:01

que es que si quitamos todo el zoom, vamos viendo los elementos con iconitos y en listado, que a 00:03:07

veces es más interesante para saber de qué se trata cada elemento. Al ver esta caja azul sabemos 00:03:13

que es un prefab y lo tenemos ahí preparando. Y habéis visto que yo puedo empezar a meter aquí 00:03:18

el prefab 85 millones de veces. Lo podemos tener aquí para hacer un escuadrón. No sé si ahora 00:03:24

habéis visto el típico juego que hay de alguien que va corriendo y va pasando por un más 10, por 2 00:03:30

y se va multiplicando. No, eso al final son que se van instanciando más o menos prefabs a medida que 00:03:38

se van cumpliendo ciertas condiciones. Bueno, una vez dicho esto, algo importante y me 00:03:43

vuelvo a referir a la bala de la escopeta. Imaginaos que ahora en vez de la nave es una escopeta. El 00:03:48

prefab cuando lo generáis, que lo podéis ir generando, como ya habréis estado haciendo los 00:03:54

que comenzaste la tarea, a generar aquí los elementos con la geometría, etcétera, con las distintas 00:03:58

primitivas que se pueden poner en Unity. Y lo que hacemos es arrastrar, pues imaginaos 00:04:03

que este cubo es lo que queremos convertir en prefab. Para convertir en prefab cogéis de la 00:04:09

jerarquía los elementos, podéis seleccionar varios, y lo arrastráis al panel de proyecto y se 00:04:15

genera un prefab. En este caso es un cubo. Bueno, pues es un prefab bastante básico. Si fuera una 00:04:20

esfera pues podría ser la bala. Si queréis editar este prefab, bueno y ved que he borrado el prefab 00:04:26

que había generado y aunque esté en la escena, es verdad que se pone en rojo como avisando de 00:04:32

oye el prefab de origen no está. Te dejo el objeto aquí pero esto ya no es un prefab. Si 00:04:36

visual esta indicación roja significa eso. Imaginaos que tenemos ya la nave y ya la hemos 00:04:42

preparado y está ahí como un prefab. ¿Cómo se edita un prefab? Porque esto al final es como cuando 00:04:49

en cualquier software se mete en una carpeta, en un folder, en un bin, varios objetos de la jerarquía 00:04:55

que se van aquí poniendo una dentro de otra, como habréis visto también en la tarea. Cuando 00:05:01

vayamos teniendo estos elementos y los convertimos en prefab, pues igual lo tengo aquí como prefab, 00:05:06

lo borro todo y digo vale pues tengo aquí el prefab que lo puedo duplicar pero esto cómo se 00:05:11

edita luego. Para editar un prefab es fácil o le dais doble clic al elemento o al propio elemento 00:05:19

también de la jerarquía, se puede de cualquiera de los dos puntos, en este caso el cubo, voy a abrir 00:05:27

la nave, mi nave. Cuando hagáis el prefab, pues para reeditarlo y recolocar elementos, doble clic 00:05:31

y se os abre esta área como azul, un poco tron, ahí esperando a que hagamos cosas. Esto se 00:05:37

identifica, para que sea fácil, con dos pistas visuales. Una, aquí vais a ver en el panel de 00:05:43

escena que hay unas migas de pan para ir viendo que este prefab está metido dentro de escenas 00:05:52

porque lo hemos abierto desde donde está aquí incorporado, en una de las escenas está 00:05:58

este prefab aplicado y aquí podemos ir variando todos los elementos que componen ese prefab, 00:06:05

que al final veis que es como una especie de empaquetado de geometrías que tenemos ahí con 00:06:11

una jerarquía, esperando a que se instancie. Si en algún momento queremos cambiar el prefab, 00:06:15

pues nos metemos dentro del prefab y aquí podemos ir modificando cada elemento como en la jerarquía 00:06:20

de la escena habitualmente. Sí que es verdad que es importante, aquí hay una opción que se llama 00:06:25

autosave, que por defecto a mí me aparece marcada, debería aparecer marcada, que nos puede interesar o 00:06:31

no, porque esto significa que todo cambio que vayamos haciendo de los elementos se irán guardando 00:06:37

en el prefab automáticamente. Si lo desmarcamos, veréis que yo, si por ejemplo el alerón lo muevo 00:06:43

un poco, pues si yo saliera no se está guardando, habría que dar a este save que ha aparecido aquí, 00:06:50

que a veces cuando intentáis salir del prefab os dice oye pero guardas o no, eso dependerá de 00:06:54

cómo lo estáis gestionando. Si queréis volver, dice ya he terminado y lo voy a dejar mal, esta 00:07:00

pieza la he dejado un poco, que es el alerón trasero vertical este que he puesto, lo dejo así, 00:07:06

movido de sitio, si os fijáis. Si yo guardo y salgo, para volver a la jerarquía o al escenario, 00:07:12

aquí está esta flechita que nos sirve para volver al proyecto, para ir para atrás o también 00:07:20

podemos incluso dar a esa miga de pan que tenemos. ¿Qué pasa? Que ahora incluso si lo veis en la 00:07:26

miniatura, ese alerón se ha movido y se ha guardado como movido, si yo ahora lo duplico va a tener el 00:07:31

alerón ahí flotando, lo ha instanciado todo. Y esto es lo que me sirve para primera cosa que suele 00:07:36

haber de problema en vuestras entregas de esta tarea, que es tener en cuenta, imaginaos que cuando 00:07:43

hagamos las instancias del objeto, vuelvo a remitir a la bala, nosotros luego vamos a dar un punto de 00:07:49

referencia donde se va instanciando esa bala, desde donde se emite ese proyectil. En el caso 00:07:56

de una bala pues lo suyo será poner la boquilla de la pistola o del arma que sea, para que a 00:08:01

partir de ahí vaya para adelante en profundidad. Si ese elemento que estamos instanciando está 00:08:06

movido del cero cero de ese origen, imaginaos que hago esto, si yo me muevo de aquí, cuando yo 00:08:14

instancia esa bala, si no lo corrijo de algún modo, va a identificar que desde donde se lanza, 00:08:22

imaginaos que aquí está la boquilla de la pistola, va a estar ya movido desde ese punto. Por tanto, 00:08:27

ojo, si queréis instanciar algo en un punto concreto, aseguraos de que todo esté en el cero 00:08:34

cero de origen. Es decir, ahora mismo lo está y veis que aquí hay un elemento padre, que es el 00:08:41

nave prefab, que está con todo intacto, y luego he ido haciendo hijos a los distintos elementos de 00:08:46

la jerarquía. ¿Por qué pongo otro padre? Está el elemento empty, que es como un nulo, 00:08:52

como un null en otros software de 3D, etcétera, que cuando lo creáis está vacío, pero sirve para 00:09:00

colocar elementos dentro de otros elementos y dar coordenadas. El elemento padre padre de un prefab, 00:09:05

cuando estamos dentro del prefab, digamos que no puedes poner nada por encima de la jerarquía de 00:09:12

ese elemento, por tanto diría que este elemento, por defecto en los prefabs, debería estar siempre 00:09:18

configurado para que estén las coordenadas de origen, que son los ceros de posición, los ceros 00:09:23

de rotación y a uno de escala. Ojo, la escala por defecto es 1 en las tres dimensiones. Y luego, 00:09:28

dentro de eso, nos aseguramos a modo visual que esté todo donde queremos que esté. Así, 00:09:35

cuando instanciemos, nos aseguramos que este padre es el origen del prefab y luego ya iremos 00:09:41

distribuyendo los elementos. Luego hay otra cosa a considerar que os pone, que es que la nave 00:09:47

tiene que estar mirando hacia la Z en profundidad. Si os fijáis en este gizmo del mundo, dado el 00:09:55

juego que vamos a hacer luego, que va a ser un endless runner, que va la nave en profundidad y 00:10:03

van apareciendo obstáculos, un poco como el Subway Surfer, no sé si lo conocéis. Yo os voy a 00:10:09

enseñar para que tengáis en cabeza hacia dónde se dirige esto, lo enseño muy rápido. Esto será 00:10:13

de la tarea 2, es el siguiente paso. Pero lo que vamos a buscar, ahí lo tenemos, es un juego como 00:10:18

de estas características, todavía feo etcétera, pero que va a ir esquivando los pivotetes estos 00:10:26

que van apareciendo. Lo que vamos a hacer es que esta nave va en profundidad. Si el prefab lo 00:10:31

incorporamos angulado hacia otra dirección, luego habrá que hacer otra operación para reenderezarlo. 00:10:38

Por tanto, igual que con lo de la bala, lo mismo. Si queremos que esté en el punto de origen y 00:10:43

orientado correctamente, pues hay que tener en cuenta que el mundo está mirando en Z en profundidad. 00:10:50

¿Hasta aquí qué tal? Los que habéis estado probando, ¿cómo lo veis? Esto es ponerse y probar. Creo que 00:10:56

no tiene más complicación que saber meterte en un prefab, etcétera. Luego hay otra cosa para 00:11:05

que lo vayáis teniendo en cuenta, que es que cuando vamos instanciando o metiendo en la jerarquía 00:11:12

distintos prefabs, de pronto puede haber una de estas instancias, por ejemplo esta nave. 00:11:16

Veis que aquí se han acumulado unas cuantas, que yo le quiero poner un material o 00:11:22

darle otro componente, meterle un componente, como por ejemplo un Rigidbody. En los siguientes temas 00:11:29

lo vamos a ver. Metemos un componente. Recordad, esto lo dije el otro día, que los distintos 00:11:38

elementos que van sumándose a cada objeto se llaman componentes, que son lo que van metiendo 00:11:43

las propiedades que tiene ese objeto. Un Rigidbody, si le doy a play, vais a ver que es un objeto 00:11:50

que lo que hace es meter gravedad al objeto. ¿Qué ha pasado? Esto me sirve no para hablar del Rigidbody 00:11:59

en este momento, todavía no es el momento, sino para que veáis que tengo un prefab de todos los 00:12:06

que ya he metido, que es diferente al resto, que tiene un Rigidbody. Por defecto este de origen 00:12:11

no tiene el Rigidbody, pero a lo mejor estamos trabajando en uno de estas instancias y 00:12:17

hemos metido un elemento nuevo. Esto lo vais a ver a nivel visual, porque vais a ver que 00:12:22

donde está el iconito del componente, os añade un más, en plan está añadido a una instancia 00:12:29

del prefab. Podemos seguir obviando que esto es un añadido y seguir trabajando, porque esta 00:12:35

nave va a ser diferente al resto, o hay una opción aquí, cuando metáis un prefab va a aparecer 00:12:43

esta línea, para abrir el prefab como hemos hecho, para seleccionarlo de la jerarquía, y otro que son 00:12:48

los overrides. Los overrides sirven para, diciendo lo que tiene diferencial marcado con este más, 00:12:53

esa diferencia que hay con el prefab, decir yo lo que quiero es que todos los prefabs que deriven 00:12:59

de este, pues he pensado que tenga este Rigidbody, entonces si le damos a aplicar, vais a ver 00:13:05

que se aplica ahora a todas las instancias que tenga este prefab, por tanto es otra forma 00:13:12

de modificar también una instancia. Incluso aquí podemos ir abriendo la nave y decir no, es 00:13:19

que la nave no quiero que tenga alerones, veis que estoy trabajando no dentro del área de prefab, sino 00:13:29

dentro de la jerarquía, en una instancia. Si yo borro esos alerones, en los alerones justo me va a 00:13:34

decir, oye esto es un hijo de un prefab, si borras esto pues te está variando el prefab, lo tendrías 00:13:40

que hacer del prefab o tendrías que hacer una variante, y aquí es donde se podría borrar y 00:13:45

luego guardar. Hasta aquí, no sé si tenéis alguna duda, algo que me queráis decir, algo que 00:13:50

queráis que explique más relacionado con esto, si no paso a las siguientes cosas. 00:13:57

Nada, vale. Vamos a empezar a hablar de programación. Yo no sé de vosotros si alguno 00:14:03

ya ha programado alguna vez en otro lenguaje o tiene nociones, entiendo que muchos no, lo cual 00:14:15

es lógico. Vale, entiendo que si alguien tiene nociones, que me lo diga y así también le uso 00:14:23

un poco de ayudante en algunas cosas. El otro día dije que lo que son, algunos lo han 00:14:31

montado en Java, bueno pues ya salgo. Hablé de que se podían añadir código, todas las 00:14:40

funcionalidades que vamos a ir añadiendo, va a ser a través de estos componentes que os he indicado, 00:14:47

o añadiendo nosotros código que vayamos programando, que a fin de cuentas también se 00:14:51

añadirá como un componente. Para eso se generan lo que se llaman scripts. Y estos scripts ya vimos, 00:14:56

voy rápido porque esto lo expliqué el otro día, que se generan con clic derecho, crear y aquí 00:15:04

tenemos una opción de generar un script de César, que es el lenguaje de programación en el que 00:15:09

trabajamos. Ya os comenté y lo pone en los apuntes, que cuidado con el nombre que demos al script por 00:15:13

defecto, porque luego se va a ver reflejado dentro del código, y si no coincide este 00:15:19

nombre con el nombre de la clase del código, la clase es digamos el patrón que se va a usar en 00:15:29

el código para ir organizando los distintos códigos, pues si no coincide dará problemas. 00:15:36

Entonces he generado este script y si quiero que se vean los resultados de algún modo, habrá que 00:15:42

meterlo como componente en algún elemento. Ahora vamos a hacer operaciones matemáticas y al final 00:15:48

del todo un instance hit, para ver cómo se hace un poco lo de la tarea. Pero para que se aplique 00:15:54

este código a algo, ahora mismo simplemente está aquí preparado y si le doy doble clic se abrirá 00:16:01

vuestro Visual Studio, que tendréis aquí. Veis esta bonita pantalla de hacker que se nos ha quedado, 00:16:06

con un poco ese código abierto preparado para trabajar. Aquí vais a ver que este nombre y 00:16:13

este coinciden, y tienen que coincidir, ya lo expliqué el otro día, por eso si no tenéis dudas 00:16:20

no lo voy a repasar más, pero aquí tenemos la conexión entre el archivo que está trabajando 00:16:24

operando dentro de Unity y lo que va a responder a nuestro código. Por tanto si cambiamos alguna 00:16:30

letra aquí o algo, habrá que cambiarlo en ambos puntos. Importante, aquí ya de hecho tengo 00:16:36

algunas carpetas, habéis visto la de prefabs, donde tenía los prefabs, para generar carpetas clic derecho 00:16:44

crear, aquí es prácticamente donde se crea todo lo que podemos tener para el proyecto, hay 00:16:50

uno de folder. Os recomiendo que vayáis organizando, esto lo ponen los apuntes también, por tipología 00:16:54

de elemento. Entonces yo por ejemplo tengo aquí algunos que he estado yo trabajando, los quiero 00:17:00

tener ahí preparados, pero este que va a ser durante la tutoría, lo meto en la carpeta durante, para 00:17:05

tenerlo ahí, para saber cuáles son los de durante y los que tenía de antes. Lo dicho, tenemos 00:17:10

aquí el script abierto esperando para operar, y por mucho que yo escriba aquí hasta, bueno, no por mucho, 00:17:16

hay otros que no hará igual falta, esto ya es más avanzado, pero si queremos que lo que yo vaya 00:17:22

aplicando a este código se vea reflejado en algún momento en el programa, habrá que meterlo como 00:17:27

componente en algún elemento. Ahora mismo vamos a hacer, porque va a ser a nivel teórico, vamos a 00:17:32

generar un vacío, no va a afectar a un objeto visual, visible, y va a servir para 00:17:37

cálculos, por ejemplo, va a ser un objeto vacío al que yo vinculo, y mirad que para vincular un script 00:17:44

puedo arrastrar desde aquí al inspector y se incorpora como otro de los componentes. Si lo 00:17:50

quiero eliminar, las opciones de eliminar, de copiar, etcétera, están en estos tres puntos, lo voy a 00:17:58

eliminar, porque también se puede añadir, igual que se puede hacer, por ejemplo, con los componentes, con 00:18:04

los efectos, digamos, por decirlo de una forma rápida e inteligible, todos los que ya vienen 00:18:09

configurados también se puede buscar por aquí como para añadirlo. Hay uno de cálculos, que es el otro 00:18:17

que tenía, y cálculosTut. Fijaos, de hecho, cuando leáis sobre el PascalCase y el CamelCase, 00:18:23

cómo se deberían escribir las palabras en programación, aunque aquí haya puesto 00:18:30

cálculosTut todo seguido, fijaos que el propio programa, yo ya cuando lo meto en el archivo, sabe 00:18:36

separar estos nombres, para que veáis que ya está pensado esto, y hay que ir siguiendo estas 00:18:41

nomenclaturas que iremos viendo, y que ya en el tema 0 se habla de varias. Hasta aquí, no sé si hay 00:18:46

alguna duda. Vuelvo a abrir el código. Ahí lo tenemos. Ahora ya está, digamos, en un objeto dentro 00:18:52

de Unity, esperando a operar con él. ¿Qué tal? ¿Hasta aquí qué tal? ¿Alguien tiene dudas? Os abro un 00:19:00

segundo, que igual alguien me está escribiendo y no lo he visto. Sí, la opción, Elisa, es CSARP. 00:19:08

CSARP es el lenguaje de programación, C almohadilla, si lo hispanizamos. 00:19:18

CSARP Script, se crea uno nuevo y ya genera eso, y importante, según le das a crear, ya te pide 00:19:24

el nombre, pues tenerlo ya pensado, no lo dejes para más tarde, y así en estos momentos, sobre 00:19:31

todo, que igual nos puede generar problemas, pues lo metemos ya. Perfecto, pues estamos 00:19:36

aquí con CalculoStud, y vamos a hacer nuestra primera operación matemática. Y os voy a decir 00:19:43

algo, que es que casi todo lo que vais a hacer consiste en operaciones matemáticas, y en lógica 00:19:50

de que se cumplan condiciones o no. Es decir, todo por detrás suelen ser números, o interpretaciones 00:19:59

de números. Entonces, aunque ahora una suma parezca una tontería, al final casi todo lo vamos a ir 00:20:05

controlando con números, ¿vale? Entonces es importante saber operar con las opciones que nos 00:20:11

da. Para empezar a programar, y esto, quien haya programado en cualquier lenguaje, hay un 00:20:17

concepto que es el primario, digamos, que es la variable. La variable, digamos, es un elemento 00:20:23

en el que se van guardando espacios en la memoria con una información. Por ejemplo, quiero que 00:20:28

haya un número al que puedo referenciar con otra palabra. Voy a hacer primero una operación 00:20:36

matemática, y luego vamos a ver qué son las variables. Para empezar, cuando abrís este código, 00:20:46

aparecen aquí varias líneas, que ahora mismo no me interesan tanto, pero son estas tres. Son 00:20:51

librerías que hay dentro del Visual Studio, que es el IDE, el administrador de desarrollo que 00:20:56

tenemos. Cuando vamos añadiendo estas librerías, nos va dando posibilidades de ir usando como 00:21:04

opciones ya preconfiguradas por desarrolladores que han hecho este sistema. Si yo borrara esto, 00:21:14

por ejemplo, lo hago muy rápido, vais a ver que empiezan a surgir fallos, y los fallos vienen 00:21:20

marcados con estos subrayados rojos. Veis que el MonoBehaviour, que no sabemos lo que es, 00:21:25

pero funciona, parece, supeditado a estos sistemas. Así que no aburráis nada hasta que no sepáis lo 00:21:30

que es, pero son líneas que están proporcionando ya características preechas para el código. Luego 00:21:38

aquí hay una línea que veis que se llama igual que el archivo. Ya veremos un poco más qué es esto de 00:21:44

clase, etcétera. Pero a partir de estas llaves, y vais a ver que cuando marca una llave, se marca 00:21:50

otra llave, una de apertura y una de cierre, porque este lenguaje, como los que si habéis visto el 00:21:58

tema 0, los que se suele trabajar en lo que se llama programación orientada objetos, más avanzado, 00:22:04

ya le iréis dando vueltas, se van estipulando en bloques. Estos bloques significan que hay 00:22:09

una llave de apertura y una llave de cierre que delimita un área. Ahora mismo, de aquí a aquí, 00:22:17

pues hay un área y dentro de ese área, de ese bloque, es donde vamos a ir añadiendo las 00:22:23

instrucciones que se van a ejecutar, por ejemplo en este caso, dentro de esta clase. Si veis esta 00:22:28

llave, comprende todo lo que hay aquí dentro. Y luego vais a ver otras llaves, por ejemplo aquí. Y esta 00:22:34

llave, cuando marco esta, veis que tiene su correspondiente llave de cierre. Y aquí es donde 00:22:39

se irá ejecutando, por ejemplo, lo de este Start o este Update, este método Update. Esto ya 00:22:44

veremos ahora qué es. También tiene un área de influencia, donde yo iré escribiendo código y se 00:22:50

ejecutará lo relacionado con Update. Entonces aquí es muy importante que lo que se abre se cierre a 00:22:56

nivel de llaves y a nivel de paréntesis. También veis que se suelen abrir y cerrar aunque estén 00:23:03

vacíos y parezca un sinsentido. Ahí están esperando. Dentro de este bloque iremos haciendo operaciones, 00:23:08

pero veis que este bloque ya tiene, digamos, dos bloques aquí también, esperando que hagamos cosas. 00:23:15

Esto es porque Unity ya, a través de la herencia de otra clase, como de otra carpeta de posibilidades 00:23:21

que alguien ha hecho antes, los que han desarrollado CSAR para trabajar en Unity, 00:23:29

pues ya ha generado ciertas funciones, como este Start y este Update, para poder ejecutar en ciertos 00:23:34

momentos. CSAR se usa también para programar de otro tipo, etc. Incluso si veis tutoriales en 00:23:42

internet de CSAR, de Aprende CSAR, si no está aplicado a Unity, vais a aprender CSAR, el lenguaje, 00:23:48

pero veréis que por definición va a haber una cosa llamada Main, pues otro método que está 00:23:53

pensado para otros usos. Aquí digamos que está adaptado, igual que un lenguaje luego tiene 00:23:58

dialectos, por decirlo así, pues este ya está adaptado para lo que se hace en Unity, que es 00:24:03

desarrollo de aplicaciones, videojuegos, etc. Entonces, si pensamos fríamente, cuando estamos 00:24:07

jugando en un videojuego, lo que vamos a tener es unas interactividades, unas interacciones que 00:24:13

vamos a ir haciendo, y el programa en todo momento tiene que ir captando lo que hacemos o no 00:24:18

hacemos, para si en el mando damos a la X, pues que salte, si es lo que hemos configurado. 00:24:23

También va a haber operaciones que queremos que se ejecuten según se lanza el juego. Por ejemplo, 00:24:31

que se configure el nivel, se cargue, que se ponga que la vida está al 100%, etc. Y ese es otro 00:24:39

momento del juego, que es al iniciar. Estos dos métodos que tenemos aquí sirven, uno, 00:24:47

para meter instrucciones que se ejecutan según se abre o se aplica dentro del juego este código, 00:24:52

al arrancar este código, en el Start, lo que yo diga, se va a ejecutar. Y luego va a haber aquí 00:25:00

otro bloque, en base a otro método, que es este Update, a ver la traducción que ahora no me sale, 00:25:06

como de actualización, de actualizar, que constantemente, fotograma a fotograma, 00:25:13

va a ir mirando qué hay aquí dentro, para fotograma a fotograma, irlo ejecutando. 00:25:17

Entonces, lo primero, lo que metamos aquí, dicho rápido, se ejecutará al iniciar el juego, 00:25:21

a no ser que este código se ejecute posteriormente, y será cuando empiece a ejecutarse ese código, 00:25:29

y este Update se irá ejecutando fotograma a fotograma. Esto lo vamos a entender en poco. 00:25:34

Vamos a escribir, lo ha dicho el compañero, nuestro primer Hola Mundo, que es una frase 00:25:40

que se usa en programación para comprobar que la consola de programación del programa, 00:25:47

la consola es una especie de ordenador que va a ir reflejando qué operaciones se están 00:25:55

desarrollando en cada momento, aquí está más simplificado que en otros usos, pero vamos a 00:26:02

lanzar a consola, ahora veis lo que es eso, nuestra primera frase, que va a ser ese Hola Mundo, 00:26:09

y vamos a ver nuestra primera operación. Va a haber un montón de palabras reservadas, 00:26:13

de palabras clave, de propiedades, etcétera, que tenemos que ir aprendiendo e ir manejando. 00:26:18

La primera que vamos a hacer es cómo hacer que nuestro programa lance una frase. Vamos a conseguir 00:26:23

que a través de Unity ver la frase que nosotros le digamos. Para eso hay que escribir debug, 00:26:30

y veis algo importante, que cuando empecéis a escribir algo os empieza a salir aquí como 00:26:37

ayudas. Esto es un sistema en Visual Studio que se llama IntelliSense, que lo que va haciendo es 00:26:42

detectar lo que vamos escribiendo para darnos sugerencias de, oye, pues esto puede completarse 00:26:47

con estas opciones, que en todas veis que hay un tran, pues si sigo ir afinando, pero esto viene 00:26:54

muy bien para ir sabiendo qué opciones hay que podamos ir seleccionando. La primera instrucción 00:27:00

es este debug, y dentro de cada instrucción, digamos que luego, dentro de cada clase en este 00:27:07

caso, luego va a haber como propiedades hijas de esta operación. Por ejemplo, debug, si le 00:27:15

damos al punto, de pronto van a salir muchas opciones, no hemos escrito más. Pues debug a 00:27:24

ser debug log, que es la que nos interesa. Entonces quiero que en programación interpretéis los puntos 00:27:28

como separadores en jerarquías inferiores, me explico, como unas migas de pan que hemos visto 00:27:34

antes. ¿Qué significa esto? Supongo que todos habéis rellenado la típica ficha que os preguntan 00:27:40

cuál es vuestro país, y luego cuál es vuestra ciudad, y luego cuál es vuestra calle, y luego 00:27:46

cuál es nuestro número. Y cada opción consecuente, cada opción va a ser dependiente del padre, es 00:27:53

decir, si ponéis que sois de EEUU, pues luego saldrá aquí la opción de poder elegir entre los 00:28:00

estados. Pero si elegís España, pues lo que van a salir son las comunidades autónomas. Cada 00:28:05

caso irá desbloqueando nuevas opciones. Entonces siempre se va a ir de lo general a cada vez lo 00:28:10

más concreto. Debug, que sirve sobre todo para depurar código, para encontrar 00:28:17

errores. Si damos al punto, tiene dentro muchas operaciones relacionadas. La mayoría 00:28:25

de ellas no las vamos a necesitar, pero hay una muy importante que vais a aprender, que es esta 00:28:33

que se llama debug.log. Damos doble clic y ahí está. Cuando estamos ejecutando una acción con 00:28:39

código, vais a ver que siempre, o prácticamente siempre, vais a tener que abrir y cerrar unas 00:28:46

unos paréntesis. Y esto alude otra vez a estos paréntesis, por ejemplo, que tenemos aquí, sin 00:28:54

rellenar, porque ahora mismo esto nos interesa que esté vacío. Pero hasta que no ponemos estos 00:29:00

paréntesis, digamos que el software, el Visual Studio, nos sabe que estamos lanzando una instrucción 00:29:07

de hacer algo, que es lo que se llama lanzar un método o lanzar una función. Debug.log, 00:29:14

como funciona, por ver el primer uso, sirve para aquí, entre comillas, ahora os digo por qué, podéis 00:29:21

poner la frase que queráis lanzar, desde el hola mundo, que es la que vamos a lanzar ahora, pero 00:29:28

bueno, lo voy a hacer más personal. Hola mundo, Daniel. Y vais a ver que aquí nos sigue 00:29:33

marcando un fallo. Está aquí subrayado con un fallo. Os dije el otro día que para que se vea 00:29:38

reflejado algo que hagamos en código, atención que aquí arriba tenéis el nombre del archivo y va 00:29:44

apareciendo un asterisquito. Esto también os lo conté ayer, por ejemplo, en Premiere, que veáis que esto 00:29:49

pasa en muchos, un asterisquito que indica que es que no está guardado. Hasta que yo no haga 00:29:54

CTRL-S, yo no estoy guardando el código y hasta que yo no guardo el código, por tanto, siempre hay 00:29:58

que estar dando CTRL-S cuando queramos hacer algo, aunque yo vaya a Unity y haga lo que tenga que 00:30:03

hacer, no se va a ver reflejado. Tenemos que ir guardando. Y ojo, mirad que aquí y aquí también 00:30:07

tenéis asterisquitos. Son dos software diferentes, Visual Studio y Unity. En uno estamos trabajando el 00:30:16

código, que habrá que ir guardando también, y en otro iremos trabajando en todo lo que nos 00:30:21

ofrece esta interfaz destinada a desarrollo de videojuegos a nivel gráfico. Aquí también puedo 00:30:28

hacer CTRL-S e ir guardando. Veis que ahora se ha ido el asterisco. Aquí se ha guardado todo lo 00:30:34

relacionado a nivel visual, pero si yo cambio algo en Unity, en código, son independientes 00:30:38

cada uno de ellos. Entonces atención de si algo no funciona, que aquí no esté el asterisco, porque 00:30:44

igual todo lo que habéis cambiado no se está viendo reflejado. Y veis que aquí está este error. 00:30:50

Si aquí hay algo subrayado rojo, vuestro programa no va a funcionar. Va a dar fallo, va a dar error, 00:30:55

porque no está sabiendo ejecutarlo. Y esto lo veis si vais a Unity. Aquí abajo ya sale 00:31:01

una exclamación roja que algo nos dice que no está yendo bien. Y de hecho yo intento ejecutar 00:31:08

el juego, aunque ahora no tenga nada. Le doy y dice todos los errores de compilación tienen que ser 00:31:14

arreglados antes de poder proceder al modo de juego. Por tanto veis que a mí no me deja hacer 00:31:18

nada en el área de game, porque está habiendo un error. Esta línea roja que hay aquí realmente es 00:31:24

una especie de resumen de lo que podéis ver en el menú consola. Si dais a consola, 00:31:32

aquí sale aún más grande la exclamación y es el mismo error. Hay verdad que aquí pueden salir 00:31:38

muchas más líneas, muchos más errores. Se puede llenar, pero aquí digamos que os va poniendo como 00:31:43

la última o la principal que tenéis que ver. Son las mismas. Si leís la línea es exactamente lo mismo. 00:31:48

Y esto más adelante va a venir bien si queréis acceder a lo que está dando este fallo. Si le 00:31:54

dais doble clic, lo debería abrir. A mí me lo ha abierto en otro lado porque tengo otra ventana, 00:31:59

pero lleva a la línea de ese error. Me está aquí marcando dónde está el error. Es una buena 00:32:05

forma de saber de dónde viene. Le dais doble clic y decís, oye, ¿qué pasa? ¿por qué esto 00:32:10

está yendo mal? Aparte aquí os pone también tanto el nombre del script del que está 00:32:16

surgiendo el error, la línea 1140, la línea y la columna que está dando el error. Si nos metemos 00:32:23

en el código vemos que es la línea 11, por eso no lo va numerando, y la columna que no está 00:32:29

detallada es la línea 40. Aquí podéis ir viendo todos los problemas que podéis ir 00:32:34

viendo de una forma también descrita. Aquí también pone el error. Aquí suele poner el 00:32:42

motivo y es que espera un punto y coma. A nivel de sintaxis, de trabajo de este código, de CISAR, 00:32:47

de este lenguaje, toda instrucción que vayamos dando, toda línea, debe acabar en punto y coma 00:32:56

para ir separando las distintas órdenes que vamos ejecutando. Hasta que no ponga punto y línea, 00:33:02

pues esta orden no se sabe hasta dónde llega, entonces hay que delimitarla en algún momento. 00:33:09

Vemos que no da error y voy a ir a CISAR para ejecutar esto. Aquí sigue poniendo el error. 00:33:17

¿Por qué creéis que es? 00:33:27

¿Por qué? Si aquí no me sale nada rojo. 00:33:31

Venga, primera pregunta interactiva. Porque no se ha guardado el proyecto en el Visual Studio. 00:33:34

Perfecto. Veis que está el asterisquillo. Importante, porque esto ahora es muy obvio, 00:33:42

pero luego pasa. Control-S, se ha guardado, vuelvo y ya, cuando me permita, a veces tiene que 00:33:47

recargar. Según el ordenador, mejor o peor, pues tardará más. Ahora hay otros problemas, pero ya 00:33:55

no es el rojo. Cuando salen errores amarillos, con este warning amarillo, significa que hay 00:34:03

errores, pero no son fatales. Es decir, no van a detener la ejecución, pero bueno, convendría echarle 00:34:09

un ojo. Lo mismo, si le damos doble clic, nos abriría, esto es de otros scripts que tengo preparados 00:34:16

antes, nos abriría donde está en el código ese error. Ahora, cuando lancemos la aplicación, 00:34:20

cuando le dé a play, vais a ver que se ejecuta. Os he dicho, cuando lancéis, ahora se va a ver en el 00:34:26

juego la frase cual hemos dicho, hola mundo Daniel. Y os vais a llevar la primera desilusión, porque 00:34:32

no se ve nada en el juego, no hay nada que se vea. Pero si os fijáis en la consola, sí que aquí pone 00:34:38

hola mundo Daniel. Os he dicho que estas operaciones se hacen para depurar errores de código. Es decir, 00:34:45

no es algo que se va a ver en el juego, son instrucciones que la consola va a ir mostrando 00:34:54

para ir viendo si se está ejecutando algo bien o no. Es de vital importancia este debug log. Ya 00:34:59

iréis viendo que es con lo que vamos a ir comprobando que todo funcione. Ahora mismo 00:35:03

he puesto hola mundo Daniel, aquí podría poner, hola a ver uno de vosotros, Elisa, que la estoy 00:35:07

viendo ahora mismo. Pues hola Elisa, yo si vuelvo a guardar y voy, cuando ejecute el juego, ojo, 00:35:15

cuando me meto otra vez, si está el juego en ejecución, necesito volver a lanzarlo. Y ahora 00:35:21

pone por lo que le he dicho. Ya vamos viendo que hay cierta interacción. 00:35:28

¿Dudas hasta aquí? ¿Más o menos me vais siguiendo? 00:35:38

Sí, creo que alguien está hablando, pero no lo escucho. 00:35:43

Vale, por si tenéis bloqueado. Lo digo porque la única persona que me ha puesto, no sé si es a mí, 00:35:51

pero que leo. Sí, vale, no te escucho, si lo estás intentando. Tienes el micro bloqueado. 00:35:56

Y alguien está pidiendo la mano, dos personas, pues adelante. 00:36:02

Vale, no sé si lo vais a escribir. Vale, bueno, pero no sé si ha sido Esther, también ha levantado 00:36:12

la mano. ¿Alguien quiere decir algo? Que no sé, es que ahora solo, ahora no lo veo, igual se ha 00:36:18

equivocado. Vale, ha habido equivocación ahí. Vale, entonces, ya para entender que lo que hemos 00:36:23

hecho en el Start significa que cuando empieza a ejecutarse el juego se ve este Hola Elisa. 00:36:29

¿No te sale en la consola, Elisa? No, ahora ya me escuchas, ¿no? Que no me sale en la consola, 00:36:36

lo estoy poniendo en el código y cuando me voy a Unity no me sale. ¿Quieres compartirme pantalla 00:36:41

y lo vemos? Sí. Ah, no puedo, porque estoy con la cámara en un ordenador y con el Unity en otro. 00:36:46

Bueno, pues compárteme con él. En el ordenador de Unity no están metidas las dos. 00:36:52

No. Vale. Sigo trasteando y si no te escribo y lo vemos. ¿Tú has escrito el código dentro? No, 00:36:58

hombre, pero me interesa que vayamos viéndolo. Sí, a ver, estoy poniendo como anotaciones de 00:37:06

las cosas que vas explicando para tener como ahí una mini chuleta, pero he puesto de bug.log 00:37:09

Hola Eli y no me sale. O sea, me sale bien el código, no me sale ningún error, está pues con 00:37:14

los mismos flores que tú, pero en Unity no me sale en consola. De hecho, me sale un error. 00:37:21

¿Y le estás dando al reproducir? Es decir, lo guardas. 00:37:26

Sí, lo guardo, lo reproduzco y me sale un error. A ver. 00:37:29

¿Y qué error pone? Collapse service is desplicated and has been replaced with plastic SCM. 00:37:36

Uy, ese es avanzado. ¿Pero es rojo el error? No creo. 00:37:45

Sí, es rojo. ¿Puedes hacer algo para compartirme la pantalla, por fa? 00:37:47

A ver si te van así. Es que esto es una locura. No, no, espérate. Me quito la cam, me meto en el ordenador. 00:37:52

Vale, sí, quita la cámara, da igual. Hombre, me ha servido para ver que estabas hablando y no te 00:38:02

escuchaba, pero bueno, ¿qué tal? Prefiero ver tu código. 00:38:06

Vale, pues espera, dame un momento que cierro aquí y me abro en otro sitio. 00:38:08

Vale, genial. ¿El resto qué tal? ¿Tenéis alguna duda? ¿Más o menos vais siguiendo? 00:38:12

De momento todo bien. Vale, genial. Voy a esperar a que se conecte Elisa, pero... 00:38:24

No estoy en ello. 00:38:28

Ah, pero tú me vas escuchando mientras lo vas haciendo el cambio. 00:38:29

Sí, sí, de hecho creo que lo voy a dejar el datos conectado y ya está. 00:38:33

Vale, sí, sí, sin problema. Voy a hacer una cosa para que veáis las diferencias que hay ya entre 00:38:36

todo lo que tenemos, que es que si yo esta línea de debug log la corto con CTRL X de toda la vida 00:38:42

y la meto dentro del update y guardo, el resultado va a cambiar. Es decir, ahora no le estamos 00:38:48

diciendo que ese debug log, esa escritura de frase en consola se haga en el comienzo del juego, 00:38:54

sino que se haga fotograma a fotograma, hemos dicho. De hecho, aquí hay lo que se llaman comentarios, 00:39:01

creo que esto no lo comenté el otro día, que son estas líneas que aparecen en verde marcadas 00:39:06

con dos líneas verticales y estas líneas verticales, todo lo que se ponga después, 00:39:11

no se está ejecutando, son comentarios que vamos escribiendo. Y aquí pone, 00:39:19

esta se llama antes de la primera actualización de frame, de primer frame vamos, y este se irá 00:39:23

llamando una vez por frame. Ahora lo ejecuto, vamos a ver un segundo lo de Elisa, no sé si lo veis 00:39:28

todos, lo muevo aquí, espera un segundo, y aquí, lo voy a cambiar de pantalla para que se grabe, 00:39:35

vale collapse services deprecated, claro pero eso no tiene nada que ver con, 00:39:43

sí, está bien, clase, a ver, vuélvete al editor, 00:39:55

dale doble clic al error, que te hace, 00:40:02

vale, y esto lo ha generado de cero y nada. 00:40:11

Y ese más que te sale, es que tienes activado algo de compartir en la nube, puede ser, a ver, 00:40:19

cuando lo hayas creado en Unity Hub, ¿puedes ir al Unity Hub un segundo? El Unity Hub es el otro, 00:40:27

el blanco, ahí, conectado, vale, han metido nuevas opciones que están dando fallos y de las que yo 00:40:33

la verdad tampoco controlo mucho, en el último Unity Hub han metido opciones de el cloud, 00:40:42

de la nube, vale, y en tu caso aparece como conectado, desconectalo porque creo que es lo 00:40:47

que está dando problema, entonces para desconectarlo, no, no, no te salgas, dale donde pone connected, 00:40:53

ahí, a ver qué te pone, dale, no te deja cambiar la opción, vale, 00:40:58

disconnect from Unity Cloud, pero no te deja, y a ver, y en el proyecto de abajo, que es otro, 00:41:08

que no está en uso ahora mismo, si vas a los tres punticos de la derecha, disconnect from Unity Cloud, 00:41:14

vale, vale, te sugiero que lo desconectes, 00:41:20

sí, desconectalos, sin problema, y va a seguir dando el error porque este archivo sigue estando 00:41:26

conectado, tienes que cerrarlo, vale, ciérralo, ciérralo de, ahí, eso es, sí, y vuelve a hacer 00:41:31

lo de la opción de desconectar, desconectar, este error la verdad que no sé muy bien cómo 00:41:38

gestionarlo porque es algo que acaban de poner nuevo, a ver si con esto ya, perfecto, a ver, dale a play, 00:41:47

pero no te sale el hola Elisa, ah bueno, claro, a ver, importante, bueno, ya hemos solucionado el error, 00:42:04

no, pero como he dicho antes, para que se vea reflejado en el Unity, ¿lo has aplicado como 00:42:11

componente algún objeto? ¿lo has arrastrado algún elemento? ahí, por ejemplo, la luz da igual, la luz, 00:42:17

cuando tiene sentido, ahora cuando lo lances, que igual te tarda un poquillo, vale, dale a play, 00:42:25

ahí lo tienes, vale, hasta que no lo aplicáis a algún objeto que está dentro de la escena, 00:42:36

pues el código está ahí preparado, pero no sabe a qué aplicarse, vale, bueno, no te escucho, pero 00:42:41

espero que más o menos resuelto, vale, vuelvo a tomar yo el control, vale, vuelvo a compartir 00:42:47

pantalla, voy a ello, no te escucho si me estás hablando, que no sé si lo estás haciendo, 00:42:54

vale, a ver, gracias, vale, comparto yo pantalla y deberíais verla ahora otra vez, 00:42:59

compartir, veis mi Unity, ¿verdad? 00:43:12

vale, entiendo que veis mi Unity, sigo, entonces, importante, ya veis que las sutilezas son 00:43:24

importantes, estaba preparado todo bien, pero bueno, no se estaba reflejando, y como he visto 00:43:29

que estaba haciendo en el código lisa, cuando ponemos dos líneas de este tipo, podemos escribir 00:43:35

lo que queramos para darnos indicaciones, pues por ejemplo, esto sirve para mostrar mensaje en consola, 00:43:40

vale, y esto no se ejecuta, esta línea, esto verde, no se ejecuta, es simplemente comentarios que 00:43:47

vamos metiendo en el código para recordarnos nosotros e ir marcando a otro programador que 00:43:52

también se meta en el código, pues lo que queramos, indicaciones, vale, importante, para que no ocurra 00:43:57

lo de lisa, que tampoco era el problema por lo que hemos visto, pero bueno, esa indicación roja que 00:44:03

salía no era muy aconsejable, han añadido, a lo mejor alguno, si el Unity Hub lo incorporaste y 00:44:07

según empezó el curso no salga, porque es algo nuevo del Unity Hub que acaban de incorporar, que 00:44:12

es poder trabajar en la nube, vale, para que esto no aparezca por defecto y no haya que desconectarlo 00:44:16

después, como acaba de hacer la compañera, cuando creéis un nuevo proyecto, de momento, a no ser que 00:44:22

sepamos lo que hagamos, vale, el otro día lo vimos y de hecho el otro día no estaba estas opciones, para 00:44:28

que veáis lo reciente que es, os sugiero que a no ser que sepáis lo que hacéis, desconectéis los dos 00:44:33

tics nuevos que han puesto de usar en la nube, vale, la versión de controles y el connect y de 00:44:38

esta forma ya aparece desconectado, vale, para que no de ese error, que no era fatal aunque salía en 00:44:43

rojo, yo creo que hubiera funcionado, pero bueno, pues de momento no nos liamos con más cosas, vale. 00:44:49

Hasta aquí bien, como alguna duda de alguien, no? Lo que he hecho, si os acordáis lo último que he 00:44:58

hecho, mientras Elisa hacía el cambio, ha sido copiar ese debug log de start a update, vale, si yo 00:45:07

ahora mismo ejecuto el juego, vale, me meto aquí y le doy a play, cuando arranca el juego vais a ver 00:45:16

que hola Elisa sale muchísimas veces y aquí se van contando y me dice ya más de mil y ya no te 00:45:22

hace la cuenta, no? Cuando yo pare el juego, veréis que aquí hay un trillón de hola Elisas, ¿por qué? 00:45:28

porque esta instrucción que le he dado aquí de escríbeme en consola hola Elisa, pues se ha ido 00:45:34

ejecutando cada fotograma de juego, vale, fotograma dependiendo del ordenador, esto lo veréis en la 00:45:40

próxima lección que abra, al final cada ordenador va a tener una capacidad de computación, según si el 00:45:48

procesador es mejor o peor, pues la capacidad, pues eso, si es mejor o peor el ordenador, pues va a poder 00:45:55

procesar más fotogramas por segundo que otros, vale, entonces dependiendo del ordenador ya veremos 00:46:00

que esto puede suponer un problema, vale, porque unos ordenadores van a ser más rápidos a la hora de 00:46:05

ir calculando más fotogramas que otros, vale, pero por defecto ya vemos que sea el ordenador que sea 00:46:11

esta instrucción de hola Elisa, cada fotograma que puede ir refrescando, pues danza la instrucción 00:46:16

indiscriminadamente cada fotograma, cuando se meta dice un hola Elisa, un hola Elisa, un hola Elisa, vale, ya 00:46:21

veis que hay dos momentos que vienen ya por defecto hechos en los códigos, que son este start para 00:46:26

cuando arranca el script y otro para, según en el momento que esté este script, pues se vaya ejecutando, 00:46:31

vale, digo siempre lo de en el start cuando arranca el script, porque si yo vuelvo a poner en el start 00:46:36

el debug log, vale, y yo tengo aquí el juego, lo tengo dentro, el componente está dentro de este 00:46:43

empty object que es cálculos, vale, hay una opción aquí que sirve para activar y desactivar, que 00:46:51

esto si lo probáis, pues por ejemplo con la nave, pues sirve para que se vea o no, está ahí en la jerarquía 00:46:56

pero no está funcionando, si yo lanzo el juego, vale, veis que no se ejecuta, a diferencia de antes, 00:47:02

vale, está el start, pero es que como no se ha ejecutado el componente, dado que el objeto que lo contiene 00:47:08

no existe, vale, cuando yo le dé a, de alguna forma ya veremos, a que se ejecute este objeto, pues ahí sí, 00:47:14

según se ejecuta, vale, por eso digo que el start no es el primer fotograma del juego, porque hasta que 00:47:21

no se lance, digamos, el script, pues no funciona, vale, importante, entonces ya tenemos, voy a dejar que 00:47:27

sí que esté activo, vale, importante, que a veces no es que no funcione, es que no está vinculado a nada, no 00:47:35

está funcionando ese objeto, vamos otra vez aquí al código, vale, os he dicho este debug log, hola Elisa, 00:47:40

yo ahora en vez de decirle una frase literal, por eso hay que poner las comillas cuando sean textos, 00:47:47

o strings, esto es lo que vamos viendo, hay que ponerlo entre comillas, yo voy a decirle, no, yo quiero que lo 00:47:52

que muestre en consola, pues porque soy así de temerario, yo que sé, es el resultado de 5 más 4, 00:47:57

vale, una operación aritmética muy básica, yo cuando lance este juego, guardo, vale, y lance este 00:48:04

juego, al arrancar, lo que me va a mostrar en la consola, dado que es lo que está dentro de estos paréntesis, 00:48:13

va a ser un 9, vale, lo veis aquí, que es el resultado de la suma, vale, esto cuando vayamos teniendo que una 00:48:19

bala así te impacta, te quita 100 de vida y lo resta de las 500, pues ya tendremos que ir haciendo 00:48:30

operaciones, entonces esta operación tan básica es el origen de todo lo que vamos a ir haciendo 00:48:36

con los juegos, vale, aunque aquí haya puesto los números rápidamente, como números sueltos, vale, 00:48:42

hay que entender un poco cómo gestiona la información el propio Unity, me refiero con cómo 00:48:49

gestiona la operación, con que aunque aquí pongamos un 5 y un 4, vale, hay distintos tipos de variables, 00:48:54

ya me meto a ello que he introducido, según qué vamos a meter en esa variable, vale, voy a hacer 00:49:01

primero una cosa para que lo veáis sin entenderlo y luego lo explico, yo por ejemplo voy a generar 00:49:08

un número de tipo entero, con número de tipo entero me refiero a un número que no tiene decimales, 00:49:14

vale, un número entero, que se va a llamar 5, vale, contesto y a esto le digo que es igual a 5, ahora 00:49:20

digo que es y luego voy a hacer otra variable llamada 4 que va a valer 4, vale, y aquí lo que 00:49:27

voy a hacer es, en vez de decir 5 con número, voy a apelar a este 5 que he puesto aquí y a este 4 00:49:35

que tengo aquí y vais a ver que yo cuando lo lancé, lo he escrito con texto, vale, cuando lo lancé 00:49:45

va a dar otra vez ese 9 que teníamos, ahí está el 9, vale, pero esto no es porque el programa sepa 00:49:52

que si escribe el 5 con texto es un 5 como un número, vale, esto es porque anteriormente hemos 00:50:00

declarado y de hecho si yo borrara estas líneas, vale, daría error, vale, porque hemos creado lo 00:50:08

que se llaman variables, las variables son referencias de ciertos tipos, vale, como cajas 00:50:14

digamos que vamos a ir usando para ir construyendo un lego, vale, que pueden ser de distintas formas, 00:50:21

entonces vamos a ir construyendo estas cajas de distintos tipos, en este caso estamos operando 00:50:26

con números que son enteros pero por ejemplo hay otro tipo de caja, otro tipo de variable que son 00:50:32

los que permiten operar con números decimales que son estos de tipo float, por ejemplo esto se va 00:50:40

a llamar 5 con 5, vale, vais viendo que cuando escribo el nombre de esta variable, vale, lo primero 00:50:47

que hacemos es decir qué tipo de caja o qué tipo de información va a guardar porque yo aunque aquí 00:50:56

me ponga bruto si le pongo 5 con 5 pues no lo sabe entender porque esta caja sólo permite guardar 00:51:01

números enteros, vale, pero si yo pongo 5 con 5 y pongo aquí 5 con 5 y hay que poner una F, esto 00:51:07

también lo veremos, aquí no da fallo, vale, aunque sea decimal, aquí aunque pusiera lo mismo 5 con 00:51:14

5 F, pues nada, entonces ved que hay cajas variables de distintos tipos y cada una va a 00:51:19

permitir guardar información de distintas características. La estructura de declarar 00:51:27

una variable, es decir, de crear una caja o una pieza de lego con la que vamos a seguir trabajando 00:51:34

en el código es siempre la misma, primero hay que poner de qué tipo es esa caja, en este caso pues 00:51:40

vamos a hacer, como sé que voy a trabajar con un número entero, pues pongo este int, de integer, de 00:51:46

entero, vale, y luego a esa caja, por hacer como una caja de mudanza el símil, la voy a etiquetar 00:51:52

para yo saber qué hay dentro y yo sé que aquí pues va a ser un 5, vale, este es el nombre que 00:51:58

nosotros queramos, es el nombre que damos a esa pieza de lego con la que vamos a ir trabajando, 00:52:05

entonces yo en vez de 5 puede ser el número primero que vamos a usar, vale, y ese número 00:52:09

primero, esa caja dentro va a tener lo que le asignemos después de este igual, que es un 5, 00:52:16

vale, aquí por ejemplo creo otra caja, otra pieza, que se va a llamar número que suma el nombre que 00:52:21

queramos, aquí es lo que queramos, también de tipo entero y meto ahora un 3, vale, y cuando vaya generando 00:52:30

estos números, veis que me da fallo porque las cajas que antes se llamaban 5 y 4 ya no existen, 00:52:37

ahora habrá que trabajar con las cajas, digamos que yo he creado estas piezas y quiero que la suma 00:52:43

a hacerlo a partir de esas variables, ahora tendré que poner, vale, pues el número primero de la 00:52:48

operación y veis que cuando yo voy escribiendo el IntelliSense me va mostrando lo que coincida, 00:52:53

si yo he creado esta variable, fijaos que incluso el icono tiene forma de caja, que es bastante 00:52:59

representativo, vale, yo si escribo ese número primero, ahora mismo lo que yo ponga aquí con 00:53:03

este nombre y este identificador, vale, lo que le he asignado, vale, ahora mismo aquí esto es sinónimo 00:53:09

de 5 en este momento, esta caja luego podremos ir cambiándola de contenido a lo largo del código, 00:53:16

por ejemplo habrá algún momento que, para adelantar, que sea vida personaje, vale, y empiece valiendo 00:53:22

100, lo que pasa es que nosotros a lo largo del juego a esta caja vida personaje le iremos quitando 00:53:30

o añadiendo vida según pues reciba balas o vaya cogiendo power ups de corazón, de vida, vale, 00:53:36

entonces esta sigue dando fallo porque ahora mismo esta caja no existe, no hay ninguna caja llamada 00:53:44

así, pues por ejemplo número que suma, vale, pues número primero si lo volviera a meter sería otro 00:53:49

5, no, yo quiero el número que suma, a ver, le clico y ahí está, ahora mismo si leemos esto estamos 00:53:55

diciendo por favor muéstrame en consola número primero más número que suma, cuánto crees que 00:54:01

va a dar de resultado, venga, mientras voy 8, a ver, le doy al play y 8, perfecto, y si ahora en vez 00:54:07

de número que suma aquí pongo vida persona, que es otra caja que tengo, ¿cuánto valdría? 00:54:22

105, si, ¿no? ¿estamos todos de acuerdo? a ver si lo que dice... 105, perfecto, vale, entonces vemos que al 00:54:35

final, y esto si no le veis la utilidad se la iréis viendo rápidamente, iremos generando variables 00:54:44

o palabras, digamos que van englobando datos dentro, vale, que ya os digo que se irán actualizando a lo 00:54:51

largo del juego cuando vayan ocurriendo ciertos eventos, vale, veis también que cuando uso una 00:54:57

una de estas palabras, vale, cuando marco en un sitio se me marcará en el resto de sitios que 00:55:04

está apelando a un mismo variable en ciertos puntos, vale, esto sirve para ir viendo 00:55:10

fácilmente dónde se ha declarado, es decir, dónde se ha generado la caja y dónde estamos pues 00:55:17

usándola, veis que hay un número, hay variables que están marcadas de gris, ¿qué eso significa? que sí, 00:55:22

que esa caja existe pero no se ha usado en ningún momento, si nunca se va a usar lo suyo sería borrarla, 00:55:27

vale, de hecho si voy a algunos de los errores en este momento que hay aquí, vale, cuando detengo 00:55:32

la ejecución me puede sugerir a veces, ahora no me lo está haciendo porque tengo que cambiar algo, 00:55:38

voy a poner 105, yo que sé, vale, cuando ahora vuelvo a refrescar vais a ver que por defecto en la consola 00:55:47

a veces tarda un poco, bueno, entre los errores es en Cancun 5 la variable 5 con 5 está sin nada pero 00:55:55

su valor nunca se usa, vale, pues eso significa que 5 con 5 está aquí pero nunca se usa, veis que es un 00:56:06

error que va a funcionar el juego pero dice, oye, borra esta línea si no la vas a usar, para qué vas a 00:56:13

llenar tu habitación de cajas si no las vas a usar, vale, hasta aquí más o menos vais viendo qué estoy 00:56:19

haciendo, sí, vale, aparte de números enteros y decimales, vale, y los decimales se escriben con un 00:56:24

punto en vez de una coma, vale, y hay que poner una f de float, vale, porque si no, no sabe si se está 00:56:34

refiriendo a un número decimal u otras cosas, vale, si no ponéis la f, aunque permita tener 5 con 5, 00:56:40

yo le doy a la f y no funciona, y ojo, si yo pongo número primero y 5 con 5, vale, ahora estoy juntando 00:56:45

cajas de distinto tipo, ¿qué debería la lógica decir que nos da como resultado? 00:56:57

vamos a verlo, 10 con 5 dicen por ahí, por cierto cuando tenemos todos los errores estos que nos 00:57:09

pueden salir, si damos a clear, lo limpiamos, vale, ya sabemos lo que queremos para al volver a ejecutar 00:57:16

pues que se generen los que tienen que ser, 10 con 5, perfecto, vale, entonces los decimales los va 00:57:21

cogiendo, pero cuando vayáis introduciendo un dato decimal siempre con punto y con f detrás, 00:57:28

vale, si no, no lo lee, si no da fallo, vale, simplemente eso, hay más tipos de cajas, otra muy 00:57:33

importante que es el string, las cajas, las variables de tipo string, la variable de tipo string lo que 00:57:41

contienen son textos, vale, no son números con los que operar, son textos, pues la f tiene algún motivo lógico, 00:57:47

simplemente es float, es la miniatura de float, que como vemos aquí es el tipo de variable 00:57:54

que guarda estos valores, vale, el string igual, la lógica de declarar una variable es siempre el 00:58:04

tipo de variable, en este caso vamos a decir el dato que voy a guardar aquí es una cadena de texto, 00:58:11

es un texto, y lo voy a llamar pues cadena de texto o yo qué sé, mi nombre, vale, y entonces al darle 00:58:16

igual, vale, y quiero que vayáis interpretando estos iguales no como un igual en matemáticas de 2 más 2 00:58:24

igual a 4, esto significa que se está asignando un valor, vale, o lo que se llama el término más 00:58:29

correcto sería inicializar, en este caso el valor, que es que una caja que está vacía hasta aquí, de 00:58:36

pronto la vamos a poner un algo, no estás comparando nada ni es equivalente una cosa a otra, sí lo es, 00:58:41

pero es que esto que está aquí a la izquierda pasa a tener este valor, y aquí si yo 00:58:48

pusiera un número, vale, y mirad que yo todas las operaciones las acabo cuando acaba la instrucción 00:58:53

con un punto y coma como os he dicho antes, vale, importante, porque si no se empiezan a juntar 00:58:58

conceptos y empieza a dar problema, entonces veis que yo aquí pongo un 5 y dice error, porque esta 00:59:01

caja no está pensada para números, vale, para meter texto cuando algo queremos que sea un texto 00:59:07

literal, como hemos hecho antes con el hola mundo, hay que abrir comillas, vale, las comillas típicas 00:59:12

de entrecomillar, y aquí se puede poner, vale, pues en mi caso Daniel, vale, y ahí se ha guardado un texto, 00:59:18

si yo pongo ahora mismo, 00:59:27

a ver, por ejemplo, 00:59:32

voy a hacer una frase, digamos, compuesta de varias variables, para que veáis que se puede 00:59:34

ir modulando todo, modularizando mejor dicho, voy a generar un string que guarda mi nombre, 00:59:41

otra caja que guarda la frase que construye o el predicado, que va a ser, tiene 00:59:48

vale, tiene de edad, vale, y luego al final voy a poner otra variable, que en este caso es un número, 00:59:59

porque va a ser mi edad, que van a ser, cuando pongo mi edad, que son 34, entonces yo puedo ir 01:00:10

combinando estas cajas para que vaya componiendo texto, si yo por ejemplo aquí dijera, enseñan el 01:00:16

de backlog solo mi nombre, vale, pues lo que va a enseñar la consola es mi nombre, que es Daniel, 01:00:22

en vez de haber escrito literalmente aquí, está referenciando a una variable, para enseñarnos lo 01:00:27

que hay en el interior de esa variable, yo si ahora voy a la consola, vale, y le doy a iniciar, 01:00:33

pues pone Daniel, vale, así que lo que podemos ver es que podemos ir concatenando distintas variables 01:00:39

para hacer, digamos, elementos más grandes, igual que antes hemos sumado dos variables que contenían 01:00:46

dentro un número, también podemos ir concatenando textos, por ejemplo puedo poner mi nombre, más, 01:00:53

vale, y este más no es que estemos sumando números, cuando se usa el más al usar textos, lo que 01:00:59

estamos haciendo es que un texto va detrás de otro, vale, entonces yo puedo poner mi nombre, luego el 01:01:07

predicado, vale, y ahora lo que va a enseñar, ¿qué crees que va a ser? A ver si alguien puede adivinar. 01:01:12

Voy cambiando a... 01:01:24

¿Alguien quiere apostar? 01:01:31

Ahora lo que va a mostrar es lo que hay, exacto, Daniel, ¿no? y a continuación tiene edad, este más no es para sumar 01:01:34

números, es para unir, entonces vais a ver que lo que pone es Daniel tiene edad, y fijaos que no deja 01:01:46

ningún espacio en medio entre Daniel y tiene, ¿por qué? Pues porque básicamente no sabe que hay un 01:01:55

espacio entre esta cadena de caracteres y esta, vale, si la creemos como es literal, mete un espacio y ahora 01:02:00

sí, ahora sí que va a haber ese espacio, ved que lo que hay entre comillas es literalmente lo que vamos 01:02:07

escribiendo dentro, vale, entonces ahora sí que vais a ver que llegamos aquí y pone Daniel tiene 01:02:11

edad, vale, y ahora puedo decir, vale, y aparte de Daniel tiene edad, vale, que son bloques que yo puedo 01:02:19

en cualquier momento ir cambiando, vale, ahora lo que va a guardar esta variable es tiene de años, 01:02:26

perdón que la frase sea un poco extraña, pero es para construirlo más fácil, tiene de años y aquí voy a 01:02:30

poner edad, que es esta variable, que veis que ahora es una variable de tipo número y además es de tipo 01:02:35

número float, lo cual no es muy correcto si no voy a meter decimales y normalmente la edad no se mete 01:02:41

con decimales, tienes 34 años o 35, no tienes 34 y medio o no se suele guardar así, por tanto, al hacer 01:02:47

esta caja, si la edad siempre van a ser número entero, pues lo ponemos aquí de tipo entero, vale, 01:02:53

sin ningún problema, pero hay ciertas limitaciones si no vamos usando los tipos de variables que hay 01:02:57

que usar, ahora mismo lo que va a hacer es poner Daniel, vale, espacio por este espacio que he puesto 01:03:02

aquí, no porque haya aquí en medio, vale, esto es lo mismo que escribirlo así, los espacios en 01:03:09

programación son sólo visuales, vale, al final lo que importa son los valores que vamos dando dentro, 01:03:14

entonces esto va a decir Daniel tiene de años 34, aquí aunque no sea de tipo texto, como entiende 01:03:21

que un número, si se está concatenando, porque está aquí unido a textos, lo que vas a querer ver es el 01:03:30

texto también, ¿no? y entonces al final lo que voy a hacer es, aparte de meterlo en variable, poner años 01:03:36

y punto, vale, es decir, va a poner Daniel tiene de años 34 y valga la redundancia, años 01:03:42

punto y ojo, aquí habrá que poner un espacio para que se pare de la anterior palabra y en años también 01:03:50

habrá que poner uno para que se pare de la edad, vale, para que se vea con espacio, vale, bien 01:03:56

construido, ¿no? guardamos y a ver si es verdad que está poniendo lo que yo digo, que va a poner 01:04:02

Daniel tiene de años, bueno, he cambiado de edad, habéis visto que he cambiado el interior de la 01:04:11

variable antes, a mano, 34 años, vale, de esta forma podemos ir uniendo distintos elementos 01:04:16

de distintos tipos, ¿sí? hasta aquí, ¿qué tal? ¿me vais siguiendo? 01:04:22

Sí, sí, vale, entonces, importante, al declarar una variable, el tipo de variable, el nombre de la 01:04:30

variable que nosotros queramos darle y luego asignamos el valor que tiene esa caja, vale, lo 01:04:37

que pasa es que muchas veces cuando vamos creando estas variables, vale, y voy quitando aquí, lo 01:04:43

dejo solo en esto, en su mínima expresión, has creado la caja pero no la has llenado de nada, 01:04:50

vale, cuando no llenas la caja de nada, interpreta en los números que es un cero, vale, que está vacía 01:04:56

pero a nivel práctico es un cero, vale, y en los textos pues no tiene texto también, lo interpreta 01:05:02

como un cero y en los de tipo float también es un cero, vale, podemos ir creando las cajas, vale, y 01:05:10

posteriormente, en algún momento de la ejecución, que a lo mejor no es al principio, cambiar su valor, 01:05:15

por ejemplo, hemos dicho, y fijaos que esto está dentro de la clase, que es lo que os he dicho, que 01:05:21

es el patrón que va conteniendo todos los comportamientos que vayamos haciendo, vale, pero luego 01:05:27

hasta que no hay un momento concreto al comienzo o al actualizar, estos son como datos, como variables 01:05:32

que estamos creando a nivel genérico, pero hasta que no sea en el momento del comienzo o que esté 01:05:38

dentro del update, realmente no se está ejecutando nunca, vale, más rápido, si yo cogiera este debug.log 01:05:45

y lo pusiera aquí, va a dar falla, pues dice, sí, muy bien, depura, pero ¿cuándo? ¿cuándo depuro? 01:05:50

Esta instrucción no es crear una caja para luego usarla, es algo concreto, que es lo que os he 01:05:56

dicho, que son los métodos cuando se usa estos paréntesis, una acción, algo concreto, se hace 01:06:00

cuando apelamos a algo que tiene estos paréntesis, aquí dice, vale, yo hago lo que tú me digas, pero 01:06:05

¿en qué momento? no me estás definiendo en ningún momento, por eso tiene que ir dentro de algún bloque 01:06:10

de momento de ejecución, vale, y también lo que podemos hacer es decirle, al iniciar el juego, el 01:06:14

script, quiero que número primero, vale, esta variable que he generado aquí, valga 7, vale, y aquí 01:06:22

qué ha pasado, y voy a volver a decirle que lo que quiero que me enseñe es número primero, y veis que 01:06:34

la misma palabra, yo cuando la marco en un sitio, como es la misma caja nombrada igual, aparece en 01:06:39

varios sitios, esto que estoy haciendo aquí, he declarado, he creado la caja, he declarado la variable, 01:06:43

al principio está vacía, vale, cero, vale, pero al empezar el juego, yo le he dicho, yo quiero que esta 01:06:51

caja valga 7, vale, y imprímeme aquí lo que hay dentro del número primero en la consola, por 01:06:55

tanto, lo que vamos a tener ahora es, pues si lo adivináis, un 7, no, qué pasa, que esto a lo largo 01:07:03

del juego, vamos a irlo cambiando, fijaos que cuando yo ya he declarado la variable y he 01:07:14

dicho de qué tipo es esa caja, vale, ya cada vez que hablemos de esa caja, ya no hace falta poner de 01:07:20

qué tipo es, ya lo hemos generado aquí al principio, vale, veis que por eso ya nunca más vuelve a poner 01:07:25

el tipo de variable, sólo se habla de la variable y se puede asignar a continuación o usarla, pero 01:07:30

no hay que volver a declararla, eso se hace una vez, que declarar, de hecho, es crear esa 01:07:36

caja la primera vez, luego ya es emplear la variable, ¿no? Entonces, ahora mismo enseña 7, pero 01:07:41

algo importante es que, por defecto, en estos momentos que estamos de programación, el código 01:07:48

se va a ir ejecutando de manera lineal, es decir, de arriba a abajo, igual que leemos nosotros, de arriba 01:07:55

a abajo y de izquierda a derecha, ¿no? Entonces, cuando vamos bajando, hemos declarado esta variable de 01:08:00

tipo entero, vamos bajando, va bajando y dice, ah, vale, al empezar la ejecución, enséñame lo que hay en 01:08:05

número primero y luego, aparte, pues decimos, vale, número primero vale 7. Antes ponía que era 7, ¿ahora 01:08:12

qué va a poner, qué va a enseñar en consola, qué número? ¿Ha cambiado algo, no? ¿Creéis que ha pasado algo? 01:08:19

Nada, no va a poner nada porque está debajo, ¿no? Eso es, hasta este momento, la variable vale 0, 01:08:26

nadie ha cambiado que valga 0, que es el valor por defecto, y luego, ya más adelante, pues pondrá 7, 01:08:34

¿no? Entonces, si vamos aquí, ahora mismo y ejecuto, pues pone el 0 como una casa, ¿vale? Veis que si es 01:08:39

solo una línea, además, también nos la enseña aquí, ¿vale? Que a veces también puede servir de ayuda, ¿vale? 01:08:45

Esto sirve para ver el orden de ejecución y que aquí podemos empezar a inicializar y decir, 01:08:50

número primero vale 2, pero después de valer 2, número primero vale 4. Se ejecuta esto, ¿vale? 01:08:59

Cuidado que si no, acabamos la instrucción con punto y coma. Luego, número primero vale 7 y luego voy a 01:09:09

hacer un debug log de vida persona. Ahora mismo, ¿qué va a mostrar? ¿Qué pensáis que va a salir en la consola? 01:09:14

El 4. Sí, pero he puesto otro debug log, otro enseñame en la consola, ¿no? Pues lo suma. No, 01:09:31

es decir, eso es lo que ha puesto Roberto. Primero hace esta instrucción y me enseña, va bajando, 01:09:50

aquí es lo último que le hemos dicho que vale este número primero, ¿vale? Pues aquí enseñará un 4, 01:09:57

seguimos bajando, ¿vale? Si a partir de aquí volvemos a usar número primero, valdrá 7, 01:10:02

pero bueno, aquí va a enseñar 4, aquí hemos dicho enseña 4, sigue bajando, bla bla, y dice, 01:10:06

y aquí voy a enseñar vida persona, que además ahora mismo vale 0. Entonces, Roberto, te has 01:10:10

equivocado en este segundo porque el 7 lo enseñaría si aquí pusiera número primero, pero es que estoy 01:10:18

pidiéndole que me enseñe vida persona, que está vacía, ¿vale? Lo enseño. Es decir, el juego no va 01:10:23

a consistir solo en que enseñe una cosa, va a enseñar o va a realizar muchas operaciones. 01:10:30

Entonces, bueno, os lo enseño y vais a ver que primero sale ese 4 y luego ese 0, ¿vale? Y una 01:10:33

se ha ejecutado primero y luego la siguiente. Os he dicho antes que las operaciones, lo haz algo, 01:10:40

son normalmente palabras con paréntesis, y entre paréntesis puede haber cosas o no. Vale, 01:10:46

pues aquí, al empezar el juego, le hemos dicho, enséñame lo que valga número primero, que vale 4, 01:10:51

y aquí lo que valga vida persona, que está aquí vacía. Si yo vida persona, aquí vale 85, 01:10:56

¿qué va a poner ahora en consola? 01:11:10

Nada, porque está por debajo 0. Es decir, la consola va a mostrar primero 4, ¿no? Y luego 0. 01:11:12

Vale, si yo pusiera... Esto es para ver que pilláis la lógica, vamos, 01:11:24

que sé que son preguntas simples. ¿Ahora qué pondría? 01:11:28

85. En la segunda línea, primero 4 y luego 85. Vale, lo vais entendiendo, ¿no? Básicamente, 01:11:32

puede haber varias operaciones, y aquí se están ejecutando dos. Entonces, el orden de ejecución 01:11:39

está en relación a las líneas que se van leyendo, ¿vale? Hasta aquí bien. Recordad que luego se nos 01:11:44

puede ir un poco la pinza con, vale, vida persona vale 85, pero aquí quiero que me lo enseñe más 01:11:53

número primero, ¿vale? Y aquí ahora mismo, ya última que hago de esto, perdonad, ¿qué pondría 01:12:00

aquí en la segunda línea? La segunda instrucción que le he dado al arrancar. 89. 4 y 89, ¿no? No. 01:12:09

No, 92. Efectivamente, porque aunque aquí ponga número primero, en este punto que estamos ya ha 01:12:19

superado esto y ha cambiado de valor lo que hay dentro de la caja, ¿no? ¿Vale? Esto es lo que va 01:12:26

a ir permitiendo luego tener en cuenta que hay operaciones que se van a ir haciendo fotograma 01:12:31

fotograma, que vayamos actualizando, subiendo, bajando cifras, que al final son la vida, 01:12:35

el tiempo de carga, el nombre del jugador que hemos metido en un campo. ¿Vale? Se va a ir 01:12:40

actualizando a medida que vayamos haciendo ciertas operaciones, ¿vale? Esto es un poco la base de 01:12:46

todo. ¿Vale? Una duda, Daniel. ¿Sí? Para el ejercicio de la unidad cero, entonces, sería mejor declarar las 01:12:53

vidas, o sea, declarar las vidas sin asignarle un valor y luego tú irle asignando los valores 01:13:01

dependiendo de si le afecta la bala, no le afecta, es mucho más cómodo de eso que ir poniendo que 01:13:05

restas o que sumas. Claro, tú declaras esa bala y luego tendrás que ir sumando o restando daño, y 01:13:11

daño puede ser un número ya establecido o uno aleatorio, que también se pueden hacer números 01:13:17

aleatorios. Vale. Hablar de la tarea cero, ¿no? Por un lado, ¿no? Sí, sí. Vale, esa tarea ya os digo que no va a salir de 01:13:22

momento ni de broma, si nunca habéis estado, pero si lo que quiero es que vayáis intentando resolverla 01:13:32

para con lo que vayamos viendo tal, ¿vale? Que hay cosas que no se ha explicado, ni se ha abierto el tema, ni 01:13:37

está todavía en el tema, ¿vale? Pero que es para que os pongáis con ello. Vale. Entonces, variables, el 01:13:43

concepto de variables ya vais viendo que es referenciar valores para moverlos por el código en 01:13:49

distintos momentos, ¿vale? En esencia es eso. Esto se va complicando, por supuesto. Vamos a la tarea 1, ¿vale? 01:13:54

Después de hacer ese prefab de la nave, que en principio no había mayor problema ya, quien lo 01:14:01

haya intentado pues le da alguna pista de algo que puede fallar, pero en principio es tener esa nave. 01:14:07

Lo segundo que pide es instanciar la nave, ¿vale? Instanciar más allá, que evidentemente si vamos a 01:14:12

usar variables, por eso lo has explicado, lo que vamos a hacer es una operación, que es, ya esto lo pone 01:14:17

en el tema, que es hacer una operación que es instanciar el objeto por código, ¿no? Para eso se 01:14:22

usa, al arrancar el juego, se puede poner aquí la operación instantiate, ¿vale? De todas las que hay. 01:14:28

Vais a ver que IntelliSense también nos va dando distintos iconitos, ya iré explicando mejor qué es 01:14:34

cada cosa, ¿vale? Pero en este caso, por ejemplo, es de un método o una función. Método y función, si lo iréis 01:14:42

escuchando mucho, son sinónimos. A veces diré métodos y a veces diré función, ¿vale? Y cuando me pongo 01:14:48

encima, vais a ver que IntelliSense, cuando me voy poniendo con la selección de la palabra, nos da más 01:14:56

ayudas aquí, nos da muchas ayudas siempre, ¿vale? Aquí ahora mismo nos dice, ahi va, bueno, pero 01:15:02

cuando a veces no salga, empezad a escribirlo otra vez, porque si no se pierde. Os ponéis 01:15:08

encima y pone instantiate, ¿vale? Pone como cosas que está heredando de estas librerías que os he dicho que 01:15:14

había aquí arriba, ¿vale? Y llegamos hasta la palabra instantiate y dentro de paréntesis pasan cosas, ¿vale? 01:15:20

Y pone más cuatro sobrecargas. Ahora vemos qué es eso. Os he dicho, cuando hay algo que lleva 01:15:26

una palabra, ¿vale? Y luego unos paréntesis, como aquí el estar, es una acción. En este caso, estar 01:15:32

es al arrancar lo que tengas dentro del bloque. Ahora vamos a hacer una, que esto son cosas que 01:15:38

tenemos que ir aprendiendo, es al arrancar, ¿vale? Dentro voy a instanciar un objeto, ¿vale? De momento 01:15:43

me da fallo, porque es verdad que esta operación, a diferencia de la de estar, hasta que, por ejemplo, 01:15:51

no le dices qué objeto, no sabe qué hacer. Y cuando no sabe qué hacer, estos programas se vuelven 01:15:55

muy locos y te dan error y dice, mira, yo hasta que no me digas qué tengo que hacer, pues no me voy a 01:16:00

ejecutar, ¿no? Entonces, cuando abrimos llave, una vez ya hemos puesto por completo la instrucción en el 01:16:04

debug log, vuelvo un segundo al debug, ¿vale? Hemos dicho, es la clase debug que dentro tiene la 01:16:11

operación log. Al dar a log, yo sé que es una operación que debe tener unos paréntesis para, 01:16:16

en este caso, en esta operación, definir qué tiene que mostrar el mensaje, ¿no? Y vais a ver que a 01:16:24

veces salen aquí, en el desplegable, dos flechitas, ¿vale? Una misma operación, una misma palabra que 01:16:29

esconde detrás operaciones, puede variar en el contenido de estos paréntesis, ¿vale? Debug log 01:16:37

puede, como hemos hecho hasta ahora, solo mostrar un mensaje, lo que pongamos ahí como mensaje, y 01:16:43

fijaos que, como nos va enseñando lo que tiene que ir dentro, tiene la misma lógica que cuando hemos 01:16:49

declarado la variable. Primero te dirá qué tipo de variable o de objeto tiene que tener dentro, y 01:16:55

luego cómo ha llamado, digamos, el software, el código, a ese mensaje. Es decir, ahora mismo, en 01:17:02

el debug log que hemos hecho hasta ahora, está diciendo que dentro tiene que haber un elemento 01:17:11

de tipo objeto, que dentro de Unity se querría decir cualquier tipo de variable, ¿vale? Y aquí 01:17:15

ha puesto un nombre, igual que hacíamos nosotros, genérico, que lo ha puesto el programador para que 01:17:22

sepamos que lo que hay que meter es el mensaje, ¿vale? Esto no significa nada, simplemente que nos está 01:17:25

dando la ayuda de que es un mensaje, ¿no? Si le damos aquí a lo que se llama sobrecarga, nos dice 01:17:30

hay otra opción que, aparte de poder introducir el mensaje separado por una coma, podemos meter un 01:17:35

contexto, ¿vale? Esto aquí no lo voy a hacer con esta operación, lo voy a hacer con la de instanciar. 01:17:40

Cuando yo abro el paréntesis de instanciar, hay hasta 10 de lo que se llaman sobrecargas, que son, 01:17:45

a esta palabra, esta acción, puedes hacer uso de ella hasta de 10 formas diferentes, y veis que 01:17:51

cada una, entre el paréntesis, va poniendo distintas opciones, cada una con sus peculiaridades, que ahora 01:17:58

vamos a ver, ¿vale? Si vamos a la primera, dice, pues tú aquí me puedes meter un objeto que se llama 01:18:04

original, ¿vale? Y abajo incluso pone una descripción, pone clona el objeto original y devuelve 01:18:10

un clon, ¿no? Es decir, que coge un objeto y lo clona en la escena, ¿vale? Bueno, pone el original es un 01:18:16

objeto que ya tengas, del que quieras hacer una copia, que en este caso va a ser el prefaz que 01:18:25

tenemos de la nave, ¿vale? Entonces, simplemente para que sepáis, vais a ir viendo que hay distintas formas 01:18:29

de operar con estos métodos, ¿vale? Y lo que hagamos normalmente va a variar dependiendo de lo que 01:18:35

pongamos aquí. Aquí, de la forma rápida, vamos a decir que lo que vamos a poner dentro de 01:18:42

este paréntesis es el prefab que va a instanciar, es decir, ahora mismo este código se va a 01:18:49

ejecutar donde esté este objeto empty, que hemos creado antes, y ahí vamos a generar un clon 01:18:56

del prefab que tenemos aquí preparado, de esta navecica que tenemos aquí preparada. Y claro, aquí 01:19:02

es donde empieza ya la cabeza a dar vueltas y decirle, vale, hasta ahora hemos hecho variables 01:19:10

que he creado aquí, le he dicho que son cinco, una palabra, pero ¿cómo meto yo aquí dentro? Pues que es 01:19:14

un prefab, ¿no? ¿Cómo meto aquí la nave, no? Vale, cuando vayamos avanzando en el temario, vamos a 01:19:20

ver que aparte de números enteros, de strings de cadena de texto o de floats, por ejemplo, hay más, 01:19:29

pero bueno, esos son como los más usados a nivel de primitivas de variable, hay otras que apelan 01:19:38

a conceptos que están dentro del juego. Uno, por ejemplo, es, y con mayúscula, esto ya veréis que se 01:19:44

puede escribir con y sin mayúscula, un transform, ¿vale? Un transform, veis que nos lo marca y dice 01:19:53

es una clase, bueno, y guarda la posición, rotación y escala de un objeto. Cuando generamos una variable 01:19:59

de tipo transform, por ejemplo, la lógica es igual que la que hemos hecho anteriormente. Hemos dicho, 01:20:05

primero hay que decir el tipo de variable que estamos creando y luego le damos un nombre nosotros 01:20:12

que queramos, pues posición referencia, ¿vale? Punto y coma. Ahora mismo vale cero porque no hay 01:20:17

nada, ¿vale? Pero tenemos aquí una posición de referencia de donde queremos que se instancie la 01:20:25

nave, ¿vale? Y voy a hacer otra cosa, ahora lo explico, que es que también se puede crear una variable de 01:20:32

tipo GameObject, que lo que va a hacer es que en su interior se va a poder guardar un objeto, 01:20:39

en este caso un prefab y va a ser mi prefab, por ejemplo, ¿vale? Ahora mismo lo que tenemos es, aunque no 01:20:44

sepamos muy bien qué quiere decir esto, una variable que por el tipo que es esta caja lo que va a 01:20:52

guardar son GameObjects que tenemos en la arcena. Está configurado, con estas librerías que 01:20:58

tenemos aquí, va a permitir, y de hecho fijaos que cuando leemos esto pone UnityEngine.GameObject 01:21:03

y os he dicho siempre va de lo general a lo concreto, ¿no? UnityEngine, si os fijáis, está aquí abierto, por eso 01:21:10

no hay que volver a abrirlo y gracias a esta librería, pues aquí tenemos este GameObject y cuando 01:21:17

metamos algo en esta caja vamos a referirnos a esta caja con mi prefab, ¿vale? ¿Qué tal? Ahora vemos cómo 01:21:23

seguimos, pero ¿más o menos me vais siguiendo? Sí, más o menos. Aquí hemos generado una caja que ahora 01:21:32

veremos cómo va a guardar el objeto para poder usarlo bajo el nombre en mi prefab, ¿vale? Y luego como 01:21:41

vamos a querer que esta instancia se ubique donde nosotros le digamos, pues hemos generado otra 01:21:47

variable de tipo transform y con transform es que podemos guardar los valores de 01:21:54

posición, rotación y escala de un objeto. De hecho, no es extraño que dentro de los componentes haya 01:22:01

uno que se llama transform que justo se ocupa de esos tres conceptos. Si nosotros 01:22:10

conseguimos que en una variable se guarde el transform, guardará todo lo que hay adentro, ¿vale? 01:22:16

Entonces ya podremos decirle a través de código, oye, lo que me genere es por donde esté este 01:22:22

transform y nosotros hemos guardado la posición de, en este caso esto, pero puede estar variado, ¿vale? 01:22:26

Entonces, para coger ciertos... A ver, voy a guardar... Y de hecho, así me sirve para adelantarlo, 01:22:31

normalmente va a haber variables de todos los tipos de componentes. Por ejemplo, esto también ya veremos 01:22:39

qué es. Meto un BoxCollider, voy metiendo aquí distintos componentes y veis que he generado 01:22:46

un nuevo tipo de transform que podré guardar la información de transform, pero también va a 01:22:50

existir, por ejemplo, el de RigidBody, que es el que antes os he enseñado que da gravedad, que hace 01:22:55

actuar al motor de físicas, ¿no? Y si yo empiezo a escribir aquí, no es casualidad que haya un objeto, un 01:23:00

tipo de variable que se puede llamar RigidBody, y esto lo llamo mi gravedad, el nombre que queramos. 01:23:06

Este último es gravedad. Yo voy a poder dirigirme a los distintos componentes guardándolos en su 01:23:12

propia caja, ¿vale? Hay que hacer alguna operación más, pero dentro de esta variable de esta caja voy 01:23:18

a poder meter cualquier cosa que esté dentro de RigidBody. Luego podré acceder a todas estas 01:23:24

propiedades. O BoxCollider, pues también voy a poder hacer cajas que se refieran a lo que haya 01:23:31

dentro de BoxCollider. Y aquí, pues BC de BoxCollider. Que os vaya sonando que estos son 01:23:37

componentes. Cuando aparecen además con este colorcito verde, que es el mismo de la clase, al 01:23:43

final, fijaos la lógica que CalculusTut, si nos fijamos, no deja de ser otro componente. Es un 01:23:50

nombre de componente. Esto es lo que se llama una clase en programación. Y las clases en 01:23:58

programación se pueden usar para incorporarlo como componentes. Entonces, todo componente, al final, 01:24:03

lo que es, es una clase que podemos referenciar aquí. Es decir, que si yo me meto, esto simplemente 01:24:09

espero que os ayude a ir comprendiendo. Si damos con la tecla control sobre algunas palabras, os 01:24:17

deja meteros dentro. ¿Veis que cambia el cursor? Y me puedo meter dentro. Y aquí hay un montón de 01:24:24

cosas que ya ha programado alguien, y por eso están las librerías, preparando el componente. En este 01:24:29

caso, GameObject. Pues ya hace muchas cosas, pero que ya están hechas por el programador. Entonces, 01:24:36

que vaya al padre, ahora aquí. Y Transport también tendrá sus historias ya preconfiguradas, etc. 01:24:45

Entonces, estas clases, aunque aquí veamos estos componentes con muchas opciones, esto es porque 01:24:52

ya hay un código que dice, quiero que enseñes... Bueno, no sé cuál lo había metido, pero mira, 01:24:58

por ejemplo, Cámara. Todo esto alguien ha hecho un código para que vaya enseñando cada uno de los 01:25:04

elementos. Al final, ahí. Y veréis que no me lo estoy inventando. Cuando aquí ponga Cámara, 01:25:08

y puedo llamarle Mi Cámara, ponerle un nombre, y aquí me meto. Y cuando me meto, habrá opciones 01:25:14

como... Es que hay tantas que no voy a poder verlo. Pero, por ejemplo, Fill of View. Y hay 01:25:21

ya opciones preconfiguradas. Pues si nos fijamos aquí, va a haber alguna que es Fill of View. Bueno, 01:25:28

todo esto se está viendo porque alguien lo ha programado antes para que ya estén 01:25:34

constituidas y tengan ciertos comportamientos. Esto, evidentemente, simplemente para que vaya 01:25:38

viendo qué clase y componente son sinónimos, en cierto modo, y aparte se pueda hacer cajas 01:25:44

variables con los valores que ya tienen estas clases. Entonces, ahora mismo lo que me interesa 01:25:50

es la clase que me permite guardar GameObjects, que son objetos, y también voy a decir una posición, 01:25:59

voy a crear una posición y, por tanto, voy a usar que la caja Transform también lo puedo 01:26:05

usar, el componente Transform de otro objeto. Hasta aquí, ¿qué tal? ¿Más o menos? 01:26:10

Vale, no sé si voy rápido o al contrario, si eso me decís. Entonces, claro, aquí a diferencia de 01:26:20

antes, no podemos hacer un igual y cinco o nave prefab, no se puede. Se puede hacer con código más 01:26:27

adelante, pero bastante más complejo que hacer una asignación por el igual. Entonces, aquí hay que 01:26:35

empezar a hablar de lo que, y esto está en el tema cero también, lo que se llaman los ámbitos de las 01:26:40

variables. Vais a ir viendo, si cogéis otro código, empezáis a ver que muchas veces le iréis 01:26:46

palabras como privado, private o público, que aquí ya viene uno, por ejemplo, porque al final 01:26:53

estos códigos llegarán momentos que queremos que se comuniquen entre sí. Es decir, imaginaos que yo 01:27:00

he puesto a cálculos un componente y luego el personaje tiene su propio script con su vida, 01:27:07

de 100, y es cálculo la que se ocupa de coger de otro componente la vida del personaje y en otro 01:27:14

objeto, en otro script, hacer operaciones. Entonces, digamos que cuando se vaya complicando el tema, 01:27:21

habrá que ir intercomunicando los distintos scripts y los códigos, pero no siempre nos va a 01:27:25

interesar que todo se comunique con todo, porque a lo mejor va a haber personajes con sus scripts, 01:27:32

va a haber enemigos con sus scripts, va a haber una pared que podemos romper con sus scripts y 01:27:38

todas tienen vida, digamos, cada uno la suya respectiva. Si al final empezamos a poner variables 01:27:43

como vida, porque no nos acordábamos, si todos los scripts diferentes tienen vida, al final nos 01:27:48

podemos equivocar. Podemos poner vida y referirnos a la vida de otro personaje. Entonces, para limitar, 01:27:55

esto es como una explicación así un poco chusca, pero bueno, a veces no nos interesa que los 01:28:00

distintos elementos se puedan meter unos dentro de otros. Entonces, para eso existe lo que se 01:28:06

llaman los ámbitos de acceso. ¿Eso qué significa? Que cuando vamos generando tanto clases como 01:28:13

variables, incluso como métodos, acciones, podemos decirle que algo se pueda ver desde fuera de este 01:28:23

script o no. Y esto básicamente significa que cuando generamos cualquier variable, igual que 01:28:30

os he dicho que una variable sin valor vale a cero, normalmente cuando declaramos una variable es 01:28:37

privada. Es decir, que sólo se va a ver dentro de esta clase. No lo va a poder ver otro código. 01:28:42

Aquí también, aunque no lo ponga, también hay un private. ¿Veis que no da error aunque lo escriba? 01:28:48

Porque se supone que por defecto lo pone como privado, para que sea restrictivo. Sin embargo, 01:28:53

en ciertos momentos nos puede interesar que una variable sea pública y lo puedan ver otros objetos. 01:29:01

Y en Unity no es sólo que lo puedan ver otros scripts. En Unity es que también sea público 01:29:08

desde el inspector de Unity. Voy a hacer una cosa. Voy a borrar, voy a comentar. En vez de borrar, 01:29:13

para tenerlo preparado, comento de un segundo. Si luego quiero usar, digo para que no dé error, 01:29:19

si en cualquier momento quiero recuperar cualquier cosa, quito el código y lo tengo ahí. Es una 01:29:23

práctica muy común, comentar para dejar de usar algo. Entonces, ahora mismo si me meto, 01:29:28

si me meto en el script CalculusTut, sólo hay un campo aquí, que es script, que viene por defecto, 01:29:35

cuando metemos un script para definir qué script es el que estamos asociando. No permite hacer nada. 01:29:41

Pero fijaos, y aquí ya va a empezar a abrirse un mundo de posibilidades, que si yo en vez de decir 01:29:47

que algo es privado, lo pongo como público, es decir, que puedan acceder otros scripts a este 01:29:54

elemento. Si yo lo pongo público y guardo, vais a ver que ahora dentro de este script se ha abierto 01:30:00

otro campo nuevo que se llama miPrefab. Voy un segundo aquí, que es el nombre de la variable. 01:30:09

Veis que él ya interpreta que aunque sea mayúsculas y minúsculas, lo separa bien con 01:30:14

sus mayúsculas, bien escrito, que está hecho todo a propósito. Y aquí deja un espacio que 01:30:19

podemos rellenar con algo que sea un GameObject. Haciendo públicas las variables es como, por 01:30:25

ejemplo, en este componente, en este código, alguien hace que aquí se puedan meter tres variables 01:30:31

llamadas posición, que luego además se referirá a ellas para hacer ciertas operaciones. Si, por ejemplo, 01:30:36

el transform, digo que sea público también, pues cuando lo hago público y guardo vais a ver que, 01:30:42

esperad un segundo que está cargando, pues está la posición de referencia y está esperando algo 01:30:51

que sea de tipo transform. Entonces, con esto lo que vamos a poder hacer es, desde el propio 01:30:56

inspector, arrastrar elementos. La mainCamera la meto en las dos. Fijaos, importante antes de 01:31:11

seguir, que aunque estoy arrastrando la misma cámara, en cada uno sale un iconito, porque en 01:31:20

cada uno está guardando un tipo de información. En uno está guardando la caja del GameObject, 01:31:26

porque es de tipo GameObject, y en otra, recordad que el componente transform tiene este icono, 01:31:30

está guardando la información de transform de este objeto. Aunque estemos arrastrando el mismo 01:31:35

objeto en cada una de las variables, dentro de esta caja de esta pieza de Lego, está guardando 01:31:40

una información distinta, que nosotros ya iremos usando a conveniencia. Entonces, esta es la forma 01:31:45

más rápida, las hay más, y de hecho en ciertos momentos esto es muy básico, digo que se tendrá 01:31:50

que buscar de otra forma, es la forma en la que tenemos para llenar estas cajas de la información 01:31:56

que nos importe. Ahora mismo, si tenemos aquí un Instantiate, y vuelvo a escribir el paréntesis 01:32:03

para que veamos, aquí el primer método dice Object, que es sinónimo de GameObject, aquí 01:32:11

podemos meter el objeto que queremos que se instancie, y ahora lo bueno es que si ponemos 01:32:18

aquí mi prefab, esa variable que hemos llenado con algo en este momento, a través del inspector, 01:32:22

ahora se va a instanciar algo cuando arranque. Es verdad que ahora mismo lo he hecho así de la 01:32:29

explicación, pero mi prefab lo que instancia es una cámara, que no es lo que me interesa. Yo lo que 01:32:34

voy a querer instanciar es la nave prefab. Voy a Cálculos, y el prefab lo puedo arrastrar a MainCamera, 01:32:38

y veis que se ha guardado aquí el objeto de nave prefab. ¿Esto qué significa? Voy a guardar 01:32:45

también aquí, voy al código, y aquí le estoy diciendo, en esta nave de mi prefab, al hacerlo 01:32:51

público a través del inspector, he guardado ese prefab, y cuando yo instancio, ahora sí que sabe 01:32:58

qué objeto es el que tiene que instanciar, porque se lo he atribuido ahí. Cuando guarde, vais a ver que... 01:33:04

Cuando guarde, al darle a Play, no está en ningún lado, pero me genera una copia... bueno, perdonad, 01:33:12

que como aquí le he metido a la nave antes un Rigidbody y tal para explicarlo, voy a quitar 01:33:19

dentro del prefab todo lo que le he añadido de componentes que ahora mismo no me interesa que 01:33:24

tengan, como el VoxCollider y el Rigidbody. Se ha auto guardado, salgo y vuelvo. A ver, detengo, 01:33:29

y cuando arranca el juego, porque está en el Start, me genera esta nave aquí. Así es como 01:33:36

ha sabido el programa que es esta nave la que tiene que hacerse, una copia. Si yo en vez de 01:33:43

la nave pongo el prefab cubo, pues sin hacer nada más, ya cuando le dé al Play, lo que se 01:33:49

va a instanciar es el cubo, no la nave. ¿Hasta aquí bien? 01:33:54

Ya empieza a ser mucho. Todo esto lo explica Álvaro en su vídeo, que aparte de que lo esté 01:34:02

explicando, si habéis visto todo lo que hay que ver, ya sale. Lo estoy diciendo un poco más 01:34:09

pausado para que se vaya entendiendo. Y para acabar, de las últimas cosas que voy a decir, 01:34:14

lo bueno que tiene esto es que como cada método tiene sus sobrecargas, el primero te lo origina 01:34:21

en el punto de origen de donde se está generando el script. Es decir, yo me pongo aquí y le digo 01:34:29

mi prefab como estaba haciendo y yo no tengo control de dónde se instancia, más allá de que se 01:34:36

instanciará donde esté el objeto padre, que es el que instancia. Es decir, yo ahora me pongo en el 01:34:41

0,0. Por cierto, cuando generéis un nuevo elemento, como un empty, cuidado que según dónde tengáis la 01:34:47

navegación, no lo genera en el punto de origen. Veis que yo genero uno nuevo y me lo he puesto en el 01:34:55

20, menos 1, menos 6. Si queréis empezar a hacer todo desde el 0, es muy buena práctica siempre 01:35:00

crear el objeto, a menos que lo hagáis a posta, claro, y luego reseteáis para que esté en el punto de origen. 01:35:06

Ahora mismo cálculos, que es el objeto que tiene aquí, veis que tampoco está en el origen y yo cuando 01:35:11

arranco el juego me lo está generando en una posición que tampoco es la que me interesa, que sería 01:35:18

la del origen. ¿Por qué? Porque si recordáis, cuando yo he hecho el cubo estaba movido del 0,0 01:35:24

y cuando he instanciado sin decirle un punto de referencia, que es lo que he hecho ahora en el código, 01:35:31

porque no le he dicho nada referente a posición, lo intentará hacer en el 0,0 pero lo está moviendo 01:35:36

en relación a lo desplazado que esté ya el prefab, lo que os he dicho antes de la boquilla y si lo 01:35:42

movíamos. Entonces si yo este prefab lo guardo y vuelvo aquí y lo vuelvo a lanzar el juego, 01:35:47

me lo deja en el 0,0. Ahora sí que está en el 0,0 este cubo. Si yo quisiera decir un punto del espacio 01:35:57

donde se puede ubicar el objeto, pues por ejemplo hago aquí un objeto que es la boquilla de la 01:36:07

pistola. De hecho, voy a hacer algo visual para que sea más fácil de detectar. Hago 01:36:15

este cilindro que es la pistola que se va a ir moviendo durante el juego y en un momento X voy 01:36:22

a querer que en este punto, cuando le dé a la barra espaciadora por ejemplo, se instancie la bala. 01:36:28

Este objeto está en unas coordenadas que no son el 0,0. Si yo ahora mismo le digo que se instancie 01:36:33

la bala en algún punto, pues lo mismo se va a instanciar en el 0,0. Pero si yo vuelvo otra 01:36:40

vez a cálculos y le digo la posición de referencia quiero que sea la del cilindro, que la voy a 01:36:49

llamar boquilla pistola boquilla. Cuando voy a cálculos, yo si arrastro boquilla a la posición, 01:36:54

yo quiero que instancie el cubo, va a instanciar en la posición de la boquilla. Estoy preparando 01:37:01

esto. Entonces, como esta posición, este transform, lo está cogiendo de la boquilla, hay otra opción 01:37:07

que decirle vale quiero que me lo hagas en... al ponerle coma veis que se pueden ir añadiendo más 01:37:14

parámetros y ahora la sobrecarga que me abre es la 2, que es la que permite meter dos valores. 01:37:19

Incluso si pusiera tres comas significa que puedo meter tres distintos valores, pero el que está 01:37:24

configurado para que lleve dos es una que es el objeto original y otra que es cuál es el padre 01:37:31

y la posición donde se va a generar, que es esta posición referencia. Cierro el paréntesis, guardo 01:37:37

y vais a ver que a diferencia de antes, ahora sí que cuando se ejecute el juego 01:37:45

la bala se ha hecho hija de la boquilla y además está en la misma posición que la boquilla, ya no 01:37:54

se hace en el 0,0. Entonces veis que de esta forma podemos ir relacionando, ir cogiendo la 01:38:01

información de uno y de otro e irla usando nuestro antojo. Habrá que ir conociendo poco a poco los 01:38:07

métodos, las acciones que podemos hacer, pero bueno esto es un poco como la base de ir moviendo 01:38:13

datos de un lado a otro mediante código. Solo me queda una cosita muy corta por explicar y por mí 01:38:19

por hoy creo que ya estoy y creo que tenéis información suficiente para hacer la práctica. 01:38:25

Me quedan dos cosas y ahora os pregunto qué tal. Imaginaos que yo en este Instantiate en vez de 01:38:30

hacerlo en Start lo pongo en Update. Corto y pego la línea y guardo. ¿Qué es lo que va a hacer? Pues 01:38:35

que va a generar una copia cada frame. Aquí se van haciendo millones. Esto normalmente no va a 01:38:41

interesar porque va a colapsar el juego de tantas copias que está haciendo, pero veis que dependiendo 01:38:50

de dónde se ubique pues hace la operación una vez al comienzo, otra durante cada fotograma y hay 01:38:55

más métodos de tiempo. Pero bueno estos son como los básicos que vienen. Luego última cosa. Os he 01:39:01

dicho antes que por nivel de protección, para que no se pueda acceder a una variable desde 01:39:08

varias variables que a lo mejor se llaman igual y luego un código muy grande, esto por defecto si 01:39:13

no ponemos nada al declarar una variable es privado. Yo lo he puesto público para que se vea en el 01:39:17

inspector. Lo he vuelto a hacer privado. Ojo que lo privado no existe y ahora no es solo que no 01:39:22

exista sino que ahora se ha perdido la referencia de los objetos. Es decir que ahora hago esto y 01:39:30

no se va a instanciar nada porque ha dejado de pasarse la información. Pero hay otra operación 01:39:36

digamos híbrida que es que yo puedo seguir queriendo. Esto es un poco para que veamos 01:39:42

si lo vais cogiendo. Que es que teniendo la misma protección privada, que otro script no se pueda 01:39:49

meter a esta variable, que sí que permita que se pueda operar con ella desde el inspector de Unity 01:39:57

para pasar los objetos. Esa operación es metida entre estos corchetes, lo que 01:40:05

se llama un SerializeField, campo serializado. Se pone antes del tipo de variable que es donde 01:40:12

se ponen los ámbitos. Y ahora las dos van a seguir siendo de tipo 01:40:19

privado. Lo puedo poner incluso de manera explícita aquí escrito. Pero siguen siendo privados cuando 01:40:25

veamos cómo se accede a otros scripts. No se va a poder acceder así de forma fácil, pero sí 01:40:33

que permitimos que aparezcan aquí para poder hacer este traspaso de información de elementos. Ojo, 01:40:40

veis que cuando he borrado y lo vuelto a poner están vacíos. Muchas veces va a dar error que 01:40:48

de pronto vamos a ver aquí algo vacío y pensamos que está. Este es el peligro que tiene de trabajar 01:40:53

desde el inspector. Por eso muchas veces se hace todo con código, que eso funciona siempre si está 01:40:57

bien hecho. Entonces habría que volver a decirle en cálculo, la boquilla es lo que voy a usar de 01:41:02

posición de referencia. Ahora la nave, por ejemplo, va a ser el prefab que se va a instanciar el objeto, 01:41:07

guardo y al ejecutar pues ya la boquilla va a tener, como está en el update, se va a estar 01:41:13

haciendo la nave en el sitio. Lo primero casi me va a interesar meter esto en el Start y ya está. 01:41:19

Más o menos lo que se os pide la práctica está todo explicado. Desde luego instancia y luego 01:41:28

tiene más sobrecargas. Podría poner otra coma. Incluso antes de decirle podemos poner si se 01:41:32

instancia en un punto concreto, con una rotación concreta, aunque coja la posición de manera 01:41:39

independiente. Bueno, pues ya hay más sutileza, pero esto ya es demasiado por hoy. Último de todo, 01:41:45

para que os vayáis haciendo la cabeza, y esto lo va a poner muchas veces en los temas, si ponéis 01:41:52

cualquier método, cualquier propiedad en Google, por ejemplo Instantiate, y ponéis Unity, os va a 01:41:59

remitir a la API o al manual de Unity. Y aquí es donde os da una explicación, esto está en inglés, 01:42:06

no está en español normalmente, de cuántas sobrecargas hay, su uso, descripciones, ejemplos, 01:42:14

cuando no sepáis cómo funciona algo, a medida que vayáis cogiendo más soltura, iréis entendiendo 01:42:22

mejor qué pone aquí, pero esto va a ser vuestro manual de uso frecuente y que hay que ir revisando 01:42:29

cuando tengamos problemas. De hecho, si en cualquier momento le dais al interrogante de un componente 01:42:36

concreto, por ejemplo el Transform, al darle se ha abierto la otra pantalla, pero me ha abierto aquí 01:42:43

la aplicación de Transform, con eso podéis ir viendo la ayuda. Está a veces demasiado extensa, 01:42:49

pero da mucha información útil. ¿Qué tal? Paro ya, dudas que os pueda quedar pendientes. 01:42:54

Todo bien. Si está todo bien, por hoy creo que no vamos mal. Otro día veremos más operaciones 01:43:03

también de números, pero bueno, esto ya lo iremos usando todo. Pero si os quedáis ya con la idea de 01:43:22

que es una variable, que es esto de público-privado así, grosso modo, para captar elementos, pues mira, 01:43:26

la tarea ya la podéis ir haciendo. La 1, la 0 todavía no. Si no hay dudas, pues los dejamos 01:43:32

por hoy. Voy a dejar de compartir un segundillo. No sé si me veis la cámara todo el rato 01:43:43

mientras estoy hablando o no. No sé si cuando comparto se ve, la verdad. No, vale. Bueno, tampoco 01:43:53

es muy importante creo que me veáis. Pues por mi parte poco más por hoy. Estamos con los de 01:43:59

prácticas, haciendo tutorías y vamos alternando. En dos semanas imagino que habrá la siguiente, 01:44:08

que además ya habré abierto el nuevo tema. En esa me centraré más en cosas de la unidad 0, 01:44:13

mientras vais leyendo la unidad 2, pero porfa, ir poniéndoos con los temas que están ya abiertos, 01:44:18

sobre todo el 1 en este momento y el 0, pues poco a poco también ir viendo qué cuenta ahí. 01:44:23

Que muchas cosas de ese tema, vamos, las hemos visto ahora. ¿Dudas? ¿Algo más? 01:44:28

No, todo bien. 01:44:37

Perfecto, chicos, pues lo dejamos por hoy, ¿vale? 01:44:38

Muchas gracias. 01:44:43

Venga, muchas gracias a vosotros. 01:44:44

Hasta luego. 01:44:46

Hasta luego. 01:44:47

Chao. 01:44:48

Tutoría 1 - DEIM - UT1 y 0 - Curso 23·24 - 16 Noviembre - Contenido educativo

Del mismo autor…

INSTALACIÓN PAÑUELOS

Baile Navidad 2025

Aves en el Calderón - enero 2026

Resolución de Problemas de Circuitos en Paralelo.

Resolución de Problemas de Circuitos en Serie.

Tamborilero Navidad 2025

Programa con Scratch Jr un juego de saltos en un campo de baloncesto.