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

Bueno, en la anterior tutoría inicial ya se habló de cómo instalar Unity, el Unity Hub, el Unity Editor, un poco los paneles, esa parte la voy a dar un poco por supuesta y voy a proceder un poco a ir resolviendo dudas de la tarea 1, especialmente a partir de cuando entramos en el código que es al instanciar, ¿vale? 00:00:02

Voy a compartir pantalla. Entiendo que veis el Unity Editor, ¿verdad? Vale, en esta práctica hay una parte que a no ser que tengáis problemas claros, no me voy a meter mucho, que es la creación del prefab, porque creo que está suficientemente bien explicada dentro de las dudas que os puedan surgir. 00:00:24

que por favor si tenéis alguna me vais diciendo, sí que hay un concepto que es el de prefab, que yo tengo aquí por ejemplo preparada mi nave, 00:00:47

que quizá cuando vais siguiendo un poco las instrucciones o pasáis por alto, porque también es normal, o que puede generar dudas. 00:00:56

Al final un prefab no deja de ser un objeto, como se explica, que está guardado para poder ser reutilizado en distintas partes de proyecto o instanciado. 00:01:04

Instanciado es generar copias de un mismo objeto 00:01:15

Y lo voy a usar de referencia en varios momentos 00:01:19

Por ejemplo, si en un videojuego 00:01:22

Y perdonad que remita a videojuegos violentos 00:01:24

Pero es que suelen abundar mucho 00:01:27

Cuando disparamos una bala con la metralleta 00:01:28

Imaginaos que cada bala es un objeto 00:01:31

Que ese proyectil va volando por el aire 00:01:34

Bueno, pues tenemos ya un prefab de esa bala 00:01:36

Y lo que vamos haciendo es lanzar copias de esa bala 00:01:39

De una única bala 00:01:42

A lo mejor tenemos prefabs de bala de escopeta, bala de metralleta, yo qué sé. 00:01:43

Pero al final, a menos que lo hagamos con otra finalidad, va a ser ese prefab que se va duplicando. 00:01:48

Como hemos visto los prefabs, y tengo aquí uno preparado en el panel de proyecto, 00:01:55

y lo puedo importar, meterlo en el proyecto, incluso meterlo dentro de la jerarquía, 00:01:59

vais a ver que viene marcado con este texto azul, con la cajita azul. 00:02:04

en el panel proyecto vais a ver 00:02:09

normalmente ya la geometría del prefab 00:02:11

por ejemplo aquí veis la nave 00:02:13

y atención porque aquí podemos hacer zoom 00:02:15

y hay una forma que no es que haya 00:02:17

un menú de ver en modo lista 00:02:19

ni en modo visualización, que es que si quitamos todo el zoom 00:02:21

vamos viendo los elementos 00:02:23

con iconitos y enlistado 00:02:25

que a veces es más interesante para saber 00:02:28

de qué se trata cada elemento 00:02:30

al ver esta caja azul sabemos que es un prefab 00:02:31

y lo tenemos ahí preparando 00:02:34

y habéis visto que yo puedo 00:02:36

empezar a meter aquí el prefab 00:02:38

85 millones de veces 00:02:40

¿vale? lo podemos tener aquí 00:02:42

para hacer un escuadrón, no sé si ahora habéis visto 00:02:44

el típico juego que hay de 00:02:46

alguien 00:02:48

que va corriendo y va pasando por un 00:02:50

más 10, por 2 y se va multiplicando 00:02:52

no, eso al final son 00:02:54

que se van instanciando más o menos prefabs a medida que 00:02:55

se van cumpliendo ciertas condiciones ¿vale? 00:02:58

bueno, una vez dicho esto 00:03:00

algo importante y me vuelvo a referir 00:03:02

a la bala de 00:03:04

La escopeta, ¿no? Imaginaos que ahora en vez de la nave es una escopeta. El prefab cuando lo generáis, ¿vale? Que lo podéis ir generando, como ya habréis estado haciendo los que comenzaste la tarea, a generar aquí los elementos, ¿no? Con las geometrías, etcétera, con las distintas primitivas que se pueden poner en Unity, ¿vale? Y lo que hacemos es arrastrar, pues imaginaos, ¿vale? Que este cubo es lo que queremos convertir en prefab. 00:03:06

Para convertir en prefab, cogéis de la jerarquía los elementos, podéis seleccionar varios, y lo arrastráis al panel de proyecto, ¿vale? Y se genera un prefab. En este caso es un cubo. Bueno, pues es un prefab bastante básico. Si fuera una esfera, pues podría ser la bala, ¿vale? 00:03:27

Si queréis editar este prefab, bueno, y ved que he borrado el prefab que había generado y aunque esté en la escena, ¿vale? Es verdad que se pone en rojo como avisando de, oye, el prefab de origen no está. Te dejo el objeto aquí, pero esto ya no es un prefab, ¿vale? Si visual esta indicación roja, significa eso. 00:03:42

Imaginaos que tenemos ya la nave 00:03:59

Y ya la hemos preparado 00:04:02

Y está ahí como un prefab 00:04:05

¿Cómo se edita un prefab? 00:04:06

Porque esto al final es como cuando 00:04:08

En cualquier software se mete en una carpeta 00:04:10

En un folder, en un bin 00:04:13

Varias objetos de la jerarquía 00:04:13

Que se van aquí poniendo una dentro de otra 00:04:16

Como habréis visto también en la tarea 00:04:19

Cuando vayamos teniendo 00:04:20

Estos elementos y los convertimos en prefab 00:04:23

Pues igual lo tengo aquí como prefab 00:04:25

Lo borro todo 00:04:27

y digo, vale, pues tengo aquí el prefab, que lo puedo duplicar, pero ¿y esto cómo se edita luego? 00:04:28

Para editar un prefab es fácil, o le dais doble clic al elemento o al propio elemento también de la jerarquía, 00:04:35

se puede de cualquiera de los dos puntos, en este caso el cubo, voy a abrir la nave, mi nave, 00:04:43

cuando hagáis el prefab, pues para reeditarlo y recolocar elementos, doble clic, 00:04:47

y se os abre este área como azul, un poco tron, ahí esperando a que hagamos cosas. 00:04:52

Esto se identifica, para que sea fácil, con dos pistas visuales. 00:04:58

Una, aquí vais a ver en el panel de escena que hay unas migas de pan para ir viendo que este prefab está metido dentro de escenas, 00:05:04

porque lo hemos abierto desde donde está aquí incorporado, ¿vale? 00:05:14

En una de las escenas está este prefab aplicado, ¿vale? 00:05:19

Y aquí podemos ir variando todos los elementos que componen ese prefab, que al final veis que es como una especie de empaquetado de geometrías que tenemos ahí con una jerarquía, ¿no? Esperando a que se instancie. Si en algún momento queremos cambiar el prefab, pues nos metemos dentro del prefab y aquí podemos ir modificando cada elemento como en la jerarquía de la escena habitualmente. 00:05:21

vale sí que es verdad que importante aquí hay una opción que se llama auto safe que por defecto a 00:05:42

mí me aparece marcada debería aparecer marcada que nos puede interesar o no porque esto significa que 00:05:48

todo el cambio que vayamos haciendo de los elementos se irán guardando en el prefab 00:05:54

automáticamente si lo desmarcamos veréis que yo pues si por ejemplo el alero el alerón lo muevo 00:05:58

un poco pues si yo saliera no se está guardando habría que dar a este 6 que ha aparecido aquí vale 00:06:05

Que a veces cuando intentáis salir del prefab os dice, oye, ¿pero guardas o no? Eso dependerá de cómo lo estéis gestionando, ¿vale? Si queréis volver, dice, ya he terminado y lo voy a dejar mal, ¿vale? Esta pieza la he dejado un poco, que es el alerón trasero vertical este que he puesto, lo dejo así, ¿vale? Movido de sitio, si os fijáis. 00:06:10

Si yo guardo y salgo, para volver a la jerarquía o al escenario, aquí está esta flechita que nos sirve para volver al proyecto, para ir para atrás. 00:06:30

O también podemos incluso dar a esa miga de pan que tenemos. 00:06:40

¿Qué pasa? Que ahora, incluso si lo veis en la miniatura, ese alerón se ha movido y se ha guardado como movido. 00:06:44

Si yo ahora lo duplico, va a tener el alerón ahí flotando. Lo ha instanciado todo. 00:06:50

Y esto es lo que me sirve para la primera cosa que suele haber de problema en vuestras entregas de esta tarea, que es tener en cuenta, imaginaos que cuando hagamos las instancias del objeto, vuelvo a remitir a la bala, nosotros luego vamos a dar un punto de referencia donde se va instanciando esa bala, desde donde se emite ese proyectil. 00:06:54

En el caso de una bala, lo suyo será poner la boquilla de la pistola o del arma que sea, ¿no? Para que a partir de ahí vaya para adelante en profundidad. Si ese elemento que estamos instanciando está movido del 0,0 de ese origen, imaginaos que hago esto, si yo me muevo de aquí, cuando yo instancie esa bala, si no lo corrijo de algún modo, va a identificar que desde donde se lanza, imaginaos que aquí está la boquilla de la pistola, 00:07:16

va a estar ya movido desde ese punto. 00:07:46

Por tanto, ojo, si queréis instanciar algo en un punto concreto, 00:07:49

aseguraos de que todo esté en el 0,0 de origen, ¿vale? 00:07:53

Es decir, ahora mismo lo está. 00:07:57

Y veis que aquí hay un elemento padre, que es el nave prefab, 00:07:59

que está con todo intacto, ¿vale? 00:08:02

Y luego he ido haciendo hijos a los distintos elementos de la jerarquía. 00:08:04

¿Por qué pongo otro padre, vale? 00:08:09

Esto es fácil, está el elemento empty, que es como un nulo, ¿vale? Como un nul en otro software de 3D, etcétera, que cuando lo creáis está vacío, pero sirve para colocar elementos dentro de otros elementos y dar coordenadas. 00:08:11

El elemento padre-padre de un prefab 00:08:24

Cuando estamos dentro del prefab 00:08:27

Digamos que no puedes 00:08:28

Poner nada por encima 00:08:31

De la jerarquía de ese elemento 00:08:33

Por tanto diría que este elemento 00:08:34

Por defecto en los prefabs 00:08:36

Debería estar siempre configurado 00:08:38

Para que estén las coordenadas de origen 00:08:40

Que son los ceros de posición, los ceros de rotación 00:08:41

Y a uno de escala, ojo 00:08:44

La escala por defecto es uno 00:08:46

En las tres dimensiones 00:08:48

Y luego dentro de eso 00:08:50

Nos aseguramos a modo visual 00:08:51

que esté todo donde queremos que esté, ¿vale? 00:08:53

Así cuando instanciemos nos aseguramos que este padre es el origen del prefab, ¿vale? 00:08:56

Y luego ya iremos distribuyendo los elementos. 00:09:01

Luego hay otra cosa a considerar que os pone, 00:09:05

que es que la nave tiene que estar mirando hacia la Z en profundidad, ¿vale? 00:09:09

Si os fijáis en este guismo del mundo, ¿vale? 00:09:14

Dado el juego que vamos a hacer luego, que va a ser un endless runner, ¿vale? 00:09:18

Que va a la nave en profundidad y van apareciendo obstáculos, un poco como el Subway Surfer, no sé si lo conocéis. 00:09:21

Yo os voy a enseñar para que tengáis en cabeza hacia dónde se dirige esto, lo enseño muy rápido. 00:09:28

Esto será de la tarea 2, ¿vale? Es el siguiente paso. 00:09:33

Pero lo que vamos a buscar, ahí lo tenemos, es un juego como de estas características, todavía feote, etc. 00:09:36

Pero que va a ir esquivando los pivotetes estos que van apareciendo, ¿vale? 00:09:44

¿Qué pasa? Que lo que vamos a hacer es que esta nave va en profundidad. 00:09:48

Si el prefab lo incorporamos angulado hacia otra dirección, 00:09:52

luego habrá que hacer otra operación para reenderezarlo. 00:09:56

Por tanto, igual que con lo de la bala, ¿vale? Pues lo mismo. 00:09:59

Si queremos que esté en el punto de origen y orientado correctamente, 00:10:02

pues hay que tener en cuenta que el mundo está mirando en Z en profundidad. 00:10:08

¿Vale? Hasta aquí, ¿qué tal? 00:10:12

Los que habéis estado probando, ¿cómo lo veis? 00:10:13

Esto es ponerse y probar. Creo que no tiene más complicación que saber meterte en un prefab, etc. 00:10:18

Luego hay otra cosa para que lo vayáis teniendo en cuenta, que es que cuando vamos instanciando o metiendo en la jerarquía distintos prefabs, 00:10:25

de pronto puede haber una de estas instancias, por ejemplo esta nave, que yo le quiero poner un material o darle otro componente, 00:10:32

meterle un componente como por ejemplo 00:10:48

un RigidBody, que esto 00:10:50

en siguientes temas lo vamos a ver 00:10:52

pues metemos un componente, recordar 00:10:54

esto lo dije el otro día, que los 00:10:56

distintos elementos que van 00:10:58

sumándose a cada 00:11:00

objeto se llaman componentes 00:11:02

que son digamos lo que van metiendo 00:11:04

o pues digamos 00:11:06

las propiedades que tiene ese objeto 00:11:08

un RigidBody, si le doy 00:11:10

a play vais a ver que es un objeto 00:11:12

que así grosso modo lo que hace 00:11:14

es meter gravedad al objeto 00:11:16

¿Vale? ¿Qué ha pasado? Esto me sirve no para hablar del RigidBody en este momento, todavía no es el momento, sino para que veáis que tengo un prefab de todos los que ya he metido que es diferente al resto. ¿Vale? Que tiene un RigidBody. Por defecto este de origen no tiene el RigidBody, pero a lo mejor estamos trabajando en una de estas instancias y hemos metido un elemento nuevo. 00:11:17

Esto lo vais a ver a nivel visual 00:11:39

Porque vais a ver que donde está el iconito del componente 00:11:43

Os añade un más 00:11:46

Está añadido a una instancia del prefab 00:11:47

Podemos seguir obviando que esto es un añadido 00:11:54

Y seguir trabajando porque esta nave va a ser diferente al resto 00:11:57

O hay una opción aquí 00:12:00

Cuando metáis un prefab va a aparecer esta línea 00:12:01

Para abrir el prefab como hemos hecho 00:12:04

Para seleccionarlo en la jerarquía 00:12:06

Y otro que son los overrides. Los overrides sirven para, diciendo lo que tiene de diferencial, marcado con este más, esa diferencia que hay con el prefab, decir, no, no, yo lo que quiero es que todos los prefabs que deriven de este, pues oye, he pensado que tenga este RigidBody. 00:12:07

Entonces, si le damos a aplicar, vais a ver que se aplica ahora, va a tardar un segundete, a todas las instancias que tenga este prefab. Por tanto, es otra forma de modificar también una instancia. 00:12:24

Incluso aquí podemos ir abriendo la nave y decir, no, es que la nave no quiero que tenga alerones. 00:12:40

Veis que estoy trabajando no dentro del área de prefab, sino dentro de la jerarquía, en una instancia. 00:12:46

Si yo borro esos alerones, en los alerones justo me va a decir, oye, esto es un hijo de un prefab, 00:12:51

si borras esto, pues te está variando el prefab. 00:12:57

Lo tendrías que hacer del prefab o tendrías que hacer una variante. 00:12:59

Y aquí es donde se podría borrar y luego guardar. 00:13:02

Vamos a empezar a hablar de programación. Yo no sé de vosotros si alguno ya ha programado alguna vez en otro lenguaje o tiene nociones. Entiendo que muchos no, lo cual es lógico. 00:13:06

El otro día dije que se podían añadir código, todas las funcionalidades que vamos a ir añadiendo va a ser a través de estos componentes que os he indicado o añadiendo nosotros código que vayamos programando que a fin de cuentas también se añadirá como un componente. 00:13:21

Para eso se generan los que se llaman scripts. Y estos scripts ya vimos, voy rápido porque esto lo expliqué el otro día, que se generan con clic derecho, crear y aquí tenemos una opción de generar un script de César, que es el lenguaje de programación en el que trabajamos. 00:13:40

Ya os comenté, y lo ponen los apuntes, que cuidado con el nombre que demos al script por defecto, porque luego se va a ver reflejado dentro del código. 00:13:54

Y si no coincide este nombre con el nombre de la clase del código, la clase es el patrón que se va a usar en el código para ir organizando los distintos códigos, 00:14:08

Pues si no coincide, dará problemas. Entonces he generado este script y si quiero que se vean los resultados de algún modo, habrá que meterlo como componente en algún elemento. 00:14:20

Ahora vamos a hacer operaciones matemáticas y al final del todo un instant sheet para ver cómo se hace un poco lo de la tarea. 00:14:31

Pero para que se aplique este código a algo, ahora mismo simplemente está aquí preparado y si le doy doble clic, se abrirá vuestro Visual Studio que tendréis aquí. Veis esta bonita pantalla de hacker que se nos ha quedado con un poco ese código abierto preparado para trabajar. 00:14:39

Aquí vais a ver que este nombre y este coinciden y tienen que coincidir. Ya lo expliqué el otro día, por eso, si no tenéis dudas, no lo voy a repasar más. Pero aquí tenemos, digamos, la conexión entre el archivo que está trabajando, operando dentro de Unity y lo que va a responder a nuestro código. Por tanto, si cambiamos alguna letra aquí o algo, habrá que cambiarlo en ambos puntos. 00:14:58

importante, aquí ya de hecho tengo algunas carpetas 00:15:21

habéis visto la de prefabs, donde tenía los prefabs 00:15:26

para generar carpetas, clic derecho crear 00:15:28

aquí es prácticamente donde se crea todo lo que podemos tener para el proyecto 00:15:30

hay uno de folder, os recomiendo que vayáis organizando 00:15:34

esto lo ponen los apuntes también 00:15:38

por tipología de elemento 00:15:39

yo por ejemplo, tengo aquí algunos que he estado yo trabajando 00:15:42

los quiero tener ahí preparados, pero este que va a ser durante la tutoría 00:15:45

lo meto en la carpeta durante, para tenerlo ahí, para saber cuáles son los de durante y los que tenía de antes. 00:15:48

Lo dicho, tenemos aquí el script abierto esperando para operar. 00:15:55

Y por mucho que yo escriba aquí, hasta, bueno, no por mucho, hay otros que no hará igual falta, 00:16:00

esto ya es más avanzado, pero si queremos que lo que yo vaya aplicando a este código 00:16:05

se vea reflejado en algún momento en el programa, habrá que meterlo como componente en algún elemento. 00:16:08

Ahora mismo vamos a hacer, porque va a ser a nivel teórico, vamos a generar un vacío, no va a afectar a un objeto visual, visible, y va a servir para cálculos, por ejemplo. 00:16:14

Va a ser un objeto vacío al que yo vinculo y mirad que para vincular un script puedo arrastrar desde aquí al inspector y se incorpora como otro de los componentes. 00:16:26

Si lo quiero eliminar, las opciones de eliminar, de copiar, etc. están en estos tres puntos. Lo voy a eliminar porque también se puede añadir, igual que se puede hacer con los componentes, con los efectos, por decirlo de una forma rápida e inteligible, todos los que ya vienen configurados también se puede buscar por aquí para añadirlo. 00:16:37

Hay uno de cálculos, que es el otro que tenía, y cálculos tut. Fijaos, de hecho, cuando leáis sobre el Pascal case y el Camel case, cómo se deberían escribir las palabras en programación, aunque aquí haya puesto cálculos tut todo seguido, fijaos que el propio programa, yo ya cuando lo meto en el archivo, sabe separar estos nombres. 00:17:02

Para que veáis que ya está pensado esto y hay que ir siguiendo estas nomenclaturas que iremos viendo y que ya en el tema cero se habla de varias. Ahora ya está en un objeto dentro de Unity esperando a operar con él. 00:17:23

Pues estamos aquí con CalculusTut y vamos a hacer nuestra primera operación matemática. 00:17:37

Y os voy a decir algo que es que casi todo lo que vais a hacer consiste en operaciones matemáticas y en lógica de que se cumplan condiciones o no. 00:17:43

Es decir, todo por detrás son esos números o interpretaciones de números. 00:17:57

Entonces, aunque ahora una suma parezca una tontería, al final casi todo lo vamos a ir controlando con números. Entonces es importante saber operar con las opciones que nos da. 00:18:01

Para empezar a programar, y esto quien haya programado en cualquier lenguaje, hay un concepto que es el primario, digamos que es la variable. La variable es un elemento en el que se van guardando espacios en la memoria con una información. 00:18:13

Por ejemplo, quiero que haya un número al que puedo referenciar con otra palabra. Voy a hacer primero una operación matemática y luego vamos a ver qué son las variables. 00:18:29

Aquí hay una línea que veis que se llama igual que el archivo. 00:18:45

Ya veremos un poco más qué es esto de clase, etc. 00:18:49

Pero a partir de estas llaves, y vais a ver que cuando marco una llave, 00:18:53

se marca otra llave, una de apertura y una de cierre, 00:18:58

porque este lenguaje, como los que si habéis visto el tema cero, 00:19:01

los que se suele trabajar en lo que se llama programación orientada a objetos, 00:19:05

esto es más avanzado, ya le iréis dando vueltas, 00:19:09

se van estipulando en bloques, ¿vale? 00:19:11

Y estos bloques significa que hay una llave de apertura 00:19:15

y una llave de cierre que delimita un área, ¿no? 00:19:19

Ahora mismo, de aquí a aquí, pues hay un área, 00:19:22

y dentro de ese área, de ese bloque, 00:19:25

es donde vamos a ir añadiendo las instrucciones 00:19:27

que se van a ejecutar, por ejemplo, en este caso, 00:19:29

dentro de esta clase, ¿vale? 00:19:32

Si veis esta llave, comprende todo lo que hay aquí dentro. 00:19:34

Y luego vais a ver otras llaves, por ejemplo, aquí. 00:19:38

Y esta llave, cuando marco esta, veis que tiene su correspondiente llave de cierre. 00:19:39

Y aquí es donde se irá ejecutando, por ejemplo, lo de este start o este update, este método update. 00:19:44

Esto ya veremos ahora qué es. 00:19:50

También tiene un área de influencia, donde yo iré escribiendo código y se ejecutará lo relacionado con update. 00:19:52

Entonces, aquí es muy importante que lo que se abre se cierra a nivel de llaves y a nivel de paréntesis. 00:20:00

También veis que se suelen abrir y cerrar, aunque estén vacíos y parezca un sinsentido, ahí están esperando. Dentro de este bloque iremos haciendo operaciones, pero veis que este bloque ya tiene, digamos, dos bloques aquí también, esperando que hagamos cosas. 00:20:07

Esto es porque Unity ya, a través de la herencia de otra clase, como de otra carpeta de posibilidades que alguien ha prehecho antes, los que han desarrollado C-SARP para trabajar en Unity, pues ya ha generado ciertas funciones como este start y este update para poder ejecutar en ciertos momentos. 00:20:21

C-SARP se usa también para programar de otro tipo, etc. Incluso si veis tutoriales en internet de C-SARP, de Aprende C-SARP, si no está aplicada Unity, vais a aprender C-SARP, el lenguaje, pero veréis que por definición va a haber una cosa llamada Main, pues otro método que está pensado para otros usos. 00:20:42

Aquí digamos que está adaptado, igual que un lenguaje luego tiene dialectos, por decirlo así, pues este ya está adaptado para lo que se hace en Unity, que es desarrollo de aplicaciones, videojuegos, etc. 00:21:00

Entonces, si pensamos fríamente, cuando estamos jugando en un videojuego lo que vamos a tener es unas interactividades, unas interacciones que vamos a ir haciendo y el programa en todo momento tiene que ir captando lo que hacemos o no hacemos. 00:21:10

para, pues si en el mando damos a la X, pues que salte, si es lo que hemos configurado, ¿no? 00:21:24

¿Vale? También va a haber momentos, va a haber operaciones que queremos que se ejecuten 00:21:31

según se lanza el juego. Pues, por ejemplo, que se configure el nivel, se cargue, 00:21:38

que se ponga que la vida está al 100%, etc. Y ese es otro momento del juego, que es al iniciar. 00:21:42

Entonces, estos dos métodos que tenemos aquí sirven, uno, para meter instrucciones que se ejecutan según se abre o se aplica dentro del juego este código, ¿vale? Al arrancar este código, en el estar lo que yo diga, se va a ejecutar, ¿vale? 00:21:49

Y luego va a haber aquí otro bloque, en base a otro método, que es este update. A ver, la traducción que ahora no me sale, como de actualización, de actualizar, que constantemente fotograma a fotograma va a ir mirando qué hay aquí dentro para fotograma a fotograma irlo ejecutando. 00:22:05

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

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

Y este update se irá ejecutando fotograma a fotograma 00:22:35

Esto lo vamos a entender en poco 00:22:38

Vamos a escribir, lo ha dicho el compañero, nuestro primer hola mundo 00:22:40

Que es una frase que se usa en programación para comprobar que la consola de programación del programa, la consola es, digamos, una especie de ordenadorcito que va a ir reflejando qué operaciones se están desarrollando en cada momento. 00:22:47

Aquí está más simplificado que en otros usos, ¿vale? 00:23:04

Pero vamos a lanzar a consola, ahora veis lo que es eso, nuestra primera frase, que va a ser ese hola mundo, ¿vale? 00:23:09

Y vamos a ver nuestra primera operación. 00:23:14

Va a haber un montón de palabras reservadas, de palabras clave, de propiedades, etcétera, que tenemos que ir aprendiendo e ir manejando, ¿no? Entonces, la primera que vamos a hacer es cómo hacer que nuestro programa lance una frase, ¿vale? Entonces, vamos a conseguir que a través de Unity ver la frase que nosotros le digamos, ¿vale? 00:23:15

Para eso hay que escribir debug y veis algo importante que cuando empezáis a escribir algo os empieza a salir aquí como ayudas. Esto es un sistema en Visual Studio que se llama IntelliSense, que lo que va haciendo es detectar lo que vamos escribiendo para darnos sugerencias de que esto puede completarse con estas opciones. 00:23:34

Que en todas veis que hay un tran, ¿no? Pues si sigo ir afinando, pero esto viene muy bien para ir sabiendo qué opciones hay que podamos ir seleccionando, ¿vale? 00:23:56

Entonces, la primera instrucción es este debug, ¿vale? Y dentro de cada instrucción, digamos que luego, dentro de cada clase en este caso, luego va a haber como propiedades hijas de esta operación, ¿no? 00:24:06

Por ejemplo, debug, si le damos al punto, de pronto van a salir muchas opciones, no hemos escrito más. Pues debug a ser debug log, que es la que nos interesa. Entonces, quiero que en programación interpretéis los puntos como separadores en jerarquías inferiores, me explico, como unas migas de pan que hemos visto antes. 00:24:22

¿Qué significa esto? Supongo que todos habéis rellenado la típica ficha que os preguntan, ¿cuál es vuestro país? Y luego, ¿cuál es vuestra ciudad? Y luego, ¿cuál es vuestra calle? Y luego, ¿cuál es vuestro número? 00:24:41

Y cada opción consecuente va a ser dependiente del padre. Es decir, si ponéis que sois de Estados Unidos, pues luego saldrá aquí la opción de poder elegir entre los estados. Pero si elegís España, pues lo que van a salir son las comunidades autónomas. Cada caso irá desbloqueando nuevas opciones. 00:24:55

Entonces, siempre se va a ir de lo general a cada vez lo más concreto. Debug, que sirve sobre todo para depurar código, para encontrar errores. Si damos al punto, tiene dentro muchas operaciones relacionadas. La mayoría de ellas no las vamos a necesitar, pero hay una muy importante que debéis aprender, que es esta que se llama debug.log. 00:25:13

Damos doble clic y ahí está. Cuando estamos ejecutando una acción con código, vais a ver que siempre, o prácticamente siempre, vais a tener que abrir y cerrar unos paréntesis. 00:25:40

Y esto alude otra vez a estos paréntesis, por ejemplo, que tenemos aquí, sin rellenar, porque ahora mismo esto nos interesa que esté vacío. Pero hasta que no ponemos estos paréntesis, digamos que el software, el Visual Studio, no sabe que estamos lanzando una instrucción de hacer algo, que es lo que se llama lanzar un método o lanzar una función. 00:25:56

De backlog, como funciona, por ver el primer uso, sirve para aquí, entre comillas, ahora os digo por qué 00:26:19

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

Pero bueno, lo voy a hacer más personal, hola mundo, Daniel 00:26:33

Y vais a ver que aquí nos sigue marcando un fallo, está aquí sobre allá con un fallo 00:26:36

Os dije el otro día que para que se vea reflejado algo que hagamos en código 00:26:42

¿vale? atención que aquí arriba 00:26:47

tenéis el nombre del archivo y va apareciendo 00:26:49

un asterijillo que indica que es que no está guardado 00:26:50

¿vale? hasta que yo no haga control S 00:26:52

yo no estoy guardando el código 00:26:54

y hasta que yo no guardo el código, por tanto 00:26:56

siempre hay que estar dando control S cuando queramos hacer algo 00:26:58

aunque yo vaya a Unity 00:27:00

y haga lo que tenga que hacer 00:27:02

no se va a ver reflejado 00:27:03

tenemos que ir guardando 00:27:07

y ojo, mirad que aquí 00:27:08

y aquí también tenéis asterijillos 00:27:09

¿vale? son dos software diferentes 00:27:12

Visual Studio y Unity 00:27:14

En uno estamos trabajando el código, que habrá que ir guardando también, y en otro iremos trabajando en lo que son las, pues todo lo que nos ofrece esta interfaz destinada a desarrollo de videojuegos a nivel gráfico. 00:27:16

Entonces, aquí también puedo hacer control S e ir guardando. 00:27:28

Veis que ahora se ha ido el asterisco. 00:27:31

Aquí se ha guardado todo lo relacionado a nivel visual, pero si yo cambio algo en Unity en código, son independientes cada uno de ellos. 00:27:33

Entonces atención de si algo no funciona 00:27:41

Que aquí no esté el asterisco 00:27:43

Porque entonces igual todo lo que habéis cambiado 00:27:45

No se está viendo reflejado 00:27:46

Y veis que aquí está este error 00:27:48

Y ya os digo, si aquí hay algo subrayado rojo 00:27:51

Vuestro programa no va a funcionar 00:27:53

Va a dar fallo, va a dar error 00:27:55

Porque no está sabiendo ejecutarlo 00:27:57

Y esto lo veis, si vais a Unity 00:27:58

Y os metéis 00:28:01

Aquí abajo ya sale una exclamación roja 00:28:03

Que algo nos dice 00:28:05

Que no está yendo bien 00:28:07

Y de hecho yo intento ejecutar el juego, aunque ahora no tenga nada 00:28:08

Le doy y dice, todos los errores de compilación tienen que ser arreglados antes de poder proceder al modo de juego. 00:28:11

Por tanto, veis que a mí no me deja hacer nada en el área de game porque está habiendo un error. 00:28:18

Esta línea roja que hay aquí realmente es una especie de resumen de lo que podéis ver en el menú consola. 00:28:25

Que os he dicho antes, si dais a consola, aquí sale aún más grande la exclamación y es el mismo error. 00:28:32

Es verdad que aquí pueden salir muchas más líneas, muchos más errores, se os puede llenar, pero aquí digamos que os va poniendo como la última o la principal que tenéis que ver. 00:28:37

Son las mismas, si leéis la línea es exactamente lo mismo. 00:28:47

Y esto, más adelante os va a venir bien, si queréis acceder a lo que está dando este fallo, si le dais doble clic, lo debería abrir, a mí me lo ha abierto en otro lado porque tengo otra ventana, 00:28:50

Pero lleva a la línea de ese error. Me está aquí marcando dónde está el error. Es una buena forma de, cuando hay error, saber de dónde viene. Le dais doble clic y decís, oye, ¿qué pasa? ¿Por qué esto está yendo mal? 00:29:01

Aparte aquí os pone también tanto, veis, el nombre del script del que está surgiendo el error, la línea, ¿vale? 11, 40, la línea y la columna que está dando el error. 00:29:13

Si nos metemos en el código, vemos que es la línea 11, por eso no lo va numerando, y la columna que no está detallada, pues es la 40, ¿vale? 00:29:24

Aquí podéis ir viendo, pues digamos, todos los problemas que podéis ir yendo de una forma también descrita. 00:29:32

Aquí también pone el error, ¿vale? Que aquí suele poner el motivo, ¿no? Y es que espera un punto y coma, ¿vale? A nivel de sintaxis de trabajo de este código, de CISAR, ¿vale? De este lenguaje, toda instrucción que vayamos dando, toda línea, debe acabar en punto y coma para ir separando las distintas órdenes que vamos ejecutando, ¿sí? 00:29:40

Entonces, hasta que no ponga punto y línea, pues esta orden, digamos que no se sabe hasta dónde llega, entonces hay que delimitarla en algún momento, ¿vale? Vemos que no da error, ¿vale? Y voy a ir a cesar para ejecutar esto, ¿vale? Y dice, aquí sigue poniendo el error, ¿por qué creéis que es? ¿Por qué? Si aquí no me sale nada rojo. 00:30:02

Venga, primera pregunta interactiva. 00:30:30

interactiva. Porque no se ha guardado 00:30:31

el 00:30:34

proyecto en el 00:30:36

Visual Studio. Perfecto. Veis que 00:30:38

está el asterijillo. Importante, porque 00:30:40

esto ahora es muy obvio, pero luego pasa. 00:30:42

Control-S, se ha guardado, vuelvo 00:30:44

y ya 00:30:46

cuando me permita 00:30:46

a veces tiene que recargar. Según el 00:30:50

ordenador, mejor o peor, tardará más. 00:30:52

Ahora hay otros problemas, 00:30:54

pero 00:30:56

ya no es el rojo. Cuando salen 00:30:56

errores amarillos, significa 00:31:00

con este warning 00:31:02

amarillo, significa que hay errores 00:31:03

pero no son 00:31:06

fatales, es decir, no van a detener la ejecución 00:31:07

pero bueno, convendría echarle un ojo 00:31:10

lo mismo, si le damos doble clic 00:31:12

nos abriría, esto es de otros scripts que tengo preparados 00:31:13

antes, nos abriría donde está en el código 00:31:16

ese error 00:31:18

ahora, cuando lancemos la aplicación 00:31:19

cuando le da play, vais a ver que se ejecuta 00:31:22

os he dicho 00:31:24

cuando lancéis, ahora se va a ver 00:31:25

en el juego, la frase, cual hemos dicho 00:31:27

hola mundo Daniel, y os vais a llevar 00:31:30

la primera desilusión, porque 00:31:32

no se ve nada en el juego, no hay nada 00:31:34

ahí que se vea 00:31:36

pero si os fijáis en la consola 00:31:38

sí que aquí pone hola mundo Daniel 00:31:39

os he dicho que 00:31:41

estas operaciones 00:31:44

se hacen 00:31:46

para depurar errores de código 00:31:47

es decir, no es algo digamos que se va a ver en el juego 00:31:50

son instrucciones que la consola 00:31:52

va a ir mostrando para ir viendo si se está ejecutando 00:31:54

algo bien o no, es de vital importancia 00:31:56

este debug log, ya iréis viendo que es con lo que 00:31:58

vamos a ir comprobando que todo funcione 00:32:00

entonces, ahora mismo he puesto 00:32:01

hola mundo Daniel, aquí podría poner 00:32:04

hola 00:32:06

a ver, uno de vosotros 00:32:07

Elisa, que la estoy viendo ahora mismo 00:32:09

pues, hola Elisa, ¿no? yo si vuelvo a guardar 00:32:11

y voy, cuando ejecute el juego 00:32:14

ojo, cuando me meto 00:32:16

otra vez, si está el juego en ejecución 00:32:18

necesito volver a lanzarlo 00:32:20

¿vale? 00:32:22

y ahora pone lo que le he dicho 00:32:23

¿vale? ya vamos viendo que algo 00:32:25

Se ve que hay cierta interacción 00:32:28

Vale, entonces, ya para entender 00:32:30

Que lo que hemos hecho en el Star 00:32:32

Significa que cuando empiece a ejecutarse 00:32:34

El juego 00:32:36

Se ve este hola Elisa 00:32:37

¿No te sale la consola Elisa? 00:32:39

No, ahora ya me escuchas 00:32:42

Que no me sale la consola 00:32:44

Lo estoy poniendo en el código y cuando me voy a Unity 00:32:46

No me sale 00:32:48

¿Quieres compartirme pantalla y lo vemos? 00:32:48

Ah, no puedo 00:32:51

Porque estoy con la cámara en un ordenador 00:32:53

Y con el Unity en otro 00:32:55

bueno, pues compárteme con el 00:32:56

en el ordenador de Unity no estás 00:32:58

con, no estás metida en las dos 00:33:00

no, vale 00:33:02

vale, pues nada, sigo trasteando 00:33:04

y si no te escribo y lo vemos 00:33:06

tú has escrito el código dentro, no hombre 00:33:08

pero me interesa que vayamos viéndolo 00:33:10

estoy poniendo como anotaciones de las cosas que vas 00:33:12

explicando para tener como hay una mini chuleta 00:33:14

pero he puesto debug.log 00:33:16

hola Eli 00:33:18

y no me sale, o sea, me sale bien 00:33:19

el código, no me sale ningún error 00:33:22

está pues con los mismos colores que tú 00:33:24

Pero en Unity no me sale en consola. 00:33:26

De hecho, me sale un error. 00:33:30

¿Y le estás dando al reproducir? 00:33:31

Es decir, lo guardas... 00:33:33

Lo guardo, lo reproduzco y me sale un error. 00:33:34

A ver. 00:33:38

¿Y qué error pone? 00:33:40

Collapse service is desplaced and has been replaced with Plastic SCM. 00:33:42

Uh, ese es avanzado. 00:33:49

¿Pero es rojo el error? 00:33:50

No creo. 00:33:51

Sí, es rojo. 00:33:52

¿Puedes hacer algo para compartirme la pantalla, porfa? 00:33:54

A ver si te va a dar sí 00:33:56

Espera, esto es una locura 00:33:59

Vale 00:34:01

Collab services deprecated 00:34:02

Claro, pero eso no tiene nada que ver 00:34:05

Con 00:34:07

Sí, está bien 00:34:09

Clase 00:34:14

A ver 00:34:16

Vuelvete al editor 00:34:17

Dale doble clic al error 00:34:19

¿Qué te hace? 00:34:24

Vale 00:34:29

Y esto lo ha generado de cero 00:34:30

Y nada 00:34:32

Y ese más que te sale... Es que tienes activado algo de compartir en la nube. Puede ser. A ver, cuando lo hayas creado en Unity Hub, ¿puedes ir al Unity Hub un segundo? El Unity Hub es el otro, el blanco. Ahí. Conectado. Vale. 00:34:34

Han metido nuevas opciones que están dando fallos y de las que yo, la verdad, tampoco controlo mucho. En el último Unity Hub han metido opciones del cloud, de la nube, ¿vale? Y en tu caso aparece como conectado. Desconectalo porque creo que es lo que está dando problema entonces para desconectarlo. No, no, no te salgas. Dale donde pone connected. Ahí, a ver qué te pone. Dale, no te deja cambiar, ¿no? La opción, vale. 00:34:55

A ver, Disconnect from Unity Cloud, pero no te deja. 00:35:25

Y a ver, y en el proyecto de abajo, que es otro, que no está en uso ahora mismo, 00:35:30

si vas a los tres punticos de la derecha, Disconnect from Unity Cloud, vale. 00:35:34

Vale, te sugiero que lo desconectes. 00:35:40

Sí, desconectalo, sin problema. 00:35:45

Y va a seguir dando el error porque este archivo sigue estando conectado. 00:35:46

Tienes que cerrarlo, vale, ciérralo. 00:35:50

Ciérralo de... Ah, eso es, sí 00:35:53

Y vuelve a hacer lo de la opción de desconectar 00:35:55

De desconectar 00:35:58

Este error 00:36:00

La verdad es que no 00:36:02

No sé muy bien cómo gestionarlo 00:36:02

Porque es algo que acaban de poner nuevo 00:36:05

A ver si con esto ya 00:36:07

Perfecto, a ver, dale al play 00:36:09

Pero no te sale el... Hola Elisa 00:36:11

Ah, bueno, claro 00:36:24

A ver, importante 00:36:26

Bueno, ya hemos solucionado el error 00:36:28

Pero, como he dicho antes 00:36:29

para que se vea reflejado en el Unity, 00:36:32

¿lo has aplicado como componente a algún objeto? 00:36:34

¿Lo has arrastrado a algún elemento? 00:36:39

Ahí, por ejemplo, a la luz, da igual. 00:36:41

La luz, cuando tiene sentido. 00:36:43

Ahora, cuando lo lances, 00:36:45

igual te lanza, tarda un poquillo, 00:36:47

¿vale? Dale al play. 00:36:50

Ahí lo tienes. 00:36:54

¿Vale? 00:36:55

Hasta que no lo aplicáis a algún objeto 00:36:56

que está dentro de la escena, 00:36:57

pues el código está ahí preparado, 00:36:59

pero no sabe a qué aplicarse. 00:37:00

¿Vale? 00:37:01

Bueno, no te escucho, 00:37:03

pero espero que que más o menos resuelto vale vuelvo a tomar yo el control vale 00:37:04

vale entiendo que veis mi unity sigo entonces importante ya veis que las 00:37:11

sutilezas son importantes estaba preparado todo bien pero pero bueno no 00:37:16

se estaba reflejando y como he visto que estaba haciendo en el código lisa cuando 00:37:20

ponemos dos líneas de este tipo podemos escribir lo que queramos para darnos 00:37:24

indicaciones. Por ejemplo, esto sirve para mostrar mensaje en consola. Y esto no se ejecuta. 00:37:28

Esta línea, esto verde, no se ejecuta. Es simplemente comentarios que vamos metiendo 00:37:36

en el código para recordarnos nosotros e ir marcando a otro programador que también 00:37:39

se meta en el código, pues lo que queramos, indicaciones. Importante, para que no ocurra 00:37:44

lo de Lisa, que tampoco era el problema por lo que hemos visto. Pero bueno, esa indicación 00:37:50

roja que salía no era muy aconsejable 00:37:53

añadido, a lo mejor 00:37:56

alguno, si el Unity Hub lo incorporaste 00:37:57

y según empezó el curso no salga 00:38:00

porque es algo nuevo del Unity Hub que acaban de incorporar 00:38:01

que es poder trabajar en la nube 00:38:03

para que esto no 00:38:05

aparezca por defecto y no haya que 00:38:07

desconectarlo después como acaba de hacer 00:38:09

la compañera, cuando creéis 00:38:11

un nuevo proyecto, de momento 00:38:13

a no ser que sepamos lo que hagamos, el otro día 00:38:15

lo vimos y de hecho el otro día no estaba 00:38:17

estas opciones para que veáis lo reciente que es 00:38:19

Os sugiero que a no ser que sepáis lo que hacéis 00:38:21

Desconectéis los dos 00:38:23

Tics nuevos que han puesto de usar 00:38:25

En la nube, ¿vale? Lo de la versión de controles 00:38:27

Y el connect, y de esta forma ya aparece 00:38:29

Desconectado, ¿vale? Para que no de ese 00:38:31

Error 00:38:33

Que no era fatal, aunque salía en rojo, yo creo 00:38:34

Que hubiera funcionado, pero 00:38:37

Bueno, pues de momento 00:38:38

No nos liamos con más cosas, ¿vale? 00:38:41

Vale 00:38:43

Hasta aquí bien 00:38:43

Como alguna duda de alguien 00:38:46

lo que he hecho 00:38:49

si os acordáis lo último que he hecho 00:38:53

mientras Elisa hacía el cambio 00:38:54

ha sido 00:38:56

copiar ese debug log de start 00:38:58

a update 00:39:01

si yo ahora mismo ejecuto el juego 00:39:02

me meto aquí y le doy a play 00:39:04

cuando arranca el juego 00:39:07

vais a ver que hola Elisa sale 00:39:09

muchísimas veces y aquí se van contando 00:39:11

y me dice ya más de 1000 y ya no te hace 00:39:13

la cuenta, cuando yo pare el juego 00:39:15

veréis que aquí hay un trillón 00:39:17

de hola Elisas. ¿Por qué? 00:39:19

Porque esta instrucción que le he dado 00:39:21

aquí de escríbeme en consola 00:39:23

hola Elisa, pues se ha ido 00:39:25

ejecutando cada fotograma de juego. 00:39:27

¿Vale? Fotograma 00:39:30

dependiendo del ordenador, 00:39:31

esto lo veréis en la próxima 00:39:33

lección que abra, 00:39:35

al final cada ordenador va a 00:39:37

tener una capacidad de computación 00:39:39

según si el procesador es mejor o peor, 00:39:41

pues eso, si es mejor 00:39:43

o peor el ordenador, pues va a poder 00:39:45

procesar más fotogramas por segundo 00:39:47

que otros, ¿vale? Entonces dependiendo del 00:39:49

ordenador ya veremos que esto puede suponer un problema 00:39:51

¿vale? Porque 00:39:53

unos ordenadores van a ser más 00:39:55

rápidos a la hora de ir calculando más fotogramas 00:39:57

que otros, ¿vale? Pero 00:39:59

por defecto ya vemos que sea el ordenador 00:40:01

que sea, esta instrucción de hola Elisa 00:40:03

cada fotograma que puede ir refrescando 00:40:05

pues lanza la instrucción indiscriminadamente 00:40:07

cada fotograma cuando se meta 00:40:09

dice uno hola Elisa, uno hola Elisa, uno hola Elisa 00:40:11

¿vale? Ya veis que hay dos momentos 00:40:13

que vienen ya por defecto hechos en los códigos 00:40:15

que son este start para cuando arranca el script y otro para según en el momento que esté este script, pues se vaya ejecutando, ¿vale? 00:40:17

Digo siempre lo de en el start cuando arranca el script porque si yo vuelvo a poner en el start el debug log, ¿vale? 00:40:24

Y yo tengo aquí el juego, lo tengo dentro, el componente está dentro de este empty object que es cálculos, ¿no? 00:40:32

Vale, yo, hay una opción aquí que sirve para activar y desactivar, que esto si lo probáis, pues por ejemplo con la nave, 00:40:40

Pues sirve para que se vea o no 00:40:45

Está ahí en la jerarquía pero no está funcionando 00:40:48

Si yo lanzo el juego 00:40:50

¿Vale? Veis que no se ejecuta 00:40:51

A diferencia de antes 00:40:54

Está el start pero es que como no se ha ejecutado 00:40:55

El componente 00:40:58

Dado que el objeto que lo contiene no existe 00:40:59

Cuando yo le dé a 00:41:02

De alguna forma que ya veremos 00:41:04

A que se ejecute este objeto 00:41:05

Pues ahí sí según se ejecuta 00:41:07

¿Vale? Por eso digo que el start no es 00:41:10

El primer fotograma del juego 00:41:12

Porque hasta que no se lance 00:41:13

digamos el script pues no funciona vale importante entonces ya tenemos voy a dejar que sí que esté 00:41:15

activo vale importante que a veces no es que no funcione es que no está vinculado a nada no está 00:41:22

funcionando ese objeto no vamos otra vez aquí al código vale os he dicho este de backlog o la elisa 00:41:28

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

o strings esto lo vamos viendo hay que ponerlo entre comillas yo voy a decirle no yo quiero que 00:41:39

lo que muestre en consola, porque soy así de temerario, es el resultado de 5 más 4. 00:41:45

Una operación aritmética muy básica. Yo cuando lance este juego, guardo y lance este 00:41:52

juego, al arrancar, lo que me va a mostrar la consola, dado que es lo que está dentro 00:42:00

de estos paréntesis, va a ser un 9. Lo veis aquí, que es el resultado de la suma. Esto 00:42:05

cuando vayamos teniendo que una bala si te impacta te quita 100 de vida y lo resta de las 500 pues ya 00:42:15

tendremos que ir haciendo operaciones entonces esta operación tan básica es el origen de todo 00:42:23

lo que vamos a ir haciendo con los juegos aunque aquí haya puesto los números rápidamente como 00:42:28

números sueltos vale hay que entender un poco cómo gestiona la información el propio unity me 00:42:35

Me refiero con cómo gestiona la operación, con que aunque aquí pongamos un 5 y un 4, ¿vale? 00:42:41

Hay distintos tipos de variables, ya me meto a ello que he introducido, según qué vamos a meter en esa variable, ¿vale? 00:42:47

Voy a hacer primero una cosa para que lo veáis sin entenderlo y luego lo explico, ¿no? 00:42:54

Yo, por ejemplo, voy a generar un número de tipo entero, con número de tipo entero me refiero a un número que no tiene decimales, ¿vale? 00:42:59

un número entero, que se va a llamar 5, ¿vale? Contesto. 00:43:07

Y a esto le digo que es igual a 5. Ahora os digo qué es. 00:43:12

Y luego voy a hacer otra variable llamada 4, que va a valer 4, ¿vale? 00:43:15

Y aquí lo que voy a hacer es, en vez de decir 5 con número, voy a apelar a este 5 que he puesto aquí 00:43:22

y a este 4 que tengo aquí. Y vais a ver que yo cuando lo lance, lo he escrito con texto, ¿vale? 00:43:31

Cuando lo lance, va a dar otra vez ese 9 que teníamos. Ahí está el 9, ¿vale? Pero esto no es porque el programa sepa que si escribe 5 contextos es un 5 como un número, ¿vale? Esto es porque anteriormente hemos declarado, y de hecho si yo borrara estas líneas, ¿vale? Daría error, ¿vale? 00:43:37

Porque hemos creado lo que se llaman variables. Las variables son referencias de ciertos tipos, como cajas, digamos, que vamos a ir usando para ir construyendo un Lego, que pueden ser de distintas formas. 00:43:59

Entonces, vamos a ir construyendo estas cajas de distintos tipos. En este caso estamos operando con números que son enteros, pero por ejemplo hay otro tipo de caja, otro tipo de variable, que son los que permiten operar con números decimales, que son estos de tipo float. 00:44:13

Por ejemplo, esto se va a llamar 5 con 5. Vais viendo que cuando escribo el nombre de esta variable, lo primero que hacemos es decir qué tipo de caja o qué tipo de información va a guardar, porque yo, aunque aquí me ponga bruto, si le pongo 5 con 5, no lo sabe entender porque esta caja solo permite guardar números enteros. 00:44:32

Pero si yo pongo 5,5 y pongo aquí 5,5 y hay que poner una f, esto también lo veremos, aquí no da fallo, aunque sea decir mal. 00:44:55

Aquí, aunque pusiera lo mismo, 5,5, f, pues nada hay. 00:45:05

Entonces, ved que hay cajas variables de distintos tipos y cada una va a permitir guardar información de distintas características. 00:45:09

la estructura 00:45:18

de declarar una variable, es decir 00:45:20

de crear una caja 00:45:22

o una pieza del ego 00:45:24

con la que vamos a seguir trabajando en el código 00:45:26

es siempre la misma 00:45:28

primero hay que poner de qué tipo es esa caja 00:45:30

en este caso pues vamos a hacer 00:45:32

como sé que voy a trabajar con un número entero 00:45:34

pues pongo este int 00:45:36

de integer, de entero 00:45:38

y luego esa caja 00:45:39

por hacer como una caja de mudanza el simil 00:45:41

la voy a etiquetar para 00:45:44

yo saber qué hay dentro y yo sé que aquí pues va a ser un 5 vale esta es el 00:45:46

nombre que nosotros queramos es el nombre que damos a esa pieza del ego con 00:45:52

la que vamos a ir trabajando entonces yo en vez de 5 puede ser el número primero 00:45:55

que vamos a usar vale y ese número primero esa caja dentro va a tener lo 00:46:00

que le asignamos después de este igual que es un 5 vale aquí por ejemplo creó 00:46:05

caja otra pieza que se va a llamar número que suma el nombre que queramos 00:46:11

aquí es lo que queramos también de tipo entero y un método ahora un 3 vale y 00:46:17

cuando vaya generando estos números veis que me da fallo porque las cajas que 00:46:24

antes se llamaban 5 y 4 ya no existen ahora habrá que trabajar con las cajas 00:46:28

digamos que yo he creado estas piezas y quiero que la suma lo va a hacerlo a 00:46:32

partir de esas variables ahora tendré que poner vale pues el número primero de 00:46:36

La operación. Y veis que cuando yo voy escribiendo el IntelliSense me va mostrando lo que coincida. Si yo he creado esta variable, y fijaos que incluso el iconito tiene forma de caja, ¿vale? Que es bastante representativo, ¿vale? Yo si escribo ese número primero, ahora mismo lo que yo ponga aquí con este nombre y este identificador, ¿vale? Lo que le he asignado, ¿vale? Ahora mismo aquí esto es sinónimo de 5 en este momento. 00:46:40

Esta caja luego podremos ir cambiándola de contenido a lo largo del código. 00:47:04

Por ejemplo, habrá algún momento que, para adelantar, que sea vida personaje y empiece valiendo 100. 00:47:10

Lo que pasa es que nosotros a lo largo del juego a esta caja vida personaje le iremos quitando o añadiendo vida, 00:47:18

según reciba balas o vaya cogiendo power-ups de corazón, de vida. 00:47:25

Entonces, esta sigue dando fallo porque ahora mismo esta caja no existe, no hay ninguna caja llamada así. Por ejemplo, número que suma. Número primero, si lo volviera a meter, sería otro 5. No, yo quiero número que suma. A ver, le clico y ahí está. 00:47:30

Ahora mismo, si leemos esto, estamos diciendo 00:47:45

Por favor, muéstrame en consola 00:47:48

Número primero 00:47:50

Más número que suma 00:47:52

¿Cuánto crees que va a dar de resultado? 00:47:54

Venga, mientras voy 00:47:58

8, ¿no? A ver, le doy al play 00:47:59

Le doy al play 00:48:04

Y 8, perfecto 00:48:06

Y si ahora, en vez de número que suma 00:48:08

Aquí pongo 00:48:10

Vida persona 00:48:12

Que es otra caja que tengo 00:48:14

¿Cuánto valdría? 00:48:16

105, ¿sí, no? ¿Estamos todos de acuerdo? 00:48:22

A ver si lo que dice... 105, perfecto. Entonces vemos que al final, y esto si no le veis la utilidad se la iréis viendo rápidamente, iremos generando variables o palabras, digamos que van englobando datos dentro. 00:48:24

¿Vale? Que ya os digo, que se irán actualizando a lo largo del juego cuando vayan ocurriendo ciertos eventos. ¿Vale? Veis también que cuando uso una de estas palabras, ¿vale? Cuando marco en un sitio, se me marcará en el resto de sitios que está apelando a un mismo, a un mismo, a la variable en ciertos puntos. ¿Vale? Esto sirve para ir viendo fácilmente dónde se ha declarado, es decir, dónde se ha generado la caja y dónde estamos, pues, usándola. 00:48:42

veis que hay un número hay variables que están marcadas de gris que eso significa que sí que 00:49:10

esa caja existe pero no se usa en ningún momento si nunca se va a usar lo suyo sería borrarla vale 00:49:15

de hecho si voy a algunos de los errores en este momento que hay aquí vale cuando detengo la a ver 00:49:20

cuando detengo la ejecución me puede sugerir a veces ahora no me lo está haciendo porque tengo 00:49:26

que cambiar algo 00:49:31

a poner 105 vale cuando ahora vuelva a refrescar vais a ver que por defecto en 00:49:35

la consola a veces tarda un poco 00:49:41

vale entre los errores es en cálculos 5 la variable 5.5 está sin 00:49:46

nada pero su valor nunca se usa vale pues eso significa que 5.5 está aquí 00:49:53

pero nunca se usa veis que es un error que va a funcionar el juego pero dice 00:49:58

oye borra esta línea si no la vas a usar para que vas a llenar tu habitación de 00:50:02

cajas si no lo vas a usar aparte de números enteros y decimales vale y los 00:50:07

decimales se escriben con un punto en vez de con una coma vale y hay que poner 00:50:11

una f de flow at vale porque si no no sabes si se está refiriendo a un número 00:50:15

decimal o otras cosas vale si no ponéis la f aunque permita tener 55 yo le doy 00:50:19

a la F y no funciona. 00:50:25

Y ojo, si yo pongo 00:50:28

número 00:50:29

primero y 5 con 5, 00:50:31

¿vale? Ahora estoy juntando 00:50:34

cajas de distinto tipo. 00:50:35

¿Qué debería la lógica 00:50:37

decir que nos da como resultado? 00:50:39

Vamos a verlo. 10 con 5 00:50:48

dicen por ahí. 00:50:49

Por cierto, cuando tenemos 00:50:52

todos los errores estos que nos pueden salir, 00:50:53

si damos a Clear, lo limpiamos, 00:50:55

ya sabemos lo que queremos, para al volver 00:50:57

a ejecutar, pues que se generen los que tienen que ser. 00:50:59

10,5, perfecto, ¿vale? Entonces los decimales los va cogiendo, pero cuando vayáis introduciendo un dato decimal siempre con punto y con F detrás, ¿vale? Si no, no lo lee, si no da fallo, ¿vale? Simplemente eso. 00:51:01

Hay más tipos de cajas. Otra muy importante que es el string. Las cajas, las variables de tipo string. La variable de tipo string lo que contiene son textos, ¿vale? No son números con los que operar, son textos. 00:51:16

la f tiene algún motivo lógico 00:51:29

simplemente es 00:51:32

float, es la miniatura 00:51:34

de float 00:51:36

que como vemos aquí es el 00:51:37

tipo de variable que 00:51:40

guarda 00:51:42

estos valores, el string 00:51:44

igual, la lógica de 00:51:46

declarar una variable es siempre el tipo de variable 00:51:48

en este caso vamos a decir, el dato que voy a guardar 00:51:50

aquí es una 00:51:52

cadena de texto, es un texto 00:51:54

y lo voy a llamar pues cadena de texto 00:51:55

o yo qué sé, mi nombre, ¿vale? 00:51:58

Y entonces, al darle igual, ¿vale? 00:52:01

Y quiero que vayáis interpretando estos iguales 00:52:03

no como un igual en matemáticas de 2 más 2 igual a 4. 00:52:05

Esto significa que se está asignando un valor, ¿vale? 00:52:09

O lo que se llama, el término más correcto sería inicializar, 00:52:13

en este caso, el valor, que es que una caja que está vacía 00:52:16

está aquí, de pronto la vamos a poner un algo. 00:52:19

No estás comparando nada, ni es equivalente una cosa a otra. 00:52:21

Ahora, sí lo es, pero es que esto que está aquí a la izquierda 00:52:25

pasa a tener este valor, ¿no? 00:52:29

Y aquí, si yo pusiera un número, ¿vale? 00:52:31

Y mirad que yo todas las operaciones las acabo 00:52:33

cuando acaba la instrucción con un punto y coma, 00:52:35

como os he dicho antes, ¿vale? 00:52:37

Importante, porque si no se empiezan a juntar conceptos 00:52:38

y empieza a dar problema, ¿no? 00:52:40

Entonces, veis que yo aquí pongo un 5 y dice error, 00:52:43

porque esta caja no está pensada para números, ¿vale? 00:52:45

Para meter texto, cuando algo queremos que sea un texto literal, 00:52:48

como hemos hecho antes con el holamundo, 00:52:51

hay que abrir comillas, ¿vale? 00:52:53

Las comillas típicas de entrecomillar, ¿no? 00:52:54

Y aquí se puede poner, vale, pues en mi caso, Daniel, ¿vale? 00:52:58

Y ahí se ha guardado un texto. 00:53:02

Si yo pongo ahora mismo, a ver, por ejemplo, 00:53:05

voy a hacer una frase, digamos, compuesta de varias variables 00:53:14

para que veáis que se puede ir modulando todo, 00:53:19

modularizando, mejor dicho. 00:53:21

Voy a generar un string que guarda mi nombre, ¿vale? Otra caja que guarda la frase que construye o el predicado que va a ser tiene de edad, ¿vale? 00:53:22

Y luego al final voy a poner otra variable, que en este caso es un número, porque va a ser mi edad, que son 34. 00:53:44

Entonces yo puedo ir combinando estas cajas para que vaya componiendo texto. 00:53:54

Si yo, por ejemplo, aquí dijera, enseña en el debug log solo mi nombre, lo que va a enseñar la consola es mi nombre, que es Daniel. 00:53:58

En vez de haber escrito literalmente aquí, está referenciando a una variable para enseñarnos lo que hay en el interior de esa variable. 00:54:06

Yo si ahora voy a la consola y le doy a iniciar, pues pone Daniel. 00:54:12

Así que lo que podemos ver es que podemos ir concatenando distintas variables para hacer elementos más grandes. 00:54:20

Igual que antes hemos sumado dos variables que contenían dentro un número, también podemos ir concatenando textos. 00:54:28

Por ejemplo, puedo poner mi nombre, más, y este más no es que estemos sumando números. 00:54:35

Cuando se usa el más al usar textos, lo que estamos haciendo es que un texto va detrás de otro, ¿vale? Entonces yo puedo poner mi nombre, luego el predicado, ¿vale? Y ahora lo que va a enseñar, ¿qué creéis que va a ser? A ver si alguien puede adivinar. Voy cambiando a... ¿alguien quiere apostar? 00:54:41

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 números, es para unir, ¿no? Entonces vais a ver que lo que pone es Daniel tiene edad. 00:55:11

Y fijaos que no deja ningún espacio en medio entre Daniel y tiene. ¿Por qué? Pues porque básicamente no sabe que hay un espacio entre esta cadena de caracteres y esta, ¿vale? Si la queremos, como es literal, meto un espacio y ahora sí, ahora sí que va a haber ese espacio. 00:55:32

que ved que lo que hay entre comillas es literalmente lo que vamos escribiendo dentro, ¿vale? 00:55:47

Entonces ahora sí que vais a ver que, le damos aquí y pone Daniel tiene edad, ¿vale? 00:55:52

Y ahora puedo decir, ¿vale? Y aparte de Daniel tiene edad, ¿vale? 00:55:59

Que son bloques que yo puedo en cualquier momento ir cambiando, ¿vale? 00:56:03

Ahora lo que va a guardar esta variable es tiene de años, 00:56:06

perdón que la frase sea un poco extraña, pero es para construirlo más fácil, 00:56:09

tiene de años y aquí voy a poner edad, que es esta variable, 00:56:12

Que veis que ahora es una variable de tipo número 00:56:15

Y además es de tipo número float 00:56:18

Lo cual no es muy correcto si no voy a meter decimales 00:56:20

Y normalmente la edad no se mete con decimales 00:56:23

Tienes 34 años o 35, no tienes 34 y medio 00:56:26

O no se suele guardar así 00:56:28

Por tanto, al hacer esta caja, si la edad siempre va a ser número entero 00:56:30

Pues lo ponemos aquí de tipo entero, ¿vale? 00:56:33

Sin ningún problema 00:56:35

Pero hay ciertas limitaciones si no vamos usando los tipos de variables que hay que usar 00:56:36

Ahora mismo lo que va a hacer es poner Daniel, ¿vale? 00:56:41

espacio, por este espacio que he puesto aquí, no porque haya aquí en medio, ¿vale? 00:56:45

Esto es lo mismo que escribirlo así. 00:56:49

Los espacios en programación son solo visuales, ¿vale? 00:56:52

Al final lo que importa son los valores que vamos dando dentro. 00:56:56

Entonces, esto va a decir, Daniel tiene de años 34. 00:57:00

Aquí, aunque no sea de tipo texto, como entiende que un número, 00:57:05

si se está concatenando, porque está aquí unido a textos, 00:57:09

Lo que vas a querer ver es el texto también, ¿no? Y entonces al final lo que voy a hacer es, aparte sin meterlo en variable, poner años y punto, ¿vale? Es decir, va a poner Daniel tiene de años 34 y valga la redundancia años punto. 00:57:12

Y ojo, aquí habrá que poner un espacio para que se pare de la anterior palabra y en años también habrá que poner uno para que se pare de la edad, ¿vale? Para que se vea con espacio, bien construido, ¿no? Guardamos y a ver si es verdad que está poniendo lo que yo digo, ¿qué va a poner? 00:57:29

Daniel tiene de edad 00:57:48

de años, bueno, he cambiado de edad 00:57:51

habéis visto que he cambiado el interior de la variable antes 00:57:53

a mano, 34 años 00:57:55

¿vale? de esta forma podemos ir 00:57:56

uniendo distintos elementos 00:57:59

de distintos tipos 00:58:01

entonces, importante, al declarar 00:58:03

una variable, el tipo de variable 00:58:05

el nombre de la variable que nosotros queramos 00:58:06

darle y luego asignamos 00:58:09

el valor que tiene esa caja 00:58:11

¿vale? lo que pasa es que muchas veces 00:58:13

cuando vamos creando 00:58:15

estas variables, ¿vale? Y voy quitando aquí. Lo dejo solo en esto, en su mínima expresión. 00:58:17

Has creado la caja, pero no la has llenado de nada, ¿vale? Cuando no llenas la caja 00:58:24

de nada, interpreta en los números que es un cero, ¿vale? Que está vacía, pero a nivel 00:58:29

práctico es un cero, ¿vale? Y en los textos, pues no tiene texto también. Lo interpreta 00:58:34

como un cero. Y en los de tipo float también es un cero, ¿vale? Podemos ir creando las 00:58:40

cajas, ¿vale? Y posteriormente, en algún momento de la ejecución, que a lo mejor no es al principio, cambiar su valor. Por ejemplo, ¿no? Hemos dicho, y fijaos que esto está dentro de la clase, que es lo que os he dicho, que es el patrón que va conteniendo todos los comportamientos que vayamos haciendo, ¿vale? 00:58:44

Pero luego hasta que no hay un momento concreto al comienzo o al actualizar, estos son como datos, como variables que estamos creando a nivel genérico. Pero hasta que no sea en el momento del comienzo o que esté dentro del update, realmente no se está ejecutando nunca, ¿vale? 00:59:01

más rápido, si yo cogiera este debug log 00:59:18

y lo pusiera aquí, va a dar fallo 00:59:21

pues dice, sí, muy bien, depura 00:59:23

pero ¿cuándo? ¿cuándo depuro? esta instrucción 00:59:25

no es crear una caja para luego usarla 00:59:27

es algo concreto, que es lo que os he 00:59:29

dicho que son los métodos cuando se usa 00:59:31

estos paréntesis, una acción, algo concreto 00:59:32

se hace cuando apelamos a algo que tiene 00:59:35

estos paréntesis, aquí dice, vale, yo 00:59:37

hago lo que tú me digas, pero ¿en qué momento? 00:59:39

no me estás definiendo ningún momento 00:59:41

por eso tiene que ir dentro de algún bloque 00:59:43

de momento de ejecución 00:59:45

Y también lo que podemos hacer es decirle, al iniciar el juego, el script, quiero que número primero, esta variable que he generado aquí, valga 7. 00:59:46

Y aquí ¿qué ha pasado? Y voy a volver a decirle que lo que quiero que me enseñe es número primero. Y veis que la misma palabra yo cuando la marco en un sitio, como es la misma caja nombrada igual, aparece en varios sitios. 01:00:03

esto que estoy haciendo, aquí he declarado 01:00:14

he creado la caja, he declarado la variable 01:00:17

al principio está vacía, vale 0 01:00:20

pero al empezar el juego yo le he dicho 01:00:23

yo quiero que esta caja valga 7 01:00:25

y imprime aquí 01:00:27

lo que hay dentro del número primero, la consola 01:00:29

por tanto, lo que vamos a tener ahora es 01:00:33

pues si lo adivináis 01:00:35

un 7 01:00:39

¿qué pasa? que esto a lo largo del juego 01:00:41

vamos a irlo cambiando, ¿no? Fijaos que 01:00:46

cuando yo ya he declarado la variable y he dicho 01:00:48

de qué tipo es esa caja, ¿vale? 01:00:50

Ya cada vez que hablemos de esa caja 01:00:53

ya no hace falta poner de qué tipo es, ya 01:00:54

lo hemos generado aquí al principio, ¿vale? 01:00:56

Veis que por eso ya nunca más 01:00:59

vuelve a poner el tipo de variable, solo se 01:01:00

habla de la variable y se puede asignar 01:01:02

a continuación o usarla 01:01:04

pero no hay que volver a declararla, eso se hace 01:01:06

una vez. Declarar de hecho 01:01:08

es crear esa caja 01:01:10

la primera vez, luego ya es emplear 01:01:12

la variable. Entonces, ahora mismo enseña 7, pero algo importante es que, por defecto, 01:01:14

en estos momentos que estamos de programación, el código se va a ir ejecutando de manera 01:01:21

lineal, es decir, de arriba a abajo, igual que leemos nosotros, de arriba a abajo y de 01:01:27

izquierda a derecha. Entonces, cuando vamos bajando, hemos declarado esta variable de 01:01:30

tipo entero, vamos bajando, va bajando y dice, ah, vale, al empezar la ejecución, enséñame 01:01:36

lo que haya en número primero. Y luego aparte 01:01:41

pues decimos, vale, número primero vale 01:01:43

7. Antes 01:01:45

ponía que era 7. Ahora, ¿qué va a poner? 01:01:48

¿Qué va a enseñar en consola? 01:01:50

¿Qué número? ¿Ha cambiado 01:01:52

algo o no? 01:01:53

¿Creéis que ha pasado algo? 01:01:55

Nada. No va a poner nada porque está 01:01:57

debajo, ¿no? Eso es. 01:01:59

Hasta este momento, ¿vale? La variable 01:02:01

vale 0. Nadie ha cambiado 01:02:04

que valga 0, que es el valor por defecto. 01:02:05

Y luego ya más adelante, pues pondrá 7. 01:02:07

Entonces, si vamos aquí, ahora mismo yo ejecuto, pues pone el 0 como una casa. 01:02:09

¿Veis que si es solo una línea, además, también nos la enseña aquí, que a veces también puede servir de ayuda. 01:02:15

Esto sirve para ver el orden de ejecución. 01:02:21

Y que aquí podemos empezar a inicializar y decir, número primero vale 2. 01:02:24

Pero después de valer 2, número primero vale 4. 01:02:32

Se ejecuta esto. 01:02:37

Y cuidado, que si no acabamos la instrucción con punto y coma. 01:02:39

Luego, número primero vale 7. 01:02:42

Y luego voy a hacer un debug log de vida persona. 01:02:44

Ahora mismo, ¿qué va a mostrar? 01:02:55

¿Qué pensáis que va a salir en la consola? 01:02:59

El 4. 01:03:11

Sí. 01:03:13

Pero he puesto otro debug log, otro enséame en la consola, ¿no? 01:03:15

pues lo suma 01:03:18

no, es decir, eso es 01:03:20

lo que ha puesto Roberto, primero 01:03:23

hace esta instrucción y me enseña 01:03:24

va bajando, va bajando, aquí es lo último que le hemos 01:03:26

dicho que vale este 01:03:29

número primero, vale, pues aquí enseñará un 4 01:03:29

seguimos bajando, vale, si a partir de aquí 01:03:32

volvemos a usar el número primero, valdrá 7 01:03:34

pero bueno, aquí va a enseñar 4, aquí hemos dicho 01:03:36

enseña 4, sigue bajando, bla, bla 01:03:38

y dice, y aquí voy a enseñar vida persona 01:03:40

que además, ahora mismo, vale 0 01:03:43

entonces 01:03:45

Entonces, Roberto, te has equivocado en esto segundo porque el 7 lo enseñaría si aquí pusiera número primero, pero es que estoy pidiéndole que me enseñe vida persona, que está vacía, ¿vale? Lo enseño. Es decir, el juego no va a consistir solo en que enseñe una cosa, va a enseñar o va a realizar muchas operaciones. 01:03:46

Entonces, bueno, os lo enseño y vais a ver que primero sale ese 4 y luego ese 0, ¿vale? Y una se ejecuta primero y luego la siguiente. Os he dicho antes que las operaciones, lo haz algo, son normalmente palabras con paréntesis. 01:04:04

Y entre paréntesis puede haber cosas o no. Vale, pues aquí al empezar el juego, ¿vale? Le hemos dicho, enséñame lo que valga número primero, que vale 4, y aquí lo que valga vida persona, que está aquí vacía. Si yo vida persona, ¿vale? Vida persona, aquí vale 85, ¿vale? ¿Qué va a poner ahora en consola? 01:04:20

Nada, porque está por debajo 0. 01:04:46

Es decir, la consola va a mostrar primero 4, ¿no? Y luego 0. Vale. Esto es para ver que pilláis la lógica, vamos, que sé que son preguntas simples. Ahora, ¿qué pondría? 01:04:48

85. 01:05:03

En la segunda línea, primero 4 y luego 85. 01:05:04

4 y luego 85. 01:05:06

Vale, lo vais entendiendo, ¿no? Básicamente, que puede haber varias operaciones y aquí se están ejecutando dos, ¿vale? Entonces el orden de ejecución está en relación a las líneas que se van leyendo, ¿vale? 01:05:07

hasta aquí bien recordad que luego se nos puede ir un poco la pinza con vale vida persona vale 85 01:05:20

pero aquí quiero que me lo enseñe más número primero vale y aquí ahora mismo ya última que 01:05:29

hago de esto perdonad que pondría aquí en la segunda línea la segunda instrucción que le 01:05:37

al arrancar 89 4 y 89 no no no 92 efectivamente porque aunque aquí ponga número primero en este 01:05:41

punto que estamos ya ha superado esto y ha cambiado de valor lo que hay dentro de la caja 01:05:55

no vale esto es lo que va a ir permitiendo luego tener en cuenta que hay operaciones que se van a 01:06:00

ir haciendo fotogramas fotogramas que vayamos actualizando subiendo bajando cifras que al 01:06:05

Al final son la vida, el tiempo de carga, el nombre del jugador que hemos metido en un campo, ¿vale? 01:06:09

Se va a ir actualizando a medida que vayamos haciendo ciertas operaciones, ¿vale? 01:06:16

Esto es un poco la base de todo. 01:06:21

Vale. 01:06:25

Una duda, Daniel. 01:06:26

Para el ejercicio de la unidad cero, entonces, ¿sería mejor declarar las vidas sin asignarle un valor 01:06:27

y luego tú irle asignando los valores dependiendo de si le afecta la bala, no le afecta? 01:06:34

es mucho más como eso que poniendo 01:06:39

que restas o que sumas 01:06:41

claro, tú declaras esa bala 01:06:42

y luego tendrás que ir sumando o restando daño 01:06:45

y daño puede ser un número 01:06:47

ya establecido o 01:06:48

uno aleatorio, que también se pueden hacer números aleatorios 01:06:51

vale 01:06:53

hablar de la tarea cero, ¿no? 01:06:54

sí, sí, la tarea cero 01:06:55

vale, esa tarea 01:06:58

ya os digo que 01:07:00

no va a salir de momento 01:07:02

ni de broma, si nunca habéis estado 01:07:03

pero si lo que quiero es que vayáis intentando resolverla 01:07:05

para con lo que vayamos viendo tal vale que hay cosas que no se ha explicado ni 01:07:07

se ha abierto el tema ni está todavía en el tema vale pero que es para que os 01:07:12

pongáis con ellos vale entonces variables el concepto variable ya vais viendo que 01:07:15

es referenciar valores para moverlos por el código en distintos momentos en 01:07:21

esencia es eso esto se va complicando por supuesto vamos a la tarea 1 vale 01:07:26

después de hacer ese prefab de la nave que en principio no había mayor problema 01:07:32

fallar, quien lo haya intentado pues le da alguna pista de algo que puede fallar, pero en principio es tener esa nave. Lo segundo que pide es instanciar la nave, ¿vale? Instanciar más allá, que evidentemente si vamos a usar variables, por eso lo has explicado, lo que vamos a hacer es una operación, que es, ya esto lo pone en el tema, que es hacer una operación que es instanciar el objeto por código, ¿no? Para eso se usa, al arrancar el juego, se puede poner aquí la operación instantiate, ¿vale? De todas las que hay. 01:07:36

Vais a ver que IntelliSense también nos va dando distintos iconitos, ya iré explicando mejor qué es cada cosa, ¿vale? Pero en este caso, por ejemplo, es de un método y una función. Método y función, si lo iréis escuchando mucho, son sinónimos. A veces diré métodos y a veces diré función, ¿vale? 01:08:05

Y cuando me pongo encima, vais a ver que IntelliSense, cuando me voy poniendo con la selección de la palabra, nos da más ayudas aquí, nos da muchas ayudas siempre, ¿vale? Aquí ahora mismo nos dice Instant, ahí va, bueno, espera, Instant, cuando a veces no os salga, empezad a escribirlo otra vez porque si no se pierde. 01:08:24

Os ponéis encima y pone Instantiate, pone como cosas que está heredando de estas librerías que os he dicho que había aquí arriba y llegamos hasta la palabra Instantiate y dentro de paréntesis pasan cosas y pone más cuatro sobrecargas. 01:08:44

Ahora vemos qué es eso. Os he dicho, cuando hay algo que lleva una palabra y luego unos paréntesis, como aquí el start, es una acción. En este caso, start es al arrancar lo que tengas dentro del bloque. 01:08:58

Ahora vamos a hacer una, que esto son cosas que tenemos que ir aprendiendo, es al arrancar, dentro voy a instanciar un objeto. De momento me da fallo porque es verdad que esta operación, a diferencia de la de start, 01:09:11

hasta que, por ejemplo, no le dices qué objeto, no sabe qué hacer. 01:09:24

Y cuando no sabe qué hacer, estos programas se vuelven muy locos 01:09:27

y te dan error y dicen, mira, yo hasta que no me digas qué tengo que hacer, 01:09:30

pues no me voy a ejecutar. 01:09:33

Entonces, cuando abrimos llave, una vez ya hemos puesto por completo 01:09:35

la instrucción en el debug log, vuelvo un segundo al debug, 01:09:39

hemos dicho es la clase debug que dentro tiene la operación log. 01:09:43

Al dar a log, yo sé que es una operación que debe tener unos paréntesis para, en este caso, en esta operación, definir qué tiene que mostrar el mensaje, ¿no? Y vais a ver que a veces salen aquí, en el desplegable, dos flechitas, ¿vale? 01:09:47

Una misma operación, una misma palabra que esconde detrás operaciones, puede variar en el contenido de estos paréntesis. 01:10:03

Debug log puede, como hemos hecho hasta ahora, solo mostrar un mensaje, lo que pongamos ahí como mensaje, 01:10:13

y fijaos que como nos va enseñando lo que tiene que ir dentro, tiene la misma lógica que cuando hemos declarado la variable. 01:10:19

Primero te dirá qué tipo de variable o de objeto tiene que tener dentro y luego cómo ha llamado el software, el código, a ese mensaje. 01:10:26

Es decir, ahora mismo en el debug log que hemos hecho hasta ahora, está diciendo que dentro tiene que haber un elemento de tipo objeto, que dentro de Unity querría decir cualquier tipo de variable. 01:10:39

Y aquí ha puesto un nombre, igual que hacíamos nosotros, genérico, que lo ha puesto el programador para que sepamos que lo que hay que meter es el mensaje. 01:10:50

Esto no significa nada, simplemente que nos está dando la ayuda de que es un mensaje. 01:10:57

Si le damos aquí a lo que se llama sobrecarga, nos dice hay otra opción que aparte de poder introducir el mensaje separado por una coma, podemos meter un contexto. 01:11:02

Esto aquí no lo voy a hacer con esta operación, lo voy a hacer con la de instanciar. 01:11:13

Cuando yo abro el paréntesis distanciar hay hasta 10 de lo que se llaman sobrecargas, que son a esta palabra, esta acción, puedes hacer uso de ella hasta de 10 formas diferentes. Y veis que cada una, entre el paréntesis, va poniendo distintas opciones, cada una con sus peculiaridades, que ahora vamos a ver. 01:11:16

Si vamos a la primera 01:11:35

Dice, pues tú aquí me puedes meter un objeto 01:11:37

Que se llama original 01:11:40

Y abajo incluso pone una descripción 01:11:41

Pone, clona el objeto original 01:11:44

Y devuelve un clon 01:11:46

Es decir, que coge un objeto 01:11:48

Y lo clona en la escena 01:11:50

Bueno, pone 01:11:52

El original es un objeto 01:11:54

Que ya tengas, del que quieras hacer una copia 01:11:56

Que en este caso va a ser el prefaz que tenemos de la nave 01:11:58

Entonces, simplemente 01:12:00

Para que sepáis, vais a ir viendo 01:12:02

que hay distintas formas de operar con estos métodos, ¿vale? 01:12:04

Y lo que hagamos normalmente va a variar dependiendo de lo que pongamos aquí. 01:12:09

Aquí, de la forma rápida, vamos a decir que lo que vamos a poner dentro de este paréntesis 01:12:14

es el prefab que va a instanciar. 01:12:20

Es decir, ahora mismo este código se va a ejecutar donde esté este objeto entity, 01:12:23

que hemos creado antes 01:12:29

y ahí vamos a generar un clon 01:12:30

del prefab 01:12:32

que tenemos aquí preparado 01:12:35

de esta navecica que tenemos aquí preparada 01:12:36

y claro, aquí es donde empieza 01:12:38

ya la cabeza a dar vueltas y decirle 01:12:41

vale, hasta ahora hemos hecho variables que he creado 01:12:43

aquí, le he dicho que es un 5, una palabra 01:12:45

pero como meto yo aquí dentro 01:12:46

pues que es un prefab 01:12:48

¿no? 01:12:51

como meto aquí la nave, ¿no? 01:12:52

vale, cuando 01:12:54

vayamos avanzando en el 01:12:56

En el temario vamos a ver que aparte de números enteros, de strings, de cadena de texto o de floats, por ejemplo, hay más, pero bueno, esos son como los más usados a nivel de primitivas de variable, hay otras que apelan a conceptos que están dentro del juego. 01:12:58

Uno, por ejemplo, es, y con mayúscula, ¿vale? Esto ya veréis que se puede escribir con y sin mayúscula, un transform, ¿vale? Un transform, veis que nos lo marca y dice, es una clase, bueno, y guarda la posición, rotación y escala de un objeto. 01:13:18

Cuando generamos una variable de tipo transform, por ejemplo, ¿vale? La lógica es igual que la que hemos hecho anteriormente. Hemos dicho, primero hay que decir el tipo de variable que estamos creando y luego le damos un nombre nosotros que queramos. 01:13:33

Pues posición referencia, ¿vale? Punto y coma. Ahora mismo vale cero porque no hay nada, ¿vale? Pero tenemos aquí una posición de referencia de donde queremos que se instancie la nave. 01:13:48

Y voy a hacer otra cosa, ahora lo explico, que es que también se puede crear una variable de tipo GameObject, que lo que va a hacer es que en su interior se va a poder guardar un objeto, en este caso un prefab, y va a ser mi prefab, por ejemplo. 01:14:03

Ahora mismo lo que tenemos es, aunque no sepamos muy bien qué quiere decir esto, una variable que por el tipo que es esta caja lo que va a guardar son GameObjects que tenemos en la escena. Está configurado con estas librerías que tenemos aquí. Va a permitir, y de hecho fijaos que cuando leemos esto pone UnityEngine.GameObject. 01:14:19

Yo os he dicho, siempre va de lo general a lo concreto, ¿no? Unity Engine, si os fijáis, está aquí abierto, por eso no hay que volver a abrirlo. Y gracias a esta librería, pues aquí tenemos este GameObject. Y cuando metamos algo en esta caja, vamos a referirnos a esta caja con mi prefab, ¿vale? 01:14:40

¿Qué tal? Ahora vemos cómo seguimos, pero más o menos me vais siguiendo. 01:14:59

Sí, más o menos. 01:15:07

Más o menos, vale. 01:15:08

Aquí hemos generado una caja, que ahora veremos cómo va a guardar el objeto para poder usarlo bajo el nombre Mi Prefab, ¿vale? 01:15:10

Y luego, como vamos a querer que esta instancia se ubique donde nosotros le digamos, pues hemos generado otra variable de tipo transform. 01:15:16

Y con transform es que podemos guardar los valores de posición, rotación y escala de un objeto. 01:15:26

De hecho, no es extraño que dentro de los componentes haya uno que se llama transform que justo se ocupa de esos tres conceptos. 01:15:35

Si nosotros conseguimos que en una variable se guarde el transform, guardará todo lo que hay adentro. 01:15:45

Entonces ya podremos decirle a través de código, oye, lo que me generes por donde esté este transform. Y nosotros hemos guardado la posición de, en este caso, esto, pero puede estar variado. 01:15:52

Entonces, para coger ciertos... A ver, voy a guardar. Y de hecho, así me sirve para adelantarlo, normalmente va a haber variables de todos los tipos de componentes. 01:16:02

Por ejemplo, esto también ya veremos qué es 01:16:13

Meto un box collider, voy metiendo aquí distintos componentes 01:16:16

Y veis que he generado un nuevo tipo de transporte 01:16:19

Transform, que podré guardar la información de transform 01:16:22

Pero también va a existir, por ejemplo, el de rigidbody 01:16:24

Que es el que antes os he enseñado que da gravedad 01:16:27

Que hace actuar al motor de físicas 01:16:29

Y si yo empiezo a escribir aquí 01:16:33

No es casualidad que haya un objeto, un tipo de variable 01:16:34

Que se puede llamar rigidbody 01:16:37

Y esto lo llamo mi gravedad 01:16:38

El nombre que queramos 01:16:41

Este último es gravedad. Yo voy a poder dirigirme a los distintos componentes guardándolos en su propia caja. Hay que hacer alguna operación más, pero dentro de esta variable de esta caja voy a poder meter cualquier cosa que esté dentro de RigidBody. 01:16:42

Luego podré acceder a todas estas propiedades. O BoxCollider, pues también voy a poder hacer cajas que se refieran a lo que haya dentro de BoxCollider. Y aquí, pues, B, C de BoxCollider. ¿Vale? Entonces, que os vaya sonando que estos son componentes. 01:17:00

Cuando aparecen además con este colorcito verde, que es el mismo de la clase, al final, fijaos la lógica que CalculusTut, si nos fijamos, no deja de ser otro componente. Es un nombre de componente. Esto es lo que se llama una clase en programación. 01:17:14

Y las clases en programación se pueden usar para incorporarlo como componentes. Entonces, todo componente al final lo que es, es una clase que podemos referenciar aquí. Es decir, que si yo me meto, esto simplemente para que espero que os ayude a ir comprendiendo, si damos con la tecla control sobre algunas palabras, os deja meteros dentro. 01:17:32

¿Veis que cambia el cursor y me puedo meter dentro? Y aquí hay un montón de cosas que ya ha programado alguien y por eso están las librerías preparando el componente, en este caso, GameObject. 01:17:55

Pues ya hace muchas cosas, pero que ya están hechas por el programador. 01:18:09

Entonces, a ver, que vaya al padre, ahora aquí. 01:18:14

Y Transport también tendrá sus historias ya preconfiguradas, etc. 01:18:18

Entonces, estas clases, aunque aquí veamos estos componentes con muchas opciones, claro, esto es porque ya hay un código que dice, pues quiero que enseñes, bueno, no sé cuál lo había metido, pero mira, por ejemplo, cámara. 01:18:23

Todo esto alguien ha hecho un código para que vaya enseñando cada uno de los elementos. 01:18:35

Al final, ahí, y veréis que no me lo estoy inventando, cuando aquí ponga cámara, ¿vale? Y puedo llamarle mi cámara, ponerle un nombre, y aquí me meto, y cuando me meto, pues habrá opciones como, a ver si alguna, es que hay tantas que no voy a poder verlo, pero por ejemplo, fill of view, ¿vale? Y hay ya opciones preconfiguradas. 01:18:39

Pues si nos fijamos aquí, va a haber alguna que es fill of view, ¿vale? Bueno, pues todo esto se está viendo porque lo hemos programado antes, alguien lo ha programado antes para que ya estén constituidas y tengan ciertos comportamientos, ¿vale? Esto evidentemente, simplemente para que vaya viendo qué clase y componente son sinónimos, en cierto modo, y aparte se pueda hacer cajas variables con estos, con estas, digamos, con los valores que ya tienen estas clases, ¿vale? 01:19:00

Entonces ahora mismo lo que me interesa es la clase que me permite guardar GameObjects, que son objetos, y también voy a decir una posición, voy a querer una posición y por tanto voy a usar que la caja transform también lo puedo usar, el componente transform de otro objeto. 01:19:27

Entonces, claro, aquí a diferencia de antes no podemos hacer un igual y 5 o nave prefab, no se puede. Se puede hacer con código más adelante, pero bastante más complejo que hacer una asignación por el igual. 01:19:43

Entonces, aquí hay que empezar a hablar de lo que, y esto está en el tema cero también, lo que se llaman los ámbitos de las variables. 01:19:56

Vais a ir viendo, si cogéis otro código, empezáis a ver que muchas veces leeréis palabras como privado, private o público, que aquí ya viene uno, por ejemplo, 01:20:05

porque al final estos códigos llegarán momentos que querremos que se comuniquen entre sí. 01:20:16

Es decir, imaginaos que yo he puesto a cálculos un componente y luego el personaje tiene su propio script con su vida de 100. 01:20:22

Y es cálculo la que se ocupa de coger de otro componente la vida del personaje y en otro objeto, en otro script, hacer operaciones. 01:20:32

Entonces, digamos que cuando se vaya complicando el tema, habrá que ir intercomunicando los distintos scripts y los códigos. 01:20:40

Pero no siempre nos va a interesar que todo se comunique con todo, porque a lo mejor va a haber personajes con sus scripts, va a haber enemigos con sus scripts, va a haber una pared que podemos romper con sus scripts y todas tienen vida, digamos, cada una la suya respectiva. 01:20:47

Si al final empezamos a poner variables como vida, ¿vale? Pues no nos acordábamos, si todos los scripts diferentes tienen vida, al final nos podemos equivocar, podemos poner vida y referirnos a la vida de otro personaje. 01:21:03

Entonces, para limitar, esto es como una explicación así un poco chusca, pero bueno, a veces no nos interesa que los distintos elementos se puedan meter unos dentro de otros, ¿no? 01:21:15

Entonces, para eso existen lo que se llaman los ámbitos de acceso. ¿Eso qué significa? Que cuando vamos generando tanto clases como variables, incluso como métodos, acciones, podemos decirle que algo se pueda ver desde fuera de este script o no. 01:21:28

Y esto básicamente significa que cuando generamos cualquier variable, igual que os he dicho que una variable sin valor vale a cero, normalmente cuando declaramos una variable es privada, es decir, que solo se va a ver dentro de esta clase, ¿vale? No lo va a poder ver otro código, ¿vale? Aquí también, aunque no lo ponga, también hay un private, veis que no da error, aunque lo escriba, ¿vale? Porque se supone que por defecto lo pone como privado, para que sea restrictivo, ¿no? 01:21:49

Sin embargo, en ciertos momentos nos puede interesar que una variable sea pública y lo puedan ver otros objetos. 01:22:16

Y en Unity no es solo que lo puedan ver otros scripts. 01:22:25

En Unity es que también sea público desde el inspector de Unity. 01:22:28

Voy a hacer una cosa. Voy a borrar, voy a comentar, ¿vale? 01:22:33

En vez de borrar, para tenerlo preparado, comento de un segundo. 01:22:36

Si luego quiero usar, digo, para que no dé error, ¿vale? 01:22:39

Si en cualquier momento quiero recuperar cualquier cosa, quito el código y lo tengo ahí. 01:22:41

Es una práctica muy común comentar para dejar de usar algo. Entonces, ahora mismo si me meto en el script CalculusTut, solo hay un campo aquí que es script, que viene por defecto, cuando metemos un script para definir qué script es el que estamos asociando. 01:22:44

Ya está, no permite hacer nada. Pero fijaos, y aquí ya va a empezar a abrirse un mundo de posibilidades, que si yo en vez de decir que algo es privado, lo pongo como público, es decir, que puedan acceder otros scripts a este elemento, si yo lo pongo público y guardo, vais a ver que ahora dentro de este script se ha abierto otro campo nuevo que se llama mi prefab, ¿vale? 01:23:03

Voy un segundo aquí, que es el nombre de la variable. Veis que él ya interpreta que aunque sea mayúsculas y minúsculas, lo separa bien con sus mayúsculas, bien escrito, ¿vale? Que está hecho todo a propósito. Y aquí deja un espacio que podemos rellenar con algo que sea un GameObject, ¿vale? 01:23:29

Entonces, haciendo públicas las variables es como, por ejemplo, en este componente, en este código, alguien hace que aquí se puedan meter tres variables llamadas posición, que luego además se referirá a ellas para hacer ciertas operaciones, ¿vale? 01:23:46

Si, por ejemplo, el transform digo que sea público también, ¿vale? Pues cuando lo hago público y guardo vais a ver que, esperad un segundo que está cargando, pues está la posición de referencia y está esperando algo que sea de tipo transform. 01:23:59

¿Vale? Entonces, a ver un segundo que se esté grabando todo. Vale, genial. Vale, aquí estamos. ¿Vale? Entonces, con esto lo que vamos a poder hacer es, desde el propio inspector, arrastrar elementos. 01:24:15

veis que la main cámara la meto en las dos 01:24:31

¿vale? 01:24:34

fijaos, importante antes de seguir 01:24:36

que aunque estoy arrastrando la misma cámara 01:24:38

en cada uno sale un iconito 01:24:40

¿vale? porque en cada uno está guardando 01:24:41

un tipo de información, en uno está guardando 01:24:44

la caja del GameObject, porque es de tipo 01:24:46

GameObject, y en otra 01:24:48

¿vale? recordad que el componente de transform 01:24:50

tiene este icono, está guardando 01:24:52

la información de transform de este objeto 01:24:53

aunque estemos arrastrando el mismo objeto 01:24:55

en cada una de las variables 01:24:58

dentro de esta caja, de esta pieza de Lego 01:24:59

está guardando una información distinta 01:25:01

que nosotros ya iremos usando a conveniencia 01:25:03

¿vale? entonces esta es la forma más rápida 01:25:05

las hay más 01:25:08

y de hecho en ciertos momentos esto es 01:25:09

muy básico, digo que se tendrá que buscar 01:25:11

de otra forma, es la forma en la que tenemos 01:25:13

para llenar 01:25:15

estas cajas de 01:25:17

la información que nos importe 01:25:18

¿no? entonces ahora mismo 01:25:21

si 01:25:24

tenemos aquí un instant shade 01:25:25

y vuelvo a escribir el paréntesis para que veamos 01:25:27

aquí hay el primer método 01:25:30

dice object 01:25:32

que es sinónimo de GameObject 01:25:33

aquí podemos meter el objeto que queremos que se instancie 01:25:35

y ahora lo bueno es que si ponemos aquí 01:25:38

mi prefab 01:25:40

esa variable que hemos llenado 01:25:40

con algo en este momento 01:25:43

a través del inspector 01:25:45

ahora se va a instanciar algo cuando arranque 01:25:47

es verdad que ahora mismo lo he hecho así 01:25:49

de la explicación pero mi prefab lo que instancia 01:25:51

es una cámara que no es lo que me interesa 01:25:53

yo lo que voy a querer instanciar es la nave prefab 01:25:55

voy a cálculos 01:25:57

y el prefab lo puedo arrastrar a main cámara. 01:25:59

Y veis que se ha guardado aquí el objeto de nave prefab. 01:26:03

¿Esto qué significa? 01:26:07

Voy a guardar también aquí, voy al código 01:26:08

y aquí le estoy diciendo, en esta nave mi prefab, 01:26:09

a través de, al hacerlo público, a través del inspector, 01:26:14

he guardado ese prefab y cuando yo instancio, 01:26:17

ahora sí que sabe qué objeto es el que tiene que instanciar 01:26:20

porque se lo he atribuido ahí. 01:26:23

Cuando guarde, vais a ver que, 01:26:25

¿vale? cuando guarde 01:26:27

al darle a play 01:26:31

no está en ningún lado pero me genera una copia 01:26:32

bueno, perdonad que como aquí le he metido 01:26:35

a la nave antes un rigidbody y tal 01:26:38

para explicaroslo, voy a quitar 01:26:39

dentro del prefab todo lo que le he añadido 01:26:41

de componentes 01:26:44

que ahora mismo no me interesa que tengan 01:26:46

como el boss collider y el rigidbody 01:26:47

¿vale? se ha autoguardado, salgo 01:26:49

y vuelvo, a ver, detengo 01:26:51

y cuando arranca el juego porque está en el start 01:26:53

me genera esta nave aquí 01:26:56

¿vale? 01:26:58

Así es como ha sabido el programa que es esta nave la que tiene que hacerse, una copia. 01:26:59

Si yo en vez de la nave pongo el prefaz cubo, pues sin hacer nada más, ya cuando le da al play lo que se va a instanciar es el cubo, no la nave. 01:27:06

Y para acabar, o de las últimas cosas que voy a decir, lo bueno que tiene esto es que como cada método tiene sus sobrecargas, 01:27:14

el primero te lo pone, te lo origina en el punto de origen de donde se está generando el script. 01:27:22

Es decir, yo me pongo aquí y le digo mi prefaz como estaba haciendo y yo no tengo control de dónde se instancia, ¿vale? Más allá de que se instanciará donde esté el objeto padre, que es el que instancia, ¿vale? Es decir, yo ahora me pongo en el 0, 0. 01:27:28

por cierto, cuando generéis un nuevo elemento 01:27:42

como un empty 01:27:46

cuidado que según donde tengáis 01:27:47

la navegación 01:27:50

no lo genera en el punto de origen 01:27:51

veis que yo he generado uno nuevo y me lo he puesto en el 20 01:27:54

menos 1, menos 6 01:27:56

si queréis empezar a hacer todo desde el 0 01:27:57

es muy buena práctica siempre crear el objeto 01:28:00

a menos que lo hagáis a posta, claro 01:28:02

y lo reseteáis para que esté en el 01:28:03

punto de origen 01:28:06

ahora mismo cálculos, que es el 01:28:06

objeto que tiene aquí, veis que tampoco 01:28:09

está en el origen 01:28:12

Y yo cuando arranco el juego, me lo está generando en una posición que tampoco es la que me interesa, que sería la del origen. 01:28:12

¿Por qué? Porque si recordáis, cuando yo he hecho el cubo, estaba movido del 0,0. 01:28:20

Y cuando he instanciado, sin decirle un punto de referencia, que es lo que he hecho ahora en el código, 01:28:27

porque no le he dicho nada referente a posición, lo intentará hacer en el 0,0, 01:28:31

pero lo está moviendo en relación a lo desplazado que esté ya el prefab. 01:28:36

Lo que os he dicho antes de la boquilla y si lo movíamos, ¿no? 01:28:40

Entonces, si yo este prefab lo guardo y vuelvo aquí, ¿vale? Y lo vuelvo a lanzar el juego, me lo deja en el 0, 0, ¿vale? Ahora sí que está en el 0, 0, este cubo. 01:28:43

Si yo quisiera decir un punto del espacio donde se puede ubicar el objeto, por ejemplo, hago aquí un objeto que es la boquilla de la pistola. 01:28:58

De hecho, voy a hacer algo visual para que sea más fácil de detectar. 01:29:11

Hago este cilindro, que es la pistola que se va a ir moviendo durante el juego. 01:29:16

Y en un momento X voy a querer que en este punto, cuando le dé a la barra espaciadora, por ejemplo, se instancie la bala. Este objeto está en unas coordenadas que no son el 0,0. Si yo ahora mismo le digo que se instancie la bala en algún punto, pues lo mismo, se va a instanciar en el 0,0. 01:29:21

Pero si yo vuelvo otra vez a cálculos y le digo la posición de referencia quiero que sea la del cilindro, que la voy a llamar boquilla-pistola-boquilla. Cuando voy a cálculos, yo si arrastro boquilla a la posición, yo quiero que instancie el cubo, va a instanciar en la posición de la boquilla. Estoy preparando esto. 01:29:42

Entonces, como esta posición, este transform, lo está cogiendo de la boquilla, hay otra opción que es decirle, vale, quiero que me lo hagasen, al ponerle coma, veis que se pueden ir añadiendo más parámetros. 01:30:02

Y ahora la sobrecarga que me abre es la 2, que es la que permite meter dos valores. Incluso si pusiera tres comas, significa que puedo meter tres distintos valores. 01:30:15

Pero el que está configurado para que lleve dos es una que es el objeto original y otra que es cuál es el padre y la posición donde se va a generar, que es esta posición referencia. Cierro el paréntesis, guardo y vais a ver que a diferencia de antes, ahora sí que cuando se ejecute el juego, la bala se ha hecho hija de la boquilla y además está en la misma posición que la boquilla. 01:30:25

Ya no se hace en el 0,0. Entonces veis que de esta forma podemos ir relacionando, ir cogiendo la información de uno y de otro e irla usando a nuestro antojo. Habrá que ir conociendo poco a poco los métodos, las acciones que podemos hacer, pero bueno, esto es un poco como la base de ir moviendo datos de un lado a otro mediante código. 01:30:56

solo me queda una cosita muy corta 01:31:16

por explicar y por mi por hoy 01:31:19

creo que ya estoy y puedo 01:31:20

creo que tenéis información suficiente 01:31:22

para hacer la práctica, me quedan dos cosas 01:31:25

y ahora os pregunto que tal, imaginaos 01:31:27

que yo en este instantiate en vez de hacerlo en start 01:31:29

lo pongo en update, corto y pego 01:31:31

la línea y guardo, que es lo que va a hacer 01:31:33

pues que va a generar 01:31:35

una copia cada frame 01:31:37

vale, aquí 01:31:40

se van haciendo millones 01:31:42

esto normalmente no os va a interesar porque va 01:31:43

colapsar el juego de tantas copias que está haciendo pero veis que dependiendo 01:31:46

de dónde se ubique pues hace la operación una vez al comienzo otra 01:31:50

durante cada fotograma y hay más métodos de tiempo pero bueno estos son como los 01:31:55

básicos que vienen vale luego última cosa os he dicho que antes que por nivel 01:31:59

de protección para que no se pueda acceder a una variable desde varias 01:32:05

variables que a lo mejor se llaman igual y luego un código muy grande esto por 01:32:09

defecto si no ponemos nada al declarar una variable es privado no yo lo he 01:32:12

puesto público para que se vea en el inspector. Lo he vuelto a hacer privado. Ojo, que lo privado 01:32:15

no existe. Y ahora no es solo que no exista, sino que ahora se ha perdido la referencia de los 01:32:22

objetos. Es decir, que ahora hago esto y no se va a instanciar nada porque ha dejado de pasarse la 01:32:29

información. Pero hay otra operación, digamos híbrida, que es que yo puedo seguir queriendo. 01:32:35

Esto es un poco para que veamos si lo vais cogiendo, que es que teniendo la misma protección privada, que otro script no se pueda meter a esta variable, que sí que permita que se pueda operar con ella desde el inspector de Unity, por ejemplo, para pasar los objetos. 01:32:41

Y eso se llama, esa operación es metida entre estos corchetes, lo que se llama un serialized field, campo serializado. Se pone antes del tipo de variable, que es donde se ponen los ámbitos, a ver, esperad, que lo quiero copiar en la otra. 01:33:01

Y ahora las dos van a seguir siendo de tipo privado, lo puedo poner incluso de manera explícita aquí escrito, pero siguen siendo privados. Cuando veamos cómo se accede a otros scripts, no se va a poder acceder de forma fácil, pero sí que permitimos que aparezcan aquí para poder hacer este traspaso de información de elementos. 01:33:18

Ojo, veis que cuando he borrado y lo he vuelto a poner, está en vacío. 01:33:43

Muchas veces va a dar error que de pronto vamos a ver aquí algo vacío y pensamos que está. 01:33:46

Este es el peligro que tiene de trabajar desde el inspector. 01:33:50

Por eso muchas veces se hace todo con código, que eso funciona siempre si está bien hecho. 01:33:54

Entonces habría que volver a decirle en cálculo la boquilla es lo que voy a usar de posición de referencia. 01:33:58

Ahora la nave, por ejemplo, va a ser el prefab que se va a instanciar el objeto. 01:34:04

guardo y al ejecutar pues ya la boquilla va a tener bueno como está en el update pues se va 01:34:08

a estar haciendo la nave en el sitio vale entonces bueno lo primero casi me va a interesar meter esto 01:34:14

en el start y ya está más o menos lo que se pide la práctica está todo explicado desde luego instancia 01:34:20

y luego tiene más sobrecargas vale podría poner otra coma incluso antes de decirle podemos poner 01:34:27

si se instancia en un punto 01:34:34

concreto, con una rotación concreta 01:34:36

aunque coja la posición de manera 01:34:38

independiente. Bueno, pues ya 01:34:40

hay más sutileza, pero esto ya 01:34:42

demasiado por hoy. 01:34:43

Último de todo. 01:34:46

Para que os vayáis haciendo la cabeza, y esto 01:34:48

lo voy a poner muchas veces en los temas, 01:34:50

¿vale? Si ponéis 01:34:53

cualquier método, cualquier 01:34:54

propiedad en Google, por ejemplo, 01:34:56

Instantiate, y ponéis Unity, ¿vale? 01:34:58

Os va a remitir a la API 01:35:01

o al manual, ¿vale? 01:35:02

de Unity 01:35:04

y aquí es donde os da una explicación 01:35:06

esto está en inglés, no está en español 01:35:08

normalmente 01:35:10

de cuántas sobrecargas hay 01:35:11

su uso, descripciones, ejemplos 01:35:14

¿vale? cuando no sepáis cómo funciona algo 01:35:16

a medida que vayáis cogiendo además 01:35:18

más 01:35:20

soltura, pues iréis entendiendo mejor que pone aquí 01:35:21

pero esto va a ser vuestro 01:35:25

manual de uso 01:35:26

frecuente y que hay que ir 01:35:28

revisando cuando tengamos problemas de hecho si en cualquier momento le dais al 01:35:31

interrogante de un componente concreto por ejemplo el transform al darle se ha 01:35:37

abierto la otra pantalla pero me ha abierto aquí la aplicación de transform 01:35:42

vale con eso podéis ir viendo la ayuda está a veces demasiado extensa pero da 01:35:45

mucha información útil 01:35:51

Tutoría 2 - DEIM - UT1 y 0 - Curso 24·25 - Contenido educativo

Del mismo autor…

Vídeo resumen "El ciclo celular, Biología 2º Bachillerato

Vídeo resumen "Bioelementos, El agua y las sales minerales", Biología 2º de Bachillerato

Vídeo resumen "Bloque II, Biología de 2º de Bachillerato"

Vídeo resumen "ADN, Biología 2º de Bachillerato"

Vídeo resumen "Bloque I de Biología, 2º de Bachillerato"

Día Internacional de las Personas con Diversidad Funcional 2025

Encender 4 led a la vez