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

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. 00:00:06

Sí que hay un concepto, que es el de prefab, que yo tengo aquí, por ejemplo, preparada mi nave, 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:20

Al final, un prefab no deja de ser un objeto, como se explica, que está guardado para poder ser reutilizado en distintas partes del proyecto o instanciado. Instanciado es generar copias de un mismo objeto. 00:00:34

y lo voy a usar de referencia en varios momentos 00:00:49

por ejemplo, si en un videojuego 00:00:52

y perdonad que remita a videojuegos 00:00:54

violentos, pero es que suelen abundar 00:00:56

mucho, cuando disparamos una bala 00:00:58

con la metralleta 00:01:00

imaginaos que cada bala es un objeto 00:01:01

ese proyectil va volando por el aire 00:01:04

bueno, pues tenemos ya un prefab 00:01:06

de esa bala y lo que vamos haciendo es 00:01:08

lanzar copias de esa bala, de una única 00:01:10

bala, a lo mejor tenemos prefab de 00:01:12

bala de escopeta, bala de 00:01:14

metralleta, yo que sé, pero al final 00:01:16

a menos que lo hagamos con otra finalidad, va a ser ese prefab que se va duplicando. 00:01:18

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

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

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

En el panel proyecto vais a ver normalmente ya la geometría del prefab. 00:01:39

Por ejemplo, aquí veis la nave, y atención porque aquí podemos hacer zoom 00:01:44

Y hay una forma que no es que haya un menú de ver en modo lista ni en modo visualización, que es que si quitamos todo el zoom vamos viendo los elementos con iconitos y enlistado, que a veces es más interesante para saber de qué se trata cada elemento. 00:01:47

Al ver esta caja azul sabemos que es un prefab y lo tenemos ahí preparando. Y habéis visto que yo puedo empezar a meter aquí el prefab 85 millones de veces. Lo podemos tener aquí para hacer un escuadrón. No sé si ahora habéis visto el típico juego que hay de alguien que va corriendo y va pasando por un más 10, por 2 y se va multiplicando. 00:02:01

Eso al final son que se van instanciando más o menos prefabs a medida que se van cumpliendo ciertas condiciones. Una vez dicho esto, algo importante y me vuelvo a referir a la bala de la escopeta. Imaginaos que ahora en vez de la nave es una escopeta. 00:02:24

El prefab cuando lo generáis, que lo podéis ir generando, como ya habréis estado haciendo los que comenzaste la tarea, a generar aquí los elementos con las geometrías, etc., con las distintas primitivas que se pueden poner en Unity, y lo que hacemos es arrastrar, pues imaginaos que este cubo es lo que queremos convertir en prefab, para convertir en prefab cogéis de la jerarquía los elementos, podéis seleccionar varios, y lo arrastráis al panel de proyecto y se genera un prefab. 00:02:39

En este caso es un cubo. 00:03:06

Bueno, pues es un prefab bastante básico. 00:03:07

Si fuera una esfera, pues podría ser la bala. 00:03:10

Si queréis editar este prefab, bueno, y ved que he borrado el prefab que había generado 00:03:13

y aunque esté en la escena, es verdad que se pone en rojo como avisando de 00:03:18

oye, el prefab de origen no está. 00:03:21

Te dejo el objeto aquí, pero esto ya no es un prefab. 00:03:24

Si veis, sale esta indicación roja, significa eso. 00:03:27

Imaginaos que tenemos ya la nave y ya la hemos preparado 00:03:30

y está ahí como un prefab, ¿no? 00:03:35

¿Cómo se edita un prefab? 00:03:37

Porque esto al final es como cuando en cualquier software 00:03:38

se mete en una carpeta, en un folder, en un bin, 00:03:41

varios objetos de la jerarquía, ¿no? 00:03:44

Que se van aquí poniendo una dentro de otra, 00:03:46

como habréis visto también en la tarea, ¿no? 00:03:49

Cuando vayamos teniendo estos elementos 00:03:51

y los convertimos en prefab, 00:03:53

pues igual lo tengo aquí como prefab, 00:03:55

lo borro todo, ¿vale? 00:03:57

Y digo, vale, pues tengo aquí el prefab, 00:03:58

que lo puedo duplicar, pero esto cómo se edita luego, ¿vale? 00:04:02

Para editar un prefab es fácil. O le dais doble clic al elemento o al propio elemento también de la jerarquía, ¿vale? Se puede de cualquiera de los dos puntos, en este caso el cubo. Voy a abrir la nave, mi nave, ¿vale? Cuando hagáis el prefab, pues para reeditarlo y recolocar elementos, doble clic y se os abre este área como azul, ¿vale? Un poco tron, ahí esperando a que hagamos cosas, ¿vale? 00:04:05

Esto se identifica, para que sea fácil, con dos pistas visuales. 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 porque lo hemos abierto desde donde está aquí incorporado. 00:04:27

En una de las escenas está este prefab aplicado. Y aquí podemos ir variando todos los elementos que compone ese prefab, que al final veis que es como una especie de empaquetado de geometrías que tenemos ahí con una jerarquía, esperando a que se instancie. 00:04:48

Si en algún momento queremos cambiar el prefab, nos metemos dentro del prefab y aquí podemos ir modificando cada elemento como en la jerarquía de la escena habitualmente. 00:05:03

Sí que es verdad que es importante. Aquí hay una opción que se llama autosave, que por defecto a mí me aparece marcada, debería aparecer marcada, que nos puede interesar o no. 00:05:11

Porque esto significa que todo cambio que vayamos haciendo de los elementos se irán guardando en el prefab automáticamente. 00:05:23

Si lo desmarcamos, veréis que yo, si por ejemplo el alerón lo muevo un poco, pues si yo saliera no se está guardando. 00:05:30

habría que dar a este save que ha aparecido aquí, ¿vale? 00:05:38

Que a veces cuando intentáis salir del prefab os dice, 00:05:40

oye, pero ¿guardas o no? 00:05:43

Eso dependerá de cómo lo estéis gestionando, ¿vale? 00:05:44

Si queréis volver, dice, ya he terminado y lo voy a dejar mal, ¿vale? 00:05:47

Esta pieza la he dejado un poco, 00:05:51

que es el alerón trasero vertical este que he puesto, 00:05:53

lo dejo así, ¿vale? 00:05:57

Movido de sitio, si os fijáis. 00:05:58

Si yo guardo y salgo, ¿vale? 00:06:00

Para volver, digamos, a la jerarquía o al escenario, 00:06:02

aquí está esta flechita, ¿vale? 00:06:06

que nos sirve para volver al proyecto, para ir para atrás, o también podemos incluso dar a esa miga de pan que tenemos, ¿vale? 00:06:08

¿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:14

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

Y esto es lo que me sirve para primera cosa que suele haber de problema en vuestras entregas de esta tarea, 00:06:25

que es tener en cuenta 00:06:31

imaginaos que cuando 00:06:33

hagamos las instancias del objeto 00:06:35

vuelvo a remitir a la bala 00:06:36

nosotros luego vamos a dar un punto 00:06:39

de referencia donde se va instanciando esa bala 00:06:41

desde donde se emite 00:06:43

ese proyectil, en el caso de una bala 00:06:45

pues lo suyo será poner la boquilla 00:06:47

de la pistola o del arma que sea 00:06:49

para que a partir de ahí vaya para adelante 00:06:51

en profundidad 00:06:53

si 00:06:54

ese elemento que estamos instanciando 00:06:55

está movido del 0,0 de ese origen, imaginaos que hago esto, si yo me muevo de aquí, cuando yo 00:06:59

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

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

ojo, si queréis instanciar algo en un punto concreto, aseguraos de que todo esté en el 0,0 00:07:19

de origen, ¿vale? Es decir, ahora mismo 00:07:26

lo está. Y veis que aquí hay un elemento 00:07:28

padre, que es el nave prefab, que está 00:07:30

con todo intacto, ¿vale? 00:07:32

Y luego he ido haciendo hijos 00:07:34

a los distintos elementos de la jerarquía. 00:07:36

¿Por qué pongo 00:07:39

otro padre, vale? Esto es 00:07:40

fácil. Está el 00:07:42

elemento empty, que es como un nulo, ¿vale? 00:07:44

Como un nul en otro software de 3D, etc. 00:07:46

Que cuando lo creáis está vacío, pero 00:07:48

sirve para colocar elementos dentro de otros 00:07:50

elementos y dar coordenadas. 00:07:52

El elemento padre-padre de un prefab, cuando estamos dentro del prefab, digamos que no puedes poner nada por encima de la jerarquía de ese elemento 00:07:53

Por tanto diría que este elemento, por defecto en los prefabs, debería estar siempre configurado para que estén las coordenadas de origen 00:08:04

Que son los ceros de posición, los ceros de rotación y a uno de escala, ojo, la escala por defecto es 1 en las tres dimensiones 00:08:11

Y luego dentro de eso nos aseguramos a modo visual que esté todo donde queremos que esté. Así cuando instanciemos nos aseguramos que este padre es el origen del prefab y luego ya iremos distribuyendo los elementos. 00:08:20

Luego hay otra cosa a considerar que os pone, que es que la nave tiene que estar mirando hacia la Z en profundidad, ¿vale? Si os fijáis en este guismo del mundo, ¿vale? Dado el juego que vamos a hacer luego, que va a ser un Endless Runner, ¿vale? Que va la nave en profundidad y van apareciendo obstáculos, un poco como el Subway Surfer, no sé si lo conocéis. 00:08:35

Yo os voy a enseñar para que tengáis en cabeza hacia dónde se dirige esto, lo enseño muy rápido. Esto será de la tarea 2, ¿vale? Es el siguiente paso. Pero lo que vamos a buscar, ahí lo tenemos, es un juego como de estas características, todavía feote, etcétera, pero que va a ir esquivando los pivotetes estos que van apareciendo. 00:08:58

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

Si el prefab lo incorporamos 00:09:21

Angulado hacia otra dirección, luego habrá que hacer otra operación 00:09:24

Para reenderezarlo, por tanto, igual que con lo de la bala 00:09:27

¿Vale? Pues lo mismo 00:09:30

Si queremos que esté en el punto de origen 00:09:32

Y orientado correctamente, pues hay que tener en cuenta 00:09:35

Que el mundo está mirando en Z en profundidad 00:09:38

Luego hay otra cosa 00:09:41

Para que lo vayáis teniendo en cuenta, que es que cuando vamos instanciando 00:09:43

o metiendo en la jerarquía distintos prefabs, de pronto puede haber uno, una de estas instancias, por ejemplo, esta nave, ¿vale? 00:09:47

Veis que aquí se han acumulado unas cuantas, que yo, pues, le quiero poner un material o, mira, o darle otro componente, 00:09:54

meterle un componente como, por ejemplo, un RigidBody, que esto en siguientes temas lo vamos a ver. 00:10:05

pues metemos un componente, recordar, esto lo dije el otro día, que los distintos elementos que van sumándose a cada objeto se llaman componentes, 00:10:11

que son lo que van metiendo las propiedades que tiene ese objeto. 00:10:21

Un RigidBody, si le doy a play vais a ver que es un objeto que así grosso modo lo que hace es meter gravedad al objeto. 00:10:27

¿Qué ha pasado? Esto me sirve no para hablar del RigidBody en este momento, todavía no es el momento, 00:10:35

sino para que veáis que tengo un prefab 00:10:40

de todos los que ya he metido 00:10:42

que es diferente al resto 00:10:44

que tiene un RigidBody 00:10:45

por defecto este de origen no tiene el RigidBody 00:10:47

pero a lo mejor estamos trabajando en uno de estos 00:10:50

de estas instancias 00:10:52

y hemos metido un elemento nuevo 00:10:53

esto os va a 00:10:56

lo vais a ver a nivel visual 00:10:58

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

os añade un más 00:11:03

en plan está añadido 00:11:04

a una instancia 00:11:05

del prefab 00:11:07

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

y seguir trabajando porque esta nave va a ser diferente al resto 00:11:14

o hay una opción aquí, cuando metáis un prefab 00:11:16

va a aparecer esta línea para abrir el prefab como hemos hecho 00:11:20

para seleccionarlo en la jerarquía y otro que son los overrides 00:11:22

los overrides sirve para 00:11:26

diciendo lo que tiene de diferencial, marcado con este más 00:11:28

esa diferencia que hay con el prefab, decir no, no, yo lo que quiero 00:11:31

es que todos los prefabs que deriven de este, pues he pensado que tenga este RigidBody. 00:11:35

Entonces, si le damos a aplicar, vais a ver que se aplica ahora, 00:11:41

va a tardar un segundete, a todas las instancias que tenga este prefab. 00:11:46

Por tanto, es otra forma de modificar también una instancia. 00:11:50

Incluso aquí podemos ir abriendo la nave y decir, 00:11:57

no, es que la nave no quiero que tenga alerones. 00:12:01

Veis que estoy trabajando no dentro del área de prefab, sino dentro de la jerarquía en una instancia. Si yo borro esos alerones, bueno, en los alerones justo me va a decir, oye, esto es un hijo de un prefab, si borras esto, pues te está variando el prefab. Lo tendrías que hacer del prefab o tendrías que hacer una variante, ¿vale? Y aquí es donde se podría borrar y luego guardar. 00:12:03

El otro día dije que lo que son 00:12:22

Hablé de que se podían añadir código 00:12:26

Todas las funcionalidades que vamos a ir añadiendo 00:12:29

Va a ser a través de estos componentes que os he indicado 00:12:31

O añadiendo nosotros código que vayamos programando 00:12:34

Que a fin de cuentas también se añadirá como un componente 00:12:37

Para eso se generan lo que se llaman scripts 00:12:42

Y estos scripts ya vimos, voy rápido porque esto lo expliqué el otro día 00:12:45

Que se generan con clic derecho, crear 00:12:49

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

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

y si no coincide este nombre con el nombre de la clase del código, 00:13:10

la clase es el patrón que se va a usar en el código 00:13:14

para ir organizando los distintos códigos, 00:13:19

pues si no coincide, dará problemas. 00:13:22

Entonces, he generado este script 00:13:26

y si quiero que se vean los resultados de algún modo, 00:13:28

habrá que meterlo como componente en algún elemento. 00:13:31

Ahora vamos a hacer operaciones matemáticas 00:13:33

y al final del todo, un instant sheet 00:13:35

para ver cómo se hace un poco lo de la tarea. 00:13:38

Pero para que se aplique este código a algo, 00:13:41

ahora mismo simplemente está aquí preparado 00:13:44

y si le doy doble clic, 00:13:46

se abrirá vuestro Visual Studio, 00:13:47

que tendréis aquí. 00:13:50

Veis esta bonita pantalla de hacker 00:13:51

que se nos ha quedado 00:13:54

con un poco ese código abierto, 00:13:55

preparado para trabajar. 00:14:00

Aquí vais a ver que este nombre y este coinciden 00:14:01

y tienen que coincidir. 00:14:03

Ya lo expliqué el otro día, 00:14:04

por eso, si no tenéis duda, 00:14:05

No lo voy a repasar más, pero aquí tenemos 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:06

importante, aquí ya de hecho tengo algunas carpetas 00:14:23

habéis visto la de prefabs, donde tenía los prefabs 00:14:28

para generar carpetas, clic derecho crear 00:14:30

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

hay uno de folder, os recomiendo que vayáis organizando 00:14:36

esto lo ponen los apuntes también 00:14:40

por tipología de elemento 00:14:41

yo por ejemplo, tengo aquí algunos que he estado yo trabajando 00:14:44

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

lo meto en la carpeta durante, para tenerlo ahí, para saber cuáles son los de durante y los que tenía de antes, ¿vale? 00:14:50

Lo dicho, tenemos aquí el script abierto esperando para operar. 00:14:57

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

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

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

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. Va a servir para cálculos, por ejemplo. Va a ser un objeto vacío al que yo vinculo. 00:15:16

Y mirad que para vincular un script puedo arrastrar desde aquí al inspector y se incorpora como otro de los componentes, ¿vale? Si lo quiero eliminar, las opciones de eliminar, de copiar, etcétera, están en estos tres puntos, ¿vale? Lo voy a eliminar porque también se puede añadir, igual que se puede hacer, por ejemplo, con los componentes, con los efectos, digamos, por decirlo de una forma así rápida e inteligible, 00:15:30

Vale, todos los que ya vienen configurados también se puede buscar por aquí como, para añadirlo, hay uno de cálculos que es el otro que tenía y cálculos tut, ¿vale? 00:15:57

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, 00:16:08

Fijaos que el propio programa, yo ya cuando lo meto en el archivo, sabe separar estos nombres, ¿vale? 00:16:20

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, ¿vale? 00:16:25

Ahora ya está, digamos, en un objeto dentro de Unity esperando a operar con él. 00:16:33

Pues estamos aquí con CalculusTut y vamos a hacer nuestra primera operación matemática, ¿vale? 00:16:39

Y os voy a decir algo que es que mucho, casi todo lo que vais a hacer consiste en operaciones matemáticas, ¿vale? Y en lógica de que se cumplan condiciones o no. Es decir, todo por detrás son esos números o interpretaciones de números, ¿vale? 00:16:44

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

Para empezar a programar, y esto quien haya programado en cualquier lenguaje, 00:17:14

hay un concepto que es el primario, digamos que es la variable. 00:17:18

La variable, digamos que es un elemento en el que se van guardando espacios en la memoria con una información. 00:17:23

Por ejemplo, quiero que haya un número al que puedo referenciar con otra palabra. 00:17:30

Voy a hacer primero una operación matemática y luego vamos a ver qué son las variables. 00:17:40

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

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

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

se marca otra llave, una de apertura y una de cierre, 00:17:59

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

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

Esto es más avanzado, ya le iréis dando vueltas. Se van estipulando en bloques, ¿vale? Y estos bloques significa que hay una llave de apertura y una llave de cierre que delimita un área, ¿no? Ahora mismo, de aquí a aquí, pues hay un área, y dentro de ese área, de ese bloque, es donde vamos a ir añadiendo las instrucciones que se van a ejecutar, por ejemplo, en este caso, dentro de esta clase. 00:18:10

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

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

Y esta llave, cuando marco esta, veis que tiene su correspondiente llave de cierre 00:18:40

Y aquí es donde se irá ejecutando, por ejemplo, lo de este Start 00:18:44

O este Update, este método Update 00:18:48

Esto ya veremos ahora qué es 00:18:51

También tiene un área de influencia 00:18:52

Donde yo iré escribiendo código 00:18:55

Y se ejecutará lo relacionado con Update 00:18:56

entonces aquí es muy importante que lo que se abre se cierra a nivel de llaves y a nivel de paréntesis 00:18:59

también veis que se suelen abrir y cerrar aunque estén vacíos y parezca un sinsentido 00:19:08

ahí están esperando, dentro de este bloque iremos haciendo operaciones 00:19:13

pero veis que este bloque ya tiene dos bloques aquí también, esperando que hagamos cosas 00:19:17

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 CISAR para trabajar en Unity, pues ya ha generado ciertas funciones como este start y este update para poder ejecutar en ciertos momentos. 00:19:22

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

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

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

Si en el mando damos a la X, pues que salte, si es lo que hemos configurado. 00:20:25

También va a haber momentos, va a haber operaciones que queremos que se ejecuten según se lanza el juego. 00:20:33

Por ejemplo, que se configure el nivel, se cargue, que se ponga que la vida está al 100%, etc. 00:20:40

Y ese es otro momento del juego, que es al iniciar. 00:20:47

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

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, fotograma, va a ir mirando qué hay aquí dentro para fotograma, fotograma, irlo ejecutando. 00:21:06

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

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

Y este update se irá ejecutando fotograma a fotograma 00:21:36

Esto lo vamos a entender en poco 00:21:39

Vamos a escribir nuestro primer hola mundo 00:21:41

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

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

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

Y vamos a ver nuestra primera operación. 00:22:13

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

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

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? Entonces, la primera instrucción es este debug, ¿vale? 00:22:54

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. 00:23:08

Por ejemplo, debug, si le damos al punto, de pronto van a salir muchas opciones, no hemos escrito más. 00:23:21

Pues debug a ser debug log, que es la que nos interesa. 00:23:26

Entonces, quiero que en programación interpretéis los puntos como separadores en jerarquías inferiores. 00:23:30

Me explico, como unas migas de pan que hemos visto antes. ¿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:23:37

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

Entonces, siempre se va a ir de lo general a cada vez lo más concreto. 00:24:12

Debug, que sirve sobre todo para depurar código, para encontrar errores. 00:24:19

Si damos al punto, tiene dentro muchas operaciones relacionadas. 00:24:25

La mayoría de ellas no las vamos a necesitar, pero hay una muy importante que debéis aprender, 00:24:31

que es esta que se llama debug.log. 00:24:37

Damos doble clic y ahí está. 00:24:39

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

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. 00:24:55

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

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

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

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

Y vais a ver que aquí nos sigue marcando un fallo, está aquí subrayado con un fallo 00:25:34

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

Atención que aquí arriba tenéis el nombre del archivo 00:25:45

Y va apareciendo un asterisk que indica que no está guardado 00:25:48

Hasta que yo no haga control S 00:25:51

Yo no estoy guardando el código 00:25:53

Y hasta que yo no guardo el código 00:25:55

Por tanto, siempre hay que estar dando control S 00:25:56

Cuando queramos hacer algo 00:25:58

Aunque yo vaya a Unity y haga lo que tenga que hacer 00:25:59

No se va a ver reflejado 00:26:02

Tenemos que ir guardando 00:26:05

Y ojo, mirad que aquí 00:26:06

Y aquí también tenéis asterisk 00:26:08

Son dos software diferentes 00:26:11

Visual Studio y Unity 00:26:13

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:26:14

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

Veis que ahora se ha ido el asterisco. 00:26:30

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

Entonces atención de si algo no funciona 00:26:39

Que aquí no esté el asterisco 00:26:42

Porque entonces igual todo lo que habéis cambiado 00:26:43

No se está viendo reflejado 00:26:45

Y veis que aquí está este error 00:26:46

Y ya os digo, si aquí hay algo subrayado rojo 00:26:49

Vuestro programa no va a funcionar 00:26:52

Va a dar fallo, va a dar error 00:26:54

Porque no está sabiendo ejecutarlo 00:26:55

Y esto lo veis, si vais a Unity 00:26:57

Y os metéis 00:26:59

Aquí abajo ya sale una exclamación roja 00:27:01

Que algo nos dice 00:27:04

Que no está yendo bien 00:27:06

Y de hecho yo intento ejecutar el juego 00:27:07

aunque ahora no tenga nada, le doy y dice 00:27:08

todos los errores de compilación tienen que 00:27:10

ser arreglados antes de poder proceder 00:27:12

al modo de juego 00:27:14

por tanto veis que a mi no me deja 00:27:15

hacer nada en el área de game porque 00:27:18

está habiendo un error 00:27:20

¿vale? 00:27:22

esta línea roja que hay aquí realmente 00:27:24

es una especie de resumen de lo que 00:27:26

podéis ver en el menú consola 00:27:28

¿vale? que os he dicho antes, si dais a consola 00:27:30

aquí sale aún más grande la exclamación 00:27:33

y es el mismo error ¿vale? 00:27:35

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

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

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, ¿vale? 00:27:49

Lo debería abrir, a mí me lo ha abierto en otro lado porque tengo otra ventana, ¿vale? 00:27:56

Pero os lleva a la línea de ese error, ¿vale? Me está aquí marcando de dónde está el error. 00:28:00

Es una buena forma de, cuando de error, saber de dónde viene. Le dais doble clic y decís, oye, ¿qué pasa? ¿Por qué esto está yendo mal? 00:28:04

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

Si nos metemos en el código, vemos que es en la línea 11, por eso no lo va numerando, y en la columna que no está detallada, pues es la 40. Aquí podéis ir viendo todos los problemas que podéis ir yendo de una forma también descrita. 00:28:22

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:28:39

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. 00:29:00

Vale, vemos que no da error, ¿vale? Y voy a ir a cesar para ejecutar esto, ¿vale? 00:29:11

Y dice, aquí sigue poniendo el error. ¿Por qué creéis que es? ¿Por qué? Si aquí no me sale nada rojo. 00:29:19

Venga, primera pregunta interactiva. 00:29:29

Porque no se ha guardado 00:29:31

No se ha guardado el proyecto 00:29:33

En el Visual Studio 00:29:35

Perfecto, veis que está el asterijillo 00:29:37

Importante, porque esto ahora es muy obvio 00:29:39

Pero luego pasa 00:29:41

Control S, se ha guardado, vuelvo 00:29:42

Y ya cuando 00:29:44

Me permita 00:29:47

A veces tiene que recargar, según el ordenador 00:29:49

Mejor o peor, pues tardará más 00:29:51

Ahora hay otros problemas, pero 00:29:52

Ya no es el rojo 00:29:55

Cuando salen errores amarillos 00:29:58

significa con esta con este warning amarillo significa que hay errores pero 00:29:59

no son fatales es decir no van a detener la ejecución pero bueno convendría 00:30:05

echarle un ojo lo mismo si le damos doble clic nos abriría estos de otros 00:30:10

escribe tengo preparados antes vale nos abriría donde está en el código ese 00:30:13

error vale ahora cuando lo hacemos la aplicación vale cuando le da play vais a 00:30:17

ver que se ejecuta os he dicho cuando la fe y ahora se va a ver en el juego la 00:30:22

frase cual hemos dicho, hola mundo Daniel 00:30:27

vale, y os vais a llevar la primera desilusión 00:30:29

porque no se ve nada 00:30:32

en el juego, no hay nada 00:30:33

que se vea, pero si os fijáis 00:30:35

en la consola, si que aquí pone 00:30:37

hola mundo Daniel, vale 00:30:39

os he dicho que estas 00:30:40

operaciones 00:30:43

se hacen para depurar 00:30:44

errores de código, es decir, no es algo 00:30:47

digamos que se va a ver en el juego, son instrucciones 00:30:49

que la consola va a ir mostrando 00:30:51

para ir viendo si se está ejecutando algo bien o no 00:30:53

es de vital importancia este debug log 00:30:55

Pues ya iréis viendo que es con lo que vamos a ir comprobando que todo funcione. 00:30:57

Entonces, ahora mismo he puesto hola mundo Daniel, aquí podría poner hola Elisa. 00:31:01

Yo si vuelvo a guardar y voy, cuando ejecute el juego, ojo, cuando me meto otra vez, si está el juego en ejecución, necesito volver a lanzarlo. 00:31:08

Y ahora pone lo que le he dicho. 00:31:18

Ya vamos viendo que hay cierta interacción. 00:31:21

Vale, entonces, ya para entender que lo que hemos hecho en el Start significa que cuando empiece a ejecutarse el juego, se ve este Hola Elisa. 00:31:25

Lo último que he hecho ha sido copiar ese debug log de Start a Update. 00:31:35

Si yo ahora mismo ejecuto el juego, me meto aquí y le doy a Play, cuando arranca el juego vais a ver que Hola Elisa sale muchísimas veces. 00:31:42

y aquí se van contando y me dice ya más de mil 00:31:51

y ya no te hace la cuenta 00:31:53

cuando yo paré el juego veréis que aquí hay 00:31:55

un trillón de hola Elisa 00:31:58

¿por qué? porque esta instrucción 00:31:59

que le he dado aquí de escríbeme 00:32:02

en consola hola Elisa 00:32:03

pues se ha ido ejecutando cada fotograma 00:32:05

de juego ¿vale? fotograma 00:32:08

dependiendo del 00:32:10

ordenador, esto lo veréis 00:32:12

en la próxima lección que 00:32:13

abra, al final 00:32:16

cada ordenador va a tener una capacidad 00:32:17

de computación, según si el procesador 00:32:20

es mejor o peor 00:32:22

si es mejor o peor el ordenador 00:32:23

pues va a poder procesar más fotogramas 00:32:25

por segundo que otros 00:32:28

dependiendo del ordenador ya veremos que esto puede 00:32:29

suponer un problema 00:32:32

porque unos ordenadores 00:32:32

van a ser más rápidos a la hora de ir 00:32:35

calculando más fotogramas que otros 00:32:37

pero por defecto ya vemos 00:32:39

que sea el ordenador que sea, esta instrucción 00:32:41

de hola Elisa, cada fotograma 00:32:44

que puede ir refrescando, pues danza la instrucción 00:32:46

indiscriminadamente cada fotograma 00:32:48

Cuando se meta, dice uno la elisa, uno la elisa, uno la elisa, ¿vale? 00:32:49

Ya veis que hay dos momentos que vienen ya por defecto hechos en los códigos, 00:32:52

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

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

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

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, pues sirve para que se vea o no. Está ahí en la jerarquía, pero no está funcionando. Si yo lanzo el juego, ¿vale? Veis que no se ejecuta, a diferencia de antes, ¿vale? Está el start, pero es que como no se ha ejecutado el componente, dado que el objeto que lo contiene no existe, ¿vale? 00:33:19

Cuando yo le dé a, de alguna forma que ya veremos, a que se ejecute este objeto, pues ahí sí, según se ejecuta, ¿vale? 00:33:41

Por eso digo que el start no es el primer fotograma del juego, porque hasta que no se lance, digamos, el script, pues no funciona, ¿vale? 00:33:50

Importante. 00:33:58

Entonces, ya tenemos, voy a dejar que sí que esté activo, ¿vale? 00:33:59

Importante, que a veces no es que no funcione, es que no está vinculado a nada, no está funcionando ese objeto, ¿no? 00:34:03

Vamos otra vez aquí al código, ¿vale? 00:34:09

Os he dicho este de backlog, hola Elisa. 00:34:11

Yo ahora en vez de decirle una frase literal, por eso hay que poner las comillas cuando sean textos o strings, esto lo vamos viendo, 00:34:14

hay que ponerlo entre comillas, yo voy a decirle, no, yo quiero que lo que muestre en consola, 00:34:21

porque soy así de temerario, yo qué sé, es el resultado de 5 más 4, ¿vale? 00:34:25

Una operación aritmética muy básica, ¿no? 00:34:32

Yo cuando lance este juego 00:34:35

Guardo, vale, y lance este juego 00:34:38

Al arrancar 00:34:39

Lo que me va a mostrar en la consola 00:34:41

Dado que es lo que está dentro de estos paréntesis 00:34:43

Va a ser un 9 00:34:46

Lo veis aquí 00:34:50

Que es el resultado de la suma 00:34:52

Esto cuando vayamos teniendo 00:34:53

Que una bala así te impacta, te quita 100 de vida 00:34:56

Y lo resta 00:34:59

De las 500, pues ya tendremos que ir 00:35:01

Haciendo operaciones, entonces 00:35:02

Esta operación tan básica es 00:35:04

el origen de todo lo que vamos a ir haciendo 00:35:06

con los juegos 00:35:08

aunque aquí haya puesto los números 00:35:09

rápidamente, como números 00:35:12

sueltos, hay que entender 00:35:14

un poco cómo gestiona la información 00:35:16

el propio Unity 00:35:18

me refiero con cómo gestiona la operación 00:35:20

con que, aunque aquí pongamos 00:35:22

un 5 y un 4 00:35:24

hay distintos tipos de variables 00:35:25

ya me meto a ello que he introducido 00:35:28

según qué vamos a meter en esa variable 00:35:29

voy a hacer 00:35:32

primero una cosa para que lo veáis 00:35:34

sin entenderlo y luego lo explico. 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, 00:35:36

un número entero, que se va a llamar 5, ¿vale? Contesto. Y a esto le digo que es igual a 5. Ahora os digo qué es. Y luego voy a hacer otra variable llamada 4, 00:35:47

que va a valer 4, ¿vale? 00:35:58

Y aquí lo que voy a hacer es, en vez de decir 5 con número, 00:36:01

voy a apelar a este 5 que he puesto aquí 00:36:07

y a este 4 que tengo aquí. 00:36:10

Y vais a ver que yo, cuando lo lance, 00:36:12

lo he escrito con texto, ¿vale? 00:36:15

Cuando lo lance, va a dar otra vez ese 9 que teníamos. 00:36:16

Ahí está el 9, ¿vale? 00:36:22

Pero esto no es porque el programa sepa 00:36:23

que si escribe cinco contextos es un cinco como un número. 00:36:26

Esto es porque anteriormente hemos declarado, 00:36:32

y de hecho si yo borrara estas líneas, 00:36:35

daría error, 00:36:37

porque hemos creado lo que se llaman variables. 00:36:39

Las variables son referencias de ciertos tipos, 00:36:41

como cajas que vamos a ir usando para ir construyendo un Lego, 00:36:46

que pueden ser de distintas formas. 00:36:51

Entonces vamos a ir construyendo estas cajas 00:36:53

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 00:36:56

operar con números decimales, que son estos de tipo float. Por ejemplo, esto se va a llamar 5 con 5. Vais viendo que cuando escribo el nombre de esta variable, 00:37:08

¿Vale? 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,5, pues no lo sabe entender, porque esta caja solo permite guardar números enteros, ¿vale? 00:37:20

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, ¿vale? Aunque sea decir mal. Aquí, aunque pusiera lo mismo, 5,5F, pues nanay, ¿no? 00:37:35

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

La estructura de declarar una variable, es decir, de crear una caja o una pieza de Lego con la que vamos a seguir trabajando en el código, es siempre la misma. 00:37:58

primero hay que poner de qué tipo es esa caja 00:38:09

en este caso pues vamos a hacer 00:38:11

como sé que voy a trabajar con un número entero 00:38:13

pues pongo este int 00:38:16

de integer, de entero 00:38:17

y luego esa caja 00:38:18

por hacer como una caja de mudanza el simil 00:38:21

la voy a etiquetar para 00:38:23

yo saber qué hay dentro y yo sé que aquí 00:38:25

pues va a ser un 5 00:38:27

¿vale? este es el nombre que 00:38:29

nosotros queramos, es el nombre que damos 00:38:31

a esa pieza de lego con la que vamos a ir trabajando 00:38:33

entonces yo en vez de 5 puede ser 00:38:35

el número 00:38:37

primero que vamos a usar, ¿vale? Y ese número primero, esa caja dentro va a tener lo que le asignemos después de este igual, que es un 5, ¿vale? 00:38:38

Aquí, por ejemplo, creo otra caja, otra pieza, que se va a llamar número que suma. El nombre que queramos aquí es lo que queramos, también de tipo entero, 00:38:49

y meto ahora un 3 00:39:00

¿vale? y cuando vaya generando 00:39:01

estos números, veis que me da fallo 00:39:04

porque las cajas que antes se llamaban 5 00:39:06

y 4 ya no existen, ¿no? ahora habrá que 00:39:08

trabajar con las cajas, digamos que 00:39:10

yo he creado estas piezas y quiero 00:39:12

que la suma la voy a hacerlo a partir de esas variables 00:39:14

ahora tendré que poner, vale, pues 00:39:16

el número primero de la operación 00:39:18

y veis que cuando yo voy escribiendo 00:39:20

el IntelliSense me va mostrando 00:39:22

lo que coincida, si yo he creado esta variable 00:39:24

y fijaos que incluso el iconito tiene forma de caja 00:39:26

¿vale? que es bastante 00:39:28

representativo vale yo sí escribo ese número primero ahora mismo lo que yo 00:39:30

ponga aquí con este nombre este identificador vale lo que le ha 00:39:35

asignado vale ahora mismo aquí esto es sinónimo de 5 en este momento esta caja 00:39:39

luego podremos ir cambiando la de contenido a lo largo del código no por 00:39:44

ejemplo habrá algún momento que para adelantar que sea vida personaje vale y 00:39:50

empiece valiendo 100 00:39:56

lo que pasa es que nosotros a lo largo del juego 00:39:57

a esta caja vida personaje le iremos 00:39:59

quitando o añadiendo 00:40:02

vida según reciba balas 00:40:03

o vaya cogiendo 00:40:06

power ups de corazón, de vida 00:40:06

¿vale? entonces esta 00:40:10

sigue dando fallo porque 00:40:12

ahora mismo esta caja no existe, no hay ninguna caja 00:40:13

llamada así, pues por ejemplo 00:40:16

número que suma, ¿vale? pues 00:40:17

número primero si lo volviera a meter sería otro 5 00:40:19

no, yo quiero número que suma, a ver 00:40:21

le clico y ahí está 00:40:23

Ahora mismo, si leemos esto, estamos diciendo 00:40:25

Por favor, muéstrame en consola 00:40:27

Número primero 00:40:30

Más número que suma 00:40:31

¿Cuánto crees que va a dar de resultado? 00:40:33

Venga, mientras voy 00:40:37

8, ¿no? A ver, le doy al play 00:40:39

Le doy al play 00:40:44

Y 8, perfecto 00:40:46

Y si ahora en vez de número que suma 00:40:47

Aquí pongo 00:40:49

Vida persona 00:40:51

Que es otra caja que tengo 00:40:53

¿Cuánto valdría? 00:40:55

105, ¿sí, no? ¿Estamos todos de acuerdo? 00:41:01

A ver si lo que dice... 105, perfecto. 00:41:04

Entonces vemos que al final, y esto si no le veis la utilidad se la iréis viendo rápidamente, 00:41:09

iremos generando variables o palabras, digamos que van englobando datos dentro. 00:41:15

Que ya os digo, que se irán actualizando a lo largo del juego cuando vayan ocurriendo ciertos eventos. 00:41:22

¿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:41:26

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

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

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

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

que cambiar algo, voy a poner 105, yo que sé, ¿vale? Cuando ahora vuelva a refrescar 00:42:11

vais a ver que por defecto en la consola, a ver, a veces tarda un poco, bueno, venga, 00:42:19

¿vale? Entre los errores es en cálculo 5 la variable 5.5 está asignada pero su valor 00:42:26

nunca se usa, ¿vale? Pues eso significa que 5.5 está aquí pero nunca se usa. Veis que 00:42:33

es un error que va a funcionar el juego pero dice oye borra esta línea si no la 00:42:39

vas a usar para que vas a llenar tu habitación de cajas si no lo vas a usar 00:42:44

aparte de números enteros y decimales vale y los decimales se escriben con un 00:42:47

punto en vez de con una coma vale y hay que poner una f de flow at vale porque 00:42:52

si no no sabes si se está refiriendo a un número decimal o otras cosas vale si 00:42:56

no ponéis la f aunque permita tener 55 yo le doy a la f y no y no funciona y 00:43:01

Y ojo, si yo pongo número primero y 5,5, ¿vale? Ahora estoy juntando cajas de distinto tipo. 00:43:07

¿Qué debería la lógica decir que nos da como resultado? Vamos a verlo. 10,5 dicen por ahí. 00:43:16

Por cierto, cuando tenemos todos los errores estos que nos pueden salir, si damos a Clear, lo limpiamos, ¿vale? 00:43:31

Ya sabemos lo que queremos para al volver a ejecutar, pues que se generen los que tienen que ser. 00:43:37

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

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

la lógica de declarar una variable es siempre 00:44:08

el tipo de variable, en este caso vamos a decir 00:44:11

el dato que voy a guardar aquí es 00:44:13

una cadena de texto, es un texto 00:44:14

¿no? y lo voy a llamar pues cadena 00:44:17

de texto o yo que sé 00:44:19

mi nombre ¿vale? 00:44:20

y entonces al darle igual ¿vale? 00:44:22

y quiero que vayáis interpretando estos iguales 00:44:25

no como un igual en matemáticas de 2 más 2 00:44:27

igual a 4, esto 00:44:29

significa que se está asignando 00:44:30

un valor ¿vale? 00:44:32

o lo que se llama el término más correcto sería 00:44:34

inicializar en este caso el valor 00:44:36

que es que una caja que está vacía 00:44:38

está aquí, de pronto la vamos a poner un algo 00:44:40

no estás comparando nada, ni es 00:44:42

equivalente una cosa a otra 00:44:44

sí lo es, pero es 00:44:46

que esto que está aquí a la izquierda 00:44:48

pasa a tener este valor, ¿no? 00:44:50

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

y mirad que yo todas las operaciones las acabo 00:44:54

cuando acaba la instrucción con un punto y coma, como os he 00:44:56

dicho antes, ¿vale? importante, porque si no 00:44:58

se empiezan a juntar conceptos 00:45:00

y empieza a dar problema, ¿no? 00:45:02

entonces, veis que yo aquí pongo un 5 y dice 00:45:04

error, porque esta caja no está pensada para 00:45:06

números, ¿vale? Para meter texto 00:45:08

cuando algo queremos que sea un texto literal 00:45:10

como hemos hecho antes con el hola mundo, hay que 00:45:12

abrir comillas, ¿vale? Las comillas 00:45:14

típicas de 00:45:16

entrecomillar, ¿no? Y aquí 00:45:18

se puede poner, vale, pues en mi caso, Daniel 00:45:20

¿vale? Y ahí se ha guardado 00:45:22

un texto 00:45:24

Si yo pongo ahora 00:45:25

mismo 00:45:28

a ver, por ejemplo 00:45:28

voy a hacer una frase 00:45:34

digamos compuesta de varias variables 00:45:37

para que veáis que se puede ir modulando todo 00:45:40

modularizando mejor dicho 00:45:42

voy a generar un string 00:45:43

que guarda mi nombre 00:45:46

otra caja que guarda 00:45:47

la frase que construye 00:45:50

o el predicado 00:45:52

que va a ser 00:45:54

tiene 00:45:55

vale 00:45:57

tiene 00:46:01

tiene de edad 00:46:02

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

Entonces yo puedo ir combinando estas cajas para que vaya componiendo texto. 00:46:15

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

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

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

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

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

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

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. Ahora lo que va a mostrar es lo que hay, 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:47:02

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

Ved que lo que hay entre comillas es literalmente lo que vamos escribiendo dentro, ¿vale? Entonces ahora sí que vais a ver que, le damos aquí y pone Daniel tiene edad, ¿vale? Y ahora puedo decir, ¿vale? Y aparte de Daniel tiene edad, ¿vale? Que son bloques que yo puedo en cualquier momento ir cambiando, ¿vale? 00:47:45

Ahora lo que va a guardar esta variable es tiene de años, perdón que la frase sea un poco extraña, pero es para construirlo más fácil, tiene de años y aquí voy a poner edad, que es esta variable, que veis que ahora es una variable de tipo número, y además es de tipo número float, lo cual no es muy correcto si no voy a meter decimales, y normalmente la edad no se mete con decimales, tienes 34 años o 35, no tienes 34 y medio, o no se suele guardar así. 00:48:04

Por tanto, al hacer esta caja, si la edad siempre va a ser número entero, pues lo ponemos aquí de tipo entero, ¿vale? Sin ningún problema, pero hay ciertas limitaciones si no vamos usando los tipos de variables que hay que usar. 00:48:28

Ahora mismo lo que va a hacer es poner Daniel, ¿vale? Espacio, por este espacio que he puesto aquí, no porque haya aquí en medio, ¿vale? Esto es lo mismo que escribirlo así. Los espacios en programación son solo visuales, ¿vale? Al final lo que importa son los valores que vamos dando dentro. 00:48:39

Entonces, esto va a decir, Daniel tiene de años 34. Aquí, aunque no sea de tipo texto, como entiende que un número, si se está concatenando, porque está aquí unido a textos, lo que vas a querer ver es el texto también, ¿no? 00:48:57

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. 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. 00:49:13

va bien construido no guardamos y a ver que a ver si es verdad que está poniendo lo que yo digo que 00:49:37

va a poner daniel tiene de edad de años bueno que cambia lo de edad no habéis visto que cambia el 00:49:46

interior de la variable antes a mano 34 años vale de esta forma podemos ir uniendo distintos 00:49:52

elementos de distintos tipos entonces importante al declarar una variable el tipo de variable el 00:49:58

nombre de la variable que nosotros queramos darle y luego asignamos el valor que tiene 00:50:05

esa caja. Lo que pasa es que muchas veces, cuando vamos creando estas variables, y voy 00:50:10

quitando aquí, lo dejo solo en esto, en su mínima expresión. Has creado la caja, pero 00:50:17

no la has llenado de nada. Cuando no llenas la caja de nada, interpreta en los números 00:50:24

Que es un cero, ¿vale? Que está vacía, pero a nivel práctico es un cero, ¿vale? Y en los textos, pues no tiene texto también. Lo interpreta como un cero. Y en los de tipo float también es un cero, ¿vale? Podemos ir creando las cajas, ¿vale? Y posteriormente, en algún momento de la ejecución, que a lo mejor no es al principio, cambiar su valor. 00:50:29

Por ejemplo, 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, 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. 00:50:50

¿Vale? Más rápido. Si yo cogiera este debug log y lo pusiera aquí, va a dar fallo. Pues dice, sí, muy bien, depura, pero ¿cuándo? ¿Cuándo depuro? Esta instrucción no es crear una caja para luego usarla, es algo concreto, que es lo que os he dicho que son los métodos cuando se usa estos paréntesis. Una acción, algo concreto, se hace cuando apelamos a algo que tiene estos paréntesis. Aquí dice, vale, yo hago lo que tú me digas, pero ¿en qué momento? No me estás definiendo ningún momento. Por eso tiene que ir dentro de algún bloque de momento de ejecución. ¿Vale? 00:51:16

Y también lo que podemos hacer es decirle, al iniciar el juego, el script, quiero que número primero, ¿vale? Esta variable que he generado aquí valga 7, ¿vale? 00:51:45

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. 00:52:02

esto que estoy haciendo, aquí he declarado 00:52:13

he creado la caja, he declarado la variable 00:52:15

al principio está vacía, vale 0 00:52:18

pero al empezar el juego yo le he dicho 00:52:21

yo quiero que esta caja valga 7 00:52:23

y imprime aquí 00:52:25

lo que hay dentro del número primero, la consola 00:52:27

por tanto, lo que vamos a tener ahora es 00:52:31

pues si lo adivináis 00:52:34

un 7 00:52:37

¿qué pasa? que esto a lo largo del juego 00:52:39

vamos a irlo cambiando, ¿no? Fijaos que 00:52:44

cuando yo ya he declarado la variable y he dicho 00:52:46

de qué tipo es esa caja, ¿vale? 00:52:48

Ya cada vez que hablemos de esa caja 00:52:51

ya no hace falta poner de qué tipo es. 00:52:52

Ya lo hemos generado aquí al principio, ¿vale? 00:52:54

Veis que por eso ya nunca más 00:52:57

vuelve a poner el tipo de variable. Solo se 00:52:58

habla de la variable y se puede asignar 00:53:00

a continuación o usarla, 00:53:02

pero no hay que volver a declararla. Eso se hace 00:53:04

una vez. Declarar, de hecho, 00:53:06

es crear esa caja 00:53:09

la primera vez. Luego ya es emplear 00:53:10

la variable. Entonces, ahora mismo enseña 7, pero algo importante es que, por defecto, 00:53:12

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

lineal, es decir, de arriba a abajo, igual que leemos nosotros, de arriba a abajo y de 00:53:25

izquierda a derecha. Entonces, cuando vamos bajando, hemos declarado esta variable de 00:53:29

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

lo que haya en número primero. Y luego aparte 00:53:39

pues decimos, vale, número primero vale 00:53:42

7. Antes 00:53:44

ponía que era 7. Ahora, ¿qué va a poner? 00:53:46

¿Qué va a enseñar en consola? 00:53:48

¿Qué número? ¿Ha cambiado 00:53:50

algo o no? 00:53:52

¿Crees que ha pasado algo? 00:53:53

Nada. No va a poner nada porque está 00:53:55

debajo, ¿no? Eso es. 00:53:57

Hasta este momento, ¿vale? La variable 00:53:59

vale 0. Nadie ha cambiado 00:54:02

que valga 0, que es el valor por defecto. 00:54:04

Y luego ya más adelante, pues pondrá 7. 00:54:06

Entonces, si vamos aquí ahora mismo y ejecuto, pues pone el 0 como una casa. 00:54:07

¿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. 00:54:13

Esto sirve para ver el orden de ejecución y que aquí podemos empezar a decir, inicializar y decir, número primero vale 2. 00:54:19

Pero después de valer 2, número primero vale 4. 00:54:30

se ejecuta esto 00:54:35

y cuidado que si no acabamos la instrucción con punto y coma 00:54:37

luego número primero vale 7 00:54:40

y luego voy a hacer un debug log 00:54:42

de 00:54:43

de 00:54:44

vida persona 00:54:49

vale, ahora mismo 00:54:51

¿qué va a mostrar? 00:54:53

¿qué pensáis que va a salir en la consola? 00:54:58

¿el 4? 00:55:03

sí 00:55:05

pero he puesto 00:55:05

otro de backlog, otro enséame en la consola 00:55:08

pues lo suma 00:55:10

no, es decir 00:55:12

eso es lo que ha puesto Roberto 00:55:14

primero hace esta instrucción y me enseña 00:55:16

va bajando, va bajando, aquí es lo último 00:55:18

que le hemos dicho que vale este 00:55:20

este número primero, vale, pues aquí enseñará un 4 00:55:21

seguimos bajando, vale, si a partir 00:55:24

de aquí volvemos a usar el número primero, valdrá 7 00:55:26

pero bueno, aquí va a enseñar 4, aquí hemos 00:55:28

dicho enseña 4, sigue bajando, bla bla 00:55:30

y dice, y aquí voy a enseñar vida 00:55:32

persona, que además ahora mismo 00:55:34

vale 0, entonces 00:55:36

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. 00:55:38

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. 00:55:56

paréntesis entre paréntesis puede haber cosas o no vale pues aquí al empezar el 00:56:11

juego vale le hemos dicho enséñame lo que valga número primero que vale 4 y 00:56:15

aquí lo que valga vida persona que está aquí vacía si yo vida persona 00:56:19

vale vida persona aquí vale 85 00:56:25

vale que va a poner ahora en consola nada porque está por debajo pero es 00:56:31

Es decir, la consola va a mostrar primero 4, ¿no? 00:56:40

Y luego 0. 00:56:43

Vale. 00:56:47

Si yo pusiera... 00:56:47

Esto es para ver que pilláis la lógica, vamos, 00:56:48

que sé que son preguntas simples. 00:56:50

¿Ahora qué pondría? 00:56:52

85. 00:56:54

En la segunda línea, primero 4 y luego 85. 00:56:56

4 y luego 85. 00:56:58

Vale. 00:56:59

Lo vais entendiendo, ¿no? 00:56:59

Básicamente. 00:57:00

Que puede haber varias operaciones 00:57:01

y aquí se están ejecutando dos. 00:57:03

¿Vale? 00:57:05

Entonces el orden de ejecución 00:57:05

está en relación a las líneas que se van leyendo, ¿vale? 00:57:07

Hasta aquí bien. 00:57:13

Recordad que luego se nos puede ir un poco la pinza con, vale, 00:57:14

vida persona vale 85, pero aquí quiero que me lo enseñe más, 00:57:19

número primero, ¿vale? 00:57:23

Y aquí ahora mismo, ya última que hago de esto, perdonad, 00:57:27

¿qué pondría aquí en la segunda línea? 00:57:30

La segunda instrucción que le he dado al arrancar. 00:57:32

89. 00:57:34

4,89, ¿no? 00:57:37

No. 00:57:38

No, 92. 00:57:41

Efectivamente. 00:57:44

Porque aunque aquí ponga número primero, en este punto que estamos ya ha superado esto 00:57:45

y ha cambiado de valor lo que hay dentro de la caja, ¿no? 00:57:49

Esto es lo que va a ir permitiendo luego tener en cuenta que hay operaciones 00:57:52

que se van a ir haciendo fotograma a fotograma, que vayamos actualizando, subiendo, bajando cifras, 00:57:56

que al final son la vida, el tiempo de carga, el nombre del jugador que hemos metido en un campo. 00:58:01

se va a ir actualizando a medida que vayamos 00:58:07

haciendo ciertas operaciones 00:58:10

esto es un poco 00:58:12

la base de todo 00:58:13

vale 00:58:16

una duda Daniel, para el ejercicio 00:58:17

de la unidad 0 entonces sería 00:58:20

mejor declarar las vidas 00:58:22

sin asignarle un valor y luego 00:58:24

tú irle asignando los valores dependiendo 00:58:26

de si le afecta la bala o no 00:58:28

es mucho más cómodo eso 00:58:30

poniendo que restas o que sumas 00:58:32

claro, tú declaras esa bala 00:58:34

y luego tendrás que ir sumando o restando daño. 00:58:36

Y daño puede ser un número ya establecido o uno aleatorio, 00:58:39

que también se pueden hacer números aleatorios. 00:58:43

Variables. 00:58:47

El concepto de variables ya vais viendo que es referenciar valores 00:58:47

para moverlos por el código en distintos momentos. 00:58:50

En esencia es eso. 00:58:54

Esto se va complicando, por supuesto. 00:58:56

Vamos a la tarea 1, ¿vale? 00:58:58

Después de hacer ese prefab de la nave, 00:59:00

que en principio no había mayor problema ya, 00:59:02

Quien lo haya intentado le da alguna pista de algo que puede fallar, pero en principio es tener esa nave. 00:59:05

Lo segundo que pide es instanciar la nave. Instanciar más allá, que evidentemente sí vamos a usar variables, por eso lo has explicado. 00:59:11

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. 00:59:18

Para eso se usa, al arrancar el juego, se puede poner aquí la operación Instantiate, de todas las que hay. 00:59:26

vais a ver que IntelliSense también nos va dando distintos iconitos, ya iré explicando mejor qué es cada cosa, ¿vale? 00:59:33

Pero en este caso, por ejemplo, es de un método o una función. Método y función, si lo iréis escuchando mucho, son sinónimos. 00:59:41

A veces diré métodos y a veces diré función, ¿vale? Y cuando me pongo encima vais a ver que IntelliSense, 00:59:49

cuando me voy poniendo con la selección de la palabra, nos da más ayudas aquí, nos da muchas ayudas siempre, ¿vale? 00:59:57

Aquí ahora mismo nos dice 01:00:03

Instance, ahí va, bueno, espera 01:00:05

Instance, cuando a veces 01:00:07

No salga, empezad a escribirlo otra vez 01:00:09

Porque si no se pierde, os ponéis encima 01:00:11

Y pone Instance8 01:00:13

¿Vale? Pone como cosas que está heredando 01:00:15

De estas librerías que os he dicho que había aquí arriba 01:00:17

¿Vale? Y vamos hasta la palabra Instance8 01:00:19

Y dentro de paréntesis 01:00:21

Pasan cosas, ¿vale? 01:00:22

Y pone más cuatro sobrecargas, ahora vemos que es eso 01:00:25

Os he dicho, cuando hay 01:00:27

Algo que lleva una palabra 01:00:29

y luego unos paréntesis 01:00:31

como aquí el start, es una acción 01:00:33

en este caso start es al arrancar 01:00:35

lo que tengas dentro del bloque 01:00:37

ahora vamos a hacer una, que esto son cosas 01:00:39

que tenemos que ir aprendiendo 01:00:41

al arrancar, dentro 01:00:42

voy a instanciar un objeto 01:00:45

¿vale? de momento me da 01:00:47

fallo porque es verdad que esta operación a diferencia 01:00:49

de la de start, hasta que por ejemplo 01:00:51

no le dices que objeto, no sabe que hacer 01:00:53

y cuando no sabe que hacer, estos 01:00:55

programas se vuelven muy locos y te dan 01:00:57

error y dice mira yo hasta que no me digas que tengo que hacer pues no me voy a ejecutar entonces 01:00:59

cuando abrimos llave una vez ya hemos puesto por completo la instrucción en el debate lo vuelvo 01:01:03

un segundo al debate vale hemos dicho es la clase de bach que dentro tiene la operación log al dar 01:01:11

a los yo sé que es una operación que debe tener una paréntesis para en este caso en esta operación 01:01:16

definir qué tiene que mostrar el mensaje no y vais a ver que a veces salen aquí 01:01:24

en el desplegable dos flechitas vale una misma operación una misma palabra que 01:01:28

esconde detrás operaciones puede variar en el contenido de estos paréntesis vale 01:01:35

de backlog puede como hemos hecho hasta ahora solo mostrar un mensaje lo que 01:01:41

pongamos ahí como mensaje y fijaos que como nos va enseñando 01:01:45

Lo que tiene que ir dentro tiene la misma lógica que cuando hemos declarado la variable. 01:01:50

Primero te dirá qué tipo de variable o de objeto tiene que tener dentro 01:01:55

y luego cómo ha llamado el software, el código, a ese mensaje. 01:02:00

Es decir, ahora mismo en el debug log que hemos hecho hasta ahora, 01:02:08

está diciendo que dentro tiene que haber un elemento de tipo objeto, 01:02:11

que dentro de Unity querría decir cualquier tipo de variable, 01:02:15

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

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

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

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

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

Si vamos a la primera 01:03:03

Dice, pues tú aquí me puedes meter un objeto 01:03:05

Que se llama original 01:03:08

Y abajo incluso pone una descripción 01:03:09

Pone, clona el objeto original 01:03:12

Y devuelve un clon 01:03:14

Es decir, que coge un objeto 01:03:16

Y lo clona en la escena 01:03:18

Bueno, pone 01:03:20

El original es un objeto 01:03:22

Que ya tengas, del que quieras hacer una copia 01:03:24

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

Entonces, simplemente 01:03:28

Para que sepáis, vais a ir viendo 01:03:30

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

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

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

es el prefab que va a instanciar. 01:03:48

Es decir, ahora mismo este código se va a ejecutar donde esté este objeto empty, 01:03:51

que hemos creado antes 01:03:57

y ahí vamos a generar un clon 01:03:58

del prefab 01:04:00

que tenemos aquí preparado 01:04:03

de esta navecica que tenemos aquí preparada 01:04:04

y claro, aquí es donde empieza 01:04:06

ya la cabeza a dar vueltas y decirle 01:04:09

vale, hasta ahora hemos hecho variables que he creado 01:04:11

aquí, le he dicho que es un 5, una palabra 01:04:13

pero como meto yo aquí dentro 01:04:14

pues que es 01:04:16

un prefab 01:04:19

como meto aquí la nave 01:04:19

cuando vayamos 01:04:22

avanzando en el 01:04:25

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

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

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

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

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

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

Yo os he dicho, siempre va de lo general a lo concreto. 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. 01:06:08

Y cuando metamos algo en esta caja, vamos a referirnos a esta caja con mi prefab. Aquí hemos generado una caja, que ahora veremos cómo va a guardar el objeto para poder usarlo bajo el nombre mi prefab. 01:06:21

Y luego, como vamos a querer que esta instancia se ubique donde nosotros le digamos, pues hemos generado otra variable de tipo transform. Y con transform es que podemos guardar los valores de posición, rotación y escala de un objeto. 01:06:34

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. Si nosotros conseguimos que en una variable se guarde el transform, guardará todo lo que hay adentro. 01:06:53

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

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

Por ejemplo, esto también ya veremos qué es 01:07:31

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

Y veis que he generado un nuevo tipo de transport, transform 01:07:38

Que podré guardar la información de transform 01:07:41

Pero también va a existir, por ejemplo, el de rigidbody 01:07:43

Que es el que antes os he enseñado que da gravedad 01:07:46

Que hace actuar al motor de físicas 01:07:47

Y si yo empiezo a escribir aquí 01:07:51

No es casualidad que haya un objeto, un tipo de variable 01:07:52

Que se puede llamar rigidbody 01:07:55

Y esto lo llamo mi gravedad 01:07:56

El nombre que queramos 01:08:00

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

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

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

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

¿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:09:13

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

Entonces, a ver, que vaya al padre, ahora aquí. 01:09:32

Y Transform también tendrá sus historias ya preconfiguradas, etc. 01:09:37

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

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

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

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

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

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

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

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

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

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

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

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

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

Si al final empezamos a poner variables como vida, 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:12:21

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. 01:12:34

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

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

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

Y en Unity no es solo que lo puedan ver otros scripts. 01:13:44

En Unity es que también sea público desde el inspector de Unity, ¿vale? 01:13:46

Voy a hacer una cosa, voy a borrar, voy a comentar, ¿vale? 01:13:52

En vez de borrar, para tenerlo preparado, comento de un segundo, si luego quiero usar, digo, para que no dé error, ¿vale? 01:13:54

Si en cualquier momento quiero recuperar cualquier cosa, quito el código y lo tengo ahí, ¿vale? 01:13:59

Es una práctica muy común, comentar para dejar de usar algo. 01:14:03

Entonces, ahora mismo, si me meto en el script CalculusTut, solo hay un campo aquí, que es script, que viene por defecto, 01:14:07

cuando metemos un script para definir qué script es el que estamos asociando. 01:14:17

Ya está, no permite hacer nada. 01:14:21

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, 01:14:23

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, 01:14:31

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 su mayúscula, bien escrito, 01:14:47

que está hecho todo a propósito 01:14:56

y aquí deja un espacio 01:14:58

que podemos rellenar con algo que sea un 01:15:00

GameObject 01:15:02

entonces, haciendo públicas las variables 01:15:03

es como, por ejemplo 01:15:06

en este componente, en este código, alguien 01:15:07

hace que aquí se puedan meter tres variables 01:15:10

llamadas posición, que luego además 01:15:12

se referirá a ellas para hacer ciertas operaciones 01:15:14

¿vale? si por ejemplo 01:15:16

el transform 01:15:18

digo que sea público, también 01:15:20

¿vale? pues cuando lo hago 01:15:22

público y guardo, vais a ver que 01:15:24

Esperad un segundo que está cargando. Pues está la posición de referencia y está esperando algo que sea de tipo transform. Entonces, con esto, lo que vamos a poder hacer es, desde el propio inspector, arrastrar elementos. 01:15:26

veis que la main cámara la meto en las dos 01:15:40

¿vale? 01:15:44

fijaos, importante antes de seguir 01:15:45

que aunque estoy arrastrando la misma cámara 01:15:47

en cada uno sale un iconito 01:15:49

¿vale? porque en cada uno está guardando 01:15:51

un tipo de información, en uno está guardando 01:15:53

la caja del GameObject, porque es de tipo 01:15:55

GameObject, y en otra 01:15:57

¿vale? recordad que el componente de transform 01:15:59

tiene este icono, está guardando 01:16:01

la información de transform de este objeto 01:16:03

aunque estemos arrastrando el mismo objeto 01:16:05

en cada una de las variables 01:16:07

dentro de esta caja, de esta pieza de Lego 01:16:09

está guardando una información distinta, que nosotros ya iremos usando a conveniencia. 01:16:10

Entonces, esta es la forma más rápida, las hay más, y de hecho en ciertos momentos esto es muy básico, 01:16:15

digo que se tendrá que buscar de otra forma, es la forma en la que tenemos para llenar estas cajas 01:16:21

de la información que nos importe. 01:16:27

Entonces, ahora mismo, si tenemos aquí un instant shade, y vuelvo a escribir el paréntesis para que veamos, 01:16:31

aquí hay el primer método 01:16:39

dice object 01:16:41

que es sinónimo de GameObject 01:16:42

aquí podemos meter el objeto que queremos que se instancie 01:16:44

y ahora lo bueno es que si ponemos aquí 01:16:47

mi prefab 01:16:49

esa variable que hemos llenado 01:16:49

con algo en este momento 01:16:52

a través del inspector 01:16:55

ahora se va a instanciar algo cuando arranque 01:16:56

es verdad que ahora mismo lo he hecho así 01:16:58

de la explicación pero mi prefab lo que instancia 01:17:01

es una cámara que no es lo que me interesa 01:17:02

yo lo que voy a querer instanciar es la nave prefab 01:17:04

voy a cálculos 01:17:07

y el prefab lo puedo arrastrar a main cámara. 01:17:08

Y veis que se ha guardado aquí el objeto de nave prefab. 01:17:12

¿Esto qué significa? 01:17:16

Voy a guardar también aquí, voy al código 01:17:17

y aquí le estoy diciendo, en esta nave mi prefab, 01:17:19

a través de, al hacerlo público, a través del inspector, 01:17:24

he guardado ese prefab y cuando yo instancio, 01:17:27

ahora sí que sabe qué objeto es el que tiene que instanciar 01:17:30

porque se lo he atribuido ahí. 01:17:32

Cuando guarde, vais a ver que... 01:17:34

¿Vale? Cuando guarde, al darle a play, no está en ningún lado, pero me genera una copia, bueno, perdonad que como aquí le he metido a la nave antes un RigidBody y tal para explicaroslo, voy a quitar dentro del prefab todo lo que le he añadido de componentes que ahora mismo no me interesa que tengan, como el Boss Collider y el RigidBody, ¿vale? 01:17:39

Es autoguardado, salgo y vuelvo. A ver, detengo y cuando arranca el juego porque está en el start, me genera esta nave aquí, ¿vale? Así es como ha sabido el programa pues que es esta nave la que tiene que hacerse, una copia. 01:17:58

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

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, el primero te lo pone, te lo origina en el punto de origen de donde se está generando el script. 01:18:23

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. Por cierto, cuando generéis un nuevo elemento, como un empty, cuidado que según donde tengáis la navegación no lo genera en el punto de origen. 01:18:38

Veis que yo he generado uno nuevo y me lo he puesto en el 20, menos 1, menos 6, ¿vale? 01:19:03

Si queréis empezar a hacer todo desde el 0, es muy buena práctica siempre crear el objeto, 01:19:07

a menos que lo hagáis a posta, claro, y lo reseteáis para que esté en el punto de origen, ¿no? 01:19:11

¿Vale? Ahora mismo cálculos, que es el objeto que tiene aquí, veis que tampoco está en el origen. 01:19:17

Y yo cuando arranco el juego, me lo está generando en una posición que tampoco es la que me interesa, 01:19:22

que sería la del origen, ¿vale? ¿Por qué? Porque si recordáis, cuando yo he hecho el cubo, 01:19:28

estaba movido del 0, 0 01:19:33

y cuando he instanciado 01:19:35

sin decirle un punto de referencia 01:19:37

que es lo que he hecho ahora en el código 01:19:39

porque no le he dicho nada referente a posición 01:19:40

lo intentará hacer en el 0, 0 01:19:42

pero lo está moviendo en relación a 01:19:45

lo desplazado que esté ya 01:19:47

el prefab, lo que os he dicho antes de la boquilla 01:19:49

y si lo movíamos, ¿no? 01:19:51

entonces si yo este prefab lo guardo 01:19:52

y vuelvo aquí 01:19:55

y lo vuelvo a lanzar el juego 01:19:58

me lo deja en el 0,0, ¿vale? 01:20:00

Ahora sí que está en el 0,0 este cubo. 01:20:05

Si yo quisiera decir un punto del espacio 01:20:08

donde se pueda ubicar el objeto, 01:20:11

pues para, por ejemplo, hago aquí un objeto 01:20:15

que es la boquilla de la pistola. 01:20:18

De hecho, espera, no, voy a hacer algo visual 01:20:20

para que sea más fácil de detectar. 01:20:22

Hago este cilindro, ¿vale? 01:20:25

Que es la pistola que se va a ir moviendo 01:20:28

durante el juego, y en un momento X 01:20:30

voy a querer que en este 01:20:32

punto, cuando le dé a la barra espaciadora, por ejemplo 01:20:34

se instancie la bala 01:20:36

este objeto está en unas coordenadas 01:20:38

que no son el 0,0, si yo ahora 01:20:40

mismo le digo que se instancie 01:20:42

la bala 01:20:44

en algún punto 01:20:46

pues lo mismo, se va a instanciar 01:20:48

en el 0,0, pero si yo 01:20:50

vuelvo otra vez 01:20:52

a cálculos y le digo la posición de referencia 01:20:54

quiero que sea la del cilindro 01:20:56

que la voy a llamar boquilla, pistola, boquilla, ¿vale? Cuando voy a cálculos, yo si arrastro boquilla a la posición, ¿vale? Yo quiero que instancie el cubo, ¿vale? Va a instanciar en la posición de la boquilla, estoy preparando esto, ¿no? 01:20:58

Entonces, cuando, como esta posición, este transform, lo está cogiendo de la boquilla, hay otra opción que es decirle, vale, y quiero que me lo hagas en, al ponerle coma, veis que se pueden ir añadiendo más parámetros. 01:21:12

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. 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. 01:21:24

Cierro el paréntesis, guardo, y vais a ver que a diferencia de antes, ahora sí que cuando se ejecute el juego, 01:21:47

la bala se ha hecho hija de la boquilla y además está en la misma posición que la boquilla, ya no se hace en el 0-0. 01:21:58

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. 01:22:08

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. Solo me queda una cosita muy corta por explicar y por mí por hoy creo que ya estoy y creo que tenéis información suficiente para hacer la práctica. 01:22:15

Me quedan dos cosas y ahora os pregunto qué tal. Imaginaos que yo en este instantiate, en vez de hacerlo en start, lo pongo en update, corto y pego la línea y guardo. ¿Qué es lo que va a hacer? Pues que va a generar una copia cada frame. Aquí se van haciendo millones. 01:22:35

Esto normalmente no os va a interesar porque va a colapsar el juego de tantas copias que está haciendo, pero veis que dependiendo de dónde se ubique, pues hace la operación una vez al comienzo, otra durante cada fotograma y hay más métodos de tiempo. 01:22:53

Pero bueno, estos son como los básicos que vienen. Luego, última cosa. Os he dicho antes que por nivel de protección, para que no se pueda acceder a una variable desde varias variables que a lo mejor se llaman igual y luego un código muy grande, esto por defecto, si no ponemos nada, el declarar una variable es privado. 01:23:07

Yo lo he puesto público para que se vea en el inspector. Lo he vuelto a hacer privado. Ojo, que lo privado no existe. Y ahora no es solo que no exista, sino que ahora se ha perdido la referencia de los objetos. 01:23:24

Es decir, que ahora hago esto y no se va a instanciar nada porque ha dejado de pasarse la información, ¿vale? Pero hay otra operación, digamos, híbrida, que es que yo puedo seguir queriendo, que esto es lo que os pide la... esto es un poco para que veamos si lo vais cogiendo, que es que teniendo la misma protección privada, ¿vale? 01:23:39

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, pues, por ejemplo, para pasar los objetos, ¿no? 01:24:00

Y eso se llama, esa operación es metida entre estos corchetes, ¿vale? 01:24:11

Lo que se llama un serialized field, campo serializado, ¿vale? 01:24:16

Se pone antes del tipo de variable, que es donde se ponen los ámbitos. 01:24:21

A ver, esperad, que lo quiero copiar en la otra, ¿vale? 01:24:25

Y ahora las dos van a seguir siendo de tipo privado, lo puedo poner incluso de manera explícita aquí escrito, ¿vale? Pero siguen siendo privados. Cuando veamos cómo se accede a otros scripts, pues no se va a poder acceder así de forma fácil, digamos, pero sí que permitimos que aparezcan aquí, ¿vale? Para poder hacer este traspaso de información de elementos. 01:24:27

ojo, veis que cuando he borrado 01:24:51

y lo he vuelto a poner está en vacío 01:24:53

muchas veces va a dar error 01:24:55

que de pronto vamos a ver aquí algo vacío y pensamos 01:24:56

que está, este es el peligro que tiene de trabajar 01:24:59

desde el inspector 01:25:01

por eso muchas veces se hace todo con código 01:25:02

que eso funciona siempre si está bien hecho 01:25:05

entonces habría que volver a decirle en cálculo 01:25:07

la boquilla es lo que voy a usar 01:25:09

de posición de referencia 01:25:11

ahora la nave, pues por ejemplo 01:25:13

va a ser el prefab que se va a instanciar el objeto 01:25:15

guardo y al ejecutar 01:25:17

pues ya 01:25:19

La boquilla va a tener, bueno, como está en el update, pues se va a estar haciendo la nave en el sitio, ¿vale? Entonces, bueno, lo primero casi me va a interesar meter esto en el start y ya está. Más o menos lo que se os pide la práctica está todo explicado. 01:25:20

Desde luego Instanciate luego tiene más sobrecargas, ¿vale? Podría poner otra coma. Incluso antes de decirle, podemos poner si se instancia en un punto concreto, con una rotación concreta, aunque coja la posición de manera independiente. Bueno, pues ya hay más sutileza, pero esto ya demasiado por hoy. 01:25:35

si ponéis cualquier método, cualquier propiedad en Google, 01:25:54

por ejemplo, Instantiate, y ponéis Unity, 01:26:00

os va a remitir a la API o al manual de Unity. 01:26:02

Y aquí es donde os da una explicación, 01:26:09

esto está en inglés, no está en español normalmente, 01:26:11

de cuántas sobrecargas hay, su uso, descripciones, ejemplos. 01:26:14

Cuando no sepáis cómo funciona algo, 01:26:19

a medida que vayáis cogiendo además más soltura 01:26:21

pues iréis entendiendo mejor que pone aquí 01:26:25

pero esto va a ser vuestro manual de uso frecuente 01:26:27

que hay que ir revisando cuando tengamos problemas 01:26:31

de hecho si en cualquier momento 01:26:35