Desarrollo de juegos en 2D de Unity: unidad principiante y C en Unity 2020. 3 | Kaupenjoe (Nico) | Skillshare

Velocidad de reproducción


1.0x


  • 0.5x
  • 0.75x
  • 1x (Normal)
  • 1.25x
  • 1.5x
  • 1.75x
  • 2x

Desarrollo de juegos en 2D de Unity: unidad principiante y C en Unity 2020. 3

teacher avatar Kaupenjoe (Nico), CS Student, Nerd and Educator

Ve esta clase y miles más

Obtenga acceso ilimitado a todas las clases
Clases enseñadas por líderes de la industria y profesionales activos
Los temas incluyen ilustración, diseño, fotografía y más

Ve esta clase y miles más

Obtenga acceso ilimitado a todas las clases
Clases enseñadas por líderes de la industria y profesionales activos
Los temas incluyen ilustración, diseño, fotografía y más

Lecciones en esta clase

    • 1.

      Introducción a mi clase de unidad

      1:29

    • 2.

      Instalación de Unity

      8:27

    • 3.

      (C#) Creación de nuestro primer proyecto de unidad

      3:55

    • 4.

      (C#) Introducción a los cipos de datos en C

      12:43

    • 5.

      (C#) Sintaxis de C# explicada

      6:51

    • 6.

      (C#) integers y operadores aritméticos

      11:40

    • 7.

      (C#) Métodos de matemáticas

      9:31

    • 8.

      (C#) Operadores de asignación

      4:49

    • 9.

      (C#) Booleans y operadores de comparación

      3:39

    • 10.

      (C#) Booleans y operadores lógicos

      4:55

    • 11.

      (C#) Cuerdas y métodos de cuerda en C #

      15:00

    • 12.

      (C#) Variables de fundición

      8:22

    • 13.

      (C#) Declaraciones condicionales (si y otras cosas)

      8:18

    • 14.

      (C#) Ternary

      4:55

    • 15.

      (C#) Declaración de interruptor

      4:49

    • 16.

      (C#) mientras que bucle

      8:08

    • 17.

      (C#) para bucle

      4:20

    • 18.

      (C#) Romper y continuar con palabras claves

      4:02

    • 19.

      (C#) Arrays en C

      11:32

    • 20.

      (C#) Arrays multidimensionales en C#

      5:49

    • 21.

      (C#) Listas de C #

      8:01

    • 22.

      (C#) C# Diccionarios

      5:32

    • 23.

      (C#) Foreach

      3:00

    • 24.

      (C#) en espacios de nombres

      9:09

    • 25.

      (C#) Métodos de C#

      9:33

    • 26.

      (C#)

      6:10

    • 27.

      (C#) Clases y objetos

      12:26

    • 28.

      (C#) Miembros de clase

      4:49

    • 29.

      (C#) Miembros estáticos

      7:26

    • 30.

      (C#) Modificadores de acceso

      10:24

    • 31.

      (C#) Propiedades de C#

      9:08

    • 32.

      (C#) herencia

      9:55

    • 33.

      (C#) Polimorfismo

      4:49

    • 34.

      (C#) Clases y métodos abstractos en C#

      8:04

    • 35.

      (C#) Métodos virtuales

      3:45

    • 36.

      (C#) Interfaz de C#

      7:15

    • 37.

      (C#) en los enums

      4:12

    • 38.

      (C#) Excepciones y prueba y captura declaración

      7:28

    • 39.

      (C#) Conceptos básicos de los genéricos en C#

      5:18

    • 40.

      (C#) Conceptos básicos de LINQ en C#

      5:58

    • 41.

      (C#) Eventos y delegados

      8:02

    • 42.

      (C#) File E/O

      6:46

    • 43.

      (C#) Convenciones de C#

      8:19

    • 44.

      (conceptos básicos de unidad) y editor de unidad explicados

      18:03

    • 45.

      (conceptos básicos de unidad)

      4:42

    • 46.

      (conceptos básicos de unidad) y el inspector

      8:52

    • 47.

      (Aspectos básicos de Unity) para Kenny y la tienda de activos para nuestros juegos

      3:30

    • 48.

      (Conceptos básicos de la unión) Escenas y configuración de construcción

      7:31

    • 49.

      (conceptos básicos de unidad)

      12:54

    • 50.

      (conceptos básicos de la unidad) matemáticas cortas: vectores

      3:39

    • 51.

      (conceptos básicos de la unidad)

      15:15

    • 52.

      (conceptos básicos de unidad) GameObjects in Unity

      12:18

    • 53.

      (conceptos básicos de unidad)

      7:15

    • 54.

      (conceptos básicos de unidad) Creación de un Script de movimiento muy simple

      12:27

    • 55.

      (conceptos básicos de unidad)

      10:49

    • 56.

      (conceptos básicos de unidad) la cámara (principal)

      8:22

    • 57.

      (conceptos básicos de unidad) GetComponent en unidad

      14:07

    • 58.

      (conceptos básicos de unidad) prefabs y nuevos objetos

      11:00

    • 59.

      (conceptos básicos de unidad) texturas y sprites

      10:11

    • 60.

      (conceptos básicos de unidad) Sprite

      5:42

    • 61.

      (conceptos básicos de unidad)

      10:06

    • 62.

      (conceptos básicos de unidad)

      14:47

    • 63.

      (conceptos básicos de unidad)

      11:14

    • 64.

      (conceptos básicos de la unidad)

      7:08

    • 65.

      (conceptos básicos de unidad) Herramientas básicas de depuración de unidad

      6:57

    • 66.

      (Cheese Clicker) La idea de "Cheese Clicker"

      3:24

    • 67.

      (Cheese Clicker) Creación de un queso para hacer clic

      17:58

    • 68.

      (Cheese Clicker) Creación de edificios para construir

      32:32

    • 69.

      (Cheese Clicker) para crear una interfaz de usuario básica para edificios

      44:52

    • 70.

      (Cheese Clicker) Creación de mejoras

      32:27

    • 71.

      (UI de Unity) agregando una lienzo

      15:20

    • 72.

      (UI de Unity) Paneles y texto

      9:23

    • 73.

      (Unity UI) TextMashPro para un mejor texto

      8:24

    • 74.

      (UI de Unity) agrega imágenes a nuestra UI

      5:15

    • 75.

      (UI de Unity) puede ser divertido

      9:41

    • 76.

      (UI de Unity) Toggles y deslizadores

      8:15

    • 77.

      (UI de Unidad) en unidad

      12:23

    • 78.

      (Unity UI) y máscaras

      8:16

    • 79.

      (UI de Unity) y campos de entrada

      12:05

    • 80.

      (UI de Unity) agrega grupos de diseño a nuestro Clicker de queso

      4:52

    • 81.

      (Unity Intermedia) agregando una fuente de audio

      9:25

    • 82.

      (Unity Intermedia) agregando partículas

      8:42

    • 83.

      Configuración de proyecto (Unity intermedia)

      9:17

    • 84.

      (Unity Intermedia) agrega etiquetas a GameObjects

      6:52

    • 85.

      (Unity Intermediate) Raycasting en 2D en Unity

      11:35

    • 86.

      (Unity Intermedia) Preparar la escena para guardar datos

      46:48

    • 87.

      (Unity Intermedia) para ahorrar datos con PlayerPrefs

      9:49

    • 88.

      (Unity Intermedio) de almacenamiento (personalizado) con archivos JSON

      14:33

    • 89.

      (Unity intermedia) con TileSets

      16:36

    • 90.

      Conceptos básicos de animación (Unity intermedia)

      23:24

    • 91.

      Objetos Scriptable (Unity Intermedia)

      13:23

  • --
  • Nivel principiante
  • Nivel intermedio
  • Nivel avanzado
  • Todos los niveles

Generado por la comunidad

El nivel se determina según la opinión de la mayoría de los estudiantes que han dejado reseñas en esta clase. La recomendación del profesor o de la profesora se muestra hasta que se recopilen al menos 5 reseñas de estudiantes.

788

Estudiantes

--

Proyectos

Acerca de esta clase

¿Siempre has querido crear tus propios juegos, pero no sabes por dónde empezar? ¡Esta es exactamente la clase que necesitas entonces!

En esta clase de desarrollo de juegos para 2D para principiante completa, aprenderás los conceptos básicos de la programación en C# y de la creación de juegos con Unity 2020.3. No se necesita experiencia para este curso para aprender los ins y outs de hacer juegos con Unity.

Esta clase es accesible para los principiantes completos. Incluso si nunca has programado en tu vida. Los conocimientos básicos de Unity y Game Development serían ventajosos, pero no es necesario. Como parte de esta clase, también harás juegos 2D totalmente jugables de principio a fin y para que puedas remodelar, modificar o actualizar como quieras y usar como un parque de juegos de Unity.

Primero, aprenderás C#, luego revisaremos conceptos básicos de desarrollo de juegos de unidad y luego examinaremos conceptos intermedios así como el sistema de interfaz de usuario de unidad.

El Código fuente completo estará disponible para que puedas seguir todo lo que hago en las conferencias.

Si tienes alguna pregunta o sugerencia, también puedes contactarme aquí. Estoy encantada de ayudarte a aprender a hacer juegos con Unity.

Conoce a tu profesor(a)

Teacher Profile Image

Kaupenjoe (Nico)

CS Student, Nerd and Educator

Profesor(a)

I am Nico - also known as Kaupenjoe - I have a Master's Degree in Computer Science and teach Game Development through many different classes. Mid-2020, when I became a bit disillusioned with my job, I set my sights to something different. Multiple people have previously told me I was good at teaching things.

With some of my prior YouTube Video making knowledge I was able to make my first courses. The Minecraft Courses in particular made a huge impact on students and myself and allowed me to teach full-time with courses and other supplementary methods.

I hope you will also join me and allow me to help you learn Programming, Modding or Game Development. As a hobby, side-hustle or as a promising career, it is an amazing and fulfilling field and I'm so happy to have y... Ver perfil completo

Level: All Levels

Valoración de la clase

¿Se cumplieron las expectativas?
    ¡Superadas!
  • 0%
  • 0%
  • Un poco
  • 0%
  • No realmente
  • 0%

¿Por qué unirse a Skillshare?

Mira las galardonadas Skillshare Originals

Cada clase tiene lecciones cortas y proyectos prácticos

Tu membresía apoya a los profesores de Skillshare

Aprende desde cualquier lugar

Ve clases sobre la marcha con la aplicación de Skillshare. Progresa en línea o descarga las clases para verlas en el avión, el metro o donde sea que aprendas mejor.

Transcripciones

1. Introducción a mi clase de unidad: Hola, soy Nico me pilló en estudiante de músculo para ciencias de la computación y todo nerd impar por todo lo relacionado con el desarrollo de juegos. hace casi ocho años, llevo programando en Unity tanto por razones recreativas como profesionales. El increíble poder del motor Unity te da gratis todavía me desconcierta hasta el día de hoy. En esta clase completa de unidad y C-Sharp, aprenderás todas las habilidades que necesitas para hacer juegos increíbles en Unity o desde los temas muy básicos hasta los más avanzados. En primer lugar, se te presentará a fondo el lenguaje de programación C-sharp. Estos fundamentos te ayudarán a entender la unidad en toda su belleza. Y así hasta principiantes absolutos a la programación son muy bienvenidos en esta clase. Después de aprender los fundamentos de C Sharp, pasaremos a los conceptos básicos de unidad, como el editor, cómo funcionan los guiones, texturas y sprites y más. Tan pronto como se hagan los conceptos básicos, vas a crear tu propia primera marcha, Ella es clicker. Este proyecto está inspirado en él, Cookie Clicker. Y usaremos todos los fundamentos C-sharp así como todos los conceptos básicos que habrán aprendido hasta ese momento. Y luego seguiremos con temas más intermedios como una sección en profundidad sobre el I-System de la USU, además de refundir, guardar y tener datos persistentes, además de usar conjuntos de fichas, entre otras cosas. Todo eso y más te espera en esta clase completa sobre el desarrollo del juego Unity. Entonces, ¿a qué esperas ahora para inscribirte en esta clase? Y seamos el primer paso del increíble viaje para crear increíbles juegos de Unity. El poder está en tus manos. Te veré en la primera lección. 2. Instalación de Unity: Muy bien, bienvenidos a esta conferencia donde pasamos por cómo descargar Unity e instalarla. Por lo que esta URL está disponible como recurso para que puedan acceder muy fácilmente a ella. Simplemente se almacena en unity.com slash download. Y luego asegúrate de que estás, que cumples con todos esos criterios aquí. Y se podría decir simplemente: Sí, cumplo con todos esos criterios. Esto es básicamente si simplemente eres una persona soltera y no estás haciendo esto en ningún tipo de empresa o algo así, entonces puedes usar la licencia personal de Unity aquí y sí, y solo descarga Unity Hub. Entonces va a haber un programa que va a ser útil para todo tipo de cosas. Voy a poner rápidamente esto dentro de esta carpeta aquí. Entonces esto es simplemente un EXE, solo puedes iniciarlo. Y entonces tal vez tengas que hacer eso. Cuenta con acceso de administrador y luego serás recibido por los términos de servicio. Simplemente aceptarás esos y luego dirás donde quieras instalar esto. Ahora personalmente ya lo he instalado. Simplemente hará clic en Instalar y luego todo funcionará a partir de ahí. Después de haberlo instalado, probablemente te pedirá que básicamente inicies sesión si ya tienes una cuenta de Unity, eso es genial. Si no lo haces, entonces simplemente puedes hacer uno en el sitio web de Unity y luego iniciar sesión con eso después de haber iniciado sesión, debería aparecer algo como esto. Ahora tus proyectos probablemente estarán vacíos, pero eso es totalmente normal. Pero lo primero que tenemos que hacer es instalar una instancia específica de unidad. Entonces en nuestro caso, como pueden ver, tengo 20 1946, tengo 2020 a 0. Esta es una versión beta. Y entonces tengo la versión 2023 0, que es básicamente la que vamos a estar trabajando mayormente. Ahora si vas a este botón Agregar, entonces se abrirá un nuevo pop-up y podrás ver que ya puedes obtener algunos lanzamientos recomendados. Por lo que en realidad hay cuatro nuevas versiones extranjeras que se han lanzado desde el 2020 punto de tres punteros 0. Y luego también hay otras versiones oficiales así como pre lanzamientos. Ahora en nuestro caso, en realidad queríamos la versión 2020 0.3, cualquiera que sea el número que esté después de eso usualmente significa que solo hay algunas correcciones de errores y algunos cambios menores. Entonces vamos a dar click El próximo año. Y luego si no lo tienes instalado por tu cuenta. Entonces si no tienes Visual Studio, recomiendo encarecidamente que agregues esto a tu instalación así como un módulo. Porque estaré usando Visual Studio y podría haber algunos en congruencias. Si utilizas otro entorno de desarrollo, básicamente documentación que absolutamente tienes que tener. Y entonces también podrías en teoría tener aquí algunos paquetes de idiomas diferentes como puedes ver, y todas las plataformas realmente no nos interesan. A lo mejor si básicamente estás en un Mac o Linux, entonces yo por supuesto diría que definitivamente deberías tomar eso también, para que realmente puedas construir tu juego en tu propia máquina. De lo contrario, eso no sería tan inteligente. Hora, sin embargo, sí creo que la unidad, el hub realmente detecta en qué tipo de sistema eres y debería instalar eso automáticamente. Pero sí, así que definitivamente creo que definitivamente deberías tener este Visual Studio aquí. Ya tengo esto instalado, así que no lo necesito, pero lo recomiendo muy bien. Y luego simplemente haz clic en Listo. Ahora como puedes ver, esto se está descargando de vez en cuando también instalando. Esto va a llevar un tiempo dependiendo de tu conexión a internet así como de tu velocidad de tu computadora. Una vez terminada la instalación, podemos volver a los proyectos. Y ahora vamos a ir realmente a crear nuestro propio primer enorme proyecto aquí. Entonces vas a ir a Nueva. Y normalmente voy a este menú desplegable para que puedas elegir qué versión de Unity te gustaría seleccionar. Seleccionemos la versión más reciente aquí. Y luego se va a crear una nueva ventana aquí que diga Crear una nueva versión con esta versión en particular. Debido a que este es un curso 2D, básicamente sólo queríamos D, seleccionado como plantilla aquí. Podemos seleccionar una ubicación, estoy bien con esa ubicación. Y luego el nombre del proyecto. En este caso, sólo vamos a utilizar el ejemplo de instalación en nuestro caso para usted, porque después de esto inmediatamente vamos a empezar a la introducción C aguda. A lo mejor ese sería un mejor nombre para ti. Así que tal vez nombró el proyecto C introducción aguda para ti. Me voy a pegar con ejemplo de instalación, luego haga clic en Crear, luego Unity Hub se cerrará y se abrirá una unidad. Es posible que tenga que decir sí al Windows Defender real que quiera usar el firewall. Solo vamos a decir que sí, claro, porque eso está bien. y luego en solo un poco después de que esté importando algunas cosas e incluso descargando algunas cosas más, entonces se abrirá para nosotros dependiendo de lo bueno que sea tu PC. Esto podría tardar un poco más o más corto, y ahí lo tenemos. Ahora lo primero que voy a hacer es cambiar el diseño a mi diseño personal, el cual uso. He guardado esto bajo disposición de KJ. Y si selecciono esto, entonces este es el diseño que vamos a estar usando durante este curso. Ahora en realidad te he dado esto como un layout aquí, algodón maquetación general, W LTE. Este es el archivo disponible como recurso también. Y luego básicamente puedes importarlo yendo a kJ, luego viendo Load layout from file y seleccionando este fichero. Y entonces deberías tener exactamente el mismo diseño también. Si lo deseas. No necesitas necesariamente tener eso. Es sólo que este es el diseño al que estoy acostumbrado he crecido. Sí. Una cosa más que deberás revisar antes de poder continuar es que debes ir a la Edición y luego ir a Preferencias. Y esto abrirá aquí una ventana de preferencias. Y luego dentro de herramientas externas, asegúrate de tener aquí seleccionado el editor de guiones correcto. Entonces para nosotros, esto para ti, esto probablemente será Visual Studio Community 2019. Yo Visual Studio 2019 en sí. Entonces solo para que sepas que tienes que seleccionar esto. De lo contrario, usarás el editor de scripts predeterminado, ¿cuál es qué? Se verá un poco diferente a lo que vas a estar viendo conmigo. Pero eso sería todo para este. Esta es la instalación realizada. Entonces cuando continúas con este curso, básicamente tienes en algunas de esas son algunas de las secciones. Tienes dos opciones. Por lo que puede o bien obtener el paquete completo para algo o un paquete vacío. Entonces esto básicamente significa que puedes hacer todo o empezar con básicamente nada y construirlo mientras lo estoy haciendo. Por lo que para importar esto, puedes ir a Activos, importar paquete, paquete personalizado. Entonces abrirá aquí una carpeta en particular. Y simplemente vamos a ir básicamente a nuestra carpeta donde tengo esto en. Y como puedes ver, hay algunos de esos paquetes, todos esos están disponibles como recurso. Entonces, por ejemplo, lo que queremos es el C-sharp completo. Entonces, abramos esto. Y luego como puedes ver, todo lo que aquí dentro ya está hecho para ti para que simplemente tengas que decir Importar. Y luego va a importar todas esas clases y todas esas escenas. Y entonces básicamente se puede iniciar conferencia 10 tipos de datos. Ahí está. Y luego si empezara esto, entonces lo que se puede ver es que de inmediato funciona con, bueno, se va a recargar y luego como se puede ver, funciona y todo está bien. Entonces eso sería básicamente es, eso es muy importante. Por lo que tienes que elegir si quieres o no la versión completa o si quieres la versión vacía de ésta. Y sí, eso básicamente sería todo para la instalación. Eso sería todo lo que realmente necesitas para que inicies el viaje de programación en Unity. Sí, espero que esto te resulte útil y la instalación fue exitosa. Si quedan preguntas, por supuesto, siéntase libre de preguntar y me aseguraré de responder. Y sí. 3. (C#) crear nuestro primer proyecto de unidad: Muy bien, bienvenidos a esta conferencia. Y esto es sólo una adición rápida aquí. Para que sepas lo que tienes que hacer. Porque próxima conferencia de inmediato vamos a empezar a esta introducción C-sharp. Y básicamente, solo quería mostrarte una vez más creando un nuevo proyecto y luego básicamente importando el paquete real que he proporcionado aquí. Esa fue la conferencia anterior. Ese fue el paquete completo y el vacío. Ellos son Archivos de Paquete de Unidad. Y sí, básicamente cuando tienes abierto Unity Hub, simplemente haces clic en esta pequeña flecha y luego eliges la versión más reciente. Y cuando haga clic en eso, aquí se abrirá una nueva ventana. Crea un nuevo proyecto con Unity 2020 tres, y luego sea cual sea la versión actual, ME seguro que seleccionará aquí la plantilla 2D. Y luego sugeriría algo así como C introducción aguda como nombre de proyecto o algo así. Por supuesto, también tendrás que especificar tu ubicación. ¿ Dónde quieres que se cree esto? Digamos que estoy contento con esto. Y como dije, C-Sharp introducción que tiene más sentido. Y luego crea el nuevo proyecto. Por lo que en realidad sí tienes que crear un nuevo proyecto. En general, diría que probablemente por cada sección. Entonces C-sharp viene entonces los conceptos básicos. Y luego llegamos a construir básicamente nuestro primer juego, el clicker de mejillas, unidad, DUI y demás. Por lo que para cada una de estas secciones, te aconsejo que hagas un nuevo proyecto para eso, entonces siempre podrás importar cualquiera que sea el contenido real de eso. Para la introducción C aguda, tienes la capacidad de elegir entre los dos siguientes. Entonces si sólo los traigo por aquí, así que ahí está el C-sharp. Como puede ver, el paquete de unidad completo y el paquete de unidad vacío. Ambos vienen con un predefinido, por lo que las carpetas y escenas ya están dispuestas y hechas. El Vacío simplemente son scripts básicamente vacíos. Y los completos son los guiones completos que ya son los que básicamente estamos haciendo en la introducción aguda de C. Entonces lo que sea que te sientas es mejor para que aprendas C-sharp. puedes hacer todo ya o tener esto vacío, mismo con todas las demás secciones. Ellos lo son. Se puede obtener los paquetes completos que son o básicamente crear todo el proyecto a medida que vamos con las conferencias. Entonces vamos a ver, una vez más, generalmente el diseño aquí debería ser diferente. Si miras hacia atrás en el aislamiento de unidad, son, es el número uno un recurso o el número 2, te digo que vamos a cambiar el diseño a esto. Y este es también el diseño que vamos a estar usando durante todo el curso aquí. Y puedes ir a Activos, importar paquetes o importar paquete, paquete personalizado. Y entonces te dejará básicamente abrir este diálogo de archivo. Y luego puedes elegir ya sea el paquete completo o el paquete vacío. Como dije, el paquete MD contendrá todo también. No obstante, los guiones van a estar vacíos excepto posiblemente para los dos primeros porque eso es, eso es lo más básico que quiero explicar algunas cosas que son. Y en la completa, todo estará dentro de ella. Por lo que la importación en sí se verá igual tanto para la completa como para la vacía. No obstante, en el completo se llenan, que básicamente podemos comprobar sólo por el bien de argumento aquí. Entonces vamos a guiones, por ejemplo, y vamos a hacer click en cualquier cosa aquí. Y luego como puedes ver, esto ya está rellenado, a veces con algunos comentarios también para que también puedas comprobar eso. Pero sí, de aquí en adelante, vamos a empezar de inmediato con la conferencia uno, datatypes. Espero que te diviertas con el curso y que aprendas algo nuevo. Y te veré en la primera conferencia. 4. (C#) Introducción a la dato): Muy bien, Bienvenidos a la introducción C-sharp aquí para el curso de unidad. Y en esta primera conferencia vamos a echar un vistazo a unos tipos de datos. Entonces lo primero es lo primero, asegúrate de tener los tipos de datos de la Conferencia 1 abiertos aquí. Y luego simplemente vaya a scripts y haga doble clic en tipos de datos y luego se abrirá el script de tipo de datos. Ahora, hay algunas cosas que quiero decir primero, lo primero es que vamos a ignorar la mayor parte de lo que hay aquí arriba. Sólo vamos a ignorar eso por ahora. Vamos a llegar a eso más tarde por la línea. Y eso lo voy a explicar a detalle. Pero ahora mismo, necesitamos empezar con un poco de otra fundación primero. Entonces digamos que necesitamos todo esto para que el programa se ejecute. Sólo digamos así y entonces vamos a estar bien. Y luego todo lo demás allá arriba, sólo vamos a ignorar. Y vamos a mirar adentro, en este inicio aquí, así que vemos el inicio. Y entonces tenemos este corchete rizado y todo lo que está escrito dentro de aquí. Esto es lo que vamos a ver. Entonces en código, en C Sharp por ejemplo. Y además, creo que como básicamente cualquier otro lenguaje de programación, siempre vamos de arriba a abajo. Por lo que cada una de esas líneas, por suerte ahí también están numeradas aquí. Cada una de esas líneas se ejecutan en serie. Entonces básicamente, primero, se ejecuta la línea 10 y luego la línea 11 y luego la línea 12 y así sucesivamente y así sucesivamente. Hay algunas cosas en las que puedes, por ejemplo, agrupar unas cuantas líneas y luego hacerlas ejecutadas. Pero ahora mismo, sólo lo vamos a pensar como vamos a pasar de arriba a abajo. Y todo ha pasado en cereal, ¿verdad? Y ahora tipos de datos. Entonces, ¿qué? La primera pregunta es, ¿qué son los tipos de datos? Los tipos de datos son básicamente una forma de almacenar información y hay diferentes tipos de información. Entonces en C-Sharp, tenemos valores de verdad o booleanos. Tenemos números. Esos pueden ser enteros o números de coma flotante. Y también tenemos básicamente texto. Se trata de caracteres o múltiples caracteres, caracteres uno al lado del otro, que se llamarían cadenas. Ahora, empecemos con la verdad o los valores booleanos. Algunas cosas para la sintaxis básica también. Entonces si queremos crear una nueva variable, entonces lo que tenemos es escribir el tipo que queremos. En este caso, se trata de un valor booleano. Entonces escribimos bool y luego escribimos el nombre de la variable, y luego terminamos cada línea con un punto y coma. Esto es lo que se llamaría una declaración. Eso lo vamos a volver a ver en la próxima conferencia, un poco más, la sintaxis de todo. Pero ahora mismo, esta es la idea. Por lo que ahora hemos creado una variable, como se puede ver, variable local de tipo bool, que se llama, está a tierra. Y entonces podemos asignar un valor a esta variable con este operador igual. En este caso decimos igual a cierto. Entonces en este caso, después de la línea 12 está puesta a tierra es igual a verdadero. Entonces esta es la asignación. Y se puede, por ejemplo, imaginar esta es la razón por la que un resfriado está a tierra. El variable está conectado a tierra podría ser algo que haga un seguimiento de cuando se tiene como un juego de plataformas 2D donde Mario, por ejemplo, corre de ida y vuelta y en cuanto Mario salta se pone a tierra se pondría en falso porque ahora está en el aire. Y entonces tan pronto como toque el suelo de nuevo se pone a tierra sería cierto. Entonces esto es algo donde podrías, por ejemplo, hacerlo para que no puedas saltar infinitamente alto porque necesitas estar en el suelo para poder saltar. Eso es como una especie de ejemplo real que puedes usar en un juego. Y entonces tenemos aquí la salida específica de Unidad, sólo para que podamos ver qué implica realmente la variable. Vamos a ver la salida al final cuando termine con la explicación aquí. Y entonces esto sería la verdad y los valores booleanos útiles para básicamente decidir si algo es cierto o no falso. Porque esos son los posibles valores ahí dentro son verdaderos o falsos. Y eso es todo. Entonces veamos el entero. Entonces los enteros son números enteros. En este caso, estamos, en hacer una variable que se llama puntos de tipo entero y de inmediato le asignamos un 50. Por lo que en este caso, declaración y asignación juntos en una línea se llamaría inicialización. Y eso de inmediato sólo establece la variable de puntos 250. Y entonces también tenemos un largo. Un largo simplemente tiene un límite más alto. Para que podamos almacenar números más grandes ahí dentro. Y en realidad tengo como tener esto aquí sólo para referencia. Entonces el valor máximo de un entero normal es de 2 mil millones, y entonces el valor máximo de un largo es de cinco quintillion, creo. Pero al final, es tan grande que rara vez se usa. Y también he, en, sobre todo en juegos, por lo general el máximo entero es suficiente. Y sí, los pulmones están ahí. Si alguna vez los necesitas, entonces puedes hacer esto y tener que básicamente sean nueve quintillones. Y tú deberías estar bien En ese momento, sí creo. ¿ Verdad? Y entonces los números de punto flotante son básicamente números con un punto decimal. No obstante, se guardan con una en notación científica. Por lo que la notación científica son cosas como diez. Hagamos como 3.5 veces diez a los cuatro, por ejemplo, esto es notación científica y así es como se guardan los números de coma flotante. Y hay dos tipos de números de punto flotante hay interesantes aquí. Uno es un flotador y otro es un doble. Y la diferencia entre esos dos es básicamente la precisión de los números que puede ahorrar. Por lo que un número de punto flotante puede ahorrar hasta ocho puntos de precisión. Por lo que podemos tener ocho números aquí. Entonces, ya sea antes o después del punto decimal, y seguiría siendo preciso. Y el doble puede hacer hasta 16 números. Por lo que hasta 16 números antes y después del punto decimal. Entonces, pero para hacerlo bien, entonces si tenemos algo como Ro, algo loco como esto. Entonces contarías 123, y luego contarías aquí 456 y así sucesivamente. Y si eso es 16, entonces o lo es, si es más grande que 16, entonces no lo haría. Se redondearía hacia arriba o hacia abajo. Se redondearía. Entonces eso es importante saberlo. Si necesitas como precisión. Lo mejor es usar enteros si no necesitas puntos decimales. Sí, esos son números de punto flotante. Vamos a ver cómo funcionan esos también en futuras conferencias. Pero esos son también pueden ser muy importantes. Y luego vayamos a los personajes y a la primavera. Entonces caracteres, hay un char, tipo variable, un tipo de datos, y una cadena. Un char es simplemente una sola letra y lo escribes aquí con estas comillas simples. Y una cadena es un es múltiples caracteres uno al lado del otro. Y tú escribes eso con estas comillas dobles. Sí. Y la idea simplemente es que como dije, la letra es una sola letra. Ahora esto puede ser una a, podría en teoría ser un número, pero entonces no es el número en sí también, pero es la representación textual de dos. Y luego también, por ejemplo, unos personajes especiales como un I'm Space-bar o un guión bajo o algo así, también serían personajes en este caso. Y luego una cuerda es simplemente como dije, un múltiples caracteres uno al lado del otro. Y sin embargo, una cosa que también quería mencionar, C-sharp tiene algo llamado tipos implícitos. Entonces lo que hemos visto antes es que siempre hemos designado el tipo, el tipo de datos que era. Entonces char una cuerda, un doble, y así sucesivamente. No obstante, también podemos simplemente escribir var, así VAR, y luego el nombre de la variable y luego ponerlo como simplemente asignarlo a algo y entonces solo se va a saber, vale, este es un entero ahora. Y como se puede ver, si paso el cursor sobre él, enteros puntos totales. Y aquí tenemos jugador de cuerdas para nombrar. Por lo que esto también funciona. lo personal, no uso esto muy a menudo ni donde sea porque no saco nada de esto. Algunas personas usan esto cuando tienes quizás nombres de tipos de datos largos porque en el futuro podemos, por ejemplo, hacer nuestros propios tipos de datos. Eso a veces ayuda. Por lo general me pareció que es mejor ser realmente específico, o en nuestro caso, explícito, ¿verdad? Entonces este es un tipo implícito y entonces esto sería explícito encintado. Lo escribimos explícitamente. Oye, esto es una cuerda, este es un personaje que es un flotador. Entonces sí, pero por supuesto puedes usar esto. Y podrías verlo en código que otras personas han escrito. Entonces eso siempre es importante saber cosas, aunque no tendas a usarlas o si no quieres usarlas. Pero tiene todo que ver con el estilo y nada que ver con si es o no mejor o peor en términos de rendimiento o algo así. La palabra clave var no cambia nada. Si escribo o no var o una cadena ahí dentro. Después de que todo se compila en todos, eso, no importa. No cambia nada. Es sólo por el bien de legibilidad. Y esa es también una de las cosas que es importante. El código debe ser legible para las personas. Y lo hará muy fácilmente en realidad, se puede escribir código que funcione. Pero también necesita ser legible para alguien que nunca antes haya visto el código. Y eso es realmente duro, ¿verdad? Entonces veamos qué pasa cuando realmente ejecutamos esto. Entonces lo que esperaríamos esto, lo primero que se saca está fundamentado, cierto. Y entonces los puntos deben ser de 50 por nueve, cuatrillones o continuándolos. Y luego tenemos un dañado 3.5, gran daño, un 100, luego la letra un NICU como jugador 1, James jugador dos, y luego el total de puntos sería de 100. Esto es una especie de lo que esperaríamos aquí que se apaguen, ¿verdad? Una vez más, asegúrate de tener una conferencia abierta. Y entonces sólo podemos pulsar el botón de reproducción aquí. Y como podemos ver, ahí vamos. Entonces si miramos aquí abajo, en realidad podemos desplazarnos un poco y luego está conectado a tierra es cierto. Después tenemos puntos 59, quintillón, 3.5 daños. También tenemos grandes daños, un 100, y luego personaje, un personaje, un jugador uno es James del Jugador 2 de NICU, y luego punto engendrar un 100. Algo a tener en cuenta es aquí que el 100, en realidad el punto decimal se corta. En este caso, porque en realidad no contiene ninguna información útil porque era 0 de todos modos. Por lo que realmente no importaba si tenemos 0.01, por ejemplo. Y luego lo dejamos sentarse un rato y luego volver a jugar. Entonces vamos a ver que realmente hace esto. También es importante tener en cuenta, estas son comas en mi caso, esto es solo por la localización, porque mi máquina ejecuta la localización alemana para que las comas o ningún punto decimal se conviertan en dos comas y comas para los 1000 separadores se van a convertir en puntos o, ya sabes. Sí. Entonces eso solo es importante saber. Simplemente no te confundas con eso. Eso está todo bien. Sí. Y eso fue básicamente todo para la introducción a los tipos de datos. Y como dije, sólo una visión aproximada. En las futuras conferencias, realmente vamos a hacer uso de esos diferentes tipos, lo que pueden hacer. Y los vamos a manipular. Vamos a, por ejemplo, a los números que vamos a matemáticas con ellos, ¿verdad? Entonces vamos a calcular cosas. Entonces eso es todo por venir. Y espero que lo hayan encontrado útil. Si hay alguna pregunta. Por supuesto, siéntete siempre libre de preguntar y me aseguraré de responder. Y sí. 5. (C#) Sintax C#: Muy bien, bienvenidos de nuevo a la introducción C-sharp para el curso de unidad. Y en esta conferencia vamos a echar un vistazo a la sintaxis C Sharp. Entonces, solo abramos el script aquí, el script de sintaxis. Y pasemos por ahí y veamos qué podemos ver. Entonces, en primer lugar, si aquí tenemos dos barras, este es un comentario, como dice. Y entonces también podemos tener comentarios multilínea. Si hacemos una slash y luego una estrella, y luego básicamente hacemos otra estrella y una contrasta o una slash. Y luego cada vez que básicamente golpeamos Enter, creamos una nueva línea, nuevo peso de línea, o podemos comentar. Por lo que esto serían comentarios multilínea. A veces puede ser importante explicar piezas de código. O tal vez tenemos algunas cosas que hacer y luego simplemente podemos escribir algo como hacer y luego simplemente agregar más cosas. Eso en realidad es algo así, a veces puede ser importante. Para Commons. No vamos a meternos en el tipo de argumento ideológico si los comunes son o no buenos o malos. Yo sólo estoy aquí para decirte que hay comentarios, básicamente, ¿verdad? Ya hemos visto la declaración donde simplemente ponemos en el tipo de variables, el tipo de datos en el nombre de la variable. Y entonces la asignación es simplemente asignar un valor a esa variable. Aquí realmente ponemos salida una cadena, ingrese la variable I. Ya hemos visto esto en la última conferencia. Ahora bien, esta es simplemente una forma en la que podemos combinar básicamente una variable en este caso, así como una cadena y luego imprime ambas. Debug dot log. Ahora mismo, no necesitamos entrar en los detalles. ¿Qué significa eso? Bueno, simplemente significa que le damos algo a la consola dentro de Unity. Pero muy importante, esto es específico de la unidad. Y sí, así que si solo estás usando C-sharp, esto no funcionaría. Tendrías que usar otra cosa. Es por ello que se trata de una C aguda introducción para la unidad. Si queremos acceder a variables y métodos de objetos, entonces podemos hacer esto. Ahora, variables, sabemos que las variables se escriben así como esto es una variable, entero. Escribo esa es una variable que teníamos el booleano está a tierra, esa era una variable ¿verdad? Ahora bien, ¿qué son los métodos y los objetos? Vamos a entrar en eso también un poco más tarde en una conferencia diferente. Pero ahora mismo, sólo podemos pensar en esto como un objeto básicamente siendo algo donde podemos almacenar variables y métodos. Y un método es simplemente múltiples líneas de código condensadas en como una expresión. Piénsalo así. Entonces por ejemplo, en este caso, cuando tenemos, queremos la longitud de la cuerda S, ¿no? Podemos hacer longitud de punto S. En este caso, la longitud es una variable porque es justo, se acaba de escribir sin los paréntesis en la parte posterior. Y como puede ver, S dot normalizado en este caso tiene paréntesis aquí. Y los paréntesis denotan que se trata de una llamada de método. Entonces esa es la diferencia ahí y accedemos a las cosas dentro de un objeto con el operador de puntos. Entonces si escribo S y luego un punto, entonces como puedes ver, hay todo un montón de cosas a las que puedo acceder a la orina y hacer. Y lo vamos a ver con más detalle en futuras conferencias. En un principio. Es un poco difícil porque si no tienes ningún lenguaje de programación, Y, ya sabes, tenemos que empezar en alguna parte. Y en un principio me estoy refiriendo cada vez más a futuras conferencias, que a medida que avancemos no sucederán tanto. Es solo que, es que ahora mismo estamos intentando básicamente arrancar desde lo básico y luego seguir adelante, ¿verdad? Entonces esa es la idea de que podemos acceder a algunas cosas dentro de nuestras variables. Por ejemplo, curiosamente, así que tenemos aquí la IA, que por supuesto podemos hacer lo mismo con los ojos. Entonces si lo hacemos yo punto y como puedes ver, también hay algunas cosas que podemos hacer, en este caso, menos de lo que podríamos hacer con la cuerda. Porque el entero simplemente no tiene, no tiene tanta funcionalidad para él. Es así como se puede pensar en esto, ¿verdad? Y luego también hay otra cosa. Los corchetes rizados son básicamente pueden definir bloques de código. Estos también se llaman alcances. Por lo que este sería un alcance diferente. Y la idea es que dentro de esto, por lo que hemos declarado yo aquí arriba en el alcance del método de inicio en este caso. Y este es un nuevo alcance. Y ahora porque este alcance derecho está dentro de los alcances de que vino antes que él, donde me declararon en. Podemos acceder a ella. Ahora si declaramos x aquí, podemos ponerlo totalmente bien. Pero entonces si miramos esto, ¿verdad? Entonces si podemos hacer esto, y si hacemos esto, y como pueden ver, x en realidad está marcado aquí como una flecha. Y dice que el nombre x no existe en el contexto actual porque declaramos dentro de este ámbito. Y después de que estemos fuera del alcance, por lo que al final de este corchete rizado, ya no existe. Y por eso a veces esto puede ser útil. Simplemente puedes definirlo básicamente. Defina un nuevo alcance simplemente poniendo los corchetes rizados. Y estos también se usan si definimos métodos más adelante por la línea. Y entonces se va a conseguir una aún más clara. Pero también podemos simplemente poner en ámbitos como este. Y entonces, por ejemplo, podemos simplemente derrumbarlos también. Podría ser útil a veces para la administración de código, solo para hacerlo un poco más ordenado o algo así. Pero sí, sí, Eso es básicamente como una visión general aproximada de la sintaxis aquí. Habiendo vuelto a mirar la declaración y asignación, eso es algo importante que la salida aquí. Muy importante que sea específico de la unidad. Y sí, vamos, en realidad también podemos mirar la salida sólo por el carajo de ella. Una vez más, asegúrate de estar en sintaxis. Solo juguemos. Y va a dar salida la longitud única de la cadena es 11. Y luego tenemos un 0. Esa fue la x dentro de los diferentes alcances, ¿verdad? Sí, y eso fue todo por la sintaxis. Siguiente conferencia, en realidad vamos a hacer algo. Vamos a ver el entero y los operadores aritméticos. Entonces vamos a empezar a usar realmente algunas de las variables y algunos de los tipos de datos de los que hemos aprendido. Y sí, eso fue todo. Y si hay alguna pregunta, por supuesto, siéntete siempre libre de preguntar y me aseguraré de responder. Y sí. 6. (C#) Integers y operadores Arithmetic: Muy bien, bienvenidos de nuevo a la C aguda introducción para el curso de unidad. Y en esta conferencia vamos a echar un vistazo a los enteros y operadores aritméticos. Entonces, solo abramos el script de enteros aquí. Y vamos a acercar un poco. Y muy importante que hagas todo lo que vas a hacer dentro de este inicio aquí. Entonces en lugar de este alcance, y sí, solo empecemos. Entonces definamos dos enteros. Vamos a llamar al primero 1 primero y tal vez al segundo 1 segundo. Eso funcionaría. Entonces el primero ahora mismo, por lo que la variable con el nombre primero ahora tiene 100 escritos en ella, y segundo tiene 200 escritos en ella. Ahora lo que podemos hacer es hacer matemáticas. Ahora. En primer lugar, no te preocupes por ello. Sólo vamos a hacer, digamos las cosas simples de matemáticas ahora mismo. Y sí, así que lo primero que vamos a hacer es la adición. Entonces, sólo vamos a sumar esos juntos. Por lo tanto, digamos que la suma entera es igual al primero más segundo. Y eso sería por supuesto 300. También puedes simplemente depurar punto cerrar sesión esto. Adición. Tenga en cuenta que definitivamente no es así. Se llama algo Diego y luego lo tenemos. Entonces si echamos un vistazo a esto, así que solo pensemos en esto. Hemos declarado una variable llamada suma, y luego inmediatamente la asignamos primero más segundo. Entonces este plus, como se puede ver, este es el, este es un operador con dos enteros. Si realmente puedo flotar sobre él, ahí tienes. Entonces en izquierda y derecha, y sólo suma esos dos juntos. Eso es todo lo que hace. Agrega 100, en este caso, primero y luego segundo, 200. Y esto va a resultar en un 300. Y sólo para que lo sepas, para volver a comprobar, sólo vamos a ver Vamos a ejecutar esto como puedes ver 300. También asegúrate de que estás en conferencia tres enteros. Muy importante. Pero sí, sí funciona. Y me hubiera sorprendido si de repente esto no funcionara. También fui muy interesante. Entonces si podemos, por supuesto hacer esto con, por ejemplo, primero plus, ya sabes, podemos hacer más Arno como 500. Y luego más, más segundos, algo así. Ya sabes, esto también funcionaría. Básicamente podemos poner en las variables y diferentes enteros también. Entonces como 500 años, también podemos entonces, por ejemplo, decir, Bueno pongamos otros 200 ahí, algo así, eso también funciona. Y luego si solo podemos copiar este bloqueo de depuración, esto es a veces lo hago muy rápido. Es por eso que lo mencioné ahora mismo. Entonces lo que hago es básicamente marcar este derecho. Por lo que me aseguro de que esto sea seleccionado. Entonces presionaré Control C. Y luego pongo, voy aquí hasta el final de la línea y presiono el control V. Y luego solo, entonces simplemente va a pegarlo básicamente en la siguiente línea. Entonces probablemente me vas a ver hacer eso en futuras conferencias como un poco. Es solo, ya sabes, cuando estás, cuando digamos que programas por un tiempo, entonces algo así como esas cosas a veces se automatizan. Por lo que sólo quería mencionar esto. Probablemente lo voy a mencionar a lo largo de algunas de las futuras conferencias también. Yo sólo quería decir que así es como se puede hacer esto. Ya sabes, marcando algo, asegurándose de que esté seleccionado Control C, Control V, y luego se va a hacer. Y ahorro con Control S. O también puedes subir aquí a los seguros. Y entonces también se va a ahorrar al, al baño. ¿ Qué escribe ese disquete? El icono de guardar. Y veamos qué sale por ahí. Debería ser 1005, si tengo razón, creo, sí. Sí. Está bien. Eso es bueno. Mis habilidades matemáticas siguen bien. A pesar de que puede haber un poco de roster, pero sí, eso también funciona. Y eso es algo genial lo que podemos hacer además, pero quiero decir que eso es sólo la adición. Echemos un vistazo a la resta. Esa va a ser la próxima gran cosa. Entonces, ¿qué es eso? Entonces digamos que el Sub entero es un primer segundo menos. ¿ Qué podría ser eso? Bueno, esto sería negativo 100. Eso es interesante, es 100 menos 200 es negativo 100 porque los enteros también pueden ser números negativos. Es decir, no hay nada que diga que eso no funcione. Entonces hagamos sub y solo imprimamos eso también. Y luego vamos a ver si eso realmente funciona. Si eso es negativo 100 y de hecho es negativo 100. Entonces eso es algo importante tener en cuenta que los enteros en este caso también pueden ser negativos. También hay enteros que no pueden ser negativos. No obstante, he saltado intencionalmente esos autos. Por lo general no se requieren en básicamente como el 98% de las posturas políticas. Por lo que sólo saltaremos por encima de ellos por ahora. Si alguna vez se necesita, siempre se puede hacer una pregunta y me aseguraré de darle algo más de información. Ahora entremos en algo que también es interesante, que es la multiplicación. Entonces digamos en mole es igual a 4 veces primero, esto sería 400. Y eso sólo funciona porque ¿por qué no? Imprimamos eso. Y vamos a imprimir topo por aquí. Esto sólo debería funcionar. Por lo que cuatro veces 100 deben ser 400. Parece legal. Imprimamos esto y veamos si eso también funciona. Y por supuesto que lo hace totalmente bien. Entonces como puedes ver, el operador de multiplicación es esta estrella aquí. Eso es, sí. Y el más y el menos deben ser autoexplicativos. Creo que esto también es una especie de estrella estándar. Y luego si vamos uno más a división o a dividir, entonces podemos decir que el div es igual a segundo, dividido primero. Esto serían dos porque estamos dividiendo 200 por 100. Y también podemos imprimir ese fuera o depurado en login con el div, derecho. Y sí, eso es, así que esta es una barra en este caso, dos cortes son un comentario, una barra es la división. Y como siempre con unas reglas matemáticas normales, básicamente, más o menos el orden de las operaciones no importa, ¿verdad? Por lo que segundo más primero es lo mismo que primero más segundos veces. Alguna multiplicación tampoco importa. División de resta, en realidad importa de qué manera, Lo que viene primero y lo que viene segundo. Pero creo que eso es yo creo que eso fue como matemáticas básicas de secundaria. Eso debe ser resuelto. Correcto. Y entonces tenemos a2. Ahí lo tienes. Entonces eso realmente funciona también. Y hay una cosa más que probablemente vas a ser como, ¿qué hace otra sin embargo? Esos fueron los cuatro que conozco, sí, pero también hay uno que se llama el módulo o el resto. Ahora, probablemente tienes, si tal vez eres como Arno, como noveno grado, tal vez décimo grado, tal vez has visto esto antes. Esta es la idea es que si divides algo por otra cosa, en este caso, era perfectamente parejo. Por lo que funcionó bien. Pero también podría ser que si divides 13 por 213 dividido por dos, eso no es, eso no va a funcionar, ¿verdad? Entonces eso va a ser, uh, no va a encajar perfectamente. Y así tendremos un remanente de uno en este caso. Entonces, solo veamos un ejemplo de esto. Entonces el resto, el resto es igual a 24, digamos, y luego el operador restante, el operador de módulo es el signo de porcentaje 2 y esto sería 0. Entonces, en realidad pongamos esto aquí también. Entonces esto va a ser, correcto, esto va a ser 0 porque 2 encaja uniformemente en 24. Entonces si dividimos 24 por dos, como pueden ver, 0 resto aquí. No obstante, si nosotros, por ejemplo, vamos a esto y decimos divididos por o modulo 5, entonces esto ya no va a ser 0. Hagámoslo solo. Son cuatro porque el número más cercano al que llegamos dividiendo por 5 es 20, ¿verdad? Por lo que cuatro veces cinco es 20. Y luego para 24, básicamente quedan cuatro números. Por lo que quedan los cuatro aquí. Yo quiero hacer esto con un 23 sólo rápido porque 4 veces 5 podría ser tal vez un confuso. Va a haber tres, así que llegamos a 20 y luego cinco no encaja en tres. Por lo que tres es el resto. Esa es la idea ahí. En realidad es algo importante en algunos aspectos. Por lo que el modulo 2 es genial para saber si un número es par o no impar. Porque si tienes operador de modulo entero 2 es igual a 0, entonces ya sabes, este es un número par. Y si es igual a uno, entonces sabemos que es un número impar. Entonces ese es uno de los casos de uso donde el operador modulo o resto es increíblemente útil en este caso. Y por supuesto, otros tipos de operadores aritméticos también son útiles en, bueno, me refiero a muchas maneras. Si alguna vez has necesitado algo en matemáticas, es decir, sí, esas son increíblemente útiles y esa es una especie de primer paso conocer o para reunir algún conocimiento sobre cómo usar enteros. En este caso. En teoría, todo aquí dentro. También podrías reemplazar todo aquí por carrozas o dobles. Y todo funcionaría bien también. Por lo que puedes hacer eso, por ejemplo. Experimenta alrededor de un poco con eso. Siempre trato de alentar eso también porque si bien las conferencias aquí son realmente buenas para una especie de salir de cabeza o tener una forma estructurada de pasar por algún material. Siempre animé y digo que es muy importante que pruebes las cosas por tu cuenta también. Porque esa es la mejor manera de solidificar y aprender aún más. Entonces si por ejemplo, vas a mirar esto con flotadores, solo reemplaza todos los enteros por flotadores y ve qué sucede. Y luego puedes jugar un poco con eso. Y sí, eso es solo una pequeña idea para ti. Y sí, en general es decir, eso sería todo para los enteros y los operadores aritméticos. La próxima vez vamos a echar un vistazo a un poco más de los métodos matemáticos que tenemos en C-Sharp. Entonces un poco más, digamos especializarnos cosas como una raíz cuadrada o algo así, que a veces podríamos necesitar para cosas diferentes. Entonces eso es lo que viene en la próxima conferencia. Espero que esto te haya sido útil. Y si hay alguna pregunta, como siempre, siéntete libre de preguntar y me aseguraré de responder. Y sí. 7. (C#) Métodos) Math: Muy bien, bienvenidos de nuevo la C aguda introducción aquí para el curso de unidad. Y en esta conferencia vamos a echar un vistazo a algunos métodos matemáticos que C-sharp tiene para ofrecer para nosotros. Por lo que una vez más, se asegura de que la conferencia para los métodos de Matemáticas esté abierta y luego simplemente podemos abrir el guión. Y ya he preparado dos enteros aquí, x e y. y vamos a ver qué tipo de métodos tenemos. Ahora, lo primero que hay que señalar, hay dos tipos diferentes de matemáticas, básicamente bibliotecas a las que podemos acceder. Podemos acceder a la biblioteca de matemáticas normal con básicamente haciendo matemáticas de punto del sistema. Y esta nos ofrece algunas cosas como los métodos maxing, maximum, max y Min, la raíz cuadrada y también algunas otras cosas. No obstante, esto es específico de C-sharp. No obstante, vamos a utilizar la matemática F, Básicamente colección como se puede ver. Y éste ofrece cosas específicas, básicamente casi las mismas, pero métodos específicos que son para la unidad. Por lo que esto sólo es accesible si estás en Unidad. Si no, entonces necesitas usar este método de matemática system.Out en, por ejemplo, ¿verdad? Entonces lo primero es lo primero, ¿qué tal como max y min? Ya he estropeado eso. Hagamos un registro de puntos de depuración. Y luego dentro de ella, vamos a hacer matemáticas F punto Min. Y luego vamos a pasar en x, y. y éste debería ser 225. Entonces la idea aquí es que esto haga matemáticas F punto Min. Y luego como pueden ver, tenemos un paréntesis alrededor de esto. Y así denotando que se trata de una llamada de método. Ahora en este caso, y no hemos visto esto. En realidad tenemos dos cosas ahí dentro. Y así esos son los que llamaríamos parámetros. Como dije, vamos a ver cómo funcionan los métodos de manera, mucho más detalle en una conferencia posterior donde hablamos de métodos y profundizamos en cómo funcionan y qué son y qué es esto. No obstante, ahora mismo, podemos ver que aquí tenemos dos premisas, y están separadas por una coma. Y esto evaluará si realmente pasamos sobre él, como se puede ver, devuelve el más pequeño de dos o más valores. Por lo que también podemos poner más valores. En nuestro caso sólo tenemos dos. Y esto es, por supuesto, eso no está bien. Entonces esto sería un 100, lo siento. Entonces si minamos esto, va a devolver el más pequeño de esos dos valores. En nuestro caso va a ser un 100. Y sólo para estar completamente lleno aquí, vamos a cambiar esto a max y entonces esto va a ser 225. Porque el máximo por supuesto, devuelve el más grande de dos o más valores. Vamos a salir esto y a ver si eso funciona. Por lo que éste debería ser un 100 y luego 225. Y como se puede ver, se está registrando el primer centenar, doscientos veinticinco. Entonces vamos a ver. Entonces esos son el método Min y el max. También podemos mirar, por ejemplo, una raíz cuadrada, ¿verdad? La raíz cuadrada, Vamos a copiar rápidamente la depuración aquí. Y luego vamos a hacer matemáticas F puntos raíces cuadradas. Entonces esto es SQRT. Y luego dentro de aquí, vamos a poner en y. porque y en realidad puede ser como un cuadrado enraizado inmediatamente. Esto va a entrar en ser un 15. Raíz cuadrada de 225. Y simplemente no veamos la salida todavía. Pasemos a la siguiente, que va a ser el valor absoluto. Por lo que el valor absoluto se usa básicamente si tienes algo que es negativo. Entonces por ejemplo, negativo 2500. Y solo quieres el valor absoluto y no el negativo. Por lo que no te importa si es o no negativo o positivo, solo te importa el valor real. Se puede ver devuelve el valor absoluto de valor. Entonces lo que sea que pongamos aquí, va a devolver el valor absoluto. Sólo veamos las salidas de esos dos. Entonces el primero debe ser 15, esa es la raíz cuadrada de 225. Exactamente. Y el último, claro. El último no abrió. Ah, porque no salvé. Por eso sí. Se van. Y luego si entro aquí otra vez y golpeo Play, entonces va a salir 2500. Van porque ese es el valor absoluto del 2500 negativo. Y luego hay unas cuantas cosas más. Por ejemplo, los métodos de sellado y piso, que son interesantes, por ejemplo, para pozo de techo y pisos. Siendo la idea que si tienes números flotantes específicos, así que eso va a ser sello como tus números flotantes flotantes flotantes. Entonces por ejemplo, 22.1, 45. Entonces tal vez lo que queremos también, en realidad, queremos un redondeado, pero queremos redondearlo, uh, independientemente de lo que esté después del punto decimal. Y entonces esto va a ser un 23. Y si solo hacemos esto rápidamente y luego hacemos piso aquí, y esto va a ser un 22 porque en este caso estamos, estamos redondeando hacia abajo. Entonces como puedes ver, devuelve el entero más grande, más pequeño o igual a f, lee. Y el sello va a ser el entero más pequeño mayor o igual a f simplemente significa que estamos básicamente, cuanto esto sea como 0.0001 acero, vamos a subir y luego en este caso vamos a bajar. Entonces en este caso, vamos a ir al techo. Este caso vamos a ir al uso de la palabra. Deberían tener sentido de esa manera. Pero sí, esos son básicamente para redondear hacia arriba y hacia abajo. Específicamente, también tenemos una ronda. Creo que deberíamos tener una ronda. No soy un 100 por ciento seguro. Sí, sí tenemos alrededor. Entonces una ronda, se va a redondear al entero más cercano. Esto también debería hacer un similar a una salida 822. Porque en este caso, sí. Oh, no lo hizo, no volví a guardar, lo increíble. Esto es muy poco común, pero también debería abrir un 22 y lo hace. Por lo que el redondeo simplemente sigue lo normal. El redondeo normal rige, supongo que también tenemos el poder de, así que si pudiéramos tener algo como Math.Pow, esto es tan diez al poder de dos. Por lo que esto sería diez al poder de 2 es igual a 100. Podrías por supuesto, también hacer 10 veces 10 también funcionaría. No obstante, a veces se necesita poner algo al poder de algo. Entonces para eso los poderes. Por lo que regresa F elevado a la potencia p. Y entonces el último, que podría ser, podría ser interesante, es básicamente sujetar la variable variable Val de sujeción entre dos valores. Esto es algo muy específico que podría utilizarse específicamente para la unidad. Y en realidad no vamos a imprimir nada porque eso no es porque, bueno, no hay nada que imprimir en este momento. No obstante, la idea de haz, y vamos a ver esto en otro ejemplo más adelante por la línea también. Pero la idea es que la pinza, como se puede ver, sujeta el valor dado. Por lo que esta sería velocidad Teniendo en cuenta el mínimo y el máximo. Entonces la idea es que la velocidad en este momento era un 100. Y podríamos imaginar tal vez por ejemplo, un juego de carreras donde realmente aceleramos o disminuimos la velocidad. Debe haber en algún momento esa velocidad máxima. Y si sólo tenemos algo que es cheques, Hey, es este botón presiona hacia abajo y luego agrega velocidad a velocidad a velocidad. Y entonces podríamos imaginar, bueno, en realidad sujetar esto hacia abajo. Por lo que básicamente va a asegurarse de que esta variable de velocidad esté dentro de esos dos valores mínimo y máximo. Pero como dije, una mejor, vamos a ver una mejor, Digamos caso de uso para esta naranja, en realidad use caso para esto más adelante por la línea también. Yo sólo quería mencionar esto. Aquí hay algunos otros métodos interesantes. Por ejemplo, hay un seno, seno y tangente. Entonces está esto básicamente casi todas las cosas que podrías necesitar para las matemáticas. Hay infinidad, creo. Si veo, sí, pi también está ahí. Por lo que hay bastantes cosas con las que puedes echarle un vistazo y jugar también. Pero esto es sólo una especie de visión general en este momento. El poder para sellar valor absoluto, raíces cuadradas, valores Min y max. Esos son los que en mi experiencia son, bueno, yo diría que los más útiles pero más utilizados, sobre todo el minimax, se usan bastante. Pero sí, esa es una introducción general a los enteros y que los métodos matemáticos. Y sí, eso fue todo para esta conferencia. Espero que lo hayan encontrado útil. Si hay alguna pregunta, por supuesto, siéntase siempre libre de preguntar y me aseguraré de responder. Y sí. 8. (C#) Operadores de proyectos: Muy bien, bienvenidos de nuevo a la introducción C-sharp aquí para el curso de unidad. Y en esta conferencia vamos a echar un vistazo a los operadores de asignación. Ahora ya hemos visto al operador de asignación estándar. Ahí fue donde simplemente asignamos un valor a una variable. Pero hay algunos casos especiales en algunos operadores de asignación que hacen que sea un poco más fácil calcular básicamente cosas. Entonces, solo abramos el script de asignación aquí, y empecemos con un entero simple llamado I. Haz que esto sea igual a uno. Ahora bien, si por ejemplo, quisiéramos agregar uno a esto y luego guardarlo de nuevo en I. Podríamos hacer I igual a yo más uno. Esto no debería ser demasiado loco y en realidad debería ser una especie de autoexplicativo. Simplemente asignamos el valor de I más uno porque soy uno. En este caso, vamos a, vamos a calcular 1 más 1, y luego cuando lo guarde de nuevo en la variable misma, así que en este caso esto sería 1 más 1. Vamos a escribirlo así. Ahora. Podemos escribirlo así, totalmente bien. También podemos escribirlo así. I plus es igual a 1. Y esto es funcionalmente equivalente a esto. Entonces simplemente vamos a agregar uno a la variable original I, y luego le vamos a asignar esa variable. Por lo que en este caso esto sería 2 más 1 es igual a 3. Entonces porque después de la línea 13, tenía 22 y me voy a llevar 21 a ella. Y luego lo vamos a volver a escribir en I. Así que en este caso esto serían tres. Ahora hay otra cosa que podemos hacer y esa es yo plus, plus. Y esto hará exactamente lo mismo también. Entonces esto sería, en este caso, yo más 1. Y debido a que tengo tres, esto sería un cuatro. Entonces también podemos hacer yo menos, menos, y esto luego se convertiría en i negativo uno o menos uno y eso es entonces un tres. Entonces esos son algunos básicos, básicamente cómo se puede condensar la adición de una variable. En este caso, se puede, por supuesto, trazar el plus igual. Puedes escribir lo que quieras. Puedes escribir un 12014, otra variable, lo que quieras. En el plus, plus, eso siempre va a ser un más uno o uno menos. Esto sería lo que se llama incremento o incremento y decremento. Y eso es realmente útil para algún tipo de estructuras que vamos a ver en C-Sharp bajando por la línea. Ahora este plus es igual, en realidad podemos hacer otras asignaciones también. Entonces como ustedes han visto, así tuvimos un plus igual. Entonces digamos por ejemplo, más es igual a 5 y 14, ¿verdad? Esto sería entonces un 17 igual a 17, algo así. Entonces podríamos hacerlo menos igual a sólo por el bien de la discusión ahora mismo este menos dos conducirá a un 15, ¿verdad? Por lo que también podemos hacer menos iguales. También podemos hacer a veces iguales. Hagamos dos otra vez. Por lo que esto sería un 15 veces 2 es igual a A3. Y entonces podemos, por ejemplo, hacer dividir igual también, dividir por tres. Por lo que esto sería 30 dividido por 3 es igual a 10. Y luego al final, también podemos hacer modulo igual y eso sería un 10. El modelo más de cuatro es igual a 2. Ahora bien, rara vez he visto lo modular es igual en realidad, pero los otros podrían realmente ser realmente útiles en algún momento por debajo de la línea. Y como ya dije en una conferencia anterior, puede ser el caso de que si bien podría no usar algunos de esos operadores, Alguien más podría usarlos. Y si no sabes cuáles son, entonces vas a tener más difícil leer el código de otras personas. Por eso siempre digo que aunque lo seas, tienden a no usar algo donde aunque seas como, Bueno, tal vez lo guardo así porque una vez más, esto es completamente lo mismo que éste, ¿verdad? Por lo que escribir I igual a I plus 1 es lo mismo que igual a 1. Algunas personas simplemente dicen, bueno, esto es simplemente más fácil de leer. Entiendo así mejor. Algunas personas dicen que entiendo mejor de esta manera. Definitivamente eso es solo una elección de estilo. Y puedes hacer cualquiera de ellos. Cuando se trata de rendimiento. Realmente no hay diferencia. Entonces sí, esos son los diferentes operadores de asignación también. Sí, espero que eso te resulte útil y aprendas algo nuevo. Si hay alguna pregunta. Por supuesto, siéntete siempre libre de preguntar y me aseguraré de responder. Y sí. 9. (C#) Booleans y operadores de comparación: Muy bien, bienvenidos de nuevo a la introducción C-sharp para el curso de unidad. Y en esta conferencia vamos a echar un vistazo a los booleanos y específicamente a las comparaciones y cómo poner a cómo escribirlos en variables booleanas. Entonces, solo abramos el guión booleano y veamos qué podemos ver. Por lo que recordando de nuevo, teníamos la variable es a tierra y vamos a poner esto en falso. Y Austria, recuerden, los booleanos eran unos valores de verdad que podemos establecer como verdaderos o falsos. Por lo que pueden ser sí o no, uno o 0. Eso fue lo esencial de ello. Y tal vez por ejemplo, tenemos un booleano que se llama x. Y entonces a lo que realmente queremos asignarlo es a un cálculo. Entonces un cálculo booleano o simplemente una expresión, una expresión booleana, por ejemplo, dos es menor que cinco. Esta sería una expresión booleana. Como se puede ver, el a, un operador, el operador más pequeño agregó esto devuelve un booleano. En este caso, esto sería cierto porque 2 es menor que cinco si fuera al revés. Entonces por ejemplo, de esta manera, entonces dos serían más grandes que cinco y esto sería falso. Entonces esta es la idea de un operador de comparación. Podemos por supuesto también tener un bully bool. ¿Por qué? Por ejemplo, 10 es, 10 es mayor que 50. Y esto por supuesto, sería falso, ¿verdad? Porque por supuesto Sen no es mayor que 50. Y por eso la expresión aquí es falsa. Hay un montón de diferentes operadores de comparación. Por lo que hemos visto los más pequeños que, más grandes que mayores o iguales, más pequeños o iguales, iguales y no iguales o desiguales. Entonces esto sería, por ejemplo, esto es como un 100 igual a un 100. Esto sería cierto, ¿verdad? Y esto se debe a que en este caso, un 100 es exactamente igual a un 100. Ahora, como puedes ver, esto a veces puede parecer un poco confuso porque el operador igual son dos signos iguales y el operador de asignación es un signo igual. Eso es algo que definitivamente tienes que cuidar porque a veces o te olvidas de uno de los signos de igualdad o tal vez solo estás programando con entusiasmo y luego solo supervisas que o solo has puesto en un signo o dos signos iguales. Esas son cosas completamente diferentes y no tienen nada que ver entre sí. Una es la expresión booleana para ver si dos variables o dos cosas son iguales. Y el otro asigna un valor a una variable. Justo como una nota rápida. Y entonces, por ejemplo, podemos tener algo como esto. Entonces 51, desigual, 50. Y esto por supuesto también sería cierto. Y esto es un desigual. O qué otra cosa podría ser, no igual, algo así. Pero esos son los operadores de comparación. Por lo que pueden ser increíblemente útiles para comparar diferentes variables entre sí. Es algo más grande o igual a algo, es simple igual a otra cosa. Aplicaciones increíblemente útiles y generalizadas que vamos a ver en las próximas conferencias también. Pero eso es todo. Al igual que una breve introducción a los operadores booleanos y de comparación. Si hay alguna pregunta, por supuesto, siéntase siempre libre de preguntar y me aseguraré de responder. Y sí. 10. (C#) Booleans y operadores lógicos: Muy bien, bienvenidos de nuevo a la introducción C-sharp aquí para el curso de unidad. Y en esta conferencia vamos a echar un vistazo a los booleanos una vez más. Por lo que acabemos de reabrir el guión booleano aquí. Y en este caso, lo que vamos a ver no son los operadores de comparación, pero vamos a mirar a los operadores lógicos. El hecho de que tuviéramos estas expresiones booleanas como a menores de cinco o 10 es mayor que 50, lo que podría ser cierto o falso. Por lo que eran expresiones o declaraciones que o eran verdaderas o falsas. Por lo que fueron expresiones booleanas. Y ahora en realidad podemos encadenar esos juntos. Entonces por ejemplo, hacemos, vamos a hacer un nuevo booleano aquí, B2. Y entonces lo que podemos hacer es decir x e y. entonces si hacemos este doble signo de ampersand, entonces esto va a ser, esta es una operación final. Y la idea aquí es que va a ser x e y. ahora x es verdadera y y y es falsa. Por lo tanto, esta declaración entera no se cansa aquí también es falsa porque se trata de un operador AND. Y el operador básicamente es cierto si ambas declaraciones estatales son ciertas también, entonces hay otra que es el operador OR. Entonces esto, por ejemplo, podemos tomar está a tierra o B. Y esto en este caso sería cierto. Ahora la razón es porque B es verdad, ¿verdad? Entonces sabemos que B es verdad. Tu B era un 100 igual a un 100. Y eso es cierto. Y el operador OR básicamente es cierto si uno de los dados, si uno o ambos de los booleanos dados o declaraciones es cierto. Y luego hay una última cosa que hemos visto antes, y eso es sólo el signo de exclamación. Y que simplemente esto simplemente invierte lo que se da. Entonces en este caso, este es básicamente el operador NOT. Entonces no cierto es sólo falso, ¿verdad? Por lo que esto simplemente voltea o invierte el valor booleano. Entonces, en teoría, lo que podríamos hacer es poner los paréntesis alrededor de esto. Podría ponerle un signo de exclamación delante de él y luego negaría todo lo que hay en el año. Y también son como matemáticas de fantasía que puedes usar. Las palabras que buscarías, eso serían ya sea mesa de verdad o álgebra booleana. Y así te imaginas tal vez tienes algo loco como esto, ¿verdad? Tienes que B2 y B4, o B3 y x o y, o qué tal o ver a alguien así, ¿verdad? Entonces no podemos tener algo loco como esto. Sería, funciona totalmente bien si tuvieras, por supuesto, básicamente que evaluar cada uno de ellos por separado. Pero posiblemente también puedas simplificar algo como esto a una versión mucho más pequeña de la misma función básicamente que tenemos aquí. Bueno, la misma expresión y esta fue, esto es lo que se llama álgebra booleana. Por lo que podríamos simplificar esto. No voy a, si sin embargo, hay como muchos intereses en esto, puedo hacer una conferencia separada para ello. No obstante, yo diría que rara vez es realmente necesario. Es más algo teórico y eso es realmente importante en la informática teórica y por supuesto a veces también la informática aplicada. En este caso, cuando tienes declaraciones increíbles, increíblemente largas como booleanas, entonces tiene sentido mirar cómo tal vez puedes hacerlas un poco. Tanto más fáciles de entender como también puede ser más fácil de evaluar. No obstante, como dije, no es necesariamente lo más importante. No obstante, si hay suficiente interés frente a la gente, quiero ver eso, entonces estoy feliz de hacer una nueva conferencia sobre esto. No obstante, ahora mismo este es el, básicamente los operadores lógicos, el operador AND, el operador OR y el operador NOT o el reverso. Es decir, se llama el operador NOT. Y sí, esos son básicamente los tres principales operadores lógicos, que con los que básicamente se puede hacer todo en lógica. Y sí, esos son los dos términos que tú, si quieres, quizá mira algunas otras cosas también que tienen que ver con eso. Esos son los dos términos que debes mirar. Y si hay alguna pregunta respecto a esto, por supuesto, siempre siéntete libre de preguntar y me aseguraré de responder. Y sí. 11. (C#) C# y métodos de cuerdas: Muy bien, bienvenidos de nuevo a la introducción C-sharp aquí para el curso de unidad. Y en esta conferencia vamos a echar un vistazo a las cuerdas. Por lo que una vez más, asegurándonos de que estamos en la Conferencia 8, cuerdas aquí arriba. Si no, simplemente puedes ir a la carpeta Escenas y abrirla. Y luego asegurándonos de que dentro de nuestra carpeta de scripts, hacemos doble clic en estos scripts de cadenas. Y aquí estamos dentro de nuestro guión. Y empecemos simplemente haciendo realmente una nueva cuerda. Entonces la frase de cadena, por ejemplo, hagámoslo decir helloworld. Esto, esta conferencia es maravillosa. Bueno, esperemos que eso sea cierto. Pero antes que nada, como ya hemos visto, la idea de una cadena es que se trata de múltiples caracteres uno al lado del otro. Y lo primero que vamos a ver es básicamente una vez más, la longitud. Ya hemos visto esto antes. Entonces la longitud de la cuerda. Y esto fue, pudimos acceder a eso escribiendo el nombre de la variable, en este caso frase. Y podemos autocompletar eso con lengüeta y luego longitud de punto, la longitud. Y entonces también podríamos autocompletar eso con tab. Y después de que hayamos salvado, podríamos simplemente cambiar de nuevo a Unidad. Y vamos a ver. El largo es de 39. Bueno, eso es genial. Entonces volvamos. Y vamos a ver. Por lo que la longitud de la cuerda puede ser útil en muchas partes diferentes. Por ejemplo, a veces, tal vez queremos como subcadenas o ciertas partes de una cadena y entonces necesitamos saber la longitud. Eso lo voy a ver muy pronto. En primer lugar, veamos en mayúsculas y minúsculas. Esto podría ser útil, por ejemplo, si desea, independientemente de cierta entrada, verificar si esa entrada es o no la misma. Pero en este caso, sólo vamos a convertir básicamente la sentencia en gritos. Entonces vamos a escribir en sentencia punto dos superior en este caso. Como se puede ver, esto es, esto termina con paréntesis, lo que significa que se trata de una llamada de método, por lo que esto llama a un nuevo método. Y luego podemos simplemente volver a copiar esto básicamente simplemente seleccionando el registro de depuración, presionando Control C y luego Control V para pegarlo. Y esto va a ser para bajar. Y esto va a ser, por supuesto, susurrando. ¿ Verdad? Y luego, sí, veamos eso. Por lo que ducharse solo a arriba solo va a hacerlo todo en mayúsculas. Y para bajar es solo va a hacer de todo, cada personaje de esa frase a minúsculas. Entonces como puedes ver, gritar va a ser mayúscula y luego susurrar. Todo es minúscula. Como dije, lo a veces lo que es interesante una aplicación para esto es básicamente hacerlo para que lo que sea, independientemente de mayúsculas o minúsculas, puedas comparar dos cadenas entre sí y ver si siguen siendo lo mismo independientemente de si todo está o no en mayúsculas o minúsculas. Y, bueno, sólo veamos la frase en sí. Entonces la propia primavera. También imprimamos ese fuera. Simplemente, sólo por el bien de la discusión. Bueno, lo que nos respetamos que todo está desacelerado, pequeño pero son minúsculas, pero como puedes ver, los H y W en realidad siguen en mayúsculas. ¿ Qué, Por qué es eso? Bueno, la idea es que a pesar de que aquí hemos llamado a este método, como se puede ver, en realidad dice string y luego dice string dot two oper. Entonces la idea es que este realmente tipo de ella, devuelve una nueva cadena. Por lo que es, la sentencia en sí no se está modificando. Y eso sucede con algunos de los métodos. Creo que es casi todos estos métodos de cadena en realidad no cambian esta variable original o incluso el valor. Siempre devuelven una nueva instancia de esta variable que luego se cambia. En este caso, sierra mayúscula todo es grande. Y luego éste, todo minúscula. A lo mejor lo que queremos es saber dónde hay algo dentro de esa cuerda. Y podemos usar index-off para eso. Entonces, solo hagamos un bloqueo de depuración otra vez. Y luego vamos a encontrar la palabra conferencia. El palabra conferencia encontrada en posición. Y luego pongamos la posición aquí con hacerlo haciendo de la oración punto índice apagado. Y entonces podemos pasar en una cuerda aquí. Y vamos a decir conferencia, oh, eso no está bien. Ahí tienes, conferencia. Y esto va a devolver el índice de donde empiezan los electrones. Entonces vamos a ver qué, solo contemos primero. Entonces 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 , 11, 12, 13, 14, 15 , 16, 17, 18, 19. Entonces, veamos si realmente conseguimos 19 o lo que estamos obteniendo. Estamos recibiendo 18. Bueno, eso no es tan raro? A la OIM le gusta contar mal? No, no contábamos mal. Bueno, lo hicimos de alguna manera. Pero no. La idea es que una frase, el primer carácter aquí, el primer char aquí es en realidad 0. Por lo que en realidad tenemos que empezar a 0. Y si empezamos a contar en 0, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18. Entonces vemos que la L de conferencia en realidad se encuentra en la posición 18 porque empezamos a contar en 0 y eso es realmente importante, empezar a contar en 0. Entonces eso es algo importante en la programación. La mayoría de los lenguajes de programación comienzan por ahí, cuentan tanto de cadenas como de otros tipos de datos en 0. Tipo de importante saber. Porque a veces puede llevar a rarezas. También hay algunos otros lenguajes de programación donde ese no es el caso y el conteo comienza en 1. No obstante, es realmente confuso cambiar entre los dos. Por eso digo, vale, empieza el conteo a 0. Muy importante. También hay un método de reemplazo. Por lo que en este caso, el método replace reemplaza a todas las, todas las instancias de una frase en particular, básicamente. Digamos que se llama el método de reemplazo y queremos reemplazar mundo por estudiantes. Y la idea es que, oh, sé por qué el ego, por eso el, toma dos cuerdas. El primero es la cadena que se va a reemplazar y luego la segunda cadena es con la que se supone que debe ser reemplazada. Entonces en este caso, lo que va a pasar es que la salida va a ser hola estudiantes. Esta conferencia es maravillosa en lugar de hola mundo y esta conferencia es maravillosa. Vamos a ejecutar esto y a ver si eso funciona. Sí, Hola alumnos. Esta conferencia es maravillosa. Y una vez más, no olvides que esto no es modificar las frases originales, en realidad dándonos una nueva. Entonces lo que podemos hacer es también podemos, cuando tenemos una nueva cadena, por ejemplo, cadena S, eso sólo va a ser una cadena vacía. Por lo que esta sería una cadena vacía. También podemos decir strings.xml para una cadena vacía, pero esos son básicamente los mismos. Entonces lo que podemos hacer es básicamente tener un booleano. Por lo que podemos llamar a cadena es nulo o vacío. Pase en una cadena, en este caso S. Y esto va a devolver verdadero si la cadena aquí es nula o vacía. Y va a devolver un falso si la cadena no es nulo, novedoso, ni vacío, ¿verdad? Y también podemos ver si como lo que una cierta cadena empieza con un, con qué termina, puede ser útil en momentos muy diferentes. Sólo tomemos este. Esto va a ser de Stuart con, y esta es frase empieza con, empieza con retornos un booleano. Entonces básicamente podemos decir, oye, ¿empieza con una H? Y entonces podemos decir que termina con. Y entonces sólo rápidamente a éste, termina con, y digamos que termina con un gran a. Y eso por supuesto no es cierto. Entonces esto sería cierto. Y esto sería falso. Eso está formateado muy bien. Ahí tienes, Eso es genial. ¿ Verdad? Veamos eso después de que hayamos mirado el siguiente y el siguiente es el método contiene. El método contiene simplemente devuelve verdadero o falso. Entonces un valor booleano si algo está contenido en él o no. Entonces digamos que queremos saber si la sentencia contiene mundo o no. Esto es, por supuesto, cierto porque qué mundo es la segunda palabra aquí. Y una vez más, el sustituto no sustituyó a la frase. En realidad creó una nueva especie de cadena en el fondo. Entonces veamos. Sí, empieza con una H. empieza con una H, H mayúscula, y luego termina con una a grande, que era una a mayúscula y que tiene pliegues. Y entonces es cierto aquí para el contiene el mundo de cuerdas. También hay una especie de manera diferente. El índice aquí era un entero. Entonces básicamente el número donde comienza la L de la conferencia, también podemos hacer que sea al revés para que realmente podamos conseguir un personaje en posición. Entonces vamos a ponerlo en la posición 10. Y la forma en que hacemos eso es que básicamente estamos escribiendo la frase del nombre. Y luego hacemos estos corchetes y luego tecleando en cualquier posición que sea la que queramos. Entonces esto devuelve un personaje. Y en este caso sería, supongo el D, creo uno. Entonces 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10. Sí. Por lo que esto devolvería el D aquí en el mundo. Y algo que también tiene que ver con eso es la subcadena donde también necesitamos especificar posiciones. Y ahora en sí, así que vamos a hacer debug log oración punto subcadena y E Una vez un índice de inicio, y luego quiere la longitud, va. Entonces básicamente la subcadena, lo que quiere es saber, vale, ¿ dónde empiezo y luego por cuánto tiempo voy? Entonces en este caso, esto debería comenzar por la t y terminar En, no estoy seguro, realidad, 123456789, 10, 11, supongo. Tour. Bueno, vamos a ver de eso. Veamos que en realidad es el caso. Veamos qué va a traer eso. Entonces la subcadena en realidad es sí, y eso también tiene el espacio ahí dentro. Y elegir a esta conferencia. Y como se puede ver aquí, la D también es salida este tramo dos. Entonces esto sería 12 y no comenzaría a los 13, creo que si queremos, queremos que imprima esta conferencia, Hagamos eso. Y van Esta conferencia, genial. Eso es exactamente lo que quiero, ¿verdad? Y esa es una subcadena en este caso donde tenemos, cuando tomamos una parte particular de la cadena y creamos otra. Entonces, una vez más, no modificamos la cadena en sí. El modo en que modificaríamos la cadena podría ser algo así como esta frase, subcadena de punto de oración por ejemplo. Y entonces lo que pasaría es que crearía este do substring y luego guardaría de nuevo en la frase misma para que la variable misma, para que funcionara. No obstante, no vamos a hacer eso en este punto. Eso en realidad no es exactamente lo que necesitamos en este momento. Lo último que quiero mostrarles es si tenemos una cadena y entonces tal vez lo que queremos en esta cadena es que queremos tener cotizaciones. Ahora, el tema es que en cuanto escribo entre comillas, termina la cadena, eso es por supuesto, no del todo lo que queremos. Y lo que podemos hacer es hacer una de esas varillas invertidas. Y esta barra inversa es básicamente un personaje de escape para que el programa sepa que, de acuerdo, esto ahora está realmente destinado a ser comillas que en realidad están dentro de una cadena. También hay algunas otras cosas como la barra inversa t, barra inversa, barra inversa, barra inversa. Si quieres teclear una dirección inclinada. Esos son básicamente los principales. Por lo que las citas de barra inversa, barra inversa t, barra inversa n. Así que el enseñar simplemente MIX tab. Entonces si presionas tabulador, tabulas sobre un cierto número de espacios y hace una nueva línea. Y la Barra invertida, la Barra invertida simplemente escribe en una nueva Barra invertida. Entonces como personaje, lo mismo con, lo mismo que con estas comillas, ¿no? Sí, esos son el tipo de cosas principales sobre las cadenas y algunos de estos métodos de cadena. Una vez más, te imploro que mires a algunos de esos tú mismo. Hay unos cuantos más. Entonces si solo miramos esto, lo que podemos ver, también hay comparar iguales, hay inserto, um, hay un método remove. Entonces hay algunas otras cosas que podemos hacer también. Como dije, te imploro que los mires. Eso es sólo una visión general de los resortes, generalmente sobre todo en el propio desarrollo del juego. No es la manipulación de cadenas no es tan común como tal vez en algunos otros campos. No obstante, a veces nunca se sabe lo que se va a conseguir. Por lo que lo mejor es saber de estas cosas y haberlas echado un buen vistazo. Espero que esto les haya sido informativo. Si lo fue, entonces yo, por supuesto, agradeceré una crítica de ustedes. Y si hay alguna pregunta, por supuesto, como siempre, siéntete libre de preguntar y me aseguraré de responder. Y sí. 12. (C#) Variables de fundición: Muy bien, bienvenidos de nuevo a la C aguda introducción aquí para el curso de unidad. Y en esta conferencia vamos a echar un vistazo al casting. Ahora, el casting quizá no te diga nada. El término podría estar bien. ¿ Qué es el casting? Bueno, sólo echemos un vistazo abriendo aquí el guión. Y la idea es que veamos, tenemos una variable llamada préstamo, que es 750, y es un entero. Ahora, lo que también tenemos es un flotador llamado la tasa de interés. Y eso va a ser, digamos como 5.25%. Por lo que esto puede escribirse como 0.05 a cinco. Ahora lo que podemos hacer es decir, bueno, el dueño de casa calcula los intereses. Bueno, el interés simplemente va a ser el préstamo veces la tasa de interés, la tasa de interés que vas, ¿verdad? Entonces eso no va a ser demasiado loco de un cálculo y debería ser bastante sencillo. Y entonces también asegurémonos de que solo registramos el interés ahora mismo. Y veamos qué podemos ver. Qué va a salir de eso. Entonces va a salir de eso es 39.375, o digamos 39 punto, digamos 3, 8 dólares, digamos. Ahora bien, ¿cómo funciona eso? Acabamos de tomar un entero y básicamente lo multiplicamos con un flotador. Entonces viene la pregunta, ¿cómo funciona esa? Eso, eso es algo raro, ¿verdad? ¿ Por qué podemos simplemente tomar el entero y básicamente multiplicarlo con un flotador? Bueno, esto es lo que se llamaría fundición implícita porque los dos son números y eso funciona. Lo que no funcionaría es, por ejemplo, si dijera, bueno el interés ahora es un entero, entonces en realidad sería un que no funciona porque como se puede ver ahí, dice no puede convertir implícitamente a tipo float a int es porque esto es un flotar. Y si tenemos un entero multiplicado por flotador, entonces se convierte en un flotador porque un flotador tiene más información que una interrupción. No obstante, puedo decir explícitamente Hey, independientemente, tratar esto como un entero. Por lo que puedo decir bien int. Y entonces va a ser como Ok, claro, la tasa de interés ahora es un entero. El gran problema con eso va a ser, bueno, ¿qué significa eso realmente? Bueno, vamos a ver si todavía tenemos 39. Ahora conseguimos, obtenemos 0. ¿ Cómo obtenemos 0? Bueno, la idea es que un entero no tiene ninguno, nada después del punto decimal, ¿verdad? Por lo que un entero es siempre un número entero. Por lo tanto, esto se convierte en un entero. ¿ Y qué sucede cuando un flotador se convierte en un entero? Todo después del punto decimal, sólo se corta. Entonces básicamente lo que ve la tasa de interés después de que se está convirtiendo en un entero es 0. lo que la tasa de interés es 0, por lo tanto , el préstamo es 0, lo que por supuesto no tiene sentido. O si el interés es, pues, 0, lo cual no tiene sentido. Por eso queremos que esto sea un flotador. También podemos ver esto como otro ejemplo. Digamos que tenemos un entero x y solo vamos a decir algo así como 50.5 f más 20.6 f, ¿verdad? Y vamos a ahora un log esto fuera. Entonces veremos lo que esperaríamos. En este caso, un 71. Sí, 0.171.1. Ahora es un entero. Entonces lo que deberíamos ver es un 71, y de hecho vemos un 71. Por lo que una vez más, en este caso, esto sería en realidad 71.1. Y luego todo después del punto decimal se corta, por lo tanto, es 71. Y lo que también es interesante aquí es cuando dividimos algo, si dividimos, por ejemplo, un 100 por 200, F, por ejemplo, ¿verdad? Es amable, a veces es importante porque a veces una división no va a devolver números enteros. Entonces en este caso, es un número entero. Pero si nosotros, por ejemplo, fuéramos a hacer algo así y luego Claro, ¿por qué no dividir eso por doscientos doscientos F. Así dividiendo esto por un flotador. Y luego veamos qué es lo que realmente rinde. Como se puede ver, esto grita para apuntar al 55. Ahora bien, si tuviéramos que dividir esto por 200, y entonces también podemos decir que no flota, en realidad no importa. Tema siendo que este entonces es un dos. Entonces a veces es mejor si tenemos un flotador aquí, a veces lo mejor es trabajar con enteros. Una nota que realmente quiero dejar claro sólo para que tengamos esto fuera. Entonces usé este préstamo y la tasa de interés justo como ejemplo. Si alguna vez estás trabajando en un sistema bancario, ya sea en el interior de un juego o en la vida real, nunca uses números de punto flotante. Siempre hacer todo con enteros. Por lo que ahorra tanto el, tanto la cantidad total de dólares así como centavos en ambos enteros. Porque los números de punto flotante, como ya les he dicho, son propensos a errores. Y sobre todo en redondeo. Y realmente no quieres errores de redondeo cuando se trata de dinero, eso va a ser un verdadero gran problema. Solo quería mencionar que siempre usa enteros si haces eso igual que un rápido a un lado. Cuando otra cosa que podemos hacer es realmente podemos lanzar personajes. Entonces lo que podemos hacer es echar el personaje, por ejemplo, de las castas superiores, ocho, la superior, mayúscula a. Así que hagámoslo yAhora en realidad es genial aquí un poco porque el elenco es redundante porque en realidad puedo simplemente decir, bueno, int y es igual a una y eso funciona bien. Sólo lo vamos a mantener aquí sólo para que lo sepamos, vale, En realidad nos echamos. Y si entonces solo ejecutamos esto, podemos ver que es un 65. ¿ Por qué es ese 65? Bueno, esto viene de la forma en que los personajes están básicamente codificados. Y la codificación en segundo plano es sólo un número. Eso es todo lo que es. Por lo que en realidad podemos hacer algo como esto. Entonces podemos decir, por ejemplo, 50, bueno no vamos a 50, Vamos a hacer 12 más esto, verdad? Así que así. Y entonces también podemos lanzar el entero a un personaje y luego imprimir lo que sea que sea. Entonces básicamente vamos a ir de una y luego 12 codificaciones después. Veamos qué es eso. Eso debería ser un otro. Este es un M. Ahí tienes. Por lo que también hay alguna cantidad de formas en las que básicamente podemos calcular las cosas con los personajes también. Y esos son algunos de los fundidos básicos. Y también hay conceptos un poco más avanzados que vamos a echar un vistazo en una futura conferencia. Pero en este momento no tenemos las herramientas ni los conocimientos para que realmente sepa cómo funciona eso dondequiera que este sea un panorama básico en este momento. Por lo que realmente podemos convertir algunos tipos de datos en otros tipos de datos. La mayoría de las veces, implícito. Trabajos de colada implícita. Si pasas de un tipo de datos que tiene menos información a un tipo de datos que tiene más información. Entonces de un entero a un flotador funciona implícitamente. De un flotador a un int no funciona implícitamente porque pierdes información, principalmente en este caso siendo el, todo después del punto decimal, ¿verdad? Eso fue todo para la conferencia de casting. Espero que esto les haya sido informativo. Si hay alguna pregunta, como siempre, siéntete libre de preguntar y me aseguraré de responder. Y sí. 13. (C#) declaraciones condicionales (si y más): Muy bien, bienvenidos de nuevo a la introducción C-sharp para el curso de unidad. Y en esta conferencia vamos a echar un vistazo a los operadores condicionales. ¿ Cuáles son los operadores condicionales? Bueno, básicamente son algunas palabras clave que podemos usar para ver si algo es cierto o no falso. Y luego, dependiendo de si en este trofozoitos hacen ciertas acciones diferentes o ejecutan diferentes pelaje. Entonces, solo empecemos aquí el guión condicional. Y veamos qué podemos ver. Entonces como pueden ver, van a ser las declaraciones si y lo demás a las que vamos a echar un vistazo. Pero antes que nada, necesitamos algunas variables, así que vamos a tener una x y un por qué tan bien como un bool es buen curso. Y eso es, claro que va a ser cierto. Esperemos que eso también sea cierto, pero estoy bastante seguro de que lo es. Bueno, ¿qué podemos hacer? Bueno, solo tecleemos SI esta es la declaración if. Ahora lo que podemos hacer es que podemos presionar Tab dos veces y luego nos va a generar la forma en si se ve enunciado, como puedes ver, tiene paréntesis después del if. Entonces dentro de estos paréntesis hay una expresión booleana. Ahora esto puede ser tan complicado o tan fácil como te preguntas. Puede ser o simplemente un valor booleano, como cierto. Puede ser una variable booleana o como hemos visto en anteriores, uh, conferencias, los locos operadores de comparación booleanos o algo así. Entonces, solo tecleemos x es más grande que yY entonces si ese es el caso, entonces todo dentro de este alcance aquí se ejecuta. Así que digamos que debug dot log. Y luego vamos a decir que x es más grande de por qué van, bam. Y luego si ese es el caso, entonces esto se ejecuta. Ahora por supuesto, en realidad ya podemos ver que x es un 100 y y y es 1000. Por lo tanto, esto definitivamente es falso. ¿ Qué podemos hacer entonces? Bueno, entonces sólo podemos agregar una declaración else. Entonces se ejecuta el comunicado else. Si esto es falso. Entonces si esto es cierto, entonces esto se ejecuta. De lo contrario. Entonces si esto no es cierto, entonces esto se ejecuta. Y en este caso, x no es más grande que y. sólo ejempliquemos esto y veamos qué pasa. Una vez más, asegurándose de que estás en la Conferencia 10. Y luego como puedes ver, x no es más grande que y. y eso es lo único que se ejecuta. En cambio, lo que hemos visto aquí, lo que hemos visto antes fue que simplemente vamos directamente de arriba a abajo y todo, cada línea se ejecuta. En este caso, en realidad tenemos un condicional. Entonces esto es una especie de cosa de ramificación. En este caso. Depende de lo que pase aquí. Interesante. ¿ De qué otra manera podemos hacer esto o qué más podemos hacer con esto? Bueno, en primer lugar, una cosa a tener en cuenta es que, por ejemplo, si tenemos este es buen video, Es buen curso aquí. Lo que podemos usar es que en realidad no necesitamos tener estos corchetes. También podemos simplemente golpear Enter y después tener una línea que queremos hacer. Entonces sí, es bastante bueno, por ejemplo. Y esto luego se ejecuta. Si esto es cierto. También podemos, si acabamos de copiar esto. Y en este caso acabamos de poner en el, el booleano. También podemos decir explícitamente, Hey, esto tiene que ser cierto. Ahora esto no es necesario porque todo esto ya hace esto. No obstante, algunas personas prefieren esto porque lo hace un poco más explícito a lo que esto realmente significa. Entonces, ¿qué quiero con esto? Yo personalmente prefiero usar esta versión. No obstante, si crees que esto es más legible para ti, por supuesto puedes usar esto también. Lo que también quería decir es que, si sí usas la M esta forma de escribirla, entonces la declaración if y luego con la siguiente línea sangrada, diría que no es lo mejor que se puede hacer. Porque si alguna vez queremos agregar una nueva línea que también esté dentro de esto, si entonces necesitábamos agregar los corchetes rizados de cualquier manera. Por lo tanto, en realidad siempre es lo mejor que hay que hacer para agregar los corchetes rizados. Simplemente, yo sólo, quería mencionar esa, ¿verdad? Entonces veamos una última cosa. Entonces, por ejemplo, tenemos una calificación, por ejemplo, ¿verdad? Eso es, digamos algo así como 99. Entonces tal vez tú, acabamos de escribir un examen y la nota es del 99%. Y entonces lo que se podría imaginar es que tal vez lo que queremos es que también queremos cosas diferentes. A, B salida dependiendo de lo que pase con lo grande. Entonces, por ejemplo, si la calificación es menor a 50, bueno entonces lo que quisiéramos imprimir es que has fallado la clase. Porque eso tiene sentido, ¿verdad? Si tienes menos de 50, entonces eso te hace fallar una clase. Ahora, si tal vez queremos, ¿verdad? Y luego has tenido éxito en la clase, así que pasaste, ¿verdad? Has pasado la clase. Si no son 50, sin embargo, bueno, tal vez lo que quiero es que en realidad quiero tener esto, correcto, porque has pasado la clase, pero no tranquilo con, tranquilo con un 100 puntos. Entonces tal vez lo que quiero es en realidad quiero que se llame a esto si la persona no tiene 100 puntos pero ha pasado. Y luego quiero que otra cosa sea fría. Entonces, lo que podemos hacer entonces es que podemos hacer la declaración else if, simplemente cambiando la, otra si declaración aquí diciendo, por ejemplo, la calificación es más grande o igual a 50. Entonces esto es exactamente el reverso de este extremo derecho. El grado es menor a 100. Por lo que es entre 50 y 100. Y luego se llama a esto. Por lo que has pasado la clase, pero no del todo con un 100 puntos. Y si entonces decimos otra cosa, entonces podemos mirar, por ejemplo, hacer esto y luego tener esto. Has pasado la clase, Vamos a ver, con sobre nosotros algo así. Y esto funcionaría entonces. Entonces ahora mismo tenemos 99. Entonces lo que se debe imprimir es que has pasado la clase, pero no del todo con 100 puntos. A ver si ese es el caso. Has pasado la clase, pero no del todo con 100 puntos, exactamente. Y luego si tenemos 100 puntos, entonces debería funcionar. A ver. En efecto tienes clase, la clase pasa el ancho de clase sobre nosotros. ¿ Verdad? Ahora, hay un pequeño flujo ahí dentro el cual puedes mirarte a ti mismo. A lo mejor puedes averiguarlo y agregarle a esto en tu propio tiempo. Porque si tengo 101% en año, sigo pasando la clase con honores. Como se puede ver, todavía funciona. A lo mejor puedes agregar ya sea una nueva expresión aquí o tal vez ocho, otra afirmación if. Pero eso es genuinamente solo una idea para ti. Si quieres jugar con esto, un poco más. Muy importante si y lo contrario las declaraciones son un elemento fundamental crucial de la programación. Básicamente son una de las cosas más importantes para bajar. Por lo que este es un área de conocimiento muy importante que necesitas tener para que programes. Entonces es por eso que realmente quiero recalcar, probar algunas cosas con las declaraciones if y lo else. Juega un poco con él. Y si hay alguna pregunta en esta instancia, en este tema, muy importante, Duke, haga cualquier pregunta que tenga que tal vez no sea completamente clara si hay algo poco claro, por favor haga una pregunta. Voy a estar seguro de responder como siempre. Y sí. 14. (C#) Operador Ternary: Muy bien, bienvenidos de nuevo a la C aguda introducción para el curso de unidad. Y en esta conferencia vamos a echar un vistazo al operador ternario. Ahora lo primero es lo primero, el operador ternario suena como si fuera increíblemente complicado y algunos como cosa muy loca. No es una locura para nada. En realidad es bastante fácil de entender y lo vamos a pasar ahora mismo. Una vez más, asegurándonos de que estamos en la Conferencia 11, ternaria, y luego apenas abriendo el guión ternario. Entonces como puedes ver, ya hay algo aquí dentro. Tenemos un gran grado y un bool que simplemente expresan si este mayor pasado ha pasado o no. Hemos visto en las últimas conferencias cómo básicamente podemos manipular eso un poco. Y ahora solo va a mostrar una taquigrafía rápida básicamente. Entonces podemos decir que el pasado es igual. Y entonces por ejemplo, podemos decir grado, soy más grande o igual 50. Y eso sólo funciona porque podemos por supuesto salvar las expresiones booleanas. En este caso con el operador de comparación justo a un lado de un booleano también. En lugar de, en lugar de evaluar siempre esto dentro de una declaración if, también podemos simplemente guardarlo en un booleano y luego básicamente mirarlo así. Ahora el operador ternario tiene algo. Básicamente funciona casi como una declaración if. Entonces podemos, por ejemplo, decir que el pasado es igual a y luego decimos que el grado es, digamos, menor que 50. Hagamos un paréntesis de suma en lugar de que el operador ternario sea un signo de interrogación. Y luego lo que deba devolverse. Si esto es cierto, va a ser un poco. Estamos ahora mismo. Esto puede ser falso y luego hacemos colon a través. Entonces como puedes ver ahora en realidad no está mostrando más errores. Siendo la idea que frente al signo de interrogación, pongas una expresión booleana. Y el primer elemento aquí es lo que se devuelve. En este caso, escrito en la variable pasada. Si la expresión aquí es cierta. Y entonces qué viene después de que se devuelva el colon? Si la expresión aquí es falsa. Entonces esta, Entonces esta, esta expresión aquí es básicamente la misma si yo hiciera lo siguiente. Por lo que este pasado es igual a falso. Else pasado igual a verdadero. Por lo que esos son completamente equivalentes. En este caso. Lo mismo pasaría aquí como lo hace aquí. A lo mejor un, otro ejemplo podría ser un poco mejor, por ejemplo, con una cuerda. Entonces digamos, por ejemplo, la frase y luego vamos a decir grado igual a 100. Entonces vamos a decir felicitaciones por el 100. Y luego si no es un 100, entonces esto, esto se devuelve si es un 100, y esto se devuelve si no es un 100, no un 100. Pero sigue siendo bueno. Algo así. Por ejemplo. Como puedes ver, eso funciona. Y esto podría ser un poco mejor ejemplo que el último año porque también estamos usando booleanos aquí. Este el operador ternario, como dije, puede ser reemplazado por declaraciones normales if también, o si las declaraciones pueden reemplazar con un operador ternario. Realmente depende de la situación. Algo que definitivamente no haría es tener múltiples operadores ternarios, como dentro uno del otro. Entonces en teoría podemos decir, bueno, vale, esta es otra revista más brillante, así que podemos decir más grande, más grande o igual a 50. Y luego otro signo de interrogación, y luego podemos volver pasado y luego podemos, por ejemplo, regresar fallado, ¿verdad? Entonces podemos hacer esto. En este punto, empieza a complicarse un poco más de leer. Creo que esto podría estar bien. Si tienes como dos niveles de profundidad, tal vez eso funcione. Pero realmente no te aconsejaría que hicieras nada más que eso. Sí. Pero también es una especie de cosa que te da una idea si comienzas a programar un poco. Sí, Entonces ese es el operador ternario. Es solo un poco breve introducción al mismo. No hay nada demasiado elegante en ello. Y es solo importante que hayas visto eso son todo. Entonces sí, sí, eso fue todo para esta conferencia. Espero que te resulte útil si hay alguna pregunta, como siempre siéntete libre de preguntar y me aseguraré de responder. Y sí. 15. (C#) Cambiar: Muy bien, bienvenidos de nuevo a la C aguda introducción aquí para el curso de unidad. Y en esta conferencia vamos a echar un vistazo a las declaraciones de cambio. Por lo que la última vez que hemos visto al operador ternario. Hay otro operador o una declaración que podemos usar que no diría reemplazar las declaraciones if, pero que podemos usar en lugar de las declaraciones if si así lo elegimos. Así que vamos a abrir aquí el script de declaración switch. Y se puede ver ya he preparado un valor entero o variable entera x con valor 75. Y vamos a ver la palabra clave switch. Entonces es solo interruptor. Y luego entre paréntesis dentro de ella, queremos poner una variable que queremos evaluar, en este caso x, y luego necesitamos los corchetes rizados. Y eso es básicamente ya lo que necesitamos para la declaración de cambio. Entonces dentro de la sentencia switch, en realidad vamos a definir casos específicos. Entonces si por ejemplo, x es 10, así que vamos a escribir el caso 10, luego un colon, y luego pase lo que queramos. Entonces aquí en realidad podemos escribir como todo un montón de código, llamada de método, lo que queramos. En este caso, solo vamos a imprimir o depurar log x es 10. Y al final de esto, así que después del punto y coma, en realidad queremos otra palabra clave y eso es ladrillo. Y esto simplemente significa que, acuerdo, este caso ya está hecho. Por lo que obviamente el, IT, hay una forma más fácil de generar lo que sea x en este caso. Esto es sólo con fines de demostración en este caso. Y así podemos tener otro caso, así por ejemplo, caso 20. Y luego vamos a decir debug log x es x es 20. Y otro descanso. Y sólo copiemos esos terminados. Por lo que básicamente vamos a asegurarnos de que los marcamos y que los seleccionemos. Entonces vamos a presionar Control C para copiar el control V para pegar. Y entonces vamos a tener otros cincuenta y ciento cincuenta y cien. Y sí, eso está bien. Ahora, como pueden ver, el inconveniente digamos aquí es que en realidad tenemos que especificar cada caso específico en lugar de una declaración if donde teníamos el tipo de habilidad donde pasamos el booleano para tener rangos. Aquí realmente necesita ser explícito en cada caso. Por lo que puede ser un poco tedioso. Y hay un caso específico que sucede si x es algo en lo que no hemos pensado o si no queremos definir un caso para eso, y eso se llama default. Y el default sucede. Entonces, por ejemplo, digamos debug log. No sé qué es x. Un poco raro. Y luego un descanso, tú también lo estás, ¿verdad? Entonces en este caso, obviamente por defecto sería, el caso sería por defecto porque x 75 cae en ninguno de esos cuatro casos. Y en realidad podemos comprobar eso. Asegurándose de que estamos en la conferencia de cambio. Y juguemos y veamos si eso funciona. No sé qué x es un poco raro. Ahí vas. Porque x era algo para donde no se definió ningún caso. Entonces sí, esa es básicamente la declaración de cambio. Tiene algunos usos en casos específicos. No obstante, suele reservarse para tal vez donde tengas tres o cuatro casos predefinidos, donde esto no se prolongue demasiado tiempo. Y también por lo general enteros y también flota. Así que nunca uses cajas de cambio si tienes flotadores o dobles porque eso, quiero decir, literalmente no funciona. O Mi plomo al desastre. Los enteros r pueden estar bien. No obstante, por lo general los casos de cambio están reservados para cosas como enumeraciones, que vamos a echar un vistazo un poco más tarde, donde eso básicamente tienen valores predefinidos. Entonces esa es una especie de idea. Pero quería mostrarles la declaración de cambio. Puede ser útil y básicamente se puede intercambiar con una declaración if. Y sí, eso fue todo para esta conferencia. Espero que te resulte útil si no hay preguntas, como siempre, siéntete libre de preguntar y me aseguraré de responder. Y sí. 16. (C#) Mientras bucle: Muy bien, bienvenidos de nuevo a la introducción C-sharp aquí para el curso de unidad. Y en esta conferencia, vamos a echar un vistazo al bucle while. Entonces vamos a la siguiente sección, digamos, que es loops. Y vamos a ver sólo qué podemos ver abriendo el script while loop. Por lo que ya he definido un entero x igual a cinco. Y ahora lo que queremos, tal vez, lo que queremos es que queramos bloquear esta x, tal vez muchas veces, ¿verdad? Entonces queremos bloquear esto. Entonces ahora mismo hemos mirado 6 veces, pero en realidad quiero registrarlo un 100 veces, ¿verdad? Entonces tengo que copiar y copiar de nuevo y copiar eso. Es decir, eso es ridículo, verdad. Obviamente eso es demasiado. Y tal vez en realidad lo que quiero entre esas cerraduras, en realidad quiero aumentar esto. Entonces quiero lucir cinco y luego quiero lucir seis y luego 78. Y quiero decir, eso es tasa de locura. Por supuesto que eso es una locura. Por eso tenemos bucles. Un bucle simplemente repite una sección específica de código. Digamos número de veces que definimos. Y en este caso, un bucle while hace algo mientras cierta expresión booleana es cierta. Así que vamos a escribir el while, un bucle, la palabra clave while aquí, y vamos a tocar dos veces y como puedes ver, genera un paréntesis, paréntesis aquí y corchetes rizados. Por lo que todo dentro de los corchetes rizados se ejecuta siempre y cuando lo que esté dentro de los paréntesis sea cierto. En este caso, mientras que true siempre se ejecutará y seguirá corriendo. Y básicamente va a chocar la unidad si hacemos esto. Entonces esa es una de las cosas que tenemos que cuidar. Siempre debe haber una gran condición en lugar de un bucle while. De lo contrario, podría convertirse en un bucle interminable. Y eso entonces a su vez, convertirá en Unity estrellarse. Créeme, te va a pasar en algún momento. Si bien programa algo con loops while. A mí me ha pasado. ¿ Y quién sabe? Para el final de esta conferencia, tal vez vaya a suceder también. Lo dudo mucho, pero nunca se sabe. Entonces vamos a poner en x es más pequeño o igual a 10. Y si bien eso es cierto, vamos a depurar dot log x log x, y luego vamos a aumentar x Así que si no tuviéramos este aumento aquí, entonces seguiría cerrando sesión 55, 55. Pero lo haría con esto To Eternity, que por supuesto no funciona, y por lo tanto la unidad se estrellaría. Eso no es lo que queremos. Por lo tanto, vamos a aumentar X cada vez que se ejecute el bucle while. Por lo que va a correr como cualquier otro tipo de código de arriba a abajo. Entonces va a imprimir esto o aumentarlo. Check a sigue siendo una cosa. Si está resolviendo un logarla, aumentarla, revisar de nuevo y así sucesivamente, así sucesivamente hasta que terminemos. Y vamos a añadir una depuración después de aquí. Se va a decir fuera del bucle. El bucle, no, fuera del bucle. Ahí vas. Y sí, vamos a correr esto así lo que esperamos. Entonces una cosa que siempre es buena idea mirar, qué estamos esperando ver en la consola. Entonces espero ver 5, 6, 7, 8, 9, 10. Sí. Yo creo. ¿ Voy a ver 10? Sí, voy a ver 10, creo. Y luego fuera del bucle. Entonces cinco a diez. Y luego fuera de eso es lo que estoy pensando en senior y asegurarme de que estamos en la Conferencia 13. Si bien Vamos a ver si ese es el caso. 05678910. Y fuera del bucle, ¿no es genial? Eso también es igual de un rápido a un lado, muy importante. Piensa en lo que quieres ver en la consola. Entonces piensa en tu expectativa y luego mira lo que sale. Y si se cumple tu expectativa y lo que sea salida o bloqueado, genial, tienes un pensamiento al respecto de la manera correcta. Si hay una discrepancia, entonces intenta averiguar, bueno, ¿qué hice mal? O por ejemplo, un fácil, Digamos error o, o algo fácil de hacer es en lugar de tener x más pequeño igual a 10, tenemos, es más pequeño 10. Estamos como, bueno, todavía va a dar salida al 10, ¿verdad? Todavía va a pasar de cinco a 10 porque mientras sea más pequeño que 10, y por supuesto no sale el 10, porque en cuanto es 10, ya no es menor que 10. Por lo tanto, no va a, no va a ejecutar lo que esté en el, en los corchetes rizados. Entonces eso es algo que tener en cuenta. Eso no es específico del bucle while en sí, sino solo consejos generales. Y hay un segundo, Digamos. Otro lo hago con un bucle while ese tipo de lazos en lo más pequeño, más pequeño que o igual. Y ese es el bucle do while. Por lo que podemos simplemente poner en do y luego presionar Tab dos veces. Y como pueden ver, en este caso, vamos a tener aquí una palabra clave do, seguida de los corchetes rizados y luego el inalámbrico en la parte posterior. Vamos a poner en x es menor que 10. Y entonces en realidad podemos hacer lo mismo. Entonces hagamos exactamente lo mismo. Y no lo hagamos como no hagamos este año. ¿ Verdad? Vamos, en realidad saquemos esto rápidamente de aquí. Y el bucle do-while. Bueno, sólo veamos qué pasa. Por lo que hemos visto previamente que el bucle while con x menor que 10 que imprimió cinco a nueve. Y en este caso, va a imprimir de cinco a nueve una vez más. Interesante, ¿no? Bueno, ¿qué también es interesante? Si nos quedamos con esto, entonces vamos a ejecutar nuestra x en diez. Entonces esta función es exactamente de la misma manera, ¿verdad? Por lo que esto también se va a evaluar esto. Y entonces pongamos esto aquí. Digamos, vale, x es, cuanto estemos fuera del bucle, x va a ser igual a 10. Entonces el tiempo no es, nunca es una cosa. Por lo que X siempre va a ser más grande que 10, nunca menor que 10. No obstante, si miramos esto, en realidad va a imprimir 11 aquí. Y si hacemos doble clic aquí, en realidad vamos a ver que esto es lo que se imprime. Eso es un poco raro, ¿no? ¿ Por qué sucedería eso? Porque x nunca es menor que 10 en ese momento. Y quiero decir, es, es bastante evidente porque en realidad está impreso 11. Bueno, do-while hace éste, así que hay comando DO por así decirlo. Hacen palabra clave, va a correr las cosas dentro de los corchetes rizados una vez. Y luego se va a evaluar la condición while. Y entonces básicamente funciona como un bucle while normal podría ser útil en algún momento. Personalmente, rara vez he usado esto. Y también personalmente, también he usado raramente mientras bucles también, porque lo hacen, al menos cuando los uso tienden a chocar la unidad. Así que ten aviso, pero no lo seas, no va a ser tan malo porque normalmente mientras ahorres suficientes veces, entonces va a estar bien. Pero sí, es que en realidad no está tan mal. Yo sólo quería mencionar eso. Y sí, eso es básicamente una breve visión general del bucle while. Espero que te haya parecido útil y de verdad agradecería una crítica de tu parte. Y si hay preguntas como siempre, honorarios por tarea y me aseguraré de responder. Y sí. 17. (C#) para el bucle: Muy bien, bienvenidos de nuevo a la introducción C-sharp aquí para el curso de unidad. Y en esta conferencia vamos a echar un vistazo a los bucles. Por lo que hemos visto un bucle salvaje. Entonces, ¿cuál es el for loop? Bueno, echemos un vistazo abriendo el guión for-loops. Bueno, vamos a echar un vistazo al bucle for sin nada más. Entonces, solo tecleemos cuatro y vamos a hacer esto manualmente primero. Entonces el primer componente dentro de un bucle for es un entero. En este caso, vamos a llamar a este entero I igual a 0. Voy a poner punto y coma. Entonces tenemos que elegir una, una expresión. Entonces digamos que soy más pequeño que cinco y luego yo más, más. Y luego poner los corchetes rizados también. Entonces, ¿qué significa esto? Bueno, esto significa que empiezo a las 0. Se va a cinco. Y está aumentando, aumentando yo por uno. Esa es la idea porque como hemos aprendido, yo más plus aumenta. En este caso, yo por una. Empiezo a las 0. Y mientras esto sea cierto, el bucle continúa. Por lo que éste estaría contando del 0 al 2, 1, 5, 4, 5 a 4. Echemos un vistazo a esto. Entonces debug dot log y luego I. Y entonces vamos a pasar por esto. Cómo luce esto. Entonces, solo bloqueemos esto y veamos qué tiene para nosotros la consola. Debería bloquear de 0 a cuatro. Y como se puede ver, 0, 1, 2, 3, 4. Genial, eso es bastante bueno. Y entonces pensemos en esto. Entonces empezamos a 0, eso es fácil de ver. Entonces vamos a imprimir 0. ¿De acuerdo? Entonces vamos a aumentar yo por uno. Y luego vamos a evaluar, Oye, ¿ soy más pequeño que cinco? Sí, lo es. Está bien. Vamos a imprimirlo. Y luego va a ser 2 es en más pequeño. Sí. Entonces van a ser tres áreas pequeñas para sí. Y luego van a ser 55. No sé si escucharon, pero eso no es menor que 5. En realidad es igual a 5. Por lo tanto, estamos fuera del bucle en ese punto. Y es por eso que cinco en realidad no se incluyen en el ojo, por así decirlo. Entonces en cuanto sea igual a cinco, sí, vamos a saltar fuera del bucle. Entonces eso es realmente útil para contar, y también es útil para algunas otras cosas que vamos a echarle un vistazo muy pronto en la próxima conferencia ya. No obstante, el for-loops, definitivamente genial. También podemos contar al revés. Entonces, solo hagamos eso. Entonces hagamos un entero 10. Y digamos, Bueno, en realidad debería ser más grande que 0. Y entonces vamos a decir que menos menos. Y vamos a imprimir este. Y esto debería estar contando desde, bueno 10, definitivamente escribir 200. Conoce una vez más, piensa en esto. Si tenemos en no, digamos más grande o igual o más pequeño o igual signo ahí dentro. Entonces por lo general que el número aquí no se incluye. Si tenemos un mayor o igual que el 0 se incluiría. En este caso, va a ser uno. Y entonces vamos a decir también al revés, porque esto cuenta al revés. Entonces vamos a, la salida debe ser de 0 a cuatro y luego de 10 a uno. Entonces, veamos si ese es en realidad el caso. Empecemos. Entonces 0 a cuatro y luego diez a uno, vamos. Genial. ¿ Verdad? Entonces ese es el for-loop. En mi opinión personal, por lo general más versátil que el bucle while. Pero creo que también tiene que hacer un poquito con preferencia. Creo que también son aplicables en diferentes situaciones, así que, bueno, eso es todo para el bucle for, una parte muy importante de la programación, definitivamente. Entonces si hay alguna pregunta, como siempre, siéntete libre de preguntar y me aseguraré de responder. Y sí. 18. (C#) Rompe y continuar las palabras clave: Muy bien, Uh, bienvenido de nuevo a la introducción C3b para el curso de la unidad. Y en esta conferencia vamos a echar un vistazo a dos palabras clave. Esos se van a romper y continuar. Ahora ya hemos visto un poco de la palabra clave break en conferencia de declaración de cambio. No obstante, esta es en realidad la aplicación FOR loops. En este caso, vamos a echar un vistazo al descanso y continuar las palabras clave dentro del for-loop. No obstante, especialmente la palabra clave break también podría usarse en un bucle while. Entonces, solo abramos el descanso y continuemos con el guión aquí. Y como puedes ver, en realidad tenemos 24 bucles que hacen exactamente lo mismo. En realidad, vamos a contar de 0 a nueve en ambos. Y sin embargo eso sólo va a funcionar. No obstante, lo que podemos hacer es usar una de esas palabras clave, palabras clave. Entonces digamos, por ejemplo, si soy igual a cuatro, entonces lo que vamos a hacer es que vamos a seguir. Entonces, ¿qué hace eso? Bueno, la palabra clave continue básicamente dice, bien, vamos a pasar a la siguiente I. Así que vamos a saltar la impresión o registrar los cuatro. Y vamos a saltar directamente de tres a cinco. Entonces vamos a ver, Vamos a copiar rápidamente esto fuera de aquí para que la consola no se desorden. Y una vez más, asegúrate de que estamos en la Conferencia 15 descanso y continuar. Como se puede ver, saltamos de tres rectas a cinco. Porque en un cuatro, así que igual a 4. Lo que hemos hecho es que hemos continuado, Continuar, básicamente sólo salta al bucle otra vez, ignorando todo lo que viene después dentro del bucle. Entonces básicamente se vuelve a enfriar y todas las líneas después se ignoran. Sí, esa es la palabra clave continue. Ahora, vamos al segundo for loop. Y digamos por ejemplo, si soy igual a cinco, entonces lo que queremos hacer es romper. Hagámoslo realmente correctamente para que se vea bien. Sí, descanso. Ya hemos visto esto antes en, como he dicho en la declaración de cambio dentro de aquí, el break simplemente significa en lugar de un bucle, break significa paradas de bucle. Entonces break dice: Vale, saltemos inmediatamente a la parte posterior del org, al final del bucle es lo mismo que si la expresión booleana de aquí arriba sería falsa. Entonces, por tanto, salimos del bucle de inmediato. Veamos esto. Entonces lo que deberíamos ver es que deberíamos ver 0, 2, 3, cinco a nueve. Y luego después deberíamos ver 0, 2, 4 porque en cuanto tenga cinco, vamos a salir de esta forma. ¿ Verdad? Entonces veamos si eso es realmente lo que vamos a ver. De lo que estoy bastante confiado que es. Entonces es de 0 a tres y vamos a saltar de cinco a 901234 y luego eso fue todo. Sí, así que esa es básicamente la idea de la palabra clave continue and break. Hay algunas personas que dicen que no es necesariamente la mejor práctica porque a veces puede ser confuso, sobre todo si tal vez tienes un bucle FOR largo y tienes muchas continuas y descansos ahí con tal vez incluso más si las declaraciones y todo eso, entonces a veces podría ser un poco confuso para los loops simples. Y mientras bucles rompen o continue palabra clave no va a ser demasiado malo. Yo no lo creo. Pero sí, así que eso es todo para el descanso y continuar palabras clave. También partes importantes para haber visto al menos y saber para bucles. Entonces si hay alguna pregunta, como siempre, siéntete libre de preguntar y voy a ser corto responder. Y sí. 19. (C#) Arays de C#: Muy bien, bienvenidos de nuevo a la C aguda introducción para el curso de unidad. Y en esta conferencia, vamos a hablar de matrices. Ahora, las matrices son una parte vital de la programación. Y el primer tema que es un poco más complejo y complicado. Por lo que definitivamente te imploro que tal vez incluso veas esta conferencia dos veces, porque esto tiene un poco más en ella. Y por supuesto, si hay alguna pregunta, siéntase libre de preguntar. Pero vamos a saltar justo dentro. Al abrir el guión. Ya he preparado tres cuerdas aquí. Como se puede ver, los estudiantes 0, el estudiante uno, y el estudiante dos, John, July y Ryan. Esas son, digamos, direcciones de correo electrónico de mis alumnos, por ejemplo aquí. Y ahora lo que quiero es que quiero enviarlos por correo electrónico o quiero dar salida a los correos electrónicos, digamos, así que por supuesto podemos hacer debug dot log y luego podemos decir estudiante, estudiante 0, y luego podemos decir estudiante uno. Y entonces podemos decir estudiante hoy te vas, ahora les he dado salida a esos. ¿ No es genial? Bueno, eso está bien. Pero digamos que tengo un 100 de esos emails Eso va a ser un poco más difícil que, bueno, hemos aprendido algo que podemos hacer. Podemos tomar este bucle de cuatro y podemos decir, bueno, vamos a pasar por eso y entonces tal vez podamos decir debug log y luego tal vez poner el yo aquí son algunos, no, eso no funciona. Obviamente eso no funciona, ¿verdad? Entonces esto, tristemente, esto no funciona. Entonces no podemos simplemente producirlos con un bucle for y no podemos, podemos iterar sobre ellos, ¿verdad? Entonces esto es básicamente lo que queremos. Nosotros queremos, especie de, queremos enumerar algo así como una lista. Y ahí es donde entra la teoría. Entonces podemos, digamos init, una matriz, ¿verdad? Entonces la idea es que una matriz es básicamente una lista de cierto tipo. En este caso, vamos a hacer un, un área de cuerda. Entonces vamos a escribir string, solo la palabra clave de cadena normal como lo haríamos con cualquier otra variable, variable de cadena. Y luego vamos a escribir estos corchetes y luego el nombre de la variable, estudiante, varones, digamos. Y entonces podemos hacer un, podemos inicializar esta nueva matriz poniéndola entre paréntesis rizadas. Y luego podemos poner, por ejemplo, a John en gmail.com. Y entonces el segundo va a ser julio en gmail.com. Y entonces la tercera va a ser María en Gmail por ejemplo.com. Y luego también tendremos a Ryan en gmail.com. Vamos a alejarnos un poco. Y luego al final, un punto y coma. Y ahora esto es, como puedes ver, no hay errores, todo está bien. Y ahora en realidad hemos inicializado esta matriz también es otra forma en que podemos inicializar esta matriz. Por lo que esto es explícito con cuatro cadenas específicas. En este caso. También podemos decir, por ejemplo, una matriz entera de algunos números como ese. Va a ser igual a nuevo int. Y luego de esta manera, así los corchetes, entonces dentro de esos corchetes realmente tenemos que escribir cuántos. Números, o en este caso, entonces ¿cuántos enteros hay ahí? Entonces, solo pongamos 5. Por lo que éste sería, puede tener cinco entradas. Y entonces podemos asignarle algo a eso. ¿ Y cómo le asignamos algo? Bueno, sólo podemos tomar el nombre de la variable. Por lo que algunos números. Volvemos a poner entre corchetes. Y dentro de esos corchetes que tomamos, ponemos en un número que es el índice de la entrada. Por lo que 0 significa la primera entrada. Entonces esto, digamos 10, y luego vamos a copiar rápidamente esto sobre 1, 2, 34. Entonces digamos algo así como 2054421337, algo así, ¿no? Muy importante. Las matrices comienzan ahí, cuentan en 0. Esto ya lo hemos visto antes con las cuerdas. Y quería volver a mencionar esto aquí. Si miramos por ejemplo a los varones estudiantiles, correcto, tenemos cuatro elementos. Entonces el tamaño o la longitud de este array de cuerdas, los varones estudiantiles son cuatro. Eso está bien, Eso está bien. Eso es comprensible. No obstante, el primer elemento aquí, John edit gmail.com. En realidad está en el índice 0. Por lo que una vez más empezamos a contar a 0. Entonces esto es 0, 1, 2, 3. En, en suma, aún quedan cuatro elementos. No obstante, acabamos de empezar a contar en 0. Entonces ahora mirando hacia atrás a esto, bueno, queríamos imprimir o anotar todas nuestras direcciones de correo electrónico, y ahora podemos hacerlo. Entonces, solo hagamos un nuevo for-loop. Y ya fuentes fuera longitud aquí. Bueno, lo que podemos hacer es que podemos, bueno, hagamos sólo cuatro, porque sabemos que tenemos para los emails de los estudiantes Eso es bastante fácil. Y podemos decir que debug dot log student son varones. Y entonces aquí tenemos valores asignados. También podemos simplemente recuperar los valores simplemente llamando al hacer los corchetes. Y luego dentro de aquí, ponemos en el ojo porque ese es el número que cambia. Entonces va a ir de 0, 1, 2, 3, y nunca se alcanza el 4. Ya hemos visto esto antes. Entonces nuestra salida debería ser, primer lugar, John, July y luego Ryan Gmail y luego junio, julio Maria Ryan. Porque primero esos van a ser salida aquí aparecen. Entonces el bucle for va a salir. Entonces vamos a ver asegurándonos de que estamos en Lectura 16 matrices. Empecemos esto y como podemos ver, junio y julio, Ryan, esos son los tres que hicimos manualmente y luego tenemos a John, Julio, y María y un Ryan. Genial. Bueno, quiero decir, eso es increíble. Entonces, solo agreguemos otro. Ya sabes, también se une a la Nube. Digo, eso es, eso es bastante guay, ¿verdad? Entonces eso es realmente bonito. Vamos, asegurémonos de que todos estén ahí y todos estén incluidos aquí también. Empecemos esto y todo funciona totalmente bien como puedes ver muy claramente. Pero ahora, bueno, en primer lugar. Sí, pero las nubes en realidad no fueron de salida. Entonces eso está bien, eso es algo raro. Pero ahora, oh no, mira esto. En realidad estamos perdiendo tres de nuestros estudiantes se conocieron. Por lo que sólo John y Julio están, ya sabes, quedan para este semestre. Es decir, eso es, ya sabes, puede pasar. Puede suceder, pero no hay ningún tema que sea sí, hay un índice de emisión fuera de rango. Entonces, ¿qué es eso? Bueno, lo que pasa aquí es que de repente estamos tratando de acceder a algo que no existe. En este caso, los varones estudiantiles sólo tienen dos elementos. Por lo que en realidad sólo podemos contar desde, así 0 y 1, dos elementos. Pero aquí dentro, en realidad estamos tratando de acceder al elemento 3, 4, 5, y así sucesivamente. Eso no funciona porque, bueno, no existe. Entonces, ¿qué podemos hacer al respecto? Porque lo hemos dicho explícitamente para, vale, voy a cambiar eso a dos. Pero cada vez que el estudiante cambia, tenemos que entrar manualmente y cambiar esto. Bueno, eso no funciona. Por supuesto que hay algo para ello y luego podemos ir varones estudiantiles de esa longitud. Y esa es siempre la longitud de los varones estudiantiles. Y ahora va a pasar por esto. Por lo que María, Ryan y Klaus se han unido de nuevo a nosotros. Y ahora klaus también será salida porque lo hemos tomado en cuenta. A ver, ahí tienes. Cierra en gmail.com, también es salida. Entonces sí, es decir, esa es la idea de matrices. Básicamente es una lista. Puede ser de cualquier tipo de variable, por lo que cualquier tipo de datos, siempre y cuando ponga los corchetes después de él, puede ser una matriz. Y en este caso, explícito. Lee puso las cuerdas. Aquí te dejamos algunos enteros. El encargo funciona muy similar a conseguir realmente la salida de lo que sea que haya ahí dentro. Lo que también es importante es que cuando se ha definido cuántas entradas hay en una matriz, no se puede cambiar el número de entradas, por lo que eso permanece igual. Se puede cambiar lo que esté escrito en esa posición, pero no se puede cambiar el número de entradas en una matriz. Ahora hay algunas otras cosas que podemos usar que en realidad sí tienen este tipo de lista dinámica en ella. Esas son algunas otras estructuras de datos que vamos a ver más adelante por la línea. No obstante, las matrices en este momento en el tiempo son al menos un poco importantes. Este algo que podemos usar más adelante que es un poco más fácil de entender en mi opinión. No obstante, ahora mismo, las matrices son lo que pasa. Definitivamente te animaría a echar un buen vistazo a esto para intentar realmente entender lo que está pasando. Si hay alguna pregunta definitivamente pregunte. Porque este es como uno de los, diría uno de los temas más importantes, pero definitivamente este es un tema importante. Y sólo por un poco rápido a un lado aquí, en realidad puedo contar una divertida y pequeña historia sobre esto. Entonces cuando empezaba a aprender programación y surgía la era, yo, al principio no las entendía. Es por eso que preparo esto con decir, vale, esto es quizás un poco más duro y un poco más complejo. Y así no los entendí al principio. Y yo simplemente no pude averiguar qué estaba haciendo mal. Y luego estaba como, nunca voy a usar áreas de todos modos. No los necesito para nada. No importa. Siempre lo voy a hacer así. Y por supuesto, quiero decir, en primer lugar, esa es la forma equivocada de abordar esto de cualquier manera. Nunca debes hacer eso. Si estás tratando de aprender algo nuevo. Esa definitivamente no es la forma correcta de abordar esto. Pero en esto específicamente, solo hay algunas cosas que no puedes hacer si no usas una matriz o como lo tenemos más tarde que como vamos a ver más adelante una lista o algún tipo de estructura de datos diferente. A veces hay que usar estas estructuras de datos que son diferentes de simplemente escribir estúpidamente cadena línea por línea. Funciona, pero en algún momento se pone muy, muy desagradable, malo, simplemente no es bueno. Entonces es por eso que realmente quiero animarte a que intentes entender esto. A lo mejor míralo una o dos veces. Y si hay alguna pregunta, no dudes en preguntar. Y como siempre, me aseguraré de responder. Y espero que esto te resulte útil. Y sí. 20. (C#) arreglos multidimensional en C#: Muy bien, bienvenidos de nuevo a la C aguda introducción aquí para el curso de unidad. Y en esta conferencia, vamos a echar un vistazo rápido a las matrices multidimensionales. Ahora, después de que hayamos mirado las matrices, ahora vamos a echar un vistazo a las matrices multidimensionales. Ahora en adelante mencioné que esto es sólo una visión muy, muy rápida, sólo un vistazo rápido a cómo esos, cómo se ven, y sólo un poco de cómo funcionan. Y vamos a abrir aquí el guión multidimensiones. Y ya he definido una matriz multidimensional. Como se puede ver, sólo ponemos una coma entre los paréntesis. Y luego dentro de ella, en realidad definimos una matriz y luego también se define la siguiente área. Y luego otro corchetes rizados por ahí. Entonces básicamente hay dos áreas. En lugar de una matriz, se puede pensar en ella como una matriz de matrices. En teoría, eso es algo en lo que puedes pensar. O puedes pensar en esto como una tabla donde tienes diferentes filas. Entonces si lo escribiéramos así, por ejemplo, digamos algo como esto, entonces se podría imaginar que esta es la primera venta, segunda celda y así sucesivamente y así sucesivamente. Y entonces de repente tiene mucho más sentido cuando pensamos en esto. Para que puedas tener, tienes dos coordenadas para describir estas celdas. Y entonces esto sería simplemente 0, 0. Y eso tiene sentido absoluto. Y entonces esto es algo así como 0, 3 por ejemplo, y así sucesivamente y demás. Y solo, voy a copiar algo más. Entonces si miramos esto, así podemos volver a obtener los contenidos o los elementos de la matriz simplemente poniendo el corchete y luego escribiendo en los índices ahora mismo porque por supuesto necesitamos dos índices en este caso . Y 03 producirá algo desde la primera matriz. Por lo que este 0 notifica la primera matriz. Una vez más, empezamos a contar desde 0 y luego los tres simplemente significa 0123. Por lo tanto, va a la salida 25. Y la segunda, va a ser la segunda matriz o la que está en la posición uno, más bien una de índice. Y luego con el índice dos, así que vamos a tener 1, 0, 1, 2. Esto va a abrir 5 mil. Entonces, veamos si ese realmente es el caso. Asegurándose de que estamos bajo la Conferencia 17. Y la salida es de 25 y 50 mil, exactamente como nos hemos imaginado. Y hay dos cosas que hemos visto la longitud y ahora hay algo más que es el rango. Entonces esto es básicamente cuántas filas hay. Entonces como puedes ver que esas son básicamente las filas. Esto tiene cuántas matrices de vías respiratorias internas podrías describirlo así. En este caso, Rose, creo que la abstracción de pensar en una matriz multidimensional como especie de tal vez incluso una hoja de cálculo Excel es en realidad bastante útil. Y lo que también podemos hacer es que podemos hacer por bucles. Y voy a copiar rápidamente también esto sobre m. Y esto sería un dos para bucles dentro uno del otro. Uno que pasa por las filas básicamente, y luego uno que pasa por cada uno de los elementos mismos. Por supuesto, en este caso, los elementos es la longitud. Entonces la longitud es la totalidad de todos los elementos, ¿no? Tenemos ocho elementos aquí divididos por cuántas filas hay. Muy bien, por lo que cada fila tiene cuatro elementos, como se puede ver claramente. Por lo que tenemos que dividir el número de elementos por el número de filas. Esto es lo que hace este cálculo aquí mismo. Y entonces funciona también fue muy importante es que cada una de las matrices internas, donde cada una de las filas tiene que tener exactamente el mismo número de elementos que las otras. Entonces si hago esto, entonces como pueden ver, espera un inicializador de matriz de longitud 4. Por lo que en realidad necesitamos cuatro elementos en cada una de las matrices. Entonces si tuviera que agregar otra matriz, también necesitamos cuatro. Eso se acaba de mencionar rápidamente. Sólo veamos la salida para esto también. Y entonces básicamente estamos terminados con matrices multidimensionales. Yo sólo quería mostrarte esto rápidamente. Entonces como se puede ver, 10, 15, 20, y 25. Entonces se imprime la primera, la primera fila y luego 5500, cinco mil, y cincuenta mil, y luego se imprime la segunda. Así que eso es un poco bonito. En mi estimación. Y mi experiencia, es muy raro que se utilicen matrices multidimensionales. No obstante, sí quería mostrárselos porque sí tienen alguna aplicación alguna parte del tiempo. No obstante, de verdad no me preocuparía si hay ciertas cosas que no entiendes del todo sobre este tema, Eso no está tan mal, como que eso no es tan importante. Las propias áreas son mucho más importantes que entender las matrices multidimensionales. Son como una especie de bono. Es bueno saber, Es bueno tener realmente no necesario. Pero de todos modos, si esto te resultara útil, realmente agradecería una crítica de ti. Y si hay alguna pregunta, por supuesto, siempre se puede preguntar, me aseguraré de responder. Y sí. 21. (C#) Listas de C#: Muy bien, bienvenidos de nuevo a la C aguda introducción para el curso. Y en esta conferencia vamos a echar un vistazo a las listas. Entonces después de echar un vistazo a las matrices y luego solo un vistazo rápido a las matrices multidimensionales. Ahora vamos a ver listas que nos van a hacer la vida aproximadamente un 120% más fácil. Y así solo echemos un vistazo al guión de listas aquí mismo. Y antes que nada, recordemos las matrices. En lugar de las zonas. Teníamos diferentes direcciones de correo electrónico de los estudiantes como ejemplo aquí, definido. Y fue tan fácil como simplemente poner en el, el tipo de datos y luego los corchetes. Y luego tuvimos una matriz de una lista es un poco más complicada o un poco más extraña tal vez. Pero sólo definamos una lista. Vamos, inicialicemos una lista. Entonces sólo vamos a escribir en la lista. Entonces vamos a hacer estos corchetes angulares. Y dentro de esos corchetes angulares, vamos a escribir el tipo de datos que queremos guardar ahí dentro. Entonces en este caso una cuerda y vamos a llamar a esto machos. Después yendo a igualar nueva lista de tipo string y luego paréntesis y un punto y coma para terminarlo. Es así como básicamente inicializas una lista. ¿ Verdad? Entonces ahora tenemos una nueva lista como el nombre nueva lista sugiere de tipo string, por lo que ahora podemos agregarle. Entonces veamos algunos métodos que podemos llamar para esta lista. Entonces podemos, por ejemplo, decir machos dot add, como se puede ver. Y entonces podemos escribir, por ejemplo, tal vez Jonah ya no está en Google, tal vez esté en Yahoo a estas alturas. No sé por qué, pero ¿quién sabe? Y luego vamos a copiar esto un par de veces y luego sumar unos cuantos tipos de julio y luego vamos a añadir a Ryan otra vez y luego a María. Entonces ese es el método add, como se puede ver claramente. Ahora, lo primero que debes pensar de nuevo fue, espera un segundo. Teníamos, teníamos que definir cuántos elementos estaban en una matriz. Exactamente. No tenemos que hacer eso en una lista. Una lista es dinámica. Por lo que puedes tener 0 elementos y puedes agregar múltiples elementos y luego luego puedes bajar la línea, también puedes eliminar elementos. Y sí, eso es, esa es una de las cosas buenas, son grandes cosas de las listas. Entonces, solo cierremos sesión, primero que nada, solo machos y luego también cierren sesión correos 0. Entonces esto una vez más, el mismo acceso, el mismo operador de eje que hemos visto con la matriz, ¿verdad? Apenas los corchetes y luego el número que indica el índice de lo que queremos. En este caso, se va a sortear en yahoo.com. Y luego solo vamos a ver qué pasa si logramos cerrar sesión a los machos, solo para ver. Entonces vamos a presionar el botón de reproducción y ver. De acuerdo, entonces vamos a sistematizar la lista genérica de colecciones. Entonces algo que no nos es realmente útil, no realmente. No obstante, aquí en realidad podemos ver a John en yahoo.com consigue. El logueado. Cuando logramos cerrar sesión el primer elemento de la lista, o el elemento 0 de la lista. Supongo. También podríamos reasignar valores. Entonces reasignar valores, esto es muy similar al, en realidad es exactamente lo mismo cuando lo hicimos con la matriz. Entonces vamos a ver, en realidad John volvió a cambiar. Por lo que John en realidad está de nuevo en Gmail. Entonces en este caso, entonces el elemento John en yahoo.com cambia a John en gmail.com. También podemos quitar un artículo. Por lo que quitan van a quitar un artículo. Y eso sería si llamamos a los machos dot remove. Y entonces podemos quitar. Para que podamos pasarle una cuerda. Entonces podemos decir, vale, quiero que se quite una cadena específica. Entonces por ejemplo, Julio en yahoo.com. Ahora, para que esto funcione, por supuesto necesitamos saber qué elemento queremos quitar de quién no lo sabe, pero sabemos el lugar donde está. También podemos decir machos punto quitar en y luego poner en uno. Entonces esto es equivalente. Ahora claro que no puedo hacerlo uno tras otro porque después de que hayamos quitado el Julio, Ryan De repente se convierte en lo que está en el lugar uno. Por lo tanto, eso no funciona. Si queremos la longitud de la de una lista, podemos conseguir eso también. Entonces esto sería, por ejemplo, importante para, para bucles o alguien así. Entonces usamos el conteo. Entonces la variable de conteo es lo que necesitamos. Entonces esta es la longitud. Longitud. En ocasiones algunas personas también lo llaman el tamaño o el recuento de la lista. Y en diferentes, en diferentes lenguajes de programación, esto es casi intercambiable longitud, tamaño y recuento. Pero en nuestro caso, es el conteo en este momento, en este, en este guión, deberían ser tres porque aquí hemos quitado uno de los elementos, a saber Julio en yahoo.com. Y entonces también podemos despejar la lista. Por lo que los machos punto-punto-punto claro. Esto lo hará, esta convocatoria literalmente despejará la lista. Entonces sólo va a borrar por completo todo lo que hay ahí dentro. Y solo imprimamos el conteo después de eso también. Entonces veamos qué va a pasar aquí. Nosotros vamos a tener esto. Bueno, ya no necesitamos esto. Vamos a imprimir a John en yahoo.com. Entonces vamos a reescribir el primero. Entonces vamos a decir: Oye, ¿cuánto, cuántos elementos hay ahí dentro? Esto debe ser tres. Y luego vamos a despejar la lista. Entonces ya no debería estar nada en la lista y entonces deberíamos tener 0. En lugar de eso. A ver si ese es el caso. Pero tengo bastante confianza aquí van. Entonces, en primer lugar, imprimimos a John en yahoo.com. Después tenemos tres elementos en la lista. Después de haber quitado el elemento uno, y luego después de borrar la lista tenemos 0 elementos ahí adentro van. Entonces esas son algunas de las cosas que podemos hacer con las listas. Si miras, entonces si hacemos el correo stat, como puedes ver, hay algunos bastantes métodos más a los que podríamos llamar. En este caso. Yo sólo quería darles una breve visión general de la lista. Es si entiendes matrices, básicamente entiendes listas. Y lo grandioso es que las listas son simplemente mejores en casi todos los sentidos que un área. Porque son dinámicos. Se pueden agregar a ellos. Y su general, creo que mucho más agradable usar las matrices por lo general, ¿no? Entonces en general, diría que por lo general lo mejor es usar siempre listas. Porque libere no. Digamos que el impacto positivo del uso de matrices versus listas. Podría haber algunas cosas muy especializadas, pero es como con casi todo. Ya sabes, si le preguntas a 100 personas, entonces vas a conseguir 100 opiniones. Entonces, a veces así es como es. De todos modos, esa es una breve visión general de la lista en C sharp. Espero que esto les haya sido útil. Y si hay alguna pregunta como siempre, siéntete libre de preguntar y me aseguraré de responder. Y sí. 22. (C#) C# Dictionaries: Muy bien, bienvenidos de nuevo a la introducción C-sharp para el curso de unidad y esta conferencia vamos a echar un vistazo a un diccionarios. Ahora, los diccionarios son básicamente listas con un poco de giro para ellos. Entonces, solo abramos el script del diccionario y veamos qué podemos ver. Entonces, en primer lugar, ¿cómo definimos o inicializamos un diccionario? Bueno, sólo vamos a escribir diccionario. Y luego una vez más, los corchetes angulares. Y ahora en realidad tenemos que especificar dos tipos diferentes, o no dos tipos diferentes, sino dos tipos de tipos de datos. En nuestro caso, vamos a hacer una cuerda y una cuerda. Por lo que estos están separados por una coma. Ahora vamos a llamar a esto capitales. Tengo mis razones para eso, que serán evidentes en breve. Y luego es igual a nuevo. Y luego como puedes ver, ya básicamente nos da una sugerencia aquí de que solo podemos autocompletar pulsando o pulsando el botón Tab, agregando los paréntesis y el punto y coma. Y luego nos vamos, tenemos un nuevo diccionario. Ahora un diccionario funciona de la siguiente manera. Por lo que básicamente mapea. Entonces, sólo escribamos esto. Un diccionario mapea una clave. En nuestro caso, esto es una cuerda, ¿verdad? Porque este es el primer tipo de datos que le hemos dado el diccionario a un valor específico, que también es una cadena. Ahora bien, este es básicamente el, el valor clave. A la dinámica se le llama par de valor clave porque vienen en pares, ¿verdad? Y esto ahora se mostrará con mayúsculas. Siendo la idea que, bueno, si tienes un país, que sería la clave, que siempre tendrás un cierto valor para su capital. Eso es bonito, bastante fácilmente comprensible. Y entonces sólo podemos añadir nuevas entradas aquí. Por ejemplo, si ponemos en México, entonces podemos poner en la Ciudad de México como la capital. Y entonces sólo copiemos esto. Unas cuantas veces. Alemania sería Berlín, y después tenemos a Francia con París. Y luego por último pero no menos importante, Estados Unidos con Washington DC. Entonces esos son ahora algunos ejemplos que hemos sumado a esto. Hemos visto previamente en el, tanto la matriz como la lista que podemos conseguir ciertos elementos ahí dentro usando los corchetes y luego poniendo ahora cualquier índice que queramos. Ahora en este caso, eso en realidad no funciona. Como puedes ver claramente, 0 no funciona porque realmente quiere una clave específica, no el índice. Entonces si ponemos una cuerda dentro de aquí y decimos Alemania, por ejemplo, entonces lo que vamos a conseguir es Berlín, porque Alemania es la clave para el valor Berlín, z. Y si volvemos aquí asegurándonos de que estamos en la Conferencia 19 y diccionarios. Entonces podemos ver que Berlín se desconecta porque de hecho es el valor a la clave Alemania. Por lo que esto no es diferente a tener una lista. Pero en lugar de tener las claves ser la posición en la lista, realidad tenemos algo diferente. También podemos quitar un artículo. Entonces por ejemplo, porque yo mayúsculas punto quitar, y entonces sólo podemos quitar a Francia, ¿no? Y esto en realidad básicamente simplemente eliminará esta entrada aquí. Entonces no podemos realmente sacar el, saca un valor Paris de ella porque realmente tiene. Después retira todo el año de entrada. Y si entonces vamos por mayúsculas conteo de puntos, que sería el número de elementos dentro del diccionario. Esto debería ser entonces 3 después de que hayamos retirado Francia. Como se puede ver, eso es tan fácil como va. Sí, y eso es básicamente un, en el diccionario. Un diccionario increíblemente útil de muchas maneras diferentes. Básicamente puede mapear algún tipo de datos a otro tipo de datos. En nuestro caso, ponemos una cadena a una cuerda. Podría haber, por supuesto, algo más. Por ejemplo, podríamos tener la cadena a un entero, y entonces esto sería, por ejemplo, el número de personas que viven en el país o el PIB o algo más. Para que podamos hacer, podríamos hacer todo tipo de cosas con el diccionario. Definitivamente puedo decir que lo mejor es jugar un poco con él también. Hay algunos métodos más a los que también puedes llamar. Bueno, sí, eso es, eso es más o menos una breve visión general de los diccionarios. Y espero que esto te resulte útil. Si hay alguna pregunta, como siempre siéntete libre de preguntar y me aseguraré de responder. Y sí. 23. (C#) bucle de foreach: Muy bien, bienvenidos de nuevo a la introducción C-sharp para el curso de unidad. Y en esta conferencia vamos a echar un vistazo al bucle para-cada. Por lo que esta va a ser una conferencia muy rápida apenas mirando el, en otro tipo de bucle. Entonces después de haber visto que podemos usar listas y hemos visto cómo básicamente podemos pasar por ellas con un for-loop normal. Ahora vamos a mirar realmente en un, otro bucle. A esto se le llama el bucle para-cada. Por lo que podemos simplemente escribir un foreach como palabra clave. Y dentro de los paréntesis, vamos a definir una nueva variable, en este caso una cadena llamada macho. Entonces vamos a escribir en la palabra clave en so i n, y luego vamos a escribir la colección. Esto va a ser machos. Y luego dentro de aquí, vas a tener razón, debug dot log masculino y se van. Y esa es la idea de bucle para-cada es, básicamente puedes leerlo en voz alta y va a tener sentido para cada cuerda macho en machos. Y luego vamos a hacer lo que esté dentro de los corchetes rizados. Entonces en este caso sólo lo vamos a cerrar la sesión. También podría haber algunas otras cosas que podríamos querer hacer. Algo que se menciona en para cada bucles, realmente podemos cambiar la colección. Podemos cambiar los elementos en sí, pero no la colección en su totalidad. Entonces no podemos simplemente quitar algo de la colección, entonces el bucle for-each se romperá que solo podemos hacer en normal para bucles, digamos. Y aun eso, no es del todo ¿qué dirías? No se aconseja. Correcto. Pero vamos a ver si esto funciona. En realidad no necesitamos especificar ningún elemento específico en el bucle for-each. Asegurándose de que estamos en la Conferencia 20 para cada bucle. Llamemos a esto. Entonces el primero, John July Ryan, Maria, y luego tenemos separador, John July, Ryan y María. Por lo que todo queda bloqueado como esperaríamos que lo hiciera. Y ese es el para cada bucle. Esto por supuesto también funciona para diccionarios u otras colecciones. No vamos a mirar a detalle otras colecciones. En esta introducción. No obstante, también hay otros y esto funcionaría también para los diccionarios en teoría, ¿no? Eso es sólo una mirada rápida, corta. Estoy en el para cada bucle. Espero que hayas aprendido algo nuevo. Y si hay alguna pregunta, como siempre siéntete libre de preguntar y me aseguraré de responder. Y sí. 24. (C#) espacios de nombres: Muy bien, bienvenidos de nuevo a la introducción C-sharp aquí para el curso de unidad. Y en esta conferencia vamos a echar un vistazo rápido a un espacio de nombres. Entonces, ¿cuáles son los espacios de nombres? Bueno, sólo vamos a abrirlo, el guión de espacios de nombres y vamos a ver. Entonces les he dicho desde el principio que vamos a ignorar la mayoría de las cosas aquí arriba, mayoría de lo que aquí está escrito. Pero ahora en realidad vamos a echar un vistazo a estas tres cosas. En primer lugar, la palabra clave de uso y luego lo que se escriba después de ellos. Entonces esos son espacios de nombres. Y la idea de espacios de nombres es básicamente de ellos como directorios donde se mantienen ciertas clases, ciertos scripts se mantienen en. Esa es la forma más fácil de conceptualizarlas. Y luego podemos acceder a esas funcionalidades y esas clases si las estamos usando. Entonces, por ejemplo, hay un espacio de nombres particular para la interfaz de usuario de la unidad. Entonces, por ejemplo, hay algo llamado botón, que obviamente es un botón que podemos usar en Unity. Pero como puedes ver, no lo es, no existe. Si pongo botón aquí, no muestra nada. No obstante, si subo aquí y digo usando motor Unity, wi, entonces de repente este botón aquí gira, gira este color azulado. Y esto me dice, jaja, en realidad puedo usarlo. Y puedo usarlo porque tengo el motor Unity wi un espacio de nombres aquí. Y si pasamos sobre él, como se puede ver, namespace, Unity motor wi. Y en realidad podemos usar espacios de nombres en para nosotros también. Por lo que eso también funciona. Podemos agregar uno para el script existente. Por ejemplo, así, simplemente escribimos espacio de nombres. Después ponemos en el nombre del espacio de nombres. lo general, lo que yo diría es que ahora que tienes nombre para tu proyecto, así que eso es una especie de convención. Tienes nombre para el proyecto. Esto, sólo vamos a llamar a nuestro proyecto, en este caso tutorial. Y entonces también puedes dividir eso con espacios de nombres a continuación básicamente. Por lo que puede hacer un espacio de nombres de directorios dentro de un espacio de nombres. Pero no necesitamos hacerlo así donde aterrizamos, por ejemplo, hacemos algunos como espacios de nombres. nombres, ¿verdad? No necesitamos hacer esto. Esto también funciona, ¿verdad? Y entonces lo que hago es simplemente copio rápidamente esto y se van. Entonces tenemos la clase en lugar de un espacio de nombres. Ahora bien, no necesariamente necesitamos hacer esto. No obstante, te voy a mostrar justo después hecho con esto, cómo realmente puedes automatizarlo allí para que automáticamente agregue cada nueva clase que crees en un espacio de nombres. Entonces no tienes que hacer este marcado aquí, así que no tienes que seleccionar todo esto, ya sabes, controlar X4 para cortarlo, Control V para pegarlo, guardarlo todo y luego no necesitas hacer eso. En realidad podemos automatizar esto. Sólo voy a querer mostrarte cómo podrías hacer eso si no tienes un espacio de nombres aquí. Pero generalmente en realidad recomendaría comenzar con un espacio de nombres de todos modos. Uh, pero sí, en realidad no necesitamos definir dos espacios de nombres. Entonces en este caso, esta clase de espacios de nombres sería accesible si fuéramos como, si estamos en otra clase, entonces tendríamos que poner espacios de nombres tutorial dot, y luego podemos usarlo. Ahora obviamente estamos ahora mismo en este directorio en negrita sangrienta específica, digamos así podemos usarlo de todos modos, pero debido a que tenemos dos espacios de nombres aquí, también podemos simplemente hacer este namespaces. Y esto en realidad nos va a ahorrar bastante, bastante espacio aquí porque entonces en realidad podemos hacer todo así y luego no se sangra demasiado porque si tuviéramos, así que por ejemplo, no estoy seguro si Unity UI tiene aún más espacios de nombres por debajo, no lo hace. Pero algunos de ellos como se puede ver. Entonces sistema que colección de genérico tiene como tres ya. Bueno genérico no tiene nada más pero podría ser, tal vez es como en algún momento y luego es genérico W2 y en util dot core o lo que sea. Por lo que puedes tener múltiples espacios de nombres dentro uno del otro. Por lo tanto, lo mejor es, sin embargo, todos tenerlo en una sola línea. La idea es que quieres una especie de separar tu base de código. Entonces si tienes 100 guiones, entonces simplemente no has volado por ahí en tus carpetas, entonces eso puede, bueno, primer lugar, va a llevar a todo mi dios, ¿dónde está mi guión? ¿ Dónde estaba esto? No sé qué hace esto. Y con los espacios de nombres, básicamente puedes especie de crear ciertos grupos de scripts y clases que trabajan en conjunto y tienen un propósito particular. Entonces, por ejemplo, tal vez quieras poner todos tus scripts enemigos en un espacio de nombres específico. Entonces eso sería, por ejemplo, enemigos tutorial dot. O quieres poner todo tu combate en cosas en las clases de combate, en tu espacio de nombres específico que, por ejemplo, podría ser tutorial.com, algo así. Y quizá tengas algunas interfaces que vamos a ver en un video posterior, qué es eso en una conferencia posterior. Algunas cosas que vas a usar a lo largo del código. Se puede, por ejemplo, poner eso en YouTube clase tutorial dot util. Esas serían cosas que ayudarían con todo. Entonces, al igual que las matemáticas, las matemáticas F eran una especie de clase util de alguna manera. Y donde tienes ciertas otras cosas que tal vez quieras poner en un espacio de nombres core. Por lo que hay muchas aplicaciones para ellos. No obstante, ahora mismo, lo que yo diría es que más importante es que yo aconsejaría usarlos definitivamente. Y cuando yo también asesoraría en nuestro caso, porque se trata de una básicamente sólo una clase de clase tutorial C-sharp sobre esto. No lo hice, no tengo esa buena estructura aquí dentro de la carpeta de guiones. No obstante, lo que yo asesoraría personalmente lo que haces es que tu carpeta de script. Por lo que el script siempre debe ser el espacio de nombres raíz. Entonces, así que todo, cada guión que estaría dentro del guión. Entonces si creo un nuevo alcance, sólo por el infierno, lee este. En teoría o este guión de prueba. Desearía que esto estuviera en el tutorial del espacio de nombres. Y luego si tengo otra carpeta aquí, así que por ejemplo, espacios de nombres, entonces querría que cada clase que está dentro de esa carpeta fuera los espacios de nombres de punto de aluminio. Por lo que básicamente refleja tu estructura de carpetas con tu estructura de espacio de nombres. Pero no nos preocupemos por esto ahora mismo. Eso es sólo, sólo una advertencia de la que en realidad no necesitamos preocuparnos. Y ahora en realidad también podemos hacerlo para que cada nuevo script que creamos ya obtenga un espacio de nombres asignado. Y lo podemos hacer yendo a Editar configuración del proyecto. Y luego dentro del editor bajar un poco. Y luego como se puede ver, generación de proyectos C-sharp, espacio de nombres raíz. Y sólo vamos a decir tutorial. Y eso es todo. Voy a guardar esto presionando Control S. Y entonces vamos a crear un nuevo guión aquí. Sólo vamos a llamar a eso, llamémoslo festivo. Seguro. Y si entonces abrimos este script, entonces se puede ver genera con el tutorial de espacio de nombres. Y eso es básicamente todo lo que hay para este momento en el tiempo. No creo que haya nada más para espacios de nombres sea solo una cosita corta. Y no es lo más importante, pero sigue siendo algo que, sobre todo cuando realmente quieres hacer un proyecto en realmente no haría un juego, entonces recomendaría mucho buscar en el, también el convenciones de espacios de nombres. Vamos a echar un vistazo a eso al final de la introducción C-sharp. Una vez más también. No obstante, yo solo algo en lo que pensar y tipo de importante para la expandibilidad y también para entender el código rojo comprensibilidad del código con el fin de básicamente tener es novedades de función semi separadas del código en especie de lugares diferentes, derecho ? Eso fue todo para esta conferencia. Espero que lo hayan encontrado útil. Si hay alguna pregunta, como siempre, siéntete libre de preguntarme, me aseguraré de responder. Y sí. 25. (C#) C# Methods: Muy bien, bienvenidos de nuevo a la introducción C aguda aquí para los núcleos cinéticos. Y en esta conferencia vamos a echar un vistazo a los métodos. Ahora los métodos son una gran parte de la programación y C agudo en general. Entonces, bueno, no perdamos tiempo y veamos qué podemos ver abriendo el script de métodos. También asegurándose de que estamos en la Conferencia 22 métodos. Y vamos a abrirla y ver qué podemos ver. Entonces hemos visto, digamos, métodos en un poco en el abstracto, donde teníamos algunos métodos para cadenas, por ejemplo, los hemos visto. También hemos visto que podemos acceder a los métodos por parte del operador de puntos. Y sí, eso fueron algunas cosas de métodos que hemos visto. Y ahora veamos un ejemplo de, por ejemplo, una vez por qué los métodos serían realmente agradables y realmente buenos de usar en ciertas circunstancias. Y además, solo, empecemos aquí. Vamos a echar un vistazo a. Entonces ahora mismo lo que queremos hacer es que queremos calcular el factorial. Entonces podemos hacer eso muy fácilmente en realidad solo ellos haciendo algo como esto y luego configurándolo a lo que queríamos que calcularan los dos factoriales. Factorial es sólo todo. Entonces si quisiéramos factorial cinco por ejemplo, esto sería exactamente esto cinco veces cuatro veces tres veces dos veces uno. Entonces esto es lo factorial, así es como se define. Y eso es simplemente lo que queríamos calcular ahora mismo. Entonces establecemos el num factorial, y luego tenemos un bucle for que vamos de num menos uno hasta que yo sea más grande o igual a uno. Y entonces en realidad contamos atrás eso. Y entonces decimos tiempos factoriales iguales a I. Y esto es exactamente lo que hace esto porque factorial comienza a las cinco, yo empiezo como cinco menos uno. Entonces a las cuatro, por lo tanto, pasamos y nos veces yo que así 5 veces 4. Y entonces la siguiente va a ser 5 veces 4 veces 3, y así sucesivamente hasta que lleguemos a una, y luego terminamos. Entonces si ahora hacemos un debug dot log factorial es, y luego hacemos de esta manera alrededor de un go. Y luego salvamos factorial. Y en realidad podemos imprimir eso o cerrar sesión en la consola. Y empecemos por C. Lo que esto es, factorial es 2, 120. Por lo que factorial 5 es 120. Ahora. Y ahora lo mío es, bueno en realidad lo que quiero es que en realidad quiero factorial para ocho números diferentes. Fui factorial por ejemplo, por siete y también quería por la noche, y también lo quiero para D. Y estaba pensando en tenerlo para 11 también. Y ahora nos metemos en un tema porque ahora tenemos que tomar esto y tal vez copiado como ocho veces o algo así. Y eso es por supuesto. Eso es absolutamente ridículo. No tiene ningún sentido. Esto es lo que métodos de guerra. Entonces básicamente podemos tomar todo el asunto aquí y ponerlo en un método y luego llamarlo tantas veces como queramos. Y para hacer eso, lo que vamos a hacer es ir fuera de este método almacenado porque este también es un método por cierto. Y a este método se le llama cuando un cierto, uh, cuando el juego básicamente comienza. Vamos a la forma más fácil de conceptualizar esto ahora mismo. Entonces vamos a salir del corchete rizado aquí, y vamos a teclear lo siguiente. Vamos a escribir en int público y luego el nombre del método factorial. Dentro de ella, vamos a escribir número int, y voy a explicar rápidamente lo que esto significa. Ahora, vamos a tener una flecha aquí por el momento. La preocupación por eso, lo vamos a arreglar pronto. Sólo voy a explicar rápidamente, explicar como la idea de este método y qué, qué todo esto, esto se llama el modificador de acceso. Vamos a echar un vistazo a eso un poco más tarde también. Entonces básicamente cuáles son los modificadores de acceso y qué hacen exactamente. Público en este caso, simplemente significa que podemos acceder a él desde cualquier lugar. También tenemos el tipo de devolución. Por lo que este es el tipo de datos que se devuelve al llamar a este método. En este caso, es un entero. Como se puede ver aquí en el método de inicio, en realidad es nulo. Y vacío significa que no devuelve nada. Integer en este caso obviamente devuelve un entero. Después tenemos el nombre del método, después tenemos los paréntesis. Y dentro de ahí hay parámetros y primero se da el tipo de parámetro y luego el nombre del parámetro. En este caso, queremos darle un, un entero llamado número. Y este número es básicamente este num aquí que hemos usado aquí. Entonces tomemos esto y lo copiemos. Ahora algunas cosas que realmente no necesitamos. Sólo necesitamos conseguir factorial aquí. Y en realidad no necesitamos hacer esto. Y no necesitamos hacer esto de todos modos. Déjame solo necesito hacer en realidad podemos incluso hacerlo un poco más fácil haciendo número, van. Y entonces aquí sólo necesitamos reemplazar esto por número y luego ya está. Y luego también regresan, regresan factorial, el ego. Y ese es el método factorial ahora hecho. Y lo que podemos hacer ahora es si solo copiamos rápidamente esto y decimos con un método, entonces podemos decir factorial que 25, algo así como método es. Y luego llamamos factorial. Y como puedes ver, en realidad está aquí con este tipo de cubo ahí dentro. Y luego lo pasamos, por ejemplo seis. Y luego vamos a copiarlo sobre él y dejarlo hacer cinco también, sólo para que podamos asegurarnos de que realmente funcione. Pero estoy bastante seguro de que sí. Y se puede ver, también podemos ver que esto es un, tiene dos referencias porque en este caso, nuestro método se llama 2 veces 1, 0, 1, 1 aquí. Y veamos si eso realmente hace algo, pero estoy bastante seguro de que sí, sí. A 120. Y luego con el método también es un 120 cuando lo pasamos al cinco y el seis es 720. Entonces los métodos son una herramienta increíble y algo que es realmente, realmente importante. Hay algunas puntas centrales de métodos, por ejemplo, que cada método solo debe hacer una cosa y una sola cosa. Los nombres no deberían ser demasiado largos, algo así. Pero esas son algunas convenciones que, como dije. Ah, así que vamos a echar un vistazo al final de la introducción de C-sharp también. En este momento, los métodos son simplemente una forma de contener básicamente ciertas instrucciones que queremos hacer. Muchas veces. Es una forma de nudos de reutilizar código sin copiarlo. Esa es también una especie de forma en que podemos conceptualizar los métodos. Entonces es una forma de reutilizar el código sin copiarlo. Y eso siempre es una buena indicación si has copiado. Entonces si necesitábamos este código factorial ocho veces R, como dije, eso sería un candidato primo para asegurarnos de que haya un método fuera de esto porque, tiene sentido si tan pronto como empieces, tal vez si empiezas a usar algo dos veces, puedes debatir sobre, bueno, realmente no necesito un método para ello. Pero cuando comienzas a usar unas líneas de código en particular, como por tercera vez, es hora de hacer un método con él. Creo que esa es una buena regla de oro. Sí. Pero esos son los métodos C Sharp. También quería mencionar que a veces la gente puede referirse a ellos como funciones. Es, básicamente es lo mismo. Por lo general, en mi estimación por lo que he escuchado, unos métodos están atados a objetos y las funciones son una especie de flotación libre. Pero por lo general se puede, hay sinónimos el uno para el otro. Por lo que puedo decir que se trata de funciones C-sharp o métodos C-Sharp. Por lo general, alguien debe entenderlos como iguales. Pero podría haber algunas personas que son como realmente pedantes eran como. Eso no es correcto. Escritores como yo estoy bien, sí. Correcto. Esto sería un método. Una función es algo ligeramente diferente. No obstante, puedes usar los términos indistintamente, ¿verdad? Eso fue todo por la conferencia de métodos. Espero que lo hayan encontrado útil. Y como siempre, si hay alguna pregunta, siéntete libre de preguntar y me aseguraré de responder. Y sí. 26. (C#) sobrecarga: Muy bien, bienvenidos de nuevo a la interrupción aguda C para el curso de la unidad. Y en esta conferencia vamos a echar un vistazo a los métodos de sobrecarga, o también llamado sobrecarga de métodos. Entonces esto es básicamente una continuación de lo que podemos hacer con los métodos y sin embargo tan poco, algo que es semi importante saber qué se puede hacer. Entonces, solo abramos el script de sobrecarga aquí y veamos qué podemos hacer. Entonces lo primero que vamos a hacer es que vamos a crear un nuevo método y vamos a hacer que devuelva un entero y llamarlo multiplicarse con dos parámetros, a y b. Y como su nombre indica, Va a devolver un veces B. Ahora por supuesto, definir tal método no tiene sentido en el sentido de que, bueno, es bastante fácil simplemente escribir un tiempo b. incluso si tenemos múltiples parámetros aquí, así que a, B, C, D, E, F, G tal vez el conjunto alfabeto. Siempre podríamos escribirlo como a veces b veces c y así sucesivamente. Por lo que normalmente este tipo de método no es algo que realmente necesitamos. No obstante, es fácil demostrar con este método, el concepto de sobrecarga de método. Entonces lo que podemos hacer es que podemos registrar, así que debug dot log. Y entonces podemos hacer multiplicar y luego por ejemplo, algo así como 10 y tres. Por lo que esto devolvería 30. Entonces vamos a ver si eso realmente funciona. Asegurándose de que el método sea correcto. Conferencia 23, sobrecargando como la escena y vamos a ver, sí, son 30, así que eso es bastante bueno. Y ahora lo puedes hacer es que podemos definir un segundo método, también llamado Multiply. Ahora esto es, aquí es donde se pone interesante. Por lo que tiene que tener exactamente el mismo nombre que éste. Por lo que el nombre tiene que ser el mismo también con mayúsculas y minúsculas como será el mismo. No obstante, lo que podemos hacer es cambiar el número de metros y luego esto es un, un método sobrecargado. Entonces por ejemplo, si agregamos el entero c aquí como parámetro, y luego hacemos esto, y luego podemos regresar, por ejemplo, a veces B veces C. También podríamos regresar, por cierto, esto es justo como ejemplo. También podemos volver multiplicar AB veces C. Por ejemplo, podríamos, podríamos devolver eso, ¿verdad? Para que podamos, podríamos llamar al otro método. Y como puedes ver en este momento, no hay errores. A pesar de que tengo dos métodos con el mismo nombre. ¿ Cómo, cómo sabe el programa cuál tomar? Uno tiene tres parámetros y uno tiene que permanente. Entonces si copiamos esto con Control C y luego Control V pegándolo, lo que podemos ver es si empezamos con la multiplicación, en realidad podemos ver que hay, ¿escribí eso mal? Yo no negué NO. Multiplicar. ¿ Me estoy volviendo loco? No me voy a enloquecer bien. Por un segundo, estaba pensando que esto se multiplica. Ahora lo que tenemos que hacer es sí, tenemos que empezar eso. Perdón, Exactamente. Entonces como puedes ver, uno de dos. Por lo que ahí se da cuenta de que hay dos métodos llamados multiplicarlo. Y él es como, De acuerdo, uno de ellos tiene int a y b y a, uh, toma esta flecha, click en esta flecha, luego podemos ver en a en B y C. Entonces podemos tomar esto por ejemplo, podemos decir 524 por ejemplo. Y luego también cierra debug dot log. Por lo que esto también funciona. Y entonces lo último que podemos hacer, por ejemplo, es multiplicar con flotadores. Entonces vamos a devolver un flotador y vamos a multiplicar flotadores una vez más, regresar a veces b no es nada loco en este caso. Y entonces también podemos copiar esto. Y luego por ejemplo, decir algo así como 3.512 para F, por ejemplo. Y esto es, Es lo mismo, es el mismo nombre para los tres métodos. La única diferencia es esa parte de la firma del método. Por lo que este sería el, el modificador de acceso, el tipo de retorno, el nombre, y los parámetros. Ellos lo son. Algunas de esas cosas son diferentes, a saber, los perímetros y también quizá el tipo de retorno. Y eso es la sobrecarga de método. Puede suceder a veces, a veces hay algunos métodos que tienen diferente número de parámetros porque tal vez haya algo que pueda, sabes, a un método se le puede llamar uno o dos o tres parámetros diferentes, y cualquiera de ellos está bien. Por lo que podemos llamar al método con uno o en este caso con 23. Y entonces por supuesto podríamos sumar a esto, ¿no? También podríamos tener una multiplicación con a, B, C, D, y así sucesivamente y así sucesivamente. Pero solo, solo te muestra que puedes tener métodos que se definen varias veces con el mismo nombre pero firmas diferentes, como el diferente número de parámetros o diferentes tipos de parámetros. Y eso te permite sobrecargar esos métodos. Es un concepto importante que definitivamente haber visto. Y lo mejor que hay que hacer aquí es simplemente jugar un poco con él, sobre todo después de los métodos. Esa es una especie de un próximo gran paso. Y entonces el método de sobrecarga es un poco encima de eso. Entonces definitivamente sugeriría simplemente jugar un poco con él, solo definir unos cuantos métodos usando algunas de las palabras clave y estructuras anteriores y declaraciones que hemos aprendido a jugar con eso un poco y solo ver lo que se puede ver. Y entonces eso es lo mejor que puedo. Básicamente consejos en este punto, ¿verdad? Espero que esto te resulte útil. Si hay alguna pregunta como siempre, siéntete libre de preguntar y me aseguraré de responder. Y sí. 27. (C#) clases y objetos: Muy bien, sigamos con la introducción C-sharp aquí para el curso de unidad. Y en esta conferencia vamos a echar un vistazo a clases y objetos. Probablemente uno de los temas más importantes en C-Sharp en este caso. Porque C sharp, como se podría saber, es un lenguaje de programación orientado a objetos. Y las clases y los objetos son una especie de uno de los bloques de construcción más básicos de este tipo de abstracción. Por lo que la programación orientada a objetos es solo una abstracción. Entonces decimos que todo es un objeto. Y ciertos objetos tienen miembros y métodos. Y podemos crear nuevos objetos y nuevas clases. Y sí, sólo echemos un vistazo a esto. Entonces, en lugar de abrir nuestro script de clases y objetos, en realidad vamos a crear un nuevo script haciendo clic derecho en la carpeta de objetos 24, 25 clases y luego vamos a crear y luego C script agudo. Y vamos a llamar fruta a este archivo. Justo después de haber creado el archivo de frutas, podría recibir una advertencia aquí. No te preocupes por eso. Eso no importa ahora mismo. Lo que importa es que hemos creado esta clase de frutas y este archivo de frutas. Y voy a hacer doble clic en él y luego lo abriremos. Ahora como puedes ver, hay un montón de cosas aquí, y en realidad no queremos eso. También a notar, ahora tenemos dos archivos abiertos. Entonces si también abres los objetos de clases, vas a tener ambos abiertos y puedes cambiarlos. Son solo pestañas simples como en un navegador básicamente. Y esas son las diferentes clases que tenemos abiertas en este momento. Ahora, vamos a hacer es vamos a borrar todo lo que hay dentro de aquí. Entonces sólo vamos a marcar todo. Y luego vamos a golpear Enter para que todo se borre. Y este comportamiento modelo y este colon también eliminarán para que solo hayamos escrito aquí fruta de clase pública, y luego los corchetes rizados, y eso es todo. Eso es todo lo que queremos dentro de aquí. Y luego dentro de nuestras clases y objetos, estamos una vez más en lugar del método de inicio y en realidad ya podríamos hacer algo, pero pensemos en una fruta. Por lo que queremos crear una nueva fruta. Ahora, cuando pensamos en una fruta, bueno, ¿qué hace una mitad de fruta? Entonces estamos pensando en una especie de atributos de una fruta, ¿verdad? Entonces una de las cosas que podría tener una fruta en particular es un número, un nombre, ¿verdad? Entonces mango, eso es, eso es un nombre para una fruta y un plátano. Y también tendría una manzana, ¿verdad? Entonces ese sería un nombre para una fruta. Por lo que todas las frutas tienen nombre. Yo diría que eso tiene sentido. Ahora podríamos pensar, bueno, ¿qué diferentes atributos tiene también una fruta? Bueno, tal vez tenga un contenido de azúcar, ¿no? A lo mejor tú y yo vivimos sanos y tú quieres saber, yo quiero saber el contenido de azúcar, ya sabes, vamos a estar seguros sobre eso. Entonces mejor saber eso, ¿verdad? Entonces ese es el contenido de azúcar. Y entonces tal vez otra cosa podría ser un color por ejemplo. Entonces vamos a hacer una nueva cadena llamada color. ¿ Verdad? Ahora esos tres atributos, esto es lo que llamaríamos campos. Entonces esos son campos de esta clase en particular, la fruta. Y se puede pensar en ellos como básicamente los atributos que tiene cada fruta, ¿no? Entonces cada fruta tiene cierto contenido de azúcar, cada fruta tiene un cierto color, y cada fruta tiene un cierto nombre. Ahora bien, podría haber mucho más atributos de los que tenemos en este momento. Por lo que hay mucho más que estos tres. No obstante, nos vamos a quedar con estos tres sólo para que sea sencillo, ¿verdad? Y ahora en realidad ya podemos usar esto y en realidad ya podemos hacer algo con raíces para que realmente podamos crear una nueva fruta aquí mismo. Entonces lo que vamos a hacer es que vamos a teclear fruta. Y como pueden ver, en realidad ya nos sugiere esto y vamos a crear una fruta nueva y lo vamos a llamar plátano. Y luego vamos a decir igual a fruta nueva, luego terminar con los paréntesis. Entonces como si estuviéramos llamando a un método, como pueden ver, aquí no hay ningún error. Y esto no debería ser demasiado loco. Por lo que esta parte de la construcción es simplemente una vez más una declaración de una variable. Entonces esto no es nada como que no haya diferencia entre este año y en x Básicamente, esta es simplemente una nueva variable que hemos creado. Y esta variable, en este caso es de tipo de fruta. Entonces lo único que ha cambiado aquí es que no estamos usando los tipos de datos primitivos. Entonces los tipos de datos primitivos para string e integer y así sucesivamente y así sucesivamente. Ahora hemos creado una especie de tipo de datos complejo, pero hemos creado nuestra propia clase y eso se llama Fruit. Y este año la asignación básicamente. Y tenemos el Mu, tenemos la nueva palabra clave que hemos visto con las listas antes. Y ahora, sin embargo, hemos creado un nuevo fruto. Y esto podría parecer un poco raro al principio. No obstante, esto es básicamente sólo el, uh, como, uh, es básicamente justo como una llamada de método. No obstante, en este caso, codificamos el constructor. Por lo que este es un método muy especial que está relacionado con clases y objetos. De esta manera, en realidad creamos una nueva instancia de esta clase. Y sí, así que vamos a ver lo que en realidad también podemos hacer es usar esto un plátano y podemos hacer con el operador de puntos. En realidad podemos, como puedes ver, vas y accedes al color y podemos acceder al nombre y al eje, al contenido de azúcar. Por lo que en realidad podemos acceder a todos estos campos como puedes ver, como se les llama. Y, y sin embargo se puede acceder a ellos. Entonces, por ejemplo, podríamos decir, bueno, un nombre de punto banana es igual a un plátano, por ejemplo. Lo cual tendría sentido. No obstante, en el tema aquí siendo realmente tendríamos que pasar por cada uno de esos y crear un nuevo nombre de punto banana y luego 80 nano un contenido de azúcar de punto banana igual a, no lo sé, como 15 y así sucesivamente y así sucesivamente. Bueno, eso parece un poco tedioso. No obstante, en realidad podemos hacerlo un poco más fácil usando este constructor y realmente haciendo nuestro propio constructo. Por lo que hay una manera fácil con eso podemos hacer nuestro propio constructor. Y eso es presionando Alt. Entrar. Como puedes ver, entonces obtienes esta sugerencia de Generar Constructor aquí, y vamos a hacer esto y ahora podemos escoger qué miembros queremos. Por lo que sólo podemos tener que poner la garrapata aquí. Tenemos que decir, vale, ¿qué miembros queremos tener como parámetros en el constructor? Solo vamos a dejar, tener todo seleccionado y decir, acuerdo, y luego como puedes ver, creó un nuevo constructor para nosotros con parámetros aquí y también las asignaciones. Entonces el, esta palabra clave simplemente se refiere al objeto que se está creando. Por lo que hay que separar básicamente dos cosas. La clase en sí es básicamente una plantilla a partir de la cual luego creamos un objeto y que luego existe. Y entonces también tenemos los parámetros que pasamos por el constructor aquí, y esos también son separados. No obstante, luego se guardan en el objeto. Como se puede ver aquí ahora, en realidad estamos recibiendo un, un error porque no hay argumento dado que corresponda al nombre del parámetro formal requerido, y así sucesivamente y así sucesivamente. Lo que eso solo significa es que aquí no tenemos suficientes parámetros y entonces podemos arreglarlo. Bueno, podríamos arreglarlo ya sea poniendo plátano y luego un contenido de fruta y luego un color. O porque lo que pasa es que antes funcionaba y entonces ¿por qué no funciona ahora? Bueno, en realidad hemos anulado el constructor normal, el, el, el constructor básico. Y eso es sencillamente, eso fue esto. Entonces fruta. Ah, ahí tienes. Y luego éste, lo hemos sobrescrito porque y hemos creado el nuestro. Y esto básicamente cuando tienes una nueva clase, esto normalmente se genera. Entonces esto siempre está ahí dentro, aunque no lo veas. No obstante, en cuanto hagas tu propio constructor, esto básicamente ya no funciona. Y ahora tenemos que escribirlo explícitamente y decir: Vale, esto ahora también es constructor y luego esto funciona. Como puedes ver ahora, no hay más error. Pero lo que podemos hacer ahora es que podemos crear una nueva fruta. Entonces, por ejemplo, podemos decir una, una manzana. Una manzana es una fruta nueva. Y esto tiene el nombre de manzana. Y tiene un contenido de azúcar de 10, por ejemplo, y un color rojo. Y de esta manera ahora hemos creado una manzana con el nombre Contenido de azúcar de manzana de 10 y luego el color rojo. Entonces, por ejemplo, podemos decir debug dot log, y luego podríamos decir un nombre de apple dot. Y luego vamos a imprimir o registrar todo, el contenido de azúcar y también el color. ¿ Verdad? Entonces, veamos si eso funciona. Asegurándose de que estamos en conferencias 24, 25 clases y objetos. Y vamos a correr esta manzana 10 y leer, bueno, ¿no es genial? Eso es bastante bonito. Eso funciona muy bien. Y volvamos rápidamente una vez, una vez más a la fruta aquí. Y una de las cosas que es señalar que vamos a mirar en, creo, dos conferencias. Es la palabra clave pública aquí. Vamos a averiguar qué es eso. Esto lo hemos visto muy pronto con el modificador de acceso, lo siento, con los métodos. Entonces este fue el modificador de acceso. Y lo hemos visto con los métodos que también los hicimos públicos. Esto simplemente significa que se nos permite acceder a estas variables en este caso. Y sí, esa es básicamente la idea que sólo voy a poner rápidamente. Entonces esto es, por lo que este es el constructor muy importante y utilizado para crear nuevas instancias. Entonces eso es básicamente Clase de esta clase. Entonces se puede decir, bueno, esta es una nueva instancia. Entonces aquí el, una manzana es una nueva instancia, o se puede decir que este es un nuevo objeto. Este tipo de especie de indistintamente. Pero sí, esa es la visión general básica de la de clases y objetos y también cómo crearlos. Un ejemplo más, sólo para que te deje con, es, se podría pensar, por ejemplo, un, se podría pensar en un enemigo. Y un enemigo podría ser una clase. Entonces tendríamos una clase enemiga. Y luego una clase Emmy, por ejemplo, tiene puntos de hit enteros, y así sucesivamente y así sucesivamente. Y eso es tal vez algo que está un poco más estrechamente relacionado con el propio desarrollo del juego. No obstante, creo que hay ejemplo de fruta también muestra un poco, definitivamente sugeriría mirar las próximas conferencias antes de probar algunas cosas. Por lo que diría que probablemente hasta que estemos en la Conferencia 28 a través de donde hablamos de las propiedades. Creo que debes mirar a través de esos y luego cuando terminemos con ellos, entonces yo, entonces creo que entonces puedes jugar con las clases y los objetos. Hay algunas cosas más que tenemos que mirar antes de que puedas, antes te sugeriría que realmente te sumerjas, claro, puedes sumergirte en cualquier momento y probar cosas nuevas tan pronto como quieras. Pero eso es sólo una simple sugerencia de mi parte. Pero sí, eso fue todo para la conferencia de clases y objetos aquí. Muy importante. Si hay alguna pregunta, realmente siéntete libre de preguntar y me aseguraré de responder. Y sí. 28. (C#) miembros de la clase: Muy bien, sigamos con la C aguda introducción para el curso de unidad. Y en esta conferencia, vamos a echar un vistazo a los miembros de la clase. Y esto es básicamente un poco de profundización en la comprensión de las clases. Entonces echemos un vistazo a nuestra clase de frutas y pensemos de nuevo. Entonces tuvimos las, estas variables que declaramos. Y esos son campos, ¿verdad? No obstante, también son miembros. Entonces los miembros son básicamente una forma elegante de decir, bueno, esto es parte de una clase y un campo simplemente significa que esto es una variable. Ahora, otros miembros incluyen, por ejemplo, un método. Entonces, solo creemos un nuevo método. Entonces por ejemplo, un vacío público, comer fruta, que simplemente va a hacer lo siguiente. Entonces esto es, conseguimos el formato correcto. Ahí lo tienes. Esto simplemente se va a depurar punto log fruit. Y luego vamos a decir, esto.nombre se ha comido, ¿verdad? Entonces en este caso, en realidad no necesitamos el, esta palabra clave aquí nombre se puede simplificar. Por lo que también podemos simplemente escribir nombre porque el programa sabe bien, significa este nombre. No obstante, personalmente, a veces use el, esta palabra clave aunque no sea necesaria. En mi caso, creo que a veces lo hace un poco más claro y se puede ver un poco más cerca, vale, esto, con el, esta palabra clave, se entiende un, básicamente un miembro o un campo de esta clase en particular. Pero esa es en gran medida una elección estilística. No tienes que hacer esto. Yo sólo quería mencionar, sin embargo, ahora tenemos un nuevo método llamado comer fruta. Ahora, ¿qué podemos hacer con esto? O sea, ¿es tan fácil como llamar, por ejemplo, una fruta de punto de manzana? Y sí, En realidad eso es lo fácil que es. Entonces un punto de manzana come fruta como puedes ver, y ahora también puedes ver que hay algunos otros métodos que podríamos llamar. Esas son simplemente cosas de la clase de objeto que cada objeto es, es básicamente una parte de. No obstante, hemos creado esto, comemos fruta, y vamos a llamar a esto, y vamos a ver qué pasa. Entonces si hacemos esto, entonces después de la salida roja, deberíamos ver que fruta, manzana se ha comido. Eso es lo que debe decir la salida. Entonces vámonos. Eso en realidad sí funciona. Bueno una vez que empezamos van y fruta, se ha comido manzana. Bueno, eso es bastante bueno. Eso es bastante bueno. Sí, y podemos hacer todo tipo de cosas con estos métodos básicamente. Entonces en este caso, es un vacío por lo que no devuelve nada. No obstante, podemos por supuesto, también hacer otras cosas y podemos crear diferentes métodos que devuelvan cosas diferentes. Entonces vamos a ver, por ejemplo, en próximas conferencias es cuando entrenamos a nuestro modificador de acceso, tal vez tengamos que hacer algo. Ellos son algo así. Y esto es realmente genial. Por lo que podemos crear las nuevas clases que no sólo tienen diferentes variables en ellas, sino que también tienen diferentes funcionalidades donde podemos usar esas variables, posiblemente manipularlas. Y sí, así que esta es una de esas cosas. Entonces, en general, los integrantes son básicamente solo partes de la clase. Entonces en este caso, campos que básicamente son solo variables. Y luego también hay nuevos métodos que podemos llamar para el en esos objetos y en esas clases, pero en los objetos podemos llamarlos en la instancia específica. En este caso una manzana. Podríamos por supuesto también decir un punto de plátano comer fruta. Eso también funcionaría. Sí, y eso es, sólo quería mostrártelo. Por lo que principalmente el método. Eso es bastante guay. Y luego también solo asegurándote que entiendes básicamente la terminología al menos un poco. No es absolutamente necesario, pero solo quería dártelo, el suelo que lo conoces. Entonces esos son campos. Y entonces este es un método y este es un miembro y los campos también son miembros. Sí, así que eso es todo para los miembros de la clase. Pequeña conferencia. Espero que lo hayan encontrado útil. Si hay alguna pregunta como siempre, siéntete libre de preguntar y me aseguraré de responder. Y sí. 29. (C#) miembros estáticos: De acuerdo, sigamos con la introducción C-sharp aquí para el curso de unidad. Y en esta conferencia vamos a echar un vistazo a la palabra clave estática. Ya hemos visto algunas palabras clave antes, pero ahora la palabra clave estática también forma parte de clases y objetos. Por lo que todavía vamos a necesitar la clase de fruta. Pero también necesitamos por vía vocal esta clase de gripe y el guión de frutas en este caso, y el script de palabras clave estáticas también. Asegurándose de que estamos en la Conferencia 26, estática en este caso. Y vamos a abrir el script de palabras clave estáticas. Y antes de que podamos hacer algo aquí, en realidad tenemos que modificar de nuevo el guión de la fruta. Y vamos a crear un nuevo campo, y eso va a ser un campo estático. Entonces vamos a hacer una nueva pública estática int. Podemos llamar a este num de frutas. Por lo que este es un nuevo campo estático llamado un num de frutas. Entonces ahora mismo no hace nada. Es solo sentado ahí como puedes ver, si me cierro sobre él, puedes ver que dice campo, estática, int fruit, numéricos. Entonces no hay nada realmente especial pasando aquí mismo. Ahora lo que vamos a hacer es cada vez que se llame a este constructor, vamos a decir num of roots plus, plus. Ahora esto va a tener un problema porque esto en realidad en este momento no está realmente inicializado. Entonces vamos a decir, bueno, esto es igual a 0 porque ahora mismo no hay frutas, ¿verdad? Por lo que este num de frutas es número de frutas. Solo, ya sabes qué, seamos, seamos buenos programadores y de lo contrario en realidad lo llamemos número de frutas porque el BER, eso realmente no cambia mucho cuando se trata del nombre. Por lo que el número de raíces es igual a 0. Y luego cada vez que se llame a uno el constructor, vamos a llamar a este número de socket. Eso está bien, Eso está bien. Y luego nos comemos la fruta. También podemos decir, bueno, qué tal entonces en realidad vamos a menos lo menos porque se ha comido. Entonces el fruto es Dios, pesar de que no se ha ido del todo para que técnicamente no se haya ido. Solo pensémoslo así. Bueno, bien, pero quiero decir que eso no nos lleva a ninguna parte porque si una fruta tiene eso, entonces podemos crear una fruta nueva, por ejemplo, un plátano otra vez. Y vamos a decir fruta nueva. Y no dirá nada. Amino k es. Entonces podemos decir, bueno, un plátano punteará un número de, bueno, número de Froude, número Froude. ¿ Por qué no puedes acceder a ella? Bueno, eso es raro. Bueno, si miramos esto, esto no es llamable porque se trata de un miembro estático o de un campo estático en este caso. Pero también miembro estático no se pudo enfriar desde el objeto a banana. Bueno, en realidad tenemos que llamarlo vía la clase. Por lo que en realidad tenemos que teclear en número de punto de fruta de frutas. Y esto es lo loco de, bueno, en realidad sólo depuremos dot log esto. Porque entonces en realidad podemos ver que esto debería ser uno después de haber creado este nuevo alimento, vamos a guardar eso. En realidad es el caso. Y luego te voy a explicar por qué la palabra clave estática es tan impresionante. Interesante, Así que eso es un 0. Podemos, estoy seguro de que podemos averiguar por qué. Entonces pensemos en esto. Bueno, porque hemos puesto esto en este constructor y encendido en este constructor. Bueno, ese es por supuesto un asunto real. Entonces, solo copiemos esto y lo pongamos aquí también. Para que si llamamos a este constructor, también vamos a aumentar el número de raíces. Entonces estoy bastante seguro de que vamos a tener hace un día y ahí está el uno. Ahora por qué es tan grande la palabra clave estática. Bueno, a esto lo llamamos usando la propia clase. Entonces decimos fruta punto número de frutas. ¿ Por qué eso de alguna manera es un especial o algo así? Bueno, esta variable, este campo en este caso, es en realidad completamente independiente de cada fruta en particular. Entonces en el caso de la cantidad de frutas, realmente no tiene sentido almacenar cuántas frutas hay con cada fruta. Porque antes que nada, realmente no tiene sentido porque por qué un plátano sabría cuántas frutas hay en este muro mundial, como un plátano en particular. Esa parrilla no tiene sentido. Pero también que cada fruta en particular sabría cuántos alimentos hay. Ya sabes, eso es, eso no tiene sentido. Por lo que también podrías llamar a este tipo de variable global. Digo esto con, ya sabes, con precaución, pero se puede pensar en ello como una variable global que existe una para la fruta de clase, no una vez para cada uno de los objetos que se crean a partir de la fruta. Por lo que sólo existe una vez. Se puede pensar en lo estático, también puede ser, también se puede tener métodos estáticos en este caso. Entonces digamos estáticos. Y entonces podríamos decir simplemente evitar por ejemplo, y luego simplemente conseguir número. Hagámoslo. Sí, consigue número de frutas. En este caso. En realidad estamos, vamos a hacer de esto un entero y luego tener este número de retorno de frutos de esto. Por supuesto, en este caso, no es realmente necesario, sin embargo, sólo para ilustrar el hecho de que también podemos tener métodos estáticos. Métodos estáticos la mayor parte del tiempo de yo no diría la mayor parte del tiempo, pero algunos del tiempo pueden ser, por ejemplo, una especie de métodos de ayuda. Pueden ser una especie de generar métodos generadores. Por lo que podrías tener algo así como un público buscar fruta, generar fruta. Por lo que entonces generaría un frutos aleatorios. Entonces por ejemplo. Sí, sin embargo, la idea de estática es solo que no está atada a un objeto específico, está ligada a la clase específica. Entonces eso es realmente importante. A veces, sobre todo al principio. La diferencia ahí puede haber un poco mal entendida tal vez o tal vez un poco más difícil de comprender. No obstante, creo que una vez que tú, una vez que nos pongamos en marcha y veamos algunos ejemplos más de esto, estoy seguro de que vamos a descifrar como un poco más rápido. De acuerdo, ¿qué es esto? ¿ Cómo funciona esto? ¿ Qué es esto exactamente? Pero ahora mismo, ¿qué dicen que la palabra clave estática realmente útil? Y también se puede ver esta última cosa. Entonces si hago este número de puntos de frutas, como se puede ver, eso no funciona porque esto es exactamente lo mismo que hemos hecho antes, donde un número de puntos banana de raíces no funciona porque el número de frutas no está atado a un objeto de una fruta o como instancia de una prensas de frutas atadas a la clase. Eso es todo para la palabra clave estática. Sí, lo es, es increíblemente útil. Puede ser realmente útil y lo hay, hay un montón de aplicaciones reales para ello. Y en el futuro, definitivamente vamos a ver más y más a medida que continuamos por la introducción de C3b, además de entrar en la parte de unidad del curso porque lo son, vamos a tener un montón de métodos estáticos y también campos. Entonces, sí, si hay alguna pregunta sin embargo, siéntete libre de preguntar y me aseguraré de responder. Y sí. 30. (C#) Modificadores de acceso: Muy bien, sigamos con la introducción C-sharp para el curso de unidad. Y en esta conferencia vamos a echar un vistazo a los modificadores de acceso. Entonces modificadores de acceso, hemos visto antes el modificador de acceso público cuando estábamos hablando de métodos y también cuando hablamos de clases. Y ahora básicamente vamos a sumergirnos aún más en esos y ver cuáles son los diferentes tipos y qué bien podemos hacer que suceda con ellos. Entonces, por ejemplo, Vamos a abrir nuestro script de acceso y también asegurarnos de que abramos el guión de la persona que está aquí. Es decir, vamos a usar la clase Persona en este caso, y no vamos a continuar con la, uh, con la muy bonita clase de frutas. Nos vamos a apegar a persona ahora mismo. Entonces, ¿qué tiene la persona? Bueno, digamos que una persona tiene un nombre de pila y una persona tiene un apellido. Y esos dos serán públicos. Y esos ahora serían accesibles en todas partes. Ahora en todas partes, por supuesto, no quiere decir literalmente en todas partes. No obstante, dentro de nuestro programa, en todas partes del programa, si se crea una persona nueva, se podría leer el nombre y apellido. Vale, eso es justo, eso no es demasiado loco. También podríamos pensar, bueno, quizá tengamos un entero h y queremos que eso esté protegido. Tan protegido la edad int. Y esto ahora es un poco más complejo. Y esto básicamente es accesible para la clase misma. Entonces todo lo que escribo dentro de los corchetes rizados aquí entre para esta clase, ¿no? Entonces si tengo un método aquí dentro, puedo ir a la edad y cambiarlo y usarlo. De lo que termino. Esto también se puede acceder, tan accesible, tan accesible para todos por sí mismo, ¿no? Entonces esto es por la propia clase, clases finales derivadas de esto. Ahora eso es un poco raro. De acuerdo, ¿qué es eso? Bueno, esto es frío en la heredad y de esto se va a hablar en una futura conferencia, muy importante. No obstante, quería mostrarles la palabra clave protegida, en este caso, en ella es utilizable en la clase de persona, pero no, no fuera de ella. Entonces si bien me vendría bien, podría hacer , por ejemplo, ahora hagamos el último y luego vamos a ver un ejemplo de esto. Por lo que el último sería privado. Y esto es, por ejemplo, una cuerda. Entonces por ejemplo, un número del Seguro Social. Eso parece algo que probablemente sería mejor ser sólo accesible. Accesible sólo por esta clase. Porque no quisiéramos que nos leyeran ni tampoco quisiéramos que esto fuera cambiable. Entonces si creamos el constructor pulsando una vez más Alt y luego en Generar Constructor, vamos a tener los cuatro campos como perímetros. Y sólo nos vamos a quedar con esto. A mí me gusta esto. Gracia. Entonces podríamos, por ejemplo, pensar en algo como esto. Por lo que también podríamos hacer un método privado o público. Entonces hagamos un bool privado es de edad de beber, por ejemplo, podríamos hacer eso y esto podría entonces devolver una edad booleana mayor o igual 21 si estamos en Estados Unidos, si somos obstáculo en Alemania, por ejemplo, esta sería 16. Dependiendo de qué tipo de licor. Dejemos eso fuera de la ecuación. Sólo nos quedemos con 21 en este caso. Como se puede ver, la edad, no hay tema. Puedo acceder a ella aquí. Puedo cambiarlo. También seguridad social, mi lo cambié aquí. No es un problema más si ahora entras en nuestro script de acceso y vamos a crear una nueva persona. Entonces vamos a crear una persona de Frederick. Entonces cállate de ti. Y vamos a crear una nueva persona. Y por supuesto, FirstName es retórica, y entonces el apellido va a ser Johnson. Si puedo escribirlo, se van y él va a tener 26 años. Y el número de la seguridad social, quiero decir, no tengo ni idea. Entonces, solo pongamos algo así ahí dentro. A mí me gusta, ¿verdad? Entonces eso es genial. Ahora tenemos un nuevo objeto llamado frederick, por lo que nueva variable llamada fosfórica. Y vamos a decir debug dot log. Y entonces podemos, por ejemplo, decir Frederick, ese nombre de pila. Eso está totalmente bien. Podemos imprimir FirstName. También podemos, si miramos las sugerencias, imprimir el apellido. Como pueden ver, me refiero tanto a la edad al número de seguridad social que faltan y también faltaba es el método que hemos creado. Por lo que nos puede gustar hacer esto, pero tanto h como número de seguridad social y no accesible. Eso es exactamente correcto. Entonces tenemos porque el protegido quisiera que dijera, sólo accesible en la propia clase. Entonces si bien esto ahora es un privado, tal vez decimos, vale, ya sabes qué, esto puede ser público en realidad, como. Eso es algo que quizá sea importante para que la gente lo sepa. Al igual que renuncié EC de edad de beber. También podemos decir, tener un método que se llama es una edad para votar, por ejemplo, ¿verdad? Y entonces por supuesto, dependiendo del país, esto cambia. Vamos a abstraer esto de lejos y sólo digamos, vale, o la edad de beber ahora es de 21. Y podemos hacer esto y ni siquiera tenemos que revelar su edad en teoría, ¿verdad? Entonces solo podemos hacer algo así y digamos algo como Ken, persona, bebe. Y entonces sólo podemos decir boo retórica punto es de edad bebiendo y luego llamar a esto, y esto ahora regresará un booleano y B. Podemos acceder a esto. Entonces vamos a ver, por supuesto, con un 26, la persona no puede beber. Entonces vamos a ver cuando tenemos Conferencia 27, acceso abierto. Frederick Johnson, ¿puede la persona beber, verdad? Vamos a ver si cambiamos esto. Entonces si cambiamos el nombre aquí, o más bien la edad a, digamos 20. Cuál por supuesto en nuestro caso sería. Menos de 21, entonces el anillo de persona Ken debe volverse a falso. Ahí vas. Eso es exactamente lo que quería ver. Y lo grandioso de esto es que ni siquiera tenemos que abrir la edad, ¿verdad? Entonces eso es realmente bueno. Entonces en nuestro caso, nosotros por supuesto que no lo sabríamos. Está bien. Es la persona mayor de 21 años o menor de 21, sin embargo, no sabríamos directamente la edad de la persona. Esto es parcialmente útil en nuestro caso porque aquí no hay caso de uso real. Esto por supuesto, sólo para ilustrarlo. Pero sí, estos son los tres modificadores de acceso, públicos, protegidos y privados. Por lo general, esto es sólo algo que es una muy buena práctica. Todo debe ser privado excepto si hay realmente buenas razones para no tenerlo privado o necesita ser accesible desde fuera. Esto cambia un poquito cuando hablamos de trabajar específicamente en Unity. Porque en realidad tenemos un beneficio agregado. Son porque podemos usar alguna manera interesante en la que aún podemos ver qué tienen los valores privados sin hacerlos públicos. En lo que vamos a ver eso, cuando realmente lleguemos a la unidad ahora mismo en C agudo, yo diría que use variables privadas, que se puede entonces. Además, si realmente necesitamos usar esos, podemos cambiarlos agregando en una guitarra o una configuración. Ahora un getter o una configuración son básicamente formas en las que todavía podemos acceder a las variables, pero tenerlas aún siendo privadas. Entonces creo que si vamos aquí, realidad deberíamos saber que en realidad no podemos hacer eso. A lo mejor podemos hacerlo con esto. En realidad no podemos bien, que pensé que podríamos generar esos automáticamente. Creo que hay una forma de generar esos automáticamente. En realidad. En realidad dice que deberíamos usar una propiedad. Esto va a ser lo que vamos a usar la próxima vez. Entonces en este caso, una configuración sería, o una guitarra sería una cuerda pública. Obtener social. Sólo voy a llamar a este número establecido por un momento. Y luego vamos a devolver este número de punto del Seguro Social. Y entonces un cetera simplemente significa establecer esto. Esto sería un vacío y como cadena Social sec number. Y entonces éste no lo devuelve, pero éste es específicamente éste. Entonces hagamos esto y luego pongamos esto, se van, ¿verdad? Por lo que esto sería una guitarra y una configuración. En nuestro caso, por supuesto, no realmente lo que queremos porque en realidad no queremos de ninguna parte en el tipo de número de seguridad que se obtenga o incluso que se establezca. No obstante, en nuestro caso, justo como ejemplo, esto a veces resulta útil. No obstante, sólo lo voy a volver a borrar porque normalmente, y no usamos getters y setters en C-Sharp. Por lo general en C Sharp utilizamos propiedades. Y eso es exactamente lo que vamos a ver en la próxima conferencia. Entonces esto fue todo para esta conferencia con, para los modificadores de acceso. Espero que esto les haya sido útil. Y yo por supuesto, realmente agradecería una revisión de ustedes si les resultara útil hasta, hasta este punto. Y como siempre, si hay alguna pregunta, siéntete siempre libre de preguntar y me aseguraré de responder. Y sí. 31. (C#) Propiedades de C#: Muy bien, bienvenidos de nuevo a la C aguda introducción aquí para el curso de unidad. Y en esta conferencia vamos a echar un vistazo a un C propiedades afiladas. Por lo que hemos visto todo un montón de cosas concernientes a las clases y objetos, algunos modificadores de acceso. Y ahora vamos a echar un vistazo a las propiedades. Entonces para eso tenemos el script de propiedad y un guión de estudiante. Sí. Y el guión de los alumnos, una vez más, es solo una clase en blanco sin ninguna de las cosas de Unity y el script de propiedades en este caso tiene nuestro método de inicio. Pero vamos a empezar aquí en el guión del estudiante. Entonces podríamos, por ejemplo, digamos que un estudiante tiene un nombre de cadena público, ¿verdad? Eso, eso tendría sentido. Que un estudiante tenga un nombre de pila y vamos a copiar esto y también hacer un apellido fuera de esto. Ahora bien, esto sí funciona. Pero antes que nada, él dice, Hey, ya sabes, tal vez lo que quieres hacer es encapsular este campo usando una propiedad, y eso es realmente lo que vamos a hacer. Entonces lo primero es lo primero que realmente vamos a hacer la convención de nomenclatura aquí para una propiedad es una letra mayúscula. Y luego como pueden ver, con lo que vamos a empezar es que vamos a tener estos corchetes rizados. Vamos a quitar el punto y coma al final. Y dentro de esos corchetes rizados, vamos a escribir, Get and Set. Y con eso, ya hemos declarado un campo. Y se puede ver que ahora tenemos, en lugar de tener la caja lenta aquí, en realidad tenemos esta llave inglesa y este registro simplemente significa que esto es un campo o una propiedad más bien. Y hagámoslo. Hagamos el apellido también. Se van. Y hagamos también, y esta es una de las cosas geniales que podemos hacer. Entonces, por ejemplo, ahora tenemos esas dos propiedades. Y eso está todo bien y bien, y es como, Vale, ¿qué significa eso? ¿ Qué hace eso? Bueno, obviamente lo que podemos hacer ahora, solo hagamos un nuevo estudiante también. Vamos, sí, vamos a hacer unos nuevos estudiantes. Entonces hagámosle un estudiante. Llamémoslos Sí, claro estudiantes, ¿por qué o por qué no? Y el nuevo alumno. Entonces, por ejemplo, en realidad podemos llamar nombre de punto de estudiante como se puede ver, y el apellido de punto de estudiante. Y como pueden ver aquí también, tenemos oh, allá van. Bueno, espera un segundo. Hagámoslo otra vez. Ahí vas. Entonces último tenemos get y set para que podamos ver o bien podemos obtener esta variable, en este caso, esta propiedad, o podemos configurarla. Ahora lo que también podemos hacer es hacerlo bien, ya sabes, así que tal vez podamos cambiar nuestro botón FirstName. Tienes el apellido que está engastado en piedra. Entonces vamos a convertirlo en un conjunto privado. Y si luego voy, como pueden ver, todavía puedo acceder al nombre y al apellido, pero dice conjunto privado. Y si ahora digo, por ejemplo, algo así como Arnold Smith, entonces va a decir la propiedad o índice, nuestro apellido no se puede usar en este contexto porque es conjunto X es inaccesible, simplemente significa que tenemos un privado conjunto. No obstante, un bien público. Y esa es una de las cosas muy fáciles, o formas fáciles con las que podemos establecer la variable a privada o pública. Y lo que también podríamos hacer, por ejemplo, es que podemos definir una nueva cadena llamada FullName. Y mediante el uso de las propiedades podemos decir get. Y entonces en lugar de simplemente poner un punto y coma normal aquí, en realidad podemos básicamente devolver algo que queremos haber devuelto. Entonces, por ejemplo, podemos devolver este punto FirstName plus, y luego un espacio, este punto apellido. Y con esto lo tenemos en realidad, esto también podría ser un método, pero también podemos simplemente ponerlo en una propiedad como esta. Y no hay set en esto en absoluto porque nunca se dice el nombre completo que esto nunca es tener variable que cambiamos. Sólo lo conseguimos a través del nombre y el apellido. Y como acaba de agregar rápidamente un público. Ahora vamos a añadir en realidad una, una edad también. Entonces en edad con un getter público y una configuración privada, ¿verdad? Y esto es tan fácil como simplemente agregar esto. Esto también tiene el bono agregado que por supuesto, cuando nosotros, por ejemplo, establecemos algo, en realidad podemos, en lugar de simplemente enviar una variable, podemos hacer una llamada a método o algo así, ¿verdad? Podemos, por ejemplo, en teoría, tener una variable privada detrás de todo. Entonces podemos tener una variable privada, edad, por ejemplo, digamos, Bueno, digamos nada. Y entonces lo que podemos hacer es en lugar de tener el tipo de cosa no visible que es como invisible con estas cuerdas. Podemos hacer esto y luego decir retorno H aquí, y luego éste y el conjunto privado por ejemplo, también podemos hacer y esto sería entonces aij es igual al valor. Entonces el valor es simplemente lo que pasaríamos ahí. Y esto también funcionaría. Yo sólo quería mostrar rápidamente que básicamente podemos tener un exceso de para esta variable que entonces es privada. Y luego por último pero no menos importante, vamos a hacer un rápido Student constructor aquí con string firstname. Hagámoslo correctamente. Nombre, el ego, string, lastName, y un entero h. Y entonces solo vamos a decir FirstName es igual a FirstName, lastName es igual a apellido, y la edad es igual a h Ahora una vez más, podemos establecer esta edad porque nosotros son a pesar de que el centro es privado, porque estamos en clase. Y podemos, por ejemplo, si ahora realmente le damos un nombre a este estudiante. Entonces digamos Jordan Smith, 31 años, algo así. Entonces por supuesto podemos depurar log algunas cosas interesantes. Entonces, por ejemplo, podemos depurar lock student dot firstName. Podemos bloquear el apellido del estudiante. También podemos buscar nombre completo, ¿verdad? Eso fue lo interesante. Y podemos bloquear la edad. No obstante, no podemos cambiar la edad porque como puedes ver, el setter es privado. Ni siquiera tienes una configuración. Aquí. El vendedor también estaría orgulloso y podríamos cambiar el nombre, pero no elegimos escribir. Entonces vamos a ver rápidamente la salida de esto ahora esto no debería ser demasiado loco, por supuesto que sólo va a Jordania, Jordan Smith. Y luego el nombre completo y luego envejecer como lo hemos dicho. Y solo por mencionar rápidamente, ¿por qué, por qué usaríamos propiedades C Sharp? Bueno, me refiero a uno del lago, a ver. Realmente buenas razones es que podemos desacoplar el conseguir y el ajuste, la accesibilidad básicamente, ¿no? Entonces eso es una cosa que realmente no podemos hacer con los campos normales y las variables normales dentro de las clases. Eso no funciona. Y también con tener el, tener esto, por lo que tener el getter y el setter y poder básicamente tener funcionalidad añadida al mismo. Esto podría funcionar en realidad para que en primer lugar, si queremos cambiar algo que podamos hacerlo muy fácilmente. Y en segundo lugar, podríamos, por ejemplo, mantener un conteo. Con qué frecuencia se establece algo, con qué frecuencia se obtiene algo si eso podría no ser el mejor ejemplo. Pero básicamente podemos agregar funcionalidad al conseguir en el ajuste de una variable específica que podría ser útil. Por lo que para el ajuste podría ser algo así como siempre queremos guardar el ajuste anterior para que podamos volver a cambiar o algo así. Entonces siempre podemos guardar eso en una variable diferente que podría no ser accesible fuera o lo que sea. Entonces hay bastantes aplicaciones, pero la principal comida para llevar, creo que es bastante genial es que el entrar en el ajuste puede tener diferentes ajustes de accesibilidad básicamente, ¿verdad? Eso ya era para las propiedades. Es una parte relativamente grande en C-Sharp. Pero una vez que lo ves, es bastante obvio. Por lo general dentro de Unity es un poco complicado trabajar con propiedades porque Unity no realmente no es un gran fan de las propiedades, todas las cosas consideradas. Pero podemos salirnos con la suya si también tenemos estos campos individuales en este caso. Entonces si tenemos los campos privados, entonces básicamente podemos trabajar en torno a esto. Pero sí, eso fue sólo una introducción rápida para el para las propiedades aquí. Como siempre, si hay alguna pregunta, siéntete libre de preguntar y me aseguraré de responder. Y sí. 32. (C#) Inherencia: Muy bien, bienvenidos de nuevo a la introducción C-sharp aquí para el curso de unidad. Y en esta conferencia vamos a echar un vistazo a la herencia. Por lo que continuando junto con ello, las clases y objetos que ahora vamos a ver básicamente las subclases y la herencia. Y para eso tenemos para clases en el año listo animal, gato, perro y herencia. Si los abrimos todos, entonces podemos ver que la herencia es sólo debe estar vacía. Es decir, todas las clases deben estar vacías o están llenas dependiendo de lo que elijas mirar. No obstante, lo importante aquí es que el animal, el perro y el gato no tienen nada de fantasía aquí. Por lo que no tienen un Método de inicio, no tienen ninguna herencia. Básicamente están vacías. Y en el script de herencia aquí tiene el método de inicio donde queremos implementar cosas. Bueno, vamos a empezar en la clase de animales. Y pensemos, quiero decir, que un animal tiene un montón de cosas diferentes que como atributos que podría tener y campo. Podría haber sido. Lo único que realmente nos interesa en este momento es una cuerda protegida. Vamos a llamar a esto la especie. Y recuerda de nuevo, por lo que las variables protegidas sólo accesibles por subclases. Y está bien. Recordamos que tuvimos eso en la conferencia de modificadores de acceso donde hemos visto que había sentados públicos, protegidos y privados y protegidos entre esos. Y vamos a ver cómo podemos usar esto a nuestra ventaja ahora mismo en herencia. Entonces vamos a crear entonces dos métodos aquí, public void run, que simplemente se va a depurar dot log lo siguiente. Entonces va a hacer esta especie de punto ahora se está ejecutando. Y entonces sólo vamos a copiar esto. Y vamos a sostener el otro método, comer. Y entonces sólo vamos a decir que esta especie está comiendo ahora. Y eso es todo para el animal ahora mismo. Ahora pensemos en esto. Cuáles son algunos animales ahora, claro, ya tengo al perro y al gato. No obstante, también podrías tener un BVA o movimientos o flecha, gran tiburón blanco por ejemplo, hay muchos animales. Y por supuesto, lo que todos tienen en común es que son un animal, pero también todos tienen cosas diferentes que pueden hacer. Entonces tal vez va a haber algo interesante aquí. Pero lo primero que vamos a hacer es dentro de la clase de perros, lo vamos a hacer para que herede de animal. ¿ Cómo hacemos esto? Vamos tras el perro de clase pública y luego tecleamos un colon, y luego la clase de la que deriva, entonces en este caso, animal. Y qué trae esto también en este momento, como pueden ver, aquí no ha pasado nada. Simplemente parece funcionar. Aquí no pasa nada interesante. Lo que podemos hacer es que ahora podemos, ¿qué tal si hacemos un nuevo perro público? Entonces este es un nuevo constructor aquí. Y bueno, sabemos que esto es un perro, así que realmente no necesitamos cambiar el no necesitamos darles ningún parámetro. ¿ Qué pasa con la Especie, así que, Vale, bueno, esta especie puntiaguda. Bueno, ¿cómo puedo acceder a la especie? Esto no es, yo, no he declarado nada bien, porque hemos derivado esta puerta de animal. Y dentro de animal tenemos una especie de llamada de cuerda protegida. Por eso podemos cambiarlo aquí y podemos, por ejemplo, decir perro. Y ahora el, cada vez que creemos un perro que es un objeto, tendrá especies, el campo, básicamente fijado a los perros. Ahora hagamos también un método público llamado corteza. Debug dot log. No una flecha sino normal. Hagámoslo Seguro. Hagamos ladrar, ladrar. ¿Por qué no? Se van. Es decir, podría ser cualquier cosa, pero hagámoslo así. Y luego pasemos también al catalizador. En realidad, solo copia esto rápidamente porque eso lo va a hacer un poco más fácil. Y luego también hacer este animal. Por lo que esto hereda de animal. Esto es un gato. Harás un gato y en realidad maullará por favor. ¿ Qué tal ese? Y entonces sólo vamos a maullar una vez porque eso es genial, ¿verdad? Y ahora tenemos un gato, un perro, y ambos son animales. Pero ahora entra la pregunta, bueno, quiero decir, ¿qué podemos hacer ahora? ¿ De verdad como dónde? ¿ Dónde está lo interesante aquí? Y lo interesante viene de esto. Entonces digamos que tenemos un perro llamado Fluffy. Y este es un nuevo doc sólo por el bien de la discusión. Ahora esponjoso, ahora mismo. Esponjoso. Si puedo escribirlo correctamente, el ego puede ladrar. Puede comer, y puede correr. Pero si miramos hacia atrás, así que si digo que va a correr, si pensamos en este ancho segundo, esto es un perro. O sea, no hemos dicho específicamente que un perro pueda correr, un animal puede correr, pero no tenemos como redefinido este método dentro de perro. No obstante, aún funciona. Y si miramos las definiciones aquí, así que si sí me pongo esponjoso y me cierro sobre tan seleccionado como se puede ver, ladrar es de perros. Entonces este fue el método en especie de perro comer es un método dentro de animal. Lo mismo con correr. Esos son ambos métodos que tienen, hemos creado en la clase animal y en la clase de perro. Y digamos que para lo último que vamos a hacer, una corteza de punto esponjosa, ¿ verdad? Y vamos a ver. Entonces lo que esperaríamos aquí es que quisiéramos ver perro ahora está corriendo, luego atracamos no es comer y luego ladrar, ladrar, creo que es lo que queremos ver. Entonces, veamos si eso funciona. Entonces hagamos éste. Sí. Como ves, el perro ahora corre, log, ahora está comiendo y ladra, ladra. Todo funciona totalmente bien. Podríamos, por supuesto, hacer lo mismo con la cámara ahora mismo. Entonces, solo hagamos eso. Gato entero lo bigotes. Claro, ese es un gran nombre. Bigotes, puntocorrer. Justo lo mismo. Y los bigotes también pueden comer. Y también miau en este caso porque bigotes es gato. Ahora, una cosa interesante, muy interesante. Porque ambos, Consideremos esto un poco, Diego. Porque ambos son animales. También puede tener un animal llamado Henry. Y esto es, por ejemplo, en gato nuevo ¿verdad? Ahora bien, esto funciona. Previamente. Siempre hemos visto que el tipo de datos que hemos dado una variable debe ser el mismo que, digamos el constructor que creamos. No obstante, debido a que el gato es un animal, también podemos salvar a este nuevo gato dentro de un animal. Variable que funciona. Y cuando llamamos a Henry dot-dot-dot comer y Henry dot run, por ejemplo, cambiemos esto para que lo tengamos en todas partes correctamente. Y entonces también me limitaré a poner un año divisor para que sepamos cuál es cuál. Entonces después del divisor, así deberíamos ver los bigotes. Entonces perro corre perro come que ladra, cap run cat come Meow, y luego gato y gato corren de nuevo. Sí, exactamente. Por lo que tenemos perro ladra, tenemos gato gato, miau, hemos seguido corriendo gato ED. A pesar de que Henry aquí es un animal. Entonces el m, Este es un animal. Puede hacer todo lo que un animal puede, pero ¿no puede hacer qué? Un gato. Entonces Henry, Henry.me. Es una lata ver no funciona. Se va a lanzar un error porque animal, no es contener definición para miau porque no sabemos actualmente que es Henry es un animal, un gato. Sabemos que es un animal y razón animal definitivamente. Pero Katas como Mao no funciona. Henri que el varón no funciona. De todas formas podemos hacer, es podemos echar a Henry a un gato. Si sabemos que es un gato, no necesariamente, pero en este caso, este es uno de esos momentos donde podemos tener un costo más complejo, digamos. Entonces hay dos formas de hacer esto. Podemos, por ejemplo, escribir, lo siento, podemos escribir a Henry como gato, miau, como puedes ver. Eso funciona. Por lo que esta es la palabra clave como simplemente es casi lo mismo que costar. Y también podemos hacer básicamente dos paréntesis, poniendo gato, como hemos visto antes, luego hacer henry y luego hacer miau. Entonces esas serían dos formas en las que podemos echar a Henry a un gato. Ahora, sabemos que Henry es un gato. Por eso esto funciona. Si nosotros, por ejemplo, hacemos algo como esto. Entonces perro y luego decir ladrar. Yo no lo haría. Es decir, vamos a ver qué pasa. Tienes razón. Es decir, eso es porque por supuesto podemos hacer eso también y ver qué pasa aquí. Y se puede ver que obtenemos una referencia nula porque esto por supuesto, no funciona porque Henry no es un gato. Henry es un, Henry no es un perro. Henry es un gato. He dicho gato y perro tantas veces. Ya ni siquiera sé dónde agregar. Entonces ahí vas, miau y otro miau. Como siempre. Si hay alguna pregunta, siéntete libre de preguntar y me aseguraré de responder. Y sí. 33. (C#) Polymorphism: Muy bien, bienvenidos de nuevo a la C aguda introducción aquí para el curso de unidad. Y en esta conferencia vamos a echar un vistazo al polimorfismo. Ahora bien, esta es una palabra gigante para un concepto tan fácil. Cuando realmente lo piensas, en realidad es ridículo. Entonces, solo echemos un vistazo a nuestra clase de herencia y a nuestras cláusulas de animales, perros y gatos. Ahora lo que hemos hecho es que tuvimos la última conferencia un método llamado Comer, que básicamente acaba de dar salida a esta especie de punto está comiendo ahora. Y lo que vamos a hacer es decir, bueno, ya sabes, perros y gatos podrían comer cosas diferentes. Por lo tanto, lo que vamos a hacer es que en realidad vamos a anular esos métodos. A pesar de que son una llamada de método, una cotización de la clase Animal, Ahora vamos a hacer una nueva funcionalidad en ellos y vamos a escribir en público conoció, vacío, comer. Entonces los sin los siete, preferentemente van. La idea aquí es que el, que toda la firma del método es la misma a excepción de esta nueva. Y esto nuevo básicamente significa un, esto va a ser un nuevo método con el mismo nombre. Y vamos a decir esta especie de punto. Ahora está comiendo algo de filete, por ejemplo, para el perro. ¿ Verdad? Entonces pongamos esto y luego vamos a copiar esto rápidamente al gato. Y entonces éste está tal vez bebiendo algo de leche. Y van, ahora hemos creado para comer métodos dentro de nuestras clases heredadas. Y lo que vamos a ver es que todas las, cada instrucción, por así decirlo, se van a convertir en exactamente lo que es el perro o gato específico, ya sabes, lo que están comiendo. Entonces, solo hagamos esto y veamos qué pasa aquí. Si bajamos, como se puede ver, perro ahora está comiendo un bistec, gorra, ahora está bebiendo algo de leche. Y ahora lo muy interesante, porque aquí, Kant ahora está comiendo. ¿ Por qué es esto genial, a pesar de que esto es un gato? Bueno, recordemos aquí atrás, Henry en realidad es un animal. Por lo tanto, el animal que come se enfría. Y aquí gato dot-dot-dot se enfría, ven. Entonces esa es también una de las cosas interesantes que puedes tener múltiples definiciones o implementaciones diferentes, en este caso, unas implementaciones diferentes del mismo método. Y dependiendo de cuál sea la subclase, podemos tener implementaciones diferentes específicas de la misma. E incluso cuando lo llamamos al animal, podría tener una implementación diferente, diferente a la de las clases derivadas. Otro ejemplo de eso que he visto bastantes veces es que puedes tener una especie de como una zona, por lo que una clase de área. Y entonces esto podría tener GetArea como método. Y entonces la clase de álgebra puede ser heredada por, por ejemplo, un cuadrado y un círculo. Y mientras que el área de, ya sabes cómo conseguir la zona o la zona es la misma en el sentido de que es, digamos por ejemplo, metros cuadrados, esa siempre es la zona. Pero la forma de llegar a la zona por una plaza es diferente a la de un círculo. Es por eso que necesitas diferentes implementaciones para básicamente lo mismo que quieres terminar con cuatro subclases diferentes como ejemplo, ¿verdad? Eso es en realidad. Si por polimorfismo No es lo más grande. Y también realmente no aconsejaría detenerme demasiado en ello. Es una palabra grande para un concepto muy sencillo. Y creo que incluso en el yen, una última cosa es que el método de sobrecarga que ya hemos visto en forma Lectura, manera una meta que básicamente es también polimorfismo. Simplemente significa que tienes múltiples métodos con el mismo nombre o múltiples implementaciones de un método, y todos tienen el mismo nombre. Por lo que eso también se consideraría polimorfismo. Yo diría que eso fue en realidad algo bastante fácil de entender. Mucho más fácil de lo que sugeriría el nombre polimorfismo. Y sí, eso es básicamente todo para esta conferencia. Espero que te resulte útil si hay alguna pregunta como siempre, siéntete libre de preguntar y me aseguraré de responder. Y sí. 34. (C#) clases y métodos abstractos: Muy bien, bienvenidos de nuevo a la introducción C-sharp aquí para el curso de unidad. Y en esta conferencia vamos a echar un vistazo a los métodos abstractos, a unas clases abstractas. La idea es que vamos a seguir junto con las clases, herencia, cosas lado de C Sharp. Y aquí tenemos tres guiones, el abstracto, el animal abstracto, y el castor. Número uno, ahora mismo el castor primero, o vamos a mirar al castor, estar vacíos. El abstracto de la clase Animal debe estar vacío. Y entonces el abstracto es una vez más el que tiene el método estrella, pero también vacío. Y lo primero que vamos a hacer es el animal abstracto va a conseguir aquí una nueva palabra clave, y esa es la palabra clave abstracta. Entonces lo vamos a hacer este resumen de clase específica. Lo que eso significa, vamos a ver en unos momentos. Pero antes que nada, llenemos esta clase con algunas cosas familiares, como una cadena protegida predictora, especies, especies, y luego también un método de ejecución del vacío público. Ahora se está ejecutando el log de debug dot con esta especie de punto. Ahora lo hemos visto en la herencia normal antes de eso teníamos un método de ejecución. Y ahora vamos a definir también un método abstracto. Ahora el método abstracto va a ser muy interesante. Entonces esto va a ser vacío abstracto público. Y vamos a llamar a esto el método de sonido animal. Y entonces sólo vamos a cerrar esto con punto y coma. Y como puedes ver, eso es todo porque, y estas son las cosas interesantes. Por lo que los métodos abstractos no tienen implementación, implementación dentro de clases abstractas. ¿Verdad? Eso es lo muy interesante. Y lo interesante ahí es que el derivado o las subclases, ¿no? Necesitan hacerlo, deben implementar esto de manera individual. Eso también es muy interesante de ver. Y la palabra clave abstracta para específicos, para métodos específicos solo se puede usar dentro de clases abstractas. Entonces si no hacemos este abstracto, entonces pronto vamos a ver es abstracto pero contiene en una clase no abstracta que no funciona. Por lo tanto, necesitamos hacer abstracto esta clase para que podamos usar esta palabra clave abstracta para un método específico. Ahora, el castor, en lugar de derivar del animal, va a ser un animal abstracto. La idea es casi básicamente la misma. La diferencia aquí sólo es que, bueno, quería mostrar la palabra clave abstracta con un ejemplo similar con el que hemos mostrado herencia. Y el castor ahora tiene una flecha aquí y dice, no implementa los métodos abstractos heredados, animal abstracto, sonido animal. Ahora lo que podemos hacer es que realmente podemos arreglarlo con las múltiples formas que podemos o bien ir al, en realidad, es más fácil ir aquí y decir implementar clase abstracta. Y entonces va a hacer esto por su cuenta. Entonces vamos a sobrescribir el método de sonidos animales. Y entonces de inmediato va a ser como lanzar una nueva excepción aquí. Realmente no necesitamos eso porque nosotros. Bueno, quiero decir, no sé qué dice el castor, pero digamos que dice algo como OK. Y entonces también podemos hacer un Vivre público. Y luego vamos a decir que esta especie de punto es igual a Castor. Y sí, esa es básicamente la idea de un método abstracto. Por lo que necesitamos usar la palabra clave override aquí con el fin de especie de anular el método abstracto y dejar en claro que esta es básicamente la implementación del castor. También podemos pensar, pensar de nuevo al gato y al perro. Si tuvieran el animal abstracto como ahí, la superclase, entonces podríamos imaginar que haríamos exactamente lo mismo. Y luego la muestra animal, básicamente el lobo y el miau que tenemos previamente en el animal normal y el ejemplo de gato y el ejemplo de perro que hemos implementado básicamente como un like por nuestra cuenta, en el, en las propias subclases. En este caso, sin embargo, en realidad lo hemos implementado aquí mismo. En la clase abstracta, estaba el, bueno, básicamente la idea. Y entonces la implementación se reduce a cada una de las clases derivadas. Ahora lo que podemos hacer, bueno, vamos a enterrar al castor. ¿ Por qué no? Yo soy Barry el castor y la baya. Bueno, antes que nada, corre porque eso es lo que podía hacer. Y luego va a saber que no va a comer. En realidad, no puede comer ahora mismo. Pero lo que podemos hacer, y esto es lo genial. Barry puede hacer sonido animal. Por lo que muy se puede hacer sonido animal. Y luego hay una cosa más que quería mostrarte cuando se trata de las clases abstractas. Tan abstracto animal, ¿verdad? Podemos decir simplemente animal abstracto, igual que hemos hecho con el animal. Y digamos por ejemplo, tenemos a María la castora se agota y luego tenemos un nuevo castor. Pero esto funciona. Ahora, María es un animal abstracto. Pero si queremos hacer lo siguiente, así que queríamos hacer abstracto animal Larry, porque vamos con ello es un nuevo animal abstracto. Lo que vamos a ver es que esto no funciona porque no podemos crear una instancia de la clase abstracta o de la interfaz abstracta animal. Entonces la idea aquí es que no podemos crear instancias de una clase abstracta. Eso es lo que realmente importa aquí. Entonces una clase abstracta, por eso es abstracto. No puede tener, no se puede tener un animal abstracto en este caso. Ahora, cuando realmente lo pensamos, sí tiene sentido que algunas cosas. Entonces, por ejemplo, incluso en el caso de un animal, podríamos imaginar, bueno , quiero decir, tener sólo un animal nuevo realmente no tiene mucho sentido cuando realmente lo piensas. Sí necesitamos tener una especie de cosa más específica. Entonces hasta un castor que es como mucho más específico que un animal. Entonces podríamos imaginar, bueno, hacer que animal sea igual a nuevo animal no, realmente no tiene sentido. Entonces en este caso, esto es todavía, por lo que realmente no podemos crear nuevas instancias de clases abstractas. Y sin embargo, sí tienen el beneficio agregado de tener aquí el sonido animal. Y entonces también, si tenemos a María, por ejemplo, todavía podemos decir Mary dot animal sound. Y María todavía va a decir: Ah, así que vamos a ver. Primero tendríamos castor ahora está corriendo y luego, y luego en adelante. El primero por supuesto, es de enterrar al castor y luego el casado el castor ha hecho en el segundo. Y por supuesto podemos llamar a esto porque recuerden cuando no teníamos esto implementado, realidad tuvimos un error en la clase viva porque esos métodos abstractos deben ser implementados, ¿verdad? Entonces como pueden ver, sí elegí la palabra must year. Deben ser implementados. No hay otra manera. Y sí, esa es la introducción básica a la clase abstracta y al método abstracto. También en todo este ecosistema de programación orientado a objetos, increíblemente útil e increíblemente interesante. Pero por ahora, creo que lo vamos a dejar así. Como siempre. Si hay alguna pregunta, asegúrate de preguntar y me aseguraré de responder. Y sí. 35. (C#) métodos virtuales: Muy bien, bienvenidos de nuevo a la introducción C-sharp aquí para el curso de unidad. Y en esta conferencia vamos a echar un vistazo a los métodos virtuales. Ahora los métodos virtuales, al igual que el abstracto, los contrapartes abstractos, son muy similares. Pueden ser algo que tenga que ver una vez más con la implementación en subclases y no. Entonces, solo volvamos a echar un vistazo al animal abstracto. Y vamos a añadir nuestro buen viejo favorito, el público evitar comer método. Y también agreguemos el registro de depuración. Digamos que esta especie está comiendo ahora. Esto es algo que por supuesto hemos visto numerosas veces, No del todo, pero ya hemos visto esto antes. Y ahora en lugar de sólo tener esto un método normal, vamos a hacer de este un método virtual. Ahora, a primera vista, nada ha cambiado porque la idea de este método virtual es que un, esto es básicamente un miembro que puede ser anulado por el derivado o la subclase. Entonces en el caso del castor, podemos optar por anularlo o no. Ahora en nuestro caso, vamos a sobrescribirlo. Y lo que hacemos es simplemente hacer lo mismo que hemos hecho con el método abstracto sólo porque eso simplemente no es una, no es una necesidad. Por lo que no necesitamos hacerlo sobrescribir. Y luego como pueden ver, en realidad ya se presenta aquí. Y en este caso, si llamamos base dot-dot-dot, esto es lo que pasa. En realidad enfría aquí el método virtual. Pero en nuestro caso, en realidad no queremos llamar a eso. A veces podría ser el caso que sepamos que sí queremos llamar a eso. Pero más a menudo que no, me encontré con que realmente no quieres llamar a eso también. Y entonces hagámoslo. Especies de puntos ahora está comiendo algo de madera. Por ejemplo, porque claro, estamos tratando con castores. Y ahora podemos, si volvemos al guión abstracto, por ejemplo, tanto Barry dot-dot-dot como también Mary dot-dot-dot. Estaremos contentos. Entonces como puedes ver ahora, también es muy importante es una vez más, porque María es un animal abstracto aquí. Barry consigue punto castor, Marie obtiene, obtiene animal abstracto, punto-punto. Esto es básicamente lo mismo que hemos visto con el polimorfismo. No obstante, en este caso, debido a que tenemos un método anulado, ambos carbones son para lo anulado de cosa que ha hecho el BVA. A pesar de que María es un animal abstracto. También es castora. Y es por eso que en la implementación castor se llama, en este caso, para el método virtual, ¿no? Eso es en realidad. Para los métodos virtuales, No hay nada de fantasía en ello. Como puedes ver, hay mucha superposición en muchas de esas cosas. No obstante, existen bastantes diferencias sutiles. Como dije, un método abstracto debe ser implementado por una subclase o clase Dr. Se puede sobrescribir un método virtual, muy importante. También muy importante. Un método virtual puede existir en cualquier clase. Un método abstracto sólo puede existir en clases abstractas con, y eso fue todo para esta conferencia. Espero que te resulte útil si hay alguna pregunta como siempre siéntete libre de preguntar ahora asegúrate de responder. Y sí. 36. (C#) Interface C: Muy bien, bienvenidos de nuevo a la introducción C-sharp aquí para el curso de unidad. Y en esta conferencia vamos a echar un vistazo a las interfaces. Entonces las interfaces son algo que es muy similar a las clases abstractas, pero de alguna manera todavía un poco diferente. Entonces como pueden ver, tenemos aquí las interfaces de un avión y un guión de pájaro. Y vamos a crear un nuevo guión también. Y va a haber un nuevo código de guión C-sharp I flyable. Y vamos a ignorar este y el error aquí, o más bien la advertencia. Y sólo vamos a hacer doble clic en la IA flyable. Deshazte de todo lo que hay dentro de aquí, también esto, y en lugar de una clase pública, esto va a ser una interfaz pública. Es, ahora el nombre se va a convertir especie de este color amarillo. Y dentro de ella, básicamente vamos a definir un, un método abstracto. Pero no va a abstraer, sólo va a ser básicamente el tipo de retorno, luego el nombre del método, los paréntesis, y eso fue todo. Eso es literalmente todo lo que necesitamos hacer para poner en la interfaz en este caso. Por lo que la interfaz de etiqueta ith puede ser implementada por unas ciertas clases que bien deberían tener la capacidad de volar. Por supuesto, el avión y el ave de ambos tienen la capacidad de volar. Por lo tanto, ambos van a implementar la interfaz de IA flyable. Es la misma idea que ponemos aquí en el colon. Y entonces podemos ver, hey, no implementa miembros de la interfaz. Entonces vamos a decir, está bien, hagámoslos. Y entonces simplemente tenemos que implementar el método fly para que esto se pueda llamar. En nuestro caso, lo que vamos a hacer por el avión es que simplemente va a registrar arrancando los motores a reacción. Motores, van. Y en el pájaro, realidad vamos a tener algo muy, muy interesante aquí. En realidad vamos a decir, bueno, esto es un animal. También se puede, también podríamos decir que se trata de un animal abstracto. Sólo vamos a decir animal. Y también es tan dos coma i flyable. Y entonces tenemos que implementar también la interfaz. Y aquí vamos a hacer lo siguiente. Vamos a decir debug dot log, aleteo. Hagamos aleteo. Sus alas. Se van. Y como puedes ver, el pájaro ahora es un animal y un ojo volable. Y esos realmente no lo son. No deberían ser como mutuamente excluyentes. ¿ Por qué? ¿Verdad? Porque claro, si eres un animal, puedes volar eso, eso tiene sentido en un avión, también puedes volar. Lo importante es que una clase siempre sólo puede heredar de otra clase. No obstante, puede tener múltiples interfaces implementadas. Y vamos a ver cómo se vería esto dentro de nuestro método de inicio de interfaces aquí. Entonces vamos a tener una lista de yo flyable. Y vamos a llamar a eso cosas que pueden volar. Porque eso es literalmente lo que la interfaz flyable de IA básicamente intenta mostrarnos. Y vamos a decir cosas que pueden volar punto agregar. Y luego lo vamos a decir, pájaro nuevo. Y vamos a copiar esto y decir nuevo avión. Y luego vamos a sumar unos cuantos. Hagámoslo un poco aleatorio. Pájaro aquí, un avión aquí, y el pájaro aquí y tal vez un avión al final también. Se van. Y entonces sólo vamos a tener un para cada bucle al final aquí. Y ahora lo interesante es en lugar de tener esto sea pájaro o avión, podemos tener esto volable, llamo a esto flyable, y luego mirar en la colección cosas que pueden volar. Y luego llama mosca de punto volable. Y ahora por qué es eso una cosa tan interesante y loca? Oh, lo siento, ahí va. Perdón, ahí va. ¿ Por qué es esa cosa tan loca e interesante? Bueno, hemos definido o implementado específicamente motor jet o las alas en cada una de las clases que han implementado la interfaz de ojo flyable. Pero seguimos llamando al método de la mosca en la interfaz flyable. Entonces, ¿qué pasará? Bueno, nos gustaría ver es exactamente esto. Bueno, esto ahora mismo se derrumbó. Entonces hagamos que no se derrumbó. Y luego como se puede ver, aletear sus alas y luego arrancar los motores a reacción, Stirling motor aletear sus alas, aletear sus alas, arrancar los motores plato volteando, volteando y chorro motores. Entonces a pesar de que tenemos frío todo en la interfaz aquí, en la interfaz como tipo de datos, todavía hemos conseguido los métodos implementados reales. Y esto es exactamente lo genial de la interfaz. Porque mientras sepamos, de acuerdo, algo es un ojo volable. Siempre podemos llamar a volar en eso. Y siempre va a funcionar. Y entonces lo grandioso es que también podemos convertirlo después en una especie de interfaz volable de IA. Y seguirá funcionando que podamos decir, vale, hagamos el método de mosca en esto. El, otra cosa interesante que tuve con esto que son en realidad fue como un caso de uso real que tenía en Like especie de juego como hobby que estaba programando era que tenía. Entonces fue básicamente imaginar como un RPG 2D, digamos, como Zelda. Y así como la vieja Zelda, digamos. Y pudiste hablar con cosas específicas. Por lo que son capaces de hablar con ciertas personas, por supuesto, correcto, PNJ. Pero entonces también podrías presionar la tecla superior, por ejemplo, para una consola específica o si había una estufa, entonces puedes decir, oye, ¿qué pesa ese peso? Y puedes hacer click y especie de platicar con ella en más o menos. E implementé una interfaz de burbuja I talk. Y que hablo de interfaz entonces me dio la capacidad básicamente lo que sea la cosa, hablar con ella, básicamente tener el método de conversación, charla nula o incluso charla primaveral, algo así. Y entonces pude, una vez que el implementado esto en, por ejemplo, una NPC o lo que sea, pude entonces hacer la implementación ahí. Quien sea que lo principal que se buscara fue yo hablo de sí. Entonces háblame. Y sí, esa es la interfaz se puede utilizar en numerosas cosas diferentes y estoy seguro de que vamos a ver algunos ejemplos de eso en la programación real cuando lleguemos a la unidad. Ahora mismo, esto es, sí, esto sería todo para la interfaz. Espero que te haya parecido útil como siempre. Si hay alguna pregunta, siéntete libre de preguntar y me aseguraré de responder. Y sí. 37. (C#) Enums: Muy bien, sigamos con la C aguda introducción aquí para el curso de la unidad. En esta conferencia, vamos a echar un vistazo rápido a las enumeraciones. Las enumeraciones son básicamente una especie de los últimos como el tipo de big data que vamos a ver. Tienen la habilidad donde podemos especie de, es una especie de lista predefinida. Sólo echemos un vistazo. Por lo que tenemos dos guiones, el guión de dificultad del juego y en el guión enum. Vamos a abrir primero el bucle interno. Y cambiemos de inmediato al guión de dificultad del juego. La idea es que Hay dos formas o una especie de dos lugares donde no pudimos definir una enumeración. Podemos o bien definir una enumeración en su propio script o podemos definirla en especie de otro script o, orando una clase. personal, creo que es mejor si los pones en su propio guión. No obstante, a veces podría ser más fácil ponerlos simplemente básicamente en un lado del guión donde pertenecen. Entonces tenemos la dificultad del juego enum y vamos a definir fácil, medio, y duro. Y como puedes ver, así es como funciona una especie de enum. Tenemos enum público y el nombre de la enum. Y luego el tipo individual de cosas predefinidas que puede ser para nosotros. Para la dificultad del juego , puede ser fácil, medio, o duro. Entonces esas son las únicas tres cosas que puede ser. Es por ello que, por ejemplo, una sentencia switch con una enumeración es realmente útil porque tienes mucho solo cosas predefinidas que puede ser. Por lo tanto, esa es alguna aplicación donde esto puede ser realmente útil. Ahora, también podemos hacer es podemos en teoría. Entonces digamos, por ejemplo, lenguaje enum y definamos el lenguaje. Entonces, por ejemplo, alemán, inglés, francés, o algo así. Y entonces hemos creado una enumeración dentro de esta clase enums. Como dije, a veces puede ser útil, a veces no porque lo fuera, se quiere acceder a esto fuera de la clase. Entonces por supuesto, necesitas hacerlo público y también entonces necesitarás llamar a enums dot language. Por lo que puede ser un poco raro a veces. Pero de todos modos, vamos a crear una nueva dificultad de juego de mazo, por ejemplo, llamarlo dificultad de juego igual dificultad de juego punto fácil. Entonces esta es la forma en que se escribe esto. Por lo que esto crea una nueva variable de tipo dificultad de juego y luego la establece al valor fácil. También podemos hacer lo mismo con el idioma, el idioma y hacer que el idioma punte inglés, porque eso es lo que es. Y si fuéramos entonces a depurar dot log esto, entonces por ejemplo, dificultad del juego, y vamos a copiar esto y depurar el lenguaje de bloqueo de depuración. Entonces. Bueno, veamos qué podemos sacar de esto. Algunos interesantes, bueno, fáciles e ingleses. Entonces es literalmente exactamente lo que hemos escrito aquí. Entonces eso también es un poco agradable que simplemente podemos salir. Y esto obtiene salida. ¿ Por qué usaríamos enums en lugar de un ANOVA, por ejemplo, como una cadena o algo así. Bueno, en una cuerda siempre podemos hacer una flecha. Podemos desescribir algo o algo así en una enumeración. Siempre lo llamamos llamando al nombre de la enum y luego punto y luego lo que sean los valores predefinidos para ello. Por lo tanto, realmente no podemos mal escribir nada. Sí, y eso es básicamente ya que las enumeraciones pueden ser realmente, realmente útiles para ciertas cosas. Lo mejor es una vez más sólo probar un poco con él, ver lo que se puede ver. Y entonces creo que en las futuras conferencias, sobre todo cuando miramos más de lo que vamos a ver algunos ejemplos de esas también. Entonces sí, eso fue todo para esta conferencia. Espero que lo hayan encontrado útil. Si hay alguna pregunta como siempre, siéntete libre de preguntar y me aseguraré de responder. Y sí. 38. (C#) Excepciones, intenta captar la declaración: Muy bien, bienvenidos de nuevo a la introducción C-sharp aquí para el curso de unidad. Y en esta conferencia vamos a echar un vistazo a las excepciones. Entonces, ¿qué son las excepciones? Ya hemos visto algunos de ellos cuando hay un error. Básicamente eso es lo que podríamos llamar una excepción. Pero vamos a abrir aquí el guión de excepción y vamos a ver qué podemos ver. Entonces, en primer lugar, vamos a hacer una nueva matriz de enteros aquí con dos enteros. Y luego vamos a decir debug dot log. Y luego vamos a decir números tres. Es decir, para el caso, también podemos hacer números dos, y esto básicamente arrojará una excepción. Ahora, ¿qué es una excepción? Bueno, pensémoslo así. Digamos, hagámoslo Hola. Yo también estoy aquí es otra salida que vamos a hacer después de llamar a los números dos, que por supuesto no existe porque los números sólo van de 0 a uno, porque 0 es el primer índice y luego el segundo índice es uno. Entonces, solo llamemos a esto un fin. Como podemos ver, vamos a tener índice fuera de rango excepción. índice estaba fuera de los límites de la matriz, y luego todo después de que no se agarró. Ahora bien, ¿por qué es esta excepción? ¿ Por qué necesitamos para qué sucede esto? ¿ Qué está pasando aquí? Bueno, desde luego hemos cometido un error aquí. El error en este caso fue que estamos tratando de acceder a un número o algo que no existe, y por lo tanto va a lanzar una excepción. Ahora, podemos hacer algo al respecto. Y lo que podemos hacer al respecto es que básicamente podemos asegurarnos de que no hagamos eso aunque ocurra una excepción, todo sigue adelante. Entonces básicamente comenté esto y vamos a crear un nuevo método para esto. Sólo para mostrar esto, vamos a llamar a esto el método de división. Simplemente vamos a dividir flotador a y por flotación b. Así que vamos a devolver un dividido por b. Y famosamente, no se puede dividir por 0. Entonces si d es igual a 0, lo que vamos a hacer es lanzar nueva excepción, frío o un mensaje dentro de ella. No se puede dividir por 0. Entonces, solo hagamos eso. Entonces hagamos debug dot log. Dividamos algo así como diez divididos por cinco. Y luego una segunda. Vamos a hacer 22 dividido por 0. Solo llamemos a esto como es. Y veamos qué pasa. Empecemos. Y como podemos ver, vamos a conseguir una excepción aquí lanzada. No se puede dividir por 0 exactamente el mensaje que hemos puesto aquí. Lo que también podemos hacer es simplemente poner un 22 dividido por 0 también. Vamos a ponerlo así. Y como puedes ver, eso en realidad no funciona porque 0 es una constante. Entonces tendríamos que hacer algo como float z y ni siquiera estoy seguro, vale, éste funciona porque el, esta es una variable y no comprueba variables. Si hacemos eso, vamos a entrar, en realidad nos vamos a poner infinito. Muy interesante. Tan infinito, que por supuesto. Se podría decir: Bueno, quiero decir, eso es bastante bueno, ¿no? Eso está bien. Tendría que adivinar que va a romper muchas más cosas que tener la excepción lanzada en este caso. Entonces, ¿por qué? ¿ Por qué necesitamos esto? ¿Qué podemos hacer? Bueno, podemos hacer lo siguiente, y esto es algo genial. Lo que podemos hacer es que podemos hacer algo que se llama try and catch. Entonces vamos a poner en la palabra clave try. Y luego vamos a poner la palabra clave que tiene paréntesis después de ella. Y luego dentro de aquí vamos a hacer la excepción e. Y luego vamos a poner la depuración dentro de esto. Y digamos también tener una depuración aquí. Y vamos a depurar log. Veamos advertir la excepción. Y vamos, sí, vamos a hacer eso. Y también, por ejemplo, pongamos otro. Entonces un 120 por seis o algo así. Esta es la excepción de esta es la normal y ésta es sólo una después de ella. Entonces veamos qué pasa ahora. Llamemos a esto. Y como pueden ver, dos y luego obtenemos el, la excepción del sistema. No se puede dividir por 0. Ahora esto ya no es un error porque lo que hemos hecho es que hemos citado la excepción con esta captura. Y lo que ha hecho. Y lo posible aquí es que podamos entonces básicamente seguir adelante. Entonces si fuera a hacer esto y digo, después de intentar y atrapar, entonces lo que podemos ver es lo siguiente, que el código continuará y retomará después de este intento y captura, y no se detendrá. Es por eso que un intento de atrapar, ya sabes, algo así es realmente bueno. También hay algo llamado Finalmente, que podemos usar. Y esto finalmente básicamente se enfría en lo que pase aquí. Entonces primero intentamos esto y vamos a atrapar esto, y luego finalmente vamos a hacer esto. lo que pase básicamente si atrapamos o no una, una excepción o no. Esto finalmente se enfría. Y al final aquí la idea es que, bueno, bien, excepciones, lo estoy consiguiendo, pero ¿por qué las necesitamos? La idea de es que lancemos una excepción en lugar de que el programa se estrelle. Esa es una de las grandes cosas. Por lo que se lanza una excepción cuando normalmente esto realmente llamaría como plomo a un choque. Pero entonces podemos probar esto con ciertas cosas. No siempre sabemos dónde podrían lanzarse las excepciones. No obstante, a veces sí lo sabemos y entonces básicamente podemos atraparlos con este try and catch statement aquí. Y las ideas están siendo, una vez más que podemos entonces ojalá ya sea con la captura, Hacer algo al respecto o hacerlo para que podamos arreglar un error que pudiera ocurrir más adelante por la línea. Entonces esto, por supuesto, tal vez no sería la mejor idea para hacer esto. También podríamos hacerlo un poco diferente sobre todo dentro de la misma Unidad, también podemos arrojar un error. Por lo que la era del registro de depuración también funcionaría. No obstante, en este caso, realidad creo que tener este lanzamiento una excepción en realidad está totalmente bien, ¿verdad? Eso es todo por excepciones. Eso es sólo un breve breve resumen. Una vez más, no es nada para, digamos emocionante o no es nada demasiado importante en realidad. Pero sigue siendo bueno haber visto esto una vez antes, solo para que sepas, qué significa este try y catch y qué excepción es. Entonces si eso fuera por esta conferencia, espero que le resulte útil. Si hay alguna pregunta, siéntete siempre libre de preguntar y me aseguraré de responder. Y sí. 39. (C#) fundamentos de los génos en C#: Muy bien, bienvenidos de nuevo a la pronunciada introducción gota aquí para el curso de unidad. Y en esta conferencia vamos a echar un vistazo rápido a un genérico. Muy bien, así que vamos a abrir aquí el guión genérico. Y también tenemos un script par ya en la lista. Y vamos a crear un guión genérico. Por lo que ya hemos visto algo sobre genéricos que era, por ejemplo, una lista. Y se puede ver esto es lista y luego t dentro de estos corchetes angulares. Y entonces pudimos simplemente poner básicamente cualquier tipo de variable ahí dentro. Entonces cualquier tipo de datos que pudimos poner dentro de los corchetes angulares y simplemente funcionó. Y esto es básicamente lo que queremos crear en este momento. Por lo que queremos crear una clase que sea una clase genérica donde seríamos capaces de poner en cualquier tipo de variable o tipo de datos. Y voy a mostrar esto con una clase que uso para mí de manera semiregular, diría que hay algo que es muy similar llamado tuple. Creo que esto está bajo sistema, sistema.Fuera tupla, ¿verdad? Y se puede básicamente, como se puede ver, se puede hacer 12 o algo más. El problema con una tupla es que si bien básicamente puedes poner múltiples tipos de datos diferentes, nunca puedes cambiarlos. Entonces tienes un set lo una vez y luego está hecho. Y por eso tengo básicamente esta clase de par que vamos a crear en este momento. Por lo que es bastante fácil. En realidad ponemos los corchetes angulares y luego vamos a poner en x e y. esos suelen estar significados con un, una mayúscula y un carácter singular. Pero en teoría, también puedes llamarlo x2 o lo que sea. Pero x e y va a estar bien. Entonces vamos a tener un nuevo, un nuevo campo aquí, que va a ser x primero. Y entonces esto en realidad va a ser una propiedad se establece. Y luego vamos a tener un porqué público segundo, que también getter y setter. Y luego vamos a tener un público. Oh, lo siento, Hagamos una más. Ahí lo tienes. Par público x primero, y segundo. Y entonces esto va a ser este primer SQL a primero. Y esto es igual a segundo. Y eso ya es para la clase de pareja. Esto es lo fácil que se puede conseguir. Primero necesitaremos envolver realmente tu cabeza alrededor de esto. ¿ Qué significa esto? ¿Cómo funciona esto? Bueno, si pongo una cadena, cadena, por ejemplo, entonces esto simplemente sería una cadena pública. Si pongo un animal entero, entonces esto sería un entero y éste sería un animal. Realmente puedes usarlo para lo que quieras. Y la x y la y simplemente se reemplaza con cualquier tipo de datos que pongas cuando declaras la variable. Entonces, por ejemplo, podemos poner en un par llamado string int. Y sólo llamemos a este ejemplo uno. No, wow, Ok, vamos a llamarlo par uno, y nada, que es un nuevo par de string int. Y luego dentro de aquí, ponemos en 2005 y por ejemplo, un sí. Y lo grandioso es que luego podemos decir par un punto primero es por ejemplo, igual a, para hablar con 200. Por lo que en realidad podemos cambiar esto. Y si entonces por ejemplo, decimos par con animal y cuerda, entonces podemos llamar a esto p R2. Y este es un nuevo par de animal y cuerda con por ejemplo, un nuevo pájaro. Y pájaro nuevo y una cuerda. Seguro. Porque, ¿por qué no? Y entonces podemos, por ejemplo, llamar también primero, que es un animal punto-punto. Entonces esto es algo bastante cool porque primero es un animal, entonces podemos simplemente llamar al método de comer en esto y simplemente va a funcionar. Entonces la idea de los genéricos, esto es como un muy poco, como ejemplo muy básico, ¿verdad? Al igual que no demasiado complicado. Porque en teoría, al menos en mi experiencia personal, encontré que es muy raro que necesitemos como un nuevo genérico muy complicado para cualquier cosa. Cualquier otra cosa suele ser también realizable con bastante facilidad. Hay algunas veces en las que podrían ser aplicables. Es por ello que lo estoy mostrando como ejemplo. Pero por lo general, tengo que ser honesto, es muy raro que realmente surjan. Si alguna vez suben. Esto lo hemos visto y entonces podemos por supuesto ampliar en esto. Pero por ahora mismo, aquí es donde lo dejaré. Como dije, una visión muy básica de los genéricos. No obstante, como siempre, si hay alguna pregunta, siéntete libre de preguntar y me aseguraré de responder. Y sí. 40. (C#) fundamentos de LINQ en C#: Muy bien, bienvenidos de nuevo a la introducción C-sharp aquí para el curso de unidad. Y en esta conferencia vamos a echar un vistazo rápido a un enlace. Entonces, ¿qué se vincula? Bueno, sólo abramos el enlace en el guión y veamos qué podemos ver. Por lo que esta va a ser una mirada muy básica al link, o también conocida como consulta integrada de lenguaje. Y vamos a tener dos ejemplos ahora mismo les voy a mostrar cómo básicamente se puede filtrar una lista. Y entonces puedo, también te mostraré cómo ordenar una lista por cierto parámetro, digamos. Entonces lo primero, podemos conseguir una nueva lista que solo contenga a los machos yahoo.com en este ejemplo, por ejemplo, donde no será como, quiero a todos los que tengan el correo yahoo.com. Yo quiero esos. Bueno, en realidad podemos conseguir eso por, primer lugar, tener esto usando System.Out link. Muy importante. Por lo que necesitamos estar usando este espacio de nombres y luego tenemos acceso a nuevos métodos en nuestra lista. Entonces como puedes ver, todo como promedio consultable paralelo, tenemos el método concat, tenemos algunos métodos aquí. Y el método que vamos a estar usando es dónde. Entonces este es básicamente un método que nos permite filtrar. Y ahora vamos a tener una, una cosa interesante Básicamente que vamos a ver, que va a ser una expresión lambda. Y eso se va a ver así. Entonces vamos a tener un varón, entonces podemos tener esta flecha básicamente, ¿verdad? Esto es básicamente un, un signo igual y luego un interés mayor que. Y luego aquí vamos a escribir mail dot contiene yahoo.com, y luego eso es todo. Y esto básicamente filtra esto. Ahora esto devuelve un nuevo, en este caso, devuelve un nuevo hierro innumerable. Si lo hacemos para enumerar, nope, no a cadena sino a enumerar. Entonces esto va a devolver una nueva lista en la que probablemente sea lo que queremos. Pero, ¿qué es este año, no? Entonces esto podría parecer un poco raro. Esto no lo entiendo. Nunca habíamos visto la flecha antes de la expresión lambda. ¿Qué es esto? Bueno, la idea es que al desgaste se lleve un funk, como se puede ver, system.out.print. ¿ Y qué es un funk? Bueno, un hongo, básicamente un tipo variable o un tipo de datos que almacena un método o función. Ahora hongo definido como tener una cadena, en este caso como la entrada y un bool como la salida. Entonces esto es lo que significa el string bool. El correo. Entonces el, cada elemento es siempre la entrada en este caso, ¿verdad? Por lo que cada uno de los elementos es la entrada. Y entonces quisiéramos el booleano como salida. De acuerdo, ¿esto está dentro de nuestra nueva lista o no? Y entonces voy a decir, bueno, si contiene yahoo.com, entonces va a ser parte de una lista. Si no lo hace, entonces no va a formar parte de una lista. Y eso en realidad es tan fácil como esto estar filtrando esto para personas que han visto cosas como quienes han trabajado con SQL por ejemplo, es similar a eso de muchas maneras. Y para el segundo ejemplo, rápidamente voy a copiar algo. Entonces voy a copiar una lista de enteros llamados puntuaciones altas. Básicamente son al azar, pero son simplemente al azar. Y lo que vamos a hacer es que podemos hacer puntuaciones altas punto OrderBy. Este es el orden por el método. Y luego podemos decir puntuación y luego sólo decir puntuación por ejemplo. Por lo que esto ahora pediría las puntuaciones más altas. Bueno, por el, por el puntaje real. Como puedes ver, el funk hay un entero y luego tiene otro entero. Entonces esto es lo que se está comparando. Y esto es básicamente una vez más, el realmente esto, sin embargo esto es lo que se está comparando. La idea es que podríamos, por ejemplo, en lugar de tener una lista entera, podríamos tener una lista de cadenas. Y entonces podríamos ordenar por, por ejemplo, la longitud de cada una de las cuerdas, lo que también funcionaría. Este es básicamente el entero que se da de vuelta aquí. Por lo que simplemente estamos devolviendo el entero en sí, lo tanto, ordenando por él. Esto realmente es sólo una mirada muy rápida a esto, una mirada muy básica en él. Aquí hay mucho más cosas. Pero una vez más, como muchos de estos, digamos ejemplos posteriores aquí o temas posteriores. En realidad no son tan propicios. Mirando a la Unidad misma. Yo sólo quería mencionar esto una vez más, y también algo que se puede, por supuesto, investigar por su cuenta. Y si tal vez suficiente gente está interesada en esto, podría simplemente hacer una conferencia adicional. Por lo que las expresiones lambda, por ejemplo, podrían ser al menos un poco interesantes. Si bien también hay otros tipos de datos que utilizamos u otras formas que podemos usar cosas similares dentro de Unity. Bueno, sí, esa fue básicamente la mirada muy básica al enlace. Como dije, si hay suficiente interés, podría hacer un poco de una inmersión más profunda aquí. Para la Unidad misma, realmente no es necesario. Esos métodos que te mostré, el desgaste en la orden POR esos son realmente bonitos y luego tal vez algunos otros que podrían ser útiles. Pero en este punto, creo que esos son los dos principales y todo lo demás que definitivamente puedes mirar. Y si hay intereses, como dije, sólo para preguntar si hay algo poco claro aquí, claro, siéntase libre de preguntar y me aseguraré de responder. Y sí. 41. (C#) Events y delegados: Muy bien, bienvenidos de nuevo a la C aguda introducción aquí para el curso de unidad. En esta conferencia, vamos a echar un vistazo a los eventos y a los delegados. Este es un, otro tema más avanzado. Y sólo vamos a echarle un vistazo rápido y ver qué podemos ver. Entonces el delicado guión, solo abramos eso. Ya tenemos un temporizador de flotación y un flotador apunta a tiempo. Ahora, como puede ver, esto se declara dentro de la clase en lugar del método de inicio. Y esto es algo muy importante porque en realidad vamos a usar otro método de Unity esta vez sólo para mostrar este ejemplo. Y este será el método de actualización. El método de actualización es simplemente algo que se llama una vez por fotograma. Por lo que podría haber escuchado los juegos correr a 60 fotogramas por segundo. Y entonces este método se llamaría 60 veces por segundo. Ahora lo que queremos hacer es que queremos crear algo donde básicamente llamamos cierto método cada 10 segundos o cada segundo, fijamos este tiempo objetivo a, por ejemplo. Y lo vamos a hacer con el sistema de delegados y eventos. Querido aquí es que vamos solo en realidad, primero hagamos un método al que queremos llamar. Entonces por ejemplo, mensaje de prueba de vacío privado. Y vamos a poner en el registro de puntos de depuración, no un error, sino un registro normal, simplemente dando salida a un, dando salida a un mensaje, algo así. Y queremos llamar a este método en particular cada vez que algo sucede. Y lo podemos hacer haciendo lo siguiente. Entonces vamos a hacer un delegado primero. Por lo que se trata de un vacío delegado público. Y luego vamos a llamar a esto, digamos en diez segundos pasados, sólo como ejemplo. Y en el delegado, como se puede ver, debe tener la misma firma que el método que vamos a llamarlo. Entonces esto es vacío, por lo que este es básicamente el tipo de retorno y luego también no hay parámetros dentro de aquí. Entonces básicamente misma firma que sí, método, queremos llamarla. Y entonces lo que podemos hacer es mientras este es el delegado, entonces tenemos un evento y luego los objetos básicamente pueden suscribirse a ese evento. Entonces vamos a tener un evento público. Y esto es de tipo en diez segundos pasados, donde éste es básicamente el tipo del evento. Y luego le vamos a dar un nombre, por ejemplo, autocompletar. Y así es como funciona el evento y los delegados básicamente la inicialización. Por lo que los objetos, los objetos pueden suscribirse a los eventos. ¿ Verdad? Lo que vamos a hacer ahora es que vamos a agregar el método de mensaje de prueba. Al evento, y cada vez que este evento se enfría, se llama a este método. Entonces digamos por ejemplo, OnComplete. Y luego vamos a hacer más igual mensaje de prueba. Y lo importante es sin los paréntesis, así que sólo vamos a tomar aquí el nombre del método. Y lo que esto va a hacer es básicamente esto va a agregar este método a una lista de este evento. Que cuando este evento se enfríe, entonces vamos a asegurarnos de que este mensaje de prueba también programe. Entonces, solo agreguemos una forma de llamar a esto. Entonces por eso tengo este temporizador aquí. Hay una manera bastante fácil de agregar básicamente el temporizador. Ahora esto va a ser una cosa justa, bastante fácil. Voy a explicar esto objetivos tiempo y luego vamos a decir temporizadores iguales a 0. Y luego vamos a decir OnComplete y llamar a esto y esto es igual. ¿ Y qué está pasando aquí? Bueno, cada fotograma, básicamente vamos a añadir un poco de tiempo a esta variable de temporizador que es 0. Y luego vamos a revisar, oye, ¿ el temporizador es más grande o igual al tiempo de los inodoros? Si ese es el caso, vamos a reiniciar el temporizador y carbón onComplete. Esto debería suceder alrededor de cada 10 segundos, como se puede ver, porque el tiempo objetivo es exactamente 10. Redujamos esto a algo así como cuatro, para que esto vaya a suceder un poco antes. Y luego cada cuatro años, cada cuatro segundos vamos a hacer que se emita este mensaje. Entonces, veamos si eso realmente funciona. Por supuesto, asegurándonos de que estamos en conferencia 38 eventos. Ahora mismo no pasa nada. No obstante, después de que hayan pasado cuatro segundos, deberíamos ver que se van y luego después de otros cuatro segundos deberíamos ver otro mensaje. Como puedes ver, Vamos a colapsar esto para que podamos ver cada mensaje de método. Y como pueden ver cada cuatro segundos, ahora vamos a recibir este mensaje que se está emitiendo. Ahora bien, ¿por qué es eso algo tan grandioso? ¿ Por qué, Por qué no simplemente llamamos al método de mensaje de prueba aquí? Bueno, podemos ver que este método de mensaje de prueba de lío es en realidad privado. Y tal vez lo que queremos es que realmente queremos que esto suceda en unos momentos muy particulares y no queremos hacerlo para que cada cosa, cada parte de nuestro programa sepa de cada otra parte. Entonces, por ejemplo, tal vez tengamos un sistema HP para un enemigo o para nosotros mismos. Y luego tenemos una UI dentro de nuestro juego que muestra cuánto HP, ya sea el enemigo o nosotros mismos como digamos el jugador, entonces qué podríamos hacer, la UI podría saber, vale, esta es la salud del jugador y podrían revisar todos, cada fotograma de actualización, ¿verdad? Así que cada cuadro, está bien. ¿ Qué tal tú, Eso es jugador tener cuánto? Constantemente actualizado, pero no necesitamos actualizarlo constantemente. En realidad sólo necesitamos actualizarlo cuando el HP cambie. Y entonces podemos hacer estos eventos. Por lo que un delegado especie de sobre el cambio de HP. Y luego tenemos un evento que luego básicamente llama al método UI y dice ocho, el Reino Unido, el cambio de HP. Por lo que esta es la idea de suscribirse a estos eventos. Podemos separar nuestro código muy prolijamente. Y, y tampoco hay un verdadero inconveniente de tener estos eventos. Por lo que básicamente puedes hacer como un 100 o 200 eventos, un incendio. Y si sus suscriptores geniales. Y si no lo haces, realmente no pierdes nada porque en esto, en este caso llamamos a esto, esto no lo haríamos, ¿verdad? Entonces eso es básicamente eventos ahora en general, esto también es sólo una visión muy corta y mirar dentro de ellos. Cuando, una vez que empecemos realmente a usar la programación de un juego real, jugaremos o un montón de unidades de juego. Entonces vamos a volver a usar esto. Y creo que en ese ejemplo real se va a poner camino, mucho más claro. Ahora mismo. Yo sólo quería mostrarles que existe algo llamado eventos y delegados. Y una vez más, dominarlos es realmente difícil. Y sí, es sólo algo que es muy bueno haber visto unos. Y vamos a ver esto más adelante abajo de la línea otra vez. Solo quería mostrarte esto rápidamente y cómo esto puede ser realmente útil. Vamos a ver en una futura conferencia. Pero no obstante, si tienes alguna pregunta, no lo dudes y siéntete libre de preguntar y me aseguraré de responder. Y sí. 42. (C#) File O/O: Muy bien, Bienvenido de nuevo a C aguda introducción aquí para el curso de unidad. Y en esta conferencia vamos a echar un vistazo a la entrada y salida de archivos. Por lo que he preparado un archivo de texto muy cool, como se puede ver claramente aquí en nuestra carpeta de recursos de activos. Y vamos a abrirla y ver cómo se ve. Se trata de un texto súper cool. ¿ No es genial? Y ahora vamos a aprender cómo podemos leer esto en. Y luego también vamos a aprender a escribir un nuevo archivo. Vamos a entrar en nuestro archivo I O guión aquí. Y ya he preparado básicamente el camino de lectura y el camino de escritura que vas a estar en activos, recursos. Y entonces el archivo de texto genial es el que vamos a leer. Y luego vamos a escribir a un textos súper cool que hicimos con código. Y como dije aquí, t dot TXT, es sólo un archivo de texto normal. Entonces, ¿qué necesitamos con el fin de, para que básicamente entremos y salgamos cosas? Bueno, para escribir algo en un archivo. En primer lugar, es un proceso muy lento. Ahora, lento en cuanto a comparar dos cosas que podemos hacer en código. Sigue siendo increíblemente rápido, pero normalmente escribir algo en un archivo es un proceso lento. Yo sólo quería mencionar eso. Y necesitaremos usar el espacio de nombres system.console aquí. Y luego vamos a ver, así que en primer lugar, vamos a comprobar si el archivo existe o no. Por lo que el archivo dot existe. Y luego dentro de ella vamos a poner primero el camino rojo porque vamos a ver si la lectura un camino tiene o no un archivo que existe ahí. Porque si no lo hace, bueno, realmente no podemos abrir esto. Y ahora lo que vamos a usar es que vamos a usar un lector de stream. Entonces stream reader SR file dot open text, y luego le vamos a dar el camino. Ahora lo genial del lector de stream es que este es un i desechable, creo que es el término correcto para ello. Y espero que lo hagas ahí es podemos usar la palabra clave using. Ahora bien, no lo has visto antes. En realidad podemos tomar la palabra clave using y podemos tomar todo esto, ponerlo dentro de aquí. Y luego una vez que hayamos terminado con él, nos va a cerrar el lector de stream porque probablemente necesitamos cerrar nuevamente el archivo. Y esto es básicamente todo manejado por la palabra clave using. Y dentro de aquí, vamos a tener una cuerda, cool S. También podríamos llamarlo un hábito, un poco mejor nombre. Creo que AS será suficiente por ahora. Y voy a tener un bucle while dentro de aquí, que vamos a decir, bueno, S es igual a SR dot readline. Entonces esto es, la línea roja es simplemente una cadena y vamos a poner S a esa cadena. Y siempre y cuando eso NO ES nulo. Entonces si bien es eso no es nulo, vamos a simplemente dar salida básicamente S. Así que vamos a leer cada una de estas líneas que están aquí. Ahora, sólo hay una línea aquí. Nosotros lo vamos a dar salida. Y una vez que terminamos, terminamos de usar esto. El lector de stream básicamente se eliminará. Y todos están contentos otra vez. Eso es todo lo que realmente necesitamos para básicamente leer un archivo. A ver si eso funciona. Asegurándose de que estemos en el archivo IO. No nos preocupemos por esta advertencia. Esto se debe simplemente a que tenemos la variable de ruta correcta declarada pero no utilizada. Y veamos, en supercool, los textos serán exactamente lo que hemos escrito en el archivo realmente obtiene salida. Entonces eso es bastante guay. Y ahora veamos qué podemos hacer para escribir algo. Entonces si queremos escribir algo, vamos a usar el escritor de stream. Entonces vamos a decir una vez más usando y luego retransmitir escritor. Esto va a ser entonces SW es igual al texto de punto de archivo, en este caso en la ruta correcta. Y entonces vamos a tener básicamente lo que llamamos es el SW. Por lo que el escritor de corriente correcto, línea de escritura punto-punto. Y entonces podemos decir, por ejemplo, hola, y luego vamos a copiar esto un par de veces. Esta es otra línea. Bastante cool. Cómo funciona eso. Entonces probemos esto y veamos si eso funciona. Por lo que en este momento no tenemos un nuevo archivo dentro de nuestra carpeta de recursos. Y una vez que empecemos esto, lo que podamos ver, terminemos con esto. Y en realidad, creo, tenemos que recargar esto porque no va bien, tenemos que refrescarnos. Entonces Control R. Y luego como se puede ver cómo van. Y como puedes ver, los textos súper geniales que hicimos con código está aquí. Y luego Hola, esto es un alineamiento. Bastante guay cómo funciona eso. Todo lo que hemos puesto aquí, exactamente cómo lo hemos hecho. Y ahora sumemos este cambio algunas de estas líneas. Vamos, por ejemplo, digamos, Claro, Cómo lo harías, ¿Por qué no? Esta es otra línea y luego bastante cool cómo funciona eso. Y luego cambiemos esto por tal vez uno de esos y veamos qué pasa si solo volvemos a ejecutar esto. Entonces, solo pongamos esto. Y una vez más, hemos corrido esto sin errores, Eso es un poco bonito. Vamos a abrir de nuevo este archivo. Y como pueden ver, les gusta que el programa acaba cambiar lo que se escribió aquí otra vez, así que va a anular lo que ya tenemos. Por lo que la ONU, el archivo de texto en el camino correcto en este caso simplemente se sobrescribirá con el material nuevo. Sí, eso es lo básico realmente fuera de entrada y salida de archivos. También hay cosas más avanzadas. Y durante la parte de programación de la unidad de este curso, vamos a ver especialmente cómo leer y escribir cosas con archivos JSON porque están formateados de tal manera que podamos usarlas con bastante facilidad. Pero en general, esto fue sólo una breve breve visión general una vez más, de la entrada y salida del archivo. Como siempre, espero que te resulte útil si hay alguna pregunta, como siempre siéntete libre de preguntar ahora asegúrate de responder. Y sí. 43. (C#) Convenciones C#: Muy bien, bienvenidos de nuevo a la introducción C-sharp aquí para el curso de unidad. En esta conferencia, vamos a echar un vistazo a estas convenciones C-sharp. Entonces esta es potencialmente la última de las conferencias C-sharp aquí. Y sólo vamos a echar un vistazo rápidamente a unas cuantas convenciones que debes seguir si es posible. Entonces, solo abramos el guión de convenciones y veamos qué podemos ver. Entonces he preparado algunas cosas aquí y voy a explicar de arriba a abajo algunas de estas convenciones y por qué podrían ser útiles y por qué probablemente deberías seguirlas. Todas las cosas consideradas y también compraron algunas de esas cosas son. Entonces lo primero, nombres de primera clase, ¿verdad? Entonces esas serían, por ejemplo, convenciones y lo que hemos visto abstracto animal o animal o persona, debería ser el caso Pascal. ¿ Qué es el caso Pascal? Caso Pascal simplemente significa que la forma en que escribimos ciertas palabras, en este caso, como se puede ver, animal abstracto. Si bien esto es una sola palabra, el abstracto es una palabra y animal es una sola palabra. Y ambos están capitalizados. Entonces esto es lo que hace Pascal. Nosotros capitalizamos el primero, el primer personaje. Y luego cada vez que llegamos a una nueva palabra, también capitalizamos esa palabra. Eso es muy importante. Ese es el caso Pascal. Cuando miramos variables locales, nombres de campo, y también parámetros, esos deben ser CamelCase. Camelcase significa simplemente que el primer personaje es minúscula. Y luego cada uno, cada palabra que viene después va a ser mayúscula. Cuando miramos las constantes, no hemos visto realmente la palabra clave const. Aquí la idea es simplemente que esta es una variable que no se puede cambiar. Entonces no va a ser tan complicado. La idea es que esos también deban estar en el caso Pascal y no en gorras gritando. Eso es algo que yo personalmente hago a veces. Creo que esta es una de esas cosas, como con todas esas convenciones que no son realmente reglas, son solo lineamientos que podrían ayudar. Y este es probablemente uno personalmente que lo haría. Entonces personalmente probablemente ignoro esto la mayor parte del tiempo simplemente porque a veces siento que es más fácil de ver, vale, esto es una constante. A pesar de que deberías poder ver esto por el símbolo que tiene justo aquí. No obstante, normalmente lo hago todo en gorras gritando, pero sigue siendo una convención que uno podría querer seguir. Por lo que siempre usamos nombres significativos para las variables. Esto ya lo he mencionado a lo largo del transcurso de unas cuantas veces. Pero es muy bueno tener un nombre propio para las variables. Hemos utilizado esto la mayor parte del tiempo. Creo que una o dos veces no he hecho esto, pero normalmente debes evitar las letras simples. Entonces por ejemplo, el entero t y ya veremos, vale, bueno, ¿qué significa eso? Bueno, es mucho más fácil de leer si yo Está en el temporizador y el tiempo completo o terminado. Y además, no tengas miedo de nombres realmente largos para variables. Si es un nombre expresivo y es un nombre significativo, entonces realmente no deberías tener miedo de eso. Porque cuanto mejor puedas explicar algo, más fácil es entender. Por eso siempre debemos usar nombres significativos para las variables. Personalmente también a veces me equivoco esto, pero cuando lo piensas, cuando tú, cuando estás programando rápidamente, simplemente llamarías a este S o simplemente llamarías a esto en AI. Pero, ¿qué es la IA? ¿ Cuál es su propósito? Y eso también a veces puede llevarte a pensar en tu código un poco mejor y pensar como, bueno, en realidad realmente no necesito este entero, esta variable aquí. Entonces sí, no uses abreviaturas en tus nombres de variables. Entonces cosas como ID y XML y algo así. Eso está bien, pero no poner en persona y luego hacer PRS n por eso. Eso sólo va a llevar a confusión. Y tengo que ser honesto. Esos dos, esos dos personajes que guardas ahí, simplemente no va a cometer ningún error en absoluto. Hay algo que realmente no usamos subrayados en C-sharp. Esa es sólo la convención. Especialmente en, bueno, en realidad en cualquier cosa excepto en los campos privados. Y lo hemos visto en la conferencia de propiedades C Sharp donde hice una, creo que era una booleana o algún tipo de variable que era privada. Y empecé con eso con un guión bajo. Eso está bien. Los nombres de una clase siempre deben ser sustantivos. Entonces animal, persona, esos son sustantivos, ¿verdad? Y también deberían ser singulares si no me equivoco. Entonces eso también es algo así que no deberían ser animales ni personas porque siempre es una clase. Se trata de un sustantivo singular que describe una clase. Entonces escuchemos el prefijo interfaces con la letra I. Así que el yo volable. Esa fue una interfaz que hemos hecho donde podríamos llamar al método de la mosca. Y se dice que debemos empezar esto con la letra mayúscula I. Ahora a algunas personas realmente no les gusta esto porque son como, sé si esto es o no un, esto es una interfaz. Personalmente creo que esta es una buena convención. No obstante, hay algunas personas que tienen opiniones muy, muy fuertes sobre o no necesitamos eso, lo que sea, seguirlo o no lo sigan, no importa, solo manténganse consistente. Eso es como una de las cosas más importantes. Si cambias tus convenciones a mitad de camino de tu proyecto, entonces necesitarás volver atrás y reescribir el resto del código para que siga tus convenciones. Al igual que si tienes algunas convenciones y te pegas a ellas, pero no te vuelvas loco. Y también esa otra cosa. Es a menudo que terminamos en las interfaces con Able. Para que sea una especie de, ya sabes, yo volable, hablo burbuja. Porque ese tipo de también significa, vale, ¿qué son capaces de hacer? Entonces eso también es algo para llevar contigo. Entonces siempre deberíamos tener nombres singulares para enums. Entonces dificultad de juego, por ejemplo, no dificultades de juego. Y nunca debemos usar el nombre dentro, como enum dentro del nombre. Por lo que no deberíamos tener dificultad de juego. Enum o enum de color, siempre sólo lo singular que es una enum nunca usando. Ahora, ¿de dónde tengo esto? Tengo esto de un repositorio GitHub de convenciones de nomenclatura. Esto, por supuesto, está vinculado así como un recurso. Yo sólo puedo aconsejarles que echen un vistazo a eso también porque hay algunas cosas más. Entonces he puesto aquí. Tengo esos eran sólo una especie de los más importantes que he visto. Y de verdad te puedo aconsejar que eches un vistazo al enlace. Ellos lo son. Porque esas son algunas buenas convenciones de nomenclatura que debes seguir. Al menos la mayoría de ellos para que tu código sea lo más estandarizado y fácil de leer posible. Pero en general, eso fue todo con la C aguda introducción aquí para el curso. Y sí, eso fue todo. Espero que te haya sido útil y ahora se va a aprender básicamente Unidad propiamente. Entonces puedes, por supuesto, en primer lugar felicitarte por lograr esto y entrar aquí porque fue bastante la introducción minuciosa. Y hubo algunas cosas que probablemente necesites aprender dependiendo de tu nivel de conocimiento previo. Pero sí, ya está hecho y espero que te resulte útil. Y al final aquí, como siempre, si hay alguna pregunta, siéntete libre de preguntar y me aseguraré de responder. Y sí. 44. (Fundamentos de la unidad) Layout y editor explicados: Muy bien, Bienvenidos a la introducción básica de la unidad aquí para el curso de unidad. Y en esta conferencia, vamos a echar un vistazo básicamente al diseño de la unidad, específico como editar cosas y bueno, sólo unos corazones y unas pocas partes de las ventanas básicamente, solo explicamos rápidamente como poco panorama dado para que tú sabe lo que todo esto significa y que puedes encontrar tu camino básicamente dentro de la UI de Unity aquí que ves, hay muchas partes móviles, muchos botones en los que podrías hacer clic y no solo ellos. Tan solo un poco de introducción para eso. Entonces vamos a empezar básicamente en la parte superior izquierda. Esto aquí es básicamente la ventana de escena. Y es una de las cosas más importantes en Unity porque esto es básicamente lo que te da tu visión sobre tu mundo de juego, ¿verdad? Por lo que actualmente esto se pone básicamente en modo 2D. Se puede ver cuando se conmuta en la escena como vista 2D, cuando se desactiva de la escena como en la vista 3D. Siendo idea aquí que, por supuesto, este es un curso 2D. Entonces vamos a hacer todo en 2D. Podemos mirar hacia la tercera dimensión haciendo clic en este botón. Y luego como puedes ver, Obtenemos básicamente una vista 3D. Pero como no queremos eso, nos vamos a quedar con el 2D y luego solo averiguar cómo podemos movernos dentro de aquí. Entonces si presionamos el botón derecho del ratón hacia abajo, vemos aparecer una manecita y luego podemos mover el, básicamente el mundo del juego. El punto de vista luego cambia y podemos movernos, ¿verdad? Entonces eso es bastante útil. Podemos acercar y alejar con ellos con el botón central del ratón, por supuesto, también podemos movernos si mantenemos presionado el botón central del ratón. Y entonces también podemos movernos básicamente. Si mantenemos pulsado el botón izquierdo del ratón, podemos seleccionar las cosas. Actualmente en nuestra escena. Podemos ver lo que tengamos aquí, aquí en la Jerarquía. Eso lo vamos a ver un poco más tarde también. Pero en este momento sólo tenemos la cámara principal aquí. Y podemos, por ejemplo, seleccionar esto. Y luego como pueden ver, en primer lugar, la cámara principal aparece aquí abajo. Entonces esto es lo que veríamos dentro del juego. Y luego en el lado derecho aquí, aparece todo un montón de cosas, que también vamos a ver en un rato. Entonces, ¿qué más es pues la vista de escena? Si bien aquí hay un montón de botones, básicamente puedes activar y desactivar el audio. Se puede utilizar la iluminación de escena. Hay cosas para las cajas de cielo. Se puede ver cuántos objetos hay y también alternar en la cuadrícula. Entonces por ejemplo, ahora mismo no tenemos una cuadrícula, y luego tenemos una cuadrícula. Por lo que la cuadrícula puede ser realmente útil. Y también a veces podría ser que los artilugios estén apagados. Entonces los artilugios, o básicamente, si hago clic en este pequeño botón aquí, puedes ver que hay ciertos iconos que verás que simplemente te ayudaron a encontrar ciertas cosas dentro de la vista de escena. Por ejemplo, la cámara, ¿no? No casi no importa si me alejo un poco, entonces las cámaras siguen ahí. Y si hago zoom mucho que las cámaras aún más grandes, pero solo te muestra bien, ahí está la cámara principal o hay una cámara y si apagamos eso, entonces no vemos nada y ni siquiera sabemos dónde está la cámara en esa instancia . Entonces los artilujos son básicamente para ayudarnos a ver ciertas cosas que son ayudas visuales. Grande que sólo se puede ver dentro de la vista de escena, ¿verdad? Y luego también hay sólo una especie de caja de herramientas aquí. Rara vez uso esto. Y luego también puedes cambiar la configuración de la cámara aquí. Por lo que esta es la configuración para la cámara de vista de escena. En este caso. Yo también diría que no suelo usar eso. También puedes buscar algo aquí arriba. Pero hay muchas barras de búsqueda, en realidad, hay una aquí, hay una aquí. Por lo que podemos buscar de muchas maneras. Entonces esta es la ventana de escena. Básicamente. También puedes tener diferentes modos en la parte superior izquierda aquí. Y esos básicamente no harán nada en este momento si tenemos cosas aquí dentro. Por lo que esto también se trata más, diría yo, de la perspectiva 3D. Tan sombreado simplemente significa que si tenemos, si tenemos un cubo aquí, puedo simplemente agregar uno real rapido para que podamos ver esto como un ejemplo. Entonces ahora mismo tenemos un cubo negro aquí como puedes ver. Y luego si hago una alambrada, ve esto como una estructura alámbrica. Y luego un alámbrico sombreado simplemente significa que ambos vemos el marco alámbrico bajo el modo sombreado. También tenemos cosas diferentes que podemos hacer rutas de render. Podemos tener el mapa MIP de sobredibujar canal alfa. Por lo que esos son simplemente como diferentes ideas de renderización, por así decirlo. Por ejemplo, uso suelo mantenerlo a la sombra. Ese es el que tiene más sentido. Y en 2D, las diferencias que hay en realidad no son tan importantes de todos modos. Por lo que en la parte superior, también tenemos algunas herramientas que podemos utilizar. Por lo que he dicho click derecho o clic en el medio del ratón, podemos movernos. También podemos simplemente seleccionar esta herramienta de mano y luego movernos con el botón izquierdo del ratón como un clic. Eso también funciona. Contamos con la herramienta Mover. La herramienta de movimiento básicamente es si tengo determinados objetos de juego seleccionados, por ejemplo, la cámara, entonces aparecerán estas flechas y con esas Eigen básicamente mover la cámara. Y luego en el lado derecho aquí se puede ver que la posición de la cámara realmente cambia. Como dije, en este caso, porque estamos en 2D, vamos a estar sólo necesitamos la dirección x en esta dirección y la dirección y y esta dirección. Y sí, el, sí, eso es básicamente eso. Entonces tenemos la rotación. Entonces esta es la herramienta de rotación. Básicamente podemos rotar alrededor de este ángulo, ¿verdad? Entonces podemos rotar alrededor del, este sería el eje z, ¿verdad? Porque el eje z es el que entra en el, en la propia computadora. Y entonces también podemos básicamente inclinarnos en esta dirección. Pero por lo general el eje z es la única rotación que necesitamos en dos dimensiones, tres dimensiones, podríamos, por supuesto, rotar alrededor de cada eje. También contamos con la herramienta de escalado. Por lo que esto no hará nada por la cámara en este caso, porque la cámara, la escala de la imagen de la cámara se controla de manera diferente a la escala del objeto en sí. Por lo que esto solo aplica realmente a diferentes objetos, pero en este caso podemos escalar esto con esta herramienta. Y entonces esta es mi herramienta básicamente favorita, herramienta directa. Porque cuando tenemos, sobre todo en dos dimensiones, básicamente podemos tener la capacidad de dimensionar algo arriba o abajo con los lados. Es muy similar a algo que verías si enciendes el modo de transferencia en Photoshop para cualquiera de ustedes que, como quién entiende lo que es eso. Eso es algo, pero lo vamos a ver más adelante también por la línea. Y mover, girar y escalar objetos. Por lo que esto simplemente pone a los tres juntos en uno. Personalmente no prefiero esta vista. A algunas personas realmente les gusta esto porque entonces pueden hacer lo que quieran. También contamos con la herramienta editora. No obstante, aquí no tenemos herramientas personalizadas. Entonces esto realmente no hace nada por nosotros. Personalmente guardo mi unidad casi exclusivamente en naufragada en la herramienta rect y me muevo como dije, con el botón derecho o el botón central del ratón, generalmente el botón derecho del ratón y acercar y alejar así. Sí, eso es básicamente lo esencial de ello. También puedes ir a estos botones por una persona Q, W, E, R, T, y luego la z sido ah, ese es en realidad el y sido. Sí, exactamente. Entonces q0, QWERTY básicamente son estos botones los que también funcionan, pero sí, también es suficiente si simplemente haces clic en ellos. Entonces cambiemos de pestañas aquí y veamos la vista del juego. Actualmente, como puedes ver, básicamente no hay nada aquí porque no tenemos nada dentro del juego ahora mismo. Esto simplemente es lo que verías cuando juegas el juego. Y esto también es lo que pone en marcha. Entonces si pulsamos el botón de inicio aquí arriba, el botón Play, esto también es lo que vemos, por lo que cambia automáticamente a la vista del juego una vez que hayamos iniciado el juego. Y la vista del juego, como dije, es lo que definitivamente te gustaría. Básicamente ejemplo uno a uno de lo que verías dentro del juego una vez que lo iniciaras, hay ciertas cosas que podemos hacer. Básicamente podemos tener diferentes exhibiciones aquí. Ahora. En este momento sólo tenemos display uno. Podemos establecer la resolución actualmente, como la puedes ver. Dos, para k, también podemos decir, bueno en realidad pongámoslo en Full HD. Eso va a estar bien. Podemos escalarlo hasta arriba. Por lo que esto simplemente se acerca a la imagen sin hacer ninguna fantasía como las técnicas de Zoom o alguien así. Es, literalmente, solo se acerca. Si golpeamos maximizar en juego, una vez que jugamos, la ventana se maximiza aquí, esto puede ser realmente útil si quieres ver, ya sabes, como casi todos los detalles porque esto es casi pantalla completa. Y luego hay audio mudo debe ser autoexplicativo. El Muse el audio. Podemos ver las estadísticas que se están ejecutando y también podemos encender los artilujos aquí. Y esos son básicamente los mismos artilugios que tenemos, la vista de escena. Pero esta es la vista del juego. En realidad no hay mucho para ello. Sí, sólo sigamos con la jerarquía jerárquica. Volvamos a cambiar también a la vista de escena. La jerarquía básicamente son todas las cosas que están en la escena actual. Actualmente estamos en la escena muestral. Esta es una escena que se crea cuando iniciamos un nuevo proyecto de Unity. Y como puedes ver, básicamente sólo tenemos la cámara principal aquí como componente. Podemos agregar nuevos componentes yendo a este pequeño botón más, por ejemplo. Por lo que podemos tener cosas predefinidas que podemos crear o podemos hacer clic derecho en año y también tener lo mismo. Cosas que podríamos querer crear. Entonces, por ejemplo, podemos crear un objeto vacío. Y este objeto vacío literalmente no tiene, Sólo tiene una posición, rotación, y escala. Y no tiene un, digamos marcado visual de ningún tipo. Por lo que ni siquiera sabemos dónde es esto cuando podríamos agregar esto. Y luego, por ejemplo, cambiar las cosas. Pero ahora mismo no vamos a añadir esto y sólo vamos a mantenerlo así. Por cierto, nosotros, si la escena cambia, ¿no? Entonces si cambiamos la escena, así que si movemos esto, entonces verás una pequeña historia aquí y una pequeña tienda en la parte superior. Y la tienda puede, oh chico, básicamente puedes guardar los cambios simplemente usando Control S o yendo a Archivo y luego Guardar aquí. Y, um, probablemente usaré eso varias veces en todo. Y al igual que con casi cualquier otro programa, podemos ir y deshacer o rehacer cosas con Control Z. Eso es simplemente deshace las cosas y luego Control Y básicamente retrocede y reducirlas. Entonces eso es, debería ser casi autoexplicativo, ¿verdad? Entonces la jerarquía, si seleccionamos algo aquí, también se selecciona en la vista de escena y también aparece algo en el inspector. El inspector es una de las grandes cosas que vamos a ver, como incluso con más detalle cuando miramos guiones porque ahí es donde se pone muy interesante. No obstante, lo que hay que decir del inspector es que básicamente, para cada uno de nuestros GameObjects que existe dentro de nuestra escena, obtenemos información adicional que también podemos manipular. Entonces, por ejemplo, para la posición, básicamente puedo cambiar esto. Y como se puede ver a la izquierda, en realidad también cambia en la escena. Por lo que esto es muy importante y estos son una especie de, estos se agrupan en su funcionalidad. Entonces por ejemplo, esta cámara obviamente tiene una especie de componente de cámara asociado a ella donde podemos cambiar diferentes cosas que están asociadas a la cámara. Y la transformación simplemente significa que este es el posicionamiento y la escala rotacional. Entonces esto es lo que tipo de la, digamos la manifestación física de este objeto. Y cada objeto siempre tiene unos componentes transformados. Por lo que estos son los componentes individuales. No vamos a hablar de Agregar Componente ahora mismo. Eso es algo que vamos a ver más adelante por la línea. No obstante, podemos, por supuesto, añadir componentes a nuestros objetos individuales. Echemos un vistazo rápidamente a la consola también. Por lo que la consola cuenta con dos partes principales. Aquí. Ya hemos visto si has visto la introducción C aguda, entonces lo habrás visto varias veces. Básicamente hay salidas. Si hacemos debug dot log o debug, debug dot log warning, entonces esos se muestran aquí. Si los seleccionamos, entonces podemos ver una especie de rastro aquí abajo. Y esto también se puede ampliar o mover hacia abajo. Tenemos unos botones, esto despeja la consola. Podemos colapsarlo, podemos pausar en errores, y luego también tenemos algunas cosas que podemos hacer. Como se puede ver, selección de objetivos. Realmente no uso esto. Esto es para, si realmente nos volvemos locos con nuestra depuración, realmente no lo necesitábamos. También podemos filtrar para en básicamente normal, solo registros, advertencias y errores. Y esa es básicamente toda la consola. No es tan loco. Y como con casi todas las demás cosas, vamos a mirar esas como incluso Más adelante por la línea, la vista del proyecto es básicamente las carpetas y directorios que tenemos para nuestro proyecto. Actualmente, dentro de nuestra carpeta de activos, tenemos una carpeta de escenas, y dentro de eso tenemos la escena de muestra. Esta es la escena que se crea al principio del fin cuando creamos un nuevo proyecto aquí, esta es simplemente la escena que se crea. Y eso es todo lo que tenemos aquí. Va por. futuro, crearemos unas cuantas carpetas más. Y también básicamente te mostraré mi estructura de carpetas personales que utilizo. Eso es por supuesto algo que depende completamente de ti. Puedes seguirla o no seguirla. Eso es sólo una sugerencia. Igual con el diseño básico de la, de toda la pantalla aquí. Eso es algo que tal vez quieras seguir o no. Vamos a hablar rápidamente también de los botones correctos aquí, sólo para completar, esto es colaborar. Esto simplemente significa que si quieres colaborar con varias personas con Unity colaboran, puedes hacerlo con esto. No me preocuparía por esto ahora mismo porque hagamos primero lo básico. Vamos a rodar con el concepto de unidad y omega1 básicamente hablemos de colaborar. El servicio gestionado simplemente significa que hay servicios. Entonces si hago clic en esto, aparece la ventana de servicio y esos son servicios específicos que básicamente podría habilitar aquí para este juego en particular. Al igual que la colaboración no necesaria, básicamente puedo cerrar esta ventana de servicios haciendo clic en medio del ratón y luego desaparece. También puedo hacer clic derecho y creo que también puedo cerrar pestaña. El cuenta simplemente es la cuenta en la que estoy conectado. Por lo que sus capas de cuenta de Unity son las capas que existen. Eso es algo de lo que vamos a hablar más adelante también por la línea. Y en el layout simplemente como el layout de mi Unidad. Entonces puedo, por ejemplo, cambiarlo. Podría cambiarlo una creencia que luego se vuelve a cargar. Entonces no quiero realmente hacer eso, pero tengo mi propio diseño de KJ aquí. Como dije, tengo esto y creo que también puedo ponerlo a disposición. Por lo que realmente puedo guardar esto en un archivo y tendré el diseño disponible. Ya deberías tener esto. Debería haber sido descargable en el inicio del curso. Entonces sí, sí, eso es básicamente. Es decir, las únicas otras cosas son el inicio, el stop, y el botón de paso. El botón de paso simplemente pone lo que hayamos conseguido aquí. Entonces si nos ponemos esto y entonces nos detenemos por ejemplo. Entonces este botón de pausa en realidad, y luego podemos pasar como cuadro por fotograma a través de una escena en particular con este botón. Por supuesto, ahora mismo, no hace nada porque, bueno, aquí no hay nada. Entonces no hay nada que ver son esos son estos tres botones. Y luego si alguna de esas cosas en particular no está aquí, siempre puedes ir a Window y mirar todas esas diferentes ventanas que hay ahí. Entonces la escena, ya sabes, el juego, el inspector que hemos visto, jerarquía, consola de proyectos, esos son básicamente los más importantes que deberían estar ahí casi siempre. Y entonces todo lo demás es algo que vamos a ver con algún detalle y algunos no detalles. Y así vamos a mirar como realmente bien. Y algunas de las otras cosas son mucho más avanzadas que realmente no necesitamos hacer, digamos juegos simples o incluso juegos un poco más complejos. Pero sí, eso es básicamente todo lo que quería decirte para el diseño de la unidad, es un poco más integral. Pero, y por supuesto hay más por aprender y las aplicaciones de eso. Pero yo sólo quería, que estuvieras al menos un poco sentirte cómodo dentro de este diseño así que ya sabes, vale, me gusta vagamente saber dónde está. De acuerdo, la jerarquía me muestra todos los objetos en la escena y luego el proyecto tiene básicamente la estructura de carpetas y así sucesivamente y así sucesivamente. Entonces, sí, ese es básicamente el diseño de la unidad. Y explicó el editor, espero que esto te resulte útil como siempre. Si hay alguna pregunta, siéntete libre de preguntar y me aseguraré de responder. Y sí. 45. (fundamentos de la unidad) estructura de la carpeta de unidad: Muy bien, bienvenidos de nuevo a la introducción básica de la unidad aquí para el curso de la unidad. Y en esta conferencia vamos a echar un vistazo a la estructura básica de carpetas. Básicamente eso uso personalmente. Es que creo, no sé, que evolucionó a lo largo de los años. En realidad no es tan complicado o loco de explicar, y también debería ser bastante sencillo. Por lo que dentro de nuestra vista de proyecto aquí mismo, tenemos la carpeta de activos. Y esta carpeta de activos. Ahí es básicamente donde tendremos todo lo que tiene nuestro juego o guiones. Tendremos nuestras escenas ahí dentro, tendremos nuestras fotos e imágenes y sprites. Todo va a ir dentro de esta carpeta de activos, la carpeta Paquetes aquí. Podemos básicamente por ahora ignorar esto. No usaremos ningún paquete en un futuro previsible. No obstante, la carpeta de activos, Ahí es donde vamos a crear nuestras propias carpetas dentro de ella. Y vamos a básicamente vamos a hacer nuestra estructura de carpetas aquí. Y esto es simplemente haciendo clic derecho en la carpeta Activos, crear y luego Carpeta. Y se va a llamar a la primera carpeta que vamos a crear. Por lo que dentro de esos, por supuesto, todos los guiones irán en el futuro. Y luego crearemos una carpeta llamada sprites. Entonces en lugar de ahí, todos los sprites irán. Y luego otras dos fotos que son bastante importantes que también podemos crear ya es la carpeta Recursos. Ahora es muy importante que esto esté realmente escrito correctamente porque esa es una de las otras carpetas que es especie de donde podremos ingresar y salir cosas, Digamos. Por lo que esta es una carpeta muy fácil de leer desde la unidad. Vamos a mantenerlo en eso por ahora. Eso lo vamos a ver más tarde también. Y entonces una cosa que también vamos a crear es la carpeta Prefabs. Vamos a hablar de lo que son los prefabs también en una futura conferencia en este momento, básicamente estamos construyendo una especie de fundación. Y luego vamos a sumar a esos seguidores individuales continuamente por la línea. Especialmente por supuesto, la carpeta de scripts va a ser la que básicamente vamos a crear un montón de scripts que son, ya sabes, deca tienen una plétora de funcionalidad y básicamente mostrarán cada uno de los individuos, funcionalidades individuales a las que vamos a echar un vistazo en esta introducción básica de unidad. Entonces esas son básicamente todas las carpetas que son interesantes. Algo a mencionar para los guiones es que si tengo, por ejemplo, diferentes espacios de nombres, ya lo he explicado en la parte afilada C a C. Tengo diferentes espacios de nombres y básicamente son espejados los espacios de nombres en especie de esta carpeta de scripts. Y lo que podemos hacer es básicamente, podemos entrar aquí y en lugar de los ajustes del proyecto bajo la duración del proyecto sea shore, hacer un espacio de nombres raíz. Ahora dentro de nuestra introducción básica de unidad, no vamos a hacer esto, sin embargo, cuando creemos nuestro propio juego. Entonces cuando hagamos el primer partido ahí, definitivamente vamos a hacer eso. Porque entonces la carpeta de scripts en realidad espejará esto. En este caso, la carpeta de guiones es un poco mejor atendida al tener los separados porque las conferencias que van a venir son básicamente independientes entre sí. Por lo que podría, por ejemplo, saltar de la conferencia a la conferencia 5 sin faltar nada. Si conferencia para es algo que ya has visto o conoces. Sí, así que esa es la estructura básica del proyecto, nada demasiado elegante o demasiado loco por ello. Hay un par de más, bueno básicamente carpetas que podrían unirse más adelante por la línea. Probablemente cuando nos fijamos en conceptos más intermedios y avanzados, entonces se unirán más carpetas. No obstante, esas son básicamente las fotos que necesitamos para la introducción básica y para el primer juego que vamos a crear. Entonces sí, nada demasiado emocionante. Pero ahora por fin, básicamente podemos empezar, y en la siguiente conferencia por fin vamos a empezar a leer un guión y en realidad ver un poco lo que puede, lo que la unidad básicamente puede ofrecer. Por lo que una vez más, espero que te resulte útil si hay alguna pregunta, siéntete siempre libre de preguntar y me aseguraré de responder. Y sí. 46. (Fundamentos de la unidad) guiones y el inspector: Muy bien, bienvenidos de nuevo a la unidad básica introducción aquí para el curso de unidad. Y en esta conferencia, vamos a echar un vistazo a dónde tanto el inspector como los guiones en general. Entonces vamos a echar un vistazo a si eres un guión y cómo eso se manifiesta. Y luego también vamos a ver cómo se ve esto dentro del Inspector. Para eso, vamos a crear aquí nuestro primer guión. Y una vez más estamos haciendo clic derecho en la carpeta de scripts, crear, y luego en C-sharp script. Entonces podemos renombrar esto. Vamos a nombrar a esta salud. Entonces este es el, básicamente vamos a hacer una clase de salud en este caso. Y también vamos a crear una nueva escena para esto. Por lo que básicamente quiero que cada una de las diferentes conferencias tenga una escena asociada a ella. Entonces vamos a hacer clic derecho en escenas una vez más crear, y luego aquí abajo a escena. Y esto va a ser básicamente tres. Por lo que L3, esto serían guiones. Por supuesto puedes nombrar esto lo que quieras. No tienes que seguir los guiones ni siquiera como las escenas individuales así. Puedes hacer lo que quieras. Yo sólo pienso que este es el más orden. Y esto luego también se traducirá en el contenido descargado de la aplicación. lo que por supuesto también puedes descargar toda la introducción de la unidad básica como paquete, importarla, y luego tendrás casi la misma estructura que esa. Entonces lo primero que vamos a hacer es que vamos a crear un nuevo objeto vacío aquí. Por lo tanto, crea un clic derecho dentro de la Jerarquía. Crear Vacío. Este es ahora un objeto de juego vacío. Nosotros sólo vamos a llamar salud a esto. Sólo por el bien de la discusión. Personalmente hago otra cosa. Siempre posiciono mis GameObjects vacíos en la posición 0, 0, 0. Literalmente no hay razón para hacer esto. Simplemente odio ver como estos números realmente torcidos en esta posición. Es por eso que hago esto. Y no tienes que hacerlo, pero yo lo hago. Entonces, sí. Y ahora mismo que esto se crea y posiciona, básicamente podemos tomar el guión con el clic izquierdo y luego arrastrarlo hasta aquí. Y como pueden ver, en realidad puedo conseguir un indicador aquí. Y si suelto, y podemos ver el guión de salud ahora es básicamente un componente de este GameObject. Y lo grandioso es que después de que hayamos salvado aquí, lo grandioso es que básicamente ahora podemos manipular este guión. Y esto ahora correrá dentro de nuestra puerta. Por lo que podemos hacer doble clic aquí o hacer doble clic aquí. Solo pinchemos aquí. Y luego para mí, se abrirá un Studio visual. Se abrirá en una pantalla diferente, diferente. Entonces yo sólo voy a plop, se van. Y este es un nuevo guión básicamente formado. Y así es como se ve. Obtenemos un método de inicio y obtenemos unos métodos de actualización. Entonces esas son dos de las cosas que se pregeneran. Y también podemos ver que este guión de salud, esto ayuda a clase de salud. Hereda del comportamiento mono. comportamiento mono, como se puede ver, es la clase base de la que derivan todos los scripts de Unity. Entonces si quieres un script de prueba unitaria donde funcione el método de inicio y el método de actualización funcione, entonces esto necesita heredar básicamente del comportamiento moral. Y lo que también es importante si rápidamente miro estos comportamientos mono también, lo que necesitas básicamente poner un script en un GameObject aquí. Entonces de lo contrario esto no funcionará. Entonces si tengo un guión donde no tengo este comportamiento mono, la herencia, en realidad no puedo apegarme a nada. Entonces lo que vamos a hacer es que vamos a crear unos cuantos nuevos, básicamente campos y variables aquí. Entonces no dentro de nuestro método sino por encima de él. Entonces básicamente como parte de esta clase, vamos a dar click Crear una Salud Pública. Y vamos a ponerlo igual a un 100 y luego una manera int pública igual a un 100. Entonces esto es algo que una clase de salud podría manejar con una variable de salud, una variable de salud y una variable de manera. Y también vamos a hacer un entero variable privada podría experimentar. Y eso también va a ser un 100 justo por el bien de la discusión en este momento. Ahora vamos a mantener esto como es y mirar hacia atrás a Unidad. Entonces vamos a tener algo de recarga aquí. Ahora. Nosotros lo haremos. Esta es una advertencia que realmente no nos preocupa en este momento. Simplemente dice: Hey, hemos creado como un campo, una variable que nunca hemos usado. Entonces esto es como algo que es inútil básicamente, porque no lo usamos. Yo diría realmente que se trata de una advertencia que casi siempre se puede ignorar, sobre todo al principio. Solo estamos haciendo estamos probando unas cuantas cosas y sí, así que la mayoría de las veces, esto puede ser ignorado si realmente estás trabajando en un proyecto y lo consigues como con casi todo lo que creas, entonces esto simplemente significa una, tal vez hay algunas cosas que algunos campos o algunas variables que podrían eliminarse. Pero en este caso ahora mismo, no nos concierne a quién podemos realmente despejar la consola. Si ahora miramos aquí nuestro objeto de juego de salud y un guión medio, se puede ver que algo ha aparecido, una variable de salud aquí y un hombre de variable aquí. Por lo que hay dos campos que han aparecido con sus valores básicos que hemos puesto aquí. Y quiero decir, eso es bastante guay, ¿verdad? Entonces eso es realmente algo que acaba de pasar sin que hagamos nada. Pero si estoy declarando e inicializando esas variables, Eso es bastante guay. Pero si vemos la variable espuria en realidad no está ahí. Y la razón de eso es porque lo hemos hecho privado. Por lo que los modificadores de acceso en este caso realmente sí importan para nuestra visibilidad dentro del Inspector. Pero para eso, podemos hacer lo siguiente. Podemos poner los corchetes básicamente aquí y escribir en campo serializado dentro de esto básicamente serializará este campo. Ahora también ya no conseguiremos básicamente la era ni la advertencia, Hey, esto no se usa porque ahora se usa y es usado por el inspector. Y como puedes ver, ahora la experiencia sube, no te preocupes por ello. Ahora la variable de experiencia aquí aparece también. Entonces esta es una forma en la que podemos hacer visibles las variables privadas para el Inspector específicamente. Sí, y eso es lo básico aquí. También podemos, si ahora empezamos esto, no pasará nada porque aquí no tenemos nada emocionante. Pero lo que podemos hacer es, por ejemplo, podemos hacer salud menos igual a 20, por ejemplo. Y luego solo por el bien del argumento, si puedo averiguar cómo escribir 0 en el método de actualización. Podríamos poner en el plus experimentado igual a uno, por ejemplo, sólo para que tengamos algo que mostrar. Y vamos a, sólo veamos esto. Y entonces realmente podemos ver este cambio aquí. Y sólo empecemos. Y como puedes ver, ahora la experiencia, como puedes ver, va realmente, realmente rápido porque actualmente son FBS, eso es como mil o en algún lugar alrededor de eso? Simplemente nos detenemos rápidamente o nuestra pausa el juego. Entonces lo que podemos hacer es que en realidad podemos ir cuadro por cuadro. Y luego como puedes ver, esto en realidad sólo se incrementa en uno cada fotograma, como se supone. Y se reinicia una vez que hayamos detenido el juego. Debido a que esto básicamente no es persistente, los datos aquí dentro vuelven a lo que tenemos, lo ponen dentro de nuestro script básicamente. Entonces sí, ese es un resumen básico del guión y el, el inspector. Tenemos en la C aguda introducción visto que el método de inicio básicamente algo que simplemente sucede al inicio, eso es exactamente cierto. Entonces una vez que iniciamos la escena, todo lo que hay dentro de aquí es ejecutado. Y luego después de eso se hace, el método de actualización se llama cada fotograma. Por lo que esto es dependiente del marco. Y entonces vamos a añadir algo aquí. En futuros también veremos diferentes formas en las que podemos hacer las cosas dependientes del tiempo. Entonces básicamente podemos decir, Hey, vamos a esperar un minuto para esto o, o un segundo o alguien así. Y sí, ese es el panorama básico de esto. Espero que te resulte útil como siempre, si hay alguna pregunta, siéntete libre de preguntar y me aseguraré de responder. Y sí. 47. (Fundamentos de la unidad. activos de las): Muy bien, bienvenidos de nuevo a la introducción básica de Unity aquí para el curso UD. Y esta conferencia, nos encontramos fuera de la unidad. Conozco locos. Y esto es básicamente algo que quería mostrarte por activos que tal vez quieras usar. Y por un ejemplo de bienes que vamos a utilizar. Entonces los activos de Kenny son básicamente un montón de activos y todos son libres de usar, ¿verdad? Por lo que hay más de nueve lados, como se puede ver con un montón de cosas. Como puedes ver, hay diferentes activos 2D y también 3D aquí también algunos activos de audio. Y si nosotros, por ejemplo, sólo vamos a la siguiente página, como puedes ver, hay una variedad de cosas y todas son locas cool. Se ven realmente bonitos. Y como dije, se pueden usar. Están bajo licencia universal, por lo que son puedes utilizarlos con fines comerciales o cualquier fin que te gustaría. Y para nuestra introducción básica aquí, así que para los fundamentos de la unidad, vamos a usar aquí las cartas de juego. En realidad son que nos ofrecen todo lo que necesitamos realmente. Y básicamente solo quiero una imagen en particular que podamos usar para hacer cosas con que se vea un poco más bonita que solo, no sé, como una pantalla en blanco o negro. Y como puedes ver aquí, este es un cc, tu inverso, bueno, eres libre de usar esto en el juego en cualquier proyecto, personal o comercial. No hace falta pedir permiso. Dar atribución no es requerido por muy apreciado. Por supuesto, por eso les muestro este número 1 porque es un gran recurso. Y también porque esto es, quiero decir, es increíble, ¿verdad? Nunca había sido más fácil realmente. Y hay algunos activos realmente bonitos aquí con los que puedes hacer cosas increíbles. Y además, voy a, por supuesto, las cartas de juego, tendré las incluidas como descarga y también el enlace a los activos aquí también es como recurso disponible. Y luego hay una cosa más, y esa es la tienda Unity Asset. Probablemente ya has visto esto antes. Pero esto es básicamente un pozo donde los activos se venden o también se podrían descargar de forma gratuita. Por lo que hay algunos activos que se venden, y también hay algunos activos que son gratuitos. Entonces si filtramos por los tres primeros, como puedes ver ahí, aquí hay un montón de cosas que es gratis de usar y que también puedes usar en tu juego. Estamos, nos estaremos centrando en los ácidos kenny, así que vamos a utilizar los activos kenny en el futuro. No obstante, como dije, la tienda Unity Asset también puede ser un gran momento donde básicamente se pueden obtener nuevos activos también. Y sí, básicamente sería eso. Yo sólo quería mencionarte que vamos a usar los ácidos kenny y que hay, también hay más lugares donde puedes ir por internet. Creo que van artistas de juego abierto, otro lugar. Por lo que hay un montón de lugares. Caucho, lo vamos a mantener en los activos kenny. Y eso fue sólo algo que quería mencionar. Como dije, todo como recurso disponible. Y sí, eso ya fue para esta conferencia. Yo sólo quería mostrarte esto rápidamente. Espero que te resulte útil si hay alguna pregunta como siempre siéntete libre de preguntar y me aseguraré de responder. Y sí. 48. (Fundamentos de la unidad) escenas y ajustes de construcción: Muy bien, bienvenidos de nuevo a la introducción básica de la unidad aquí para el curso de la unidad. Y en esta conferencia vamos a echar un vistazo rápido los ajustes de compilación y hacer una compilación. Entonces, ¿qué es una construcción y qué significa eso hacer? ¿ Para ver la configuración de compilación? Bueno, la idea es que un proyecto de ley es básicamente un ejecutable el cual se puede, de su juego, el cual se puede ejecutar. Y tiene todo en ella. Es básicamente el lanzamiento de tu juego, casi como si quisieras que fuera lanzado. Y hay algunos ajustes que tenemos que hacer para que esto funcione realmente. Por lo que en realidad hay muchas configuraciones, y vamos a echar un vistazo más adelante también por la línea. Pero una de las cosas que es muy importante son los ajustes de construcción. Entonces va a archivar y luego construir ajustes. Y si solo muevo rápidamente esto por aquí, como pueden ver, estos son los ajustes de compilación. Hay algunas cosas que verás de inmediato. Por lo que básicamente podemos mirar en qué plataforma queremos publicar esta app. Por lo general PC, Mac y standalone es una especie de la, diría yo, la predeterminada. Y entonces puedes, si lo tienes, puedes elegir diferentes plataformas objetivo e incluso cambiar la arquitectura aquí. Por lo general, al principio se quiere poner en esto como un desarrollo construido porque se trata de un desarrollo construido. Y entonces también muy importante es como puedes ver, hay escenas que realmente quieres construir. Entonces cuando creas nuevas escenas, entonces realmente quieres tener en cuenta que tendrás que añadir esas aquí cuando construyas. Entonces como pueden ver en este momento, he visto escena de muestra de barra que, esa está ahí dentro, pero la L3 que no está ahí dentro. Por lo que simplemente puedo arrastrarlo y tenerlo aquí. Y estos 01 es básicamente el índice. Por lo que en realidad hay una ola en la que podemos acceder a esto. Entonces si tuviéramos que ver algo como esto, entonces en realidad hay forma de que podamos acceder a esto por guión básicamente. Y sí, así que vamos a echar un vistazo rápido a eso para que luego podamos construirlo. No voy a hacerlo, porque ahora mismo hay realmente, en realidad, ¿sabes qué? Hagámoslo. Básicamente se puso, vale, ¿ dónde queremos construir esto? Por lo general diría que dentro de tu carpeta Unity, creas una carpeta llamada builds. Y luego tú, tú eliges esa. Y la construcción en realidad va a tomar un poco de tiempo dependiendo de cuánto haya ahí dentro. Ahora, claro, básicamente no tengo nada aquí. No hay, No hay sprites reales. No hay activos reales. Aquí no hay casi nada. Y solo un segundo, les mostraré el dónde ha salido esto. Entonces el básicamente aquí, ahí vas. Por lo que obtenemos un año EXE que podríamos iniciar un ejecutable. Ahora va a empezar en la pantalla equivocada, así que no lo voy a hacer ahora mismo. Pero en general, como se puede ver, aquí está todo. nivel 01 son básicamente los datos de cada una de estas escenas ahí. Y entonces también tenemos una carpeta de recursos. Este es el que mencioné que tenía que ser el nombre correcto. Y luego también hay una carpeta administrada con todo un montón de archivos DLL básicamente. En general. Esto también es lo que básicamente tomarías. Entonces el EXE y la carpeta de datos, y esos dos serían los que tendrías enviar básicamente a la gente para que jueguen tu juego. También son Ajustes de jugador. Sólo voy a dar click rápidamente en esto y mostrarte, um, vamos a pasar por esos en un tiempo más tarde también. Esas son simplemente cosas como el nombre del producto, qué empresa tienes, qué versión, algunos iconos y así sucesivamente y así sucesivamente. Aquí hay mucho y vamos a cubrir algunos de los ajustes del proyecto más adelante. Como dije, ahora mismo, realmente no vamos a ver eso porque no son tan importantes como podría ser, ¿verdad? Entonces esto fue lo creado, el Build, creó una construcción. Y solo, por el bien de la discusión, creemos aquí una nueva escena. Estas serían escenas L5, ¿verdad? Porque estamos hablando de escenas. Abramos esto y luego también creemos un nuevo guión. Entonces esta es solo la prueba. Solo llamemos a esto los guiones de escenas tan importantes que son escenas y no vistas. Porque creo que si tuviéramos que nombrar esto, sólo los vimos, podríamos chocar con algo. Y dentro de aquí en realidad podemos usar algo. Por lo que tenemos que usar un nuevo espacio de nombres. Este es el motor Unity. No, eso no está bien. Ya conoces el motor que la alta dirección. Y con esto, en realidad podemos hacer todo tipo de cosas divertidas. Entonces por ejemplo, tenemos al encargado de escena. Y el encargado de escena básicamente puede hacer todo lo que queríamos hacer. En realidad podemos incluso crear nuevas escenas. Podemos conseguir todas las escenas. Podemos ser vistos en un índice en particular, ese es exactamente el índice en lugar de los ajustes de compilación. También lo podemos conseguir, obtener las escenas por nombre. Podemos cargar una nueva escena. Entonces aquí es donde básicamente podemos cambiar de una escena a otra. También hay dos eventos a los que estás incluso a los que podríamos suscribirnos. Y sí, esas son una especie de algunas de las otras. Hagamos lo siguiente. Sólo hagámoslo para que inmediatamente después de arrancar, cargue una escena diferente. Por lo que se va a cargar vista con índice uno. ¿ Eso es correcto? Vamos a revisar rápidamente de nuevo. Entonces esa es una de las cosas donde es un poco sí, L3. Eso es exactamente correcto. Entonces eso está bien. Sí. Entonces la idea aquí es que por supuesto tenemos que adjuntar esto a un objeto. Entonces esto va a ser objetos de una escena, 000 000. Esto es sólo una vez más para mí, porque realmente quiero que esto esté en la posición 0 000 escenas. Por lo que el guión ahora se adjunta a este objeto. Si guardo y empiezo ahora, esta escena cambiará a vista L3. Como puedes ver ahora estamos en L3. Podríamos tener que ampliar esto para ver. Y luego tenemos nuestro guión de salud de vuelta. Y esto se está ejecutando porque básicamente hemos iniciado este C ahora. Y si cerramos fuera de ella, estamos de vuelta en nuestra L5 SI original. Entonces eso es una cosita corta sobre las escenas y la configuración básicamente de construir y cómo construir tu juego. Esto lo vamos a ver más adelante por la línea en un poco más de detalle y un poco más de lo que entra en ella. Pero en general, las escenas mismas son bastante importantes. Y sí, eso fue básicamente todo para esta conferencia. Espero que te resulte útil si hay alguna pregunta como siempre, siéntete libre de preguntar y me aseguraré de responder. Y sí. 49. (Fundamentos de la unidad. MonoBehavior en la unidad: Muy bien, bienvenidos de nuevo a la unidad básica introducción para el curso UD. Y en esta conferencia vamos a echar un vistazo al guión de comportamientos mono. Por lo que hemos visto en la primera conferencia de esta introducción básica que teníamos que tener un guión o una clase heredar del comportamiento mono de la clase base para que fuera un componente dentro del inspector en nuestros objetos. Y ahora vamos a ver lo que este comportamiento modelo nos permite básicamente hacer algunos ejemplos y ñames, básicamente algunos ejemplos de lo que es esto y lo que hace. Entonces creemos una nueva escena. Y esto serían seis, y este es el mono conductual. Y vamos a abrir también esta escena, por supuesto, crear un nuevo GameObject vacío. Solo llamemos a este E. Solo llamemos a este ejemplo en este caso, porque no quiero que se llame comportamiento mono necesariamente. Creo que puedes. Creo que los nombres aquí no son tan importantes para los casos porque el comportamiento mono es una palabra clave. Y no creo que los nombres aquí sean algún viejo asociado con ello. Pero solo para estar seguros, y llamaremos a éste el ejemplo de comportamiento mono. Para que no estemos confundiendo la nada. Y vamos a abrirla. Y como puedes ver, una vez más, este año el comportamiento del modelo es exactamente la clase base. Y como siempre, se crean dos de estos métodos, el método de inicio y el método de actualización. Y en realidad ya hay comentarios aquí. Entonces el método de inicio es exactamente lo que dice. Se llama antes del primer cuadro. Entonces la idea es que esto suceda, todo dentro de tu pasa en el mismo inicio. Y el método de actualización es simplemente algo que se llama cada fotograma. Para ello, el script debe estar habilitado. Eso es algo que podemos habilitar y desactivar en el Inspector. lo vamos a ver en breve. Y luego tenemos algunos otros métodos básicos que podemos llamar, por ejemplo, el método despierto. Por lo que solo podemos escribir despierto y luego presionar la tecla Tab para autocompletarlo. El método de espera nos permite básicamente tener algo llamado antes del método de inicio. Por lo que en realidad se llama al método de despertar cuando se está cargando el script. Por lo que este guión en particular en este caso, se está cargando. Y esto sucede por cierto, cuando ya sea se inicia la escena o cuando básicamente se reactiva un objeto de juego inactivo, por así decirlo. Entonces porque podemos activar y desactivar un juego específico objetos. Y a este método de activación se le llama ya sea, como dije, cuando el objeto de juego inactivo se vuelve a activar, donde la escena se carga por primera vez. También contamos con diferentes métodos de actualización. Tenemos dos métodos de actualización diferentes. Tenemos la actualización fija aquí abajo, y también tenemos la actualización tardía. Entonces el arreglado. Básicamente es un método de actualización que es independiente de la velocidad de fotogramas. Y la idea de estar aquí que por lo general la física debe calcularse dentro del método de actualización fija. Porque como se puede ver aquí, esta función se le llama todo marco de velocidad de cuadro fijo si se habilita el comportamiento moral. Entonces si esto está habilitado, este script, entonces esto se llama en una velocidad de fotogramas fija. Por lo tanto, velocidad de cuadro independiente. ¿ Por qué es importante que, que la física sea en lugar de esto, en lugar del método de actualización? Bueno, la idea es que si tienes una buena computadora o una mejor computadora, digamos, entonces tal vez un juego correrá para ti por 60 cuadros por segundo. Y por lo tanto, el método de actualización se va a enfriar 60 veces por segundo. Y tal vez alguien que tiene una peor computadora en realidad solo obtiene 30 fotogramas por segundo. Y esto entonces simplemente significa que esto sólo se llama 30 veces. Y si la física depende de la velocidad de fotogramas, entonces todo se movería más rápido para la persona que tiene la mejor computadora y más lento para la persona que tiene la peor computadora. Por lo tanto, la física entra en la actualización fija, en realidad puede agregar un comentario aquí también. Física, física dentro de aquí. Entonces eso es algo importante. Esa es la fija a ella. Y la actualización tardía se llama también cada fotograma. En realidad podemos ver esto conducen hasta esta corte cada fotograma, pero se llama después de que el método de actualización se haya llamado un realmente después de todo un método de actualización ha, se han llamado. Entonces esto es lo que corre último al final del marco y se puede usar básicamente si tenemos dos cosas, si estamos como, vale, el método de actualización se va a ir y luego la actualización fija podría ir. Y luego queremos algo que al final, entonces la actualización tardía pueda ir un personalmente no lo he usado muchas veces, pero también quería demostrarlo porque puede ser bastante importante. Y luego hay una cosa más que quería mostrar y ese es el método de destruir, el método OnDestroy. A ver si tiene algo. Esto se llama cuando se destruirá el comportamiento moral. Entonces la idea es que básicamente podemos llamar a un destruir un método que luego destruye este particular, ya sea este comportamiento modelo en particular y básicamente lo elimina de un objeto de juego. O también podemos destruir un objeto entero y esto luego se enfría. Entonces este método es exactamente lo que se llama cuando estamos a punto de destruir algo. Esto podría, por ejemplo, guardar algunos datos, o podría generar un mensaje, o podría tener otra llamada de evento que queremos transmitir, por ejemplo, a la, a la interfaz de usuario. Entonces tal vez tienes 10 enemigos y en realidad mostramos ese número en la parte superior de la pantalla y en la interfaz de usuario. Y luego cada vez que este onDestroy se enfría, tal vez queremos ver que un enemigo ha sido destruido. Por lo que actualizamos la UI con eso. Eso sería un ejemplo. Entonces vamos a añadir, si los registros aquí, así depurado con el método de despertar en este caso. Y luego solo copiemos esto al alza explicado. Básicamente puedo marcar algo aquí para poder seleccionarlo. Presiono Control C y luego entro aquí y presiono Control V para pegarlo. Y este es el método de inicio. También tenemos la actualización. Entonces pongamos esto aquí. En realidad pongamos aquí la actualización fija porque es una especie de, ya sabes, no es realmente antes de la actualización normal, pero es que creo que eso tiene más sentido. Y luego la capa que está al final. Entonces este es el método de actualización. Y también vamos a copiar esto para la actualización tardía. Y luego por último pero no menos importante, el onDestroy vamos a sumar. En realidad podemos ver esto. Vamos a ver esto, así que básicamente destruido. Y en realidad echemos un vistazo a eso primero y luego veremos otra cosa también. Además, no olvides agregar esto a nuestro objeto de juego aquí. Esta es una de las cosas que probablemente le pasarán a algunos donde lo iniciarás y no pasa nada. Es porque no has añadido a la cosa a tu objeto, ¿verdad? Y como se puede ver claramente, la actualización en la actualización tardía se llama cada fotograma, ¿verdad? Y la actualización fija, como se puede ver, se llama pesar menos porque no importa cuál sea nuestra velocidad de fotogramas aquí arriba. Esto se llama igual en todas partes. Entonces, en teoría, este número básicamente debería subir exactamente al mismo tiempo que tu número. Y estos dos podrían ser completamente diferentes para algunos, para algunos de ustedes que podrían tener una mejor computadora, va a ser mucho más rápido. Y para algunos de ustedes que podrían tener una computadora no tan buena, esto podría ser manera, mucho menos roja y como pueden ver, despiertos, luego se dispara la actualización almacenada, luego la actualización fija, luego la actualización y al fin, el tardío actualización. Y también podemos ir marco por cuadro. Y como pueden ver, que en realidad estamos consiguiendo otros nuevos. Y como puedes ver, ahora todo es igual en este momento, porque en este momento realmente vamos cuadro por cuadro. Y el FPS es, básicamente significará que es 0. Y luego voy marco por cuadro. Por lo tanto, todos están sincronizados. ¿ Verdad? La otra cosa que quería mostrarles, porque lo que aún no hemos visto es el que aún no hemos visto es el destructor. Y el método de destruir al que realmente podemos llamar. Vamos a hacer o vamos a destruir este objeto. Lo que vamos a hacer es que vamos a tener un nuevo vacío privado. Y sólo vamos a llamar a esto sólo el método de prueba. Porque ¿por qué no? Y este método de prueba en realidad va a hacer dos cosas. Una cosa, va a dar salida a algo. Sólo va a decir, Hey, eso es bastante guay. Y lo segundo que hará es destruir este objeto. Entonces como puedes ver, destruir es un método al que podemos llamar. Y este método de destruir toma un objeto. Por lo que literalmente podemos poner cualquier cosa dentro de esto. Y en realidad ya sugiere que o bien quieren la Transformación de Objeto del Juego destruya el objeto del juego para ser destruido. Entonces esto destruye exactamente este. Por lo que esto destruye en este ejemplo aquí. Y lo veremos en breve. Pero lo que haremos es no queremos que esto suceda de inmediato. Lo que queremos es que esto suceda después de un conjunto fijo de tiempo. Y para eso podemos usar el método invoke. Y el método invoke es un método de comportamiento mono que como se puede ver, invoca el método, el nombre del método en tiempos de segundos. Entonces si sí invocamos y entonces llamamos al nombre del método es método de prueba. Entonces vamos a copiar esto porque el nombre tiene que coincidir exactamente muy importante. Y digamos sólo cuatro segundos. Entonces después de cuatro segundos, con esta invocación, se llama al método de prueba, que imprimirá, oye, eso es bastante guay, y luego destruirá el objeto del juego. Por lo tanto, también dando salida a este método OnDestroy, así como detener todos los métodos de actualización porque están asociados a este objeto en particular. Entonces eso es mucho una vez, Vamos a ver qué va a pasar aquí. Entonces si lo almacenamos una vez más, lo que hemos visto antes, déjame, déjame hacer esto un poco más grande. Y como puedes ver, oye, eso es bastante guay. Básicamente destruido y después se ha detenido el conteo, así como el objeto ya no está ahí. Por lo que aquí se ha destruido. Y si ahora básicamente detenemos esto, el objeto está de vuelta de nuevo. Porque esto es exactamente como lo hemos visto antes. El dato básicamente se restablece para el cuando lo detenemos. Y sí, esa es la idea de tener unos cuantos, por lo que algunos trucos de comportamiento mono por así decirlo. También podemos mirar a algún otro. Entonces si ponemos estos puntos, entonces en realidad podemos ver que hay todo un montón de cosas que podemos llamar. Y si tienes algunos métodos aquí así como por supuesto, algunos tipos diferentes de propiedades. Y sí, esas son básicamente algunas de las cosas que podemos hacer. Podemos, por supuesto, también mirar en el comportamiento mono en sí mismo. Creo que si presionamos Control. Entonces si mantienes Control y luego haces clic en comportamiento moral, realidad podemos ver los metadatos aquí. Entonces esos son básicamente los diferentes tipos de métodos que son capaces de ser fríos. Y sí, pero ahora mismo, eso no es demasiado interesante. Ahora mismo creo que en realidad ya hemos visto bastantes cosas. Básicamente destruir un objeto y algunas otras cosas todas asociadas a este comportamiento mono. Y sí, en realidad eso sería todo para este método, comportamiento mono es una parte muy crucial de este marco de unidad. Entonces definitivamente hay un, es algo importante. Entonces entender esto es realmente importante. Entonces como siempre, pero en este caso, sobre todo si hay alguna pregunta como siempre siéntete libre de preguntar y me aseguraré de responder. Y sí. 50. (Fundamentos de la unidad: matemáticas: Muy bien, Esto es sólo un pequeño adenda corto que hice para explicar los vectores y las matemáticas detrás de ellos. Esto es realmente útil para entender realmente. Y si bien no vamos a entrar en detalles locos, vamos a ver algunas cosas para que ojalá puedas captar el concepto básico de vectores. Entonces primero vamos a empezar con algo. Todos deberían estar familiarizados con la línea numérica. Ahora como puedes ver, la línea va de 0 a cinco, y por supuesto más allá de eso también. Pero para nuestros propósitos, esto es todo lo que necesitamos. Podrías imaginarte estar en algún lugar de esa línea para conocer tu ubicación. Sólo necesitarías saber un número, el número que estás enviando, ¿verdad? Por lo que esta sería una línea unidimensional en este caso, porque sólo se necesitaba un número para saber dónde estás. Supongamos también los números negativos. ¿ Esto sigue siendo unidimensional? Sí, es porque todavía sólo necesitamos especificar un número para saber dónde estamos. Puede ser negativo o positivo, pero seguía siendo sólo un número. ¿ Qué tiene que ver esto con los vectores? Podría preguntarse, bueno, podemos representar ese número como vector. Por lo que los dos se convierte entonces en una flecha del 0 al 20 en este caso, y muchas veces otros casos se llama el origen. Podemos tener diferentes vectores. Veamos algunos ejemplos aquí. Tenemos un vector con valor2, valor3, y valor negativo tres. Si te pidiera que sumaras los números 23 juntos, dirías, bueno son cinco. Bueno vamos a ver qué pasa cuando sumamos los vectores juntos. Aquí tenemos un vector con valor2 y aquí con valor tres. ¿ Cómo podemos sumarlos juntos? Podríamos imaginar el vector con value3 viajando por el primer vector. Y después de que se haga ese diario mirar lo que terminamos a las cinco. Por lo que dos más tres equivale a cinco. Lo mismo se puede hacer con resta o más bien números y vectores negativos. Por lo que 5 más menos tres es igual a dos. Esto podría parecerte completamente obvio porque así es como añades y restas números todos los días. Pero, ¿y si vamos una dimensión más alta a la segunda dimensión? Ahora tenemos dos líneas numéricas. A éste tradicionalmente se le llama eje y, apunta hacia arriba y como vertical. El otro se llama eje x, y apunta hacia la derecha y es horizontal. Al ver el mismo ejemplo que teníamos antes, los dos ahora se escribirían como 2 0, porque ahora necesitamos dos números para identificar dónde estamos en esta cuadrícula. Vamos dos pasos en la dirección x y 0 pasos en la dirección y. Pero digamos que queremos terminar aquí. Bueno, tenemos que ir cinco pasos hacia la dirección x. En tres pasos hacia la dirección y, vamos a llamar a este vector a igual a 5, 3 con valor 53. Y podríamos querer agregar otro vector en esto, posiblemente ser iguales menos 2 y 2. Podemos tomar exactamente el mismo viaje antes de simplemente deslizarme b a lo largo del vector a, podemos llegar a nuestro destino C igual a 3 cinco. Y como se puede ver ahora, la suma y la resta es simplemente una adición para cada número del vector independiente entre sí. Entonces si tomas el valor x y los agregas o restas. Y si tomamos los valores y y sumamos, restarlos, lo que sea, la suma, Esos son los nuevos valores del nuevo vector. La multiplicación es sólo estirar el vector. Entonces si tenemos 2, 3 año y lo multiplicamos por dos, y solo estiramos el vector para que se convierta en 46. Y división sólo hacer algunos más cortos. Ahora para nuestros propósitos, en realidad estamos usando vectores en tres dimensiones, pero es tan fácil como en dos dimensiones. Gracias por escuchar esta conferencia sobre vectores. Creo que es una parte importante de las matemáticas entender, sobre todo cuando se trata de desarrollar un juego sin importar qué motor o sistema estés usando. Y si hay alguna pregunta, por supuesto, siéntete siempre libre de preguntar y me aseguraré de responder. Y sí. 51. (Fundamentos de la unidad) transformaciones y vectores: De acuerdo, sigamos con la introducción de la unidad básica aquí para el curso de unidad. Y en esta conferencia vamos a echar un vistazo a las transformaciones. Entonces hemos visto algunas cosas, el comportamiento mono, y ahora vamos a echar un vistazo a algunas de las partes constituyentes, así como si hacemos click en uno de nuestros GameObjects aquí, podemos ver que tenemos esta transformación cuando tuvimos la posición, la rotación en la escala. Y vamos a echar un vistazo a eso con un poco más de detalle. Entonces vamos a crear aquí una nueva escena. Por lo que esta escena va a ser L para transformaciones. Y vamos a abrirla y fuera de pantalla. Simplemente se llama transformaciones también. transforma, muy importante que es con la S. Así que hemos transformado. De lo contrario, probablemente vamos a tener un problema con el script de transformación real. Entonces o parte. Entonces hagámoslo extenderemos de ceros transformados 0000 en los scripts de transformación aquí. Y entonces simplemente podemos hacer doble clic para iniciarlo. Y entonces podemos pensar en esto. Ya hemos visto esto. Entonces vamos a depurar dot log exactamente esto, esta transformación de puntos. Por lo que esta es la transformación adjunta a este objeto de juego. Por lo que simplemente devolverá el componente de transformación real. Entonces éste de aquí. Entonces veamos cómo se ve esto, cómo sale esto en realidad. Y como puedes ver, no hace nada. Entonces en realidad tenemos que ir un poco mejor que esto. Entonces esto simplemente dice, correcto, esto es como una clase de transformador. Ahora, eso realmente no nos lleva a ninguna parte. Esta transformación, sin embargo, tiene algunos componentes, siendo ésta la posición. Entonces este es un vector de tres. Tiene la rotación, que es un cuaternio. Voy a decir qué es eso en sólo un poquito. Y luego también está la escala, que se divide en la escala local y de pérdidas. Y esto también es un vector tres. Entonces hagamos algo así. A lo mejor. Sí, escala local y con pérdidas. Y así en primer lugar, los vectores, lo hemos visto en la última conferencia. Qué vector es en este caso, estos son vectores tridimensionales. No obstante, los vectores bidimensionales están funcionando básicamente de la misma manera, solo con el último eje no siendo importante. Qué es un cuaternión, es en realidad un cuatridimensional, es constructo cuatridimensional para representar rotaciones en el espacio tridimensional. Ahora eso suena increíblemente complicado al primer pensamiento. Y puede ser bastante complicado. Pero lo bueno es que la rotación también se puede convertir en un vector tres, básicamente, porque la mayor parte de la rotación se puede hacer en ángulos de Euler, esa es simplemente una forma matemática de expresar también las rotaciones. Ya has hecho, podría haber oído hablar de ello cuando tal vez con un avión, ahí está la guiñada y el tono. Y eso es algo que también se puede describir con eso. Y rotación así luego funciona. Se toma básicamente un eje en particular. Entonces, por ejemplo, dices que básicamente vamos a tomar un punto y pegarlo a través del eje x para luego girar alrededor de eso. Y esa es la forma en que esta rotación también funciona básicamente. No obstante, en nuestro caso, la rotación, vamos a ver eso tal vez con un poco más de detalle también. Pero ahora mismo, lo importante es que en 2D, sólo realmente nos importa la rotación Z. Porque la rotación Y estaría en este plano, que o más bien en este plano simplemente tendría algún sentido. Y la expectativa estaría en este plano que no tiene sentido. Sólo andar por ahí así realmente tiene sentido para nosotros. Cualquier otra cosa en 2D realmente no importa. Entonces, en realidad volvamos aquí y depuremos log cada una de esas cosas. Por lo que esta transformación de punto, posición de punto. Y podemos copiar esto con Control C y pegarlo Control V, obtener la rotación aquí y obtener la escala local en este caso. Y vamos, ¿por qué no también conseguir la otra escala? Entonces si ponemos a escala, como se puede ver, hay dos de ellos. Ahí está la escala local y la escala con perdidas. En realidad hay comentarios muy bien allí. Por lo que realmente podemos ver la posición espacial mundial de la transformación. Tenemos un cuaternión que agita a las tiendas la rotación de la transformada en el espacio mundial. También tenemos la escala de la transformación relativa a los objetos del juego. Padres de familia, voy a explicar lo que eso significa en un rato. Y esta es la escala global del objeto. Entonces cuando miramos esto, salida, esto y veamos qué realmente vamos a conseguir. Y lo primero es esto, cómo se ven básicamente los vectores, ¿verdad? Entonces son tres componentes, igual que aquí. Por lo que la posición va a ser de 000, 000, la posición de rotación es de 000. Y luego uno, como dije, un cuaternión es básicamente un vector cuatridimensional que expresa las rotaciones para nosotros en este momento. No pensemos demasiado profundamente en ello. Solo pensémoslo. De acuerdo, Tenemos cuatro números que de alguna manera representan una rotación. Pero también podemos hacerlo con estos tres números. Y entonces esto podría cambiar en consecuencia. La escala, tanto local como lossy es la misma ahora mismo, porque esto es simplemente un, un objeto de juego que está en la raíz. Entonces lo que podemos hacer básicamente es si pongo un nuevo vacío, así que tengo esto seleccionado, haga clic derecho en esto, diga Crear vacío que ir. Se va a crear este objeto de juego como un, como un, básicamente un niño para este objeto de juego. Entonces este es el objeto niño por así decirlo. Y esto es ahora, básicamente tiene dos escalas. Porque si fuéramos a escalar a este padre, entonces el niño escalaría con él. Y si fuéramos a escalar sólo al niño. Apenas al niño se le escala. Entonces si fuera a poner en la balanza al 22. Y entonces como veremos, si empiezo esto y antes que nada, vamos a tener 22 y ambos, porque el, el padre, está bien. No obstante, si desactivamos el script de transformación en éste, vaya al guión hijo y ponga el mismo script de transformación en éste. A pesar de que la escala aquí es 1, 1, 1. Empezamos esto. Verás que la escala local es 111 porque ésta es la escala misma. No obstante, la escala con perdidas en cuanto a cómo el mundo mira esto es de dos a dos. Porque el esto se pone básicamente sí. Agregado. Yo creo que es multiplicativo, correcto. Entonces eso sí. Entonces es multiplicativo. Entonces el, así que si esto es tres veces más grande en cualquier dirección, y esto también es tres veces más grande, claro. Eso tiene sentido. Esa es básicamente la idea de escala local y escala con perdidas. Y también hay una última cosa que sería la posición local. También está la rotación local. Y una vez más, esto es relativo a la transformación del padre y la posición local es relativa a la transformación de los padres. Vamos a echar un vistazo rápido a eso. Y vamos a realmente como un rápido sumar el esto porque de lo contrario sólo vamos a tener números locos por ahí y no lo hacemos ni siquiera vamos a saber cuáles son esos. Entonces esta es la posición, esta es la rotación. Y solo por el infierno de ello se sumará también la rotación local. Porque, ¿por qué no? Si estamos aquí, entonces podemos ver rápidamente esto. Entonces esta es la rotación local que queremos. Y entonces esta va a ser la escala local. Vamos a darle la vuelta rápidamente a esto. Entonces vamos a poner esto aquí abajo porque siempre tenemos el local, el fondo. Entonces hagamos de esto un hábito. Ahí vas. Muy bien, entonces tenemos la posición, luego vamos a sacar la posición local, luego la rotación que la rotación local, la escala y la escala local. Entonces echemos un vistazo rápidamente a esto. Empecemos y veamos qué vamos a ver. Por lo que la posición es de 000, 000 posición local ceros. Eso tiene sentido porque tanto el transformado como el niño tienen deposiciones ceros, por lo tanto, nada cambió la rotación. Es eso lo mismo porque eso es exactamente lo que teníamos. Y luego las pérdidas, las pérdidas se escalan. Por lo que la escala en comparación con el mundo es de tres. Escala local de sí misma es una. Entonces vamos, por ejemplo, a dar vuelta estos 90 grados en la dirección z y luego al niño, podríamos, por ejemplo, en realidad vamos entonces también a mover estos cinco hacia arriba. De hecho, sólo pasemos a arriba. Entonces lo que vamos a ver es que la escala local en la posición local no va a cambiar, como se puede ver, porque localmente este niño sigue aquí mismo. Por lo que lo local es básicamente el eje de esto. Y luego en términos de posición mundial, por lo que la posición normal está ahora en 0 a 0, porque este niño, si miramos a éste, se encuentra justo aquí. Entonces aunque localmente, así que si esta sería la raíz. Este está en 000, 000 porque es exactamente la misma posición que esta transformación en tiempos del mundo, Se mueve. Y lo mismo con la rotación. Como puedes ver, esto ahora es un poco diferente aquí. Como dije, el cuaternión. No necesitas entenderlos ahora mismo. Basta con tener en cuenta que esto es diferente a esta rotación Básicamente. Sí, y esa es toda la idea aquí. Es un poco No se puede volver un poco loco. Por lo general. Simplemente lo que debes darte cuenta es que si tienes objetos infantiles e hijos, entonces pueden trabajar un poco diferentes a los objetos normales. Pero normalmente lo es, que también podemos ver aquí. Podemos establecer realmente mover la rotación y la rotación local, igual que con la posición local y la posición normal. El único que no podemos establecer es la escala con perdidas. Sólo podemos establecer a escala local. Ahora para los objetos que son, que no tienen padres de donde el padre es básicamente la raíz. Esto no importa. Siempre se quiere establecer la escala local de todos modos. Y sólo para que lo hayamos hecho aquí, lo que vamos a hacer es simplemente vamos a hacer rápidamente un movimiento muy parecido al más fácil que podamos. Y esto va a ser esta transformación punto-punto-punto traducir. Entonces este es un método al que podemos llamar a esta transformación. Y como pueden ver, en realidad tenemos muchos métodos a los que podemos llamar. Entonces hay muchas cosas. Entonces ahí lo tienes. Para que como se puede ver, hay muchas cosas en esta transformación que podríamos llamar. Y ahora mismo vamos a ver traducir. Y lo que esto hace, como se puede ver, mueve la transformación en la dirección y la distancia de la traducción. Entonces vamos a mover esto. Si podemos mirar esto, esto necesita una traducción vectorial tres y también puede tomar un espacio relativo a. Esto, simplemente significa que se moverá a lo largo de un determinado vector. Vamos a darle un vector dos puntos, ¿verdad? Entonces este simplemente es el vector 0, por lo que uno en la dirección X y 0 en la dirección y. Y vamos a veces esto por una vez a veces tiempo.Deltatime. Y este tiempo delta es básicamente tiempo de finalización en segundos desde el último fotograma. La idea es que queremos que esto no sea, que no se mueva esto a una velocidad increíble. Pero queremos que esto se tonifique un poco. Básicamente. Vamos a ver qué va a hacer esto. En realidad vamos a, para los efectos de esto, vamos a desactivar el objeto niño y el guión aquí. Voy a encenderlo para que esto se transforme. Porque eso es un más interesante ahora mismo. Y sí, vamos a ver, así que esto debería cambiar la posición. Y debería cambiar esta exposición. En realidad también desactivemos la rotación aquí porque de lo contrario se pondrá un poco funky. Entonces si miramos esto, como pueden ver, ahora se mueve hacia la dirección x. Y si entramos a la vista de escena, podemos ver que en realidad se está moviendo despacio pero seguro. Y sí, es decir, como dije, un movimiento muy, muy básico y sencillo que podemos hacer. Por supuesto, en teoría, lo que puedes hacer es que también puedes llevar tus propios vectores aquí para que puedas crear un nuevo vector porque la distancia que están es importante. Entonces, ¿qué tan grande es importante el vector? Pero sí, en general eso es un resumen básico del componente de transformación, digamos. Por lo que este es el más básico de los componentes que siempre tiene todo objeto de juego. Por lo que esto siempre está presente en cualquier script que tenga el comportamiento mono como clase base, deberías poder hacer esta transformación de puntos y cambiar el posicionamiento o la escala o algo así. Y como puedes ver, hay algunas otras cosas, cuenta de niños, puedes conseguir hijos. Hay una forma de conseguir componentes y también hay una forma de rotar este objeto. Entonces hay algunas cosas como tú, como de costumbre, probablemente sugeriría echarle un vistazo rápido a algunas de esas cosas, pero claro, muchas de ellas también vamos a echar un vistazo en futuras conferencias. Y luego una aplicación real la veremos una vez que realmente empecemos a hacer un rato, básicamente un juego de verdad, ¿verdad? Un verdadero juego como juego donde podemos colocar. Entonces eso es, eso es algo emocionante, pero estamos construyendo las cosas muy importantes. Entonces esta es otra de esas cosas que en realidad es bastante importante, transforma una parte crucial, significando básicamente dónde en el mundo se encuentra un objeto en particular. Entonces una vez más, si hay alguna pregunta, siéntete libre de preguntar y me aseguraré de responder. Mano. Sí. 52. (fundamentos de la unidad) GameObjects en unidad: Muy bien, bienvenidos de nuevo a la unidad básica introducción aquí para el curso de unidad. Y en esta conferencia vamos a echar un vistazo a un juego objetos. Por lo que hemos hablado de esto o he hablado de esto desde hace un tiempo, siempre he llamado a los elementos básicamente constituyentes de los objetos del juego de escena. Y esto es exactamente lo que son esos. Y vamos a echarles un vistazo ahora con más detalle. Entonces vamos a crear aquí una nueva escena llamada El Nine GameObjects. Y entonces por supuesto, también crearemos un nuevo guión y llamaremos a este juego objetos también. Otra vez importante con la S al final, porque de lo contrario podríamos encontrarnos con algunos temas con el nombre. Por lo que se necesita un nuevo GameObject vacío. Además, llamemos a este juego objetos y 000, 000. Una vez más, esto es solo para mí porque realmente necesito que esto sea 0. No sé por qué, pero quiero que mi objeto de juego vacío esté en la posición 0. Ahora antes de entrar en el guión, realidad necesitaremos una cosa más. Y eso es algo para básicamente visualizar nuestro muy bonito un objeto de juego. Por lo que realmente le vamos a agregar algo para que podamos ver esto. Entonces hagámoslo de la siguiente manera. Voy a tener rápidamente, tengo una carpeta en la diferente on, en otra pantalla y sólo voy a arrastrar para escuchar un PNG. Por lo que este va a ser un archivo PNG en lugar de los sprites. Pero esto por supuesto está disponible como recurso. Y esto en particular es, como se puede ver en el Inspector, ahora tenemos esta textura 2D en lugar de aquí. En realidad ya ha visto esto como un sprite. Y en realidad no hay nada que tengamos que cambiar aquí para que podamos simplemente mantenerlo así. Vamos a ir en una futura conferencia entrar al sprite, básicamente un Sprite Editor y cómo funciona esto en una conferencia y ver qué podemos ver ahí. Pero ahora mismo, vamos a hacer es realmente vamos a agregar esto como un objeto de juego. Por lo que simplemente podemos tomar esto y arrastrarlo a nuestra escena. Y así como esto, crea un nuevo GameObject como puedes ver. Y este es un pozo entonces simplemente situado aquí. Lo que vamos a hacer es porque esto es un poco pequeño. Sólo vamos a aumentar la escala aquí a algo así como cinco veces cinco. Y lo que va a hacer, también verás es que está un poco borrosa. Podemos arreglar eso cambiando este modo de filtro a apuntar y luego haciendo clic en Aplicar, y entonces ya no está borroso. Voy a explicar estas cosas como dije un poco más tarde. En lugar de un sprite, ahora mismo, no necesitamos preocuparnos realmente con eso, pero ahora realmente tenemos algo. Entonces vamos también centroide al 000 y luego lo movamos un poco como probablemente como tres. Sí, eso es bueno. Por lo que ahora está en la parte superior de la pantalla. Y si cambiamos a nuestra vista de juego, esto es ahora lo que veríamos dentro del juego. Por lo que veríamos este as de corazones básicamente flotando aquí en la parte superior. Y podremos hacer algunas cosas geniales con esto. Vamos a renombrar esto a carrito porque es una tarjeta. Y vamos a hacerlo, sólo veremos qué podemos ver. Entonces en este momento se trata de un objeto con un componente de transformación, el componente de renderizador sprite. Al igual que con la propagación algunas sales, vamos a echar un vistazo al renderizador en un rato. Ahora mismo. Sólo necesitamos saber que, vale, esto es básicamente ellos son para que tengamos un visual para este objeto. Este por supuesto siendo un objeto vacío, no tenemos eso, sin embargo, tenemos el guión aquí encendido. Y lo que vamos a hacer es hacer doble clic en esto y en realidad empezar a programar algo ahora mismo. Entonces lo primero que queremos es que aquí queremos un nuevo campo, y ese va a ser un objeto de juego privado llamado carta. Y esto es lo genial porque como dije, en lugar de la jerarquía, las cosas individuales son objetos de juego ahí dentro. Y podemos referirnos a esos simplemente usando una nueva variable del tipo de objetos de juego. Entonces esto es simplemente una voluntad de clase, porque este es un mundo privado, hacen de este un campo serializado para que realmente podamos ver esto dentro del espectro. Y entonces en lugar del método de inicio, la pregunta realmente se convierte, bueno, donde se llama esto en este momento sólo se le va a asignar. Bueno, sólo echemos un vistazo. Entonces como puedes ver en este momento, no hay ningún objeto de juego aquí. Y si hiciera algo con esta tarjeta, entonces lo que pasaría es que simplemente no funcionaría porque esto es nulo. Entonces el, no se ha asignado porque esto es, como se puede ver, num significa que aquí no hay objeto de juego. Ahora lo que puedo hacer, y esto es lo realmente genial del Inspector. En realidad podría arrastrar esto aquí. Y como puedes ver, en realidad ve que, Oh, este es un objeto de juego. Y si lo pongo aquí, puedo ver que ahora se hace referencia a este tribunal dentro de esta variable en particular. obstante, normalmente no queremos esto porque no siempre, no siempre es una gran idea asignar cosas a través del inspector. A veces puede estar bien, pero también quería mostrarles cómo se podía hacer esto dentro de sí mismo. Hay múltiples formas diferentes y una de ellas es básicamente una de las más fáciles. Entonces lo que podemos hacer es simplemente decir que el cordón es igual al objeto de juego. Por lo que el nombre de la clase punto encontrar más bien. Y luego dentro de esta llamada de método, podemos llamar, podemos poner un nombre. En este caso, esto se llamaría porque este es el nombre del objeto. Podemos volver a comprobar esto. Sí, este es el nombre del objeto se llama tarjeta, y esto es lo que necesita para entrar ahí. Entonces este es un método estático de GameObject que devuelve un GameObject, como puedes ver, encuentra un GameObject por nombre y lo devuelve. Por lo que esto mirará a través de toda la escena que tenemos Open actualmente. Busca el objeto con el nombre dado aquí y devuélvelo. Si lo encuentra. Si no lo encuentra, claro, todavía va a ser nulo. Así que vamos a ver si realmente encuentra esto haciendo algo como la posición de punto de la tarjeta de la transformación de punto. Por lo que simplemente vamos a conseguir la posición del acorde que acabamos de ver ahí. Y sí, vamos a ver si eso realmente funciona o si no lo hace. Porque ahora mismo, por supuesto la cancha, la corte no tiene ningún guión asociado a ella. Ahora estamos consiguiendo esto, este objeto de juego a través de este guión aquí y echándole un vistazo, así que solo almacenemos esto y veamos qué pasa. Entonces lo primero que podemos ver es que esta variable de tarjeta se ha llenado realmente. Por lo que ha encontrado la tarjeta con GameObject dot find. Y también vemos que 0, 3, 0 ha sido salida y esta es exactamente la posición del carro. Entonces todo ha funcionado exactamente como queríamos. Lo cual es bastante guay. Entonces esta es una forma en la que podemos buscar objetos de un juego y luego sí, Incluso, manipularlos, ¿verdad? Por lo que hemos visto las transformaciones la última vez. Cómo podemos manipular esos, cambiando la posición. Y por supuesto que podríamos, por ejemplo, hacer esto también en esto. Pero quería mostrar algo más porque hay algo más que es realmente interesante y que está engendrando nuevo objeto de juego. Entonces todo esto es una especie de parte de los objetos de juego. Y lo que podemos hacer es básicamente que podemos hacer una nueva variable de objeto de juego aquí. Por lo que juego objeto y establecer esto igual a instanciar. Instantiate es uno de los, uno de los métodos realmente objeto. Y entonces simplemente le damos un, un objeto original, que es este acorde. Entonces esto podría ser un poco raro. ¿ Qué estamos haciendo aquí? Bueno, este método de creación de instancia simplemente crea un nuevo GameObject basado en un objeto de juego dado al que le damos una especie de plantilla. Esto también se puede llamar prefabricado. Y vamos a mirar las prefabs en un poco, poco como una semana después mientras. Ahora solo quería mostrarte básicamente rápidamente que podemos especie de engendrar nuevos GameObjects. Y este nuevo GameObject ahora se guarda por supuesto en esta variable de objeto de juego. Y lo son, podemos establecer la posición, por ejemplo, en el nuevo vector 3 y luego algo así como 0, menos tres. Y menos tres, f termina en 0, algo así. Y sí, Hagamos eso y veamos si eso funciona. Por lo que al principio, deberíamos ver aparecer una nueva tarjeta con un clon de tarjeta de nombre. Exactamente. Y esto está en la posición 0 menos 3 0. Vamos a echar un vistazo a los instanciados un método en un tiempo con más detalle más adelante también por la línea. Yo sólo quería mencionarlo rápidamente porque esto también es una parte muy grande de los objetos del juego. Y en general, van a ser los GameObjects. Eso es lo principal de lo que vamos a hablar. Por lo que siempre se va a hacer GameObjects. Siempre van a ser componentes y siempre van a ser guiones. Y sí, esos son una especie de los bloques de construcción. La idea es que tenemos diferentes tipos de componentes y GameObjects básicamente puede tomar casi cualquier tipo de componente sobre ellos. Scripts o un componente particular se transforma. Y como hemos visto el renderizador sprite, ¿verdad? Eso tiene la capacidad de mostrarnos algo así como una imagen. Y hay tantos más en especie de estos componentes aquí, ¿no? Por lo que esos son todos los diferentes grupos. Y luego para cada uno de esos, Hay muchos de ellos. Entonces vamos a ir pieza por pieza, ya sabes, poco a poco. Vamos a aprender más y más. Y ojalá en algún momento entonces seamos capaces de hacer un pequeño jueguito. A ver. Esa sería una gran idea si eso realmente funcionara. Entonces esa es la clave de los objetos de juego. Puede ser un poco desalentador al principio porque hay bastante para ellos. Ahora, por supuesto sólo mostró unas cuantas cosas. Si ponemos el punto GameObject, en realidad no tenemos grasa, muchos métodos diferentes a los que podemos llamar. Por lo que hay métodos como aquí dentro. Pero lo interesante es que el, esta tasa de llamadas es exactamente un GameObject. Por lo que esto devuelve un objeto de juego. Si echamos un vistazo a esto. Entonces el, vamos por la transformación. Ahí vas. Y así la transformación distorsionada es exactamente algo para un componente en este caso. Pero el, esto se refiere exactamente al objeto del juego. Por lo que también podemos decir este punto GameObject, y luego podemos obtener exactamente el GameObject al que se adjunta este script en particular. Entonces este sería el guión y luego este punto GameObject devuelve el objeto del juego real. Como se puede ver que este componente se adjunta a. Y sí, hay muchas cosas más y estoy bastante seguro de que muchas de ellas vas a recoger a medida que avancemos. Porque podríamos hacer una conferencia de una hora de duración justo sobre GameObjects. Pero eso realmente no nos lleva a ninguna parte porque hay tantas cosas que necesitas como una especie de prerrequisito para entender otras cosas. Entonces a veces puede ser un poco inquieto, pero creo que en general vamos a tener un buen through line para entender cada parte en particular. Pero de todos modos, Suficiente dijo que esta fue la conferencia sobre un juego de objetos. Espero que lo hayan encontrado útil. Y yo por supuesto, realmente agradecería una crítica de ustedes. De lo contrario, si tienes alguna pregunta como siempre, siéntete libre de preguntar y me aseguraré de responder. Y sí. 53. (fundamentos de la unidad) métodos de introducción en la unidad: Muy bien, sigamos con la introducción básica de la unidad aquí para el curso de la unidad. Y en esta conferencia, vamos a echar un vistazo a los insumos. Entonces entradas, básicamente si presionas una tecla y luego pasa algo cierto. ¿ Cómo podemos hacer esto en Unity? Bueno, vamos a averiguarlo. Vamos a crear una nueva escena, L ten, llamada entradas y apertura, como siempre crear aquí un objeto de juego vacío, también llamando a estas entradas. Y vamos. Después de centrar esto en 000, 000, vamos a crear también un nuevo script de las entradas de nombre. Se podría haber adivinado, pero ahí tienes. Ahora, no vamos a necesitar aquí el método de inicio. Sólo necesitamos el método de actualización para este. Porque el método de actualización básicamente ejecutará cada fotograma. Y si presionamos una tecla, entonces algo sucederá. Entonces, ¿cómo podemos hacer esto? Bueno, ponemos una declaración if y luego llamaremos al punto de clase de entrada, bajaremos la tecla. Entonces este es el método que queremos, por lo que devuelve true durante el fotograma, el usuario comienza a presionar una tecla, y esta tecla es accesible mediante el uso de código clave punto. Por lo que el código clave es una enumeración. Y dentro de aquí, como puedes ver, todos son básicamente un montón de códigos clave diferentes. Y tomemos sólo para este f Así que presiona F para depurar registro de puntos. Descanso FQ. A mí me gusta. Entonces en teoría, si todo funciona, esto debería ser cierto una vez que presione la tecla F. Por lo que lo presiono y esto obtendrá salida una vez, porque en este caso sólo consigue verdaderas. Entonces vamos a ver si eso realmente funciona. Además, asegurándose de que el script de entrada esté encendido aquí. Muy importante. Ahora mismo, nada y luego llave F, y ahí tienes. Ahora lo que puedo hacer es si presiono la tecla Mayús, como pueden ver, no aumenta. Sigo sosteniendo la llave hacia abajo. Simplemente debes confiar en mí para este. Pero en efecto, esto no aumenta. Y si lo dejo ir, lo hice a propósito. Entonces tal vez has escuchado eso. Entonces vamos a ver. Por supuesto, hay otras cosas que podemos hacer. Y eso es exactamente correcto. Por lo que hay una tecla de punto de entrada y obtienen C0 simplemente también toma un código de clave. Démosles también F aquí. Solo copiemos esto y digamos presionando la tecla F. Y luego sólo por culminación, sólo voy a la otra. Esto es Ponte de pie. Y eso se llama, que luego se deja de presionar la cuadrícula de teclas F. Entonces la tecla hacia abajo es verdadera una vez que empiezo, una vez que presiono la tecla. Para sólo unos obtienen clave, como se puede ver, devuelve true mientras que el usuario mantiene presionada la clave identificada por la clave, clave llamada parámetro enum. Y obtienen claves verdaderas durante el fotograma que el usuario libera a la clave. Por lo que tenemos la capacidad de comprobar si una tecla se ha presionado o no una vez. O mejor dicho. Al igual. Vamos a ver qué pasa aquí. Por lo que presiono F y lo mantengo presionado. Como puedes ver, presionando la tecla F, solo, en realidad se detiene si el foco ya no está en el juego. Porque si miras, así podemos ver si hago esto y luego dejo de presionar porque dejan de presionar aquí. Pero se puede ver que esto ahora está en foco debido a esta línea ligeramente azul de aquí. Y si me muevo aquí en algún momento podría, tal vez porque hago clic de distancia, entonces el enfoque se desplaza y entonces por supuesto esto ya no se está ejecutando. Entonces esto es lo más probable lo que pasó aquí. Eso por alguna razón sí, ahí tienes. Ahora el foco cambió y luego esto se detendrá por supuesto. Entonces eso es una cosa que es muy importante darse cuenta también. Pero sin embargo todavía funciona muy bien. Y como puedes ver, si de verdad me gusta, intenta que me guste solo haz clic una vez y sigue como 40, 7, 2, 4, 7, 1. Entonces incluso lo son porque por supuesto nuestra velocidad de fotogramas es tan alta. Presionamos esto muchas veces, a pesar de que lo estoy presionando como por apenas un segundo, todavía nos estamos volviendo absolutamente locos. Entonces, sí. Sí, pero eso es un insumos básicos. Eso es en realidad todo lo que hay para ellos. Es igual que declaraciones si muy directas. Eso es todo lo que realmente hay. Y esos simplemente devuelven booleanos. Entonces por supuesto que también puedes encadenar esos juntos, ¿verdad? Entonces input get key down con kicker f. Y luego si, por ejemplo, podrías usar algunos de los operadores booleanos, algunos de los operadores lógicos, el final, y luego básicamente ponerlos junto con otro código clave. Entonces sí, esos son los insumos muy básicos. Y eso en realidad te permite ya hacer algunas cosas geniales locas. Y lo que vamos a ver básicamente la próxima preconferencia es hacer un guión de movimiento muy sencillo. Ahora, hay algo en lo que también puedes pensar quizá si piensas de nuevo a nuestras transformaciones, tuvimos un movimiento muy, muy sencillo ahí. Y si ahora aplicas las entradas y básicamente lo que teníamos en la conferencia de transformaciones, tal vez ya puedas descifrar antes de ver la siguiente conferencia, cómo podríamos ser capaces de crear un guión de movimientos muy, muy sencillo. Sí, pero con eso, te dejaré a ti y a mí por ahora, para esta conferencia de insumos, fue por supuesto, una de las cosas más importantes para un juego. Sé que, como siempre digo, bueno, esta es una de las cosas más importantes, pero esto podría no ser importante cómo funciona exactamente. Pero los insumos en sí son importantes para un juego. Por lo que probablemente los insumos podrían haberlos descubierto por su cuenta. Pero sin embargo, esta es la conferencia de insumos. Y en el futuro hay un poco más de matiz. Por lo que bien podría mostrarte sólo rápidamente. Por lo que la clase de entrada ya tiene, como se puede ver, mucho más cosas también. Entonces esta no es la única forma de obtener la entrada. Hay bastantes cosas que puedes hacer. Pero por ahora, este es el insumo que, ya sabes, yo era. Creo que eso tiene sentido mostrarte. Y luego más abajo de la línea, si alguna vez necesitamos algo más, vamos a ver eso también. Sí, pero para esto, es el final de la conferencia. Espero que te resulte útil y como siempre, si hay alguna pregunta, siéntete libre de preguntar y me aseguraré de responder. Mano. Sí. 54. (Fundamentos de la unidad) crear un movimiento simple: Muy bien, sigamos con la introducción básica de la unidad aquí para el curso de la unidad. Y en esta conferencia, vamos a crear un guión de movimiento muy sencillo pero a la vez eficaz. Y para eso, por supuesto, vamos a, primer lugar crear una nueva escena. Este sería el movimiento L 11, un movimiento. Y empecemos de inmediato esto. Y esta vez no vamos a crear un GameObject vacío, pero una vez más vamos a simplemente tomar el corazón y ponerlo aquí y de hecho tamaño para arriba. Vamos a dimensionarlo hasta cerca de cuatro veces su tamaño normal. Y comenzó en y nivel dos. Y luego también vamos a hacer un nuevo guión. Este va a ser un guión llamado ¿dónde está? No, me lo perdí. Al parecer, ahí lo tienes. Movimiento. Movimiento. Sí. Y abramos este guión y veamos qué podemos ver. Entonces, antes que nada, vamos a tener unas cuantas cosas aquí. El primero va a ser un campo serializado, va a ser un flotador privado llamado velocidad. Y vamos a poner esto en tres. Por el momento. Podemos, por supuesto, cambiar esto hacia arriba más adelante por la línea. Porque con el campo serializado, esto está por supuesto disponible para nosotros en el inspector. Y lo que también vamos a hacer es crear una transformación privada, que sólo va a ser mi forma de mechones de tendencia. Y esto simplemente se va a poner a. Entonces mi transformación es igual a esta transformación. No necesariamente necesitamos hacer esto. No obstante, en una conferencia posterior, vamos a aprender sobre gets componente y por qué el almacenamiento en caché así es una idea muy inteligente como esta. Hacer esto en realidad es bastante. Y luego vamos a crear dos métodos diferentes porque vamos a empezar a hacer las cosas de una manera que es, digamos legible. A lo sumo, así sería genial. Entonces tendremos un método de ejecución y un método de movimiento. No, método de movimiento normal. Ahí vas. Entonces este, Vamos a tomar los corchetes rizados aquí y luego, y esos dos son, se llamará dentro del método de actualización. Entonces r1 y luego muévete. Entonces esto es algo que es bueno pensar. A generalmente lo mejor es separar cada una de las funcionalidades en su método de actualización en métodos como diferentes. Y luego simplemente tenerlos aquí. Porque ahora si entro en este código y veo, oh, bien, primero lo haré, llamaré a correr y luego me muevo. Esto. Ya sabes, el nombramiento podría ser un poco diferente, pero en nuestro caso creo que esto va a estar bien. Ahora este método de movimiento va a tener exactamente lo que hemos aprendido en básicamente las pocas conferencias anteriores. Entonces, en primer lugar, el input.txt obtiene la clave, no bajar la clave, sino obtener la clave. Y luego con una nota clave con un código clave. Entonces este es el punto clave enum. Tomemos el w. Así que w nos moverá hacia arriba. Por lo que esto luego hará lo siguiente. En realidad estoy sí, seguro. Hagámoslo así. Hagamos realmente primero que nada lo hagamos así. Y luego te voy a mostrar otra forma de hacerlo. Entonces mi transform.py traducir, oh, nope, traduce. Entonces esta es la llamada de método que hemos utilizado. Última vez. Esta fue la llamada de método para básicamente mover algo. Y vamos a poner esto en vector dos puntos. Entonces esta es la dirección ascendente con el tiempo.Deltatime tiempos velocidad. Entonces esta es básicamente la llamada que vamos a hacer, que vamos a hacer porque entonces vamos a mover el camino hacia arriba. Entonces 0, 1, x siendo 0, y siendo 1, tiempos delta, una vez más por hacerlo para que no lo hagamos, básicamente hace esto más o menos como la actualización fija. No del todo, pero solo llamémoslo así por el momento para que no tengamos un loco, loco como gran número. Hagamos también WASD por el bien del argumento S y D aquí. Y entonces a sería la izquierda, S sería vector abajo y un vector para escribir. Entonces eso está bien. Y vamos a probar esto con este código por ahora y luego vamos a refactorizar un poco después de haber probado. Entonces tomemos el guión de movimiento y lo agreguemos a este acorde. Y luego entremos y veamos si esto realmente funciona. Entonces si presiono la tecla Esc, nos movemos y si la mantengo presionada, entonces se mueve y la carta efectivamente se mueve. Ahora lo que notarás es que el movimiento diagonal es un poco más rápido que el movimiento normal. Esto se debe simplemente al IEP. Esto se debe a la similar agregando porque nos estamos moviendo, digamos velocidad urbana de tres en esta dirección y la velocidad de tres en esta dirección. Y luego en teoría, deberíamos estar moviéndonos en una velocidad de seis en las direcciones diagonales. Que por supuesto no es realmente lo que queremos. No obstante, por el momento vamos a ignorar esto. En primer lugar, lo que vamos a hacer es que vamos a pensar en hacer esto un poco más legible. Ahora esto no es lo más grande y no necesariamente necesitamos hacer esto. Pero como puedes ver, esto es como un muy parecido a esto es casi siempre lo mismo, ¿verdad? Esto, este llamado aquí. Siempre son mis tendencias de retraducir. Y lo único que cambia es esto. Y si tenemos eso, En realidad es bastante fácil volver a hacer otro método o esto, así que esto sería, por ejemplo, mover a podría ser la cosa o podríamos, también podríamos llamarlo mover de nuevo. Porque aquí vamos a tener un perímetro que va a ser un vector para citar dirección. Y entonces básicamente podemos simplemente copiar esto porque esto es, sólo vamos a usar estos. Ponga la dirección aquí. Se va a tomar la velocidad, desde luego de aquí arriba, así que eso no importa. Y entonces básicamente podemos decir Mover a y luego decir vector a punto. Esto sería correcto. Y entonces básicamente solo cambia esto. Así, boop, boop, boop. Y luego sólo asegurándonos de que aquí tenemos los correctos. Esto queda y esto está abajo. Se van, correcto. Este es sólo un ejemplo. Al final del día, realmente no hay una respuesta como una correcta o incorrecta a esto. No obstante, diré que creo que probablemente es mejor leer esto. También podríamos decir tal vez moverse en dirección. Este podría ser en realidad un mejor nombre. Y si queremos cambiar este nombre se puede hacer es podemos golpear a Control R dos veces. Por lo que básicamente controlar RR. Y entonces podemos cambiar esto, así que muévete en dirección. Y entonces esto es aún mejor leer. Entonces esto, creo, es aún mejor leer. Entonces podemos ver, vale, si se presiona la tecla, entonces muévete en dirección vector dot-dot-dot. Por lo que conocemos nuestro caso. Nos estamos moviendo hacia arriba en la dirección. En realidad como realmente agradable de leer. Y en general creo que un buen método para básicamente refactorizar en este caso, ¿no? Entonces, ¿qué tiene que ver también con esta corrida? Por lo que también tenemos este método de ejecución aquí. Y lo que vamos a hacer aquí es que básicamente vamos a hacer lo siguiente. Entonces input.txt clave hacia abajo. Entonces si presionamos las teclas, entonces lo que vamos a hacer es que vamos a decir calor o turno de izquierda, sólo por el bien de la discusión en este momento. Entonces vamos a poner esta velocidad a cinco. Entonces básicamente, una vez que lo he presionado una vez, entonces vamos a poner la velocidad en 25. Y luego vamos a copiar esto y decir, si levantamos la llave, entonces vamos a restablecerla a tres. Entonces esto simplemente lo hace para que podamos correr. Básicamente. Hay algunos, digamos, temas asociados a él que vamos a ver también. Pero vamos a ver si eso funciona. Entonces, en primer lugar, nuestros movimientos normales aún funcionan. Y luego si presiono la tecla Mayús y los muevo, como pueden ver, soy más rápido de lo que era antes. Y luego si dejo de sostener Shift, entonces funciona para que pueda en ráfagas básicamente correr. Eso es bastante bueno. Ahora, una de las cosas que, claro que podría hacer. Entonces ahora mismo, tengo presionada la tecla Mayús. Y debido a que busca el levantarse, básicamente puedo hacer clic fuera de esta ventana, dejar de presionar la tecla Mayús, volver a entrar. Y ahora siempre estoy corriendo. También podemos ver esto por aquí. Ahora la velocidad es de cinco. Y ahora siempre estoy corriendo. Ahora esto es algo en lo que hay que pensar también. Es sólo una cosita corta que quería mencionar sólo por el momento. Y ahora pensemos también en la idea de la, la duplicación. Entonces la duplicación ocurre porque como dije, cuando miramos esto, si presiono tanto W como E, ambas direcciones se van a mover. Y entonces básicamente el traductor se va a mover ambos hacia la dirección de igual derecho, con estas adiciones. Entonces digamos sólo por el bien del argumento se va a mover o a la izquierda más bien. Entonces se va a mover en dirección menos 1, 0. También se va a mover hacia la dirección 0, 1. Y esos básicamente se agregan. Y el movimiento diagonal que entonces es más rápido, que por el, justo como funcionan los vectores. ¿ Verdad? fijación de esta diagonal es en realidad, yo no diría imposible para el traductor. No obstante, va a implicar un poco más de finura en este caso. Y esto es algo que no vamos a hacer, sobre todo porque el método Traducir en realidad no siempre es la mejor manera de movimiento, como si hubiera mejores maneras de asegurar el movimiento. Y por lo general también, el movimiento diagonal. Si es así, realmente no importa si el movimiento diagonal es más rápido o no más rápido que por supuesto, eso en realidad no es de verdadera preocupación. Pero ahora mismo no vamos a arreglar esto porque en esta instancia en realidad no es un problema. Y también por lo fijo en realidad iría un poco más profundo en cómo funciona esto y haría esto un poco más complicado. Y se supone que este es un guión de movimiento muy fácil que simplemente funciona. Ahora esto es por supuesto, un guión de movimiento que funciona para una especie de vistas de arriba hacia abajo o una especie de vista Zelda en este caso. Pero esto se puede adaptar a una plataforma tipo de u Espere el salto y lo diferente, digamos movimientos diagonales. Entonces hay una manera diferente con eso. Básicamente podemos usar el sistema de movimiento o crear un sistema de movimiento diferente. Digamos que eso es, es algo que vamos a echar un vistazo en una conferencia posterior. No obstante, tenga la seguridad, esto se verá en una fecha posterior, ¿no? Entonces esto fue todo por el movimiento muy básico. Ahora en realidad tienes una tarjeta básicamente que puede moverse, lo cual es bastante genial. Todas las cosas consideradas. Por lo que hemos recorrido bastante largo camino. Y en general eso fue todo para esta conferencia. Espero que te haya parecido útil como siempre. Si hay alguna pregunta, siéntete libre de preguntar y me aseguraré de responder. Y sí. 55. (Fundamentos de la unidad) entrada del mouse: Muy bien, sigamos con la introducción básica de la unidad aquí para el curso de la unidad. Y en esta conferencia, vamos a echar un vistazo a las entradas de un ratón. Por lo que ya hemos visto entradas normales y luego un poco de guión de movimiento. Ahora vamos a ver cuáles básicamente podrían ser las entradas con un ratón. Y vamos a crear una nueva escena para eso, que va a ser L2. Se trata de entradas de ratón, ratón. Y luego por supuesto también un nuevo guión. Esto también se va a llamar tasa de entradas de ratón. De acuerdo, enseguida enganchemos esto a un GameObject vacío, también llamado entradas Desmos. ¿ Por qué no? Y luego centroide ceros 0000, sólo por mi propio placer esta vez. Y abramos el script de entrada del ratón y veamos qué podemos ver. Entonces, antes que nada, pasemos por los diferentes botones. Por lo que tenemos entrada, punto, bajar el botón del ratón. Es casi como Unity. Escucha lo que estaba diciendo. Y en lugar de aquí, en realidad tenemos que especificar el botón por entero. Entonces, solo veamos cuáles son esos. Así que debug dot log y digamos sólo Watson 0, sólo por el infierno de ello. Y luego sumémosle uno y tres, ¿por qué no? Y ver cuáles son esos. Entonces Botón 1, 2, y 3. Y vamos a probar esto rápidamente. Por lo que el guión se adjunta al GameObject. Entonces, solo veamos. Entonces si hago un click izquierdo es 0, así que click izquierdo es alrededor de 1000. Haga clic derecho en el botón uno. Y el botón del medio del ratón se ha estado también. Ahora, en realidad no tengo otro botón en mi ratón, por lo tanto, botón tres. Bueno, no existe para mí en este caso. Si tienes un ratón que tiene múltiples botones, así más que, digamos el izquierdo, el derecho y el botón central del ratón, entonces realmente puedes acceder a ellos también con simplemente aumentar el índice dado año. Ahora esto probablemente tendrás que probar esto. Y no sé qué tan confiable es al cambiar de ratón a ratón. Por lo que probablemente ten cuidado si vas por esta ruta. Pero sí, sí, y entonces tendremos que mirar algo. Entonces ahora vamos a tomar la posición del ratón, lo cual es muy interesante. Así que debug log input dot mouse posición. Y esto es muy interesante. No obstante, la posición del ratón puede ser especialmente al principio, un poco confusa. Entonces, solo veamos la posición del ratón en acción. Por lo que veremos la posición del ratón cada vez que básicamente haga clic en el botón izquierdo del ratón. Por lo que no vamos a tenerlo constantemente, la salida en la consola. Pero cada vez que básicamente haga clic izquierdo, tendremos esto. Entonces si voy en medio de la pantalla, tenemos la más posición de 9635. 71 y digamos, está bien, vamos a la parte superior de la pantalla. Y ahí tenemos 0 y luego como 1000 y algo. Entonces vamos a la parte inferior izquierda de la pantalla. Trata de llegar tan lejos como los donantes podamos, y luego tenemos 0.514. Entonces la idea aquí es que la parte inferior izquierda de la pantalla es básicamente 00 y la parte superior derecha de la pantalla, si puedo lograrlo, sí, básicamente lo golpeé. Es básicamente la resolución. Por lo que 000. Y entonces aquí arriba está básicamente la resolución, en nuestro caso, full HD. Por lo que 1920 por 10 ADP. Y esta es la entrada normal del ratón, por lo que la otra posición del ratón más bien. Y sin embargo podemos cambiar esto. Entonces el tema siendo, bueno, quiero decir, tal vez quiero las coordenadas reales del mundo. Entonces si hago click aquí, quiero 000 porque esto fue 000. Entonces, ¿cómo consigo esto? Y esto es un poco mientras no diría como necesariamente sólo confuso, puede ser un poco raro. Entonces esto es algo que también a veces tengo que mirar hacia arriba porque hay diferentes formas en que básicamente podemos proyectar nuestra posición del ratón sobre algo. Y lo que vamos a usar es que vamos a usar la cámara para esto. Y aún no hemos hablado de la cámara. No obstante. Y este es un método muy sencillo que podemos usar. Para que podamos usar el guión de la cámara. Entonces cámara dot, esto simplemente consigue el personaje principal de esta escena en particular. Y entonces usaremos pantalla de puntos a punto mundial. Y esto devolverá un vector de tres, como puedes ver y requiere una posición. Entonces esta posición es que entonces por supuesto, en este caso, la posición del ratón de punto de entrada. Y esta voluntad, como se puede ver, transforma un espacio verde punto en espacio mundial. Dónde qué espacio se define como el sistema de coordenadas en la parte superior de tu jerarquía de juego. Entonces la posición de la pantalla es exactamente lo que se da aquí en píxeles. Así que vamos abajo izquierda 000, resolución de pantalla superior derecha. Por lo que ancho veces alto. Y esto entonces básicamente transforma esos en el espacio mundial. Entonces veamos qué podemos ver ahí. Una vez más, conseguiremos esto cuando haga clic izquierdo. Entonces vamos a volver a la 00. Eso en realidad es negativo porque estaba fuera como la pantalla. Por lo que en realidad también funciona. Probemos mano realmente quédate dentro de la pantalla. Sí, eso está bien. Entonces como pueden ver, en algún lugar a lo largo de los 000 , estamos en un menos ocho , menos, digamos menos nueve, menos cinco y menos 10. Ahora eso debería funcionar en realidad. Porque una vez más, en especie de años, así que el medio estamos en 000 000 000. Casi me toco el medio exacto. Eso es, eso es bastante bueno en realidad. Por lo que recordamos que la cámara está en la posición 0, 0 menos 10. De aquí viene este menos 10, porque básicamente estamos en el avión donde se sientan las cámaras. Entonces si ajustara esto a menos 5 y volviera a hacer clic, entonces de repente estaríamos en menos cinco. La posición Z simplemente corresponde a la posición z de la cámara. Entonces eso es algo importante saber solo por tu información. Ahora esta es la pantalla a mundo punto a punto exactamente. También hay otra cosa. Esto podría ser bastante útil. Esto también es accesible a través del punto de la cámara, y esta es la pantalla a punto de vista. Este es el ratón input.txt, posición del ratón, por supuesto. Y éste, si echamos un vistazo a esto, va a ser el siguiente. Si empezamos de nuevo, entonces el mirador, si tratamos de ir 000, no estamos del todo en 000. Tratemos de conseguir esta pierna adecuadamente. En realidad, vamos a aclarar esto. Esta es la ventana gráfica. Entonces esto son 000, 000. El puesto real fue 0529 y luego la posición mundial en algún lugar como menos 9 otra vez. Por lo que hemos visto esto ya sabio, los ceros 0000. Bueno, aquí arriba, si puedo llegar a la cima es 11. Entonces esto es básicamente, como se puede ver, una especie de en el medio es de 55 como 0.5.5. Por lo que la ventanal es 00 en la parte inferior y 11 en la muy superior. Podría también ser útil para algunas cosas, pero esos son una especie de los principales cambios. También voy a añadir rápidamente los comentarios que tengo aquí. Por lo que ya he preparado algunos comentarios para cada uno de esos para que realmente podamos pensar un poco más en esto. Ya he explicado esto. Como dije, la mayoría de los vasopresores pueden ser un poco confusos porque tenemos que traducir esto de específico, ya sabes, del espacio de pantalla al espacio mundial y así sucesivamente. Y también hay otros múltiples. Entonces como pueden ver si voy aquí. Por lo que la pantalla, también tenemos uracil y podemos ir ver puertos a pantalla y así sucesivamente y así sucesivamente. Para que podamos cambiarlo. Queríamos hacerlo. Es por eso que dije que a veces incluso tengo buscarlo porque al final del día, sí, eso es solo a veces como es. No obstante, la posición normal del ratón en la parte inferior izquierda, 00 en la parte superior derecha, tiempos de ancho adsorbidos con altura es el vector. Para la cosmovisión proyectada representa las coordenadas en lugar del mundo. Entonces si hacemos click en el medio de la tarjeta, en realidad no tenemos tarjeta en este momento y solo podemos probar eso. ¿ Por qué no? Entonces, en realidad, saquemos una tarjeta aquí. ¿ Por qué no? Entonces en realidad podemos hacer clic en esto. Entonces pongamos esto en, por ejemplo, 0, tres e intentemos hacer click en el medio de la misma. Y entonces deberíamos poder ver, probémoslo y ponernos realmente en medio de eso. ¿ Se van 003, eso, como se puede ver, y luego negativo 10, y esto es lo que estaba mencionando antes. Por lo que la posición z de la coordenada corresponde a la posición z de la cámara utilizada. En nuestro caso, utilizamos la cámara principal de esta escena. Por lo tanto, la posición Z está en 10 negativa. Y viewport, como también dije, 00 en la parte inferior izquierda y uno en uno en la parte superior derecha. Entonces esas son algunas de las entradas del ratón. Y leer la posición del ratón puede ser realmente útil para algunas cosas. Ahora, para hacer clic, digamos un juego diferente objetos, en realidad podemos usar un, un método mucho más fácil. No tenemos que usar esto. Y esto es algo que vamos a ver más adelante también. Por lo que no necesitamos comprobar básicamente siempre la posición del ratón dentro de este nodo. La posición del ratón podría utilizarse para que un objeto de juego específico siga al ratón. Ahora esto en realidad es algo que probablemente ya deberías poder hacer. Entonces esto es algo que tal vez quieras descifrar. Y sí, pero eso fue todo para la conferencia de entradas de ratón aquí. Espero que lo hayan encontrado útil. Si hay alguna pregunta como siempre, siéntete libre de preguntar y me aseguraré de responder. Y sí. 56. (Fundamentos de la unidad. La cámara): Muy bien, sigamos con la introducción básica de la unidad aquí para el curso de la unidad. Y en esta conferencia vamos a echar un vistazo rápido a la cámara principal. Por lo que ya hemos visto en la última conferencia en el mouse entradas básicamente de distancia con, en la que podemos tomar la posición del ratón y especie de convertidos en diferentes tipos de puntos. Por lo que hemos visto los puntos del mundo. Por lo que pantalla para crecer puntos y pantalla para ver PowerPoints. Y eso dependía de la cámara. Entonces esas son una o dos cosas. Por ejemplo, la cámara puede hacer. También hay unos cuantos más. Te puedo mostrar rápidamente que no vamos a crear un nuevo guión para esto. Sólo vamos a mirar en el tipo del script de entrada del ratón. Entonces camera.capture básicamente tiene algunas cosas diferentes que podemos usar. Y en realidad bastantes, como puedes ver muy claramente, hay muchas cosas, ya sabes, el píxel ancho, ortográfico, qué hace eso, todo eso significa, podemos restablecer la cámara. Entonces hay un montón de métodos que podemos llamar también. Pero la mayoría de esto en realidad generalmente no lo hace, no se hace por guión. En realidad hacemos los cambios dentro de nuestra escena aquí. Entonces aquí en realidad podemos usar básicamente todas esas cosas que acabamos de ver en el guión. Entonces hay algunas cosas que podemos hacer. Entonces hay banderas claras. Tenemos profundidad solamente, no despejes y Skybox. Y si pasamos por encima de él, como se puede ver claramente, en realidad hay unas explicaciones muy bien pensadas para muchas de esas cosas. Entonces lo que voy a ir rápidamente a pasar por estas cosas. Entonces en general, color, quiero decir, que deberían ser colores autoexplicativos, sólo el color de fondo que tenemos. Mascarilla de Culling básicamente es como puedes ver, qué capas de la cámara renderiza. Por lo que hay diferentes capas que algo puede tener justo aquí. Y si quieres algo ignorado, entonces por ejemplo, si vamos al as de picas, esta es la capa por defecto aquí. Y si dejamos de renderizar la capa predeterminada, entonces como se puede ver en la cámara principal y también en el juego, ya no está ahí. Entonces esto es, por ejemplo, algo que podrías encender y apagar. La proyección es muy interesante. Entonces si miramos en esto aquí, tan ortográfico simplemente significa que si rápidamente cambio en realidad en la vista de escena al espacio tridimensional, y me alejo un poco. Por lo que con el botón derecho del ratón, puedo hacer una especie de panear la cámara con el botón central del ratón, puedo moverla. Entonces se puede ver este tipo de caja que se extiende hasta básicamente el plano infinito aquí. Y esta es la proyección que se está haciendo. Por lo que es una proyección uno a uno, sin perspectiva. Por lo que normalmente tal vez has oído hablar de esto. El, Hay una perspectiva. Entonces las cosas que son Neera, dibujarías más grande que las cosas que están más lejos. Esta simple perspectiva básicamente, ahora la ortografía en realidad sólo tiene todo al mismo tamaño. Sólo para mostrar, en realidad voy a dimensionar rápidamente esto, escala, esto hasta como 44. Por lo que en realidad podemos ver esto un poco mejor. Y luego la cámara principal, si la volvemos a mirar, y cambio esto a perspectiva, entonces como pueden ver, ahora, este cono de proyección es en realidad mucho más como una cámara normal lo sería, ¿verdad? Así que algo así como. Y no es realmente notable en este caso. No obstante, el objeto real aquí realmente no cambia tanto porque en primer lugar, es un sprite 2D plano. Y además, en realidad no necesitábamos utilizar estas proyecciones. Básicamente se necesita la proyección de perspectiva si se quiere un juego tridimensional. Esa es la forma más fácil de pensar en esto. También hay un campo de visión en este caso, estamos, como pueden ver, podemos hacer la proyección más a lo largo o más grande aparte. Por lo que en realidad hay un deslizador f de v aquí. Y hay algunas otras cosas que podemos hacer de esta una cámara física. Tengo que ser honesto, nunca he jugado mucho con esto. Y los aviones de recorte simplemente significa que ¿dónde está la distancia cuando las cámaras paran el renderizado? Entonces pongamos el tamaño ortográfico. ¿ Estamos en realidad también ponemos en el tamaño. Por lo que el tamaño simplemente significa el tamaño de la predicción como puedes ver. Por lo que hacer lo más pequeño básicamente simplemente renderiza un área más pequeña ahí dentro. Los planos de recorte simplemente significa, vale, ¿ cuándo deja esto de renderizar? Entonces si pongo esto en negativo nueve, entonces está realmente, muy cerca de la cámara. Ahora bien, esto no cambia porque la proyección ortográfica es sólo, oh sí, eso es sólo una superficie 2D. Si fuera a poner perspectiva y por supuesto ahora el, se ha ido. Y si muevo un poco la cámara y es enorme como puedes ver. Entonces esa es en realidad una manera realmente buena de mostrar la distancia no importa para la escala del objeto. Sólo la escala en lugar de aquí realmente importa. Y el avión de recorte simplemente significa que a medida que esto se acerca a la cámara, ahora mismo estamos a 0.4 de distancia de la cámara, todavía ahí. Pero si voy en el punto menos 9, 7, entonces estamos a 0.3 de distancia. Entonces esto es justo en la cúspide. ¿ Dónde lo seguimos viendo? Y luego al 98, así que ahora está el único 0.2 de distancia de la cámara, y luego deja de renderizar porque está demasiado cerca de la cámara. Esto es básicamente lo que este avión de recorte de aquí, mi control. Entonces si pongo esto a 1.1, entonces de repente, como pueden ver, vuelve a aparecer la tarjeta. Entonces estos son los aviones de recorte. Hagamos esto en realidad, podemos hacer clic en esta llave de bloqueo y luego en lo que haga clic, el Inspector se queda donde está. Entonces eso en realidad es un poco útil. El mirador es, como se puede ver, el indicar dónde se dibujará la pantalla y la vista de la cámara. Por lo general soy también algo que realmente no he necesitado todo tanto. En realidad pongamos la espalda del corazón. ¿ Dónde está la cámara o el negativo diez? Y entonces éste es, oh lo siento, yo soy, claro que eso es, eso tiene sentido. Porque esto tiene, sigue siendo la cámara por supuesto 0, y entonces ésta está en negativo 10. Entonces ahí tienes. De acuerdo, ahora podemos ver de nuevo el as de picas. Y si cambiamos esta amina, sólo podemos cambiar esto. Como puedes ver, la pantalla simplemente se pone, quiero decir, Negativo no sería la mejor idea. Por lo que la pantalla, como se puede ver, simplemente se hace más pequeña y en realidad se desplaza. Y luego éste, nosotros, quiero decir, puedes hacerlo más grande pero no funciona. Y entonces también puedes hacerlo más pequeño aquí. Y luego en la dirección y. Y lo mismo sucede también. Como dije, normalmente no utilices realmente el Viewport Rect o tanto. Lo mismo con casi todas las demás cosas. Sobre todo porque por lo general no son realmente necesarios para juegos bidimensionales. Hay algunos, algo dicho sobre la profundidad puede ser. No obstante, en general, diría que este es un buen panorama corto, ¿no? Entonces esto es sólo una mirada rápida a esto. Conmigo. Básicamente las principales cosas que necesitamos para el desarrollo del juego bidimensional en este caso, ¿verdad? Pero también la mayoría de las cosas en la cámara realmente no necesitan cambiarse. Lo único que podría querer ser cambia el tamaño de las cámaras. Entonces cuánto muestra en realidad, tal vez también los aviones de recorte, aunque un 0.310104, por lo general es suficiente. Entonces eso fue todo para esta conferencia. Tan solo un breve resumen rápido para la cámara. Si hay preguntas como, siempre, siéntete libre de preguntar y me aseguraré de responder. Y sí. 57. (Fundamentos de la unidad. GetComponent en la unidad: Muy bien, sigamos con la introducción básica de la unidad aquí para el curso de la unidad. Y en esta conferencia vamos a echar un vistazo al método de componente Get, que es un método central utilizado básicamente para obtener los componentes de GameObjects. Entonces el único ejemplo de esto que hemos visto más o menos fue la transformación. Pero tenemos acceso a este componente de transformación simplemente usando la transformación de puntos y accediendo a ella a través de un propietario particular, el objeto del juego. No obstante, aquí hay otros componentes. Por ejemplo, el renderizador sprite, como veremos aquí, que fue capaz básicamente de mostrar una imagen. Teníamos guiones particulares. Esos también se contarían como componentes, o por ejemplo, que también hemos visto el componente de la cámara. Y podemos acceder a los de otros GameObjects dentro de nuestros guiones. En el ínterin, he puesto todo dentro de pequeñas carpetas aseadas aquí. Entonces vamos a crear una nueva carpeta. Esto va a ser L 14 get componente. Ahora falta l 13 porque en la última conferencia por supuesto, simplemente miramos a la cámara principal. No hubo guiones asociados a ella. Y también queremos una nueva escena. Entonces, solo hagamos un nuevo senior también. L 14 obtiene componente. Y dentro de los guiones, primero que nada abramos la escena. Y luego en lugar de los guiones, esta vez vamos a crear dos guiones. Uno va a ser el script de ejemplo al que vas y ya puedes abrir eso. Y luego vamos a crear también otro guión. Y este es el script de los componentes consiguiendo donde más bien esto es como lo estamos llamando. Muy bien, así que dentro de nuestro script de ejemplo, vamos a primero, eliminar el método de actualización. No necesitamos eso. Y luego sólo vamos a declarar algunas buenas variables. Entonces, ¿qué tal un, un valor de prueba entero de un 100? Y luego un flotador público, que es otro valor. Que es algo como alguien, no lo sé, como 42.1337 camisas, f por supuesto. Y luego hagamos también una cámara pública. El camara como variable, que en este caso no se inicializa y lo inicializaremos dentro del método de inicio haciendo Camera Main. Por lo que esto simplemente guardará aquí la cámara principal. Y como es muy claro, todo aquí es público. De lo contrario, no es accesible a través de otro guión. Porque en este caso, o mejor dicho, sí, no es accesible desde otro guión porque esto simplemente. Recuperaremos la clase, pero veremos esto en breve. Pensemos también en el interior de nuestros componentes de conseguir. Hagamos realmente un objeto de juego privado aquí. Entonces esta va a ser la tarjeta. Vamos a añadir una tarjeta en breve. Y sí, vamos a añadir la carta en primer lugar, y vamos a añadir algunas cosas a eso. Entonces una vez más, podemos simplemente tomar el as de corazones aquí, ponerlo, Vamos a posicionarlo aquí, hacerlo un poco más grande para que realmente podamos verlo. Y luego aquí vamos a tomar el guión de ejemplo y ponerlo en el Onto the as de corazones mismo. Por lo que en la tarjeta. También va a renombrar esto a corte porque eso es más fácil. Y también estamos así lo que podríamos hacer, por supuesto, podríamos tomar la cámara principal y ponerla en Europa o ya mostrada esto que básicamente puedes ponerlo en el, en el propio inspector y ponerlo así. No obstante, en el guión por supuesto hemos configurado la cámara de una manera que utilice el método de inicio. Entonces eso también está bien. Y entonces hagamos un, un GameObject vacío aquí. Este es el objeto de juego de componentes obteniendo. Por supuesto, una vez más centrándolo sólo para que todos sean felices aquí. Y luego conseguir los componentes es guión que queremos en este. Y ahora lo que queremos es que de alguna manera queremos acceder a estos valores de prueba aquí desde este guión. Entonces esto podría ser, se podría pensar en ello así. A lo mejor hay un guión de salud que queremos cambiar o hay un manuscrito que queremos trazar, ya sabes, o algo así. Simplemente queremos esto, estos valores. Nosotros queremos cambiarlos. Y también queremos quizá incluso cambiar la posición de la tarjeta o algo parecido así. Ahora bien, ¿cómo hacemos esto? Bueno, antes que nada, tenemos aquí el cable GameObject. Y solo hagamos esto como un campo serializado, solo para que podamos ver qué está pasando aquí. En lugar del método de inicio, vamos a utilizar el método de punto objetivo del juego Find, que nos permite, que ya hemos visto, que nos permite simplemente encontrar a un hombre que es un objeto particular dentro de la escena con el nombre, en este caso tarjeta. Ah, una vez más, es importante que el nombre esté escrito correctamente. Y ahora lo que podemos hacer, hemos encontrado este curso porque esto es por supuesto, sólo por aclaración, este objeto de juego que vamos a encontrar, esto tiene un script de ejemplo adscrito a él como un, como componente. Entonces podemos hacer ahora es que básicamente podemos, y no necesariamente necesitamos esto, pero se puede decir ejemplo ejemplo ejemplo de script. Entonces esto es simplemente una nueva instancia del script de ejemplo. Entonces eso funciona totalmente bien porque esta es una clase normal que podemos tener una variable normal apagado. Y básicamente podemos inicializarlo y configurarlo. Por lo que podemos asignar esto a autos dot get componente. Como se puede ver, esto ya está resaltado aquí. Entonces podemos decir conseguir componente y luego es aquí donde algunas personas están un poco confundidas. Tenemos este componente Get con los brackets básicamente angulosos. Y aquellos por supuesto, significan un genérico A. Y la gente es como, no sé muy bien lo que pongo aquí. Bueno, pones aquí exactamente lo que quieres. Entonces desde los componentes, así que si quiero el componente de script de ejemplo, pongo en ejemplo script y luego por supuesto necesito cambiar, termina esto con los paréntesis aquí para significar que esta es una llamada de método. Y esto luego regresará. Si el, este objeto de juego realmente tiene el componente que hemos especificado aquí, entonces devolverá esto y simplemente lo guardará dentro de nuestra variable. Ahora si lo miro hacia atrás, de nuevo, podemos ver que por supuesto, el script de ejemplo es definitivamente un componente de esta tarjeta. No obstante, también está el renderizador sprite y ese también es, por ejemplo, el transporte. Pero hay muchas otras cosas que no son componentes de esto. Que por ejemplo, podríamos decir, bueno, quiero decir, quiero salud ahora mismo. El único motivo por el que esto no funciona es por esto. Entonces si tenía aquí una variable de salud y dije: Bueno, dame el componente de salud. Podríamos hacer esto. No obstante, por supuesto esto no va a funcionar porque no hay salud de componentes in situ en esto, en este objeto de juego en particular. Entonces así es como básicamente podemos decir, vale, dame este componente, me da este componente, dame este componente, dame este componente. Y esa es una herramienta realmente útil. Y una de las cosas más grandes que comemos básicamente tienen que hacer para conseguir componentes específicos de objetos de juego. Y una cosa que es muy importante mencionar es que el, este Get Component carbón es muy, puede ser muy, muy intensivo en cuanto a uso de como CPU y tiempo. Entonces esto es un, esto es un carbón costoso. Es por ello que siempre, siempre, siempre, siempre usar este en el método de la tienda y almacenar en caché esto. Básicamente así, y no seguir llamando a get component, ese componente, cono get componente en el mismo componente. Pero siempre debes guardar esto en caché así. Y digamos que debug dot log example.bam valor de prueba. Como puedes ver ahora puedo acceder a esos porque este ejemplo es simplemente una variable conocida de tipo script de ejemplo. Y esta es una clase normal. Podemos pensar en esto como una clase completamente normal. Y entonces podemos simplemente copiar esto. También puedo decir otro valor. Y luego por ejemplo, la cámara. La cámara, cuando la cámara, sí, ahí tienes. Por lo que esto funciona totalmente bien. Y si empezamos esto, el que vamos a ver es un 142 y nulo. Y ahora viene la pregunta, Espera, ¿por qué esto es nulo? ¿ Porque la cámara está puesta aquí? Bueno, la razón por la que esto es no, es por la orden de ejecución del script. Y eso es algo que vamos a echar un vistazo cuando veamos algunos de los ajustes. Pero en general, la orden de ejecución del script es que por supuesto, porque tenemos dos guiones en el año 1, uno de esos guiones tiene que correr antes que el otro, ¿verdad? Entonces porque realmente no podemos ejecutarlos en paralelo, sobre todo piénsalo así. Tenemos un 120 guiones. Es decir, no podemos ejecutarlos en paralelo a los guiones sería posible en teoría, pero Eso no está sucediendo todavía. Entonces hay algunas cosas que podemos hacer para básicamente asegurar que se hayan establecido las variables. Podemos, en lugar de usar el método str, podemos usar el método wait, porque el método wait siempre se llama antes del método start. Y esto simplemente asegura entonces que se ha establecido la variable de cámara. Entonces probemos esto y veamos si esto sigue siendo nulo o si realmente tenemos nodo maestro. Ahora la cámara principal está puesta y todos están contentos. Entonces eso es bastante guay. Y en adelante, en lo que también se puede pensar es, bueno, en realidad, lo que quiero es que yo quiero, quiero cambiar la posición de este carrito. Bueno, podemos hacer esto. Podemos decir transporte. Entonces estamos guardando la transformación y digamos tarjeta Transformar, Transformar. Y entonces en lugar de simplemente así podríamos hacer esto de dos maneras. Podríamos decir tarjeta dot transform. Entonces podemos hacerlo así. En el fondo. Esta transformación no hace nada más. Después llame al método de componente get con transform. Entonces esto es básicamente intercambiable. Cuando hagamos esto. Ahí vas. Entonces esto es intercambiable, exactamente lo mismo. Y hace exactamente lo mismo. Sí, tiene exactamente el mismo resultado básicamente. Entonces lo que podemos hacer entonces es, por ejemplo decir acordes transforman la posición de punto, solo salida de la posición. Y luego en medio aquí, Cambiemos la posición a, digamos un nuevo vector 3, que es algo así como, no sé, como uno, F a F y F. Sí. Correcto. Por lo que sólo vamos a cambiar la posición de esta transformación de núcleo que hemos conseguido con el componente Get también. Entonces hagámoslo realmente así. Por lo que también es posible, igual que obtener componente. Componente es y vamos a ver si eso funciona. Si el tribunal cambia realmente su posición. Y como puedes ver, la tarjeta ha cambiado su posición, 2, 1, 2. Y si miramos la salida, también se puede ver que primero la posición era 03 y luego la posición era 12. Por lo que el método de componentes es una parte central de este diseño basado en componentes que Unity tiene inherente en sí mismo. Y es simplemente posible, con este método, obtiene básicamente todos los componentes de un objeto de juego en particular, acceder a sus variables, y también, bueno cambiarlas si es necesario. Sí, esta es en realidad una forma bastante fácil de acceder a diferentes componentes desde diferentes scripts. En general. Como dije, este es definitivamente un componente central y todos los demás componentes sobre los que estamos aprendiendo se pueden acceder básicamente así. Y lo grandioso es, porque eso es lo que ya hemos visto con la cámara, por ejemplo. Todas las cosas que vemos. Entonces todas las cosas particulares que podríamos ser capaces de cambiar aquí, el tamaño o para la tarjeta, el script de ejemplo, el valor de prueba a otro valor que cámara. Esos también se pueden modificar todos por exactamente otro script después de que hayamos obtenido el componente a partir de ahí. Entonces consigue componente, increíblemente útil, herramienta increíblemente importante para nosotros en nuestra caja de herramientas para trabajar básicamente con Unity, ¿verdad? Pero eso fue todo para esta conferencia. Como siempre, espero que te resulte útil. Ese fue en realidad un tema bastante grande en este punto una vez más. Pero en general, creo que salió muy bien. Y sin embargo, como siempre, si hay alguna pregunta, siéntete libre de preguntar y me aseguraré de responder. Y sí. 58. (Fundamentos de la unidad) Prefabs y objetos nuevos: Muy bien, sigamos con la introducción básica de la unidad aquí para el curso de la unidad. Y en esta conferencia vamos a echar un vistazo a las prefabs y cómo instanciarlas. Entonces, en primer lugar, ¿qué son los prefabs? Vamos a prefabs son básicamente GameObjects que por lo tanto son un para la replicación, por así decirlo. Entonces hay una especie de plantilla, por así decirlo, a partir de la cual podemos crear nuevos objetos que se parecen mucho a esos. Y vamos a crear una nueva escena. En primer lugar, una vez más, así visto 15 llamados prefabs. Y entonces también empecemos esto de inmediato. Una nueva carpeta aquí, L 15 prefabs. Y sólo necesitamos un guión. Y lo llamaremos el spawner de clics. Porque lo que vamos a hacer es con esto. Una vez que hacemos clic en el botón del ratón, vamos a cisne en una nueva tarjeta. Entonces eso va a ser muy interesante. Entonces digamos que aquí tenemos los clics Warner. Haga clic en spawner. Una vez más en la posición 0, 0, 0. Por supuesto. También asegurándose de que los componentes estén ahí encendidos. Y luego vamos a crear aquí una nueva tarjeta. Y pondremos esto en 000, 000 también. Y en realidad vamos a hacer esto sólo alrededor del doble del tamaño. En realidad, vamos a mantenerlo a las 11, una con el tamaño. Y entonces podemos pensar en hacer algo con esto más adelante por la línea. Y lo que podemos hacer ahora es básicamente que podemos decir, bueno carta, así que este ahora es un objeto de tarjeta. ¿ Y cómo hacemos un prefabricado con esto? Bueno, la forma más fácil es simplemente tomar este objeto ¿verdad? Una vez que básicamente hemos establecido todo, cómo debería ser. Por lo que este es el posicionamiento por defecto de una tarjeta. Entonces decimos, vale, sólo arrastrémoslo aquí a prefabs. Y ahora, como se puede ver, esto se vuelve azul. Y ahora aquí abajo tenemos un activo prefabricado. Entonces la idea es que ahora tenemos este tipo de plantilla y todos los diferentes valores que hemos establecido aquí o dentro de este prefab. Ahora también podemos abrir este prefab y verlo en lugar de este tipo de plantilla proyectada, especie de la pantalla prefab y puede cambiarlo aquí. Para que podamos cambiar algunas cosas como voltear el, dar la vuelta a la imagen o podemos moverla. O también podríamos agregar componentes. Por ejemplo, ahora no vamos a hacer esto. Para volver atrás, simplemente podemos presionar la flecha Atrás allí. Y en esta instancia particular de este prefabricado, están conectados. Y se puede ver esto básicamente por el azul. Subraya aquí y hay algunas cosas que están marcadas como si fueran audaces. Y la idea es que una vez que cambiemos algo, podemos, por ejemplo, decir en esto, como puedes ver sobrescribe a tarjeta en escena, lo que esto significa es que básicamente cambias, puedes cambiar algo aquí dentro. Por lo que no conozco la rotación. Me refiero a que esta rotación no tiene sentido. Entonces esta rotación, por ejemplo. Y con una tecla selecta, podemos seleccionar de inmediato el prefabricado dentro de nuestros proyectos. También podemos abrirlo de inmediato. Y ahora mismo, lo que hace esto es que anula la tarjeta. ¿ Qué significa eso? Bueno, si miramos a éste, nada cambió. Esto básicamente sobrescribe. Dice: Vale, estamos tomando estos valores en lugar de estos valores aquí. Hay algunas cosas que podemos hacer. Entonces con un prefabricado, como puedes ver, podemos desempaquetarlo y empaquetarlo, simplemente lo despega del prefabricado. Podemos seleccionar el ácido. Hay algunas cosas que podemos hacer con los prefabs. Y lo que más importante es básicamente que podamos, ahora aquí podemos entrar en él, volver a entrar en él, como se puede ver. Pero lo más importante para el prefabricado que podemos hacer es que podemos crear nuevos objetos, todos esos. Entonces, solo eliminemos esto dentro de nuestra escena real. Y el prefabricado aquí, el que vamos a crear nuevas cartas. Y lo haremos cambiando aquí el script de spawner clicker. Y dentro de ella, tendremos un GameObject privado porque siempre creamos nuevos objetos de juego llamados prefab de la cancha. Este va a ser un campo serializado, muy importante para que realmente podamos acceder a esto porque no hay otra forma de que podamos acceder. No podemos usar el punto hallazgo de GameObject en este caso porque, bueno, no hay carta en lugar de R. Y especie de ver aquí. Entonces tenemos que hacerlo de otra manera. Y la forma en que vamos a hacer esto es que vamos a establecer esto manualmente. Entonces vamos a decir que la mayoría de botones abajo 0. Ojalá recuerden que este fue el botón izquierdo del ratón. Y lo que vamos a hacer es que vamos a crear un nuevo objeto de juego aquí. Por lo que nueva tarjeta es igual a instanciar. Y voy a decir tarjeta prefab con esta transformación punto-punto. Y lo que esto hace es que si pasamos sobre esto, en realidad deberíamos poder ver, como puedes ver, esto toma una transformación como padre. Por lo que a este nuevo objeto de juego que vamos a crear con la llamada de método Instantiate se le va a asignar de inmediato el padre de clics Bonner. Y luego nosotros también, porque tenemos la nueva variable de tarjeta aquí, podemos cambiar algunas cosas ahí de inmediato. En breve, nueva tarjeta dot transform.py misión. Y lo que vamos a hacer es que realmente vamos a hacer de esta una posición aleatoria. Entonces vamos a decir rango de puntos aleatorios entre algún lugar entre negativo 10, Digamos que e1 más 10. Y la y también va a estar en algún lugar entre un 10 negativo y 10. En realidad, vamos, vamos a bajar esto a siete porque no lo hago yo no estoy 100 por ciento seguro de dónde están las fronteras. Pero lo veremos en breve también. Y sí, por supuesto también podemos cambiar todo tipo de otras cosas. Si la tarjeta, ahora, pensando de nuevo en la última conferencia con el componente Get, por supuesto, también podemos llamar a get component on aquí. Y si hay algún componente particularmente importante en este acorde, podríamos por supuesto, también ponerlos. Entonces si esto tuviera un guión de salud, por ejemplo, podríamos cambiar las cosas en el guión de salud como puedes ver. Entonces, por ejemplo, podríamos cambiar la salud si eso estuviera en la tarjeta, y así sucesivamente y así sucesivamente. Entonces esta es una especie de forma de inicializar algunos valores de ciertos objetos. ¿ Verdad? Ahora bien, es muy importante es que este prefabricado tribunal, por supuesto, tiene que ser establecido, y por lo tanto tenemos que realmente arrastrar esto aquí. Esta es la única vez que realmente tenemos que arrastrar algo ahí dentro. Si estamos usando prefabs y estamos creando objetos a partir de ellos, entonces esto tiene que ser una especie de cosa más o menos manual. Y veamos si esto funciona. Entonces si hago clic en la pantalla, entonces aparece una nueva tarjeta. Y si nos fijamos en este clon de tarjeta de un año, y podemos ver que en realidad sí aparece como un niño de este spawner de clics. Por lo que algunas cartas, porque siete definitivamente está un poco demasiado lejos fuera. Entonces esto es probablemente más como cinco es probablemente el, por lo que cinco probablemente sería mejor. Entonces volvamos a los clics Boehner y digamos, bien está en cualquier lugar del negativo cinco a cinco. Esto también tiene sentido porque la cámara principal, por supuesto, el tamaño está establecido en cinco. Entonces eso realmente chequea en una gran cantidad de desperdicios. Así que vamos a dar un click unas cuantas veces. Y como puedes ver, ahora estamos consiguiendo un racimo de cartas, simplemente generadas al azar y cada vez hay más y más cartas y simplemente las estamos desoviendo como locas. Pero funciona, funciona muy bien. Y esta es una forma en la que básicamente podemos crear nuevos objetos, hacerlos engendrar dentro de nuestro juego. Y luego por supuesto, si tienen guiones particulares que se ejecutan, entonces esos pueden correr sin ningún problema, sin que tengamos que hacer algo particularmente loco ahí. Entonces, sí, esa es básicamente la idea de prefabs. Son herramienta increíblemente útil para tener una plantilla a partir de la cual luego podremos crear nuevos objetos de juego. Por lo que algunos ejemplos de esto podrían incluir algo así como un mensaje similar incluso de texto. Podrías tener prefectos así. Podrías tener Prefabs para enemigos. Este es como uno de los ejemplos clásicos, ¿verdad? Tendría un enemigo prefabricado y luego un desovador enemigo, por ejemplo, y luego simplemente echarlos a perder en cuanto avanzas. Ahora una cosa que hay que mencionar es que el método Instantiate es, por supuesto, muy intensivo de CPU o muy costoso de nuevo también. Entonces hay algo llamado mancomunación de objetos que podrías hacer. Entonces el inicio del juego, podrías crear como un 1000 objetos, pegarlos en algún lugar del mundo del juego donde no hagan nada y luego básicamente simplemente establecer su posicionamiento y tal vez habilitar algunas cosas sobre ellos. Pero en general, eso es algo que no lo es, no vamos a preocuparnos ahora mismo. Solo quería mencionar esto, que el método Instantiate, como lo hemos visto la última vez con el método del componente Get, realmente no debería ser como un loco usado. Por lo que no deberías crear como 100 mil nuevos GameObjects como cada fotograma o algo loco así. Así que ten mucho cuidado, sobre todo si intentas usar para bucles dentro del método de actualización. Eso es algo que podría no funcionar como tú querías. Pero sí, eso fue básicamente para crear nuevos objetos de juego con prefabs. Como siempre, espero que te resulte útil. Y si hay alguna pregunta, siéntete libre de preguntar y me aseguraré de responder. Y sí. 59. (fundamentos de la unidad) texturas y sprites: Muy bien, sigamos con la introducción básica de la unidad aquí para el curso de la unidad. Y en esta conferencia, vamos a echar un vistazo a los sprites y sobre todo en los espectros aquí. Por lo que hemos visto, también ya hemos sumado al as de corazones como un sprite. Y he dicho que vamos a mirar esto más adelante por la línea y ahora es el momento. Entonces para esto, en realidad he abierto el L4 para obtener scripts de componentes para que podamos ver el sprite real dentro de la vista de escena aquí visualmente. Y si hacemos cambios a esto, entonces podemos básicamente no. De acuerdo, ¿Qué es lo que está pasando? Por qué está pasando y sí. Entonces, en primer lugar, vamos a pasar de arriba a abajo. El tipo de textura de Sprite es el que básicamente vamos a utilizar exclusivamente dentro de este curso. Y como puede ver, la pregunta aquí es ¿para qué se utilizará esta textura? Exactamente, va a ser un sprite. Entonces esta es la que vamos a estar usando. Los demás realmente no nos interesan en este momento. Al menos no para este curso. Entonces el modo sprite. Por lo que el modo sprite es muy interesante. Tenemos sencillo, múltiple y polígono. Tan sencillos y múltiples otros que nos interesan. Solo significa simplemente que esta es una sola textura. Este es un solo sprite. Esto sólo una cosa y múltiple, que es algo que vamos a ver más adelante abajo la línea es donde tenemos múltiples un fotos en particular en un archivo para que básicamente podamos poner en un archivo. Y entonces podemos separar esto a través del Sprite Editor, que vamos a echar un vistazo en la próxima conferencia manera más detalle, píxeles por unidad. Entonces, ¿qué significa eso? Bueno, como se puede ver, cuántos píxeles en el sprite corresponde a una unidad en el mundo. Esta es la razón por la que más o menos tenemos que escalar este acorde para que realmente encaje. Porque la tarjeta en realidad lo es, creo que la imagen es de 64 por 64 píxeles. Entonces lo que podemos hacer es que podríamos ponerlo en 64. Y si aplico, lo que verán es que ahora la tarjeta se ha vuelto mucho más grande porque ahora son 64 pixeles para una unidad de espacio. Entonces, cuanto menor sea este número, básicamente más grande se pone la imagen real. Pero por lo general, depende de lo grande que sea la imagen. Por lo general creo que esto se debe poner, veamos rápidamente este año para que pueda dar click en todas partes. Por lo general el este número debe estar en algún lugar alrededor de qué tan grandes son las imágenes, sobre todo si se trata de un cuadrado, ese es el mejor el tipo de malla, tipos de sprites genera mucho. Tengo que ser honesto, esto es algo con lo que no estoy 100 por ciento familiarizado. Ahí está en mi mente ahora mismo. En realidad no hay mucha diferencia ahí. Extrude bordes, cuánto espacio vacío nos deja justo a su alrededor, ¿verdad? Entonces esto realmente sólo es importante. Ver, en una malla generada ahora mismo para nosotros, no tan importante. El pivote, el pivote sólo lo cambiará a, por ejemplo, la parte superior derecha y aplicará esto. Y como puedes ver, de repente esto se mueve hacia abajo. Porque a pesar de que la propia tarjeta, si volvemos a desbloquear esto, la corriente misma sigue en la misma posición en este momento. El pivote de esta imagen en particular, el sprite ya no está centrado, puede ser, puede ser realmente útil. Normalmente lo dejo en el centro y cambio el objeto del juego en sí. Eso es mejor. Vamos a generar física, como puedes ver, es simplemente genera una forma física predeterminada para que podamos tener, esto puede estar encendido o apagado. O sea, depende de si necesitas o no física o no. Esos son algunos ajustes avanzados aquí. Y alfa, por supuesto, se asegura de que si tienes un PNG, que el Alfa sea entonces básicamente tomado en cuenta. También podemos mirar, vamos a cerrar esto otra vez. Ahí vamos. Y también podemos ignorar las, algunas de las cosas. Por lo que el alfa puede ser no transparente, por ejemplo. Y, y ahora no es transparente y sólo podemos decir, bueno, lo que sea. Entonces el Alfa en este caso no es transparente. Pero donde quieras que esto sea transparente. Y hay algunas otras cosas que podemos hacer. Ignora el archivo PNG Gamma, podemos habilitar leer y escribir datos de píxel para que realmente podamos cambiar con esta imagen en particular. Y sprite podría ser útil. A pesar de que esto es algo que donde hay que tener cuidado porque entonces básicamente puedes también tus sprites para siempre. Y también puedes en teoría, generar aquí un mapa mental, que podría ser algo que quieras. Sí, modo rap y modo filtro. Entonces el modo es básicamente cuando tienes un, vamos a hacer esto. Si tenemos un, agrega esto como textura, entonces el modo de repetición roja simplemente repite esta imagen si la ponemos en alguna parte. Entonces si lo pusiéramos en una superficie y no es lo suficientemente grande, entonces simplemente repetiría. Plan haría que sean unos no sé por qué siempre extiende los avanzados que aplico. Entonces eso es una especie de cosa interesante. Espejo por eje generalmente lo dejan en pinza esa suma suficiente, eso es lo suficientemente bueno. Y luego el punto que son las cosas interesantes para el modo de filtro, porque hemos visto que el bi-lineal es el que empezamos. A, si aplico, lo que vamos a ver es que de repente esto se pone muy, muy borroso. Y la razón es porque se trata de pixel art. Y bi-lineal es básicamente más o menos, es suaviza los bordes. Y nosotros, en este caso, no queremos que se alisen los bordes. Trilineal debería hacerlo no necesariamente peor, pero básicamente el mismo endpoint simplemente significa que no hay filtro en el hashtag, no hay filtro. Y esto hará que tu pixel art. Eres guapa. Aquí abajo hay algunos ajustes interesantes, básicamente que puedes usar para triunfos una vez que esto se publique. Por lo que el tamaño máximo simplemente se refiere al tamaño máximo. Entonces si hago 32, por ejemplo, como pueden ver, de repente, oh mi lambda eso no es, ni siquiera puedo ver qué está pasando. Si lo pongo en 16 mil, es afilado como un crujiente. Pero creo que incluso 1022 o 128, incluso eso es más que suficiente. 64 sigue siendo suficiente porque eso todavía es suficiente para tener todo ahí dentro por algo como sí, así que entonces en el medio probablemente va a ser suficiente. También tenemos un algoritmo de redimensionamiento. Se puede cambiar el formato de eso. Esto se cambia y también se puede cambiar la compresión. Esto básicamente es estos ajustes aquí se pueden cambiar. Por ejemplo, tal vez si tienes un juego móvil, lo que querrías es, bueno, en realidad hagamos un poco de baja calidad y hagamos unos bits menos, por ejemplo. Entonces puedes cambiar, oh, hagamos éste de 32 bits. O podemos decir, bueno, alfa ocho, así que eso es, y ahora todo se ha ido. O simplemente mantenerlo en automático. Eso también funciona. Hay algunas cosas que podemos cambiar tu, porque tal vez en ciertos lugares donde queremos publicar este juego, realidad queremos que el tamaño sea menor. Por lo que en una PC, hay razón para no tener el mayor tamaño para los archivos, porque si un juego es o no de tres gigabytes u ocho gigabytes. No importa para en la PC, generalmente en un teléfono. Esa es una enorme diferencia, ¿verdad? Entonces la diferencia entre un juego en un teléfono que tiene nuestro, digamos como 250 megabytes versus como cuatro gigabytes es enorme porque mientras los teléfonos se han hecho en los últimos tiempos más grandes en términos de espacio de memoria, todavía cuatro gigabytes para, digamos que un juego casual es demasiado. Entonces esto es básicamente lo que, esto es cuatro. Por lo que este sería el defecto. Y luego aquí puedes anular algo para particular, para basicamente particular BuildSettings. Pero una vez más, esto es algo que también está un poco más avanzado. No me preocuparía demasiado por esto. Tan solo asegurándote de que si tu imagen es borrosa, si tu sudor es borroso que podría ser el tamaño máximo que has puesto. La compresión también podría tener que ver con ello. Y también el modo de filtro podría ser la causa del problema, ¿no? Pero eso fue todo por la rápida mirada a la textura aquí en este modo. A lo siguiente que vamos a echar un vistazo es al Sprite Editor de esto como básicamente una nueva ventana. Y con eso, también veremos el modo sprite de múltiplo. Espero que te haya parecido útil esta conferencia como siempre. Si hay alguna pregunta, siéntete libre de preguntar y me aseguraré de responder. Y sí. 60. (Fundamentos de la unidad. editor: Muy bien, sigamos con la introducción básica de la unidad aquí para el curso de la unidad. Y en esta conferencia vamos a echar un vistazo al Sprite Editor. Y con eso, también vamos a importar las múltiples tarjetas básicamente. Por lo que múltiples sprites al mismo tiempo. Teníamos aquí el as de corazones como una textura singular o sprite desde hace mucho tiempo. Y ahora vamos a echarle un vistazo, el propio mapa de teselas. Así que vamos a, sólo voy a copiar esto por aquí. Entonces solo lo arrastraremos ahí dentro. Y como puedes ver, este es Cards mapa de azulejo grande. Actualmente, si me limitara a colocarlo aquí, es un archivo con múltiples tarjetas, como se puede ver. Y obviamente esto no es lo que queremos si fuéramos a importar algo, queremos más de una tarjeta porque esto ahora es un solo modo. Entonces pongamos esto en múltiples modos, cambie los píxeles por unidad a 64. Y esperemos que antes que nada aplique esto, también que este punto sea muy importante, el modo de filtro para que se vea bien. Y luego entrémonos en el Sprite Editor. Entonces si abrimos esto por editor, podemos ver si solo lo consigo de la otra pantalla aquí, que básicamente podemos hacer algunas cosas aquí dentro. Podemos acercar y alejar con el botón del ratón. Haga clic derecho, mantenga presionado el botón Nos hace mover esto. Y si presionamos el click izquierdo, entonces tenemos el tipo de selección. No obstante, si paramos la selección, por lo que dejamos de presionar el botón izquierdo del ratón. Y como puedes ver, aquí crea una especie de sprite. Y también podemos cambiar esto alrededor. Podemos hacerlo más grande o más pequeño. Y esto básicamente representa un sprite sobre esta imagen en particular. Ahora, hay algunas cosas que son realmente bonitas. Por lo que aquí arriba, podemos mirar pocas cosas. Al cliente le gusta, no vamos a mirar realmente esto. Por lo que se trata de un tener un contorno personalizado. Queremos al Editor Sprite en este caso. Y el Sprite Editor puede empalme, lo cual es realmente bonito. Por lo que o bien podemos hacer automático. De qué hace esto. Si digo rebanada, como puedes ver, ha creado estos diferenciales aquí automáticamente. Entonces eso es realmente bonito eso, eso funciona. Vamos a revertir. Entonces podemos revertir y ahora ya no hay sprites presentes. También podemos tener diferentes tipos. Por lo que podemos decir por, por tamaño. Y podemos, porque sabemos que estas tarjetas son 64 por 64, diríamos, vale, rebanarlas 64 por 64. Y entonces como pueden ver, si no muevo esto, cada carta ahora también está en un sprite, pero es un poco más grande. Tiene un poco de espacio a los lados para que pudiéramos hacer esto. O si volvemos una vez más, también podemos hacerlo por conteo. Entonces si sabemos que, por ejemplo, esto es, esto sería 10, 11, 12, 13, 14. Entonces sabemos que hay 14 filas y cuatro columnas. Y podemos rebanar, ese es en realidad el camino equivocado, por supuesto, 144. Ahí vas. Ahora, vocal. Ahora funciona. Y esto también funcionaría. Entonces hay algunas maneras en que podemos hacer esto. Por supuesto, también podemos cambiar el pivote. Aquí hay algunas cosas que podemos hacer. Hay algo de relleno, algo de desplazamiento. No obstante, creo que el tamaño en este caso tiene más sentido aquí. Y entonces tenemos básicamente todo, si llego aquí abajo o 56 tarjetas en este caso, porque también tenemos dos formas diferentes de ya sea esto un, un carro vacío o también podemos tener esto como fondo para rondar. Esto es, creo que significaba nosotros el fondo. Entonces sí, eso es bastante guay. Entonces, sólo vamos a aplicar. Una vez más, sólo por mencionar esto, esas son las tarjetas de los activos renales. Y una vez que hemos aplicado esto, podemos ver dentro de nuestro proyecto, bueno, esto sigue siendo sólo un pack de título aquí, pero vemos esta pequeña flecha. Y si ampliamos esto, se puede ver que cada uno de estos individuales es un acorde. Entonces si por ejemplo, también queremos sacar el as de corazones, podríamos hacerlo haciendo esto. Y si tamañamos hasta cuatro veces cuatro, entonces como puedes ver, es literalmente exactamente del mismo tamaño. Porque lo haremos, en lugar de que esto sea una carta singular, ahora es parte de este pack. Y lo grandioso de esto es, y vamos a ver esto en la próxima conferencia con un poco más de detalle, el renderizador sprite. Lo que ahora podemos hacer es básicamente decir que quiero cambiar esto y quiero cambiar el sprite bam, y entonces la tarjeta ha cambiado. Y vamos a, como dije, vamos a ver esto en la próxima conferencia con un poco más de detalle lo que el sprite render tiene para ofrecer. Pero esto fue básicamente por un breve resumen del Sprite Editor. Ahora, hay algunas cosas más por supuesto que esto puede hacer. No obstante, por ahora, esto definitivamente será mucho más que suficiente para nosotros. Y esta herramienta increíblemente útil, porque ahora no tenemos que tener necesariamente cada uno de nuestros sprites de forma independiente o en archivos separados, pero podemos tenerlos todos en un solo archivo y cortarlos ya sea manualmente, por, automáticamente lo podemos hacer por conteo o incluso por especie de cuántas filas y cuántas columnas. ¿ Verdad? Entonces eso fue todo para esta conferencia. Espero que te resulte útil como siempre. Si hay alguna pregunta, siéntete libre de preguntar y me aseguraré de responder. Y sí. 61. (Fundamentos de la unidad. El Render.: Muy bien, sigamos con la introducción básica de la unidad aquí para el curso de la unidad. Y en esta conferencia vamos a echarle un vistazo, el renderizador sprite. Por lo que este es otro componente. Y para eso vamos en primer lugar a crear una nueva escena una vez más. Entonces este es el renderizador 18 sprite. Y luego también crea una nueva carpeta aquí. Deje sprite renderizador. Y el guión que vamos a crear dentro de aquí se va a llamar el look de renderizador sprite. Por supuesto el nombre aquí es más o menos, elige. Si quieres un nombre diferente, puedes, por supuesto. Y vamos a llevarnos una nueva tarjeta aquí. Vamos a tomar una tarjeta de esto, nuestro nuevo mapa de teselas. Básicamente, una vez que puedas hacerlo de cuatro por cuatro, Vamos a colocarlo en el medio de la pantalla en este punto. Y vamos a renombrar esto a tarjeta porque eso es como una manera mejor nombre y le agregó el aspecto de renderizador sprite. Y sí, veamos qué podemos ver en esta cosa en particular. Entonces, en primer lugar, el renderizador sprite es un componente simple. Por lo que básicamente podemos guardar renderizador sprite privado y simplemente llamar a esto el renderizador sprite. Renderizador Sprite. Ahí vas. Y podemos conseguir esto haciendo en el método de inicio spread r1, r2 es igual y luego este punto get componente. Por lo que también podemos obtener componentes del GameObject en el que nos encontramos actualmente. Entonces donde se adjunta este guión. Y luego llegaremos al renderizador sprite. Como ya he dicho, esta es una idea muy inteligente para hacer esto. Y en realidad básicamente deberíamos hacer esto siempre. Ahora pensemos en otra cosa. También vamos a tener un array sprite privado llamado sprites. Y vamos a hacer de este un campo 0 por supuesto, para que podamos acceder a esto a través del inspector. Y si echamos un vistazo a esto ahora mismo, y podemos ver es que tenemos una lista. Ves, esto está vacío. Pero lo que podemos hacer es simplemente tomar el mapa de azulejo sprite y arrastrarlo aquí. Ahora, como puede ver, esto no funcionó porque eliminamos este elemento de matriz. Lo que tenemos que hacer es que en realidad tenemos dos. Por suerte, no tenemos que llevarnos todo uno por uno. Podemos buscar esto aquí arriba. Por lo que en la parte superior derecha del inspector, podemos mirar esto. Entonces básicamente podemos seleccionar todo. Entonces si seleccionamos una de las cosas, entonces sostén, cambiamos y seleccionamos la de arriba y todo lo que está entre medio queda seleccionado. Y si entonces movemos esto aquí, y como pueden ver, ahora se llena de todas nuestras tarjetas. Entonces eso es realmente bonito y realmente útil. Y ahora, bueno ahora de repente lo que tenemos es que tenemos una lista de sprites a los que podemos acceder como array. ¿ Qué podríamos hacer con esto? Bueno, lo que podríamos por ejemplo, hacer es decir, bueno, al principio, quiero este renderizador sprite y el sprite que está dentro de él. Entonces este es el sprite que, que se está mostrando. Entonces el sprite render, quiero que este sea uno de los sprites carrito. Entonces, por ejemplo, podría decir, bueno, quiero que esto sea. Las canchas, pero en el índice 4, o podría decir, bueno, en realidad quiero que esto sea una corrida aleatoria, random.randrange a partir de 0 porque por supuesto, 0 es el primer índice todo el camino hasta la corte se extiende longitud de puntos. Entonces, y luego si miras esto, el máximo es exclusivo. Es por ello que no necesitamos hacer longitud menos 1 porque longitud no se toma pero solo la longitud menos uno es el rango. Entonces el mínimo es inclusivo y el máximo es exclusivo, solo para que, ya sabes, ahora mismo, si empezamos esto, deberíamos ver que esta tarjeta realmente cambia su sprite OnStart. Veamos si eso realmente funciona. Y ahí tienes. Ahora es el seis de clubes, supongo. Y hagámoslo otra vez. Ahora son los cinco de clubes. No estoy seguro, en realidad. Tres de corazones van. Y luego una vez más, sólo por el infierno de la discusión, supongo que ese sería el siete de diamantes, ¿verdad? Y ahora, ahora esto es realmente genial. Podemos hacer dos cosas más. Entonces lo que vamos a hacer es tomar la entrada aquí y conseguir keydown, keycode dot space. Por lo que golpeó la barra espacial. Lo que vamos a hacer es que el sprite renderizador dot sprite es básicamente exactamente esto. Por lo que en realidad podemos copiar esto. Una vez más, esto sería ahora, por ejemplo, algo que pondríamos en un método diferente, bueno, sólo un método diferente aquí. Por lo que esto sería cambio a sprite aleatorio. No necesariamente tenemos que hacer esto, sobre todo porque esto es sólo un pequeño ejemplo. Pero debido a que básicamente tenemos una cita esta dos veces, hay un buen punto de hacer esto. Porque ahora si miras esto ahora vamos a estar como, vale, qué pasa si presiono la barra espaciadora oh, cambiada a sprite aleatorio. De acuerdo, eso tiene sentido. Y esto es mucho más legible que si tengo esto aquí. Porque definitivamente tenemos que dividir esto. Podemos bien, al azar, vale, así que la suma del aleatorio, vale, yo, tomo un sprite aleatorio, pero éste, acabo de leer el nombre del método real y es como, vale, eso es, eso tiene sentido. Entonces consigue keydown, keycode dot return. Por lo que esta sería la clave de retorno. También podemos simplemente cambiar otro y podemos, podemos, no tenemos que necesariamente hacer retorno. Hagámoslo, hagámoslo en realidad. Hagamos la tecla C afilada, C. Porque lo que quiero hacer aquí es que el renderizador sprite, renderizador sprite dot color cambie. Y esto se puede hacer usando el color de punto aleatorio S, H, v Esto simplemente devuelve un color aleatorio al que vas, que es bastante genial. Entonces vemos que en realidad podemos cambiar el color de la misma. Y con espacio, podemos cambiarlo por una tarjeta diferente. Y si vuelvo a mirar a este renderizador sprite, una vez más, todas esas cosas de aquí. Por lo que todos esos campos están básicamente disponibles a través del script. A pesar desde luego, así como el color aquí. Volteando esta x e y, podemos hacer esto también. El modo Dibujar, interacción de máscara, el pivote a pesar de punto de ordenación más bien. Entonces la capa naranja es algo que es muy importante. Entonces si tenemos este cárdigan, así que cópielo presionando Control C, Control V para pegarlo. Por lo que ahora tenemos una nueva tarjeta aquí. Y la capa de ordenación simplemente determina dónde está este acorde en particular. Entonces si sólo cambiamos esto por sólo el bien de la discusión aquí. Entonces cuatro de corazones, ahora, as de corazones es ahora capa es 0. Este es a más tardar 34. Por lo tanto es más alto arriba, por lo que está por encima de él. Y si lo reduzca, entonces como pueden ver, esto también cambia. Entonces eso es algo a considerar y también a tener en cuenta. Muy importante. Pero lo suficiente dicho, ahora mismo, probemos esto aquí afuera y veamos si esto funciona. Por lo que tenemos nuestra tarjeta aquí. Y ahora esto sí escogió una carta al azar y sí creo en, en realidad sí escogió esta. En realidad podemos probar esto presionando la barra espaciadora. Creo que fue un empate muy afortunado. Supongo. Entonces. Sí, podemos elegir, solo podemos poner la barra espaciadora y como puedes ver, elige una carta aleatoria ahí dentro, que es realmente, realmente genial. Y si presiono C, entonces cambia su color al azar también. Ah, eso fue muy negro. Y luego como puedes ver, ahí tienes. Por lo que cambia el color al azar también. Y si los presiono a ambos al mismo tiempo que los dos cambian o solo puedo tener una fiesta rave. Vámonos. A mí me gusta, Eso es bastante guay. Entonces eso es algo muy cool. El renderizador sprite, principalmente, creo que en mi experiencia, el sprite que definitivamente cambia bastante. Entonces eso es algo que es muy importante. La idea de cambiar el sprite y guardar básicamente todos esos sprites dentro de una matriz en lugar de una. Eso también tiene mucho sentido. El motivo por el que he elegido zona aquí es porque por supuesto, una vez que nos pusimos a la vez, realmente no necesitamos cambiarla. Y el número de spreads no cambia. O mejor dicho, aunque cambie, no cambia durante el juego. Entonces mientras el juego se está ejecutando, no necesitamos cambiar esto. No tenemos que tener una lista dinámica aquí. Básicamente. Es por ello que un es una matriz, funciona bien. Por supuesto también puedes hacer una lista. Esto no importa. O bien. Uno de esos estaría bien, ¿verdad? Pero eso sería todo para esta conferencia mirando al renderizador sprite. Por supuesto, hay algunas cosas más en esto, pero como de costumbre, en este momento, este es un muy bueno como punto de partida para el renderizador sprite puede ser realmente útil para cambiar el sprite y también el color. Eso es lindo mirar eso, ¿verdad? De acuerdo, Así que eso fue todo para esta conferencia. Como siempre, espero que te resulte útil. Y si hay preguntas, siéntete siempre libre de preguntar, me aseguraré de responder. Y sí. 62. (Fundamentos de la unidad) COLlider 2D: Muy bien, sigamos con la introducción básica de la unidad aquí para el curso de la unidad. Y en esta conferencia vamos a echar un vistazo a los colisionadores de cajas o colaborativos en general. Y la forma en que vamos a hacer esto es ante todo, por supuesto, crear una nueva escena aquí. L 19 colisionadores llamados litros. Se van, Vamos a abrir esto y también vamos a crear una nueva carpeta aquí, et al. 19 colisionadores. Y entonces en lugar de realmente vamos a hacer crear el guión. Y vamos a llamar a esto el guión de colisiones. En realidad está cerca de éste. Abramos esto. El ego. Antes de hacer algo dentro de aquí, en realidad vamos a crear una especie de escena bonita aquí. Una vez más, por los recursos tengo una particular kenny activos una vez más. Y en realidad vamos a crear un poco de una especie de forma 2D de hacer las cosas. Así que vamos a tirar de esos sprites por aquí. Por lo que este sería el frente verde alienígena, el cajón de caja. Tenemos tierra izquierda, MIT y derecha, y aquí tenemos la lava. Ahora, en teoría, esos deberían estar en algún lugar alrededor probablemente 28. Entonces, primero que todo en realidad solo marquemos todos esos, selecciónelos todos, hagamos que todos apunten. Y luego probemos 128 por los píxeles por unidad por ahora mismo. Y sólo hagamos una pequeña plataforma aquí. Sólo por el bien de la discusión. No vamos a usar esto de inmediato, pero lo usaremos en breve. Tan negativo cuatro y luego el izquierdo negativo cuatro. Y entonces simplemente necesitamos mover esto por probablemente uno que sea exactamente correcto, menos uno. Y entonces éste es más uno y uno negativo cuatro. Y entonces tenemos una pequeña plataforma aquí, lo cual es bastante bonito. Podemos meter aquí al alienígena, que en realidad se encuentra muy alto. Tan negativo 2.5 probablemente, sí. Ahora en realidad se pone en esta plataforma perfectamente. Y entonces también tenemos el año de caja, que sólo va a flotar en el aire a 2.5, sin leptón 25, 2.5 y negativo tres. Y entonces la lava va a estar aquí sólo para que la tengamos. En realidad vamos a hacer esto un poco más grande también. Entonces algo así. Hagámoslo. 2.52.2.5, 725. Oh hombre, eso es demasiado grande. 2.52.5 al negativo dos y negativo tres. Pongámoslo aquí. Sí, eso es bastante bueno. Entonces esa es nuestra escena ahora mismo. ¿ Y qué estamos haciendo? ¿ Qué, qué es, qué está pasando? Bueno, lo que haremos es lo siguiente. En realidad lo haremos. Dale el, este. Entonces primero que nada vamos a renombrar estas cosas jugador. También vamos a hacer uno vacío, que va a ser el suelo en el que sólo seleccionaremos esos y los arrastraremos hasta aquí para que el suelo sea ahora no, no, no, no, no lo centré. Eso no es eso no es posible. Tengo que centrar esto. Ahora. Ahora, ahora todo está bien. Donde el suelo está justo aquí. El lava está bien y esto sólo va a ser una caja. De acuerdo, ahora ¿qué podemos hacer? Bueno, ahora el jugador va a conseguir realmente los guiones de movimiento que hemos hecho hace mucho, mucho tiempo para que realmente podamos moverlo. Y vamos a ver, esto debería funcionar. Entonces si presiono WASD, en realidad puedo mover al jugador. Ahora claro, sólo puedo moverlas a través de estas cosas porque no, no hay nada que me impida hacerlo y tampoco pasa nada. Entonces eso es algo interesante. Pero, ¿qué podemos hacer para básicamente nos va a permitir? Bueno, tenemos algo que en realidad es antes de entrar en el guión, tenemos algo, tenemos otro componente que podemos usar. Y eso está a la vista de la, si Sophie finalmente selecciona al jugador. Y si decimos agregar componentes, entonces lo que tenemos es que tenemos un colisionador. Ahora este colisionador es en lugar de Física 2D, y vamos a usar el colisionador de caja en este caso, también podríamos usar el colisionador de cápsulas. Eso probablemente funcionaría, pero esos son básicamente diferentes. las diferentes formas, el colisionador de cajas va a estar bien. Ahora en nuestro caso, como pueden ver, el colisionador de cajas realmente se pone, como encima de toda la imagen aquí, que es un poco demasiado grande. Por lo que realmente quisiéramos que el tamaño fuera un poco diferente. Entonces si cambio esto, entonces se puede ver que esta caja verde alrededor de ellos cambia. Hagamos algo así como 1.25. Y entonces el desplazamiento básicamente cambia donde se encuentra esto. Y si hacemos algo así como punto negativo para tal vez hagamos uno. Perdón, 35, 37, cinco, algo así. Sólo por el bien de la discusión en este momento. Esa es una caja bien alrededor de este personaje jugador. Y ahora tiene un colisionador de cajas. Entonces eso es bastante guay. Ahora. ¿Eso nos lleva a alguna parte? Quiero decir, ahora mismo, no realmente porque nada más tenga un colisionador. Entonces lo que vamos a hacer es que vamos a seleccionar todos esos caminos de tierra, sus plataformas de pedidos. Y también vamos a añadir un colisionador de cajas a esos. Y si ahora amplío esos, entonces podemos ver que tiene algunos colisionadores aquí. Esto va a estar bien. Porque en este momento sólo queremos ver desde básicamente desde cómo se ve si me mudara a ello. Entonces, en realidad los movamos un poco hacia arriba. Tan negativos dos, para que flote por encima del suelo. Porque en este momento nuestro movimiento en realidad no es realmente un movimiento para 2D. Es más bien un movimiento para como algo de arriba hacia abajo, pero vamos a cambiar eso a tiempo. Vamos también, sólo para que tengamos un añadido el colisionador de caja tanto a la lava como a nuestra caja. Y vamos a retocar los ajustes ahí y un poco. Por lo que ahora puedo moverme. Y ahora qué pasa si tengo un colisionador y el suelo tiene un colisionador, ¿qué pasa si ahora voy abajo? A ver qué pasa. No pasa nada. Y la pregunta es, ¿por qué no pasó nada? Porque esto tiene un colisionador y esto tiene un colisionador y pensé que esto sería una especie de colisión. Sí, pero necesitamos una cosa más porque para que funcione la física. Y lo que necesitamos está bajo Física 2D aquí abajo, y se llama el cuerpo rígido 2D. Ahora esto tiene, como puedes ver, muchas cosas también mucha información. Sólo disminuyamos la información que vemos. Y como puedes ver, aquí hay muchas cosas. Y lo primero que tenemos que hacer, vamos a hablar de este cuerpo rígido 2D en la próxima conferencia de manera más detalle. Ahora mismo, lo único que tenemos que hacer es básicamente poner la escala de gravedad a 0. Eso es todo lo que tenemos que hacer. Y luego básicamente solo pon esto y no lo vuelvas a mirar. No obstante, sí necesitamos esto, lo contrario, ninguna de esas cosas funcionará. Pero ahora si trato de bajar, me quedo atascado. Me quedo atascado en todas esas cosas. Porque ahora esos chocan. Ahora, lo que es realmente gracioso. Lo que puedo hacer es darle la vuelta a mi chico como puedes ver. Y ahora todo es realmente raro. Hagamos algo que ver con el cuerpo rígido también. Básicamente, podemos congelar la rotación. Nos vamos a preocupar por esto, sin embargo, como dije en la próxima conferencia. Entonces el colisionador de cajas, ¿qué podemos hacer ahora? ¿ Por qué es esto interesante? ¿ Qué es así, qué podemos hacer al respecto en guión, verdad? Entonces ahora básicamente podemos chocar con todas estas cosas. Pero, ¿qué nos da eso realmente? ¿ Qué nos trae eso? Bueno, se podría imaginar que si entro a la lava, eso va a doler. Y tal vez si toco la caja, solo quiero dar salida en la consola, Oye, tocaste la caja. Digamos que esas son las dos cosas que quiero. ¿ Cómo puedo hacer esto? Bueno, hay métodos para esto, y esos métodos se verán en este script de colisión. Por lo que el script de colisión, podemos usar un método llamado en colisión enter 2D. Y como se puede ver, hay algunos otros en la salida de colisión en estancia de colisión, esos deberían ser más o menos autoexplicativos sobre colisión enter simplemente significa que esto se llama una vez. Como se puede ver, una vez que un colisionador 2D o un cuerpo rígido 2D comienzan a tocar. Y salir simplemente significa cuando dejan de tocar y quedarse se llama como cada cuadro que están tocando. Esto te da una colisión 2D. Y con esta colisión 2D, en realidad tenemos muchas cosas que podemos llamar aquí. Como puedes ver, podemos llamar colisionador, contacto, conteos de contactos o cuántos contextos hay. Podemos conseguir los puntos de contacto. Podemos conseguir el cuerpo rígido, la transformada. Podemos conseguir un montón de cosas. Ahora mismo lo que queremos es el colisionador. Y queremos el nombre del colisionador. Y vamos a comprobar si se trata o no de una caja. Por lo que queremos saber si esto ha chocado o no con la caja. Y. Es el caso. Entonces simplemente desconectaremos, hey, hue, touch, tocas la caja. Y eso es todo lo que hay a ello. Entonces esta es una forma de hacer la colisión en 2D por supuesto. Entonces veamos si eso realmente ha funcionado justo antes de que podamos ver si esto funciona o no. Por supuesto también tenemos que añadir el guión de colisiones aquí a nuestro, a nuestro jugador. Eso es muy importante. No olvides eso. Y luego veamos qué pasa. Entonces si toco el suelo, no pasa nada. Si toco la lava, no pasa nada. No obstante, si toco la caja, como puedes ver, oye, tocaste una caja. Y cada vez que vuelvo a hacer esto, aumentamos este contador. No obstante, si lo sigo haciendo, no funciona porque hemos llamado bien The, hemos implementado el método on colision enter 2D y no al estambre. Y hay alguna otra cosa. Entonces dentro del colisionador de cajas, si miramos esto. Entonces si solo echamos un vistazo a la larva por ejemplo, hay algunas cosas que podemos usar. Entonces edita colisionador simplemente, básicamente podemos editar el colisionador en un poco más de detalle. No necesitamos hacer esto en este momento. El material de física no nos interesa por el momento. Podemos sin embargo, usar este gatillo y este es gatillo es algo muy, muy interesante porque esto se dispara simplemente elimina físicamente la forma en que podemos tocar esto. Entonces sólo voy a mostrarles esto. Entonces mientras el colisionador normal colisiono con esto, y ahora si esto es un gatillo, entonces en cuanto me meto en él, no choco con él porque básicamente es sólo un pozo, es sólo un gatillo. Es una zona en particular en la que si entro, todavía puedo, algo puede pasar. Pero yo no choco con él. Y esto también sería un, otro método particular aquí. Y esto está en Trigger Stay to D por ejemplo. Entonces hay, una vez más, por supuesto, entrar esto, quedarse en esto, la salida para esto una vez más. También muy importante. Asegúrate de haber utilizado el método 2D si estás trabajando con 2D, lo contrario, tampoco funcionará. Y en este básicamente casi podemos hacer exactamente lo mismo. Ahora como puedes ver, hay un poco de algo raro. Entonces esto todavía se llama colisión o aunque te dan un colisionador, no sé por qué el por qué aún no han arreglado el auto naming de esto, pero van. Y entonces digamos que nombre de punto colisionador es igual a esto sería la lava. Y si ese es el caso, entonces por ejemplo, se puede decir que ahora se está dañando. Dañados, van a la derecha. Y luego dentro de aquí, por supuesto, lo que podrías hacer es si tienes una referencia al guión de salud, por ejemplo, podrías decir, oye, ahora estás perdiendo salud y entonces en algún momento podrías morir si estuvieras en el laboratorio o te mueres inmediatamente cuando estás en la lava o algo así. Pero ahora mismo, lo único que queremos es mientras el jugador se queda dentro de la lava, básicamente queremos que estés recibiendo salidas dañadas. Entonces, veamos si eso funciona. Y por supuesto que sí. Eso es muy bueno. Ahora bien, lo interesante es por eso ¿por qué continúa? Y si me mudo otra vez, continúa. Esto se debe a una de las configuraciones en lugar de un cuerpo rígido, como dije, próxima conferencia, vamos a arreglar este tema y algunas otras cosas. También estoy llegando a echar un vistazo al cuerpo rígido en sí. Pero por ahora. Y esto es en realidad todo lo que quería mostrarles para los propios colisionadores. En general, los colisionadores son una herramienta increíblemente útil y tan fácil de implementar realmente y trabajar con. Lo mismo con básicamente el, los desencadenantes aquí, que son una herramienta increíble para básicamente tener, ya sabes, cosas diferentes suceden en ciertos momentos sin siquiera tener que ser algo para ser visto. Entonces por supuesto, este disparador, también podríamos simplemente no tener un renderizador sprite en esto y entonces esto seguiría funcionando. Entonces hay un montón de cosas que podemos hacer con esto, lo cual es realmente bonito. Y sí, eso sería todo por los colisionadores. Como siempre, espero que esto te resulte útil. Y por supuesto que realmente agradecería una crítica de ustedes. De lo contrario, si hay alguna pregunta como siempre siéntete libre de preguntar y me aseguraré de responder. Y sí. 63. (fundamentos de la unidad) Rigidbody2D: Muy bien, sigamos con la introducción básica de la unidad aquí para el curso de la unidad. Y en esta conferencia vamos a echar un vistazo rápido al cuerpo rígido 2D. Entonces esto es una especie de parte del sistema físico de la unidad. Y ya hemos visto esto antes. Dije que vamos a la última conferencia que básicamente acabamos de ignorar esto y dijimos, bueno, necesitamos esto para que funcione el choque. Pero ahora vamos a echarle un vistazo con un poco más de detalle. Entonces primero cosas. En primer lugar, lo primero que debemos hacer es hablar de las restricciones. Las limitaciones deben ser bastante obvias. Congelar la rotación simplemente significa que este objeto de juego en particular, en nuestro caso, el jugador no puede girar en la dirección z. Ahora todavía podemos rotarlos manualmente, pero el sistema de física no puede girarlo. Y en realidad queremos hacer esto. Porque lo que hemos visto anteriormente es que cuando el jugador, en realidad estoy chocado con la caja, entonces el jugador empieza a girar. Y eso definitivamente no es algo que queremos. Ahora, hay algunas cosas diferentes que podemos usar aquí. Entonces el tipo de cuerpo es lo primero. Y esto es entre no lo hizo, dinámico, cinemático y estático. Y las principales diferencias aquí es básicamente estática simplemente significa que no está cambiando. Kinematic se mueve y luego dinámica se mueve con un poco más de dinam, dinamismo, mira, supongo algunas dinámicas más. Supongo que se utiliza la masa, calcular la fuerza más tarde por la línea porque también podemos aplicar fuerza a un cuerpo rígido. Y la escala de gravedad simplemente significa bien, escala de gravedad, pero lo que esperarías, entonces a, si tienes una escala de gravedad de 1 y masa, entonces te caes cuando comienzas. Entonces, por ejemplo, si fuera a hacer esto y no me muevo, como pueden ver, de repente el jugador se cayó. Entonces si muevo al jugador hacia arriba, como puedes ver, el jugador se cae ahora y puedo intentar subir, pero esto realmente no funciona porque mientras estoy cambiando mi posición, la gravedad realmente me está tirando de nuevo para poder moverme a la izquierda a derecho. Eso funciona bien. Abajo. Bajar no tiene sentido. Y luego subir tampoco realmente no tiene sentido porque mientras estoy entrenando mi posición, el sistema de física es una especie de lucha contra él. Y esto es básicamente también donde la parte donde se podría pensar en un sistema de saltos. Entonces esto es una especie de, por supuesto una plataforma y ahora el movimiento de izquierda y derecha funciona totalmente bien. Y ahora implementar un salto podría ser algo que sería posible porque si tienes una escala de gravedad, entonces quiero decir, esto es casi un salto, pero no es del todo un tambor porque tengo que mantener presionada la tecla W para mantener moviéndose hacia arriba básicamente. Por lo que probablemente haya una forma de hacer esto. Pero de todos modos, el cuerpo rígido, tuvimos un tema donde mientras estábamos dentro de esto y dejamos de movernos, de repente, ahora ya no nos dañábamos. Esto se debe al modo de dormir. Entonces la idea es que empecemos a despertarnos. Pero si dejamos de movernos, entonces el sistema de física para el jugador acaba de empezar a dormir. Básicamente. Si ponemos esto para que nunca duerma, entonces lo que encontraremos es que una vez que entremos de aquí y nos quedemos aquí, entonces seguirá básicamente dañándonos. Por supuesto exactamente lo que queríamos en este caso. No queremos que esto se vaya a dormir en ese momento, ¿verdad? Algunas de esas cosas como la masa, el arrastre lineal, lineal y el arrastre angular, o simplemente exactamente esas cosas en términos de física. Y en cuanto a componentes de física o, o valores de física. Ellos lo son. Por lo que la masa sobre todo se utiliza por supuesto para calcular la fuerza. Entonces si tuviera que poner fuerza a este objeto, dependiendo de la masa, cambiaría. Entonces eso es simplemente algo muy normal de la física misma. Básicamente, tenemos el interpelado es, como puedes ver, es el modo de actualización por fotograma para el cuerpo. Podemos interpolar o extrapolar o no puedes elegir ninguno. Por lo general diría que ninguno es lo que quieres. La interpolación significa simplemente que se calculan los pasos intermedios. En general. Creo que por lo general para la mayoría de las cosas que vamos a hacer dentro de aquí, en realidad no importa tanto. Lo mismo con la detección de colisiones. Tan discreto simplemente significa que está en pasos discretos, para que esté en pasos discretos. Continuo significa que es continuo, ¿verdad? Entonces echemos un vistazo rápido al, básicamente el cuerpo rígido dentro de los guiones. Entonces si vamos a la, a nuestro guión que teníamos aquí, las colisiones que el cuerpo rígido se pueden acceder ya sea haciendo no, en realidad, sólo se puede acceder haciendo un buen componente y luego Rígido, Cuerpo Rígido 2D. Por lo que podemos guardar esto dentro de un Cuerpo Rígido 2D. Esto sería cuerpo rígido 2D igual a list.rev get componente. Y entonces podemos pensar en lo que podemos hacer aquí. Entonces por ejemplo, cuerpo rígido, punto 2D. Y luego como puedes ver, hay un montón de cosas que podemos hacer. Entonces, en primer lugar, por supuesto, podemos y cambiar todos los componentes que hemos visto en el componente dentro del inspector. Podemos por supuesto, también cambiar algunas otras cosas y hacer algunos otros métodos realmente geniales. Llamar a algunos métodos, por ejemplo, a la fuerza. Por lo que podríamos, por ejemplo, agregar fuerza en una dirección particular. Entonces vector dot, por ejemplo, o digamos, Claro, vamos a hacer vector dot up por el momento. Esto añadirá entonces una fuerza en esta dirección. Entonces en y, una dirección. Si tuviéramos que decir, por ejemplo, vuelva a establecer la escala de gravedad en 0. Veamos qué pasaría ahora. Es que se puede ver que se está moviendo hacia arriba muy, muy lentamente. Entonces esta es la fuerza arriba ahora. Ahora todavía puedo moverlo y todavía puedo cambiarlo. Todavía se mantiene la fuerza. Porque si miramos en la info aquí, realidad se puede ver que la velocidad es de 0.02. Y exactamente Así que el, por lo que la velocidad es el punto 0 2. Entonces básicamente punto 0, 2. Creo que un segundo sería la velocidad en ese caso. Entonces si entonces escalo esto para ser algo así como los tiempos 20, para que ahora me muevo 20 veces más rápido. Debería ser 0.4, supongo. Y ahora se están moviendo un poco más rápido. Sí, punto para eso es genial. Y entonces como puedes ver ahora subiendo bastante rápido, nulo por supuesto, como dije, puedo moverme hacia abajo, no hay problema. Pero en este caso, la fuerza que se agregó ahí existe, sí, Se queda básicamente. Y esto es bastante guay. Podemos por supuesto también añadir torque. En teoría, podemos. ¿ Qué más hay? Podemos calcular la distancia entre éste y un colisionador. Como puedes ver, hay bastantes cosas que podemos hacer. Podemos mover posición. Por lo que esto mueve el cuerpo rígido a una posición particular. Podemos ver la superposición. Entonces hay muchas cosas como puedes ver que podemos hacer. También podemos llamar al despertar para que deshabilite el estado de sueño. Pero la fuerza publicitaria realmente es lo muy interesante. También podemos, creo, ajustar inmediatamente su velocidad a algo. Entonces como puedes ver, eso en realidad dice esto. Entonces si digo velocidad igual, supongo que como dije, ese era un vector 2D. Es una declaración secreta. Sí, este es un vector 2D, por lo que este sería un nuevo vector, 2 D, por ejemplo 0 y luego 0.15. Entonces, en lugar de agregar una fuerza, ahora establecemos la velocidad directamente. Hagámoslo. Entonces, vamos a ver. Y ahora como puedes ver, la velocidad ahora es de 0.15. Entonces esas son todas las cosas que están en la info aquí, muy importantes también. Pero la razón por la que no necesariamente quisiéramos establecer la velocidad por sí solos es porque, por supuesto, la masa. Si agregamos una fuerza, la masa determina cuál es la velocidad al final. Entonces a veces se quiere establecer la velocidad, a veces es mejor agregar la fuerza realmente depende de dónde se quiera ir con esto, ¿cuánto de los sistemas de física se quiere usar? Personalmente, diría que probablemente tiene más sentido no tener demasiado del sistema de física, pero realmente depende del tipo de juego que estés tratando de hacer. Y una última cosa que sólo quería mostrar, por ejemplo, es si tenemos, por ejemplo, algún arrastre lineal. Digo 50 es probablemente un poco demasiado. Pongámoslo a uno por ahora. Y le puse una fuerza. Entonces lo que verás es que la velocidad disminuye y de repente en algún momento es 0. Ahora está bien. Ahora es muy lento, muy lento, muy lento. Y entonces en algún momento es tan pequeño que básicamente ya no se están moviendo. Y esto se convierte en 0. Es decir, esto es básicamente 0 ya. Porque el arrastre lineal simplemente significa que lo que somos, tenemos algo de arrastre justo antes de que fuéramos básicamente sólo una cosa flotando en el espacio sin ninguna resistencia. Y ahora le pondríamos resistencia del aire. Entonces esto es, como se puede ver, lo que dice. Y sin amortiguación 0 significa que no hay amortiguación. Entonces esto es algo que puedes controlar con, por ejemplo, el arrastre lineal. Y lo mismo con Angular Drag simplemente para una rotación en ese caso, ¿verdad? Eso sería todo aunque para el cuerpo rígido en general, hay algunas cosas más geniales, por supuesto que puede hacer con él. Pero creo que como una mirada general, es , es bastante guay. Y tal vez The global, en términos de una idea o tal vez ahora tienes una idea de cómo podrías ser capaz básicamente de agregar una especie de mecánico de salto en el juego. Esto sería algo que podrías, por ejemplo, probar. No necesariamente se necesita, pero sería una buena idea. A lo mejor se puede pensar en algo. Pero de todos modos, en general, esto sería todo para el cuerpo rígido 2D, especie de una breve visión general del mismo. Como siempre, espero que te resulte útil. Y si quedan preguntas, entonces siéntete libre de preguntar y me aseguraré de responder. Y sí. 64. (Conceptos básicos de la unidad) texto básico: Muy bien, sigamos con la introducción básica de la unidad para el curso de la unidad. Y en esta conferencia, vamos a echar un vistazo rápido a un texto de UI muy, muy básico. Y la razón por la que quiero mostrarte el texto básico de la interfaz de usuario es que tienes una estimación aproximada de la interfaz de usuario, al menos cómo mostrar ciertos textos. Y luego más tarde bajando la línea en otra sección, vamos a ir a sumergirnos profundamente en la interfaz de usuario. Mira cada componente que hay, cómo usarlos y cosas así. Creo que un texto básico de la interfaz de usuario ya puede hacer maravillas. Y para eso, vamos a crear una nueva escena. Una vez más, l 21. Si no lo hago si no me equivoco y no creo que lo esté. Hagamos texto sencillo de la interfaz de usuario. Textos, el ego. Y vamos a abrir de inmediato esto. Y luego en lugar de la carpeta de scripts, una nueva carpeta, L21, texto de UI, con un script C-sharp muy fácil llamado texto UI. Quién hubiera adivinado, hay inmediatamente empezar esto. Y vamos a crear un nuevo, básicamente texto dentro de nuestro juego. ¿ Cómo podemos hacer esto? Bueno, en especie de jerarquía, haciendo clic derecho. Y luego yendo a UI y luego texto. Vamos a usar los textos normales ahora mismo. Como dije, todas las demás cosas así como lo que significa este texto Mesh pro. Voy a explicar en futuras conferencias ahora mismo. Simplemente vamos a lidiar con el texto normal y cómo podemos realmente conseguir que esto se muestre. Entonces ahora tenemos un nuevo texto y como pueden ver, se han generado algunas cosas más. Uno, el sistema de eventos, vamos a necesitar esto, no elimines esto, lo contrario, algunas cosas podrían no funcionar. Y el lienzo y lienzo es básicamente, podrías imaginar un lienzo básicamente como un, como un lienzo en el que pintarías. Y en nuestro caso, no pintamos en esto, pero nuestra interfaz de usuario básicamente está estampada en este lienzo. Ahora si alejamos un poco, verás que en primer lugar, el texto es gigante y en el lienzo también es muy, muy grande. Y podemos cambiar esto básicamente yendo aquí a Canvas y luego cambiando el modo de render a cámara de espacio de pantalla. Y luego tomando la cámara principal y poniéndola en esta cámara render. Y de repente, el lienzo se pone al tamaño de la cámara. Y nuestro texto está aquí abajo. Y podemos redimensionarlo con la herramienta rect. Esta es la forma más fácil de hacer esto. Básicamente podemos redimensionar esto y algo así como ponerlo como animal aquí arriba, por ejemplo. Y luego hacer más grande el tamaño de la fuente en el texto mismo. Eso se hace aquí. Y entonces de repente, Hagamos algo como esto. Centrilarlo y ellos, vamos, ahora tenemos un nuevo texto. En general. Esto es lo único que tenemos que hacer en el propio Canvas. Como puedes ver, hay bastante más. No nos preocupemos por esto por ahora. En realidad sólo preocuparnos por el texto en sí. Donde podemos por supuesto cambiar el fondo. En teoría, podemos cambiar el tamaño de la fuente, el estilo, la alineación. Entonces todas las cosas que también puedes hacer es por ejemplo, en Word. Y por supuesto, el color también se puede cambiar a, hagamos este tipo de color blanco. Y si voy al juego y se puede ver que el nuevo texto aparece ahí sin emisión. Puedo cambiar el texto aquí en este, en este campo de texto. Entonces por ejemplo a 100. Y lo que voy a hacer ahora es añadir el texto de la interfaz de usuario como un componente a los dos exactamente este objeto de juego de texto. Y dentro de ella, vamos a ver cómo podría cambiar el texto vía guión. Entonces para que yo cambie el script, cambie la interfaz de usuario real vía script, estaré usando Unity engine WI. Entonces este es un espacio de nombres que necesitamos estar usando. Y luego solo, por ejemplo, hagamos una variable de texto privada llamada texto de prueba. Y vamos a hacer de este un campo serio sólo para que podamos ver qué está pasando. Y esta es la UI, como se puede ver, el elemento UI, el motor Unity, el texto wi punto. Y este es exactamente este componente aquí. En teoría, este componente aquí es este texto. Y lo que podemos hacer es decir si queríamos establecer los textos, son test, test.txt. Entonces el texto es la variable de cadena que realmente se muestra. Y podemos establecer esto haciendo, por ejemplo, si queremos que esto se fije en 300, si hacemos esto, entonces se va a decir, eso no funciona porque realmente tenemos que decir a string. O podemos decir por supuesto algo así como este vehículo 300. Es decir, por supuesto aún más fácil. Por lo que podemos establecer esto en cualquier cadena que queríamos. Y por supuesto, también hay algunas otras cosas que podemos hacer para que podamos cambiar el alineado el color. Podemos rastrear la fuente en sí, también podemos cambiar el tamaño de la fuente. Entonces básicamente, todas las cosas que hemos visto dentro del componente real, podemos cambiar si tu script también. Pero ahora mismo lo único que realmente quiero hacer es básicamente cambiar esto. Para cambiar los cien, doscientos, trescientos una vez que empiezo. Y en realidad tenemos que poner esto aquí. Entonces como puedes ver, textos de prueba, ninguno en este momento. Entonces lo que podemos hacer es simplemente poner en sí mismo o dentro del guión. Antes de empezar, podemos decir que tiene textos como iguales a este punto obtener texto componente. Entonces haciendo uso del método del componente de deuda una vez más para básicamente obtener el texto en el principio. Y si iniciamos esto, se puede ver que se vuelve a 300. ¿ No es genial? ¿ Verdad? Y esta es una forma muy, muy básica de implementar un texto y cómo podemos cambiar esto. Una vez más, podemos simplemente utilizar el método del componente Get con el fin de básicamente acceder al texto y luego a todas las variables asociadas con él. No vamos a mirar demasiadas de esas cosas. Como dije, esto es algo que sólo quería mencionar rápidamente. Muéstrate rápidamente para que puedas hacer muy, muy básico solo texto de la interfaz de usuario y nada más realmente. Sólo para que tengamos esto en nuestra caja de herramientas para mirar, bueno, hacer nuestro primer juego básicamente, ¿verdad? Pero eso ya fue todo para esta conferencia. Espero que te haya parecido útil como siempre, si hay alguna pregunta siempre hay que preguntar y me aseguraré de responder. Y sí. 65. (Fundamentos de la unidad. herramientas básicos: O sigamos con la introducción básica de la unidad aquí para el curso de la unidad. Y en esta conferencia vamos a echar un vistazo rápido algunas herramientas de depuración que tienes dentro de Unity. Y vamos a crear una nueva escena, la depuración de L22. Ahora, estas herramientas de depuración serían herramientas que usan básicamente la clase Debug. Por lo que esta es una carpeta más, la depuración L22. Y luego un guión aquí. Enfriarlo, el ejemplo de depuración. Abramos esto y hagamos también un objeto de juego vacío llamado depuración. Centrándolo, por supuesto, van ceros 0000 y le agregan el script de ejemplo de depuración. Y luego veamos qué podemos ver. Entonces sólo vamos a dar salida a algo. Cuando presione aquí, vamos a usar el código de tecla punto d Así que si presiono D, entonces depuraremos algo. Creo que eso tiene sentido. Y lo primero que ya sabemos es por supuesto, el debug dot log. Esto es algo que ya hemos visto. Ya conoces este, ¿verdad? Esto debe ser autoexplicativo, simplemente bloquea un mensaje a la consola. También está la advertencia de depuración. Ahora hemos visto algunas advertencias. Entonces esto podría ser, por ejemplo, una mañana que escribes. Y esto es algo que hemos visto algunas veces antes con, por ejemplo, variables que habían sido asignadas pero que no realmente frías en ningún otro lugar. Pero no creo que hayamos llamado o hecho una advertencia nosotros mismos. Y también hay mirada, era. Esto es lo único que siempre sugiere que a veces se sugiere antes del registro. No estoy seguro de por qué esto ha cambiado en recientes, digamos versiones de unidad, pero sea cual sea el caso, esas tres, Vamos a decir aquí. Esto es una flecha. Por supuesto. Arrow, ahí tienes. Y vamos a ver cómo se ve esto si empezamos esto. Entonces antes que nada, bueno, claro que necesito presionar el botón. Por eso no pasó nada. Eso por supuesto explicaría esto. D. Y entonces como puedes ver, ya conocías a éste. Te lo advierto, y esto es un árabe. También hay, por supuesto, filtrado sobre la consola. Ya he explicado esto. Y esas tres cosas son básicamente algo que podemos hacer y podemos seguir presionando esto. Y como se puede ver, el número sube. Y esto es realmente útil porque por supuesto puedes, más o menos, dependiendo de lo que quieras expresar en tu código, puedes sacar una advertencia o un error. Y esto es realmente agradable para propósitos de depuración. No obstante, lo que sí quiero decir es que todas las herramientas de depuración son muy caras, por lo que todas deben sacarse cuando se lance el juego real o bien comentado o simplemente asegurándose de que ya no estén ahí dentro. No estoy seguro en realidad, si están fríos durante el juego o si la depuración es algo que sólo se hace en lugar del editor, no estoy un 100 por ciento seguro. Pero de todos modos, así. Hay algo más que podemos hacer y eso es una línea de dibujo. ¿ Qué es esto? Bueno, este punto transforman posición de punto. Entonces empezamos en esta posición y decimos, por ejemplo, vamos de aquí de nuestra posición a la derecha. Por lo que vector tres veces cinco. Y entonces también podemos decir, bueno, queremos que esto sea de color rojo. Y diez F significa que se queda diez segundos. Entonces esto es bastante guay porque lo que podemos hacer es simplemente trazar una línea. Y mientras el, se podría decir, bueno, ¿por qué querría trazar una línea? Veamos cómo se ve esto. No parece nada porque los gizmos no están encendidos. Enciendamos los gizmos y de repente vemos esta línea roja. Se queda ahí por 10 segundos y luego se va. Como puedes ver, ahí tienes. ¿ Por qué esto es tan genial? ¿ Por qué podemos usar esto? Bueno, en realidad es realmente útil porque a veces tal vez lo que quieres es saber qué pasa con algo. A lo mejor quieres saber una especie de si algo se está moviendo hacia o algo así. Y luego dibujar una línea con la herramienta de depuración puede ser realmente útil. Ahora puedo dibujar muchas líneas por supuesto, y todas caducarán en algún momento. Pero sí, así que la línea de dibujo, increíblemente útil podría ser. Es decir, yo sí, creo que es realmente útil. Por eso quería demostrarlo. Es realmente genial. También está la excepción de bloqueo. Si puedo conseguirlo, bloqueo de excepción, ahí tienes. Entonces en esto podemos por ejemplo, decir sistema, un nuevo sistema.Out excepción. Y entonces esto diga, sí, es una excepción. Entonces esto es solo registrar una excepción básicamente. Y luego por último pero no menos importante, lo que también quiero mostrarles es el punto de depuración, punto. Y esto simplemente aseveran unas condiciones de bool particulares. Entonces si pongo un verdadero aquí, entonces nada obtiene salida. Y simplemente ignoraremos esto. Si pongo un falso, veremos que se va a fallar aserción y tendremos una referencia con esta línea. Entonces veamos cómo se ve esto. Si guardé esto de nuevo, presione D, Como puede ver. Entonces, antes que nada, ya conoces este. Entonces te advierto que tenemos una flecha, este es nuestro propio error. También podemos buscar una excepción. Excepción. Sí, es una excepción. Y luego la aserción falló, debug dot assertion bool. Entonces básicamente podemos hacer valer ciertas cosas y decir: Oye, si esto es correcto, entonces continúa. Si esto no es así, entonces detener puede ser útil para, Vamos a agregar la depuración. Y sí, eso es una especie de las cosas que quería mostrarte. Por supuesto, dentro del div, hay algunas cosas más que puedes ver, pero en general, esas son una especie de las que quería mostrarte. Si hay otras cosas que necesitas, podrías ir, por supuesto, mirar tú mismo la clase de Depuración y mirar algunas cosas, pero esas son una especie de las que me pareció más útiles. Y sí, eso en realidad ya sería para esta conferencia y esta sección. Y espero que te resulte útil como siempre. Si tiene alguna pregunta, siéntase libre de preguntar y me aseguraré de responder. Y sí. 66. (Clicker de queso) la idea de "Clicker queso": Muy bien, Bienvenidos al clicker de queso aquí para el curso de unidad. Y en esta conferencia, sólo quería mostrarles rápidamente lo que vamos a crear en esta sección del curso. Queremos crear un clicker de queso. Hay una especie de Cookie Clicker, pero con queso. Esa es la idea que se me ocurrió. Y debido a que Cookie Clicker es un concepto muy fácil de entender, pensé que luego convertirlo en queso entonces también tendría sentido. Y esperemos que sea más fácil de seguir porque el concepto es tan fácil. No obstante, aún podemos crear unos sistemas muy bien interesantes con esto. Y también podemos ir a crear quién lo hará. Entonces en este caso, esto ya está terminado. En este caso de aquí, quería mostrarles esto y vamos a ver cómo juega. Entonces la forma en que juega es que básicamente tenemos la capacidad de crear nuevos edificios para poder construir un edificio clicker y un edificio de la estación de ordeño. También tenemos actualizaciones que se generan que hemos implementado. Y si hacemos clic en el queso, entonces como pueden ver, el número de queso aquí arriba aumenta. Y si tenemos suficiente queso para construir algo, entonces los botones reales aquí también girarán para que podamos hacer clic en él y luego podamos hacer clic, por ejemplo, en el clicker. El número aquí aumentaría y este número también aumentará. Por lo que se incrementará el costo, así como el número de edificios que tenemos de este tipo. El clicker generará para nosotros un queso por segundo. Podemos entonces, por ejemplo, por una actualización aquí abajo, y luego el clicker de repente nos llevará a queso por segundo. Y cuando tengamos, por ejemplo, una estación de ordeño aquí abajo, esto nos generará cinco quesos cada dos segundos. ¿ Verdad? Entonces así es como se ve el juego. También tenemos algunos tramposos integrados. Entonces si presiono plus, entonces vamos a aumentar el queso. Si un más menos, entonces vamos a disminuir el queso. Entonces eso es bastante guay. Y todo esto se construirá en las próximas conferencias. En primer lugar, el queso para hacer clic en ellos va a mirar a los edificios. Vamos a añadirle una interfaz de usuario sencilla que básicamente podemos usar. Y luego por último, vamos a añadir el sistema de actualización. Todo básicamente aquí. Al igual que de costumbre. El, tanto esto como un paquete está disponible para que descargues, así como cada uno de los sprites aquí están disponibles como recurso. Y yum, como quieras usar esto. Básicamente, básicamente puedes obtener el tu, todo el proyecto aquí, descargarlo, y luego mirar el código mientras lo estoy escribiendo, mientras lo estoy explicando, o básicamente puedes escribirlo en paralelo conmigo. Por supuesto, hay algo para que decidas cómo puedes entender mejor esto y cómo puedes ver mejor cómo funciona esto. Pero en general, eso será todo para esta conferencia. Ahora, espero que se diviertan para las próximas conferencias donde realmente creamos nuestro propio primer juego, el clicker de queso. Y sí, eso sería todo. Y espero que se diviertan en las próximas conferencias. Y yo diría, si hay alguna pregunta, por supuesto, durante la realización de este juego, entonces siéntete libre de preguntar y me aseguraré de responder. Y sí. 67. (Clicker de queso) crear un queso para hacer hacer clic: Muy bien, bienvenidos a crear aquí el clicker de queso para el curso de unidad. Y en esta conferencia, vamos a hacer un queso al que podamos dar click. Y también un objeto de juego donde podemos almacenar nuestro queso en. Por lo que básicamente un almacenamiento de queso, por así decirlo. Y para eso, lo primero que ya he preparado, la carpeta de scripts y la carpeta sprites aquí. Esto no debería ser nada loco o completamente nuevo para ti. Y en realidad tomemos el queso. Entonces este es el sprite de recursos que tengo. Básicamente tan disponible como recurso. Y vamos a cambiar si ustedes números aquí. Por lo que en primer lugar, los píxeles por unidad van a ser un 150. Vamos a hacer que este modo de filtro apunte para que tengamos una especie de imagen nítida y la compresión se ajustará a ninguna por esto, algunos básicos, no es una flecha como advertencia aquí. Entonces la compresión ninguna y luego la advertencia desaparecerá. ¿ Verdad? Entonces ahora que tenemos nuestro queso, realidad podemos simplemente arrastrarlo a nuestra escena y ahora tenemos un queso aquí. Localicemos esto en algún lugar como 00, negativo 0.5. Diga que esa es una buena ubicación para ello. Y vamos a renombrar el queso el clicker de queso porque básicamente son los árboles a los que vamos a hacer clic. Y también vamos a crear dos guiones. Pero antes de hacer esto, vamos a ir a nuestro editor de configuraciones del proyecto y luego a nuestro espacio de nombres raíz y el espacio de nombres raíz. En este caso va a ser clicker de queso, ¿verdad? Por lo que teniendo esto como espacio raíz, nombres generará entonces el espacio de nombres como probablemente hayas visto dentro de. Dentro de la conferencia del espacio de nombres dentro de la introducción C aguda, ¿verdad? Entonces vamos a crear nuestros guiones C, C. El primer guión que vamos a crear es el queso Flickr. Entonces este es el click real del queso. Y entonces crearemos de inmediato otro guión. Y este sería el, podemos llamar a esto Ella es almacenamiento. Creo que esa es una buena idea. Y sabemos que bien, en especie de almacenamiento de queso ahí, almacenamos nuestro queso por así decirlo. Y abramos esto. Y una vez abierta, podemos cambiar de inmediato aquí al clicker de queso. Y ahora tenemos nuestros dos archivos abiertos. Entonces pensemos en lo que necesitamos para el propio clicker de queso. Entonces, antes que nada seamos capaces de hacer clic básicamente en el queso. Bueno, en realidad hay algo muy bonito que podemos hacer. Y eso va a ser, estamos ante todo, realidad no necesitamos ni el inicio ni el método de actualización aquí. Y lo que vamos a utilizar son dos métodos que están disponibles porque se trata de un comportamiento mono. Y eso será al ratón hacia abajo, como se puede ver. Entonces al mouse hacia abajo y luego con tab básicamente podemos autocompletar esto y al mouse hacia abajo, lo que esto hace, como puedes ver, se llama cuando el usuario ha presionado el botón del mouse mientras está sobre el elemento GUI o colisionador. Por lo que este es un elemento GUI, este será un colisionador. Entonces, por tanto, lo que sólo vamos a hacer en este momento es simplemente aumentar. Básicamente, sólo para que sepamos que esto funciona. Y una cosa que también vamos a hacer es que vamos a decir, vamos a tener un nuevo método aquí, que va a redimensionar el queso. Porque ahora mismo, en realidad, veamos primero esto y luego vamos a averiguarlo después. Por lo que aumentó el queso. Entonces cuando hacemos clic en este queso Clicker, entonces queremos aumentar el queso. Ahora esto por supuesto no está implementado todavía, pero el, al menos la salida debería funcionar. Entonces este clicker de queso, pongamos el, no el almacenamiento sino el parpadeo de queso ahí y veamos si al hacer clic en él, si obtenemos o no una salida de consola. Entonces yo y no pasa nada. Entonces eso es, eso es un poco raro. ¿ Por qué es ese el caso? Bueno, sí decía que necesita un colisionador. Entonces hay dos formas en que podemos hacer esto. Podemos o agregar un colisionador aquí, ¿verdad? Ir al colisionador de caja 2D de Física por ejemplo, o un colisionador de polígonos. O podemos hacer otra cosa. Por lo que eliminaré el guión por tan solo un segundo aquí. Y lo que puedo hacer es subir aquí, poner entre paréntesis y decir requieren componente. Entonces esto básicamente dice, Hey, esto, esta clase, donde sea que este comportamiento moral esté apegado al objeto del juego, requiere también este componente. Y entonces puedo decir tipo de Collider que más ligero demasiado profundo. Y esto añadirá entonces un colisionador tan pronto como agregué este comportamiento moral a lo real, al objeto de juego real. Entonces lo que vamos a ver es si agrego esto ahora, como pueden ver, agregar un componente falló porque necesitamos ya sea un desorden de caja o algunas de esas cosas, y tenemos que sumar a eso primero. Entonces si ahora entramos aquí y vamos a tomar el colisionador de polígonos y va a hacer básicamente el contorno perfecto aquí para que realmente no podamos hacer click fuera de él. Simplemente lo vamos a mantener como está y estar bien con ello. Y una vez que agregamos el colisionador de polígonos, ahora agregamos el clicker de queso, conocemos Era, y sabemos que todo funciona totalmente bien. Entonces esto es básicamente para asegurar que un determinado script realmente funcione al usar este componente requieren. De acuerdo, probemos esto y veamos si cuando hago clic en él, funciona y lo hace. Entonces si hago clic en él, como pueden ver, se imprime un aumento de queso, lo cual es realmente bueno. Por lo que sabemos que el ratón abajo funciona. Ahora, como ya han visto, no hay realmente una indicación visual ahí. Y lo que vamos a hacer es que en realidad vamos a redimensionar básicamente el queso. Y para eso vamos a hacer un nuevo método privado aquí, vacío privado redimensionar queso. Y esto va a tomar un vector 3, que va a ser el nuevo tamaño. Entonces la idea aquí es que básicamente vamos a poner un vector en este método y luego va a cambiar esta escala local es igual a nuevo tamaño, nuevo tamaño. Y vamos a hacer esto una vez en el principio aquí, cuanto empecé con el ratón hacia abajo. Entonces vamos a redimensionar el queso para básicamente, bueno, tamaño es ahora mismo uno, por lo que este sería su tamaño original. Y luego vamos a decir algo así como 0.9, por ejemplo. Esto sería viable. Y entonces por supuesto necesitamos que esto vuelva a crecer. De lo contrario no funcionará. Por lo que ahora entonces podemos usar el otro método del ratón. Por lo que esto será en el ratón arriba. Y una vez más, este es un método cortesía del comportamiento modelo aquí, vamos a redimensionar el queso con vector tres puntos uno. Por lo que esto básicamente lo restablecerá a su tamaño original 10, 11. Y eso en realidad debería funcionar ya. Entonces veamos si eso funciona y aquí obtenemos un efecto visual genial. Entonces lo que haremos es, claro que ahora cambiará la escala. Entonces, veamos si ese realmente es el caso. Y es el caso. Si lo mantengo aguantado, entonces funciona. Y en cuanto suelte el botón, entonces funciona también. Ahora, ¿qué pasa? Por ejemplo, si fuera a salir de la vista de la pantalla, como se puede ver, todavía funciona bastante bien. Creo que hay formas en las que probablemente puedas engañar al sistema. Creo que si ahora presiono, nope, si presiono la tecla Windows, todavía funciona muy bien. Entonces eso en realidad es realmente agradable. Y entonces ahora obtenemos incluso indicación visual de esto. Por supuesto, siempre se puede cambiar esto vertical. A lo mejor quieres que esto sea un poco más sutil. Entonces tal vez quieras cambiarlo para que te guste un 95 por ciento de su tamaño original o algo más. En general, creo que esto va a estar bien. ¿ Verdad? Entonces hagamos lo siguiente. Pensemos realmente en esto. Bueno, ahora, de alguna manera queremos que el almacenamiento de queso sea capaz de almacenar queso, ¿verdad? Entonces hay algunas cosas que tenemos que hacer en el almacenamiento de software ahora. Y sin embargo lo primero, por supuesto, va a ser un int privado llamado queso, ¿verdad? Entonces este queso, ahí tienes. Y esto va a almacenar cuánto queso tenemos. Hagamos de esto campos serializados para que realmente podamos verlo dentro del constructor también. Y luego vamos a hacer algo que está bien, tal vez no muchos de ustedes saben, pero esto sería un, esto es básicamente un patrón de diseño C-sharp, y esto se llama el patrón singleton. La idea es que aquí tengamos una variable estática de almacenamiento de queso. Vamos a llamar a esto los Mets, llamar a esto el almacenamiento de queso. Y esto siempre será, bueno, el que está dentro de nuestro juego. ¿ Cómo podemos asegurar esto? Bueno, si el almacenamiento de queso, por lo que esta variable estática es igual a nula. Entonces si no hay nada escrito dentro de ella, entonces simplemente diremos que es almacén. Entonces, así la variable estática a esto. Y esto asegurará entonces que el número 1, no haya ni nunca solo un particular que esté almacenando disponible. Y luego también que podemos acceder a esto desde cualquier lugar, básicamente mediante el uso de la clase. Entonces, para que almacene, almacene, tal vez el nombre podría cambiarse en general, creo que esto está bien. Ella almacenamiento probablemente va a estar bien. Vamos a cambiar el nombre de esto para que podamos presionar Control R para cambiar el nombre de esto. Llamemos a esta instancia de almacenamiento de queso porque ese en realidad es un mejor nombre para esto. Y entonces lo que también voy a añadir también va a sumar tres eventos aquí. Por lo que hemos visto esto muy pronto al final de la introducción aguda C. Entonces primero vamos a hacer un delegado, y esto se va a llamar al cambio de cantidad de queso. Entonces esto es básicamente un delegado. Es decir, lo son si cambia una cantidad de queso y luego vamos a hacer tres eventos estáticos. Por lo que público estático, evento estático. Uno de ellos cool. Por lo que todos ellos en el queso cambio de cantidad. Uno de ellos llamó a queso agregado. Por lo que esta sería la que se llama cuando hay más que se le agrega. Entonces sólo vamos a copiar esto dos veces. Uno de ellos en Ella se quita, digamos que también podría estar en queso, restado, algo así. Y entonces también vamos a tener uno encima. Ella está cambiando, cambiada, se van. Entonces la idea es que queremos llamar a esto cuando agregamos un queso, cuando quitamos un queso y esto se va a llamar a cualquiera de esos. Yo diría que esto es algo, una vez más, como he dicho en la introducción C-sharp sobre eventos, realmente no tienes un negativo en agregar más eventos. Creo que esto va a estar bien y quién sabe lo que queremos sumar más adelante por la línea donde podríamos necesitar todos esos eventos. Es por eso que los agregué. Y sí, así que ahora pensemos en qué más necesitamos? Uh, entonces queremos, básicamente, si pensamos en esto a los métodos públicos esta vez, correcto, que se puede llamar y esos serían y ella es tarifa. Entonces fuimos de algún lugar a agregar un queso con una cantidad particular, claro, ¿verdad? Entonces esto creo, tendría sentido. Pero es como un, quiero una cantidad particular de queso y esto luego se guarda en este perímetro cantidad. Y lo que pasaría es que este queso punto-punto sería entonces sólo más igual a la cantidad. Pero eso es, debería ser bastante fácil de entender. Y entonces por supuesto, también queremos llamar aquí a los eventos. Y podemos llamar a estos eventos con una cosa en particular y eso va a ser sobre queso agregado, por ejemplo, porque sus realidades, y si ponemos en un punto de interrogación invocamos y decimos queso, entonces esta pregunta mark básicamente se asegura de que haya al menos un suscriptor ahí, lo contrario no se disparará. Entonces esto es básicamente lo mismo que si fuera a decir, si se le agrega es desigual a nulo, y luego decir en ella le ha agregado queso. Y creo que si hago esto, entonces en realidad va a decir, oye, podemos simplificar esto exactamente a éste. Y como puedes ver, esto es exactamente lo mismo. Bueno, tenemos que hacer lo mismo aquí porque en ella también ha cambiado. Y entonces estamos realmente contentos con esto. Simplemente vamos a copiar esto y luego vamos a decir que esto sería quitado árboles. Eso es entonces esto ella es cantidad negativa. Y luego en lugar de sumar, hemos eliminado. Ahora actualmente por supuesto nosotros, en este escenario, podríamos quitar árboles que no tenemos. Para que pudiéramos ir en negativo. Pero no nos vamos a preocupar por esto en este momento. Ahora mismo, sólo vamos a agregar queso de cualquier manera con el click. Entonces eso va a estar bien. Y ahora lo último que tenemos que hacer es que de alguna manera, bueno, que el método de agregar queso se llame quesos en servicio, littler y clicker, y entonces estamos bien. Y podemos hacer esto simplemente entrando aquí y luego diciendo, bueno, sé que puedo conseguir mi queso. Hagamos esto en la parte inferior justo aquí. Puedo decir, por ejemplo, queso. Instancia de almacenamiento de puntos. Entonces esta es la instancia. Entonces esto es básicamente lo mismo que estaría recibiendo si fuera a hacer game dot encontrar almacenamiento barato. Pero ahora como la instancia estática se guarda dentro de la clase misma, podemos simplemente hacerlo así en el queso y luego decir una. Y con la esperanza de que esto funcione, que esto sería bastante cool. Entonces, vamos a ver, ya no necesitamos la depuración. Y veamos si esto realmente funciona como lo pretendido. De acuerdo, empecemos esto y veamos ahora primero que nada, por supuesto, necesitamos agregar aquí un almacenamiento de queso. Eso sería bastante inteligente. Entonces ella es almacenamiento. Y agreguemos este almacenamiento. Aquí van. Como puedes ver, actualmente hay 0 árbol ahí dentro. Y esperemos que esto aumente cuando haga clic en esto. Y lo hace, ¿no es genial? Por lo que aumenta cada vez que hago clic en él y estamos consiguiendo, ella es como, nunca nadie ha conseguido queso antes simplemente haciendo clic en este queso en una báscula? no se ha visto. No lo sé. No sé cuándo empezaron a hacer queso, pero sí. Entonces eso sería en realidad por el chasquido del queso. Por lo que tenemos cada temporada a la que podemos dar click ahora. También tenemos un almacén de queso donde podemos agregar queso y quitar queso. Y ahora realmente se reduce a, ya sabes, agregar algunos extras. Entonces uno de los extras que vamos a agregar de inmediato es sólo para que básicamente podamos probar esto fuera es una especie de tramposos. Entonces en lugar del método de actualización de nuestro almacenamiento de queso, vamos a hacer ingresarlo arriba, bajar la clave. Y luego él Teclado de punto Code. Voy a usar el teclado plus. Por lo que el plus en el teclado, suelen estar a la derecha de tu teclado. Lo que vamos a hacer es que vamos a decir la instancia punto agregar queso. Digamos que alrededor de 10. Simplemente le vamos a agregar 10 queso. Y luego vamos a copiar esto más. Y lo que voy a decir tecla, teclado, mantener en menos. Y entonces simplemente vamos a hacer punto quitar queso. Y esto sería 10. Ahora es importante que en realidad no tenemos que pasar esto un número negativo aquí. Queremos pasar esto un número positivo, que por supuesto también podrías hacer es pasar, agregar queso, un número negativo. Y esto también funcionaría. Aunque por supuesto entonces el queso agregado tendría una especie de problema aquí. Por lo que esto sería algo que podrías agregar también. Entonces esto no será como absolutamente sólido, pero quería mencionar esto. Por lo que se hace muy fácilmente con un un un cheque si en ese caso. Pero sí. Sí. Entonces eso sería en realidad. Vamos, um, veamos esto en acción el más y el menos para que básicamente podamos agregar y quitar árboles aquí sin hacer clic en el queso real. Entonces vamos a hacer clic en esto unas cuantas veces. Y luego digamos primero el plus, y luego me dan 10 queso de inmediato sin problema. Y también puedo quitar queso. Y si ven esto, entonces en realidad podemos entrar en los negativos sin un tema aquí. Entonces puedo volver con el plus, básicamente sólo añadiendo y quitando queso. Esto es bueno agregar este tipo de plata solo para propósitos de depuración para que puedas probar. Está bien. Necesito, si tal vez si queremos agregar algo que cueste Hojas de hacer, entonces lo que podemos hacer es básicamente solo agregar un manojo de queso. Estamos de almacenamiento. Y luego vamos a estar bien y no tenemos que esperar y dar click como 1000 veces hasta que tengamos 1000 quesos para hacer algo. Y entonces el número por supuesto también puede cambiar. Pero sí, eso sería todo para esta conferencia. Agregando un queso para hacer clic y luego conseguir el queso, almacenándolo dentro de nuestro almacén aquí. Espero que te haya parecido útil esta conferencia como siempre, si hay alguna pregunta, siéntete libre de preguntar. Me aseguraré de responder. Y sí. 68. (Clicker de queso) crear edificios para construir: Muy bien, sigamos con nuestro clicker de queso aquí para el curso de unidad. Y en esta conferencia vamos a sumar la capacidad de construir los edificios que nos van a generar queso sin que tengamos que hacer nada. Queso tan pasivo, ¿qué podría ser mejor? No lo sé. Entonces pensemos en esto. En primer lugar haremos una nueva carpeta dentro de nuestros guiones aquí llamada edificios. Entonces así sólo cómo van a estar todos los guiones en los que van a estar nuestros edificios. Y primero que nada vamos a crear una nueva clase llamada Building. Entonces edificando ahí está, sí. Y esta va a ser una clase abstracta. Entonces, abramos esto y pensemos en esto por un momento. Entonces, en primer lugar, esto no heredará de un comportamiento mono. Entonces esta clase será una especie de, bueno sólo la clase de datos. Podrías pensarlo así. Y también vamos a sumar los edificios aquí a nuestro espacio de nombres también. Por lo que todo esto será dentro del espacio de nombres de edificios. Y el edificio va a ser una clase abstracta porque nunca queremos un edificio específico. Nosotros solo queremos las clases heredadas. Entonces cada vez que vamos a crear un nuevo edificio, vamos a hacer que herede de esta clase constructora. Y así pensemos en esto. ¿ Qué necesitamos realmente para un edificio? ¿ Qué tipo de componentes de un edificio? El primero que necesitamos es una tasa de costo. Entonces vamos a hacer que esto tenga propiedades básicamente. Entonces vamos a tener una base de costos básicamente para estos edificios cívicos. Entonces esto es cuanto queso costará. También lo haremos, si sólo voy a copiar esta propiedad más, también vamos a tener cada ganancia de Él. Esto es simplemente lo que ganaremos en términos de árboles. Y entonces tendremos aquí una propiedad flotante, que vamos a llamar el intervalo de tiempo. Y la idea aquí siendo que el tiempo esté aquí, La idea aquí siendo que simplemente vamos a tener este tiempo como usted tiene este queso ganan cada intervalo de tiempo básicamente. Entonces esos son los tres conceptos básicos que necesitamos para un edificio. A lo mejor se le puede llegar a unos cuantos más. Pero ahora mismo lo vamos a hacer así. Y también hay algunos eventos en los que estaba pensando. Uno de los hechos sería, en primer lugar, un delegado, delegado público, nulo. Este es simplemente el manejador de edificios con un edificio específico. Entonces edificando, edificando. Y entonces podríamos tener a eventos que son ambos de manejador de edificios. Uno de ellos está en la construcción, así en la edificación construida. Entonces esto es básicamente cuando estamos construyendo algo y luego también tenemos en construir flujo de efectivo que vamos a ver. Entonces el flujo de efectivo básicamente es cuando agregamos la ganancia de queso. Entonces esos serían los dos eventos que se me ocurrió. Por supuesto, probablemente haya algunos más en los que se pueda pensar, pero en este momento creo que esos bastarían. Y, y pensemos un poco más en esta clase de construcción. Entonces vamos a tener un protegido el constructor. Edificio con exactamente esas tres propiedades aquí. Entonces el costo, vamos a tener la ganancia de queso y vamos a tener el intervalo de tiempo de flotación. Y esas simplemente se establecerán en exactamente esas propiedades. Por lo que este costo de punto es igual al costo. Esta ganancia de queso punto es igual a ganancia de queso. Y entonces este intervalo de tiempo es igual al intervalo de tiempo, intervalo de tiempo. Este, se van, correcto. Y bueno, eso está todo bien. Y bueno, hay una cosa más que necesitamos, por supuesto, el flujo de efectivo vacío público abstracto. Entonces este es básicamente el método abstracto que cada una de las clases heredadas necesita implementar para que sean como edificios adecuados. Porque necesitamos básicamente este flujo de efectivo que se llame cada vez. Bueno, exactamente esto sucede. Entonces cuando se haga el intervalo de tiempo, entonces vamos a llamar a este método. Y cada uno de los edificios tendrá un tipo diferente de método de flujo de efectivo. Ya sea o no que sea tal vez regresando, simplemente devolviendo diez queso, o tal vez haya algunas partes diferentes. Entonces tal vez tengas edificios diferentes. Y cuando se tiene uno de esos, uno de construir a y uno de Edificio B, el tipo de influencia entre sí o más tarde por la línea cuando creamos mejoras para edificios específicos de los que estos métodos de flujo de efectivo podrían cambiar para específicos edificios. Es por eso que este es un método abstracto en este caso. Entonces creo que en general, eso es una especie de final listo. Ahora pensemos en dos cosas más. A lo mejor si construimos múltiples edificios, entonces queremos una especie de modificador por el cual aumenta el costo. Y debido a que hemos almacenado o queso en especie de CI, almacenamiento como un entero, probablemente vamos a tener este sea un modificador que también es un entero. Y este va a ser el modificador de costos de dos. Por lo que sólo vamos a aumentar el precio dos veces, una vez que se construya el edificio real. Podríamos también querer una lista de todos los edificios. Por lo que esta va a ser una lista estática del tipo un edificio llamado edificios. Y esto será accesible a través de dos cosas específicas. Uno de ellos va a ser una propiedad. Entonces vamos a tener en realidad una propiedad estática llamada lista. Por lo que esta va a ser una lista de edificio llamada edificio, Nota de edificio. Ahora eso va a ser edificando en instancias edificables. Y eso va a tener un get o una forma de conseguir los edificios. Y sólo va a devolver cómo edificios. No obstante, esto por supuesto, tiene un problema porque tal vez esto es nulo porque él aquí arriba, en realidad no hemos hecho nada con él. Por lo que necesitamos una forma de inicializarlo también. Y para eso vamos a hacer un método de construcción de listas estáticas privadas. Entonces esto va a ser edificios, edificio, que es, vamos a llamar construir todas las instancias de edificación. Entonces la idea es que siempre solo vamos a tener una instancia de un edificio y luego añadirle esto a una lista dentro de nuestro almacenamiento de quesos, por ejemplo. Por lo que más tarde, cuando vayamos allá, vamos a tener una lista de edificios aquí dentro los cuales se construyen. Y dentro de aquí básicamente sólo tenemos una lista. Por lo que este sería el edificio de listas. Resultado es igual a resultado. Esta lista correctamente nueva de edificio y luego devolver resultado. Y en medio aquí, vamos a añadir un edificio. Por lo que cada vez que agregamos un edificio nuevo, agregaríamos este edificio en particular aquí mismo. Y vamos entonces, por ejemplo, y también hagámoslo para que si los edificios son iguales a nulo, entonces si aún no se ha establecido facturings, entonces lo vamos a establecer simplemente llamando a construct todas las instancias de construcción. ¿ Verdad? Por lo que por ahora esto probablemente sea un paso arriba de complejidad en este momento. Ahora hay unas cositas aquí, y esto no fue sólo, digamos, elegido a capricho. Ahí está, por supuesto que mucha reflexión se metió en esto, digamos. Y ahora mismo, podríamos pensar en ello, pensarlo así. Tenemos el edificio de clase abstracta y luego podemos tener una lista de edificios. Entonces, si entonces tenemos, por ejemplo, un clicker, vamos a hacer un edificio clicker que clica automáticamente. Digamos. La mayoría de ustedes probablemente ya hayan jugado a Cookie Clicker. Esto es básicamente lo primero, sin embargo lo primero que puedes hacer ahí. Y este edificio Cookie Clicker, básicamente, vamos a sumar vía una nueva. Entonces vamos a hacer una nueva clase, tener esto heredar de la construcción. Y luego vamos a sumar esto a esta lista aquí. Y entonces tenemos una instancia de esto y nunca usaremos nuevo click que obtengo. Entonces esto es básicamente, tendremos una instancia aquí y luego siempre pasaremos estas instancias a alguna lista que vamos a hacer más adelante por la línea dentro de nuestro almacenamiento de CI. Y como almacenamiento de queso entonces será básicamente necesita entonces llamar al flujo de efectivo de cada uno de los edificios que hemos dado al almacenamiento de queso. Y entonces conseguiremos nuestras ganancias de queso, Digamos. Entonces. Vamos, así que sólo hagamos un nuevo edificio aquí. Entonces vamos a crear una nueva clase llamada el clicker. Y abramos esto. Asegúrese de que esto también esté debajo de edificios. Y entonces esto en realidad heredará del edificio justo aquí. Y lo primero que podemos ver, por supuesto, son las posibles correcciones. Por lo que implementar clase abstracta. Por lo que necesitamos implementar este método de flujo de efectivo, por supuesto, de lo contrario no funcionará. ¿ Verdad? Y lo que vamos a hacer es simplemente vamos a hacer lo siguiente. Entonces cada vez que este flujo de efectivo es. Frío. Lo que vamos a hacer es que sólo vamos a decir almacenamiento de queso, instancia de almacenamiento de puntos ci, agregar uno de queso ahora mismo. Entonces vamos a hacer esto muy, digamos, fácil de hacer así. Y entonces también lo vamos a hacer es en la construcción de flujo de efectivo. interrogación invocar. Y luego esto, porque este es el edificio que básicamente está consiguiendo este flujo de efectivo. Y también necesitamos un, necesitamos una lectura exactamente el no parámetro dentro del constructor. Entonces necesitamos un nuevo constructor aquí. Por lo que clicker público con costo, el, lo siento, la ganancia de queso entero, ella es ganancia y el intervalo de tiempo de flotación. Y lo grandioso es que podemos hacer ahora es que sólo podemos poner un colon aquí llamado base. Entonces esto va a llamar al intervalo de tiempo base. Intervalo de tiempo que van, Esto va a llamar al constructor base para el edificio real. Entonces dentro de aquí, en realidad no necesitamos hacer nada más. Y este sería el edificio, cómo lo construiría yo. Por supuesto, hay numerosas formas en las que podríamos hacer esto de manera diferente. Entonces, por ejemplo, en lugar de llamar aquí a la instancia de almacenamiento de CI , de inmediato, podríamos devolver un entero con cuánto flujo de efectivo genera este edificio. Por lo que esta no es la única forma en que se puede hacer esto por cualquier medio. Al igual que probablemente haya, quiero decir, como 1000 formas de llegar a Roma básicamente. Entonces todos, todos los caminos conducen a Roma. Es increíble cuántas formas puedes hacer esto es solo un ejemplo de ello. Y vamos a ver. Si volvemos al almacenamiento de CI. Básicamente aquí ahora queremos una lista de los edificios que se han construido. Entonces vamos a crear una nueva lista aquí. Entonces hagamos de esto una lista privada de tipo edificio. Por lo que ahora necesitamos usar un edificio de edificios. También podemos simplemente hacer usando los edificios de datos clicker de She's. Eso probablemente sea un poco más fácil ahora. Y podemos usar todas las clases ahí dentro. Y eso debería estar bien también. ¿ Verdad? Hagamos todos los edificios. Entonces hagamos todos los edificios construidos. Sí, hagámoslo. Y vamos a inicializar esto en lugar del método de inicio. Por lo que todos los edificios construidos equivalen a nueva lista de edificios, para que esto se inicialice. Y entonces básicamente podemos sumar a esta lista en particular. Una vez que tenemos un, bueno, una vez que construimos un edificio, ahora para eso, por supuesto necesitamos un nuevo método. Yo sólo voy a llamar a esto un vacío público. Construir, edificar, edificar. Ahí vas. Con una instancia de un edificio en particular. Por lo que construir un nuevo edificio. Construir en este punto ya parece una palabra bastante interesante. Pero creo que esto está bien. Y ahora hay algunas cosas que tenemos que hacer, ¿verdad? Entonces piensa en esto, vale, ¿para qué tenemos que hacer para construir un edificio? Bueno, necesitamos ver, ver si es posible, ¿verdad? Entonces eso es lo primero que tenemos que hacer y eso debería ser, bueno, esto, sólo necesitamos ver, vale, el costo del edificio real debería ser menor que la cantidad de queso que tenemos. Entonces lo que podemos hacer es si el nuevo costo de punto de construcción es básicamente más pequeño o igual al queso que tenemos. Entonces podemos construir. Entonces esto básicamente se ve así. Ahí tienes, construye. Y entonces si ese no es el caso, entonces podemos decir algo así como no construyas algo así, ¿verdad? Y así, sí, espero que eso tenga sentido. Entonces la idea es que si el edificio cuesta más, o en este caso, cuesta menos que el queso que tenemos o es igual exactamente al queso que tenemos, entonces podemos construirlo. De lo contrario no podemos. Por supuesto, también tenemos que restar esto. Por lo que hay algunos adheridos tal vez podríamos. Es decir, básicamente, lo único que tenemos que hacer es decir, vale, quitar el queso. Entonces quita el queso a la altura del costo de edificio nuevo, ¿verdad? Por lo que simplemente quitamos el queso con exactamente cuánto cuesta el edificio. Entonces nosotros por supuesto, queremos agregar este edificio. Por lo que todos los edificios o edificios construyen ahora agregan un nuevo edificio. Entonces esto debería realmente construir el ego. Por lo que vamos a sumar este edificio cedido con este método y añadido a nuestras listas aquí. Y entonces lo que vamos a hacer es que vamos a hacer lo siguiente. Básicamente vamos a usar algo que aún no hemos visto antes, que es una co-rutina. Y eso va a ser en realidad bastante sencillo. Por lo que retiraremos los árboles. Hemos agregado el nuevo edificio, y ahora necesitamos de alguna manera poder tener esto. Tener el intervalo de tiempo, revisar y agregar a nuestro queso equilibrado, por así decirlo, escribir. Y la forma en que podemos hacer esto es que vamos a definir un a, un enumerador de ojos. Te voy a explicar rápidamente después de que hayamos hecho esto. Por lo que este es un tour que enumero. Entonces este de aquí, vamos a llamar a esto el flujo de efectivo del edificio con un edificio en particular dentro de su edificio como parámetro. Y lo grandioso de este numerador iónico es que podemos hacer algo llamado retorno de rendimiento. Retorno. Y entonces podemos hacer un nuevo peso cuatro segundos. Y esto es lo realmente genial. Por lo que podemos esperar una cantidad particular de segundos. Por lo que este método toma un flotador por segundos. Y lo que podemos hacer ahora es porque le estamos dando un edificio. Podemos decir construir el intervalo de tiempo de punto. Entonces va a esperar exactamente por el intervalo de tiempo del edificio en particular dado aquí. Y luego después de esto se hace, así que si después de esto se hace, entonces va a continuar con este método. Entonces se va a esperar aquí. En este método en particular, todo lo demás todavía va a funcionar, por lo que es una especie de paralelo. Esto va a esperar hasta los segundos o más. Y una vez que esos terminen, esto va a continuar. Entonces vamos a decir que esto es Building dot cashflow en realidad. Cashflow van. Y porque esto agrega el queso, como dije, en este caso, también podríamos simplemente devolver un entero y agregar el queso aquí. Ambos funcionarían. Lo vamos a hacer así por ahora. Y eso está totalmente bien. Y luego al final de esto, porque lo que vamos a hacer es que sólo vamos a llamar a éste dentro de sí mismo. Vamos a llamar a esto otra vez. Entonces esto sería, este es el método de co-rutina de inicio. Y dentro de ella, simplemente llamamos edificio de flujo de efectivo. Y esta cosa exacta que queremos poner aquí también. Entonces este es un comportamiento mono. Este es por supuesto edificio nuevo. Ahora el ego. ¿ Qué es una especie de co-rutina en lo que decimos? Entonces la idea de una coroutina es que hemos visto esto, el método invocar a antes. Eso fue parte del comportamiento modelo. Y el método invoke nos permitió básicamente llamar a un método en particular un cierto número de veces, ya sabes, cada x segundos, por así decirlo. Y la coroutina es algo muy parecido a esto. En lugar de una co-rutina, si es una especie de, puedes pensar que esto es una especie de método asincrónico que puede esperar unos segundos en particular. Y entonces también podemos, si tan solo echamos un vistazo a este rendimiento devolver nuevo peso para final de marco fijo actualización. Podemos esperar hasta, podemos hacer esperar un rato y luego también con segundos en tiempo real. Entonces hay algunas cosas que podemos hacer con esto. Ahora mismo. Simplemente lo vamos a usar básicamente, dos generarán nuestro flujo de efectivo. Esto también es algo que se podría hacer dentro del propio edificio. Por lo que podemos agregar estos derrames de flujo de efectivo dentro del propio edificio y comenzó ahí dentro. Ahora mismo, hemos agregado aquí, y creo que esto también va a estar bien. También haremos una advertencia de registro de puntos de depuración. No se puede construir porque no hay queso. Entonces eso es sólo un pequeño mensaje aquí. Sabemos que, oye, realidad no podemos construir este edificio. Entonces en general, sí creo que esto debería ser básicamente todo lo que necesitamos hacer para construir este edificio. Ahora, hay algunas cosas más que necesitamos agregar. Entonces el número uno, por supuesto que necesitamos agregar que la instancia aquí. Por lo que dentro de nuestro resultado, añadir nuevo clicker. Entonces aquí mismo, vamos a añadir un nuevo clicker. Esta es la única vez que en realidad alguna vez llamaremos aquí a este nuevo clicker. Y luego queremos sumar esto con costo particular, ganancia de queso y un intervalo de tiempo. Entonces digamos que esto cuesta 10 y va a ganar nuevo un queso por segundo. Entonces esto es lo que esto significa en este caso. Por lo que el costo es de 10. 10, tenemos la ganancia sería una por segundo por 1 segundo. Hagámoslo así. Sí, se van. Y por supuesto esto es personalizable. Se puede pensar en esto porque por supuesto, esto necesita ser ajustado para el equilibrio, por ejemplo, ¿verdad? Si tienes múltiples edificios, entonces tal vez quieran lanzar diferente y su ganancia podría ser diferente también. Y aquí es básicamente donde lo harías, en nuestro caso aquí, la forma en que lo he construido y la forma en que probablemente lo construirás. Esta es la forma en que lo hacemos aquí. Por supuesto, una vez más, hay un millón de formas de hacer esto. Y hay una última cosa que tenemos que hacer porque este momento sólo estamos recibiendo el costo y no lo estamos cambiando. Entonces hay múltiples formas en que podemos hacer esto. Podemos decir, bueno, podemos cambiarlo aquí, o podríamos tener otro método aquí. Hagamos realmente lo siguiente. En realidad agreguemos un int cos privados, más bien de esta manera, ahí tienes. Costo privado. Sí, exactamente. Y luego vamos a hacerlo, en lugar de un edificio cambiando el costo aquí, en realidad podemos cambiar la constante, eso está bien. Vamos a cambiar un poco esta propiedad. Entonces esto va a ser devolver un costo, ¿verdad? Entonces sólo vamos a devolver un costo aquí. Y el único ajuste, lo que vamos a hacer es decir que el costo es igual al valor. Entonces esto es solo para que tengamos una variable privada extra aquí. Y entonces básicamente podemos cambiar este hacia arriba. Entonces lo que podemos hacer ahora es agregar un nuevo método aquí el cual va a ser público, entero público, obtiene costo e incrementar costo. Sólo llamémoslo así. Eso está bien. Entonces lo que vamos a hacer es que vamos a tener el costo igual los costos reales aquí, regresando esto después. Y exactamente, Así que básicamente guardamos esto antes de aumentarlo. Entonces vamos a decir, podemos decir que el costo es igual a, solo podemos decir veces iguales al modificador real, modificador. Se van, correcto. Y luego si llamamos a esto, ambos obtenemos el costo y también aumenta. Entonces hagámoslo dentro del almacén en una especie de almacenamiento de queso en lugar de aquí, solo digamos quitar el queso por los tiempos de costo. En realidad vamos a decir tiempo, obtener costos e incrementar costos también. ¿ Verdad? Entonces, como puedes ver, aquí están pasando muchas cosas. Es que es bastante, pero un paso a la vez, y creo que eso va a estar bien. Entonces por ahora mismo, lo que haremos es simplemente agregar un, un insumo donde básicamente podemos construir este edificio. Y luego haremos un nuevo objeto de juego que podamos, podemos dar click. Pero en este momento solo agreguemos un código básicamente clave. Por lo que este sería el código clave. A ver, digamos para Clicker por supuesto. Y cuando presionamos esto, veamos, ¿queremos que suceda? Bueno, queremos que esto se construya, un edificio que básicamente se llame y entonces ahora necesitamos un edificio ahí. De acuerdo, déjame pensar en esto. ¿ De dónde podemos sacar este edificio? Bueno, tenemos una lista de edificios aquí, ¿verdad? Y luego sumamos a esto, y esto es estática pública. Entonces en teoría, si pensamos en esto, deberíamos poder acceder a esta lista de todas las instancias. Y sabemos que el clicker en este momento es la primera instancia. Por lo que este sería básico o el primer edificio dentro de esta lista. Por lo que esto debería ser realizable haciendo un edificio. Entonces este es el punto de clase. Y luego tenemos instancias de construcción. Esta es la lista. Y luego sólo conseguir el del índice 0. Por lo que esto devolverá exactamente esta clase aquí que hemos creado. Y si todo funciona, entonces este es el clicker y el costo será, bueno, diez. Si tenemos estos diez quesos, entonces lo vamos a construir. Y luego se va a quitar eso, aumentar el costo de este edificio. Vamos a añadir esto a nuestra lista de edificios. Y luego también vamos a iniciar la co-rutina de flujo de efectivo, que va a correr cada segundo en nuestro caso. Bueno, esperemos que eso realmente funcione y que en realidad haga lo que queríamos hacer. Hay muchas cosas como muchas piezas entrelazadas en este caso. Y sí, supongo que en realidad podemos simplemente iniciarlo y probar esto. Entonces lo primero que hacemos es por supuesto que ahora tenemos un queso 0. Y si presiono la tecla C, lo que esperaríamos es decir, Hey, no puedo construir un edificio porque no tengo suficiente queso. Entonces veamos y no se puede construir porque el queso de nodo. Entonces eso es bastante bueno y ella también no aumenta por sí sola. Por lo que ahora puedo presionar la tecla más y me consigo diez quesos aquí mismo. Y ahora lo grande es, ¿funciona o no funciona? Entonces presiono C y bueno, disminuyó el número de quesos que tenemos. Y como puedes ver ahora, nuestro queso está aumentando en uno cada segundo. Ahora, lo grandioso es que ganen antes de esto. Bueno, eso en realidad es sólo quitar a nuestro diez Jesús otra vez con la tecla menos. Y si vuelvo a ver ahora mismo, Bueno, como pueden ver dos, así que todavía no tengo suficiente dinero ahora o suficiente queso ahora a las diez, debería tener suficiente. Pero como pueden ver, no funciona porque modifico nuestro derecho aumentado, así que ahora cuesta 20 queso y si lo presiono ahora, como pueden ver, lo construyó y ahora realmente estamos llegando a queso por segundo, porque ahora tenemos dos de esos clickers, haga clic cada segundo. Cada uno de nosotros básicamente consiguiéndonos un queso por segundo, ¿verdad? Eso es genial. Eso realmente funcionó. Quiero decir, totalmente bien. Como se puede ver muy claramente, podemos tener múltiples edificios del mismo tipo. Y ahora agregando un edificio, y esto es básicamente lo que es una de las cosas más importantes cuando haces algo como esto, siempre necesitas pensar en tu capacidad para agregar más de las cosas que quieres agregar , ¿verdad? Entonces el tema habitual podría ser, bueno, podríamos complicar esta locura. Y para algunos de ellos, para algunas de las ideas. Si ves esto la primera vez, podrías ser como, Wow, esto es realmente mucho a la vez y no estoy en desacuerdo. Es puede ser mucho en el principio. Pero paso a paso, si piensas en cada una de las partes individuales que no son tan complicadas, solo para armar, pueden crear algo que en realidad es bastante complejo. Y sí. Ahora bien, ¿cómo añadirías un nuevo edificio si estuvieras en esta etapa, cómo añadirías un edificio? Bueno, solo necesitas una nueva clase aquí, ¿verdad? Entonces en realidad podemos hacer esto sólo por el bien de la discusión, sólo para que una vez que se tenga especie de este terreno con unas cosas fundamentales configuradas, lo fácil que podría ser agregar un edificio. Entonces hagamos un nuevo edificio y vamos a llamar a esto la estación de ordeño. Porque a eso me refiero, a eso se me ocurrió. Supongo que esa es la mejor explicación que tengo. Esto por supuesto, una vez más, dentro del espacio de nombres de edificios y este será un edificio. Y lo grandioso ahora es que, bueno, podemos una especie de solo el clicker aquí, sólo por un momento. Esta por supuesto será la estación de construcción aquí. Y el flujo de efectivo, básicamente exactamente igual, pero tal vez queremos un número diferente de queso o eso también es algo interesante. En realidad agregué uno aquí. Este en realidad debería ser este punto. Ella ha ganado. No es que ese no sea un tema que pueda encontrarse, pero eso está bien. Y luego dentro de aquí, vamos a hacer lo mismo, este.tab ganancia de queso. Y eso ya es todo. Entonces este es el número uno, paso 1, paso 2, agregando esto aquí para que podamos copiar esto y decir estación de ordeño. Y entonces sólo necesitamos saber, vale, cuánto va a costar, ¿cuánto vamos a conseguir por segundo? Entonces digamos que esto cuesta 25. Y en este caso lo que vamos a conseguir es, digamos que vamos a conseguir cinco queso, pero sólo cada dos segundos. Entonces podemos decir que el costo es de 25 a 50, cinco quesos cada dos segundos. Entonces por supuesto ese es en realidad un mejor valor en el primer caso en comparación con el clicker. Pero sí, eso es bastante bueno. Pero por supuesto necesitas 25 quesos para construirlo. En teoría. Si ahora agregamos un nuevo tipo de clave que, para que podamos construirlo. Entonces, solo hagamos m aquí. Ahora sabemos que la instancia ahí hay una. Esto por supuesto, también podría ser un, esto también podría ser un diccionario, ¿no? Donde tú, en lugar de hacerlo con el interior, con los índices, podrías hacer esto con una enumeración. Por lo que tendrías enum de un edificio y tendrías cada uno de los edificios ahí también y podrías acceder a ellos como esto funcionaría todo. Básicamente la misma idea. Entonces ahora si presiono M, lo imaginaría construyendo una, una estación de ordeño ahora. Correcto. Entonces vamos a ver si realmente podemos hacer esto. Y sí, eso fue todo por agregar el nuevo edificio real. Si quieres que pasen cosas especiales con este edificio en particular , por supuesto, entonces es un poco más complicado. Pero ahora mismo esto debería funcionar. Entonces, veamos si eso realmente funciona. Entonces antes que nada, presionando la tecla M , no tengo, no tengo suficiente queso para esto. Entonces vamos a conseguir 30 queso y luego voy a presionar el conjunto vacío ha restado 25. Ella es, y como puedes ver, cada dos segundos ahora vamos a conseguir cinco quesos. Por lo que eso funciona perfectamente bien también. Y eso es realmente bonito. Ahora por supuesto, aún no tenemos ningún indicador visual. Realmente no tenemos una IU porque en realidad no lo estamos, no hemos hablado de la UI realmente. Podemos pensar en agregar sólo una especie de texto simple por supuesto, porque hemos visto la adición de los textos simples, eso, eso funcionaría. Pero en general, esto sí funciona ya. Entonces si percibo un montón de veces ahora, ahora ya no funciona porque ahora me cuesta en realidad como 80 creo que ya porque he construido demasiadas. Y ahora como puedes ver, el queso viene así como así sin hacer nada más. Entonces eso es bastante bonito, Eso es bastante bueno. Y sí, eso sería todo para la conferencia sobre cómo agregar edificios. Una vez más, esta es una especie de una de las formas en que podrías hacerlo. Es decir, probablemente haya otras 1000 formas en las que puedes hacerlo. Pero en realidad estoy bastante feliz porque esto es mucho ampliable. Y se puede ampliar esto. Por supuesto, hay pocas cosas que puedes agregar, especialmente uno más o algunos edificios más por tu cuenta. Pero sí, eso fue todo para esta conferencia. La próxima vez vamos a añadir un GameObject que podemos hacer clic para básicamente construir nuestros edificios. Y esto es algo que más tarde estamos por debajo de la línea. Entonces me voy a convertir en una UI. Entonces vamos a sumar algunas cosas aquí. Siguiente conferencia. Y sí, pero eso fue todo para esta conferencia. Espero que te resulte útil si hay algunos puntos en los que esto ha sido un poco confuso porque hemos saltado un poco de clase en clase y así sucesivamente. Entonces siéntete libre de, número uno, yo primero diría, ya sabes, lo que debería de nuevo, tal vez pensar un poco en esto. Mira la clase. Si lo descargas o si has programado para simultáneamente, entonces tal vez mires un poco, trata de entender cada uno de estos pasos y cada uno de los métodos que hemos implementado y piénsalo así. Y si quedan preguntas, por supuesto, siéntase siempre libre de preguntar y me aseguraré de responder. Y sí. 69. (Clicker de queso) hacer una UI básico para construir edificios: Está bien, sigamos con el clicker de queso aquí para el curso de unidad. En esta conferencia, vamos a añadir una interfaz de usuario muy sencilla, así como la posibilidad de añadir los edificios a través de un clic en un objeto de juego. Y esos objetos de juego van a ser elementos de la interfaz de usuario, principalmente botones. Y bien entonces solo funcionarán una manera donde podamos hacer clic en cada uno de ellos para cada uno de los edificios que tenemos. Y entonces, básicamente, engendrarán en un edificio. Y también cambiarán. Así lo harán, mostrarán básicamente el costo y también cuántos edificios hay, cada tipo en particular. Y también tendremos un texto que muestra cuánto queso tenemos en el momento actual. Entonces básicamente h, es contador, podría decir, lo primero, queremos el queso, el almacenamiento de queso UI. Por lo que personalmente, siempre termino mis scripts de UI con UI. Y luego en un principio, sean lo que sean. Y esto va a ser queso decker tú, yo por supuesto, como en términos de espacio de nombres, también estaremos usando Unity engine dot IM para esto. Lo primero que necesitamos es un texto privado. Sostén el queso. Digamos que, a ver, puedo lograr textos de almacenamiento. Ahí vas. Eso es un, eso es un bocado, un go. Y esto será simplemente mientras se metió aquí. Entonces esto va a ser si el texto de almacenamiento de queso es nulo, entonces solo estableceremos el almacenamiento vinculado a este punto get text componente. Entonces vamos a utilizar el componente Get en este script en sí. Y entonces simplemente obtiene el componente del objeto de juego de tipo texto al que se adjunta este guión en particular. Y luego iremos al punto de almacenamiento de queso sobre cantidad de queso. Entonces ella ha cambiado. Entonces esta es la idea. Si el queso cambia, entonces vamos a llamar a un método en particular. Esto va a ser sólo cambiar el método de número. Eso lo va a llamar. No necesitamos el método de actualización aquí en este transportador vacío privado. Cambia un número con una nueva cantidad porque esto es exactamente el esto es exactamente la firma de método que necesitamos para el queso cantidad de cambio delegado aquí. Y lo que esto simplemente hará es que obtendrá los textos de almacenamiento de queso, textos iguales a nueva cantidad que es toString. Por lo que simplemente cambiaremos el texto aquí cada vez que cambie el queso. Es por eso que dije que esa es una buena idea agregar esos eventos que nunca sabes cuándo los necesitarás. Por supuesto, siempre puedes añadirlos más adelante por la línea también. No obstante, en este caso, eso va a estar bien. Entonces pensemos en esto, agregando un elemento de interfaz de usuario aquí. Entonces haciendo clic derecho dentro de nuestra interfaz de usuario de jerarquía y luego un texto. Entonces por supuesto, necesitamos cambiar el lienzo una vez más para pantalla cámara espacial y arrastrar la cámara principal por aquí. Y entonces nuestro texto está abajo. Son muy pequeñas y vamos a hacerlo un poco más grande. Y luego también que sea el texto real un poco más grande, algo así como quizás 50. Ah, eso es demasiado pequeño. A 120, me encanta. Y tendremos en realidad dos textos, así que duplicaremos este Control D. Esta va a ser la etiqueta del queso, digamos. Y eso va a ser sólo queso. Y luego el otro es el texto de almacenamiento de queso. Sí, eso está bien. Va a ser un 0 por ahora. Y luego también vamos a hacer que esto sea un poco más bonito. Entonces vamos a hacer algo como esto. Este es el texto del queso. Ahí vas. Y entonces éste también puede ser un poco más pequeño. Se van, ¿verdad? Entonces ahora tenemos esto. También haremos de esos dos blancos solo para que podamos ver esto un poco mejor. Sí, creo que eso está bien. Y luego si esto fuera sí, entonces esto funciona bastante bien. Y para este texto de almacenamiento de queso C, simplemente añadiremos el script de UI que hemos hecho aquí mismo. Ahí vas. No es esto abogado? Bueno, mira el ego. Siempre abre el material. Son una especie de ruido a go. Está bien. Ella es almacenamiento para yo ahora está ahí. Y esto en realidad ya debería funcionar totalmente bien porque hemos agregado este evento. Y debido a que esto funciona vía el evento, todo debe funcionar de inmediato. Esto es, como dije, los delegados en los eventos realmente útiles para la para la ampliabilidad de su proyecto. Por lo que agregar esto fue bastante fácil. Entonces, veamos si eso realmente funciona. Entonces si hago clic en esto, como pueden ver , aumenta a dos. También puedo hacer trampa. Entonces si presiono el plus y el negativo, esto también funciona. Y si ahora fuera a, por ejemplo, agregar un clicker presionando C, restará esto. Y ahora cada segundo actualizará tu también. Y esto es mucho mejor que tener esto en especie de método de actualización donde lo comprueba cada fotograma. Porque no necesitamos cambiar la interfaz de usuario cada fotograma porque no cambia cada fotograma. Y esa es una especie de idea por qué este evento, el evento, un sistema delicado en este caso, es como increíblemente superior a cualquier otra cosa que pudiéramos implementar en ese caso. ¿ Verdad? Y ahora básicamente queremos jugar objetos en los que podamos hacer clic en lugar de presionar C y presionar M para crear nuevos edificios que estás escribiendo, realidad vamos a crear una interfaz de usuario real para esto en este caso. Entonces me voy a llevar un poco al futuro de lo que vamos a ver un poco más tarde por la línea. Por lo que algunas de esas cosas podrían no ser un 100 por ciento comprensibles, pero estoy tratando de explicarlas lo mejor que voy. Entonces lo primero que queremos es que queremos algo que se llama UI de construcción. Entonces este edificio UI básicamente va a ser la clase que va a especie de, esto se asegurará de que sepamos, acuerdo, ¿Qué tipo de edificios tenemos y podemos construir? Y también habilitará y desactivará ciertas cosas para que se construyan en función del costo. Entonces para eso, tenemos botones. Entonces hay una manera muy fácil de que podamos hacer esto. Vamos a agregar algo a nuestro Lienzo. Entonces haga clic derecho en UI y luego vamos a agregar un panel aquí abajo. El panel es sólo una especie de fondo y vamos a añadir esto a un costado aquí. A mí me gusta esto. Y luego vamos a tener a este panel. Vamos a añadir bastante loco otro panel y hacer esto un poco más pequeño aquí mismo. Entonces creo que eso es bueno. Este sería el panel de edificios. Y esto es entonces un edificio paneles. Entonces este es el panel de un edificio en particular en este caso. Y también vamos a sumar algunos activos aquí. Entonces tengo un clicker, tengo una vaca para la estación de ordeño, y también tengo un barril para otra cosa que podríamos querer agregar. Entonces estos son los barriles, vamos a ver aquí. Entonces tenemos los a barriles que realmente queremos unos 500 píxeles aquí, para que sean un poco más pequeños también, por supuesto no bilineales electrónicos, bien, creo que son lo suficientemente grandes. La vaca y el clicker. Por lo que la cuenta clicker debe ser de 150. Y vamos a mantenerlo por lineal también porque es bastante grande y el clicker que es 250 y esto definitivamente es punto. Sin compresión. Sí. Por lo que ahora podemos pensar en esto. De acuerdo, este es un panel para un edificio en particular. Y también podemos pensar en esto como un botón. Por lo que queremos básicamente hacer de esto un botón en el que podamos hacer clic y luego tener este bien construido o edificio si esto es posible. Entonces en este momento, esto es solo un panel, pero simplemente podemos ir a Agregar Componente, ir a tu ojo y agregar un botón. Y ahora esto sería un botón. Y esto puede deshacer click, hacer algo específico. Y esto va a hacer lo que realmente le digamos que haga. Pero no queremos agregar esto manualmente. Queremos agregar esto con 0. No podemos manualmente, pero en realidad querríamos probablemente agregar esto con el script real. En este caso, vamos a sumar esto manualmente, así que vamos a llamar a esto otro guión. Entonces llamemos a esto la UI Build. Entonces es un montón de guiones diferentes, una vez más lo que necesitamos, De hecho, vamos a cerrar de unos pocos aquí ahora mismo porque en realidad no los necesitamos en este momento. Y este Build UI básicamente va a ser el que determine, vale, qué, qué pasa aquí, qué edificio se construye. Y básicamente podemos hacer algo como esto. Básicamente podemos darle una oportunidad a esto. Hagamos realmente lo siguiente. Entonces hagámoslo. Podemos simplemente decir público, vacío construir. Y esto va a conseguir un, un índice en particular aquí. Y esto simplemente hará lo siguiente. Entonces vamos a agregar, simplemente vamos a decir instancia de punto de almacenamiento de queso. Entonces vamos a conseguir la instancia del almacenamiento de queso y luego tenemos el edificio de construcción aquí. Y entonces por supuesto necesitamos darle un nuevo edificio. Pero podemos hacer esto, antes que nada, yendo aquí usando She's clicker dot buildings. También. Simplemente asegurándonos de que esto esté bajo la interfaz de usuario para que tengamos todo limpio y ordenado. Y luego dentro de aquí sólo podemos decir un edificio. Instancias de construcción de puntos. Índice, van. Por lo que podemos especificar un índice particular de un edificio que debe construirse dentro de la instancia de almacenamiento de claves. Entonces esto es exactamente lo mismo. Si miramos nuestro almacenamiento de queso una vez que esto se haya recargado, podemos ver que esto es exactamente lo que hemos hecho aquí. Por lo que acabamos de llamar a esto en otro guión. Eso es todo lo que hicimos. Y luego también las instancias de construcción que, eso en realidad es todo lo que realmente estamos haciendo aquí. Y lo estamos haciendo con este panel en particular. Entonces, y entonces lo que hacemos es que agregamos esta UI Build a este panel aquí. Una vez que esto realmente se agrega, Vamos a ver. Ahí vas. Ahora está aquí. Y entonces podemos hacer es este tipo de campo onclick aquí. Si presionamos este plus, entonces podemos decir, entonces podemos mirar este y dar click en este punto allá y decir: Bueno, quiero que esta sea la UI del edificio. Y ahora onclick, y luego la UI del edificio va a ser ejecutada o algo entonces ahí. Y como puedes ver, y en realidad no tenemos esto porque yo por supuesto, porque en realidad no podemos hacer la UI del edificio, en realidad, lo cual es un poco raro, en realidad tenemos que agregarnos a ella. Entonces en realidad tenemos que tomar este panel de construcción y arrastrarlo aquí para que ahora los paneles de construcción ahí dentro. Y luego si miramos aquí, la UI Build, y luego construimos con un entero en particular, en este caso, 0 es exactamente correcto porque el primero va a ser el clicker. Y ahora vamos a hacer que esto sea un poco más visualmente atractivo. Entonces vamos a sumar algunas cosas aquí. Entonces, en primer lugar, hacer clic derecho en el texto de la interfaz de usuario del Panel de construcción, haciendo esto un poco más grande aquí. Y entonces digamos font-size 50. Sí, eso suena bien. Hagámoslo un poco más grande. 70, eso está bien. Este va a ser el clicker. Y también centremos este tipo de aquí. Podríamos, por ejemplo, añadir también la cantidad de costo, algo así. Pero ahora mismo, en realidad solo agreguemos el clicker por ahora para que tengamos algo en lo que podamos hacer click. Y además agreguemos una bonita imagen. Entonces esto es de aquí imagen. Y podemos hacer esto un poco más grande. Podemos especie de escalarlo. Presionando viejo, podemos escalarlo desde el medio. Y entonces estoy presionando turno. Podemos hacer que lo específico Qué dirías resolución se pega e inserte aquí la imagen. En realidad podemos decir sprite. Entonces simplemente podemos tomar el clicker, ponerlo ahí, y se van. Ahora en realidad tenemos esto como un buen HOMBRE pequeño al que podemos dar click. Y una vez que hacemos clic en esto, deberíamos crear un nuevo clicker. Vamos a ver si eso en realidad es todo lo que tenemos que hacer. Pero en realidad estoy bastante seguro de que nosotros, que esto es ahora construir UI. Y sí, así que probemos esto. Por lo que esto ya debería funcionar. Entonces ahora mismo si hago clic en esto, deberíamos conseguir, no tengo suficiente queso. Como se puede ver, aunado a ningún queso. En realidad nos engañemos diez queso. Y si vuelvo a hacer clic en esto, deberíamos ver que el queso se resta. Y luego el clicker construyó la portería y funciona. Bueno, eso es bastante guay. Eso en realidad ya funciona. Ahora el camino y eso es, eso es bastante guay. Como dije, podemos sumar unas cuantas cosas más a esto ahora mismo. Entonces, en realidad, vamos a mover esto un poco hacia arriba y luego agregar un poco más de texto aquí. Entonces el primer texto al que vamos realmente, vamos a copiar el clicker. Por lo que una vez más, seleccionando esto y controlando un D2, basta con copiar esto. Hagamos un como un gran número aquí. Este va a ser el número de clickers que tenemos. Entonces este sería el, digamos números, número, edificio, edificio número de camisa. ¿ Por qué no? Entonces esta sería la etiqueta de nombre que estoy construyendo. Por lo que siempre asegúrate de tener un nombre propio aquí. Porque si miras esto tal vez entonces un poco más tarde por la línea, entonces vas a decir, ¿qué fue eso? Esta es la imagen edificante. Ese es el número construyendo este 0. Y hagamos esto un poco más grande. Entonces hagamos esto como un 100. Sí, eso es genial. Al igual que un 100 000, asegurándose de que esto no se desvanezca. Y entonces también podemos sumar un costo. Entonces esto sería, una vez más, copiar este año, estamos duplicando a a a D. Este sería entonces el costo. Y solo agreguemos 0 aquí también. Vamos en realidad 10. Entonces ese es el costo que conocemos. Y aún. Mantengámoslo así por ahora. Esto, como dije, sí, no se ve como loco cool o, ya sabes, realmente no tenemos etiquetas ahí todavía. Pero esto va a estar bien. Entonces a nuestra vista de nuestra carpeta de activos, agreguemos una nueva carpeta llamada prefabs. Ahora ya hemos visto esto porque lo que vamos a hacer ahora es que vamos a hacer una prefabricada de este panel de construcción aquí. Entonces sólo vamos a patinar rápidamente por ahí el panel de construcción del ego. Y lo grandioso de esto es que ahora podemos simplemente añadir esto de nuevo aquí. Entonces y tenemos esto dos veces. Esto por cierto, sería el panel de construcción clicker. Y este es ahora el panel del edificio de ordeño. Bajemos un poco el panel de ordeño y cambiemos las cosas que necesitamos cambiar aquí. Entonces lo primero que queremos cambiar es que la imagen, claro. Entonces esta va a ser la vaca. Ahora, desde el clicker aquí, vamos a tener la vaca. Es decir, eso no es tan increíble. Y en lugar del nombre aquí, vamos a tener la estación de ordeño. Entonces esto es un poco grande, así que vamos a aumentar un poco el tamaño aquí. Y el objetivo, el costo también va a comenzar a los 25. Y ahora nosotros de alguna manera, alguna manera ese es el, ese es el verdadero punto aquí. Tenemos que cambiar las cosas individuales ahí dentro. ¿ Y cómo hacemos esto? Bueno, vamos a hacer esto con esta interfaz de usuario del edificio que ya hemos creado, pero aún no se ha utilizado. Y esto una vez más, como dije, es, podría ser un poco más complicado. Primero que nada hagamos UI aquí para que tengamos esto dentro del espacio de nombres correcto. Y sí, vamos a empezar y voy a ir te explicaré a medida que avancemos. Entonces, antes que nada, tendremos un diccionario de construcción. En realidad estamos necesitados. Usando ese espacio de nombres también. Entonces esto va a ser, ella está parpadeando fuera de los edificios. Y esto va a ser un diccionario de construcción a GameObject. Y esto va a ser construir cosa Bill a básicamente mientras construye a panel de construcción. Vamos a llamarlo así. Sí, eso está bien. Inicializaremos esto dentro del método de inicio con un nuevo diccionario. Entonces eso se hace muy bien fácilmente. Y entonces pensemos en esto. Entonces tenemos un diccionario ahora. Podemos básicamente un cambio. Aquí algunas cosas. ¿Por qué necesitaríamos diccionario? Bueno, la idea es que vamos a tener un edificio en particular que está siendo un panel en particular que se está haciendo clic y que se asocia con el edificio. También podemos tener la asociación al revés básicamente. En nuestro caso, en realidad no estoy un 100 por ciento seguro de que necesitamos esto todavía, pero es bueno tener esto aquí ya. Y veamos, int I es igual a 0. Yo es igual al recuento de niños transform.py. Entonces en realidad vamos a contar a los niños. Y entonces lo que vamos a hacer es que vamos a ver los edificios panel, añadir un panel. Y vamos a ver edificios construyendo instancias de punto. Yo es igual al transform.py hijo de I dot GameObject. Ahora esto podría parecer absolutamente loco lo que estamos haciendo aquí. Pero la idea real de lo que estamos haciendo es que estamos, estamos pasando por el número de niños que tiene este objeto de juego en particular, y luego agregando las instancias. Entonces esto es simplemente un edificio de nuestras instancias de construcción con el mismo, digamos indexar aquí, luego el índice infantil. Entonces la idea es que si agregamos esta interfaz de usuario del edificio a los edificios reales, vayan a este panel de edificios reales. Y podemos pensar, bueno, son niños es una vez más, el panel de construcción clicker y el panel de construcción de ordeño. Entonces esos son los niños, el niño 0. Este es el niño uno. Está bien. Eso en realidad lo entiendo ojalá. Y éstos se asocian entonces simplemente con el edificio dentro de nuestra lista de instancias de construcción. Entonces sí, y ahora si volvemos aquí, esto es simplemente guardar en este diccionario. Y eso es realmente todo lo que hay a ello. Y lo que vamos a hacer en un principio aquí es que vamos a pasar por esto una vez más. Entonces vamos a decir 0, yo es más pequeño que. Y ahora vamos a pasar por el recuento de instancias del edificio aquí. Que debería ser, por lo que en teoría, este conteo y este conteo siempre debe ser el mismo porque para cada edificio siempre tendremos un panel diferente. Y para cada panel, por supuesto, tendremos un edificio asociado a él. Y podemos entonces básicamente en realidad entonces bien podríamos pasar por esto a través del panel de derramamiento, ¿verdad? Entonces. Podemos conseguir esto. Y luego con los corchetes puedo decir, bien, déjame conseguir las instancias I. Entonces, ¿por qué es esto una constructa tan loca? Bueno, necesitamos darle a esto el edificio real que está asociado con él. Ahí hay un diccionario. Tenemos que darle un edificio. Y luego recuperaremos un objeto puntual específico. Entonces realmente vamos a recuperar el objeto del juego, el panel en sí, y este panel, tendremos que conseguir el componente de un botón, ¿verdad? Y entonces vamos a hacer es vamos a decir el botón por supuesto, requiere motor Unity, usando motor Unity que UI it. Y este botón, simplemente diremos que interactable es igual a falso. Ahora, ¿por qué hacemos esto? Es decir, en primer lugar, todo también, simplemente podemos hacerlo en este también. Entonces no es que tengamos que hacerlo aquí. Esto es sólo un ejemplo de cómo entonces accederías al diccionario básicamente. Pero sí, entonces ¿por qué establecemos lo interactable igual a falso? Bueno, para que podamos interactuar con lo real con el botón real. Porque sólo deberíamos poder interactuar con este botón. Y cuando realmente tengamos suficiente queso en el banco, ¿verdad? Porque eso sería inteligente. El tenemos la advertencia y eso está bien también. Pero no sería genial si sólo pudiéramos interactuar con el botón y solo construir el edificio real si tuviéramos suficiente queso en el banco. Y esto es básicamente lo que queremos implementar aquí mismo. Entonces tendremos algunas cosas que realmente vamos a querer. Entonces lo primero es que básicamente tenemos el edificio construido edificios, por lo que sobre edificación construida más bien se van a sumar cuatro a un o se le agrega un método específico a este evento. Y este va a ser el número de actualización de edificios. Entonces esto es, vamos a implementar este método en breve. Y luego otro método que queremos, que depende del host de actualización. Entonces esas dos cosas lo van a actualizar dentro del ojo. Estos ya se actualizan dentro del costo de actualización especialmente se actualiza dentro de los propios edificios ya. Pero ahora queremos verlo visualmente. Y luego también tenemos el punto de almacenamiento de queso en ella ha cambiado. Entonces, si cambia la cantidad de queso, entonces podríamos querer actualizar la capacidad de clic de clickability. Creo que eso está escrito correctamente. Eso espero. ¿ Verdad? Entonces esos son tres de los métodos que queríamos agregar aquí. Entonces el primero, número de edificios, simplemente podemos básicamente hacer clic con el botón derecho en acciones rápidas y luego solo decir Generar método aquí. Ahí vamos. Generemos también este método, y generemos este método. Por último pero no menos importante. Ahí vas. Y siempre tenemos esto con la firma correcta del método también. Déjenme darle la vuelta un poco a esto porque yo, en mi referencia, en mis referencias, tengo esto un poco diferente. Entonces empecemos realmente en la parte superior. Actualizar número de edificios. Bueno, ¿cómo en el mundo podemos actualizar el número de edificios? Entonces esto es exactamente esto lo que tenemos aquí, ¿verdad? Por lo que tenemos este campo de texto de construcción numérica que queremos agregar o cambiar dependiendo. Muchos edificios que son de un tipo particular. ¿ Cómo va a funcionar eso? Solo seamos reales. Eso es una locura. Bueno, en realidad no está tan mal. Lo que vamos a hacer es ir a hacer un bucle foreach. Y esto para cada bucle va a pasar por el par de valor clave. Esto es exactamente lo que se almacena dentro de un diccionario aquí de edificio y GameObject. Por lo que queremos pasar por los pares de valor clave. Entonces par clave-valor, sólo lo vamos a llamar así dentro de nuestros edificios a construir paneles. Entonces vamos a pasar por el diccionario con un bucle foreach. Y luego vamos a decir si el par de valor clave real que tenemos aquí, derecha e izquierda es igual al edificio en el que estamos pasando. Entonces podemos hacer cosas. Ahora, ¿cuándo es esto cierto? Esto es cierto. Entonces básicamente vamos a pasar por cada uno de los edificios. Vamos a pasar por cada uno de los paneles que tenemos en este momento. Sólo tenemos dos paneles, ¿verdad? Entonces no tenemos tantos paneles, pero tenemos dos paneles. Y vamos a decir, vale, si el nuevo edificio que se ha construido es igual a algunos paneles. Entonces digamos que construimos una nueva estación de ordeño, entonces va a ser igual a este panel y este panel que entonces será tendremos acceso a este panel, exactamente esto. Por lo que tenemos acceso a este panel haciendo valor de par clave-valor. Porque ahora sabemos, vale, el edificio que se construyó era la estación de ordeño. Esto es igual a la clave. Por lo tanto, bam, Vámonos. Y lo que vamos a decir es transform.py niño 0. Entonces esto es mucho en realidad obtener texto de punto de texto tipo componente. Y entonces vamos a decir, ¿realmente vamos a necesitar, por supuesto, evaluar este número? Entonces lo que vamos a decir es que vamos a tener un nuevo número aquí, número entero. Esto es básicamente exactamente esto, ¿verdad? Entonces lo que sea que ya esté escrito en él, que no necesitamos guardarlo en ningún otro lugar. Entonces así, adoptar textos, por supuesto. Yo también voy a explicar esto. Entonces en el análisis simplemente toma un, una cadena y la convierte en un entero si ese es un entero real, ¿verdad? Entonces en lugar de este texto aquí, lo que queremos es que esto sea, tenemos un 0 guardado y también hay que tener cuidado con el Aya real. Por supuesto. También tenemos que tener cuidado con la posición real de esto. Entonces vamos a cambiar esto en lugar de un prefabricado otra vez. Y digamos, vale, el número del edificio está en realidad en la parte superior. Por lo que esto sería un niño 0. Entonces el nombre de la etiqueta va a ser Niño 1. Entonces con el índice uno, entonces tendremos el costo. Y entonces la imagen va a estar al final. Ahora la imagen no cambia. A lo mejor queremos que la imagen cambie en algún momento, pero en este momento la imagen no cambiará. El único tipo de cosas que son cambiables es el costo del edificio y el número del edificio. Entonces vamos a cambiar esto. Y luego como puedes ver, en realidad también lo cambió aquí porque esos dos GameObjects están asociados a este prefabricado. Y una vez que cambiemos el prefabricado, también cambiaremos esos a objetos de juego. De acuerdo, pensemos en esto. Entonces ahora básicamente obtenemos exactamente esto. El primer objeto de juego ahí. Y los textos ahí está el número de es el número de objetos. De es igual al número de edificios que son especie de inexistencia. Y entonces simplemente vamos a decir, bueno, este número debería ser solo más igual a uno. Entonces queremos ahorrar, así que sólo queremos aumentar este número en uno y luego guardar eso de nuevo a exactamente esto. Una vez más, hay otra forma en que podemos hacer esto. Por ejemplo, podríamos simplemente guardar dentro de un edificio una variable cuántos edificios de un tipo específico hay. Pero en realidad no necesitamos hacerlo. Esto también funciona. cálculo de esto sobre la marcha también funciona. Ahora esto ya es, esto ya debería funcionar. Y creo que en realidad deberíamos poder ver esto ya. Si no me equivoco. Ahora, la cosa es todavía vamos a conseguir una excepción en realidad no implementada. Entonces, en realidad no hagamos esto. Primero que nada pongamos aquí también el método de costo de actualización. Entonces esto va a ser muy similar a esto. Entonces, en realidad copiemos esto solo por el bien de la discusión. Esto seguirá siendo igual. Entonces la si, la declaración if aquí es la misma. Y entonces lo único que vamos a hacer aquí es el valor clave par dot value, transform, dot get child. Entonces esto por supuesto, básicamente está codificando duro la posición de cosas particulares. Porque ahora tenemos, si volvemos a mirar esto, tenemos esto a las 012. Por lo que el costo que conocemos está en la posición 2. Por lo tanto, necesitamos que niño a. Esto, como dije, está codificando duro esto en esta instancia, probablemente habría un poco, podrías hacerlo un poco mejor. Pero ahora mismo, la expandibilidad aquí realmente lo es, no es tan grande de un trato. Yo obtendría componente. Por lo que queremos una vez más en el componente de textos del texto de costo. Y vamos a establecer esto en building.com dot toString. Entonces sólo estamos construyendo que se ha construido. Recuerde que el método de costo de actualización se llama cada vez que se ha construido un edificio a través del sobre construir un evento construido sobre edificio construido. Y este costo de actualización luego tiene el edificio como parámetro. Y simplemente vamos a ajustar el texto al costo real del edificio después de que se haya construido. Ahora bien, lo interesante es que en realidad no hemos llamado a esto sobre edificación de evento construido todavía. En realidad necesitamos hacer esto todavía. Y esto se hace dentro del almacenamiento de queso aquí mismo. Por lo que hemos agregado el edificio aquí, pero en realidad no hemos sostenido esto todavía. Y esto, esto en realidad es tan fácil como simplemente decir Building dot on building built. interrogación, invocar con edificio nuevo. Ahí vas. Eso es todo lo que tenemos que hacer. Y ahora eso también está frío. Entonces eso en realidad es muy, muy bonito. Entonces sí, esta fue la UI construida que funcionó perfectamente bien también. Hay una cosas más para la UI Build que realmente necesitamos cambiar y que está dentro de nuestro ordeño un Panel de construcción. Oh, no, no, no, no, no, no te muevas que estás loco. Se van, tenemos que cambiar este 0 a uno. Porque por supuesto, la estación de Ordeño está en el índice uno y el nodo en el índice 0. Entonces eso es algo importante. Pero después de que hayamos hecho esto, pensemos en el resto de la UI del edificio. Nosotros hemos hecho lo siguiente. Si hemos construido un edificio, vamos a llamar al número de actualización de edificios. Eso funcionó bien. También actualizaremos el costo. Y ahora, por último pero no menos importante, queremos básicamente actualizar aquí la clickability. Y eso también va a ser bastante fácil. Una vez más, vamos a seguir con un método ForEach aquí. Y en este caso, en realidad no queremos la declaración if. No necesitamos eso. Sólo queremos dos, básicamente obtener el valor y luego básicamente hacer exactamente lo mismo que hemos hecho aquí, ¿verdad? Entonces esto es básicamente lo que queremos. Queremos obtener el componente de GameObject. Podemos hacer esto simplemente diciendo, Bueno, value dot get Component button porque queremos el botón y queremos cambiar bien la intractabilidad a verdadero, pero solo bajo ciertas condiciones. Ahora podemos pensar ¿cuál es la condición? Bueno, básicamente, queremos ver el edificio en sí. Por lo que este sería el par clave-valor punto, ky, costo de punto. Más pequeño o igual al queso. Almacenamiento de queso punto instancia punto queso. Esto es, yo en realidad, no podemos acceder a cuánto queso tenemos? Es esto a, esto en efecto es una pena, Vamos al almacén de queso aquí por un momento. En realidad, sólo por el bien de la discusión, hagamos esto público ahora mismo. Hay una forma más fácil de hacer esto. En realidad, no, no hagamos esto. Hagámoslo. Y simplemente hagamos un queso entero público. Esto va a obtener retorno, devolver queso. Y esto no tiene un set en este momento porque en realidad no necesitamos tener esto como set. Nosotros sólo queremos acceder al queso ahí. Entonces hagámoslo. Ella está, ahí tienes. Y ahora todo esto es genial y bueno, pero como puedes ver claramente, primero que nada, en realidad probemos esto y luego refactoraremos un poco del código porque probablemente muchos de ustedes dirán, quiero decir , yo clave- valor par, no sé lo que está pasando aquí en absoluto. Estoy muy confundido. Esto lo puedo entender. Primero que nada probemos esto. Vamos a refactorizar esto y luego te garantizo que va a conseguir mucho más. ¿ Qué vas a decir? ¿ Despejado? Se pondrá más claro. Ahí vas. Está bien. Yo creo que todo debió haberse hecho. Ahora esto es siempre, ya sabes, vamos, vamos a ver si todo funciona. Si esto es realmente realizable y vamos a ver. Entonces, en primer lugar, se ve bien. No podemos hacer clic en ninguno de esos, así que eso es realmente bueno, eso, esa es una buena señal. Ahora si agregamos un queso 10 haciendo clic en el plus, veamos si esto se puede hacer clic. Ahora, como pueden ver, en realidad sí lo hizo. Por lo que la clickability de actualización definitivamente funcionó. Teníamos este resplandor y si rondo sobre él, se pone un poco más oscuro. En realidad puedo maximizar esto rápidamente. Apenas se nota. Pero ahora debería poder hacer clic en esto y se sumará un 1 aquí. Quita el queso 10, vamos a hacer esto, llega a 20 y vamos a añadir queso continuamente. Entonces, veamos si eso funciona. Y todo funcionó. ¿ No es genial? Entonces eso es bastante guay. Ahora hemos agregado un nuevo edificio Clicker. Básicamente, también hemos ajustado el precio. Y una vez que lleguemos a 20 aquí, esto volverá a encenderse y deberíamos poder comprar el siguiente clicker. A ver si ese es el caso. Y ahí está. Podemos comprar hasta por el siguiente clicker. Y lo mismo debe de ir para la estación de ordeño. Entonces una vez que tuvimos 25, ahí tienes. Y si hago clic en esto, entonces esto también cambia el precio. También agregamos uno a esto, y ahora conseguiremos los cinco quesos cada dos segundos para eso también. Sí. Y solo para asegurarse de que esto funcione, van a y luego 40 funciona muy bien y verifican. Entonces eso es bastante genial en términos de una interfaz de usuario. Entonces esto realmente funciona ya. También desactivemos el maximizar en juego porque no necesariamente quiero eso cada vez. Y sí, Así funciona. Pero como ya he dicho, algunos de ustedes podrían decir: Bueno, quiero decir, eso está todo bien y bien, pero yo, no sé qué está pasando aquí. Está bien. Y ahora esto es una especie de, yo diría, sólo prettify esto. Entonces para que esto sea un poco más legible, en realidad vamos a agregar aquí algunas variables locales. La idea es que, bueno, está bien, Entonces tenemos esta clave de par de valor clave y ¿qué significa eso? No lo sé. De acuerdo, pensemos en esto. Este es un edificio. Entonces podemos en realidad, si tienes todo esto, podemos ver esto es un edificio porque por supuesto esta es la clave del, de nuestro diccionario. Y entonces podemos simplemente decir, acuerdo, hagamos de esto un edificio. Este es el edificio en especie de nuestro guardado aquí. Entonces el edificio dentro del como parámetro, ese es el edificio que se está construyendo. O porque esto se llama, el método se llama a un edificio construido. Entonces este es el edificio. En realidad podemos cambiar este nombre. Entonces vamos a renombrar este primer control, RR. Esto es edificio por construir, digamos. Entonces sabemos, vale, este es el edificio a construir. Y esto es algo así como un edificio seguro. ¿ O cómo podemos llamar a esto la llave aquí? Bueno, esto básicamente es sólo el tipo de edificio que usamos para buscar, ¿verdad? Entonces, solo llamemos a este edificio para buscar en este momento. No es el nombre más claro, pero creo que va a estar bien. Y esto es igual al par de valor clave Schottky, ¿verdad? Y entonces en lugar de usar esto, en realidad podemos usar esta variable aquí. Y luego construir para lookup, es como Ok, Ok, Entonces la clave es el edificio para lookup. Entiendo eso, eso tiene sentido. Ahora bien, ¿cuál es este valor? No entiendo cuál es este valor, ¿verdad? Entonces no es un tema. Este es un objeto de juego. Y recordamos que el diccionario es el edificio a panel de construcción. Entonces esto es simplemente un Gilbane Building paneles. Por lo que podemos decir GameObject building bill do panel es igual al valor clave, par de valor clave, valor de punto. Y ahora podemos ir aún más allá porque podemos ver, bueno, sólo usamos el transformador. En realidad podemos conseguir la transformación de esto también. Entonces podemos decir Transformar y decir básicamente el panel de construcción, transformación del panel de construcción es entonces igual a la transformación del punto del panel de construcción. Y entonces en lugar de sólo reemplazar esto, en realidad podemos reemplazar todo el asunto aquí con esta transformación aquí también. Y ahora veremos que, bueno, quiero decir, ambos tenemos aquí al 0th niño, así que en realidad podemos reemplazar esto también y luego incluso ir más allá. En realidad siempre estamos obteniendo el mismo componente de textos. Entonces, en teoría, podemos conseguir esto también. Y yo digo que sí, ¿por qué no? Por lo que en realidad podemos decir texto y decir, Este es el panel de construcción. Este sería el número del panel del edificio del texto del edificio. Entonces este es un nombre variable muy largo, pero no te vuelvas demasiado loco por ello. ¿ Por qué no tener esto? Y éste sería éste de aquí. Por lo que realmente podemos guardar esto ahí dentro y luego reemplazarlo por esto, y reemplazarlo por esto. ¿ Verdad? Y ahora, si bien podemos decir, bueno, quiero decir, también puedes juntar esto. Sí, pero si miramos esto ahora mismo podemos ver, vale, par clave-valor de valor de punto es el panel de facturación, bien, claro que ese es el panel de construcción que hemos hecho. Y luego obtenemos la transformación de la misma. ¿De acuerdo? Sí. De acuerdo, la transformación, Eso es básicamente lo que se puede decir. Bueno, está bien, tal vez esto se pueda borrar y podemos decir, bueno, en realidad construyendo panel. Es decir, sé que lo que es el panel del edificio. Entonces vamos a conseguir este. Entonces esto porque la transformada y el GameObject son muy similares entre sí. Entonces puedes decir: Vale, la transformación de la pena de construcción, voy a conseguir eso, eso está totalmente bien. Y entonces la cosa es que entonces voy a conseguir que el texto se asocie. ¿ Qué tipo de texto es? El panel de construcción número de edificios textos? Sí, claro, esto es esto me dice cuántos edificios de un edificio en particular se ha construido. Y luego simplemente analizamos el texto de esto, y luego leemos un re-guardar el número que estaba ahí más uno en él. Y esta es básicamente una manera muy fácil, digamos que cambiemos esto y ser L2, leamos esto un poco mejor. Entonces hagamos este y cambiemos también esto por edificar, para construirse. ¿ Verdad? Y luego tecla baja, pero sólo en iguales. Tenemos la transformación edificable aquí también, pero sólo la necesitamos una vez. Por lo que en realidad no necesitamos obtener el texto en este caso. Creo que esto estaría totalmente bien. Y esto tiene mucho más sentido. Se puede, por supuesto, también por cierto, hacer lo mismo con, por ejemplo, este costo aquí, ¿no? Entonces se puede decir, bueno, quiero decir, en realidad, cuando pensamos en esto, ¿cuál es el costo de este edificio para construirse? ¿Qué es esto? Este es en realidad el nuevo costo que queremos tenerlo. Por lo que sólo podemos decir nuevos costos y en realidad podemos poner esto de inmediato en una cadena. Eso es aún mejor, nuevo costo cuerda No.2. Y entonces podemos pensarlo y ponerlo aquí. Entonces se vuelve aún más fácil de leer. Y decimos que el costo nuevo es igual al edificio real que se está construyendo costo porque eso ya se ha actualizado para nosotros. Y entonces conocemos nuestro caso. Simplemente tomamos los textos reales, son una actualización con el nuevo costo. Por lo tanto, el costo de actualización tiene sentido. Actualización clickability, muy similar a ésta. En este caso, en realidad podemos simplemente conseguir el edificio aquí. En realidad nosotros sólo el edificio necesitamos el. A GameObject en este caso. Por lo que en realidad queremos cambiar un poco esto. Entonces este es el objeto del juego, este es el panel de construcción. Y luego al final, en lugar de escribir GameObject, también podemos simplemente IR y luego decir valor de punto. Y entonces éste va a poner aquí. Por lo que el panel de construcción GameObject dot get Componente intractabilidad botón. También podemos conseguir el botón de inmediato. Creo que esto está bien por ahora. Y luego todo este calvario aquí, definitivamente deberíamos hacer un booleano con éste. Entonces este es el Bool en problemas en acto de terror. Podrían ir. Y entonces podemos simplemente poner esto aquí. Y, y de esta manera. 70. (Clicker de queso) crear mejoras: Está bien, sigamos con el clicker de queso aquí para el curso de unidad. Y en esta conferencia vamos a crear un sistema de actualización muy, digamos, fácil que puedes implementar. Una vez más, inspirándose en Cookie Clicker, donde también puedes obtener ciertas mejoras que se aplican a edificios específicos. Y vamos a ver si podemos crear algo ahí. Entonces, en primer lugar, vamos a crear una nueva carpeta dentro de nuestra carpeta de scripts llamada upgrades. Y ahí dentro tendremos el script de actualización bellamente llamado. Entonces la carpeta siendo plural y la clase real siendo sólo singular. Ahora esto no estará heredando del comportamiento moral y va a ser dentro de actualizaciones. Bueno, sin el punto y coma Diego. Y hay un montón de cosas que tendremos que añadir aquí. Entonces vámonos. Entonces en primer lugar, ya he preparado algunas ideas de un tipo de actualización que vamos a tener y estos se van a guardar a la vista de Un tipo de actualización enum. Y esos serán el clicker de bronce. Tendrá el clicker de plata. Tenemos el clicker de oro, el platino, platino Flickr, así como la leche de bronce. Por supuesto, podrías haber adivinado la leche plateada. Y si conoces a los otros, obtendrás una galleta u otro trozo de queso, leche de platino. Ahí vas. Esos son todos los tipos de actualizaciones. Vamos a hacer una construcción muy similar a la que hemos hecho con los edificios. Entonces donde tenemos una lista estática privada de tipo upgrade dentro de aquí, que va a ser todas las actualizaciones. Y entonces tendremos esto dentro de una propiedad estática, que también es una lista de upgrade llamada todas las actualizaciones, upgrades. Y vamos a tener un getter aquí que va a hacer volver todas las actualizaciones. Y si ese no es el caso, entonces lo que queremos es que queremos generar esos. Entonces vamos a tener otra lista pública estática de actualización. Generar todas las actualizaciones, actualizaciones que hace. Y esto es entonces exactamente el público no está escrito correctamente. Se van público estático, generan todas las actualizaciones. Y esto es básicamente exactamente lo mismo que hemos hecho con la lista de edificios dentro de la clase constructora. Por lo que este es el resultado igual a nueva lista de edificios. Devolvamos este resultado. Ve. Y luego llenaremos esto lo suficientemente pronto. En primer lugar, hagamos el cheque aquí. Entonces si la variable estática real es igual a null, entonces nosotros, en primer lugar tenemos que establecerla con exactamente el método all upgrades. ¿ Verdad? Esto es como dije, algunos de ellos ya lo hicimos por los propios edificios. Entonces esto no debería venir como demasiado loco de una sorpresa. Ahora viene la gran pregunta, bueno, ¿qué tipo de cosas hay dentro de un grado de laboratorio? ¿ Qué es lo que son las propiedades de una actualización? Bueno, antes que nada, obviamente vamos a tener un tipo de actualización, ¿verdad? Y esto va a ser un tipo de actualización con un getter y un conjunto privado. ¿ Por qué no? Entonces también tendremos un modificador público. Este es el modificador, modificador, el 0. Este es el modificador que vamos a tiempos fueron a multiplicarse con la ganancia de queso real que tendremos. Entonces este es el modificador de B, tendrá un eso. Entonces también por supuesto tenemos un costo asociado a ello. Conjunto privado aquí. Y luego otra cosa, y eso sería un bool público y eso se llama es un bot. Entonces esto simplemente comprueba si este particular se ha comprado o no ya que las actualizaciones que vamos a estar creando aquí sólo podrán ser compradas y luego se han ido. Y luego para estas cosas, por supuesto, también necesitamos un, necesitamos generar un constructor muy agradable. Podemos hacer esto, por supuesto, presionando Punto de control Control. Es Puntos de control por supuesto Generar, Constructor y tipo de. Esas son exactamente todas las cosas que quiero aquí. Y también hay una cosa más que queremos. En realidad, me olvidé por completo de eso. Vaya, eso es vergonzoso. Tenemos que saber para qué edificio es este. Por lo que en realidad queríamos empezar a usar el espacio de nombres de los edificios clicker de queso dot. Y luego queremos una bodega de edificio para edificar. Y esto tiene un get y un conjunto privado otra vez. Y esto es entonces aquí también. Entonces edificando. Y luego para construir, ¿verdad? Y no queremos se compra por cierto, porque eso es algo que siempre es falso al principio. Y luego para la construcción, va a ser para la construcción, para la construcción, para la construcción. Está bien. ¿Qué es esto? ¿ Cuál es el proceso de pensamiento detrás de él? Bueno, por supuesto, una actualización siempre es específica para un específico a un tipo de edificio. Es por ello que esto tiene aquí un referente de edificación. Y el se compra simplemente dice, vale, es falso al principio. Y luego una vez lo compramos, así una vez que se enfríe el vacío público por método, y vamos a decir que se compra es igual a falso. Más bien cierto. Perdón, ahí va. Por supuesto, ahí tienes. Entonces una vez que compramos esto, esto se compra. Y con esta pizarra básicamente comprobamos, bien, podemos especie de que compramos lo que solo queríamos tener este soviético sabemos, vale, esta actualización se ha comprado y esta al alza no se ha comprado. Y en el futuro, por ejemplo, podríamos decir, Hey, todas las actualizaciones compradas y luego filtrar fácilmente para se compra en eso, esa sería una de las cosas de Of que podemos hacer. Pero ahora realmente podemos crear esas actualizaciones dentro de esta lista aquí. Ahora lo que voy a hacer es realmente copiaré. En realidad voy a crear una nueva actualización aquí, y luego voy a copiar sobre el resto de ellos porque son un poco más complicados que los edificios. Por lo que tenemos resultados dot add, y luego una nueva actualización. Y ahora en lugar de esta actualización, primer lugar necesitamos una actualización tipo bronce Clicker. Entonces queremos el modificador, en este caso, el motor Fuego por ejemplo. En realidad volvamos esto. Entonces primero que nada obtengamos el costo y luego el modificador, lo contrario, la copia no funcionará. El costo, digamos que el bronce cuesta 25 y en realidad duplicará las cosas que vamos a obtener del click real. Y entonces para qué edificio? Bueno, podemos conseguir los edificios una vez más haciendo edificio, un edificio instancias. Y luego un 0 aquí. Porque esto por supuesto funciona porque esto una vez más es el clicker y esto es específicamente para el clicker. Y ahora en realidad podemos simplemente copiar. Esto en realidad es bastante fácil también. Y decir clicker de plata. Éste entonces cuesta, digamos 500. Entonces esa es una manera más de un costo. Y luego también duplica el, duplica la ganancia de queso. Y luego tenemos el clicker de oro. Este cuesta 1000, 500. Esos son, por supuesto, números arbitrarios, ¿verdad? Puedes elegir las tuyas y cambiarlas también. Y este va a ser el clicker platino con 5000 y esto va a veces por ello. Ahora, esos son por supuesto, multiplicativos. Entonces si tengo el bronce y el clicker de plata, vamos a sacar cuatro veces más quesos de él. Y luego si tengo esto, entonces vamos a mirar ocho veces y luego vamos a conseguir 32 veces si tengo todas las actualizaciones. Por lo que esos escalan muy rápido en realidad. Ahora, los otros los voy a conseguir en realidad y lo haremos de una manera diferente. Entonces, y nosotros en realidad, como se puede ver, Colección es inicialización. Ahí tienes, se puede simplificar. Y sólo vamos a hacer clic en esto y vamos a ver que esto se ve un poco diferente a lo que hemos visto antes, pero en general no debería ser demasiado loco. Entonces básicamente solo tenemos la en especie de inicialización en línea aquí. En lugar de agregar aquellos con el método add, solo podemos tener esto aquí. Y luego hace que mi trabajo sea un poco más fácil simplemente copiando esto por aquí. Esto es construir instancias. El ejemplar no funcionó del todo. Ahí vas. Eso es lo que es, ¿verdad? Por lo que una vez más, puedes por supuesto, elegir tu propia actualización a costos y modificadores aquí. En nuestro caso también el modificador sería un entero. Porque empezamos con una entrevista. Por supuesto, ambos pueden convertirlo en un flotador y luego básicamente solo tener el resultado más adelante. O sellarlo o hacerlo o florido, ¿verdad? Para que lo puedas redondear hacia arriba o hacia abajo. Pero ahora mismo creo que esto está bien como ejemplo, digamos. Y lo último, Hay dos últimas cosas que queremos. Bueno, una de las cosas que queremos es. Y básicamente queremos un método estático que nos permita básicamente obtener los modificadores relevantes. Entonces este es el modificador relevante. Y esto es para un edificio en particular en este caso. Entonces, ¿qué hicimos, qué queríamos aquí? Bueno, básicamente, en primer lugar, vamos a hacer modificador igual a 1 y luego devolver modificador. Entonces la idea es que dado un edificio en particular, queríamos el modificador que se asocia con él. Entonces si tenemos el Bronce click en el Clicker plateado, entonces si damos este método en el edificio clicker, entonces lo que queremos recuperar es básicamente el modificador que necesitamos aplicar a esto en ese caso entonces para, entonces, para eso vamos a hacer un nuevo for-loop que pase por todas las actualizaciones, conteo de puntos. Y una vez que pase por toda la óptica subiendo grados, lo que vamos a hacer es que vamos a preguntar, vale, si la actualización real que estamos buscando en este momento, en realidad no podría ser. Sí, vamos a hacer un bucle foreach en realidad eso es un poco mejor. Por lo que esto sería actualización. Enfriado, distinto de cero, lo siento. No, todavía no está bien. Actualización. Está bien. Hagámoslo así. Actualizar, actualizar en todas las actualizaciones Operará el ego. Yo lo que vamos a decir es si la actualización es para construir, así que si conseguimos el edificio y luego vamos a hacerlo, lo que vamos a hacer es que vamos a usar el método get type. Esto simplemente, básicamente puedes obtener, tomar el método de tipo de get llamado igual en esto y luego decir que el punto de construcción también obtiene tipo. Y esto entonces compara el tipo de tipo, la clase en realidad así con esta madera, por lo que hay un tipo de punto de sistema, como se puede ver, que es el tipo de retorno. Y eso simplemente una comparación de la clase o del tipo de datos, por así decirlo. Por lo que compara si este edificio que se estaba dando es o no, por ejemplo, el clicker. Y si esos coinciden, terminan, se compra la actualización. Entonces eso también es algo importante. Entonces ahí es donde preguntamos si spot o no. Entonces lo que vamos a hacer es modificar nuestros tiempos iguales modificador de puntos de actualización. Ahí vas. Entonces en realidad podremos multiplicar el modificador a ella. Sí, en general, quiero decir, esto no debería ser demasiado loco. Solo estamos buscando el edificio en particular. Si las mejoras ahí han sido compradas y si han sido compradas para este edificio, entonces simplemente agregaremos o no agregaremos esto al modificador, pero lo multiplicaremos al modificador, ¿verdad? Y para agregar también esto, para que esto realmente consiga algo funcionando. Tenemos que cambiar el clicker y la estación de ordeño aquí. Y esto en realidad no será demasiado loco. En realidad simplemente hacemos un total que ha ganado aquí, y esta va a ser la ganancia de queso que tenemos. Por lo que la piel de oveja de la estación de ordeño, este caso veces. Y luego vamos a hacer uso. Actualizaciones de punto de Flickr, necesitamos estar usando ese espacio de nombres. Entonces dentro de aquí podemos ver actualizado enseñado, obtener modificador relevante para esto. Y por eso me gusta ese método creativo, porque eso hace que sea muy fácil hacer esto. Y entonces sólo podemos decir ganancia total de queso. Y podemos copiar esto más, poner esto aquí, y luego decir también ganancia total de Cheese. Se van. Y también asegurándonos de que estamos usando el espacio de nombres correcto apareció. Ella es clicker dot upgrades. Ahora mismo el flujo de efectivo en sí debería funcionar ya. Por lo que modificar el flujo de efectivo por las actualizaciones aquí debería funcionar totalmente bien. El único tema es que aún no podemos comprar las actualizaciones y estamos a favor de eso vamos a hacer una nueva actualización. Tú yo en realidad ahora Hagamos esto. Sólo por el infierno de ello. Entonces te escucho. Yo así esta es la UI de actualización. Voy a hacer esto un poco diferente. Sé que eso fue un poco demasiado rápido. Ahora va a abrir otra instancia visual de Studio. Tan sólo un segundo. A go. Cerremos esto otra vez. Gracias. Entonces abre esto en el correcto, por favor. Ahí vas. Esto es por supuesto, bajo tu ojo y definitivamente estaremos usando el namespace de actualizaciones de punto de queso clicker. Déjenme echar un vistazo rápidamente aquí. Entonces lo primero que vamos a necesitar es una lista pública de Sprite. Entonces ahora vamos a tener en realidad unos sprites asociados a ello. Esos por supuesto, están disponibles como recurso y los vamos a ver en breve. Entonces vamos a tener un diccionario similar a los edificios. Vamos a tener una actualización al diccionario de objetos de juego aquí. Y también lo vamos a llamar así, actualizar a un objeto de dos juegos. Objeto. Van con un getter y un sector privado. Y luego por último pero no menos importante, tendremos un objeto público que va a ser el prefab de UI de actualización. Pero no vamos a tener esto con un año de subrayado, así como este. De acuerdo, En primer lugar, el diccionario de objetos de juego de actualización se inicializará aquí en el método de inicio. Y entonces tendremos una. Entonces lo que vamos a hacer es antes dentro del panel de edificios, en realidad agregamos la penalización particular nosotros mismos, así que de forma manual. Y ahora vamos a tener básicamente los particulares generados esta vez. Entonces vamos a decir panel, y sólo vamos a añadir un pequeño panel aquí abajo. Y básicamente vamos a generar esos. Entonces vamos a esto sería el panel de actualización. Panel de actualización. Ahí vas. Vamos a añadirle la interfaz de usuario de actualización. Y luego añadamos también los sprites. Entonces hagamos en lugar de nuestros sprites una nueva carpeta. Estas serán las actualizaciones. Hagamos también una nueva carpeta llamada edificación de edificios, y simplemente sumamos todos nuestros sprites a ellos. Y dentro de las mejoras, vamos a sumar todas las cosas doradas. Como dije, todos esos están disponibles como recurso. Copiamos esos más y dejame que me revisen rápidamente, ¿verdad? En realidad no necesitas cambiar nada por ellos. Como puedes ver, Bronx resbalón o máquina de fundición equivocada, Flickr, esa máquina. platino y la plata también. Sí. Por lo que una vez más, esos están por supuesto, disponibles como recurso. Y luego veamos, panel de actualización. Entonces básicamente, en realidad no queremos crear nada loco año. Y con la creación, soy realmente malo como si vamos a crear esto. Por lo que la interfaz de usuario de actualización en sí no debería estar demasiado loca. Tendríamos que crear éste. Entonces tenemos el prefab y luego básicamente podemos poner el prefabricado ahí. Entonces esto simplemente va a ser una imagen de ésta. Entonces esta es una imagen. Hagamos esto un poco más pequeño. Eso probablemente va a estar bien. Y entonces esta imagen va a ser la UI de actualización. Y esto también tendrá un botón asociado. Entonces esto va a ser un botón aquí. Y creo que eso ya es todo básicamente. Y entonces simplemente necesitamos cambiar cosas en él. Entonces la actualización tus islotes, pon esto dentro del prefabricado aquí. Entonces como prefabricado, ahora, está aquí. Y podemos entonces básicamente eliminar y asegurarnos que el prefab de UI de actualización aquí se establece dentro del script. Y entonces creo que esto debería ser todo. Entonces simplemente necesitamos crearlo haciendo un nuevo método, vacío privado crear, actualizar UI con un índice en particular aquí. A ver. Ahí vas. Porque queremos llamar a este método dentro de un bucle for. Entonces básicamente voy a pasar por todas las actualizaciones particulares que tenemos. En realidad todas las actualizaciones en especie del fin de semana en realidad ya hacen esto. Entonces para bucle con i y luego esto es actualización, actualizaciones, conteo de puntos. Entonces vamos a pasar por todas las actualizaciones, actualizaciones, o golpear su diagonal. Y vamos a decir Crea, califica tus ojos. Yo voy. Y dentro de aquí vamos a crear esto. Así que el objeto del juego 30, o digamos que el término de actualización es igual a instanciar estos prefab de interfaz de usuario con la ayuda de esta transformación aquí. Voy a decir que la actualización va a ser. Entonces, en primer lugar, obtener imagen de componente. Necesitamos el paquete de interfaz de usuario aquí, por supuesto. Por lo que usar Unity motor wi, eso sería muy bueno. Y luego la imagen, realmente no hemos visto esto como dije antes, pero esto va a estar bien. Por lo que el sprite aquí se puede configurar igual que con el, básicamente el renderizador sprite sprite. Y entonces este sería el índice. Entonces sólo vamos a conseguir el sprite en un índice en particular aquí. Y luego vamos a hacer algo que no hemos visto antes. Y básicamente vamos a cambiar lo que sucede cuando presionamos el botón. Entonces antes de que hayamos visto es acabamos de agregar el. A funcionalidad de botón por si miramos esto, si miramos esto, También hay tiene un botón. Agregamos el onclick y tuvimos lo particular aquí y friamos un método o función en particular ahí. Pero lo que vamos a hacer ahora es que en realidad vamos a hacer esto vía código. Y para ello vamos a conseguir aquí el componente de botón. Entonces botón onclick. Entonces esto es exactamente lo que teníamos ahí y movimiento de carbón agregar oyente. Y así este oyente de anuncios, necesitamos agregar una nueva expresión lambda. Entonces esto simplemente si me cierro sobre esto, como pueden ver, se trata de un llamado de acción de unidad. Y lo podemos hacer como expresión lambda. Entonces todo lo que pongo después de esto es básicamente lo que se pone entonces. Por lo que actualizar todas las actualizaciones índice punto por. Entonces quiero llamar al método aquí para esta actualización en particular, uno cuando se hace clic en esto. Y lo que también quiero hacer es que quiero establecer el objeto real del juego en sí mismo. Por lo que la actualización es el objeto de juego establecido activo en falso para que básicamente se desvanezca. Y luego por último pero no menos importante, quiero actualizar a GameObject el diccionario. Yo quiero agregarle las actualizaciones reales. Entonces antes que nada, quiero decir, sí, está bien. Es decir, eso no está tan mal. Todas las actualizaciones. Indice aquí. Índice. Oh, no, eso no está del todo bien. Indice un go. Y luego también el objeto del juego, que se llama Upgrade. Ahí vas. ¿Verdad? Esa sería la creación de la UI. Ahora hay una cosa que es un poco, bueno, yo no diría un problema, pero va a crear todas las y's uno encima del otro, que por supuesto no es del todo lo que queremos. Lo que quisiéramos es por supuesto e, tenerlos como separados un poco. Entonces, solo probemos esto. Déjame ver que esto realmente debería funcionar ya y al menos generar esos. Por supuesto, necesitamos establecer aquí los sprites, y necesitamos ponerlos en el orden correcto. Entonces este es el clicker de bronce. Hagámoslo. Clicker. Y luego el clicker de plata. Creo que ahora esto ciertamente no funciona muy bien. Entonces hagámoslo como digamos que vas clicker de plata, y luego tenemos el clicker de oro y luego tenemos el clicker de platino. Sí, ahí lo tienes. Y luego por supuesto, la máquina de medallas de bronce, máquina de plata. Tenemos la máquina de leche dorada y luego por último pero no menos importante, el platino. Ahí vas. Por lo que estos por supuesto tienen que ser establecidos también. Y entonces creo que al menos debería generar los objetos reales del juego. A ver si eso ya funciona. Sí crea los objetos del juego. Ahora como puedes ver, todos están en la misma posición. Si entramos en escena como puedes ver, estamos en la misma posición. Tendrías que separarlos algo así. Eso por supuesto no funciona del todo. Esto no es del todo lo que queremos. Pero sí, ¿cómo funciona eso? Entonces, ¿cómo podemos hacer eso? Bueno, podemos, por ejemplo, decir, bueno, hagamos actualizar punto, transformar la posición de punto. Y entonces básicamente justo igual. Bueno, también podemos decir que plus es igual a nuevo vector tres. Digamos que alguien como Arnold, 15 F 0. Bueno, eso también funciona. 0. Ahí vas. Algo así. Veamos cómo se ve esa, si esto lo cambiaría o no. Pero es mejor tomar la posición local. Porque por supuesto estamos actualmente bajo Nueva transformación. Veamos si eso realmente funciona. Eso por supuesto moverá todo en este caso, porque necesitamos veces esto por el índice. Por lo que índice veces esto. Y esto definitivamente necesita ser un poco más. Entonces digamos algo así como 25. Ahora por qué, ¿Qué es esto? ¿Qué estamos haciendo? Bueno, básicamente dependiendo del índice. Entonces por supuesto para la primera actualización vamos a tener un índice 0. Entonces esto va a estar en, la posición en sí va a estar en los 000 000. Y luego la próxima actualización de término, la posición va a estar en 25 000 y luego el índice dos va a ser 50 000, 000 y así sucesivamente y así sucesivamente. Ahora esto definitivamente va a estar fuera del, fuera de este panel superior derecho. Vamos a básicamente bien, Es realmente necesita incluso un poco más, pero eso está bien. Básicamente podemos probar esto un poco y encontrar un número que funcione aquí. Tenemos que hacer esto, Digamos de una manera un poco complicada porque aún no hemos visto cómo podemos tener el diseño de una interfaz de usuario generarse a sí mismo. Esto es algo que vamos a ver cuando echemos un vistazo a lo real, lo que te decimos un poco más a fondo. Ahora mismo. Creo que esto va a estar bien. No se ve mejor, pero es funcional en este momento. Una cosa más que tenemos que hacer en la interfaz de usuario de actualización aquí, realidad queremos que este color resaltado sea un poco más notable. Entonces vamos, vamos a sumar esto aquí. Tenga en cuenta que no necesitamos agregar el servidor, está bien. Hagamos sólo colores normales, completamente blancos. Y luego este color resaltado un poco más oscuro. Y el resto de las cosas va a estar bien. Veamos si eso agrega un poco más de un efecto. Sí, ahora en realidad podemos ver si flotamos sobre esos, qué funciona. Y luego si hago clic en ellos, en realidad ya deberían funcionar. Ahora. Podemos hacer clic en ellos siempre, pero debería funcionar. Entonces, en realidad probemos esto. Entonces, solo vamos a conseguir diez queso en el clicker. Y ahora por supuesto, esto va a aumentar en uno cada segundo. Y si consigo el Clicker de bronce, entonces esto ahora debería aumentar en dos. Y como puedes ver, funciona perfectamente. Si hago clic en esto ahora debería aumentar en cuatro y lo hace. No se preocupe. Y ahora puedo, por supuesto conseguir los otros clickers también. Y yo iba a aumentar en 32, creo que fue cada segundo. Entonces eso es bastante loco. Entonces, como puedes ver, trabajando realmente, muy bien. Ahora por supuesto, lo que aún necesitamos es básicamente la comprobación de si esto realmente se puede comprar o no. Por lo que aún se puede comprar la actualización. Por eso. Por supuesto, lo único que realmente necesitamos hacer es que fuimos primero que nada, queremos poner a bien todas esas habilidades intactas, no ser intratables. Por lo que solo podemos hacer botón Get Component. En la tercera vez aquí, casi podríamos pensar en tomar esto y hacer una variable fuera de él. En este momento, no lo va a hacer porque no lo es. Necesario, pero esto sería algo que probablemente tendría sentido. Entonces sólo vamos a poner el botón para que no sea intratable. Y luego dentro de aquí, vamos a decir una vez más, cuando el queso cambiado en los tramposos cambiados va a ser actualización, actualización, click movilidad. Y esto va a hacer exactamente lo mismo que hicimos en el, vamos a implementar este método de generar. Pon esto en el fondo aquí. Lo mismo que hicimos con la UI de construcción en la clickability de Actualización. Entonces simplemente vamos a pasar por ellos rápidamente, vamos a copiar esto porque ya lo hemos visto básicamente. Sólo vamos a pasar por los pares de valor clave en los objetos del juego aquí. Y si esto es interactable, entonces interactuaremos con él. Si, si el interactable, si el costo es menor o igual a la nueva cantidad de queso que está disponible. Y ahora esto en realidad debería funcionar también. Hagamos el Buchla. En realidad deberíamos poder ver esto de inmediato. Sí, ahora el color está desactivado como puedes ver. Y una vez que tengo mis diez quesos, en realidad necesito 25, creo, para la primera actualización, luego se pone rojo o, ya sabes, se vuelve normal para que realmente podamos hacer clic en él. Y una vez que le hacemos clic, se ha ido y ahora el clicker está aquí. Pero como puedes ver, en realidad no quitó ni queso. Bueno, eso por supuesto no es lo que queríamos. Queríamos quitarnos nuestro queso. Entonces lo que podemos hacer es que podemos o bien agregarlo aquí o podríamos añadirlo dentro del botón Actualizar. Esto probablemente tendrá más sentido. Por lo que podemos decir almacenamiento de queso, instancia de punto, punto, quitar árboles. Y este sería este costo de punto. Y eso ya es lo que nosotros, todo lo que realmente necesitamos hacer porque el método bind se está llamando de todos modos cuando compramos la actualización y luego el queso se va a restar de eso. Eliminado más bien, sí. Entonces vamos, ya sabes, o también puedes simplemente hacer el plus aquí, llamar a esto, y luego se quitan los 25 árboles. El upgrade, como se puede ver, la UI aquí se ha configurado para activarse básicamente porque se ha comprado el alcista, ya está hecho. Y sí, eso es básicamente cómo agregar las actualizaciones. En general, el juego en sí no se ve demasiado grande, y hay algunas cosas más, por supuesto, que podrían ser planchadas. Pero creo que esto es una especie de lo que les dejaría a estas alturas. Hay una cosa más. Ahí están los barriles, por supuesto, que se podría agregar. Esta es una especie de ejercicio sugerido que tengo también donde añades algunos más de tus propios edificios y si mas de tus propias actualizaciones basicamente. Pero esto es una especie de estado que te dejaría con este juego en particular. Se puede jugar en su totalidad. Y tal vez lo que vamos a hacer es cuando miremos la interfaz de usuario, quizá queramos cambiar algunas cosas aquí. Por lo que probablemente vamos a echar otro vistazo tanto a la actualización como al panel de edificios sólo para que esos se ordenen correctamente. Entonces al final de la sección UI de este curso, pero ahora mismo diría que esto es algo así para el clicker del xi. Espero que todo el proceso de construcción les haya sido útil. Sé que en algunos puntos fue fue mucho. Entonces no es que eso sea algo que puedas digerir de inmediato en su totalidad. Especialmente si eres completamente nuevo en la programación de Unity, entonces esto es probablemente, ya sabes, fue bastante. Pero ten la seguridad de lo que yo diría es que lo mejor que hacer, ya sabes, jugar con lo que tienes aquí. Yo diría que esta es una gran oportunidad para que solo agregues unos edificios. Haz algunas cosas que quieras hacer. Piensa en, tal vez algunas, algunas ideas que tú, lo que quieres agregar. A lo mejor lo que quieres hacer es que le vas a agregar algunos visuales más. Entonces si agregas, obtienes clickers, entonces tal vez aparezcan ratones reales como. Y si tienes, si haces clic en la estación de ordeño, tal vez quieras que se reproduzca el sonido o algo así. Entonces hay tantas cosas que podrías agregar aquí. Y quiero que uses este proyecto básicamente como una muy buena introducción como especie de una, es el tipo de juego, ¿verdad? Por lo que tienes una gran fundación. Creo que se puede ampliar. Y eso es una especie de lo que realmente es la idea del clicker de queso. Por lo que todo este proyecto básicamente. Pero sí, eso fue todo para esta conferencia y el propio clicker de queso, como dije, definitivamente vamos a volver a esto una vez más después lo hayamos hecho a través de la UI y luego vamos a hacer esto un poco. No diría que más bonita, pero que sea un poco más fácil ordenar básicamente la propia interfaz de usuario. Pero eso sería todo por esto. Y como siempre, espero que te resulte útil. Y si hay alguna pregunta, entonces siéntete libre de preguntar y me aseguraré de responder. Y sí. 71. (Unity UI) añadir un lienzo: Muy bien, Bienvenidos a la Unidad ustedes, les presento aquí para el curso de unidad. Y en esta conferencia, vamos a echar un vistazo a lienzos o al objeto del juego Canvas, digamos. Y en primer lugar, por supuesto, en un nuevo proyecto, como siempre, vamos a crear nuestra buena carpeta de guiones viejos. Y luego pongamos de inmediato en una carpeta nueva, L1. ¿ Puede esto, sólo llamémoslo Lienzo. Eso está bien. Y ahí, Hagamos inmediatamente el guión también. Ahora el guión no va a ser en realidad tan interesante en este caso, porque normalmente esto es algo que personalmente he visto. Realmente no cambias tanto los lienzos. Al menos realmente no cambio muchas cosas en Canvas a través de guiones. Pero he preparado algo aquí donde tenemos algunos comentarios más adelante abajo de la línea después de que terminemos con esto. Por lo que no se necesita el método de actualización. Y vamos a ver esto muy pronto. Pero ahora mismo lo que vamos a hacer es que realmente vamos a añadir un lienzo a la escena. Entonces vamos, en primer lugar, vamos a, vamos a cambiar el nombre de esta escena a L1 Canvas puede esto, y luego recargar esto. Entonces ahora estamos en L1 Canvas y haciendo clic derecho en UI y luego agregando un lienzo aquí abajo. Ahora, ya hemos visto un poco de esto cuando agregamos el texto en la interfaz de usuario muy simple, mira, digamos que lo son. Agregamos el texto y el Canvas se generó automáticamente. Entonces eso fue algo que fue interesante. Pero ahora, en realidad, veamos aquí los componentes del lienzo de Canvas. ¿ Qué tenemos? Entonces, en primer lugar, tenemos el modo aleatorio. Y hay tres modos aleatorios disponibles. Ahora. Anteriormente en realidad lo hemos puesto a la cámara espacial de pantalla. Pero ¿qué es la superposición de espacio de pantalla? Bueno, por supuesto el default con el que empieza. Y la idea es que se podría poner como exhibiciones head-up aquí. Y esto siendo un modo de superposición básicamente. Para que podamos alejarnos un poco. Como puedes ver, esto es gigante, ¿verdad? Entonces este es un lienzo gigante en este momento porque es exactamente del tamaño aquí. Y sólo para que tengamos algo que ver, sólo podemos añadir un texto aquí, lo contrario ni siquiera vemos nada. Hagamos como un texto gigante aquí en el medio para que al menos tengamos algo en el lienzo que podríamos ver. Ahora, como se puede ver aquí, los textos en realidad muestran la capa correcta en el medio de la cámara. En este caso, porque la superposición es exactamente eso. Se trata de una superposición en la pantalla básicamente. Por eso, ya sabes, tan columpios como las pantallas de cabezas arriba. A lo mejor cuando tocabas a Minecraft, conoce el Tao, el pequeño bar en la parte inferior, algo así, ¿verdad? Entonces head-up displays que podrías usar para mostrar algunas cosas, Ahí es donde podría funcionar la superposición basada en pantallas. El espacio de la pantalla cámara, en cuanto estamos poniendo eso y muestra elegir la cámara principal aquí. Como veo, se pone muy, muy pequeño. Además, lo que es muy importante en cuando estás en superposición de espacio de pantalla, no puedes. Cambia aquí la transformación directa para que no puedas cambiar el tamaño del lienzo en sí. Aquí. No obstante, aquí también se puede escribir, por lo que algunas cosas las hace el lienzo. Esto se debe al factor de escalado, que vamos a ver en un rato. Y así en este momento nada realmente ha cambiado. Como se puede ver, la idea de las superposiciones de que esto funcionaría para cada cámara. Y esta sólo funcionaría para una cámara en particular que eres. Básicamente poniendo aquí. También la superposición, superposiciones sobre todo y la cámara de espacio de pantalla. En realidad puedes buscar esto. Ahí vas. En realidad puedes poner ahí la distancia del avión y también tener allí una capa de pedidos también. Tan correcto. Por lo que esos son todos básicamente renderizados a cierta distancia de la cámara. Esto personalmente es una preferencia mía. Normalmente casi siempre uso la cámara de espacio de pantalla. También hay un espacio mundial y va a espacio, como se puede ver, ahora podemos realmente cambiar el directo aquí. Y si entramos en el Lienzo y lo movemos, y tú vas a ver eso, vale, el lienzo está ahí. Pero si ahora realmente muevo la cámara a la derecha, como se puede ver que Texas ahora especie de en el espacio mundial. Entonces ahora si tenemos este espacio mundial, entonces el lienzo real es un GameObject que es parte de un mundo. Podrías, por ejemplo, imaginar si tienes enemigos caminando por ahí y tienes como barras de salud o una barra de nombres por encima de su cabeza. Eso, por ejemplo, funcionaría con este nodo aleatorio espacial mundial. ¿ Verdad? Volvamos al espacio de pantalla aquí sólo por el bien de la discusión en este momento. Y sí, el resto debería ser casi autoexplicativo. Por lo que la distancia del avión es sólo la distancia del, básicamente la posición y. Por lo que esto volvería a tomar en cuenta el plano de recorte de la cámara principal, que ya hemos visto. Pero así si alguien está más cerca de 0.03.3, entonces no se renderizará. Entonces éste es exactamente éste. Y la distancia de avión aquí, un 100 estaría bien. En orden en capa funciona también con el renderizador sprite. Entonces si esto está por debajo de un determinado renderizador sprite que un componente de otro objeto de juego, entonces estaría por encima de eso. Si está por debajo de esto, entonces no, estaría por debajo de esto. Entonces esto funciona exactamente así también. También puedes poner aquí canales adicionales de trader. Realmente no he jugado por ahí con esto demasiado. Y así en este momento, no me preocuparía por ello. El escalado, sin embargo, eso es en realidad, hay una cosa más, este pixel perfecto. Casi lo olvido. Eso en realidad es algo importante. El pixel-perfecto es, como puedes ver, está disponible tanto en los espacios de pantalla, pero no en el espacio mundial, modo aleatorio. Y el pixel-perfecto básicamente se tuvo la idea de que el Canvas se alineará con los píxeles perfectamente. Por eso es pixel perfecto. Y si habilita esto, básicamente puede hacer que ciertos elementos sean más nítidos y evitar la borrosidad en los elementos. No obstante, lo que realmente importa es si tienes una especie de animación dentro de tu lienzo. Y Tus elementos, básicamente los elementos de la interfaz de usuario, entonces podría ser mejor si lo desactivas porque puede ser suave o sin él. Porque si tiene que alinearse perfectamente con el píxel, entonces el movimiento a veces puede ser un poco inactivo. Pero normalmente eso está bien. Sí, eso sería todo para el lienzo en sí. Después viene el escalador de lona, que es realmente el pan y la mantequilla aquí. Por lo que el modo de escala de UI, son tres de ellos también, tamaño de píxel constante, tenemos escala con tamaño de pantalla y tamaño físico constante. Entonces, ¿por qué tenemos que preocuparnos por el escalado de cualquier cosa? Bueno, veamos esto. Entonces tenemos la ventana de juego aquí ahora mismo, ¿verdad? Si nosotros, por ejemplo, fuéramos a sacar esto y si realmente puedo lograrlo, sí, ahora tengo esto de forma independiente, así puedo escalar esto ¿verdad? Y como pueden ver, bueno, eso está todo bien y bien, el texto real se queda ahí sin importar lo que haga. Entonces eso en realidad no está tan mal ya. Pero lo que esto tiene es que esto tiene un tamaño de píxel constante, por lo que esto se mantendrá así. Y porque la resolución aquí es tan alta, eso no es un tema. Pero si decimos vamos a ir a tres aspectos. Ahora, este es nuestro real Déjame ver. Vámonos. Sí, baja resolución. Entonces como puedes ver ahora, bueno, es del mismo tamaño de píxel, sea cual sea el aspecto. Entonces si estamos en, Hagamos no, no más bajo. Entonces 1609 y 1610, bueno, funciona un poco mejor, pero no realmente. Entonces como puedes ver, dependiendo del tamaño ahora, porque ahora el aspecto tiene que ser el mismo. Los textos reales, no hay realmente escalar muy bien a lo que tengamos. Entonces si tenemos una pantalla telefónica, quiero decir, entonces todo solo, no funciona. Por lo que se puede usar un tamaño de píxel constante, ¿verdad? No obstante, como dije, los elementos de la interfaz de usuario que están debajo en este lienzo básicamente mantienen su tamaño de píxel independientemente de lo que haga la pantalla. Es para que no básicamente no van a escalar. El balanza con tamaño de pantalla es muy interesante. Y lo son, básicamente escalan con cierta resolución de referencia. Por lo general si tienes uno, 1920 por 1080 por ejemplo. Y entonces de repente, éste es muy interesante porque el aspecto siempre es de 16 a nueve. Pero como se puede, desde luego ve, ahí va. Ahora en realidad escala con él. Ahora sólo después de que en realidad haya tomado esto. Por lo que se puede ver que esto ya funciona bastante bien. También puedes mirar lo que se supone que coincida. Entonces, ya sea el ancho o la altura. También puedes ponerlo a 0.5 y luego básicamente lo va a hacer para que ambos coincidan con el ancho y la altura misma. Ahí. También puedes poner un expandir y también poner en encogimiento aquí si quieres. Normalmente lo guardo en, si puedo hacer que esto funcione, ahí tienes. Normalmente lo mantengo en 0.5 match con el modo de coincidencia de pantalla de ancho o altura. píxeles de referencia es. Veamos si realmente podemos conseguir cualquiera de los ego es un sprite, tiene los píxeles por unidad configurando de un píxel en el sprite, vamos a cubrir una unidad en la interfaz de usuario. Entonces eso en realidad debería ser mucho autoexplicativo. Si recuerdas, hemos mirado a los sprites y ahí pudimos establecer básicamente los Nuestros píxeles por unidad para algunos de nuestros sprites. Y el último es de tamaño físico constante. Entonces esto significa que en realidad mirará centímetros, milímetros, pulgadas puntos, o nos recogerá en el sitio en la pantalla. Esto significa que tomará el tamaño físico original. literalmente pudieras sacar una regla, ponerla en tu pantalla, y esto siempre va a tomar el mismo tamaño. Ahora en sus artículos realmente no se escalarán también. Pero si quieres, por ejemplo, algo que sea exactamente como una pulgada por una pulgada, algo así como en una pantalla móvil o incluso en una, en una pantalla de PC, entonces este sería el modo que necesitarías elegir. Personalmente creo que la escala con tamaño de pantalla es la que tiene más sentido. Todavía hace algo de funkiness, sobre todo si nos metemos en diferentes aspectos, ¿no? Porque ahora mismo hemos tomado un aspecto 1920 por 1080, que sería de 16 a nueve. Y si fuéramos a ir al 16 al 10, bueno, eso seguiría funcionando una especie de. Pero si es como locos o aspectos como si aquí tenemos un aspecto libre, entonces en algún momento, esto definitivamente va a fallar, como puedes ver. Entonces si tenemos como un más o menos un smartphone, entonces, ya sabes, no funciona del todo si, ya sabes, dependiendo de qué tipo de smartphone pudiera ser. Pero sí, en general, sigue siendo básicamente el escalador de lona ahí. Y déjame volver a poner la ventana del juego y ponerla de nuevo a, digamos 16 por 9 aspecto. Eso está bien, ¿verdad? Entonces esas son algunas de las cosas que podemos hacer aquí. Lo mejor, ya sabes, generalmente también obtienes buenos tooltips aquí también. Entonces eso en realidad también es muy bonito. Y también tengo esto una vez más, si solo abro el guión real, definitivamente te aconsejaría mucho que mires el guión que ya se ha hecho. Por lo que eso se proporciona en el, en el Paquete exportado porque esto tendrá básicamente todo esto dentro de él también. Y entonces por supuesto, también necesitábamos el Lienzo aquí arriba, el go. Entonces solo unos pequeños trucos y consejos y trucos básicamente. Entonces hay algunas cosas aquí solo para que entiendas cada una de esas cosas. Nosotros, por supuesto, también todavía necesitamos estar usando la interfaz de usuario de punto del motor Unity. Ahí vas. Y entonces el escalador de lona también puede ser accesible. Última cosa, o múltiples lienzos. Entonces hay un poco de debate dando vueltas básicamente. Está bien. ¿Es mejor si tienes múltiples lienzos o es mejor si tienes muchos? ¿ Un lienzo y todo está ahí? Bueno, depende, y esto es lo que pasa. que puedas pensarlo así. Si un elemento cambia, entonces todo el lienzo tiene que ser redibujado. Entonces si tengo como 1000 textos en este lienzo y cambian como cada segundo, no importa, aunque tenga 1000 cuadros en el cambio, no cambian. Todavía tienen que ser redibujados. Por lo tanto, tiene sentido. Tienes múltiples lienzos. Yo lo he llevado aquí. Por lo tanto, tiene sentido dividir elementos dinámicos y estáticos en diferentes lienzos. Entonces si tienes una UI que básicamente nunca cambia, entonces puedes ponerlo en un Canvas. Y luego la UI donde tal vez quieras mostrar tu salud o algún tipo de sistemas, entonces eso sería algo que pondrías en un lienzo que no cambia. Entonces dividiendo los elementos dinámicos y estáticos de la interfaz de usuario, ¿verdad? Pero eso ya sería para esta conferencia. No hay nada realmente para, de lo contrario para ver. También podemos simplemente agregar este guión al lienzo aquí. Pero no tiene sentido probar esto. Simplemente básicamente pone todo en cada uno de los modos posibles aquí, solo para que puedas ver que podrías, por ejemplo, poner esto o cambiar esto vía script. Yo personalmente nunca he hecho esto realmente. Siempre es una cosa que básicamente pones el lienzo en cualquier configuración que quieras y luego lo dejas en paz. Pero sí, tal vez tu kilometraje pueda variar. Entonces, ¿quién sabe? Pero eso ya sería para la conferencia de Canvas. Espero que hayas encontrado esto útil y aprendas algo nuevo. Como siempre. Si hay alguna pregunta, siéntase libre de preguntar. Me aseguraré de responder. Y sí. 72. (Unity UI) Paneles y texto: Muy bien, sigamos con la introducción de la UI de Unity aquí para el curso de unidad. Y en esta conferencia vamos a echar un vistazo a los paneles y al texto. Entonces lo que ya hemos visto en términos de textos fue un, sabes, agregar el texto y luego cambiarlo vía guión. Y los paneles hemos agregado lo que realmente no hemos hablado de esos. Entonces echemos un vistazo a eso. En primer lugar, no vamos a crear una nueva escena, pero vamos a duplicar este Control D mientras lo seleccionamos. Y entonces podemos hacer texto de los paneles L2. Claro, por qué no. Y luego también haga doble clic para básicamente abrirlo. Y en lugar de la carpeta de scripts, vamos a hacer una nueva carpeta, paneles L2 texto dentro de eso también. Por supuesto, un nuevo guión. También vamos a llamar el texto de este panel, ¿verdad? Y entonces realmente abramos esto también. Y vamos a cerrar el script de ejemplo de lienzo. Ya no necesitamos eso. No vamos a necesitar el método de actualización una vez más. Y dentro de aquí en realidad ya podemos empezar a usar el motor Unity wi namespace, porque ese es el espacio de nombres que definitivamente vamos a necesitar porque usaremos el ejemplo de texto. Hagamos texto de ejemplo. Eso está bien. Y luego vamos a ver cómo funciona esto en un rato. Pero primero, volvamos a nuestro lienzo aquí. Sólo eliminemos este texto. ¿Por qué no? Y luego agreguemos un nuevo elemento de interfaz de usuario. Y eso va a ser un panel aquí abajo. Por lo que un panel es básicamente sólo un telón de fondo con cierta imagen de fondo aquí. Y algunos ciertos, algunos específicos ya, ya saben, llenaron valores para ciertas variables aquí que Así que el color ya se pone un a sólo 100 en términos de opacidad. Entonces hay algunas cosas que se ponen aquí. Y básicamente debe actuar como una especie de telón de fondo, ¿verdad? Entonces si quiero decir que quiero tener como una UI aquí abajo, entonces podría ponerlo aquí. Y entonces como pueden ver ahora tengo una especie de marcador visual aquí, un fondo. Y eso es básicamente para lo que se usan los paneles porque ahora si agrego un nuevo elemento, el nuevo elemento de interfaz de usuario para trabajar al propio panel, entonces se agrega como niño al panel. Y como puedes ver ahora, es básicamente yo no diría que depende del panel. También puedo ponerlo por ahí, pero esa es una especie de buena forma de estructurar tu IU general. Deberías tener unos paneles y luego básicamente tener a sus hijos siempre encima de ellos. ¿ Verdad? Lo que podemos hacer es que podemos hacer algunas cosas frías bajo. Y eso sería lo siguiente. Entonces lo que quiero mostrarles es que ahora lo hemos puesto aquí abajo. Y con todo el escalado anterior y todo eso. Bueno, lo que podría pasar es que esto escalará con él. Entonces eso es bastante guay. Si tenemos ese aspecto libre. Ahora se ha ido, supongo. Bueno, eso no es eso no es lo mejor. Si puedo sacar la ventana del juego fuera de aquí, entonces lo que vamos a ver es que, ya sabes, funciona algo así, pero también como que no funciona como siempre. Entonces eso es un poco raro, ¿verdad? Entonces con los textos que funcionaron bastante bien, pero ahora si tenemos un aspecto libre, eso va a ser un poco de cerveza, y ahí es donde entra la Transformación Rect. Yo solo quiero mostrar esto rápidamente. Hay muchas cosas que básicamente podemos poner aquí. Pero como pueden ver, esto es absolutamente enloquecedor. Lee esto se ve loco. Y estoy de acuerdo con ustedes porque también podemos sostener Shift y sostener Alt para básicamente tener dos cosas diferentes. Por lo que podemos desplazar también establece el pivote y también debería establecer el posicionamiento. Por lo que básicamente podemos hacerlo para que quede anclado a cierto punto. Ahora en nuestro caso, lo que quisiéramos es que quisiéramos que esto estuviera anclado al fondo derecho? Porque hasta el punto final especie de llega a ser el, ¿qué dirías? Llega a ser el, el ancla y también el punto de referencia, ¿no? Entonces, así que esto se convierte en un punto de referencia. Entonces si yo estableciera, por ejemplo, esto así como el pivote al fondo, a la derecha. Entonces nada en este momento ha cambiado. Vas a ser como ellos, vale, que nada ha cambiado. Pero si ahora fuera a tomar esta ventana de juego una vez más afuera, ahora como pueden ver, aunque reescale esto, se va a quedar en la parte inferior de la pantalla. Y esa es una especie de también una de las cosas. Y se va a escalar con la pantalla real. Entonces esa es una de las formas en que también puedes facilitar la colocación correcta de tus elementos de la interfaz de usuario. En esto no tiene que ser paneles, también pueden ser textos y todas las demás cosas. Y por supuesto, si ahora lo hiciera, por ejemplo, si sostengo Alt, entonces también se fijará la posición. Y si pongo la posición en, por ejemplo, la parte superior izquierda, como puedes ver ahora se pone en la parte superior izquierda de su primer padre. Entonces no se pone, el texto en sí, no se pone a la parte superior izquierda del lienzo, sino a la parte superior izquierda del panel. Por lo que eso también es muy importante tener en cuenta sobre estos anclajes. Yo no diría que vamos a mirar eso demasiado más tiempo. En general. Pueden ser un poco desalentadores porque esto podría ser como, Oh Dios mío, ni siquiera sé qué está pasando aquí. Totalmente comprensible. Pero no me preocuparía demasiado por ello. Y por ahora, solo quería mencionar que básicamente se puede anclar el objeto del juego a una parte específica de la pantalla básicamente. Bueno, sigamos con el resto de la voluntad del panel, esto es básicamente una imagen como puedes ver. Por lo que esto tiene simplemente un componente de imagen. Antecos particulares. Entonces este es el fondo, el fondo del panel, y tiene un color predefinido. Y luego todas las demás cosas que también tiene una imagen. Entonces eso es básicamente lo que es el panel y el texto que ya hemos visto. Hay muchas cosas que te deberían ser familiares si has usado un programa de procesamiento de textos como Word por ejemplo, o no lo sé, como Google Docs. Se puede establecer una fuente. Se puede cambiar el estilo de fuente, el tamaño, incluso el interlineado se puede cambiar. Entonces hagamos esto un poco más grande. Por ejemplo, se puede cambiar el interlineado, que por supuesto no hace nada porque sólo tenemos una línea en este punto. Tenemos una alineación para el texto en sí. También podemos decir mejor ajuste. Entonces básicamente va a redimensionar el tamaño de la fuente a lo que queramos que sea. Podemos especificar un tamaño mínimo y un máximo. También podemos cambiar el color del texto real. Ahora bien, esto, por supuesto, también se puede cambiar todo a través de un guión. Entonces, solo pongamos el texto de los paneles en el objeto real del juego en sí. Y vamos a abrirla. Y sólo por el bien del argumento, digamos que el texto de ejemplo es igual a este punto get texto componente. Por lo que ahí el método de componente es una vez más utilizar el ejemplo text dot txt. Entonces esto es 1 segundo yo solo el cambio del texto a través de un guión que ya hemos visto antes, donde cambiamos el texto de 100 a 300. Y por supuesto lo que también podemos cambiar el color. Y entonces aquí podríamos, por ejemplo, decir al azar color de punto HSV, y luego tener esto en realidad, solo pongamos aquí el método de actualización también. Si input schottky down keycode dot c. Y entonces básicamente podemos cambiar el color de nuevo. En este momento, en realidad no voy a extraer esto a un método diferente. Yo sólo quería demostrar que esto es, por ejemplo, algo que también podríamos hacer. Ahora cambió vértice. Somos pantalla. Si presiono la tecla C, entonces el, el color del texto cambiará también. Entonces eso es bastante guay, en realidad. Un poco gracioso. Sí, pero esta es la forma normal en que básicamente podemos acceder a los elementos o a las propiedades de este componente en particular. Y sí, eso en realidad ya sería para el texto normal y los paneles. Y en la próxima conferencia realmente vamos a echar un vistazo a un texto mejor incluso. Y este va a ser texto Mesh Pro, que te aconsejo que uses en lugar de los textos normales porque a veces los textos normales pueden ser un poco. Bueno, quiero decir, yo sólo diría que no tiene tantas opciones. Eso es algo que vamos a ver en la próxima conferencia. Por ahora, Eso fue todo para texto y paneles. Como dije, los paneles en realidad no son nada demasiado complicado ahí. Tan sólo una imagen que debería ser usada como fondo y el texto. Bueno, ya hemos visto algo de esto. Y el resto es básicamente sólo normalmente accesible a través de un guión. Y algunas de las cosas. Por ejemplo, el mejor ajuste puede ser realmente útil para todavía cambiar el tamaño del texto a medida que avanza, ¿verdad? Entonces eso fue todo para esta conferencia. Espero que como siempre lo hayas encontrado útil. Y si hay alguna pregunta, siéntete libre de preguntar y me aseguraré de responder. Y sí. 73. (Unity UI) TextMashPro para un mejor texto: Muy bien, sigamos con la introducción de Unity UI aquí para el curso de unidad. Y en esta conferencia vamos a echar un vistazo al texto Mesh Pro. Este es básicamente un paquete que viene con la propia Unity, donde no podrías tener amina manera mejor control sobre tu texto. Entonces, solo duplicemos una vez más la escena de texto de este panel, controlemos D mientras la tenemos seleccionada. Y L3 va a ser, vamos a hacer texto Mesh pro. Sí, TMP, sonda de malla txt. Y también lo abramos, asegurándonos de que ésta sea en realidad la escena en la que estamos trabajando. Y vamos a añadir un nuevo texto Mesh pro al, a los candidatos. Entonces haga clic derecho en la interfaz de usuario del lienzo. Y en lugar de elegir texto, vamos a elegir texto, sonda de malla de texto. Y lo que debería pasar es que un año de ventana en particular debería abrir este importador de TMP que vamos a importar son lo esencial. Entonces simplemente haces clic en este botón y luego va a hacer algo, tal vez abra Visual Studio, pero eso en realidad no es necesario. Y ahí tienes. Por lo que ahora se debe importar. Como se puede ver aquí abajo, texto Mesh Pro. Y en realidad podemos cerrar esto de nuevo. Y ahora tenemos este texto en y luego entre paréntesis TMP aquí. Y como puedes ver, este texto de la interfaz de usuario se ve un poco diferente. Entonces esto no es parte de ella, pero esto es parte de ella. Bastantes cosas, como puedes ver que son diferentes. Entonces, en primer lugar, tenemos un poco más de dos para el tamaño de fuente. También tenemos unos cuantos activos más cariñosos. Esos vienen con materiales. Esos son, nos va a gustar rápidamente ignorar por el momento. También hay algunos textiles que podríamos elegir. Por ejemplo, encabezamientos, encabezamientos particulares. Aquí. Podemos tener cotizaciones, son título y cosas así. Hay ajustes principales. Esos son principalmente la fuente. Podemos tener subrayada la cursiva de escritura al estilo de fuente. Podemos incluso tenerlo a través de la línea, todo en una mayúscula grande, todo en minúsculas, algo así. tamaño también funciona justo de la forma en que funciona el auto size. Es un poco que no lo sé. Aquí no es tan bueno. Tienes que hacer a veces el inspector un poco más grande para que puedas elegir el Min y el máximo correctamente. color del vértice, una vez más , es simplemente el, lo real, vamos a deshabilitar los artilujos por un momento es simplemente el color del texto. En este caso, entonces también hay gradiente de color. Por lo que en realidad podemos poner en gradientes aquí también. Entonces no sé algo así como verde en la parte superior izquierda y luego tenemos como un rojo que son. Y luego como un azul lo son. Entonces como pueden ver, aquí podemos hacer algunos efectos locos. Si es necesario. También hay gradiente vertical y un gradiente horizontal o solo uno solo, ¿verdad? Podemos anular el impuesto. En realidad no estoy un 100 por ciento seguro de si la configuración de color anula la etiqueta de color. Nunca jugué por ahí con esa. Entonces ni siquiera puedo decir realmente qué es usado ese elemento para las opciones de espaciado. Entonces básicamente si tengo algo escrito aquí, probablemente también pueda hacer esto. Por lo que en realidad tengo aquí un editor normal. Y luego el espaciado, espaciado entre los personajes. Tenemos el espaciado entre las propias palabras. Tenemos el espaciado entre párrafos y yo estoy espaciado entre las líneas también. Por lo que las opciones de alineación son básicamente todas iguales. También tenemos la opción justificada, una opción de descarga, e incluso una opción de centro geométrico. Por lo que aquí también hay algunos más, además de tener línea de base, línea media y la línea de tope si eso es necesario. Entonces si necesitas mucho más, básicamente, el control sobre tu texto que el texto Mesh Pro es una necesidad. El modo de envoltura simplemente significa, vale, ¿cómo se envuelve este envolver? Entonces ahora mismo Eso no hace nada. Pero si lo habilito ahora, como pueden ver, automáticamente se envuelve a la siguiente línea aquí. Lo mismo con el desbordamiento. Hay algunas cosas que puedes hacer con el desbordamiento tienen elipses, están enmascarando, no hace nada trunca, así que simplemente no lo muestra. Entonces hay unas cuantas cosas ahí que puedes hacer. Y luego mapeo horizontal. Entonces, ¿qué aspecto tiene eso? En realidad no cambia nada en este momento. Pero lo que es realmente interesante son ahora los ajustes extra aquí. Entonces hay márgenes que puedes poner. Entonces básicamente el margen en términos del propio GameObject y hay alguna clasificación geométrica. En realidad no creo que esto haga nada, no. Y lo que es interesante, sin embargo, es el texto rico. Definitivamente usaría el Texto Rich, su general, eso es una especie de las cosas interesantes en los ajustes extra. Lo que es muy interesante aquí es también el material. Entonces el material, no vamos a entrar demasiado en él, sino el material que básicamente también cambia algunos de los, algunos del texto en sí. Entonces, por ejemplo, el color aquí también se puede elegir con el propio material. Y lo que también puedes hacer ahora es tener un esquema que es realmente, realmente genial. Entonces puedes, por ejemplo, tener aquí un esquema, como puedes ver, ahora este texto en realidad tiene un contorno o un calco base. Yo creo que esa es una especie de sombra, creo. A ver si puedo. Sí, ahí tienes. Por lo que en realidad vas a tener una sombra en tu texto también. Ahí vas. Esa sería la base, ¿verdad? Entonces hay algunas cosas que puedes hacer con este material, que también puedes cambiar. Por lo que el general, el texto Proyectos Mesh te da un enorme control sobre tu texto. Y también lo que suele ser un poco más agudo dentro del juego. Entonces si lo hiciéramos, hagamos esto un poco más grande aquí. Por lo general es legible. Un poco más legible, ¿verdad? Vamos también sólo por el bien del argumento, reabrir el texto de los paneles aquí y sólo voy a añadir el texto Mesh Pro, bueno, idea a ello. Por lo que generalmente hemos utilizado el texto esto no podemos comer más uso para otros libros de texto sonda necesitamos estar usando TMP Pro o TM Pro. Este es el espacio de nombres que necesitamos estar usando. Y para obtener el texto necesitamos estar usando texto de subrayado TMP. Entonces este es el TMP txt. Básicamente, hagámoslo así. Tmp txt. En realidad hagámoslo así. Sí, eso es mejor. Pero en general que el texto en sí es básicamente casi el mismo. Para que como puedes ver, podemos elegir el color del gradiente, habilitarlo y desactivarlo. Podemos cambiar la fuente y el punto txt una vez más es simplemente la cadena que se asocia con los textos. Por lo que cambiar el texto es lo mismo. Ahí vas. Entonces eso es todo lo que realmente necesitamos saber sobre eso importante que ya no usamos la clase de texto pero el TMP subrayan clase tributaria. Pero si tienes eso en mente que cualquier otra cosa es realmente lo mismo, todavía podemos cambiar básicamente todas esas cosas aquí dentro, como quisiéramos escribir y eso ya sería para esta conferencia. Apenas un rápido Mostrar que el texto Mesh pro text es básicamente un superior en casi todos los sentidos al texto. No obstante, si realmente solo necesitas usar cosas como símbolos, o realmente solo quieres depurar algunas cosas en términos de un texto de UI, entonces los textos normales también bastarán para eso. Pero sí, el TMP txt te dará mucho más control sobre cómo se ve tu texto, ¿verdad? Entonces eso fue todo para esta conferencia. Como siempre, espero que te resulte útil y aprendas algo nuevo. Si hay alguna pregunta como siempre siéntete libre de preguntar y me aseguraré de responder. Y sí. 74. (Unity UI) añadir imágenes a nuestra UI: Muy bien, sigamos con la introducción de la UI de Unity aquí para el curso de unidad. Y en esta conferencia vamos a echar un vistazo a imágenes de la interfaz de usuario o cómo agregar imágenes a tu ojo. Esto también lo hemos visto en un momento muy corto cuando estamos haciendo nuestra interfaz de usuario para el clicker de queso. Entonces lo que vamos a hacer es que vamos a, primero que nada añadir una nueva carpeta aquí, y esa va a ser nuestra carpeta sprites. Vamos a añadir el clicker. Por ejemplo. Usted por supuesto, también puede agregar un elemento diferente aquí. Por lo que se puede agregar un activo diferente. Y solo voy a establecer el modo de filtro a apuntar y la compresión a ninguna. Y entonces lo que puedo hacer es, por ejemplo, en este panel, primero que nada, por supuesto, duplicemos la escena. Esto serían imágenes L4. Abramos esto y vamos a nuestro panel en un nuevo elemento de interfaz de usuario. Y esa sería la imagen aquí. Y ahí está, la imagen. Y va a ser una locura, pero en realidad es bastante similar al renderizador sprite. Entonces si solo ponemos esto aquí, el sprite, como puedes ver, ahí está. Y quiero decir, eso es básicamente todo. Es decir, no quiero estar demasiado loco por ello, pero en general, esto es básicamente, puedes redimensionarlo aquí también. Entonces si vamos imagen, ahora podemos redimensionarla. Que sea, ya sabes, locura o simplemente normal. Ahora, también podemos, por supuesto, cambiar el color. Entonces esto es una especie de color de superposición encima de lo que sea el sprite real. Y eso es realmente lo único interesante para las imágenes. Echaremos un vistazo a un nuevo guión también. Entonces L4, no conseguí esa carpeta L4 nueva. Ahí vas. L4. Eso serían imágenes. Y entonces esta sería la imagen. Hagamos ejemplo de imagen, ¿no? Ese es un buen nombre. Ejemplo. Sí. Añadamos también eso a la imagen misma. Se van y luego vamos a abrirla y ver qué podemos ver. Bueno, la idea aquí es que una vez más, tenemos, por ejemplo, primer lugar, necesitamos el, necesitamos estar usando el motor Unity que ya sabes, no accesibilidad en este caso, sino UI. Ahí vas. Y entonces, por ejemplo, tenemos una imagen privada, la imagen la interfaz de usuario, por ejemplo, la imagen de ejemplo aquí. Y entonces también podríamos tener un sprite por ejemplo, pero en realidad no necesitamos eso. Ya tenemos eso. Imagen de ejemplo es igual a este punto get componente image. Entonces así es como obtenemos el componente de imagen. Esto no debería ser demasiado sorprendente en absoluto, porque una vez más, la imagen aquí van. La imagen aquí es una vez más, solo un componente normal y en realidad es de muy fácil acceso. Entonces, ¿cómo podemos cambiar estos sprite? Bueno, solo hacemos sprite de punto. Eso es todo lo que es. Este es exactamente el campo al que necesitamos acceder para cambiar el spread. Por lo que básicamente es casi exactamente lo mismo que el renderizador sprite. Entonces la imagen en sí no es realmente tan complicada en absoluto. Y hay una cosa interesante, y esa sería la imagen cruda. Entonces si agrego aquí la imagen cruda, si miramos esto ahora mismo y hacemos ésta para que la desbloqueemos. Entonces como puedes ver, la imagen cruda aquí es un poco diferente porque en lugar de tomar un sprite, esto toma textura. Entonces si tú, por ejemplo, y esto es algo que no vamos a ver en detalle, pero quería mencionar esto. Entonces si tú, por ejemplo, tienes una cámara en la que quieres alimentarte, , así que una webcam, entonces podrías no, quiero decir incluso una básicamente una película, esto podría mostrarse en una imagen sin procesar porque esto puede ser traducido a una textura. No vamos a entrar en detalle con eso, pero eso es una especie de, una de las cosas donde la imagen en bruto tendría más sentido. Y como pueden ver, así aún podríamos poner el clicker aquí. Entonces eso no es un tema. Pero ahora esto sería una textura, ¿no? Pero en general, eso en realidad ya sería para las imágenes. Sé que eso no es nada loco ni tampoco. Sí, interesante. Pero así es como añades una imagen a tu IU. Al igual que con todo lo demás en la interfaz de usuario, puedes centrarlo. Haz lo que quieras con el rector, transforma, muévete y todo ese jazz. Pero en general es un muy, muy similar al renderizador sprite. ¿ Verdad? Y eso sería todo para esta conferencia. Como dije, un poco más corto. Pero eso no está tan mal porque las imágenes lo son, al menos en términos de IU después de que hayamos visto el renderizador sprite. No tan complicado, ¿verdad? Espero, aún espero que esto te resulte útil. Si queda alguna pregunta, entonces por favor siéntase libre de preguntar y me aseguraré de responder. Y sí. 75. (Unity UI) Clicking botones pueden ser divertidos: Muy bien, sigamos con la introducción de Unity UI aquí para el curso de unidad. Y en esta conferencia, vamos a echar un vistazo a los botones. Por lo que ya vimos un componente de botón la última vez en el clicker de queso, donde hicimos algunos botones en los que pudimos hacer clic. Y ahora en realidad vamos a añadir un botón normal desde aquí mismo. Entonces haga clic derecho en el panel, por ejemplo, u, i, y luego elija el botón. Vamos a utilizar el botón normal o el texto Mesh Pro para este ejemplo aquí. Y sí, así que una vez que esto realmente se agrega aquí, básicamente podemos redimensionarlo como cualquier otro objeto normal básicamente. Y el componente interesante de este botón es básicamente el componente de moño aquí abajo. Ahora ya hemos visto un poco de esto, pero no demasiado. El texto que se muestra en el botón es otro componente de textos debajo de él, básicamente como niño. Y podemos hacer esto más grande. Y por ejemplo, di Click Me, Algo así, ¿verdad? Hagamos que este mejor ajuste. Ahí lo tienes. Entonces ahora dice Click Me Si miramos en el juego ahí está, ahí está el botón. Y en realidad podemos tener algunas cosas que básicamente podemos poner. Entonces, número uno, podemos establecer si esto es o no intratable. Entonces si no es interactable, básicamente obtiene esto, obtiene el color deshabilitado que se notifica aquí. Vamos a ver aquí el color deshabilitado. Entonces también podemos decir, oh, bueno queremos hacerlo rojo, pero creo que tiene sentido tener este tipo de gris. Eso es lo que la mayoría de la gente esperaría por un botón deshabilitado. También hay cuando lo volvemos a encender, tenemos el color normal. Entonces tenemos un color que se destaca. Entonces si pasamos sobre él, entonces eso se cambia a este color es mientras presiono la tecla del ratón, por ejemplo. El color seleccionado es si, por ejemplo, nos estamos moviendo con las teclas de flecha del teclado, porque básicamente podemos seleccionar diferentes tipos de elementos de UI con las, uh, teclas de ahí también. También tenemos un multiplicador de color y una duración de desvanecimientos. También podemos cambiar realmente la transición, por lo que realmente podemos tener una animación particular asociada a ella. Incluso podemos cambiar el sprite en sí. Entonces si tienes diferentes sprites preparados para el botón, entonces también puedes hacer eso. Y la navegación aquí, eso es exactamente lo que es básicamente, por lo tanto las teclas de flecha tu teclado para que puedas cambiar entre ciertos botones, por ejemplo. Entonces si tuviera que duplicar este botón Control D, y lo pondré aquí, entonces realmente podemos mirar la navegación visualizada. Y como pueden ver, si presiono la flecha derecha, cambiaría a ésta. Si me fuera llega cambiaría a éste ahora mismo esos son los únicos interactables, ya sabes, botones que hay. Entonces eso es lo que la visualización mostraría eso. Pero entonces también tenemos por supuesto, el onclick, que es lo único que en realidad vamos a echar un vistazo rápido. Entonces veamos que eso es un gran, En realidad no hemos cambiado El hemos duplicado la escena y cambiar algo. Increíble, Eso no es algo que podamos hacer. Entonces hagamos realmente la imagen real aquí, botones L5. Vamos a recargar esto y luego la escena duplicada que sólo vamos a tomar como es. Y eso va a estar bien también. Entonces los botones L5, ¿qué podemos hacer aquí? Vamos a crear un nuevo script, botones L5. Y en realidad vamos a crear dos scripts en esta instancia aquí. Uno de ellos es sólo un botón. Entonces voy a mostrar algunas cosas que podemos hacer en los guiones con botones. Y luego hay otro script, este es solo el resultado de ejemplo. Digamos, llamémoslo algo así. Y vamos a crear aquí un nuevo objeto vacío, que va a ser la salida de ejemplo. Y pon eso en 000 y pon ahí el script de salida de ejemplo. Y luego si bajamos al botón del panel, agregamos el script de botones a ese. El ego, ahí está. Y sin embargo Abramos ambos y realmente veamos qué podemos hacer aquí. Entonces el primero va a ser, Vamos a ver el ejemplo de salida. Cerremos los otros. Dentro de aquí. En realidad sólo vamos a tener un vacío público. Y luego digamos una salida, salida algo que es el nombre del método. Y este método simplemente se va a registrar básicamente, tengo salida algo, tengo salida algo, algo. Ahí lo tienes. Y esto es básicamente lo que podríamos agregar a este botón. Entonces si vuelve a mirar el botón, entonces podemos agregar manualmente un evento on-click. Eso pasa si ponemos un plus dentro. Y aquí en realidad podemos poner todo para que o bien podamos ponerlo, como se puede ver, podemos poner en scripts, podemos poner en diferentes, casi todos los objetos que básicamente podemos tirar ahí. Pero lo que queremos poner es este ejemplo, salida GameObject. Y si ponemos eso ahí dentro, entonces podremos acceder a todas sus funciones. Entonces por ejemplo, el objeto del juego funciona, podemos cambiar el nombre. Podemos configurarlo activ activado o desactivado. Entonces eso también es un poco útil para algunas cosas en las que no necesitas necesariamente hacer nuevos métodos para eso. Podemos configurar la transformación para que realmente podamos hacer algunas cosas aquí también. Y también podemos acceder al script de salida de ejemplo de componente, que luego también tiene el método de salida Algo aquí que básicamente podemos poner ahí, ¿verdad? Entonces si ahora hacemos clic en esto como puedes ver, tengo salida algo. Por lo que el método en este ejemplo, salida en realidad se está llamando sin problemas. Ahora, hay otra forma en la que podemos agregar nueva funcionalidad a un botón a través del script. Y vamos a echar un vistazo a eso ahora mismo en el guión de botones, en especie del guión Bund. En primer lugar, por supuesto, necesitamos estar usando el marco de interfaz de usuario de punto del motor de Unity, marco interfaz de usuario, o más bien el espacio de nombres al que vaya. Y entonces podemos en realidad sólo todavía Vamos a hacer un botón privado. Entonces este es el botón, digamos. Y ese se va a ajustar a este punto botón get Component. Entonces eso es un escaneo el este componente o el método de componente brillando a través y el botón. Podemos entonces básicamente tener este onclick y este es un evento click como puedes ver. Y podemos agregarle oyentes. Dentro de aquí. Como se puede ver, los parámetros deben ser una unidad Sucesos, acción de Unidad. Y básicamente podemos hacer esto haciendo aquí una expresión lambda. Entonces, por ejemplo, podríamos decir debug dot log y luego algo así como cuatro ruidos. ¿ Por qué no? Vamos a conseguir un año un poco más divertido. Por qué no tendría razón. Por lo que esto entonces a su vez habría simplemente llamar a esto. También podemos, si tenemos otro método aquí dentro, también se puede decir privado. Digamos que evite el botón de prueba o algo así. Depurar registro de puntos. Una vez más pareces algo así como presioné el botón. Y también podemos agregar esto haciendo oyente al hacer clic. Y entonces simplemente podemos poner en botón de prueba como una especie de solo el nombre del método sin que haya estado en una llamada de método. Entonces no pongas los paréntesis aquí, sino sólo el nombre real del método. Y esto también funciona. Entonces esto va a llamar entonces a este método cuando se haga clic en el botón real. Entonces, veamos si eso funciona. Entonces lo que deberíamos esperar ver es que queremos ver tengo salida algo para ruidos y luego el IF hizo clic en el botón. Entonces, veamos si ese realmente es el caso. Nosotros, por cierto, no podemos ver aquí los cambios onclick. Pero lo que no podemos ver son los cuatro ruidos y el que presiono el botón. Por lo que a esos entonces se les está llamando no temas por el clic de botón. Y este es básicamente el oyente de anuncios aquí. Puede ser increíblemente útil si quieres configurar las diferentes funcionalidades para botón, tal vez dependiendo de si algo está abierto o cerrado o incluso si tienes diferentes, ya sabes, paneles de control o algo así. Entonces hay algo de funcionalidad y alguna utilidad para esto, definitivamente. Pero en general, eso en realidad ya es para el botón. No es tan emocionante. Una vez más, por supuesto hay algunas cosas en las que podemos cambiar los colores y algo así y la intractabilidad. Pero también hemos visto los cambios tanto de la intractabilidad como de un poco para la adición de nuevos oyentes. Están en el clicker de queso. Y en general eso sería bueno para el botón. Es, no hay nada demasiado loco en ello. Básicamente es solo un elemento de interfaz de usuario en el que puedes hacer clic. Y eso sería todo para esta conferencia como siempre, espero que te resulte útil y aprendas algo nuevo. Si hay alguna pregunta, por supuesto, como siempre, siéntete libre de preguntar y me aseguraré de responder. Y sí. 76. (Unity UI) Toggles y deslizadores: Muy bien, sigamos con la introducción de Unity UI aquí para el curso de unidad. Y en esta conferencia vamos a echar un vistazo a los toggles y sliders. Entonces en primer lugar, vamos a duplicar nuestro L5 visto arriba para que sea L seis deslizadores totales. Y también, sí, en realidad no necesitamos crear ningún guion para esto porque esos, bueno, quiero decir, la mayoría de esto en realidad va a ser bastante autoexplicativo. Y vas a acceder a las partes componentes particulares, los campos y propiedades de los componentes. Todo lo demás que hemos visto hasta ahora, Así que, sí, dentro del lienzo, primero que nada agreguemos un nuevo panel aquí. Entonces aquí abajo un panel. Y pongamos esto al lado derecho de la pantalla. Entonces panel, Vamos a ponerlo también darle vuelta a los artilujos que, eso sería un poco útil un ego. Y sí, eso está bien. También podemos alejar un poco el texto. Y luego inicio de este panel, tenemos dos elementos de interfaz de usuario para agregar. Uno de los va a ser primero el toggle. Entonces hagamos esto un poco más grande y voy a echarle un vistazo a eso. Y luego también le agreguemos inmediatamente los deslizadores. Y en realidad podemos hacer eso más grande e inmediatamente ver algo. Entonces eso es bastante guay. Entonces echemos un vistazo primero al toggle. Por lo que el toggle, el objeto de juego real tiene el componente total a ella. Vamos a echar un vistazo a eso en un rato. Pero primero echemos un vistazo al fondo de la marca de verificación y la etiqueta. Por lo que la etiqueta es un objeto de texto normal, que suele ser lo que te muestra lo que hace este toggle en particular. Ahora, solo podemos dimensionar esto para que realmente podamos ver lo que está pasando aquí. Lo mismo con el fondo y la marca de verificación. Esos son ambos esos son solo una imagen. Básicamente. Tanto el fondo como la marca de verificación, solo una imagen que posiblemente podrías reemplazar incluso. Por supuesto, también puedes escalar este hacia arriba. Entonces, en primer lugar, digamos dimensionar el, dimensionar el fondo, y luego la marca de verificación también se puede dimensionar X2. Vamos a darle a éste. Y luego si presionamos la tecla Alt mientras la estamos redimensionando, entonces podemos redimensionarla desde todos los ángulos diferentes. Depende de si quieres o no una marca de alternancia tan grande. Pero claro que eso es algo que podrías, por ejemplo, hacer. Y así que eso es básicamente sólo la marca de verificación en el fondo ahí solo para muy fácilmente entender las imágenes. Y la etiqueta lo hará, como dije, es sólo el texto. Y entonces el toggle es el que es interesante. Por lo que una vez más, interactable para que realmente podamos habilitarlo y desactivarlo. El tránsito es el mismo. Podemos o bien atendidos por un color o podemos cambiar el sprite o tener una animación asociada a él. Entonces esto es básicamente todo lo que ya hemos visto en el botón. Aquí la diferencia es que tenemos un valor desconocido cambiado. Básicamente método que se llama cuando cambia el valor. Pero esto en realidad también es un evento que podrías, por ejemplo, suscribirte al que hemos visto con nuestros propios eventos. Este es uno de esos eventos en teoría con los que podríamos hacer eso. Y aquí simplemente podemos añadir también. Entonces, por ejemplo, salida de ejemplo. Una vez más, cuando cambie, podemos, por ejemplo, decir en la salida de ejemplo de toggle y función y luego decir de salida algo. Esto por supuesto, también funciona si tenemos el método al que se nos quiere llamar. Si eso realmente tiene un parámetro booleano, entonces también va a pasar el parámetro booleano en el que lo estamos cambiando, el toggle en. Entonces eso es bastante guay. Está encendido es básicamente exactamente el booleano que queremos comprobar. Entonces está encendido, hace aparecer una garrapata, y luego si no lo es, entonces en este caso el es on Boolean es falso y no hay garrapata ahí. Entonces, solo usemos el toggle una o dos veces. Entonces como puedes ver, puedo hacer click en esto y como puedes ver, tengo salida algo. Y luego si cambiamos de nuevo, esto sucederá una vez más porque en este momento sólo estamos buscando sobre el cambio de valor. Entonces solo buscamos si este valor realmente cambia de verdadero a falso o de falso a verdadero. Entonces, por ejemplo, si cambiamos la etiqueta, esto podría, por ejemplo, ser algo así como una opción de muerte de perma. A modo de ejemplo, cuando se trata del deslizador, esta letra es, diría yo, una especie de alrededor de la misma complejidad. Es un poco más complejo. Por lo que tenemos una vez más una imagen. Esta es simplemente la imagen de fondo del deslizador. Aconsejaría mantener esto como especie de la misma longitud. El área de relleno en el área de relleno se mostrará una vez que realmente movamos este mango, mango , área ligera y el mango, básicamente el mango lo podemos mover, que no debes mover el mango independientemente del deslizador. Porque el deslizador aquí, cuando echamos un vistazo al valor aquí, si cambiamos esto y como puedes ver, el deslizador realmente cambia. Y lo realmente genial de este deslizador aquí es que en realidad podemos decir: Vale, primero que nada, qué dirección va de derecha a izquierda, de izquierda a derecha, arriba a abajo, o de abajo a arriba y luego de arriba a abajo. Lo vamos a mantener de izquierda a derecha. Ahora una vez más, todas las cosas habituales que se pueden hacer, transición interactable los colores, ya sabes, eso es, eso es algo así. Y los Min y max valoran otras cosas que son realmente interesantes. Porque la idea aquí es que si básicamente movemos esto, podemos, por ejemplo, decir, bueno, queremos que el valor mínimo sea 0 y el valor máximo sea un 100, por ejemplo, ¿verdad? Entonces puedes cambiar esto. Y como puedes ver ahora ese número cambia aquí de 0 a algo así. Y también podemos decir, bueno, queríamos que esto fuera solo números enteros o no queremos que sean números enteros. Entonces podrías, por ejemplo, yo creo que si pongo en 10.5, entonces eso funcionaría. Si tengo números enteros, entonces solo enteros son lo básicamente lo que funcionaría en el valor aquí. Entonces eso es bastante guay. En realidad podemos decir que también podemos ir negativos, ¿verdad? Eso funciona bien. Entonces eso es realmente genial para enviar diferentes valores para esto. Entonces esto podría, por ejemplo, ser A1 y FMV o algo así. Si queremos un texto para esto, entonces tendríamos que agregarlo nosotros mismos. Pero eso no debería ser un tema. Entonces podemos, por ejemplo, simplemente decir texto de la interfaz de usuario y luego agregarlo a aquí, a la parte de atrás allá y luego hacerlo un poco más grande. Di algo así como f de v por ejemplo. Y entonces tenemos un texto aquí. Entonces eso es, eso también funcionaría como ejemplo. Y sí, también podemos cambiar esto. Entonces dentro de nuestro juego, cuando tenemos esto, si seleccionamos el deslizador y puedes ver en este momento el valor es 35. Y si hago clic en esto y en realidad lo cambio, y como puedes ver ese deslizador, el valor también cambia. También puedo creer, vale, Scroll willing no funciona así, pero puedes usar las teclas de flecha para básicamente mover de izquierda a derecha por el valor. Y una vez más, aquí hay otro evento que podrías suscribirte. Entonces sobre el valor cambió. Y esto te da el valor con él como parámetro. Entonces en teoría, podrías tener un método ya que tiene, que evalúa el cambio aquí. Y si es algo particular, entonces podría pasar algo ahí. ¿ Verdad? Y eso en realidad lo haría básicamente para los toggles y los sliders. Creo que son principalmente útiles en menús de opciones. Fuera de eso, no estoy un 100 por ciento seguro de dónde los usarías, pero creo que a mucha gente se le ocurriría algunas otras formas creativas en las que podrías o deberías poder usar esas, ¿verdad? Pero eso será todo para esta conferencia como siempre, espero que te resulte útil y aprendas algo nuevo. Si hay alguna pregunta, como siempre, siéntete libre de preguntar y me aseguraré de responder. Y sí. 77. (Unity UI) Diseño en la unidad: Muy bien, sigamos con la introducción de la UI de Unity aquí para el curso de unidad. Y en esta conferencia vamos a echar un vistazo a los diseños. Entonces aquí es básicamente donde echamos un vistazo a bien, diseños y cómo ordenar automatizar el diseño de tu interfaz de usuario. Y para eso, ya he creado el layout L7 como escena, así que tú también puedes hacer eso. Y a eso, vamos a añadir un nuevo lienzo aquí. Por supuesto, este lienzo va a estar bajo cámara espacial mundial, cámara principal. Y entonces también nos aseguraremos de que tenga el mismo escalar aquí. Entonces escala con tamaño de pantalla, 1920 a 10, 80, y 85, y los píxeles de referencia, lo vamos a establecer en 200, sólo por el infierno de ello. ¿ Verdad? Y ahora vamos a añadir un panel. A ver, ahí tienes. Y luego vamos a duplicar este panel tres veces para que tengamos tres paneles. Y todos esos tres paneles van a ir como niños del primer panel. Y el, éste, sólo vamos a redimensionar el panel. Número uno, vamos a redimensionar y ponerlo aquí. Y luego vamos a redimensionar este también. No tiene que ser necesariamente del mismo tamaño. Simplemente similar. Y vamos a poner eso en el medio aquí mismo. Y luego vamos a tomar el último panel y hacer algo muy parecido. Para que ahora tengamos tres paneles uno al lado del otro. Y de repente así, eso funciona muy bien. De hecho vamos a escalar un poco esto para que sean una especie de la misma talla, no como dije, y tengo que ser del mismo tamaño porque vamos a cambiar las tallas de todos modos. El primero que vamos a ver es el diseño vertical. Entonces voy a llamar a esto el diseño vertical. Y lo que es bastante genial hay es que básicamente podemos tener un cierto tipo de grupo de diseño en esos paneles. En primer lugar, vamos a crear una especie de una, una nueva, bueno yo soy como una exhibición. Entonces vamos a añadir un nuevo panel aquí. Y vamos a hacer esto como algunos así para que sea una especie de centrado. Y luego en este, vamos a sumar algunos detalles más. Entonces por ejemplo, una nueva imagen. Por lo que podrías pensar en esto, tal vez así sea tal vez una pantalla de selección para unos artículos en particular o algo así. Entonces tenemos una imagen aquí. No vamos a llenarlo, sólo vamos a mantenerlo como es. O sea, podríamos llenarlo con un clicker, supongo. No así, sino así. que podamos, por ejemplo, poner el clicker ahí dentro. ¿ Por qué no? Y luego en el panel también vamos a añadir un nuevo texto. Entonces vamos a tener tal vez un texto en la parte superior, que va a ser algo así como un artículo realmente genial, realmente genial, ¿verdad? Y luego hagamos esto un poco más grande para que realmente podamos leerlo correctamente. Hagamos el mejor ajuste. Sí, eso es bueno. Y luego vamos a duplicar este texto y tal vez tener una descripción aquí. Por lo que sólo vamos a usar algo como Lorem Ipsum para este. Entonces ahí lo tienes. Correcto, Así que ahora tenemos básicamente un pequeño panel fresco aquí. Podría ser un panel de elementos o algo así, que nos gustaría, bueno tener esto mostrado de manera vertical. Por lo que queremos que esto se muestre así. Y luego el siguiente aquí y el siguiente aquí. Por supuesto, podemos duplicar este Control D y luego mover un poco el segundo hacia abajo. Y así sucesivamente y así sucesivamente. Pero en realidad no funciona del todo tan bien como nos gustaría. Y por lo tanto, lo que podemos hacer es simplemente poner un layout en este panel aquí. Y eso es lo que vamos a hacer. Entonces vamos a ir a Agregar Componente, um, y luego a ponernos aquí mismo. Y luego vamos a usar el diseño vertical en este. Ahora antes que nada, como puedes ver, todo se rompe aquí. No te preocupes por eso. Vamos a usar, vamos a hacer eso y arreglarlo en poco tiempo. Por lo que podemos volver aquí y como puedes ver, algunos valores son impulsados por grupo de diseño vertical. Entonces esto significa que esto básicamente cambia. Ahora en realidad podemos volver a cambiar esto. Entonces vamos al panel de artículos aquí, ¿verdad? Uh, se cambió un poco. Podemos, sin embargo, como pueden ver, cambiar su posición. Podemos cambiar el tamaño aquí, pero podemos cambiar la posición ahora el tamaño realmente no importa ahora cómo se vea. Porque también vamos a decir usar escala infantil, que básicamente el niño, si en realidad, esa no es la escala, su tamaño. Ahí vas. Entonces si hacemos eso, si decimos controlar el tamaño del niño, entonces va a dimensionar hasta exactamente el tamaño de su padre. Por lo que el panel aquí va a dimensionar hasta su padre. Y ahora lo cool con el grupo de maquetación y el grupo de capas verticales para esto también, podemos decir un relleno. relleno es básicamente el espacio entre el niño y sus fronteras padres, por así decirlo. Entonces si lo hago a la izquierda de aquí, como pueden ver, se hace más pequeño a la izquierda. Entonces podemos por ejemplo, decir 15, 15, 15, y 15. Por lo que ahora se va a mover hacia el medio. Y especie de 15. El espaciado también puede estar predefinido. Entonces pongamos un 15. Y si ahora tuvieras que duplicar este panel de ítem, mira lo que pasa. Automáticamente disenan eso, se ponen aquí con un 15 espaciado entre ellos y en todas partes desde la frontera de nosotros también tenemos un 15 Yup. Unidad. Básicamente espaciado o relleno. En ese caso. El alineamiento infantil simplemente dice: Vale, ¿por dónde empezamos con esta alineación? En este caso, realmente no importa. Donde podría importar es si pones más bajo así entonces contaríamos de abajo a arriba básicamente. Pero la parte superior izquierda estaría bien. arreglo inverso simplemente invierte el orden de esto, el escalado y el tamaño, como dije. Entonces si pones el tamaño en, por ejemplo, para la altura, ahora mismo, nada cambia aquí, pero podemos expandirlo. Para que podamos forzar al niño a expandirse. Y esto es a menudo lo que queríamos hacer. Porque si ahora sumamos más, como pueden ver, ahora en algún momento, se pone un poco demasiado abarrotado. Pero para, por ejemplo, en realidad funciona muy bien y se ve muy bien. Por lo que este sería el diseño vertical. Ahora, siguiente, el siguiente es también utilizable el diseño de cuadrícula? A menudo, vamos a copiar realmente uno de esos paneles de elementos y pegarlo aquí. En el diseño de la cuadrícula y asegúrate de que en realidad está una especie de centrado aquí. Y vamos a hacer esto un poco. Por lo que en realidad estamos poniendo el tipo de descripción aquí. Y luego el, tienes algo así. Entonces pongamos eso aquí y luego el nudo lo rote aunque. Y entonces el texto del título va a subir en la parte superior y tal vez hacer esto un poco más pequeño también, algo así. Y sí, vamos a ver si eso también funciona. Entonces tal vez un poco menos de texto y, o un poco más pequeño de una imagen. Y eso está bien. Ahora en el diseño de cuadrícula. Por lo que una vez más, bajo diseño podemos simplemente decir diseño de cuadrícula. De inmediato cambiará el tamaño del panel de artículos aquí. Y vamos a preocuparnos por eso en un rato porque ahora mismo aquí, este tamaño de celda es exactamente lo que hace. Por lo que hace de esto un tamaño particular. Primero que nada, miren el relleno de nuevo, ese es el panning una vez más es exactamente lo mismo. Entonces si digo 15, 15, 15, y 15 entonces va a tener relleno hasta la frontera del padre. Básicamente, el tamaño de celda es exactamente especifica el tamaño de cada una de las celdas. Entonces, por ejemplo, podríamos decir algo así como, bueno, tal vez un 150 es suficiente, pero por qué tiene que ser como 200. Y eso podría, eso podría funcionar, ¿verdad? Por lo que podemos, por ejemplo, hacer esto un poco más pequeño también. Entonces podemos hacer esto un poco más pequeño, ¿verdad? Entonces esto cabría y haría esto un poco más pequeño. Va a ser difícil de leer en este momento, pero esto es por supuesto, sólo un ejemplo de todos modos. Entonces ahí lo tienes. Para que eso no, funcionaría en teoría. Y luego si tuviéramos que añadir un nuevo panel de elementos, podemos ver de inmediato que se agrega aquí a la derecha. Y si agregamos otro de este lado, no hay espacio suficiente. Por lo que se suma a la siguiente fila, por así decirlo. Y si amplío un poco esto, entonces como pueden ver, ahora en realidad sí se agrega a la misma fila ahí. Entonces eso es bastante guay. También podemos tener algo de espaciado. Entonces este es el espaciado entre los elementos reales, los elementos de diseño. Podemos tener un rincones de inicio diferentes. Entonces, por ejemplo, podemos empezar por la parte inferior izquierda o podemos empezar por la parte inferior derecha. Ahora esto en realidad no funciona. No estoy del todo un 100 por ciento seguro de por qué es eso. Yo lo haré porque la alineación ahí vas. Entonces la alineación en realidad también se asegura de dónde empieza esto, una horizontal o vertical, ¿verdad? Por lo que primero podemos llenar las columnas y luego las filas o una columna por columna, o podemos ir fila por fila. Y las restricciones flexibles también pueden ser flexibles. Tan flexible simplemente significa que lo que quepa, encaja. Si la restricción es conteo fijo de columnas, entonces podemos decir, vale, solo tenemos estas muchas columnas, o podemos tener un conteo fijo de filas. Y entonces básicamente podemos cambiar cuántas filas hay o cuántas columnas tienen que ser. Por lo que en realidad hay mucho con lo que jugar con el diseño de la cuadrícula. Yo sólo puedo realmente, diría consejos para jugar un poco con él. El diseño de cuadrícula es uno de mis favoritos y funciona realmente, muy bien. Entonces si solo copio sobre algunos de ellos y voy a decir que en realidad, realmente no me gusta el espaciado de esos. Yo solo puedo agregar el espaciado aquí y todo sólo hace lo que hace. Entonces eso es, me parece bastante guay esto. Y también es realmente genial porque cuando generas elementos de interfaz de usuario, entonces la idea es que automáticamente se dispongan de una manera que funcione. Y el último sería el diseño horizontal. Disposición. También copiemos uno de esos y lo pongamos aquí. Y el diseño horizontal no debería sorprender a nadie, también está en Layout bajo disposición horizontal. Y éste simplemente significa, así que si agrego otro, entonces se agregan de manera horizontal. Por lo que no hay grilla en este caso. lo que también podrías, por ejemplo, expandir estos para que sean algo así como un no, ahí vas, este para que sea como un realmente largo. Por ejemplo. Eliminemos esa y hagamos ésta otra vez. Y entonces podríamos decir para el diseño horizontal, una vez más, el relleno el mismo espaciado es el mismo entre esos. Y podemos revertir el, podemos controlar el tamaño, ¿no? Eso también funciona. Por lo que controlando el tamaño una vez más, mezclar esto se expande para ser de todo el tamaño. espaciado debe ser autoexplicativo fuera relleno más bien en este punto, espaciado o todo aquí en realidad debería ser autoexplicativo. Si hemos visto tanto la vertical como en el diseño de cuadrícula, todos son muy similares pero hacen cosas ligeramente diferentes, ¿verdad? Y eso sería todo para el diseño. Conferencia aquí. El diseño es increíblemente útil, especialmente si tienes una especie de Prefabs de UI que instancias en tu IU. Por ejemplo, si tienes, no sé, como 10 ítems, entonces quieres un ejemplo de 10 ítems aquí, 10 opciones en las que puedes hacer clic. Y tal vez si quieres, si tienes 20 artículos, bueno, entonces quieres 20 de esos, y deberían estar dispuestos de una manera particular, entonces básicamente puedes facilitar eso con, por ejemplo, la, ya sea la vertical, la disposición de la cuadrícula o la disposición horizontal. Herramienta tan increíblemente útil para dispensar automáticamente elementos de la interfaz de usuario, derecha, y eso sería todo para esta conferencia. Espero que lo hayan encontrado útil. Si lo hicieras, por supuesto, realmente agradecería una crítica de ti. De lo contrario, si quedan algunas preguntas, entonces por supuesto, siéntete siempre libre de preguntar y me aseguraré de responder. Sí. 78. (Unity UI ): O yo, sigamos con la introducción de Unity UI aquí para el curso de unidad. Y en esta conferencia vamos a echar un vistazo a barras de desplazamiento y al componente de desplazamiento naufragado. Ese tipo de trabajo de la mano. En nuestro caso, lo que quiero mostrarles es básicamente cómo podría hacer una especie de vista. Y luego desplazarse hacia arriba y hacia abajo, tener básicamente múltiples elementos presentes al mismo tiempo. Y para eso simplemente vamos a duplicar el diseño L7. Y vamos a nombrar a esta barra de desplazamiento LH. Y vamos a abrir de inmediato esto. Y para sorpresa de nadie, esto se ve exactamente igual porque acabamos de duplicar la escena. Y vamos a hacer esto como ejemplo en el diseño vertical aquí. Y lo primero que vamos a hacer es que vamos a hacer esto más grande. Entonces el libro, no queremos moverlo, en realidad sólo hacemos querer hacerlo más grande. Por lo que el propio panel de disposición vertical real va a hacerse mucho más grande. Y luego solo vamos a duplicar el último panel de ítem aquí y tener unos cuantos más. No hagamos que se escapen de la pantalla ahí o del panel de diseño real, pero solo así, entonces debería estar bien. Y entonces lo que queremos es básicamente que vamos a definir eso. Bueno, vamos a tener una especie de un, un nuevo panel que es una especie de este tamaño donde lo que va a especie de actuar como una ventana y el resto no va a ser visible. Esa es una especie de idea aquí. Y así vamos a ver la barra de desplazamiento. El modo en que podemos hacer esto es antes que nada, hagamos algo como esto. Entonces vamos a hacer un nuevo panel, no básicamente como un hermano del panel de diseño vertical. Y eso va a ser bajo un panel de UI. Ahora esto va a ser realmente grande, pero eso es, podemos redimensionar esto a aproximadamente el mismo tamaño que el original. Entonces alguien así. Y luego vamos a darle un poco extra en el lado derecho para que tengamos un poco de espacio de lectura para nuestra barra de desplazamiento. En este panel será lo que arriba aquí arriba y vamos a llamar a esto el panel de desplazamiento. Seguro. Y éste tendrá que hacerlo. En realidad también asegurémonos de que esto esté centrado correctamente. Ahí vas. Eso debería funcionar muy bien. Y luego le vamos a sumar dos componentes. Uno de ellos va a ser el pergamino erecto. Este pergamino naufragó. Y entonces el otro va a ser una máscara. Y tan pronto como añadamos la máscara, verás que esto cambiará de inmediato básicamente algún visual. Nuestro no les cambió visual. Todavía no de todos modos. Por supuesto que no porque todavía tenemos que tomar el diseño vertical y en realidad tenerlo como un niño de esto. Y en cuanto hacemos eso, ahora cambia algo visual, visual. Como puedes ver, de repente, el diseño vertical real es una especie de corte en este punto porque el diseño de desplazamiento ahora es una máscara. Entonces todo, el tamaño del mismo en realidad depende donde el rango visual de esto depende del tamaño del diseño del desplazamiento aquí. Entonces cuanto más grande es el diseño pequeño, el diseño de desplazamiento que más grande es la cosa que realmente podemos ver. Y éste entonces ahora nos habilita. Entonces si tuviéramos que mover esta disposición vertical a la derecha. Vamos a mover esto, como puedes ver ahora como se mueve hacia arriba y hacia abajo. Ahora si podemos hacer esto con en especie de conjunción con una barra de desplazamiento, bueno, quiero decir, entonces todo saldría muy bien. Y eso es exactamente lo que vamos a hacer en el panel de desplazamiento debajo de esto. Entonces al seleccionar esta interfaz de usuario y luego agregar una barra de desplazamiento, vamos a agregar una barra de desplazamiento aquí. Ahora bien, ¿qué es importante? El componente de barra de desplazamiento en sí en realidad se ve algo así como el componente de deslizador. Al igual que es, es más o menos exactamente lo mismo. Para nosotros para este robot, lo que queremos es que sea de arriba a abajo, creo. Sí, eso es lo que queremos. Y entonces también podemos redimensionarlo. Entonces hagamos algo así. Ponlo a la derecha de la pantalla aquí. Hagamos algo así y luego lo movamos hacia abajo. Ahí vas. Eso es una especie de barra de desplazamiento. Creo que eso en realidad está muy bien hecho. Y yo soy la barra de desplazamiento en sí. En realidad no necesitamos cambiar nada. Lo que necesitamos cambiar es que las cosas del pergamino se corrijan en sí mismo. Y cosas que queríamos cambiar en el recto de pergamino, en primer lugar, donde sólo queríamos un movimiento vertical aquí porque esto sólo se mueve hacia arriba y hacia abajo. Y luego queremos definir una barra de desplazamiento vertical, que es exactamente la barra de desplazamiento que acabamos de agregar. Y luego también queremos agregar contenido. Y esto es básicamente la Transformación Rect. Por lo que este sería un componente de interfaz de usuario que tiene el componente de transformación de naufragio adjunto a él, que queremos mover. Y este es exactamente el diseño vertical aquí. Después de haber agregado ambos, eso es en realidad todo lo que necesitamos hacer para tener una especie de disposición vertical funcional, tipo barra de desplazamiento trato. Y creo sin embargo, que en realidad lo que queremos es de abajo a arriba, creo, sí, la dirección es en realidad de abajo a arriba. A ver si eso funciona. Y sí, sí lo hace. Entonces si me desplaza hacia abajo ahora se está desplazando hacia abajo, pero como pueden ver, va muy despacio. Puedo hacer otras dos cosas. Yo puedo por supuesto, tomar la barra de desplazamiento y moverla así. Y también puedo hacer clic en el panel de diseño vertical y mover eso por sí mismo. Y también puedo una especie de dejarlo ir como lo harías en un smartphone. Ahora bien, si yo subía, se puede ver que es una especie de poco inflable en la parte superior. Esto se puede cambiar aquí mismo. Entonces este es el tipo de movimiento. Es elástico. Yo personalmente preferiría aclamado como una especie de cómo funcionan casi todas las demás barras de desplazamiento. Y también definitivamente recomendaría poner ahí la sensibilidad de pergamino. Algo así como 25 debería ser, debería ser suficiente. Sí, ahora funciona mucho mejor, así que es un poco más rápido. Con una sensibilidad de desplazamiento de uno, me refiero, sólo estás desplazando todo el tiempo. Eso no es eso no es una muy buena idea. Sí. Y eso de hecho es lo fácil que es agregar una barra de desplazamiento con un poco de funcionalidad. Por supuesto, una vez más, todas esas cosas que ya hemos visto en básicamente todos los demás elementos interactables de la interfaz de usuario, básicamente ¿verdad? Color y todo eso. Y esto, este tipo de trato con básicamente también visto cuando miramos los deslizadores. Eso es básicamente exactamente lo mismo. Podemos cambiar el valor ahora el valor, por supuesto, no podemos cambiar porque está atado al pergamino erecto justo aquí. Pero por lo general podemos cambiar el valor y luego también podríamos simplemente leer el valor por tu guión. Por supuesto, poniendo alguno de esos ahí. También tenemos este evento ONE valor cambiado donde podemos donde básicamente obtenemos el cambio del valor. Sí. Y eso básicamente será todo para la barra de desplazamiento. En realidad no está tan mal. Y con la máscara y el componente rojo de desplazamiento, puedes hacer algunas cosas bastante geniales como un diseño de desplazamiento allí. Y entonces ahora podría ser, podrías agregar a este diseño vertical. Es decir, todo lo que quieras y podrías desplazarte y desplazarte. Y tal vez puedas tener, no sé, mil artículos geniales aquí. En ese punto, probablemente sería mejor tener el diseño de la cuadrícula, pero sí, eso sería todo para la conferencia de la barra de desplazamiento aquí. Espero que te haya parecido útil como siempre. Si hay alguna pregunta, entonces por supuesto, siéntete libre de preguntar y me aseguraré de responder. Y sí. 79. (Unity UI ). (campos Dropdown y de introducción: Muy bien, sigamos con la introducción de la UI de Unity aquí para el curso de unidad. Y en esta conferencia vamos a echar un vistazo al menú desplegable, así como al campo de entrada para los elementos de la interfaz de usuario. Esos serían una especie de los últimos elementos se creen que tenemos que mirar. Entonces hagamos una nueva escena, escena realmente nueva L nueve, llamándola bajó entrada. Seguro. ¿Por qué no? Abramos eso de inmediato. Y además agreguemos de inmediato un bonito panel aquí. El lienzo, por supuesto, necesita cambiarse a cámara de espacio de pantalla en este caso, y añadirle la cámara principal allí. Y cambiemos de inmediato también la referencia. En realidad es 1920 por 1080. Y hacer el partido 0.5. Genial. Eso debería ser todo lo que necesitábamos hacer aquí. Y luego al panel, sólo voy a redimensionarlo un poco. Ponlo una especie de en medio de la pantalla. Y luego vamos a agregar los dos tipos de últimos elementos de la interfaz de usuario que no hemos mirado va a ser el desplegable. Hagamos esto un poco más grande. A go, ponlo aquí arriba. Y también voy a agregar la interfaz de usuario para el campo de entrada. Hagamos también esto un poco más grande. Ahí vas. Otra vez con eso, eso probablemente serían todos ellos, ¿no? Nosotros hemos visto básicamente a todos los demás. El sistema de eventos se agrega automáticamente. Y el ScrollView es básicamente lo que hemos hecho la última vez, más o menos. Entonces echemos un vistazo primero al desplegable. Entonces lo primero que veremos es esta etiqueta de aquí. Entonces las etiquetas, por supuesto, se pueden redimensionar un poco, 38, Eso en realidad es bastante bueno en la flecha también se podría redimensionar un poco. Creo que eso tendría sentido. Hagámoslo como un poco más grande. Ahí vas. Sí. Eso en realidad se ve bastante bien para un menú desplegable. Y también está esta plantilla que actualmente está desactivada. Entonces si lo activamos y puedes ver así es como se ve si presionamos sobre este otro. Entonces si hacemos clic en esto y entonces vamos a tener este tipo de plantilla aquí. Se puede cambiar el contenido particular ahí dentro, por lo que el ítem aquí es cambiable. No obstante, en general, probablemente no me metería demasiado con él porque el, creo que esto en realidad se duplica. En realidad podemos. Entonces hagamos esto un poco más grande que así como sí, eso, definitivamente es un poco demasiado pequeño para hacer el artículo un poco más grande. Ahí vas. Los continentes a pagar más grande en el SDA hace, y luego el artículo debería cambiar de tamaño también. Ahí vas. Si presionas Alt, entonces lo va a redimensionar en ambos lados desde el centro. Y entonces también podemos ajustar el tamaño de fuente particular aquí. Esto aquí de la izquierda es, como puedes ver, este es marca de verificación de artículo. Y también hay una marca de verificación, el fondo y la etiqueta del artículo. Y hay una barra de desplazamiento asociada con ella. Por lo que esto más o menos es exactamente lo mismo que los registros de desplazamiento. Se puede ver que hay una especie de exactamente lo que construimos la última vez. Simplemente que esto ya está incorporado en el propio menú desplegable. Ahora bien, esto es básicamente lo que ya hemos visto, pero lo que no hemos visto son las opciones aquí. Y eso es básicamente algo muy interesante. Tenemos opción uno, opción, opción a, opción B, opción C, y simplemente podemos agregar opciones a esto. Creo que nos vamos a quedar con esto y tampoco vamos a hacer ningún sprite. En realidad vamos a hacer del sprite en el primero un clicker y los otros no tendrán un splited all. Y vamos a ver cómo se ve ese. Vamos a echarle un vistazo. Entonces empecemos esto y bajemos esto. Y como pueden ver, que en primer lugar, podemos elegir esos. Y entonces tendremos esta pequeña marca de verificación. Son para anotar cuál de esas opciones realmente se ha elegido. Ahora la plantilla se puede alterar de cualquier manera que desee. Reggie puede hacerlo más pequeño o más grande. Sí, básicamente, como quieras, el sprite real en sí no se va a mostrar. Esto es una especie de algo de fondo. Una vez más tienes el evento aquí en un valor cambiado. Y por supuesto, las opciones que puedes, con el menos aquí, básicamente puedes restarlas o, ya sabes, deshacerte de ellas. También puedes reordenarlos aquí. Y esto, las opciones aquí también serían posibles para cambiar las que están dentro del propio guión. Eso también funciona. Entonces echemos un vistazo a eso por el momento. Entonces hagamos una nueva carpeta. Este sería L9. Esto es un desplegable, desplegable. entrada, insumos. El, oh, eso está bien. Y eso Vamos a crear un nuevo, vamos a llamar a este ejemplo desplegable. Y dejemos que se recargue. Y entonces sólo vamos a empezar esto. Pero antes de que queramos cambiar algo, lo son, vamos a agregar esto también al desplegable real, sólo para que no lo olvidemos porque eso sería fatal. ¿ Verdad? Una vez más, no necesitamos el método de actualización y usando Unity engine dot, vamos a tener un privado. Esto sería un desplegable. Y esto es entonces sólo llamar a este desplegable. Seguro. Desplegable es igual a este punto obtener componentes. Desplegable, autoexplicativo éste, y luego bajó. Y ahí vamos. Opciones. Entonces esto, como puede ver, es una lista de datos de opción desplegable. De acuerdo, Eso en realidad es bastante guay. También podemos establecer el valor real. Esto es, esto sería un entero. Entonces es básicamente el índice de la lista en este caso. Por lo que el índice del elemento de la lista que queremos. Pero por ejemplo, las opciones que podemos agregar ahí, como se puede ver. Por lo que esta es una lista normal. Por lo que aquí podemos agregar y en este caso queremos, podemos ver datos de opción desplegable. Entonces la creencia de que podemos hacer esto así, sí, exactamente. que podamos hacer nuevos datos de opción y como pueden ver, podemos darle una imagen, podemos darle un texto, o podemos invertir ambos. Entonces en teoría, lo que podríamos hacer es algo así como la opción S. Sólo vamos a llamar a esta opción S porque fue generada por un guión, algo así. Y veamos si eso realmente funciona. Tenemos opción D, opción a, y opción C. Y luego después de empezar, deberíamos esperar que la opción S también se presente. Y si nos desplazamos hacia abajo ahí lo está. La opción S también está disponible para su selección. Y ahora se ha ido porque por supuesto se generó vía el guión. Entonces, en realidad eso es lo fácil que es agregar las opciones desplegables a través del script. Simplemente puede hacer una nueva instancia de datos de opción desplegable allí y agregarla a las opciones. ¿Verdad? Y quiero decir que eso es básicamente toda la locura por el desplegable. Cambiarlo visualmente no debería ser un problema. Hemos visto mucho de esto básicamente ya con todas las demás cosas en la interfaz de usuario. Entonces, sí, pasemos al campo de entrada. Por lo que el campo de entrada en realidad también es muy fácil. Ahí está el campo de entrada en sí. Ahí está el marcador de posición, y luego está el texto. Entonces el marcador de posición, podemos hacer esto un poco más grande de lo que puedes ver esto, esto es simplemente una especie de como entrar texto. También puedes cambiar esto a marcador de posición o si tienes tu juego tal vez en un idioma diferente, entonces por supuesto puedes cambiar esto también en teoría. Y el texto en sí probablemente debería tener aproximadamente el mismo tamaño que éste. Entonces hagamos este 59 también. Y si empezáramos esto y solo entramos aquí, así que si hago clic en algo de eso, voy a conseguir este carruaje. Y puedo escribir en Hello World. Y si hago clic fuera de ella, se puede ver que el año de textos cambia. Entonces esto básicamente es solo un componente de texto, ¿verdad? Una referencia a un componente de texto, que es éste. Y se acaba de leer el texto que está aquí. Por lo que básicamente podemos cambiar este texto de inmediato. Y esto también se guarda en la variable de texto, justo en el propio campo de entrada. Y esto es más o menos exactamente de donde también podrías leerlo. También hay cosas bastante geniales que puedes hacer. Entonces la zanahoria en sí parpadea, creo que esto es un parpadeo rojo normal. También puedes aumentar la tasa de parpadeo para que parpadee más rápido o más lento. No sé si eso es necesariamente algo que necesites y también puedes ajustar el ancho. Creo que cinco es el más grande, así que aquí es un poco más notable. También podemos convertirlo en un color personalizado, que es bastante cool, en realidad, una especie de rojo. Es una cosa ordenada con la que puedes jugar. Y sí, entonces también puedes conseguir esta vez incluso dos eventos diferentes aquí en valor cambiados. Entonces esto es básicamente cuando la cadena en sí cambia y luego al final editar. Entonces esto es cuando terminas de editar. Y así no tienes que llamar básicamente al valor cambiándolo cada vez. Por lo que cada poco, cada tipo de personaje específico sería indiscutible en valor cambiado, y luego en editar, string y un final Editar, lo siento, Ahí tienes. Encendido y editar básicamente solo te da este anillo una vez que hayas terminado con la edición ahí. Por lo que esos serían los dos eventos a los que podrías agregar tus llamadas de función o llamadas de método también. Y sí, eso, eso es básicamente todo lo que hay al campo de entrada. No es nada loco o sí, también puedes establecer un límite de caracteres si quieres. Eso es algo que podrías hacer. Y hay algunas otras cosas como multilínea con Submit. También puedes convertirla en una nueva línea multilínea, y también hay algunas otras cosas. Entonces, ¿cuál es el tipo de contenido aquí? Un pin, un número entero. Entonces en realidad puede leer ese número decimal, ¿verdad? Entonces eso sería algo para el tipo de contenido. Básicamente podrías cambiar esto también. Pero en general, eso sería para el campo de entrada, ingrese al menú desplegable. Y eso concluiría el tipo de mirada a través, a través de todos los elementos de la UI de Unity. Te he mostrado básicamente todos ellos. Ahora para hacer de esto la UI bastante bien, ese es otro tema completamente diferente que definitivamente está en tus manos más que las mías. Eso tiene más que ver con especie del diseño de la experiencia del usuario. Y eso es difícil de que realmente se enseñe. Te quiero decir, o quiero enseñarte las habilidades técnicas y luego qué haces con ellas. Bueno, quiero decir, espero que pudieras impresionarme no solo a mí, sino quizá incluso a ti mismo y a mucha otra gente con lo que se te ocurra, ¿verdad? Entonces eso sería todo para la introducción de la interfaz de usuario. Siguiente conferencia, en realidad vamos a agregar algunas cosas más al clicker de queso. Por lo que vamos a añadir un definitivamente al menos el layout. Y entonces tal vez podamos ver si hay tal vez una o dos cosas más que podríamos agregar ahí, ¿no? Pero eso fue todo para la UI. Y en este caso, el desplegable, una conferencia de campo de entrada. Espero que esto te resulte útil y aprendas algo nuevo. Una vez más, si queda alguna pregunta, por favor siéntase libre de preguntar y me aseguraré de responder. Y sí. 80. (Unity UI) añadir grupos de diseños a nuestro Clicker de quesos: Está bien, como prometió, nos encontramos de vuelta en el clicker de queso aquí. Y esta es la última conferencia aquí para la introducción. Y sólo vamos a agregar básicamente a grupos de diseño, uno para el panel de construcción y otro para el panel de actualización. Porque ambos básicamente podrían bien, quiero decir, beneficiarse de esos. Y pensemos en esto. Por lo que el propio panel de construcción, simplemente podemos ir al componente Add Component, building panel app, y luego agregar un grupo de diseño vertical. Creo que eso tendría más sentido. Y deja que todo controle también el tamaño del niño y luego conseguir algo como 15, 15, 15, 15, 15, y luego espaciar también 15. Creo que eso realmente funciona muy bien. Y si tuviéramos aquí un tercer elemento, entonces esto sólo funcionaría. Y al cuarto, tendríamos que empezar a redimensionar un poco. O también podríamos pensar en no tener un grupo de diseño vertical y tal vez tener un grupo de diseño de cuadrícula. Podemos tener dos de esos al mismo tiempo. Eso tiene sentido. Entonces, vamos a quitar eso. Vamos a tener un grupo de diseño de cuadrícula. Y luego también asegurándose de que esto sea un poco más grande, supongo, porque de lo contrario eso no va a caber. Entonces algo así como 300, 200 tal vez, 300, 300 en realidad funcionaría. Y luego también asegurándonos de que tenemos un poco de relleno aquí. Ahí lo tienes. Por lo que esto también funcionará si cambiáramos con los prefabs reales son un poco. Pero en realidad creo que volvamos al grupo de maquetación vertical otra vez. Creo que eso estuvo bien. Y eso en realidad está bien, ¿verdad? Y cuando miramos el panel de actualización, claro que esos se generan a través de la interfaz de usuario de actualización. En realidad abramos esto también. Porque hay una cosa que por supuesto necesitamos cambiar. Y esa sería la posición local transformada aquí porque estábamos fijando la posición nosotros mismos. Ahora ya no necesitamos hacer esto. Por lo que básicamente podemos simplemente borrar esa línea por completo. Y en realidad vamos a comentarlo. Porque de lo contrario, quién sabe, tal vez eso sea mejor. Y entonces podemos hacer esto un poco más pequeño y simplemente, literalmente, simplemente agregar el grupo de diseño de cuadrícula. Si un poco de relleno, tal vez 10 aquí, y luego el tamaño de celda, en realidad creo que el tamaño de celda de un 100 debería estar bien. Probablemente podamos hacerlo un poco más pequeño, incluso 8585, algo así. Y veamos cómo se ve eso. Ahora eso está bien. Es decir, un poco de espaciado también estaría bien. Entonces 10 espaciado y luego pienso, bien, Eso en realidad está muy bien hecho. Y si añadiéramos nuevas actualizaciones aquí, podríamos por supuesto, hacerlo un poco más grande, algo así. Y luego las actualizaciones lo encajarían ahí también. Entonces eso es bastante aseado. En realidad. Eso es cómo, así es lo fácil que es tener realmente un diseño funcional. Y eso es realmente bonito. Entonces vamos a añadir realmente el pedacito de queso para que se enciendan. Sólo por el infierno de ello. Entonces lleguemos a 500 y sí. Sí. Por lo que aún funcionan totalmente bien a pesar de que están en grupo por capas. Y otra cosa más grande es que cuando hacemos clic en uno de ellos, se deshabilitan, ¿verdad? Eso es lo que nos fijamos. Por lo que el conjunto activo en el objeto del juego se establece en falso. Y si eso sucede, entonces como puedes ver, simplemente se mueven. Porque el grupo de maquetación básicamente pone su auto hacia fuera sólo en los elementos activos del juego. Entonces si volviéramos a habilitar esto, en realidad sólo funciona. Entonces eso es realmente bonito eso, eso funciona de forma inherente para la interfaz de usuario en el grupo de diseño. Entonces eso realmente funciona sin ningún tema, ¿verdad? Y entonces podríamos añadir una especie de otro panel aquí o algo así. O también podrías reemplazar todos los textos individuales por textos malla Pro para tener una sensación más agradable al mismo. Pero en general, creo que eso en realidad está bien. Eso es una especie de lo que me hubiera imaginado lo que haríamos por el tipo de diseños diferentes, ¿verdad? El panel de actualización que encontré que era como el más interesante. Y luego el panel de edificios, si añadiéramos algunos más de esos, probablemente tendríamos que realinear nuestro edificio real como el panel de construcción, el panel de construcción individual un poco. Pero en general, eso todavía funcionaría muy bien, ¿verdad? Y eso sería todo para la UI. Por ahora. Espero que te haya parecido útil este y otro rebanador de queso con eso sería una especie de completo. Y espero que hayas aprendido algo nuevo. Y si quedaba alguna pregunta, claro, como siempre siéntete libre de preguntar y me aseguraré de responder. Y sí. 81. (Unity Intermedio) añadir una fuente de audio: Muy bien, y bienvenidos a la sección de intermediarios de Unidad para este curso de unidad. Y en esta conferencia, vamos a echar un vistazo a las fuentes de audio y básicamente cómo reproducir audio. Y las opciones básicamente que tenemos con eso. Entonces lo primero es lo primero, porque estamos una vez más en un nuevo proyecto, primero configuremos aquí nuestra carpeta de activos. Y en este momento realmente vamos a necesitar unas cuantas cosas más. En primer lugar, por supuesto, los guiones una vez más, eso es un dado. Y luego vamos a duplicar esto con Control D. Entonces por supuesto necesitamos también los sprites. A pesar de que en este caso no vamos a usar ningún sprites en esta conferencia en particular, pero esos vendrán. No se preocupe. También necesitaremos animaciones. Simplemente vamos a sumar esto ya. Y entonces una de las cosas que vamos a necesitar, por supuesto, ahora mismo en esta conferencia es que el audio dentro de la carpeta Escenas. Vamos a crear una nueva escena, no un nuevo guión, una nueva escena, por supuesto, hace. Y esta es L, una, porque una vez que obtienes la primera conferencia en la sección intermedia, y esto serían fuentes de audio. Y luego en la carpeta de scripts, podemos crear una nueva carpeta, L1 audio. Y luego ahí dentro queremos un nuevo guión. Y a esa la vamos a llamar audio, audio ejemplo. Ahí lo tienes. En cuanto a eso es un bastante bueno ya m. Y entonces creo que una vez que iniciemos las fuentes de audio aquí, creo que tenemos todo lo que necesitamos para la configuración. Vamos a crear un objeto de juego vacío. Esta va a ser nuestra fuente de audio. Yo lo puse en 000, claro. Y luego le agregaremos el componente fuente de audio. Entonces bajo el audio, extrañamente, y esta es la más baja, la fuente de audio. Y hay un montón de cosas que básicamente podemos cambiar aquí en términos de campos. Pero primero agreguemos los ejemplos de audio aquí también. Entonces el guión al objeto del juego, y además agreguemos nuestros archivos de audio. Por lo que este por supuesto, se proporciona. También puedes jugar con tu propio archivo de audio. Pero pensé que tendría uno que es una especie de sonido como un divertido boing. Eso lo vamos a escuchar en un rato. Y bueno, en realidad hay una manera muy fácil de agregar esto. Tienes este año de referencia de clip de audio y simplemente puedes arrastrar esto, y luego ahí está dentro. Ahora esto por supuesto, se puede cambiar igual que con, por ejemplo, el renderizador sprite donde cambiamos el sprite igual que ese. También podemos cambiar este clip de audio vía script. En este caso, no lo vamos a cambiar. Lo que vamos a hacer es que vamos a tocar estos, el sonido real a través del guión. Entonces lo que vamos a hacer es antes que nada, vamos a pasar por esto un momento aquí. Mezclador de audio, podemos básicamente, así que como puedes ver, esto es básicamente si el sonido debe reproducirse a través de un mezclador de audio primero o directamente el oyente de audio. No vamos a usar un mezclador de audio en este caso. Entonces esto no nos interesa, simplemente silencia los efectos de bypass de sonido. Entonces si tenemos efectos en esto. En la fuente de audio real, vamos a simplemente ignorar aquellos si eso está en el efecto del oyente. En el oyente también puede tener algunos efectos. Tenemos zonas de reverberación y podemos pasar por alto. Por lo que esto estaría pasando por alto todos esos. Jugar en despierto simplemente significa tan pronto como este objeto de juego en particular se despierte con el componente fuente de audio en él, entonces reproducirá el sonido una vez. Y loops simplemente significa que hará bucle una vez que llegue al final del clip de audio, se reiniciará desde el principio. Aquí la prioridad, como pueden ver, la idea aquí es que así si nos leyeran esto rápidamente establece la prioridad de la fuente. Entonces ese tipo tiene sentido para el, cada fuente de audio tiene una prioridad particular. En este caso, será más probable que un sol con un valor prioritario mayor sea robado. Es probable que sean robados por sonidos con valores de prioridad más pequeños. ¿ Cómo hace eso, qué significa eso? Bueno, si tenemos dos cosas jugando al mismo tiempo, tal vez algo no pueda mantenerse al día. Por lo que a veces tenemos que tener una prioridad de esos. En realidad nunca había visto que realmente entrara en vigor. Pero también tengo que admitir que no he jugado por ahí con la OU, con eso. Un volumen debe ser autoexplicativo. Es simplemente el volumen del sonido. Tampoco debe ser una locura. Esta es simplemente la frecuencia y esto en realidad ralentizará y ralentizará y bajará la velocidad del sonido. Nos vamos a sanar en cuanto antes. Pan serial, si la codificación de video es correcta, entonces también deberías poder escuchar esto. Entonces esto es simplemente si viene o no del altavoz izquierdo o derecho. Una mezcla espacial es básicamente se puede tener audio 3D. En nuestro caso, hay tres REO ni siquiera tiene sentido porque estamos en un, en un juego bidimensional de todos modos, así que van y luego la mezcla de zona de reverberación, realidad no estoy un 100 por ciento seguro de dónde va esto. Básicamente siempre guardo esto en uno. En Ajustes de sonido 3D por defecto. Ahí están bastante cool. Entonces, en realidad tenemos un montón de cosas aquí. Una vez más, para nosotros en este momento no se necesita porque sólo nos ocupamos de 2D de todos modos. Por lo que 3D en realidad no tiene ningún sentido para nosotros de todos modos. ¿ Verdad? Entonces abramos nuestro ejemplo de audio y también desmarquemos la jugada en despierto. Porque no queremos que el guiso juegue despierto. En realidad queríamos jugar sólo cuando hacemos algo. Entonces lo primero, porque por supuesto este guión en particular está una vez más en los objetos reales del juego que son fuentes de audio en también. Vamos a hacer una fuente de audio privada aquí mismo. Y luego lo vamos a configurar haciendo lo siguiente es igual este punto Fuente de audio componente, y eso fue todo. Entonces porque por supuesto, el guión real está en el mismo objeto de juego que la fuente de audio. Simplemente podemos hacerlo con este comando. De lo contrario, es posible que necesitemos obtener el objeto del juego, pero el método del componente Get con la suficiente facilidad. Y entonces lo que vamos a hacer es que vamos a decir si entrada schottky abajo y bajar la llave, en realidad el ego consigue keydown. Y luego vamos a decir keycode dot space. Tomemos espacio aquí. Y luego tan fácil como se podría pensar, Audio Source dot, ahí tienes. Eso fue todo. Eso, eso, en realidad eso es todo lo que necesitamos para llamar a esto el único método al que necesitamos llamar para poder reproducir este sonido. Y escuchemos la gloria del divertido sonido del boing. Entonces si empiezo esto, no debería pasar nada. Y no pasa nada. Y si ahora presiono la barra espaciadora, ahí vamos, Funciona. Bueno, eso es bastante guay. Por lo que realmente puedo tocar un sonido cuando presiono la barra espaciadora. Y juguemos un poco con estas cosas. Entonces, por ejemplo, si tire un poco el pitch hacia arriba aquí, y como pueden ver ahora son piezas arriba y el pitch va hacia arriba. Si tiro un poco el tono hacia abajo, no demasiado, entonces suena como alguien. Eso es bastante bueno. ¿Verdad? Entonces eso es bastante gracioso. El bolígrafo estéreo, por lo que el bolígrafo estéreo, si toco esto, y ahora debería haberse movido básicamente todo el camino hasta el altavoz izquierdo. Y si vuelvo a tocar esto, ahora debería estar solo en tu altavoz derecho. Entonces si quieres controlar eso básicamente, entonces puedes hacerlo también. Por supuesto, todas esas cosas también se pueden controlar a través del guión. Entonces si echamos un vistazo a este punto fuente de audio por ejemplo, el año de lanzamiento se mueve un get y un set. Y tenemos el estéreo de pan, consigue un set. Podemos tener un booleano, mudo y todo tipo de cosas también. Entonces hay un montón de otras cosas que también podemos hacer. Incluyendo, por ejemplo, el volumen también podría establecerse de 0 a una y algunas de las otras cosas, pero el método de juego es uno de los más importantes. También hay una obra programada, así que básicamente puedes tener esto en un momento determinado. Podemos tener una jugada un tiro. Entonces esto reproduce el audio y luego lo escala hacia arriba. Esto en realidad también lo es, también puedes darle un clip de audio en realidad. Y luego jugar retrasado simplemente lo hace retrasado. Esas son como cosas muy específicas. Por lo general el audio source dot play es el que realmente necesitas, ¿verdad? Y eso en realidad ya sería por la idea de la fuente de audio. Y simplemente puedes agregarlo. Y lo que es muy importante es que, que el componente de la cámara suele tener el oyente de audio. Ese es uno de los componentes que necesitas en tu escena. Si no tienes eso, entonces no podrás básicamente aquí de esta fuente de audio y entonces ningún sonido realmente alcanzará. Entonces eso es muy importante tener en cuenta que como en realidad también en tu cámara principal, debería venir con la cámara principal. Por lo que cada vez que tengas una cámara principal en tu escena, ésta debería estar de inmediato ahí. Pero si por alguna extraña razón no lo es, entonces, ahora sabes que esto en realidad también es algo que necesitas robot que sería todo para esta conferencia. Espero que te resulte útil y aprendas algo nuevo. Como siempre. Si queda alguna pregunta, por favor siéntase libre de preguntar y me aseguraré de responder. Y sí. 82. (Unity Intermedio) añadir partículas: Muy bien, sigamos con la sección de unidad intermedia aquí para el curso de unidad. Y en esta conferencia, vamos a echar un vistazo rápido al sistema de partículas. Ahora el sistema de partículas es probablemente uno de los sistemas más extensos de Unity. Puede, quiero decir, casi se puede hacer cualquier cosa. Bueno, no nada literalmente, pero digamos en términos de partículas al menos. Entonces sumemos aquí una nueva escena, sistema de partículas L2. Abramos eso de inmediato también. Y entonces en realidad no necesitemos otra carpeta de scripts porque en esta, realidad no vamos a usar los scripts, scripts en ese en absoluto, ¿verdad? Y éste está bajo efectos. Entonces si hacemos clic derecho y luego vamos a Effects, tenemos un sistema de partículas. Entonces vamos a añadir este sistema de partículas y como puedes ver, inmediatamente se apaga y dispara partículas como locas. Y lo primero que vamos a hacer es básicamente tomar esto y arrastrar esto hacia abajo para que podamos ver un poco más del inspector aquí. Y no lo hice yo no lo hice cuando dije eso, eso fueron muchas cosas y hay aún más por lo que en realidad podemos básicamente cada una de esas o incluso más cosas. Y una de las cosas que quiero mencionar es que definitivamente no vamos a pasar por todo aquí porque tres horas después, básicamente estamos terminados con todo. Apenas de inmediato al principio, quiero decir que lo mejor que puedes hacer es simplemente jugar con esto tanto como básicamente necesitas Y como quieras. Porque esa es la mejor manera de aprender el sistema de partículas. Algunas de esas cosas deberían realmente tener una especie de sentido inherente. Entonces algo así. Empezar con qué? Inicio Color. ¿ Se inician las partículas? Qué tipo de gravedad modificada o tienen. Entonces ahora se están cayendo, como puedes ver, hay una especie de subir y luego van a bajar otra vez. Podemos cambiar la velocidad, ¿verdad? Por lo que ahora se mueve más rápido. O podemos decir, en realidad hagámoslo más lento, entonces es negativo dos. Hagamos en realidad también esa. Y no un 0, eso sería, sí, y son realmente, muy lentos. Entonces esa es una de esas cosas donde en realidad debería tener sentido. Bastante fácil. Entonces rotacion de volteo, no creo que realmente haga nada. Y este momento, no. Porque lo que también es importante que se diga es que el, este hace algo por lo que esto realmente rota las partículas reales. El sistema del producto generalmente se utiliza en el espacio tridimensional. Entonces si cambio al espacio tridimensional, como pueden ver ahora, van allá arriba. Pero no hay razón por la que no pudieras usarlo también en un proyecto bidimensional que así, realidad no hay razón para no hacer eso. ¿ Verdad? Entonces pensemos en esto. Aquí hay algunas cosas. Entonces la duración, quiero decir, también se puede pasar por encima de esos y obtener una estimación bastante buena en lo que son todas esas cosas. Definitivamente quiero mostrar algunas de esas cosas que estás aquí abajo. Entonces esas son una especie del tipo de funciones que puedes aplicarlo. Entonces por ejemplo, lo que realmente me gusta algo así como el color a lo largo de toda la vida. Entonces si pongo esa dentro, entonces en realidad puedo, como pueden ver, tener una especie de modo de color para que puedan empezar, por ejemplo, como blanco. Y luego cuando están ubicación está en un 100, entonces puedo decir, bueno entonces los quiero una especie de avaricia. ¿ Y qué pasa? Por lo que cuanto más lejos se alejan estas partículas de mi fuente, Se vuelven más verdes. Eso en realidad es bastante guay. Y eso es básicamente, se puede hacer esto con casi todas esas cosas. Eso se puede hacer con el tamaño, con la velocidad. Incluso, puedes incluso cambiar el color por la velocidad de la partícula real. Al igual que hay un millón de cosas que puedes hacer aquí. Se puede agregar ruido como se puede ver, es decir, eso es una locura. Puedes incluso agregar datos personalizados. No vamos a definitivamente no vamos a mirar los datos de los clientes porque eso es una locura. Pero digamos, por ejemplo, velocidad a lo largo de toda la vida. Entonces podemos, por ejemplo, darle un poco más de velocidades, por ejemplo, en la dirección z o en la dirección x. Entonces podemos realmente cambiar la trayectoria de esto. Lo que es más importante o interesante es en realidad la forma y no la emisión, sino la forma. El formato es básicamente qué tipo de controles donde se están engendrando las partículas. Entonces esta es la forma del cono y entonces podemos, por ejemplo, extender el ángulo. Y luego como puedes ver ahora es un ángulo de onda más plano, por lo que las partículas se están moviendo de una manera ángulo más plano aquí. También podemos ajustar el radio aquí abajo y también el grosor. El espesor en realidad no debería importar tanto. Porque una vez más, esto está en 3D. Entonces si voy al 3D, como puedes ver ahora, esto se ve un poco diferente, como puedes ver que lo hizo en dos dimensiones. Por eso dije que el producto es impresionante, generalmente se usa en tres dimensiones, pero no hay problema. También puedes hacerlo así. Y cuando se trata de las formas, aquí, puede ver que hay muchas formas que podemos usar. Entonces la esfera es, bueno, simplemente una esfera, por lo que comenzará por el principio y luego simplemente se moverá. También podemos extender el radio hasta donde están desovando. También tienen un arco diferente. Creo que el arco aquí es, una vez más, un poco de tema por la naturaleza bidimensional de esto. Veamos otro, el cono por ejemplo, yo en realidad, el cono era lo que hemos mirado al hemisferio. Pero eso es una especie de medio círculo. Buque abierto, radio más grande. Ahí vas. Algo así. Entonces como puedes ver, esto casi no tiene fin. Ahora podemos tener una especie de viga y podríamos, por ejemplo, tener un, otro gravamen escalable IFA, escalarlo hacia arriba. Y por ejemplo, esto podría ser, podrías tener esto y luego decir, por ejemplo, tener la idea de que podríamos tener un dónde es el tamaño más, digamos por vida. En realidad, hagamos las partículas max. También, muy importante por cierto. Pero en realidad quiero toda la vida, ¿verdad? Entonces es cuando mueren. Entonces básicamente puedes decir, bueno en realidad hagámoslo. Deja que mueran como 1.5 o algo así. Y entonces de repente bam, tienes una especie de efecto teletransportador fresco para como un 2D teletransportado. O sea, eso es, eso es tan fácil como lo es para el sistema de partículas como ejemplo aquí. Esa fue sólo una especie de idea que vino a la mente para la caja, por ejemplo. Y luego también puedes tener tus propios sprites personalizados ahí dentro como el tipo de área de desove, puedes tener un círculo. Ahora el círculo es básicamente un tema porque es una vez más la forma que se gira en este caso. Pero sí, esa es una especie de look general de para el sistema de partículas. De verdad tengo que ser honesto, hay tanto que puedes hacer con esto. Pero sugiero altamente que solo probemos un montón de cosas aquí porque yo, no te lleva a ningún lado si ves una especie de conferencia de tres horas sobre, vale, ¿qué hace cada una de esas cosas? Es decir, la mayoría de ellos son muy bien descritos color por velocidad, bien, entonces la partícula cambia su color por la velocidad que tiene. Eso es todo lo que hay. Y sí, una vez más, ¿qué es una locura también? Todas esas cosas también se pueden cambiar vía script. Por lo que básicamente también puedes cambiar todo tipo de cosas vía script. Entonces tal vez tengas un teleprompter que se ve así cuando es rojo, para que puedas teletransportarte y luego lo hagas verde cuando no puedes teletransportar algo así, solo como una idea. Entonces hay tantas cosas que puedes hacer con él. Sí, quiero dejarte con esto. Juega con él tanto como necesites. El sistema de partículas es increíblemente extenso y puede hacer muchas cosas. Pero como dije, lo mejor es jugar un poco con él. Yo sólo quería mostrarles algunas cosas aquí. Y así una especie de lo fundamental general de ello, ¿verdad? Entonces eso sería todo para esta conferencia. Espero que aprendas algo nuevo. Si quedan preguntas, por supuesto, siéntete libre de preguntar y seré más corto. Engendrado. Mano. Sí. 83. (Unity intermedio): Muy bien, sigamos con la sección intermedia Unidad aquí para el curso de unidad. Y luego en esta conferencia vamos a echar un vistazo rápido a los ajustes del proyecto. Entonces hay algo donde en realidad ni siquiera necesitamos una nueva escena cuatro. Sólo vamos a ir a editar aquí arriba y luego a Configuración del proyecto. Y luego nos van a golpear con un montón de cosas que sólo vamos a especie de glándulas por un poco. Algunas de esas cosas y la configuración del proyecto hemos visto una vez antes en la introducción nítida C para la generación C, C-sharp Project para el espacio de nombres. Entonces aquí pudimos básicamente poner en un espacio de nombres. Y ahora estamos básicamente inundados de todo tipo de ajustes que podemos poner. Contamos con ajustes de audio, contamos con gestores de paquetes, física personalizada. En realidad es bastante. Y por lo general lo que yo sugeriría es sólo tener ciertas cosas miradas si realmente las necesitas. Entonces vamos a ver algunas cosas que creo que son utilizables y sensatas de haber visto antes, pero normalmente ninguna de esas es realmente necesaria. Entonces yo soy, una de esas cosas es, por ejemplo, los gráficos. Podrás tener diferentes grados de gráficos. Y los incumplimientos, yo en realidad diría que nuestro mejor simplemente se mantuvo así. Ya sabes, hay algunos shader básicamente ajustes ahí dentro. No me metería con esos, sobre todo estamos en un entorno 2D. Definitivamente diría que los gráficos deben quedarse como están. En realidad se puede tener un gestor de entrada. Realmente no hemos hablado de esto antes. Encargado de paquetes, vamos a saltarnos la física, no nos interese. Nos interesa la física a D, y esa es la primera que aquí es muy interesante. Entonces, en primer lugar, podríamos, por ejemplo, tener una gravedad personalizada. Por supuesto, la gravedad en nuestro mundo es de 9.81 metros por segundo cuadrado. Y eso es lo mismo que está aquí. Pero si tú, por ejemplo, quieres tener una gravedad que se aplique de manera diferente, entonces puedes cambiarla aquí, un proyecto amplio básicamente. Y también hay tantas otras cosas que también puedes cambiar en año. Siendo la idea que hay, la física básicamente son completamente personalizables. Entonces eso es bastante guay. En realidad. El ajustes del jugador es otra de esas cosas que son muy interesantes. Por lo que aquí puede suministrar un nombre de empresa y también un nombre de producto, así como una versión. También puedes anular el icono de tu EXE básicamente. Y también puedes anular el cursor. Entonces también hay algunas configuraciones, por ejemplo, para la PC aquí. Esto también aquí el icono en la versión de PC para su EXE. Después tienes algunas opciones básicas de resolución y presentación. Para que puedas decir cuál es el modo básico de pantalla completa? Personalmente creo que una ventana de pantalla completa es básicamente la mejor. También es posible que se ejecute una resolución nativa predeterminada en segundo plano. Entonces esta sería, como puedes ver, la idea de si haces clic fuera de la ventana, si el juego continúa o no en segundo plano. Y luego algunas cosas más que también funcionan ventana resizable sería algo que podría ser interesante. Y sí, así que eso funcionaría. Después también hay opciones de imagen splash. Entonces este es el básicamente el inicio del juego. En realidad podemos tomar un adelanto para eso. Por lo que en el inicio del juego, tendrás, verás esto hecho con Unity. También puedes agregar tus pantallas de salpicaduras personalizadas allí también. Entonces si hago esto, se van, básicamente puedes agregar logotipos y luego puedes decir: Oye, ¿dónde está esto, ya sabes, lo quieres antes del logo de la unidad después, y así sucesivamente y así sucesivamente. Puedes hacer tu propia imagen de fondo, todo eso. Entonces básicamente, esto es algo que tendrías si realmente tienes una especie de, un, un real tal vez incluso Studio. Y luego tienes tu logo y lo muestras y luego haces, tiene un logo de unity y luego cualquier otro logo que puedas necesitar, tal vez para un editor o algo así, sería entonces básicamente aquí. Pero una vez más, muchos de esos ajustes de proyectos son realmente para personas que están camino, mucho más avanzadas en incluso su juego. Sí, y luego hay algunos otros ajustes también. Por lo general, la mayoría de ellos se pueden dejar tal como están. Y eso definitivamente es lo que recomendaría. Como puedes ver una vez más, que hay tantas cosas que básicamente puedes tener aquí que en realidad es locura. El siguiente cosa muy interesante. Por lo que tanto el gestor preestablecido como la calidad, básicamente no nos vamos a importar así como las plantillas de escena. Esos podrían ser interesantes para crear tipo de plantillas para escenas. Pero actualmente, esto no es realmente necesario para nuestro caso de uso aquí. Lo interesante, sin embargo, es el servicio de ejecución de scripts. Y esa es una de las cosas a las que me referí en una conferencia anterior donde teníamos dos cosas donde un GameObject estaba siendo establecido por un guión y el guión estaba leyendo ese objeto de juego. Y el tema ahí fue que, bueno, tal vez uno de los otros, uno de los va a ser ejecutado primero y el otro es segundo. Por lo que aquí básicamente podemos agregar guiones. Por ejemplo, basta con añadir el script de ejemplo de audio. Y entonces podemos decir, bueno, ¿cuándo se va a ejecutar básicamente esto? Por lo que se trata de un script de adición al pedido del cliente y arrástrelos para reordenar scripts y el cliente puede ejecutarlo antes o después de la hora predeterminada. Por lo que este es el tiempo predeterminado y ejecutado de arriba a abajo. Entonces básicamente, primero de esos y luego, y luego en algún momento llegaremos a la muestra de audio. Entonces eso es algo donde no necesariamente tienes que tener la función despierto y inicio o un método. Más bien usa esos para especie de saber cuál se ejecuta primero porque tal vez tenemos dos cosas que se ejecutan en el método despierto en dos scripts diferentes. Y estamos como, Vale, este guión tiene que correr antes de este guión. Y esta es una forma en la que podemos asegurar esto. Entonces, por eso la orden de ejecución del script puede ser realmente, realmente importante. Los servicios, vamos a aplicar en realidad esto. Los servicios una vez más son algo que yo diría personalmente. Nos vamos a saltar una vez más porque eso es algo que es un camino más avanzado para que realmente tengas un proyecto real que quizá quieras tener. ¿ En qué quieres colaborar? Y o bien tener compras in-app, Cloud builds, y todo eso. No realmente interesante. Etiquetas y capas es algo que vamos a ver en un posterior bajando la línea. Esto es en una futura conferencia, especialmente las etiquetas o lo que vamos a ver. Un Pro basado en texto muy interesante que es simplemente la pantalla que teníamos cuando importamos un texto smash bro la última vez, el temporizador también ser algo que es importante o interesante. Básicamente tenemos algunos escalones de tiempos fijos así como la escala temporal. Esto es básicamente lo que obtenemos si llamamos una escala de tiempo.Deltatime. Y podemos, por cierto, también cambiar esto en el script VA y luego el tiempo básicamente se detiene. Entonces eso es algo que también podemos hacer. Y todas las demás cosas no nos interesan. El único que podría ser interesante es el papel divergente con los archivos metálicos visibles, que quizá quisiéramos habilitar básicamente para nuestro no sé por qué empezó. De repente eso es un poco raro sobre que quizá queramos tener aquí los mesófilos visibles. Porque tal vez lo que queremos es tener esto en GitHub y luego los mesófilos visibles tienen sentido, ¿verdad? Y eso sería básicamente por la rápida mirada a los ajustes del proyecto. Como dije, solo quería darte un vistazo somero de algunos de ellos, sobre todo la orden de ejecución puede ser muy, muy interesante e importante. Y la física 2D que básicamente puedes personalizar esos también es bastante cool. Definitivamente te aconsejaría si hay ciertas cosas, entonces también puedes mirar hacia arriba siempre buscar ciertas cosas que quieras. Por lo general, no lo sé. Entonces, por ejemplo, pudo haber sido que, Hey, en realidad quiero tener el tiempo para dormir ser más grande o quería establecer la escala temporal en algo más de uno, y eso es exactamente lo que debes hacer. Por lo que caso por caso, les aconsejaría que busquen los ajustes del proyecto en la unidad en la documentación de Unity. Esa es la mejor idea que te puedo dar por esto porque de lo contrario, una vez más, al igual que con el sistema de partículas, estará aquí después de tres horas. Y luego pasaríamos por todos los ajustes del proyecto. Y luego las dos primeras horas habrían sido simplemente olvidadas después de la última hora. Entonces por eso solo quería mencionar que esos existen pueden ser útiles en algún momento por debajo de la línea. Pero ahora mismo, solo te aconsejo que aceptes esto. Está bien. Y entonces sigamos adelante para la próxima vez, ¿verdad? Por lo que esto sería todo para esta conferencia. Una vez más, si quedan preguntas, por supuesto, siéntete libre de preguntar y me aseguraré de responder. Y sí. 84. (Unity intermedio) añadir etiquetas a GameObjects: Muy bien, sigamos con la sección intermedia Unidad aquí para el curso de unidad. Y en esta conferencia, vamos a echar un vistazo a las etiquetas. Y para ello, en primer lugar, vamos a añadir algunos sprites bonitos a este proyecto aquí. Tenemos nuestras buenas cartas viejas que hemos utilizado previamente. Esta es una vez más las múltiples cartas. Por lo que sólo vamos a poner básicamente unos ajustes aquí. Punto de Modo Filtro, vamos a poner los píxeles por unidad a 16, además de poner el modo sprite a múltiplo. Entonces vamos a aplicar esto yendo al Sprite Editor. Pon el rebanado a automático, Eso está bien. Y luego rebanar. Y entonces nos tenemos tarjetas individuales aquí con un ancho de 42 y una altura de 60. Hit Postúlate aquí. Y entonces en realidad estamos bien. Y luego dentro de aquí tenemos esas cartas, core 0, 1, todo el camino hasta 55. Y sólo vamos a tomar Corte 0 y ponerlo en nuestro pequeño mundo oye en nuestra escena. Y creo que 02 es una gran posición para esto. En realidad, nada de eso es un sistema de partículas. Primero que nada, creemos una nueva escena, por supuesto, para mantener todo bonito y ordenado. Y esto sería L4, que está agregando etiquetas. Y eso también está abierto esto. Y luego dentro de aquí podemos poner la tarjeta y van a 0.5, ¿verdad? Eso es genial. Esa es una buena posición que son. Y entonces queremos un bonito GameObject vacío aquí. Por supuesto, en 000, 000 o Mónaco, esta etiqueta. Y luego dentro de nuestra carpeta de guiones, una nueva carpeta. No, eso no funcionó. Ahí lo tienes. Scripts. Scripts, crear carpeta, etiquetas L4. Y luego vamos a crear un nuevo guión de C Sharp. Sólo vamos a llamar a eso etiquetas también. Y esto se agregará a nuestro objeto de juego vacío aquí. Y luego echaremos un vistazo a lo que esto realmente puede hacer por nosotros. ¿Está bien? Entonces antes que nada, unas etiquetas, ¿cuáles son nuestras etiquetas? Bueno, la idea es que se pueden agregar ciertos elementos a los objetos del juego, y eso es exactamente aquí arriba. Entonces como puedes ver, etiquetado y actualmente esto está sin etiquetar, esto es desenredar. En realidad, la cámara principal tiene detectar cámara principal. Y lo que podemos hacer es que si entramos en esto, realidad podemos ver que hay algunas etiquetas predefinidas para nosotros. Responder editor de acabado solo jugador de cámara principal y el controlador de juego. Y luego también está la etiqueta edge, básicamente funcionalidad en la que podemos hacer click. Y luego en el Inspector obtenemos estas etiquetas y las capas sentirán que podemos ver. Y en lugar de aquí, como se puede ver, lista de impuestos está vacía. Por lo que la lista de nuestras etiquetas predefinidas que hemos definido está vacía y podemos darle a este pequeño plus y luego tenemos que especificar un nombre. Entonces, por ejemplo, podemos decir, bueno, la cancha, el nuevo nombre de la etiqueta es tarjeta y luego guardar esto. Entonces esto ahora está etiquetado 0. Y entonces podemos, por ejemplo, añadir enemigo también. Y entonces tal vez algo así como. Ni siquiera se sabe la salud o, o, o, o, o daño, algo así. Entonces, ¿qué hace eso? Entonces, ¿qué hace eso ahora mismo? Entonces vamos al vector, a la tarjeta. En primer lugar, muy importante si agregas ataque vía esta suma, tenemos este menú desplegable. No agrega automáticamente la etiqueta al objeto del juego. Tendrás que estar abierto el desplegable y luego básicamente seleccionar esto. Entonces vamos a decir cordel porque esto tiene tarjeta desprendida, porque esta es una tarjeta. Y entonces podemos pensar que esta es básicamente una de las otras formas que podemos ver, vale, es este GameObject un cierto tipo de objeto básicamente, antes, cuando pensamos de vuelta a donde teníamos el colisionador de cajas, donde usamos los colisionadores. Ahí. Pudimos comparar el nombre del objeto. Pero ya sabes, a veces el nombre cambia y tal vez diferentes enemigos tienen nombres diferentes. Y quieres tener algún tipo de otra marca identificativa. Y eso podría, por ejemplo, ser una etiqueta enemiga. ¿ Y cómo usamos esta etiqueta? Bueno, esta etiqueta es en realidad sólo una cuerda. Es muy fácil de usar. Por lo que sólo vamos a hacer un registro de punto de depuración aquí. Y luego vamos a decir GameObject dot find. Y vamos a encontrar acordes 0 porque ese es por supuesto el nombre de este objeto de juego en este caso. Y luego vamos a decir, por ejemplo, tag, como se puede ver aquí, es sólo una cuerda. Y luego vamos a copiar esto con Control C. Y luego hay otra función o método realmente agradable aquí llamado compare tag. Y luego dentro de aquí podemos, por ejemplo, decir tarjeta. Y luego hay otro, Digamos enemigo. ¿ Verdad? Así que idea estar aquí. El primero, sólo vamos a dar salida a la etiqueta, como se puede ver, etiqueta de este objeto de juego. Y entonces la etiqueta de comparación es este juego objetos tarea con lo que sea etiqueta que le demos como perímetro? Esto es por supuesto que va a ser cierto porque cord es exactamente la etiqueta a la que lo hemos puesto. Un enemigo debe ser una falsa comparación. En este caso, es mejor usar este método del método CompareTo en lugar de hacer nuestro propio una comparación de cadenas, creo que hay un poco de debate al respecto. Pero generalmente el método CompareTo se ve más bonito de todos modos, en lugar de hacer tag dot es igual y luego se pone, está bien. Comparar etiqueta en realidad es realmente un buen método. Está bien, entonces en teoría, esto debería funcionar como de inmediato, Vamos a ver, tarjeta, vale, primero que nada, eso, esa es la etiqueta que aquí tenemos predefinido. Y entonces por supuesto, es cierto que la etiqueta y el carro y la TC son exactamente la misma etiqueta. Y entonces enemigo no es en realidad la etiqueta que tiene esta cancha, este objeto de juego, ¿verdad? Y eso en realidad es todo lo que hay a las etiquetas. No son locos, complicados, pero pueden ser realmente útiles si tienes ciertas cosas predefinidas que deberían funcionar de una manera particular. Y son realmente útiles, sobre todo cuando usas los planeadores. Básicamente podemos simplemente comparar etiquetas. Están en lugar de comparar el nombre como lo hicimos nosotros. Y son algo normal que forma parte de un GameObject como puedes ver. Por lo que esta es una propiedad normal del objeto del juego y puedes acceder a él e incluso ponerlo dentro del guión si te gustaría escribir, y eso sería todo para esta conferencia una vez más, espero que lo hayas encontrado útil y hayas aprendido algo nuevo. Si quedan preguntas, entonces por supuesto, siéntete libre de preguntar y me aseguraré de responder. Y sí. 85. (Unity Intermedio) Raycasting 2D en la unidad: Muy bien, sigamos con la sección intermedia Unidad aquí para el curso de unidad. Y en esta conferencia, vamos a echar un vistazo rápido a un casting de rayos. Por lo que refundir, tal vez ya has oído hablar de ello antes. Es básicamente una forma de mirar si o no si fuera a disparar un proyectil en una dirección determinada, si eso ha golpeado o no algo que tiene una de las cosas donde se utiliza. Muy a menudo diría que uno de sus casos de uso puede ser básicamente hacer detección de golpes. Entonces en lugar de engendrar una bala y tener realmente el sistema de física una especie de calcular su trayectoria y tener un nuevo objeto de juego y algo así. En realidad sólo dibujamos un costo de rayo, que es una especie de línea invisible. Somos vector invisible que luego tipo de detecta cuando golpea un determinado colisionador básico. Y vamos a echarle un vistazo a eso. Entonces parece nueva escena. Esta va a ser la refundición de L5. Ahora. Ah, eso en realidad es así. Ahí vas. Y el, vamos a ver la refundición en dos dimensiones. Ahora en tres dimensiones, lo único que realmente cambia es el número de lo que el vector que tienes que poner. Entonces en lugar de un vector para tener que poner en un vector de tres. Pero aparte de eso, todo realmente permanece igual. Y luego una nueva carpeta dentro de nuestra carpeta de scripts L5 refundición, así como un nuevo guión ahí dentro. Y que para sorpresa de nadie también se llama casting de rayos. Genial. Entonces ahora sumemos en realidad dos cartas aquí. Entonces vamos a añadir una especie de as de corazones. Y entonces sólo voy a escoger al azar fuera de esto. Entonces ahora tenemos dos cartas aquí. Y lo que vamos a hacer es ir a semicentralizados, así que negativo seis y luego poner la y a 0. Y voy a poner este en negativo. Y el X86, Eso es genial. Y uno de esos va a ser bien detectado en un rato. Y uno de los uno. Por lo que el as de corazones en realidad va a disparar un recast de sí mismo. Y luego va a detectar básicamente este acorde aquí. Y la forma en que podemos hacer esto es en primer lugar, vamos a añadir un colisionador de cajas para descartar. Entonces para los cinco de clubes, supongo que esto sería una vez más en Física 2D y luego solo colisionador de cajas para que se dibuje un bonito desorden de caja alrededor de él. Y luego al 0 o al as de corazones en este caso, simplemente podemos agregar nuestro guión para que vuelvan correcto script de casting se va a agregar aquí que vas. Y el otro tiene una parcela de caja. Abramos el guión de casting de rayos y veamos qué podemos hacer realmente aquí. Y esto va a ser algo bastante fácil de hacer. Entonces, en primer lugar, vamos a eliminar el método de inicio porque sólo necesitamos el método de actualización. Y dentro de aquí, input.txt obtiene una llave. Vamos a llevar al portero, en este caso, no a la llave hacia abajo. Y vamos a tomar espacio en este caso. Porque lo que quiero hacer es básicamente quiero hacer siempre una nueva. En realidad vamos a hacer key down por ahora primero y luego podemos cambiarlo más tarde. Si queremos. Un nuevo método, vacío privado, engendrado, refundido. Esto es sólo para que podamos leerlo un poco mejor. Entonces esto es por el bien de legibilidad así como solo porque es un poco más agradable en lugar de poner esto dentro del tipo de la declaración if allí. Y lo que queremos es un recast hit 2D. Esto es lo que queremos. Esto es igual a un rayo. Por lo que esto se llama raid la variable, y esto es igual a la física 2D. Entonces esta física a D es un punto de clase re-cast. Y esto toma, como se puede ver, un origen y una dirección. Y también podemos suplir algunas cosas más. Entonces esta va a ser esta transformada de puntos, esa posición. Y luego se pone una dirección. En nuestro caso lo que queremos este vector a dot-dot-dot, ¿verdad? Entonces también podemos especificar una distancia, como se puede ver, vamos a hacer 15 F por ahora. Y entonces vamos a estar bien. Si no especificas una dirección, entonces el rayo va a ser infinitamente largo. Y en básicamente el mismo trazo o lo vamos a hacer es que vamos a dibujar, así que debug dot draw ray. Por lo que en realidad podemos dibujar un rayo cuesta aquí, como se puede ver también. En este caso, en realidad se necesita un vector tridimensional. Entonces vector tres, así como una dirección. No obstante, eso no es un tema porque simplemente podemos pasarlo. Esta transformación de puntos, vector de posición de puntos, el vector dos puntos, ¿verdad? Veces 15, porque esa es básicamente la longitud que hemos especificado aquí, ¿no? Esta dirección y esta es la longitud. Y si sólo multiplicamos esos, y eso también funciona muy bien. Y entonces tenemos que suministrar un color. Hagamos azul aquí. Hagamos azul. Y luego hay una duración. Entonces esto es por cuánto tiempo se dibujará este rayo en realidad. Voy a tomar cinco segundos. Entonces esto se parece mucho a una línea de dibujo, solo que es específicamente para un rayo en este caso. Y luego qué podemos hacer, así como debug dot log re dot collider dot. Entonces este es el GameObject, Veamos, colisionador. Este es en realidad el colisionador 2D que se adjunta al objeto del juego que esta matriz ha golpeado. Y solo voy a decir nombre por ahora, vamos a enviar el nombre a lo que sea que el recast real haya golpeado. Entonces si piensas en esto, lo que debería pasar es que desde la posición negativa 600, un recast 15 riqueza mundial pasos junto con 15 unidades mundiales a lo largo de engendro. Y luego tan pronto como llegue a las canchas, 32, básicamente debería dar salida a eso también. Entonces vamos a ver si eso realmente funciona. Entonces en este momento estamos en el juego y yo golpeo la barra espaciadora y se puede ver núcleos 32 realmente obtiene salida. Y en realidad también podemos ver esta línea azul muy delgada. Es muy, muy, realidad no es muy bueno ver. De hecho, volvamos atrás y hagamos esto rojo. A lo mejor, a lo mejor el rojo es un poco mejor para ver. Ese podría ser el caso. Entonces, veamos si eso funciona. Sí, el rojo es un poco mejor. Entonces C, solo lo voy a pausar. En lugar de nuestra escena aquí, en realidad la podemos ver un poco mejor. Como se puede ver desde el centro de la tarjeta afuera, vamos a la derecha, exactamente 15 unidades básicamente. Y golpeamos este acorde y este rayo luego básicamente detecta, oh, he golpeado una tarjeta y luego sale el nombre real de la misma. Ahora, podemos hacer esto varias veces, ¿verdad? Entonces podemos engendrar array. Ahora, el rayo en realidad se habría ido a este punto porque ya hemos golpeado algo que hemos hecho, hemos terminado. Entonces el visual es un poco, bueno, yo no diría que no diría que es engañoso, pero el visual se queda un poco más, solo para que tengamos un espectáculo que realmente podamos ver lo que está pasando. Si tuviéramos que tomar esta tarjeta y moverla hacia abajo. Lo que verán es que de repente vamos a conseguir una referencia nula porque no hemos golpeado nada dentro de este rayo. Entonces eso también es algo que definitivamente debes considerar que tal vez re colisionador de puntos en realidad va a ser nulo. Por lo que sólo ten en cuenta eso. Y si lo volvemos a poner y lo volvemos a golpear, entonces como puedes ver, las cartas 32 se salen varias veces. Entonces con eso básicamente podemos decir, ¿de acuerdo, dónde está esto? También podemos echar un vistazo a dónde se golpeó esto y todo tipo de otras cosas divertidas. Por lo que el rayo en realidad tiene algunas cosas ahí. Vamos a ver lo que el rayo también tiene para ofrecer. Para que podamos conseguir el colisionador. También podemos conseguir la distancia que es puede ser realmente útil. Y esta es la fracción C de la distancia a lo largo del rayo que ocurrió el golpe. Básicamente significa que si el rayo tiene 10 unidades de largo y se golpeó exactamente en la mitad de la longitud de la matriz, entonces esto obtendría 0.5 porque eso es 50 por ciento de la longitud de la matriz. Hay un vector normal que podrías obtener lo que podría ser útil si quieres hacer cosas de lujo con vectores que son. También puedes obtener de inmediato el cuerpo rígido que está unido al objeto del juego. En nuestro caso, en realidad no tenemos un cuerpo rígido unido, unido a él. También se puede obtener el punto, el punto exacto en el espacio mundial donde el rayo golpea el objetivo. Entonces esto sería, bueno, en nuestro caso estaría en algún lugar aquí. Esta es una de las formas en que se podría, por ejemplo, decir, Bueno tal vez si golpea en la parte superior aquí, entonces quieres que tal vez la mitad superior de este núcleo se desvanezca. Y si te golpea en la parte inferior, entonces quieres que la mitad inferior se desvanezca en algún lugar así. Por lo que puedes especie de hacerte sin daños en partes particulares de esta tarjeta. Pero sí, ese es el calentador básico de refundición. Es realmente útil porque con por supuesto, el colisionador una vez más, puedes obtener muy fácilmente el GameObject dot GameObject como puedes ver. Y luego tienes el GameObject y eso por supuesto, abre básicamente todo lo que el, que el objeto del juego tiene derechos que puedes obtener, hacer volver a obtener componente, conseguir cualquier componente que tenga, y hacer todo tipo de locuras con él. Entonces podrías golpearlo y luego cambiar su posición o podrías cambiar su tamaño, algo así. Entonces básicamente el, las posibilidades son realmente interminables en este. Y el recast es simplemente de una manera tú, que podrías hacer esto básicamente. Y es una manera justa, yo diría barata. Todas las cosas consideradas para hacer esto. Entonces si tienes una escena 2D básica donde dispararías algo, entonces tal vez poner en recast es un poco mejor. Bueno, sí, hay numerosas opciones de lo que se puede utilizar re costos con. Esos son sólo algunos de los que mencioné. Una de las que usé, por ejemplo, estaba dentro de mi, tenía un juego 2D. Seamos similares a Zelda, digamos. Y yo estaba disparando en un re-cast fuera de mi personaje cada vez que presiono la barra espaciadora para básicamente hablar con los PNJ. Todos los Npcs tenían un colisionador de caja y también tenían una interfaz llamada rastreable. Y si el recast detectó que tenían una interfaz tolerable para los ojos básicamente apegada a ellos. Entonces pude hablar con ellos. Esa fue básicamente la forma en que uso el recast en un ejemplo. Pero claro, hay tantas maneras en que puedes usar el recast que sí, solo quería mostrarte cómo puedes usarlo y cuanto más lo usas para, bueno, eso realmente depende de ti. Y eso será todo para esta conferencia sobre el casting de rayos. Espero que esto te resulte útil. Como siempre. Si queda alguna pregunta, entonces por favor siéntase libre de preguntar y me aseguraré de responder. Y sí. 86. (Unity Intermedio): Muy bien, sigamos con la sección intermedia Unidad aquí para el curso de unidad. Y en esta conferencia vamos a echar un vistazo a cómo guardar datos con prefs de jugadores. Y sí, así que básicamente cómo puedes guardar datos particulares en el disco duro. Y luego cuando básicamente recargas una caja fuerte, por ejemplo, ¿cómo funciona eso? Y podemos hacer eso con algo que se llama prefs de jugador. Esa es una clase que nos proporciona la unidad en la que básicamente podemos asegurar enteros, cadenas, y especie de los tipos de datos normales y primitivos. Ahora para hacer esto, en realidad vamos a construir un bastante grande visto en esta conferencia aquí. Por lo que este es L6 jugador prefs. Y la razón por la que quiero construir un poco de una escena más grande aquí es porque el número 1, es una buena práctica. Entonces eso es bastante bueno. Y luego número dos, esto también se usará próxima conferencia cuando estemos guardando y cargando con archivos JSON. Pero llegaremos a eso una vez que sea el momento, ¿verdad? Si no te interesa básicamente la pelusa que lo rodea y hacer la UI aquí, entonces puedes, por supuesto, también saltarte esta conferencia porque la siguiente conferencia es básicamente solo la pared, cómo haces que el jugador prefs por su cuenta. Y simplemente puedes descargar el paquete real que se proporciona. Ahí. Todo ya está configurado la escena y los prefs del jugador y todos los guiones básicamente están configurados. El único que no está configurado es el guardado y carga de los datos, que luego podrías seguir básicamente. Yo sólo quería mencionar esto porque el jugador real prefs es sólo unos cinco minutos de la conferencia real. El resto es una especie de cosa a su alrededor. Yo sólo quería mencionar esto. No necesariamente tienes que configurarlo. También puedes simplemente descargarlo. Entonces sí, entonces L6, jugador prefs. Y para crear nuestros guiones, realidad tenemos cuatro guiones, en este caso, el de, el primero se llama población. Y luego probablemente, sí, ahí tienes. Y luego el segundo es un dato de jugador. Entonces esto es solo un ejemplo para algunos datos de jugadores que vamos a usar. Entonces tenemos estos prefs de jugador seguro que va a ser el archivo real o el script que va a guardar los datos. Y luego también tenemos un Administrador de UI que va a administrar la interfaz de usuario que se mostrará. Entonces abramos esos tras otro. Datos principales de los jugadores de población, seguros, jugadores prefs, y luego último pero no menos importante, el Administrador de UI. El primero que vamos a echar un vistazo es la población cancha, que va a ser muy, muy fácil. Eso en realidad va a ser como el más fácil de todos. Porque éste simplemente tendrá una lista privada de Sprite. No, no dibujo primaveral sino Sprite. Van como van a ser fríos, todos llamados sprites. Y luego vamos a hacer de este campo serializado. Eso es, Eso es todo el auto que tiene la población. Se trata simplemente de un comportamiento mono que sostendrá todas nuestras cartas. Y de inmediato podemos agregar esto como un objeto de juego vacío aquí. Por lo que esta sería nuestra tarjeta. Población. Y luego vamos a agregar esto al objeto real y luego nuestros núcleos que ya has importado. Una vez más, vamos a, en primer lugar, vamos a encerrar esto aquí. Por lo que seleccionando la tarjeta población GameObject, bloqueando al inspector. Y vamos a seleccionar Acordes 0 y luego mantener presionada nuestra tecla Mayús bajamos para que si cada carta seleccionada, y luego simplemente vamos a arrastrar esas hacia todos los sprites de cable. Y ahora tenemos todas las novias canchas aquí, ordenadamente dentro de nuestro guión poblacional cartulina. Y eso se utilizará posteriormente para hacer referencia básicamente a una tarjeta sprites diferentes. Y sí, así que entonces sigamos y primero construyamos una interfaz de usuario muy agradable. Entonces para eso, vamos a añadir aquí un panel de esta noche y luego el lienzo, primero que nada, por supuesto, desbloqueando esto de nuevo. Y entonces el lienzo se pondrá a la cámara espacial de pantalla. Agregando la cámara principal aquí. Esto no debería ser nada demasiado loco. Y entonces el panel será una especie de en la mitad inferior de la, la mitad inferior o el tercio inferior. Hagamos la mitad inferior, Eso está bien del campo visual. Y también tendremos una tarjeta. Entonces vamos a poner en un tribunal oye ocurrieron 0. Esto va a ser en 0.52. Creo que eso está bien. Y a esto se le va a llamar el cable del jugador. Entonces este es el auto. Básicamente, el jugador puede elegir qué carta se está mostrando aquí y vamos a guardar eso. Y cuando volvamos a cargar los datos, entonces la tarjeta cambiará en realidad. Entonces esa es una de las cosas que vamos a hacer. También tenemos que construir unas cuantas cosas más en el lienzo aquí. Entonces eso va a ser un poco más extenso en este caso. Una de las cosas que vamos a tener es un desplegable y vamos a utilizar el texto Mesh pro en este caso. Entonces hagamos aquí los esenciales de importación TMP. Ahora que tenemos la sonda de texto Mesh básicamente en esto también. Entonces hagamos esto un poco más grande. Algo así probablemente va a bastar por ahora. Podemos mirar eso en un poco más tarde. Entonces este sería el, básicamente el desplegable de la tarjeta, ¿no? Por lo que vamos a renombrar este desplegable de tarjeta. Este es el menú desplegable desde el que podemos básicamente desde el que podremos elegir las cartas. Eso lo vamos a poblar con las canchas más tarde por la línea. Y entonces tendremos tres insumos. Entonces esto va a ser una UI y un campo de entrada, también texto Mesh Pro. Porque ¿por qué no? Hagamos esto algo así. Tratemos de centrarlo más o menos. Y luego vamos a entrar en este campo de entrada y simplemente redimensionar esta semana este tamaño automático. Por lo que el Marcador de posición es de tamaño automático y otros textos también se autodimensionarán. Y entonces este campo de entrada va a ser la entrada HP. Entonces eso es, voy a básicamente, sí, Bueno, en primer lugar, vamos a construir esto y luego vamos a construir los datos a ella mientras seleccionamos este Control D para duplicarlo. Y entonces esto se va a arrastrar un poco hacia abajo. Y esta sería la entrada vacía, por ejemplo. Y luego vamos a duplicar eso también. Y entonces esta va a ser la entrada de XP. Y el, también voy a conseguir algunas etiquetas ahí. Esto sólo va a ser texto Mesh Pro. Entonces esta es la etiqueta HP, por ejemplo. Hagamos éste. Y vamos a mover esto, en realidad hacerlo un poco más grande. Mueve esto aquí arriba. Y esto es HP, ¿verdad? También podemos autodimensionar esto. Eso es genial, Eso es bastante bueno. Duplicarlo una vez más con aquí Control D y luego otro, regla d Esta sería la etiqueta MPI, siempre asegurándose de que esto es un bien hecho aquí así como los objetos del juego que se renombran portal correctamente, así como entonces por supuesto, también cambiando los textos que son. Porque esto te va a ahorrar mucho dolor de cabeza, sobre todo más tarde por la línea. Si tal vez quieras cambiar algunas cosas, ellas son vas a estar feliz de que renombres esto correctamente. Y luego dos últimas cosas, y esas van a ser dos botones. Un botón justo aquí. Esto va a ser una vez más un botón pro Mesh de texto. Y este va a ser el botón para ser el botón Guardar. Y luego duplicemos eso también. En realidad cambia el para que solo puedas volver atrás control Z. Por supuesto, este puede ser el botón Datos seguro, y luego vamos a copiar esto. En realidad. Hagamos también el tamaño automático, por lo que en realidad es aún mejor. Ahora duplicado. Pero parece que este va a ser el botón Cargar, botón cargar. Y luego también cambia el texto aquí para cargar datos. este momento se configura el primer panel aquí. Y ahora queremos un segundo panel. Y esto es básicamente para mostrar lo que hayamos puesto ahí va a ser tu panel. Y luego hazlo un poco más pequeño al lado derecho aquí. Vamos a tener un panel aquí arriba, que va a mostrar el resto de los datos. Por lo que este va a ser el panel de datos del jugador. Y en este, vamos a tener un texto de UI en la parte superior. Lo cual sólo va a decir, esto sólo va a ser el sello de datos del jugador. Por ejemplo. Esto sólo va a decir jugador, un jugador data auto size y luego también lo hacen centro id, el ego. Y luego vamos a tener texto. Esta va a ser la etiqueta de cada peal HP una vez más. Entonces, por ejemplo, también podríamos seleccionar esos y luego duplicarlos de nuevo. Llévalos al panel de datos del jugador, y luego simplemente arrástrelos para que en realidad no tengamos que leer. Nosotros los hacemos porque esos son básicamente los mismos. Esas son solo etiquetas que se van a quedar exactamente como son. Entonces no van a cambiar. No obstante, lo haremos, entonces básicamente podemos duplicarlos de nuevo. Y entonces estos, estos objetos de juego, en realidad van a cambiar. Entonces esos serían. El valor de HP, texto de valor, por ejemplo. Y luego tenemos el texto de valor MPI y el texto de valor XP. Los insumos aquí son, solo voy a recoger cualquier número aquí. Entonces algo así. Ciento, diez cientos, quinientos, y entonces éste va a ser 500. Ahora también va a ampliar un poco esto. Entonces vamos a hacer esto un poco más grande y también hacer que se alinee con estos para que se vea un poco bonito. Más o menos. Al menos van algo así. Una línea ahí y una línea. Ahí. Vete tú. Ahora está bien. Y luego éste también. Y ahí, y luego vamos a hacer este mismo tamaño aquí, así como éste son del mismo tamaño que el más bajo y el medio. Ahí vas. Entonces estos tres también van a estar una especie de anclados a la derecha. Entonces vamos a tener el alineamiento B a la derecha, y esos van a cambiar. Pero vamos, vamos a averiguar por qué, cómo funciona eso en un rato. En primer lugar, esa es la configuración aquí. Entonces eso funciona muy bien y eso es bastante bueno. Hagamos esto más pequeño. Y básicamente ya podemos agregar algunas cosas a esto. Entonces lo primero que vamos a tener es que vamos a tener un crear un objeto vacío. ¿ Hace el UI Manager, vamos a hacer mucho con eso en poco tiempo así como tendremos un, otro objeto vacío, el objeto de datos seguro. Esto básicamente va a guardar nuestros datos y básicamente también cargar nuestros datos para que tengamos esto disponible, ¿verdad? Creo que esa es una especie de configuración que necesitamos por ahora, y ahora pasa a los diferentes guiones. Añadamos también el, vamos a agregar el jugador, el jugador seguro prefs aquí al objeto de datos seguro, y el Administrador de UI al objeto manager, así como la población cardiaca que ya hemos agregado. Y luego los datos del jugador, ¿verdad? No es necesario agregar los datos del jugador a nada porque los datos del jugador en realidad no van a ser un comportamiento mono. Entonces ahí es donde básicamente podemos empezar. Entonces, en realidad eliminemos esto primero y ante todo. Y los datos de jugador que queríamos guardar son algunas cosas. Entonces, por ejemplo, lo que queremos guardar es un entero público, HP, un MP entero público, y un XP entero público, así como un índice de tarjeta int pública. Entonces este es el índice que representa la tarjeta. Por supuesto, lo que podríamos hacer es que podríamos guardar la tarjeta en sí. Pero ¿por qué guardaríamos la carta en sí o el sprite si simplemente podemos decir: Oh, quiero decir, tenemos un índice, tenemos una lista de cartas. Es por ello que la población núcleo fue tan buena idea. Y eso lo podemos hacer fácilmente. Y básicamente vamos a hacer que esto sea bastante sensato. Entonces, antes que nada, realmente vamos a tener un delegado aquí. Entonces esto va a ser un delegado público vacío en el cambio de datos del jugador para que básicamente podamos ver cuándo cambian los datos. Entonces vamos a poner cada pedacito de datos aquí en el índice de tarjetas, en índice de corazón. Entonces ese es el El vacío y luego todos los parámetros es cómo tiene que verse el evento real o el método al que está siendo llamado por el evento. Entonces tenemos que darle los perímetros y hay que evitarlo. Y luego vamos a tener un evento público estático de tipo sobre el cambio de datos del jugador, que es sobre el cambio de datos. Y vamos a usar esto para básicamente actualizar la interfaz de usuario una vez que los datos hayan cambiado. Entonces una vez más, en lugar de pasarlo con dentro de un, un método de actualización, lo vamos a hacer así, ¿verdad? Vamos a hacer un solo patrón aquí. Entonces vamos a tener un dato LEA estático privado, que va a ser la instancia que al principio va a ser nulo. Y luego vamos a tener un lindo gueto de get haciendo una instancia de datos de jugador estático. Esto está escrito ahora en mayúsculas. Por lo que esto sería en esta instancia, en este caso es en realidad una propiedad. Y luego vamos a tener un get aquí donde básicamente decimos, Hey, si la instancia es igual a nula, entonces vamos a crear una nueva instancia. Y si no lo es, entonces simplemente regresaremos esta instancia. Y dentro de aquí, en realidad queremos instancia es igual a un nuevo dato de jugador. No obstante, ahora mismo esto estaría sin llenar. Entonces primero que nada vamos a tener que hacer un nuevo constructor. Ahora este constructor en realidad puede ser privado porque en realidad nunca queremos que los datos claros estén fuera de cualquier lugar. Siempre queremos crearlo dentro de aquí. En este caso, porque siempre sólo va a haber datos de un jugador. Y eso se va a guardar en esta variable instancia accesible por instancia de datos del jugador estático público. Ahora por lo general, esta no es del todo la forma en que probablemente funcionaría dentro de un juego que realmente funciona. Pero esto va a ser, creo que suficiente para este momento porque en realidad lo único que queremos hacer es que queremos algunos datos que queremos guardar. Por lo que nuestro constructor tendrá un JMP XP y un índice de tarjeta. Podríamos haber generado también esto automáticamente, pero creo que esto también va a estar bien. Entonces esto es, este AHP, este punto AMP es igual a MP. Este.Tab XP es igual a x b, y entonces este índice de la tarjeta de puntos es igual a la coordenada x Es igual al índice de la tarjeta van. Y lo que también tendremos es, así que este es el dato de jugador dentro de aquí. Ahora tenemos que especificar las cosas que queremos. Entonces hagamos quinientos, cien , diez cientos a 507,000. Por lo que este sería el HP, Inicio HP, el MP titular, XP inicial, y el índice de tarjetas con el que empezamos. Y también tendremos un vacío público, que va a ser el método set player data, que básicamente establece los datos del jugador. Entonces básicamente podemos cambiarlo. Esto va a ser tener exactamente los mismos parámetros que el constructor. Y va a hacer exactamente lo mismo en este caso. Y entonces también llamaremos al cambio de datos con un signo de interrogación dot invoke para que comprobemos si es o no básicamente nulo o no. Y entonces simplemente podemos poner en todos los parámetros que teníamos ahí arriba. Dentro de aquí. Y esto luego llamará al evento de actualización o cambio cada vez que configuremos los datos del jugador y básicamente los cambiemos para que luego podamos actualizar la interfaz de usuario una vez que básicamente lo hayamos puesto en nuestro Administrador de UI. Muy bien, así que vamos entonces al Administrador de UI. Entonces tu manager va a tener un, eso en realidad va a ser muy interesante. Esto va a funcionar como lo siguiente. Por lo que tenemos un montón de elementos de interfaz de usuario dentro de nuestra escena ahora mismo. Y en realidad tendremos todo ese tipo de explícitamente puesto en nuestro Administrador de UI. Entonces vamos a tener un, así que en primer lugar, por supuesto, usar el motor Unity wi, por lo que necesitamos usar este espacio de nombres. Tendremos dos botones aquí. Botón Tan privado, Botón Guardar. Y luego podríamos simplemente copiar esto sobre el control C y luego guardarlo con el botón Cargar. Ahora ambos van a ser campos serializados. En este caso, en realidad voy a poner el campo serializado en la misma línea que esta, porque de lo contrario nuestro guión va a llegar muy largo. Ahora es ya muy largo, pero esto sólo hará que sea un poco más fácil de leer. También puedes hacer eso por cierto, normalmente lo pongo en la parte superior en otra línea. Pero también funciona. También estaremos usando TMP Pro o TM pro para nuestro pro en este caso. Y vamos a tener un campo serializado de tipo campo de entrada TMP privado, entrada HP, sin entrada, HP en realidad. Y entonces esto también se puede copiar. Entonces Control C, Control V, control V. Y entonces tenemos entrada MP y XP. También tendrá un campos serializados, TMP privado, caídos. Este va a ser nuestro menú desplegable de cartas llamado desplegable. Y después tenemos campo serializado de TMP privado, txt. Este es el texto de HP. Por lo que esta es la visualización real de los valores. Hp toma texto vacío y texto XP. Y entonces por ahora, lo que tendremos es que tendremos algunos. Por lo que los datos de un jugador juegan aquí referencia de datos también tendrá una privada llamada población, población núcleo, para que podamos acceder a esto cuando queramos. Y luego por último pero no menos importante, que no hemos implementado, pero vamos a muy pronto en los prefs de jugador seguro, que van a ser los prefs de jugador seguro. Ahí vas. Y ahora esto es todo un montón de cosas, ¿verdad? Eso es una locura. Eso son un montón de cosas. Sí. Y lo que vamos a hacer es antes que nada, básicamente vamos a armar esto en los métodos despiertos que vamos a almacenar esto en el método wake y vamos a configurar algunas cosas al principio. Y ese va a ser el dato del jugador. Por lo que los datos del jugador son iguales a la instancia de punto de datos. Por lo que esto simplemente se asegura de que la variable de datos del jugador aquí, la variable estática se está estableciendo. Y esto luego guarda esto en la variable de datos del jugador. Entonces lo haremos, luego diremos, Sí, bueno entonces realmente encontraremos todas esas cosas. Por lo que el jugador seguro prefs va a ser igual a GameObject dot find. Y en realidad lo que vamos a usar otro vamos a usar find object of type. Entonces esto es una especie de la GameObject dot find y luego obtener componente todo en uno. Esto va a encontrar un, un objeto de juego que tiene adjunto este guión en particular. Y entonces la población automovilística va a ser el mismo objeto de juego punto hallazgo, objeto de tipo. Y esta va a ser la población cartulina, ¿no? Y eso es todo. Por ahora lo que vamos a hacer en el método despierto aquí mismo. Hay algunas cosas más que tenemos que hacer antes de que podamos básicamente continuar con esto. Y así creo que el método de actualización que en realidad ni siquiera necesitamos porque como dije, no queremos usar el método de actualización. En realidad queremos actualizar la interfaz de usuario real con un, con el carbón de eventos. Y sí, en realidad podemos implementar eso ya. Por lo que esto funcionaría con la interfaz de usuario de actualización privada. Nota no actualizada, pero actualiza la interfaz de usuario, que por supuesto tiene exactamente los siguientes parámetros. En MPI, en XP e índice int. Este es el índice de tarjetas, por supuesto. Y entonces lo que vamos a hacer es que vamos a actualizar exactamente esas cosas aquí. Entonces tenemos los textos XP HP, tenemos el texto vacío y con el texto XP yo entonces otra cosa que por supuesto necesitamos es el GameObject de la tarjeta de jugador. Entonces lo que realmente podemos hacer es renderizador sprite privado. Esto debería ser comprensible en tan solo un rato. Jugador tarjeta sprite renderizador. Entonces este es el, esto va a ser una referencia al carrito aquí. Entonces la carta de jugador que tenemos justo aquí y al sprite renderizador nos para que podamos poner esto como una actualización también. Y este va a ser el jugador card sprite renderizador igual a GameObject dot find, carta de jugador, carta de jugador que vas. Dot get componente, no get componente en niños, sino normal get componente que ego, sprite renderizador leer. Entonces esta es la configuración. Esto es algo que normalmente tendrás que hacer de todos modos cuando configures algunos grandes scripts y una especie de forma entrelazada de hacerlo. Y ahora realmente podemos establecer los datos ya. Por lo que la interfaz de usuario de actualización ahora debería funcionar no, sin ningún problema. Por lo que jugador sprite renderizador dot sprite es igual a la población del automóvil. Y luego Aya, Por supuesto, bueno, la población automovilística en este momento, volvamos rápidamente a la población núcleo. Esto es por supuesto privado ahora, en realidad tendremos que ponerlo a público en este caso. Para que podamos acceder a ella desde cualquier lugar que queramos. También podrías pensar en hacerlo estático como singleton, pero eso también va a estar bien. Y entonces ahora en realidad podemos acceder a esto. Y este va a ser el acorde del índice dado donde vamos a poner este tubo. Y entonces se establecerán también los textos. Por lo que el texto de HP, el texto es igual a cada punto p toString porque esos son enteros, en realidad tenemos que convertirlos con el método toString. Y entonces simplemente podemos copiar esto. Por lo que MPI textos y cuerda experta TTX, XP y MPEG-2. Con otra manera, van MP y XP. Ten cuidado con eso. Eso podría suceder solo para asegurarse de que todo esté en el orden correcto ahí. Correcto. Y entonces qué otra cosa queríamos? También quisiéramos otro método que se va a llamar privado o no cargar, no en nivel cargado sino solo cargar. Y aquí es donde básicamente tomamos las entradas y establecemos esas. Entonces la idea es que ahora mismo están vacías, ¿verdad? Entonces en este momento la textura está vacía y de inmediato vamos a establecer esto a la predeterminada básicamente. Entonces básicamente vamos a decir de inmediato, vale, entrada HP, eso está escrito ahí va a haber punto de datos del jugador, punto, punto a cadena. Entonces en la onload, te voy a mostrar qué hace esto exactamente en un rato una vez que empecemos esto. Pero básicamente simplemente va a asegurarse de que las entradas reales también se hagan correctamente. Tos. Un valor es igual al índice de la tarjeta de punto de datos del jugador. Y entonces el método onload va a estar frío. Bueno actualmente en realidad no necesitamos llamarlo. Solo llamemos a esto en carga aquí mismo en el despierto. Después del jugador esa instancia se ha establecido. Y entonces creo que en realidad ya no necesitamos hacer demasiadas cosas. Tenemos que poblar el menú desplegable de cursos. Entonces eso es algo que tenemos que hacer porque ahora mismo podríamos hacer esto ya sea manualmente o a través del guión. Porque cuando miramos el panel aquí, así que este es nuestro panel de entrada, el menú desplegable de la tarjeta ahora mismo por supuesto no tiene opciones, o más bien tiene opciones a, B, y C. Pero eso por supuesto no es del todo lo que queremos. Y lo que queremos es básicamente todas las cartas ahí dentro. Entonces queremos que los sprites de población de tarjetas ahí adentro para que básicamente podamos elegir uno de los cordones que son. Y lo que vamos a hacer es realmente vamos a hacer un nuevo método para esto. Entonces esto va a ser un vacío privado. Vacío te pop tarde, el cordón cae hacia abajo. Y esto va a hacer lo siguiente. Esto va a tener una lista de datos de opción desplegable TMP. Esto es lo que ya hemos visto, la forma en que pudimos poblar nuestro desplegable antes era con esta clase de datos de opción básicamente. Y esta va a ser una nueva lista aquí. Y entonces simplemente vamos a hacer por cada sprite, sprite en población de corte, nota punto-punto, población de tarjetas. Eso no está bien. Población de tarjeta. Ahí vas. Sprites de punto. Vamos a hacer paquete data.table y luego hacer un nuevo dato de opción aquí con el nombre de punto sprite particular así como el propio sprite. Y luego en la tarjeta final, desplegable. Y las opciones es básicamente donde podemos agregar una lista de opciones y ellas están, vamos a sumar los datos en. Por lo que esto simplemente llena el menú desplegable real. Y lo vamos a ver en acción bastante pronto. ¿ Verdad? Entonces veamos también asegurémonos de que dentro de nuestro desplegable de corte que las opciones que ya tenemos o realmente sacadas que son lista opcional aquí esté vacía en este momento. De lo contrario tendremos también esas opciones. Y eso por supuesto, no va a funcionar. Está bien. Creo que por ahora estamos lo suficientemente adelante o estamos lo suficientemente lejos dentro de ella como para poder empezar esto y realmente cambiar las cosas. Actualmente, no podremos guardar nada. Y sin embargo, lo último en realidad, antes de empezar es que tenemos que decir, estamos despiertos aquí, en el fondo aquí, vamos a decir que este sería el cambio. Entonces este es el, en realidad, pongamos esto aquí arriba. Entonces, tan pronto como el conjunto de datos del jugador, esto va a ser datos del jugador, cambio de datos ordinales más igual a UI de actualización. Entonces vamos a actualizar la interfaz de usuario cuando cambien los datos del jugador. ¿ Verdad? Y eso debería ser en realidad para este. A ver, Empecemos esto, a ver si obtenemos algún error. En realidad sí obtenemos un error. Eso no es lo peor. Ahora mismo. En realidad estamos haciendo un muy, ya sabes, bastante las cosas complicadas. Para que podamos ver qué es Y0. Esta cartilla se cayó en opciones de datos para que en algún lugar algo aquí sea una lectura nula. Podemos pensar en esto. Entonces la idea es que tenemos la línea fría 38 en la UI Manager. Y esto de alguna manera es nulo aquí. Entonces lo que probablemente se sepa es la tarjeta que cayó en este caso. Y pensemos en esto. Y eso es por supuesto, cierto porque nos hemos perdido una parte crucial de esto y eso es establecer todos estos campos serializados. Entonces si echamos un vistazo al Administrador de UI aquí, todo aquí no se está configurando. Y eso es por supuesto, algo que tenemos que hacer primero. Entonces eso es algo que es totalmente normal le puede pasar a cualquiera, a cualquiera. Básicamente, a veces simplemente nos olvidamos de poner algo. Entonces en realidad eso es muy importante pensar. Este es un error que puede ocurrir en cualquier momento. Y ahora vamos a configurar esto para que la inserción de un panel aquí, botón Guardar es el botón Guardar, el botón Cargar. Y ahora, como pueden ver, el nombre aquí viene muy útil porque sabemos lo que es todo. La entrada Hp es la entrada HB, entrada vacía es la entrada vacía x p la entrada es la entrada EXP, lo siento, se ejecuta con el ego. Y el desplegable de la tarjeta es la carta bajada. Y luego podemos ir a nuestro panel de datos de jugadores. Y obtener los textos de valor. Por lo que los textos de valor HB, los textos de valor MP, y los textos de valor XP. Es por ello que el nombramiento de los objetos del juego es tan creíblemente importante. No digas que no necesito eso. Sólo toma unos segundos y te ahorrará mucha molestia porque ahora si esos serían entrada uno, entrada dos, entrada tres, no tendríamos ni idea. Tendremos que dar click en esto. Mira aquí. De ninguna manera más fácil. Nómbralos correctamente y todo va a salir mucho mejor. Escríbelo ahora, deberíamos poder iniciar esto sin ninguna flechas. A ver. De acuerdo, no hay errores, así que eso ya es bonito. Se pueden ver los campos de entrada aquí. En realidad me he llenado con los datos del jugador que estaba en segundo plano. Y entonces también podemos elegir algunas de las cartas aquí. Ahora, esos están, como puedes ver, un poco abarrotados. Por lo que podríamos querer mirar en nuestro desplegable y simplemente hacerlo un poco más grande aquí para que básicamente puedas expandir esta plantilla en un poco. Y creo que eso en realidad ya debería hacer esto un poco más agradable. Además de poner la plantilla aquí, teniendo la sensibilidad de desplazamiento un poco más alta. Entonces tal vez poner esto a 10 también funcionaría, pero eso es algo que realmente no es increíblemente necesario. Simplemente va a hacer nuestra vida un poco más agradable. Entonces ahora es un poco más agradable. Todavía podemos ver sin embargo, qué podemos elegir tu fin. Sí, básicamente podemos elegir una tarjeta diferente. Y ahora mismo, no pasa nada en el, en la elección aquí. Pero esto en realidad es algo que vamos a poner ahora porque estas son las últimas tres cosas. Antes de que realmente estemos guardando algo, tenemos curva tiene que, hay que cambiar los datos que vemos. Entonces, básicamente, si cambiamos la pantalla aquí, entonces queremos que cambien las cartas reales. Y si cambiamos algo aquí, entonces básicamente al final de esto, queremos cambiar esas cosas de datos aquí o los datos relevantes del jugador que se están mostrando. Y podemos agregar esto básicamente, hagamos otro vacío privado. Y esto sería básicamente sobre, sobre los cambios de datos, sobre los cambios de datos. Y vamos a poner esto en el fondo aquí. Entonces esto está encendido, sobre los cambios de datos. Y eso va a tener aquí algunos oyentes agregados. Entonces esta va a ser la tarjeta bajada. Pero sí, en valor cambiado, agregue oyente. Y luego dentro de aquí, básicamente tenemos el índice dado. Y entonces podemos hacer otra expresión lambda aquí. Y lo que realmente queremos es que queremos cambiar los datos de jugador que son. Entonces lo más fácil que creo que hacer aquí sería, sí, En realidad hagamos un método seguro de vacío privado con pulgadas, HP y MP en x ser un índice entero como este, solo sin ese. Ahí vas. Y entonces simplemente llamaremos datos del jugador de conjunto de puntos de datos, para que fuera el método que hemos definido antes. Cada BMP. Y índice. Y esto se va a llamar aquí. Entonces aunque el índice cambie, vamos a cambiar todos los datos de los jugadores. Eso no está tan mal. Todas las cosas consideradas porque, porque, ¿por qué no? Entonces esto va a ser, en realidad vamos a hacer un int. Esta sería la entrada HP es igual a en el punto de entrada de análisis de puntos HP texto. Perdón, esta es la entrada. Hp. A esto lo llamo la entrada. Sí, definitivamente. Está bien. HP de entrada es el, es un entero. Oh lo siento, claro, esto igual, entonces esto no va a funcionar. Por lo que ingresa los textos HP punto-punto-punto, van. Entonces ese fue el tema aquí dentro. Y vamos a copiar esto más, hacer el valor MP de entrada y entrada X p. Esto puede ser MP y XP. Entonces básicamente, en este momento estamos leyendo lo que sea que el texto esté dentro de nuestros insumos aquí. Entonces la entrada aquí, la entrada aquí, y la entrada aquí. Este es el texto que estamos leyendo. Y luego básicamente guardarlo en este método seguro. Y esto va a establecer ahí los datos reales. Entonces esto va a ser entrada cada valor p, valor vacío de entrada, y valor de XP de entrada aquí abajo. Ahí vas. Y entonces también necesitamos el índice. Ahora el índice es en realidad lo que se nos da con el oyente aquí porque este es el desplegable básicamente te da el índice del cambio para que podamos bajar y luego elegimos un ítem en particular en eso. Y se nos da el índice de que también estamos cambiando. Y esto es exactamente lo que quisiéramos agregar al método save aquí para que cambie el índice del acorde. Entonces este es uno de los oyentes que queríamos sumar. Y también queremos agregar oyentes para el cambio en las entradas reales que son. Entonces la entrada HP, um, que es el campo de entrada, hay una edición final. Entonces esto es una vez más, ya hemos visto esto antes. Este evento que se despide cuando terminamos de editar lo particular, bueno, lo que sea que esté escrito ahí dentro. Y luego dentro de aquí, en realidad vamos a conseguir una cuerda. Entonces esto va a ser, llamemos a esto el texto HP. Claro, ¿por qué no cambia cada vértice, por qué no ese? Y entonces también llamaremos aquí al método de guardar. Y en lugar de usar la cosa real que se analizó ahí arriba, en realidad queríamos el cambio de cada vértice aquí. No obstante, los otros valores que vamos a tomar de la parte superior, son valor de entrada x p así como el índice que en realidad también tenemos que obtener, por supuesto, entonces esto sería int index igual int dot en ninguna parte. En realidad no necesitas hacer eso. Podemos hacer valor de punto desplegable. Ahí vas. Por lo que este sería el índice. En realidad llamemos a esto el índice de tarjetas. Porque de lo contrario este índice y este índice podrían ser confusables. Entonces índice de tarjeta. Y ahí tienes. Esto ahora es por supuesto una cuerda. Por lo que esto tendría que analizarse en el interior de aquí, es un poco incómodo, pero creo que esto va a estar bien. El texto cambia el ego. Y entonces Vamos a tirar de esto aquí para que podamos, ahora en realidad creo que esto va bien. Y queremos hacer esto no sólo por los HP. Entonces cuando el, cuando terminemos con la edición HP, pero también con el MP y la edición XP. Ahora muy importante que también cambiemos esos nombres de variables. Entonces esto es NP y este es cambio fiscal XB. Y entonces ya no queríamos analizar aquí el cambio de HP. En realidad queremos tomar el valor en la parte superior. Queremos es copiar este en el análisis de puntos. Y entonces aquí está, la misma idea. Oops, no, eso no es lo que queremos. Ahí vas. Esto va a ser de entrada de valor HP y luego copiar este Control C. Y entonces esto va a ser integer.parseInt, esto y esto. Muy bien, pasemos por esto. Expliquemos listas de forma rápida, rápida, rápida. Entonces, ¿qué estamos haciendo aquí? Entonces en los cambios de datos es simplemente un método que llamamos al final de nuestro método de peso aquí. Y la idea es que en un principio estamos leyendo todo para lo que tenemos los insumos. Por lo que leemos el texto del HP y ponemos la entrada MPI en la entrada XP, así como el valor actual que se selecciona en algunos de nuestro menú desplegable. Después agregamos oyentes a cada uno de esos. Entonces básicamente cuando cambia el valor de nuestro desplegable, así que si seleccionamos un valor diferente, entonces lo que queremos es que el método seguro se llame fin, se pase exactamente esos valores. Ahora, esto simplemente no va a cambiar nada. Simplemente lo estamos, pero todavía queremos que se pasen esos valores. Porque en nuestro caso que tenemos un método seguro que tiene los cuatro de esos valores en teoría, por supuesto, también podemos ir a los datos del jugador y básicamente establecer los datos del jugador de forma individual para que podamos establecer piezas individuales de las cosas. Entonces si volvemos a los datos de nuestros jugadores aquí, por supuesto en este momento, nuestros datos de set player es algo donde tenemos que establecer cada variable al mismo tiempo. Podríamos, por ejemplo, hacer más sobre, sobrecargar este método y tener algo así como datos de jugador establecido y luego solo darle el HP o solo darle el MP, o solo la XP y así sucesivamente. Ahora mismo creo que tiene más sentido tener todo esto en uno porque podemos acceder al resto de la entrada real. No son ningún problema. Y entonces lo siguiente sería que si fuéramos a una, cambiar los campos de entrada. Entonces si terminamos con la edición ahí de lo que quisiéramos es que queremos establecer la única esa entrada que cambiamos. Esta va a ser una cadena de por lo tanto tenemos que analizarla también. Y entonces el resto va a ser los valores por defecto, especie de hablar. Entonces esos se van a quedar así. Y queremos hacer eso por cada uno de los tres insumos. ¿ Verdad? Y ahora todavía no estamos a ahorrar porque como dije, esto va a ser un poco más extenso porque en realidad quiero que encuentres el marco que lo rodea. Es peso por el ahorro en sí va a ser realmente fácil. Vas a ser como realmente, ese es el ahorro. Pasas como 30 minutos en, en la interfaz de usuario y todo eso y luego como cuatro minutos en guardar cosas, eso es ridículo. Pero esto es básicamente, quiero tener esto como una especie de, una manera muy agradable en la que también puedes jugar un poco con él. Entonces, sí, así que ahora todo se ha puesto. Veamos qué pasa. Entonces, antes que nada, empecemos con esto. Y si básicamente tuviéramos una carta diferente seleccionada aquí, y como puedes ver, cambia al Rey, que es realmente, realmente genial. Y luego podemos cambiar otra tarjeta, 33, y entonces tal vez queramos bajar 41. Ahí vas. Ahora, cambiemos el HP. Entonces por ejemplo, 8 mil. Y si hago clic fuera de esto, entonces el HP realmente se cambiará también. Ahora lo que habrás notado aquí es que el acorde vuelve a cambiar y en realidad lo arreglaremos también. Acabo de notar por qué ese sería el caso. Y la razón es porque esto en los datos cambia, por supuesto se llama una vez. Y básicamente guardamos cualesquiera que sean los valores reales. Unos de aquí, que se podría decir, bueno, eso no va a ser un tema. No obstante, en realidad va a ser un tema porque esto es una especie de cosa de una sola vez, ¿verdad? Entonces esto se llama una vez y luego esos valores se pasan a esto. Por lo que hay dos formas diferentes en que podemos lidiar con esto. O bien podemos hacer que esto tome bien estas cosas, y luego ponerlas aquí. Entonces, básicamente puede tener éste y luego éste, y luego éste. Ahora se podría preguntar, ¿por qué eso lo cambiaría? Y vamos a romper esto así para que podamos verlo. Entonces se podría preguntar, ¿por qué eso cambiaría esto a trabajar? Y la idea es que, bueno, porque el texto de entrada aquí cambia después de que hayamos guardado en caché este valor. Este valor ya no cambia. Esto está ambientado en piedra básicamente. Entonces esto es una especie de cosa que es importante cuando lo estás. Es decir, esto no es realmente una especie de paralelismo o, ya sabes, trabajar con cosas paralelas. Pero esta es una de las cosas que es muy importante pensar porque a veces almacenar en caché estos valores en realidad no funciona del todo. Por lo que tristemente, tendremos que tomar esto y luego básicamente reemplazar este y éste también. Y entonces podemos tomar el texto vacío y reemplazar éste y éste. También asegurémonos de que estamos rompiendo esto de una manera razonable. Entonces, básicamente, después del texto vacío para éste, y tenemos que tomar el caballo XP aquí y tomar el valor z, el valor z. Esto ya se está haciendo. Y luego tristemente lo mismo con el índice de la tarjeta, donde realmente tenemos que poner el valor aquí. Y luego las tres de esas variables, las cuatro de esas variables se vuelven completamente obsoletas y ya no las necesitamos. Esto tristemente lleva al hecho de que esto es mucho menos legible. Pero podríamos hacer esto un poco más legible expandiendo la expresión lambda en este caso. Pero no vamos a hacer eso ahora mismo. Porque para en este caso, esto también funciona. También podríamos tener otro método llamado, pero creo que esto va a estar bien por el momento. Correcto. Y luego sólo por un poco más de aclaración, porque esto podría no ser una especie de obvio por qué esto no está funcionando, por qué esto no funcionaba correctamente antes. La idea es que así por ejemplo, cuando cambiemos el valor de nuestras cartas desplegable. Y si ahora ponemos aquí el texto de análisis, entonces esto sucede cada vez que realmente cambiamos este valor. 87. (Unity Intermedio): Y ahora a la parte salvadora, que probablemente todo el mundo ha estado esperando desde hace bastante tiempo. Y lo que tendremos es que tendremos dos métodos dentro de nuestra jugada, prefs de jugadores seguros. Eso va a ser un público evitar un dato seguro, guardar datos, y luego un vacío público cargar datos, cargar, cargar datos. Ahí vas. Y también una variable de datos de jugador privado aquí juegan nuestros datos. Se van. Se va a establecer la fecha del jugador de la variable para jugar un dato igual clase de datos de capa igual en la instancia de punto debe ser sensato. El dato guardado simplemente va a hacer prefs de jugador. Entonces esta es exactamente la clase de la que estaba hablando en la que podemos guardar cosas y luego podemos guardar cosas con el set. Así que set, float, set, y set string. Esos son básicamente los tres valores diferentes que podemos salvar. Entonces esos serían todos ins, así que esto es HP. Y luego como segundo parámetro, vamos a dar el valor real. Entonces eso es todo lo que realmente necesitamos hacer para salvar esto. Y entonces hagamos esto por todos ellos. Entonces MPI, no sólo él sino MP, EXP, y luego también haremos la tarjeta, tarjeta a tarjeta índice. Y esto va a estar vacío EXP, y luego el índice judicial. Entonces este es el ahorro hecho. Eso es todo. Ahora sólo necesitamos recordar esas cuerdas, por supuesto, porque son las claves. Por lo que puedes pensar básicamente en que el jugador presiona como un diccionario, un diccionario de valla que realmente guarda esto en un, en el disco, en el archivo. Entonces para leer conseguir esto, podemos hacer. Así que interrumpe XP entero, jugador, jugador prefs, jugador prefs dot, entrar en este caso. Por lo que getInt está hecho de manera que pasas la clave y luego llegas al valor real. También puedes hacer una segunda cosa donde puedes poner un valor por defecto. Entonces si esto no se encuentra, entonces básicamente se obtiene el valor predeterminado. Esto es simplemente a prueba de fallas que si por alguna razón tus cosas no están configuradas, entonces realmente puedes hacerlo así. Entonces vamos a copiar esto un par de veces también. Mp XP y luego el índice de la tarjeta. Y teníamos una de 1500 para el MP y la XP era de 2500. Entonces vamos a cambiar eso también. Es 0 para los índices de tarjeta se abrirán así. Tarjeta de índice el ego. Entonces ahora que también tenemos los valores básicos por defecto, si acaso esos no existen. Porque tal vez lo que pasa es que hacemos clic en el botón de carga de datos y en realidad los datos aún no se han establecido. Entonces eso sería muy bueno. Y luego jugar un conjunto de datos datos datos del jugador. Y luego ahí dentro podemos poner en el HP, el MPI XP, y en el índice de tarjetas. Y eso fue todo por el ahorro y la carga. Ahora sólo necesitamos engancharnos a los dos botones de ahí. Y eso sería todo. Por lo que sólo tenemos que hacer el botón guardar al hacer click, Añadir oyente. Y luego ahí dentro simplemente podemos llamar a jugador seguro prefs dot guardar datos. Y en el mismo token, copiando esto, podemos decir el botón Cargar. Queremos cargar datos. Y los prefs del jugador, prefs del jugador seguro se han establecido con el objeto hallazgo de tipo. Por lo que se debe establecer eso. Esto también servirá. Por lo que esto podría extraerse a otro método. Vamos a mantener esto ahí por ahora. Pero en general, creo que esto debería ser en realidad todo lo que necesitamos. Do. Ya sabes, hay algunas cosas más. Por lo que este método onload, probablemente podríamos recordar esto a poblar el texto. Hay muchas cosas que podemos cambiar para que esto sea un poco más legible. Pero en general, esto va a estar bien. Y vamos a ver si realmente podemos guardar y cargar datos. Por lo que eso sería muy cool y muy interesante. Entonces vamos a empezar esto por ahora, y luego sólo vamos a seleccionar un agradable el rey. Entonces vamos a tener algo así como 12000 y luego vamos a tener mucho de ahí y luego algo así para el EXP. Y luego vamos a presionar el botón Guardar datos. No pasó nada, lo cual en realidad es bastante bueno porque, ya sabes , si, si hay un error, entonces probablemente habríamos oído hablar de ello. Y luego salgamos de ella y luego todos sepan, todos mis datos se pierden. No lo sé. No sé qué teníamos aquí dentro, como 30000. Hagamos clic en el botón de carga de datos y veamos si eso funciona. Y lo hizo. Entonces eso es bastante guay. Una de las cosas que en este momento no actualizaron son los textos de HP, los textos y los textos de XP aquí. Entonces eso es algo en lo que también necesitarías pensar. Porque si cambiáramos la tarjeta real aquí, esto volvería a cambiar porque esto está leyendo de esos todo el tiempo. Entonces esa es una de las cosas que es muy importante pensar, que realmente tienes que hacerlo. También me asegura que esos se guarden también y que cambien con él. Para que lo que básicamente podrías hacer en teoría, lo que básicamente podría hacer es simplemente puedes llamar al método de carga cada vez que hagas esto. Entonces básicamente lo que simplemente haces es en lugar de simplemente darle el método único, podemos poner aquí un corchete rizado y un soporte rizado aquí. Y luego asegúrate de no olvidar el punto y coma y después decir a la carga. Por lo que ahora se está llamando al método onload cada vez que dices haz clic en el botón Guardar. Y entonces básicamente podemos hacer lo mismo para el botón Cargar también. Entonces haz este, y entonces podemos decir carga. Y luego si se llama a la onload, por supuesto, entonces siempre restableceremos nuestras entradas exactamente a esto. Y esto debería entonces estar totalmente bien. Entonces, veamos si eso funciona ahora. Los datos aún deben guardarse porque se guardó antes. Entonces veamos estos datos de carga. Y como puedes ver ahora, todos estos datos también se han establecido. Y luego si cambiamos la tarjeta, entonces nada aquí cambia de nuevo. Ese es el último tipo de arreglado que necesitarías implementar para que esto funcione. Y entonces puedo cambiar esto por otra cosa. 99, 99, algo así. Y entonces, ya sabes, no sé, algo así. Y si vuelvo a guardar esto, y ahora, lo cambiaré todo, ¿no? Algo así. Y luego vamos a ir a otra tarjeta. Y si fuera a cargar ahora, todo cambia de nuevo a exactamente los datos que he guardado justo antes. ¿ Verdad? Entonces esa fue una forma muy rotonda de mostrar cómo se pueden guardar datos. Yo quería hacer esto en un poco más, digamos estilo en un poco más bonito y algo que realmente tienes eso para que puedas jugar con él. Independientemente de si tomaste el si ya importaste el paquete y jugaste así con él, o si programaste a lo largo, entiende que esto es un poco más complicado, pesar de que el real salvarse, como se puede ver claramente, es muy, muy fácil de hacer. Esto no es una locura. Se trata sólo de dos métodos cuando básicamente sólo el método set y luego el getMethod que hacemos en el jugador prefs. Y sí, eso sería el ahorro. Pero yo quería tener todo a su alrededor porque la próxima conferencia, lo que vamos a ver es guardar datos con básicamente Jason con archivos JSON. Y eso va a ser un poco más complicado, sin embargo, ¿un número uno va a ser mucho más robusto? Y número dos, en realidad nos va a permitir guardar clases enteras en lugar de simplemente guardar enteros, flotadores y cadenas. Lo cual es algo importante, sobre todo si realmente estás trabajando con un gran proyecto. Entonces enteros, flotadores, y cadenas podrían conseguirte un poco para. Pero en algún momento vas a ser como, hombre, yo simplemente no quiero poner esto también los prefs del jugador no son la mejor idea para guardar todo ahí dentro. Esos son, Es mejor ahorrar básicamente. Por lo que como puedes ver, almacena preferencias de jugador entre sesiones de juego. Como su nombre indica, es más o menos mejor guardar una especie de, ya sabes, tus preferencias por tu jugador ahí dentro. Entonces quizá opciones, esa es una buena idea ahorrar en el jugador prefs. Y luego más allá de eso, probablemente no lo sea, definitivamente no se recomienda guardar ningún dato vital ahí dentro. Es mucho mejor guardar eso en tu propio archivo JSON y luego tal vez incluso tu propio formato de archivo, pero eso es demasiado avanzado archivo adyacente para nosotros en este momento en la próxima conferencia va a bastar mucho por lo que va a ser más que suficiente. Eso sería todo para esta conferencia. Como dije, fue un poco más extenso. El ahorro en sí mismo. Bastante fácil. Pero sí, eso sería todo para este. Como siempre. Si lo disfrutaste y si aprendes algo nuevo, por supuesto te agradecería mucho una opinión tuya. De lo contrario, si quedan preguntas, entonces por supuesto, siéntete libre de preguntar y me aseguraré de responder. Y sí. 88. (Unity Intermedio) guardar (personalizado) datos con archivos JSON: Muy bien, sigamos aquí la introducción de la unidad intermedia para el curso de la unidad. Y en esta conferencia vamos a echar un vistazo a cómo guardar datos en un archivo JSON. La última vez, básicamente configuramos aquí nuestro bonito pequeño ejemplo, así como datos de seguridad con los prefs del jugador en este caso. Y ahora vamos a una especie de agregar a esto y básicamente tener los datos guardados en un archivo JSON en lugar de los prefs del jugador. Entonces, en primer lugar, vamos a crear una nueva escena. Esto va a ser en realidad ahora no una nueva escena. En realidad vamos a llevarnos a los prefs del jugador L6, lo siento, y luego Control D para duplicarlos. Y este va a ser L8, Jason. Y luego dentro de la carpeta de scripts, una carpeta nueva, y eso es L8 guardando con JSON o simplemente Jason, eso también está bien. Y luego el nuevo guión aquí, y vamos a llamar a esto el cargador Jason. Porque va a ser un solitario que cargue a Jason Wright. Y ahora vamos a abrir también el Jason se ve aquí y luego cambiar los datos seguros. Por lo que básicamente vamos a eliminar el script seguro del jugador prefs de ahí y añadir el script cargador JSON allí. Y luego abriremos el guión inferior Jason así como también necesitamos el UI Manager y los datos del jugador. Estos son los otros dos que también necesitamos porque necesitamos cambiar algunas cosas ahí dentro sobre realmente no tantas. Por lo que en los datos del jugador, realidad vamos a añadir System.Out serializable en la parte superior de la clase. Esto simplemente nos permite convertir los datos de esta clase en un, en un archivo JSON, por así decirlo. Entonces esa es, esa es la idea que son. Y lo segundo en el Administrador de UI que tenemos que hacer en realidad no es tan malo. Queremos agregar una, otra variable privada aquí, y eso sería un cargador Jason privado llamado el cargador JSON. Vamos a llamarlo así. Eso es en realidad, y eso está bien, Eso está bien. Y esto se fijará hasta aquí. Por lo que este sería el cargador JSON es igual a GameObject dot find object de tipo Jason loader. Y eso estaría bien. Y entonces en lugar de hacer lo siguiente, así que en lugar de guardar y cargar con los prefs del jugador, lo que vamos a hacer es que vamos a decir, vale, si los prefs del jugador no son nulas. Entonces si ha encontrado en la escena actual a, un objeto con el jugador seguro prefs. Entonces vamos a hacer esto. Y si ese no es el caso, vamos a ver si el trace y loader es desigual a null en igual null. Y si ese es el caso, entonces vamos a hacer otra cosa. Entonces vamos a mantener básicamente el cargador JSON dot save data. Entonces vamos a abrir el archivo cargador JSON aquí. Y en realidad vamos a seguir siendo esto un comportamiento mono porque ya lo hemos apegado. Y necesitamos una vez más en los datos del jugador aquí, datos de capas como variable. Esto por supuesto, se puede conseguir muy fácilmente con la instancia de punto de datos del jugador. Y luego al igual que con los prefs jugador, en realidad vamos a tener un viaje público, datos seguros y un vacío público. Datos de carga de vacío público. No, ese no, sino métodos de carga de datos. Entonces esto, si has visto esto y entonces también el jugador precia clase C-Sharp que hemos hecho. Se podría decir, bueno, tenemos un dato seguro y cargar datos en ambos. ¿ No podríamos hacer una interfaz para eso? Sí, eso es exactamente correcto. Esa sería una de las, una de las formas en que también se podría hacer esto. Por lo que probablemente podrías configurar una interfaz para cada uno de ellos. Una especie de tener esto como un dato guardado o un IA, IA data save o algo así, eso probablemente funcionaría también. Pero en nuestro caso ahora mismo, no necesitamos hacer eso. Solo queremos saber, vale, ¿cómo podemos realmente guardar esto en nuestro adyacente y podemos hacerlo? En primer lugar, lo que necesitamos es utilizar el espacio de nombres System.out.Print Joe también. Porque ese es el espacio de nombres que nosotros, que podemos escribir y leer datos. Ahora mismo en nuestro método de guardar datos, lo que vamos a hacer es definir una cadena llamada adyacente. Y luego vamos a usar la clase de utilidad Jason para básicamente convertir un objeto en un JSON. Entonces como puedes ver, podemos poner un objeto como parámetro y convertirlo en una representación JSON. Entonces solo para una aclaración rápida, adyacente es una notación de objeto JavaScript. Ahora no dejes que eso te engañe. Es, no tiene que ser usado solo en JavaScript, es solo una especie de forma que puedes almacenar datos de manera bastante eficiente y básicamente leerlos y escribirlos. Entonces lo que vamos a hacer es realmente vamos a registrar esta cadena JSON y en realidad ver qué hace. Y entonces lo que podemos hacer es también registraremos un camino en particular. Entonces por supuesto, pronto vamos a utilizar básicamente el escritor de secuencias, que ya hemos utilizado en la introducción de C-sharp. Y éste va a estar guardando algo en particular, en un directorio en particular. Y la forma en que podemos hacerlo es mediante el uso de datos de aplicación, datapath. Entonces este es básicamente el datapath. Entonces podemos usar separador de directorios medio viejo. Ahora esto podría parecer una locura. ¿ Qué haces ahí? Entonces el último se va a guardar data dot JSON. Y la idea es que, bueno, el datapath, como se puede ver, siempre está directamente a la carpeta del juego. Por lo que esta es una ruta directa a la carpeta Activos. Y este viejo separador es básicamente. Bueno, lo que necesites. Entonces, ya sea una barra invertida gris barra invertida porque a veces dependiendo del tipo de sistema en el que estés, si estás o no en un Linux, Mac o PC. Entonces Windows, que esto podría ser diferente. Esta es la razón por la que un path dot viejo carácter separador de directorios es probablemente mejor usar aquí. Entonces, primero que todo en realidad solo tengamos que esto sea salida aquí en una caja fuerte en lugar de realmente tenerlo básicamente ahorra algo, solo para que podamos hacer esto. Entonces vamos a copiar básicamente la escucha aquí en oyente y luego cambiar la configuración del jugador seguro a Jason loader, y luego el JSON baja también. Y esto debería funcionar absolutamente, totalmente bien. Ahora, veamos si esto realmente ha funcionado o no. Entonces si vamos a entrar aquí y vamos a cambiar algunas cosas. Entonces por ejemplo, en la vejez, esto cambia los números aquí sólo un poquito. Y luego si golpeamos Guardar datos, deberíamos ver algo de salida. Y en realidad lo hacemos HB es cinco, qué hace eso 5 millones, sí, y luego 24 mil para MP un 100 y 33 para XP. Y entonces el índice del carrito es 18. Y luego también se ve exactamente dónde guardaría el archivo adyacente. Y eso sería exactamente dentro de nuestra carpeta de activos aquí. Entonces eso es bastante bueno. Y ahora podemos agregar la funcionalidad. En realidad lo guardaré también. Entonces, ¿cómo lo salvaríamos? Bueno, vamos a estar usando la palabra clave, usando una vez más con el escritor de stream en este caso. Entonces este va a ser el escritor y eso es igual a un nuevo escritor de stream para un directorio en particular en este caso, y ese es exactamente el directorio que aquí hemos especificado. Yo sólo quería dar salida a esto porque eso es un poco bonito. Y entonces vamos a hacer esto. Y luego mientras esto sucede, en realidad, en realidad no necesitamos hacer nada loco aquí. Escritor, punto-punto-punto, ¿verdad? Y entonces sólo le vamos a dar la cuerda adyacente real que tenemos aquí. Debido a que la adyacente la utilidad daciana ya ha convertido nuestro objeto o un objeto de datos de un jugador a una cadena. Eso lo hemos visto en la salida. Y ya no necesariamente necesitamos dar salida a la ruta de datos. Y luego para los datos de carga en realidad es exactamente lo mismo justo al revés. Entonces vamos a tener una cuerda, Jason, eso va a ser un, un punto de cuerda vacía en cuerda vacía. Y luego vamos a estar usando el lector de stream. En este caso, lector es igual a nuevo lector de stream. Ahora por supuesto, asegurándose de que esta es exactamente la misma ubicación aquí. Entonces podría haber algún sentido o algún interés en guardar realmente esta ruta de datos como una variable de cadena dentro de su cargador como una, como una cadena, como dije, donde no va a hacer eso en este punto, pero podría ser una buena idea. Y entonces simplemente vamos a decir Reader dot to end y guardar eso dentro de nuestra cadena JSON. Ahora tenemos básicamente exactamente la misma cadena JSON. Vuelve a leer como tenemos aquí dentro. Pero ahora por supuesto necesitamos una especie de hacer un nuevo dato de jugador para eso. Y vamos a hacer un dato de jugador. Datos es igual a Jason util dot de JSON. Y luego dentro de aquí, dentro de nuestro Y corchetes angulares están corchetes angulares. En realidad especificamos lo que queremos como retornos. Por lo que este va a ser el dato del jugador. Y luego dentro de ahí va a ir a la cuerda real. Y entonces lo que vamos a hacer es que vamos a decir datos de jugador, set, datos de jugador. Entonces estos son los datos reales que tenemos aquí dentro. Esta sería una nueva instancia de esto. Y normalmente lo que haríamos es hacer un dato, data.table P y luego data.dat AMP, y luego data.txt. Y luego por último pero no menos importante, data.dat índice de la tarjeta. Y luego los datos reales del jugador se han vuelto a establecer. Ahora podríamos, por supuesto, también pensar en tal vez hacer otro método de datos de jugador conjunto donde realmente le damos una instancia de datos de capa otra aquí y lo hacemos así. Pero ahora mismo esto será, por supuesto, completamente suficiente y funcionará totalmente bien. Entonces veamos realmente si esto funcionará o no. Entonces lo primero por supuesto es almacenar esto y solo estoy rastreando un poco. Hagamos algo así. Y luego hagamos como 1990 y luego hagamos como 420. Seguro, ¿por qué no? Y luego hagamos clic en el botón Datos seguros. Está bien. Por lo que eso parecía haber funcionado. Por lo que 17 para 20, 30, 45, y 1990. Y entonces realmente miro dentro de nuestra carpeta de proyectos así que no vemos nada en este momento. Hagamos una actualización de clic derecho. Y vamos a ver, ahí está, seguro db.json. Entonces, hagamos doble clic en eso. Y en realidad se ha abierto dentro de Notepad Plus, Plus. Eso es un poco desafortunado. Pero en realidad se puede ver aquí también. Cada uno antes de 2013, 45, 1990, y 17 es el carro y el cuello, por lo que eso se ha guardado. Y si tuviéramos que parar esto y luego reiniciarlo, ya verás que si cargué los datos, y como puedes ver, todo funciona totalmente bien. Y esto en realidad es tan fácil como cambiar esto, ¿verdad? Por supuesto, hay un punto de decir, bueno, tal vez no queremos hacerlo así. A lo mejor queremos hacerlo con una interfaz o algo así. Creo que eso sería excesivamente complicado. Ya tenemos aquí una construcción bastante complicada para todo el aparato de ahorro, por así decirlo. Y creo que definitivamente va a estar bien. Pero sí, básicamente son los mismos métodos de guardar datos y cargar datos que llamamos. Y esto simplemente guarda los datos en un, en un archivo JSON. Ahora sí realmente quería mostrarte el archivo real como un interior del proyecto real. Tan sólo un segundo. Voy a hacer show en Explorer. Entonces esta es otra carpeta en mi otra pantalla. Y luego simplemente voy a arrastrar eso ahí dentro. Déjame ver. Ahí vas, y ahí vas. Entonces así es como se ve realmente el archivo JSON. Entonces el formateo no es el mejor, pero en este momento, yo diría personalmente, te preocupes realmente por el formato por ahora. Lo más importante es que aún lo puedes leer. Si tienes clases más complejas, entonces por supuesto se va a poner más complejo. Ya sabes, si tienes listas, entonces esto va a verse un poco diferente. Y sí, pero en general, eso es todo. Y sí, así es como puedes cargar y guardar datos con un, con archivos JSON básicamente, uh, usando el util adyacente que viene con la misma Unity, y eso sería todo. Entonces esas son básicamente las dos conferencias sobre cómo guardar el, digamos tres conferencias sobre cómo guardar tus datos. Definitivamente diría que el cargador adyacente, si bien es un poco más complicado, definitivamente, diría que usa eso. Es mucho más robusto, es mucho mejor. Y usar el jugador prefs está bien. Pero solo conducirá a dolores de cabeza porque los prefs del jugador realmente no son el, no la fuente real o la forma de reubicación debes guardar datos que son importantes para el programa. Así que guardar archivos definitivamente los haga Jason o también podrías hacerlos por tu cuenta, hacer tu propio tipo de cosa un poco sabia, pero eso es demasiado avanzado por el momento. Ahora mismo. Jason está definitivamente donde está, ¿verdad? Y eso sería todo para esta conferencia. Una vez más, espero que te resulte útil y aprendas algo nuevo. Si algo sigue sin estar claro, entonces por supuesto, no dudes en hacer una pregunta y me aseguraré de responder. Y sí. 89. (Unity Intermedio) utilizando los TileSets: Muy bien, sigamos con la sección intermedia Unidad aquí para el curso de unidad. Y en esta conferencia vamos a echar un vistazo a unos conjuntos de azulejos. Por lo que los conjuntos de azulejos son básicamente una forma en la que se puede especie de hacer un paisaje bidimensional. Y eso va a ser realmente fácil. Entonces, en realidad solo creemos una nueva escena y solo echemos un vistazo a lo que todo esto tiene en tienda. Por lo que L9 juegos de azulejos. No necesitamos una nueva carpeta dentro de una carpeta de scripts porque en realidad no necesitamos eso. A quien sí necesitábamos es una nueva carpeta dentro de nuestra carpeta de activos. Y eso van a ser las fichas, fichas sets carpeta. Y entonces vamos a hacer incluso uno más en ese. Entonces otra sub carpeta, y eso se va a llamar sólo el conjunto de título subrayado uno, sólo para que tengamos un nombre a eso. Y vamos a importar el mapa de teselas PNG. Este es una vez más uno de los activos kenny. Por supuesto, el número 1 como enlace y luego el número dos como recurso también. Cambiemos la compresión a punto de modo de filtro numb. Y luego los píxeles por unidad van a ser de 16 además de poner el modo sprite a múltiplo. Y luego vamos a decir Aplicar. Y entonces lo que es muy importante es que lo que queremos es que queramos entrar aquí al Sprite Editor. Y queremos rebanar esto, rebanarlo automáticamente. Creo que eso debería estar bien, pero en realidad creo que por el tamaño de celda es mejor. Entonces esto debería ser 16 por 16 si no me equivoco, veamos 16 por 16. Y luego pudo ver que siempre están separados por un píxel. Entonces lo que queremos es que queremos 16 por 16 y luego el offset debe ser 11. Entonces vamos a rebanar esto y ver, oh, no, eso es 64 por 64, eso no está bien. Revertir este revertir aquí. Cortar 16 por 16, offset 11, rebanar eso. Y entonces el desplazamiento es en realidad el camino equivocado. Entonces en realidad queremos, ¿queremos el relleno aquí? Esa es una forma muy rara de decir eso. De acuerdo, Entonces supongo que es un relleno para el Sprite Editor. En realidad pensé que el relleno sería el del, bueno, los bordes. Pero al parecer no lo es. Por lo que van a rebanar este 16 por 16 y luego rellenando 1 y 1. Y entonces cada uno de esos también debería funcionar muy bien. Cada uno de esos es ahora un sprite bien separado y podremos usar eso como talentoso. Ahora el aplique aquí podría tardar un poco porque esos son 485 sprites diferentes. Como se puede ver, es una especie de paisaje urbano aquí con unos cuantos verdes y una especie de sprites de construcción también. Y si eso se hace, entonces vayamos realmente a nuestra escena de conjunto de azulejos aquí, y veamos qué podemos hacer. Entonces lo que podemos hacer es hacer clic derecho en la jerarquía. En objetos 2D, tenemos el mapa de teselas. Vamos a hacer un rectángulo es mayor asuntos también hexagonal con una parte superior puntiaguda y luego superior plano. También hay asimétrica y luego isométrica Z2, Z0 como yEso también funcionaría. Pero vamos a mirar los mapas de azulejos normales de manera rectangular. Si puedo hacer que eso funcione, se van rectangulares. Entonces aparecerá una cuadrícula dentro de tu vista de escena, así como dos objetos básicos del juego, una cuadrícula GameObject con un tamaño de celda así como un hueco, brecha, y luego un mapa de teselas debajo de ella. Y esas son las dos cosas que básicamente aparecerán que son ahora. Ahora, ¿cómo podemos cambiar esto? Si bajamos aquí a la paleta de azulejos abiertos, entonces en realidad vamos a conseguir que aparezca una nueva ventana, esa es ésta. Y en lugar de ahí actualmente no tenemos mapa de teselas activo. Y dice crear un nuevo mapa de teselas. Y en realidad no vamos a crear uno. En realidad vamos a tomar nuestro pueblo de Sprite y simplemente arrastrarlo aquí. Bueno, en realidad sí tenemos que crear una nueva historia y luego la vamos a arrastrar ahí, claro. Entonces esto va a ser, solo llamemos a este azulejo, conjunto de azulejos de la ciudad. Conjunto de azulejos de la ciudad. Eso está bien. Son rectangulares. El tamaño de la cuadrícula va a ser automático y luego el modo de clasificación también va a estar bien. Entonces vamos a crear eso. Y esto se va a crear dentro de un conjunto de teselas y conjunto mental subrayado uno. Como puedes ver, esto es genial de ver, digitalizarlo. Y ahora podemos arrastrar en un spread, un pico. Y entonces vamos a hacer eso. Vamos a guardar esto exactamente, en exactamente la misma carpeta aquí. Y esto va a llevar un tiempo porque básicamente va a convertir cada uno de estos sprites en una especie de azulejo en este caso. Entonces va a, como dije, tomar un rato. Dependiendo de lo rápido que sea tu computadora, podría tardar un poco más o un poco más corto. Y entonces todo es importante aquí. Entonces si ahora miramos una especie de conjuntos de teselas, conjunto de teselas, subrayamos una carpeta, entonces se puede ver que hay un mapa de teselas 64. Y aquí arriba se puede ver realmente qué sprite es este. Y esos son básicamente todos los sprites ahora como mapa de teselas, especie de partes individuales. Y ahora puedes llevarlos y dibujar con ellos. Entonces posicionemos nuestra ventana de mapa de teselas como una especie de aquí. ¿ Y qué podemos hacer? Bueno, si nosotros, por ejemplo, seleccionamos esto, entonces se utiliza, se puede ver esto es una especie de selecto resaltado aquí. Y debe pintar con el pincel. Y si voy aquí, entonces se puede ver que es esto? Bueno, ahora puedo pintar a esto. Entonces si ahora sostengo el botón izquierdo del ratón y en realidad puedo pintar esto. Y puedo pintar, bueno aquí los azulejos básicos. Entonces eso es bastante genial en realidad eso, eso funciona así. Y los otros botones que son importantes, por supuesto, hay una selección de la cuadrícula, así que básicamente puedo seleccionar algo aquí. Y de esa manera podría poder moverlo básicamente, creo también. Entonces esto es lo que nosotros, éste quitamos la selección exactamente. Entonces básicamente puedo seleccionar esto, cambiar, la herramienta Mover y luego puedo mover esto. Entonces eso es bastante guay. También tengo diferentes tipos de modo de pintura. Entonces hay por supuesto, el modo de pintura de un solo pincel. También está el, este es el modo de caja llena. Entonces con esto básicamente puedo dibujar una caja. Y esto entonces dibujará una caja alrededor de ella. Entonces con el azulejo que se selecciona, también puedo seleccionar múltiples teselas por cierto. Entonces podría, podría, por ejemplo, decir esto para poder arrastrar, y luego tengo cuatro fichas que se están seleccionando aquí. Y entonces puedo poner eso como ejemplo. Y luego puedo seleccionar este azulejo, tomar el sorteo, y luego hacer algo así. Eso funcionaría. Y yo puedo tomar el filo, por ejemplo, algo así, lo siento, algo así. Asegúrese de que si tiene varios seleccionados , cambie de nuevo al pincel real. De lo contrario con múltiples seleccionados. Y la caja, va a ser un poco rara como puedes ver. Todavía funciona. Pero sí, ahora en realidad hemos cometido un error. Oh no, no quiero eso aquí. Lo que podemos hacer es simplemente tomar aquí la herramienta de borrador y borrar eso. Ahora porque tenemos dos azulejos seleccionados, la herramienta de borrador también es de dos azulejos gruesos o grandes. Y si solo tenemos uno seleccionado y el tamaño se establecerá en uno. También hay una herramienta de relleno. Ahora, esto también podría ser útil. A lo mejor si somos como, yo, en realidad, no quiero que esto sea verde. En realidad quiero que esto sea una especie de concreto o quiero que esto sea una especie de este concreto que vas y entonces se va a llenar eso también. Entonces eso funciona muy bien. Entonces eso ya está bastante guay. Ahora. A lo mejor, oh hombre, nena, lo que queremos es una calle, ¿verdad? Entonces estamos como, De acuerdo, construyamos una calle en realidad. A ver si podemos hacer esto. Entonces esto es por cierto, un botón central del ratón y un botón derecho del ratón pueden moverse. Y luego con el botón izquierdo del ratón básicamente puedes seleccionar cosas. Oí que aquí tenemos algún resto callejero de asfalto. Y así podríamos, por ejemplo decir, bueno, en realidad tomemos este asfalto y hagamos una calle como justo en el medio aquí. En realidad, me aseguro de que también seleccionemos esto. Hagamos una calle aquí en medio. Eso es bastante guay. Y entonces todo lo que podríamos también tener especie de estos sólidos o en realidad podemos añadir esto también. Ahí lo tienes. Y entonces podemos hacer esto. Y luego sumemos todo, sí, y entonces ahora todos sabemos que tenemos una participación mínima. También vamos a hacer Control Z, por supuesto, para hacer esto, o podemos por supuesto pintar sobre él o hacer eso en todos. También pongamos uno de esos aquí. Entonces eso es bastante guay. Ahora en realidad podemos cruzar esto. Y bueno, tal vez lo que tenemos aquí también es un no, Tal vez esto es que eso no funciona del todo. Entonces, vamos a ver. ¿De qué, de acuerdo? Entonces como puedes ver, a veces Es un poco más difícil hacer esto, pero puedes ver que éste es realmente bueno para la esquina que son. Y luego puedes hacer un rincón puesto también aquí, para luego continuar con esto. A lo largo. Ahí lo tienes. Entonces hay muchas cosas que puedes hacer con esto. Y por supuesto, esto ahora es una especie de ejemplo activo de un conjunto de teselas en particular. Pero se puede ver que después de un poco, también ya toma un poco de forma. Y digamos, Bueno en realidad, lo que realmente quiero es que realmente quiero una especie de benceno, esta zona verde, pero eso no es muy bueno, ¿verdad? Entonces ahora el banquillo es, bueno, el tipo de Mencius sentado en el espacio. Entonces eso no es muy bonito. Exactamente. De hecho Controlemos Z para volver aquí. Y, y la razón de eso es porque ahora mismo estamos usando este mapa de teselas que está justo aquí. Y la idea es que, bueno eso no es suficiente. En realidad necesitamos más. Entonces lo que queremos es que en realidad no queremos editar esto. Lo que queremos es que realmente queremos otro mapa de teselas que está por debajo de esto. Entonces lo que podríamos hacer es básicamente simplemente decir, de acuerdo, sólo tomemos este mapa de teselas y luego vamos a controlar una escritura duplicada y luego llamar a la otra, por ejemplo, base. Entonces ahora y mueve esto hacia arriba. Personalmente prefiero eso. Y luego decir uno negativo, en realidad muévelo hacia abajo porque. Ah, pero asegúrate de que esté por debajo de la rejilla. Eso es muy importante. Entonces éste está abajo y entonces tenemos tal vez algo así como el medio. Y luego duplicamos esa otra vez. Y entonces tenemos algo en la parte superior, que va a ser orden uno. ¿ Verdad? Y ahora tenemos un tres capas diferentes. Y ahora si miramos el mapa de teselas activo, en realidad podemos ver que aquí podemos elegir diferentes. Entonces antes que nada, bien, ahora los datos de todos ellos van a ser los mismos. Entonces hagamos realmente lo siguiente. De hecho, eliminemos todo lo que podamos. Hazlo como uno grande. El líder, ahí tienes. Por lo que ahora se elimina la capa base. Vayamos a la capa superior. Se suprime la capa superior. Y ahora si yo hiciera esto, ahora se borra la capa media. A ver. Ahora todo se ha ido. Por lo que puedo cambiar la selección con hacer este año, top, medio y base. O si vuelvo a tener el, ahí tienes. Entonces ahora la base tiene algo en ella y también cambiarlo aquí mismo. Tan arriba, base y un medio. Y ahora porque hemos puesto el orden en capa, que ya hemos visto dentro de amine numerosas ocasiones, sobre todo dentro del guión. Lo siento, el renderizador sprite. Sí, ahí tienes. Sabemos que bien, esto ordena los sprites reales. Si ahora quiero agregar este banquillo, como pueden ver ahora está superpuesto en la parte superior de la capa base porque ahora estamos en la capa media. Si volvemos a la capa base, como puedes ver, anularía esa capa base. Pero en la capa media, no lo anula. Y simplemente podemos añadir este bonito año de banco, tal vez dos bancos, y luego también quizá añadir un bonito árbol también. Entonces podemos, por ejemplo, tomar este y luego simplemente agregar un árbol aquí y H3 aquí por ejemplo. Y luego terminemos esto sólo para que se vea un poco más bonito. Para que tengamos, soy una especie de área verde muy bien ordenada con dos bancas y un árbol aquí. Y luego por ahí. También podemos tener esto y luego tener una bonita zona que son también. Ahí lo tienes. Este, éste. Y luego terminémoslo con la parte superior también. Y ahora tenemos dos áreas. Ahora como pueden ver, ¿qué hemos hecho? Bueno, en realidad hemos hecho una parte completa porque lo hemos hecho todo en la capa media, que por supuesto no es del todo lo que queríamos. Todo eso debió haber entrado en la capa base. Entonces es un verdadero dolor es que realmente no podemos cambiar esto. Tristemente, lo que podemos hacer es básicamente por qué estamos seleccionando esto y luego también sosteniendo Control. Entonces el control y luego seleccionarlo en realidad lo hará para que podamos pintarlo como se puede ver. Entonces podemos cambiar a la capa base. Podemos pintarlo en la capa base. Y luego en la capa media, tendríamos que volver a eliminarla. Es un poco sí, no es muy bueno que eso funcione. Cómo funciona eso, pero tristemente así lo vamos a hacer. No hay forma real de cambiar las capas que son. Y también lo que quería mencionar, mientras llamo a estas capas, Unity llama a estos mapas de teselas. Lenguaje absolutamente confuso como ese, creo que ese no es un lenguaje muy bueno porque por cualquier razón, sabes, este es un conjunto de teselas. Entonces este es un juego de títulos y luego este es el mapa de teselas también. Entonces esto se llama Telnet porque cito The My, veamos, sprites aquí, mapa de azulejo. Pero definitivamente me referiría a esto como capas. Por lo que esas son diferentes capas que puedes poner encima una de la otra. Mapa de azulejo, creo que no es el término correcto ahí. Y sí, en realidad hagamos lo mismo aquí también. Entonces vamos a copiar este. Y eso en realidad es copiar la capa base. En realidad queríamos copiar esto. Ahora, los grandes temas que todos saben, ahora lo que hemos hecho es que también son los árboles de ahí. Entonces esto es algo que como que quería mencionar también. A veces puede suceder que seas un, tienes seleccionada la capa equivocada y luego tienes que rehacer esto. Definitivamente recomendaría asegurarme de que estás en la capa correcta como esta es una de las cosas más importantes si estás trabajando con esto. Porque de lo contrario sólo va a llevar a muchos dolores de cabeza. Y puede ser en el principio, ya sabes, un poco tedioso, un poco un poco tipo de rudo. Oh no, estoy en la capa equivocada otra vez. Simplemente está obligado a suceder en algún momento y así es como va a ser. Entonces, solo agreguemos unos árboles aquí, tal vez otro árbol que sean, te vas. Y entonces tenemos nuestro mapa terminado. No es el mapa más bonito en este momento, pero claro que podemos hacer algunas cosas geniales con eso. Uno de los ejemplos de eso sería, vamos a ver. Entonces si realmente descargas esto y vas a conseguir otro mapa y te voy a mostrar rápidamente eso también. Así que es, así que es una especie de un poquito de un vistazo a otro mapa que he hecho. Sólo un exactamente para esto. Y eso va, y eso también es algo que vamos a estar usando la próxima conferencia también. Y eso se ve algo así. Entonces ese es el otro mapa que he hecho que, ya sabes, eso es bastante guay. Todas las cosas consideradas, ya sabes, tenemos unas cuantas personas aunque tú autos, unas cuantas banquetas. Y entonces podríamos tener algunos realmente no tenemos ningún top para los edificios en este caso, pero simplemente plano. Pero quién sabe, tal vez esto es una especie de escenario sonoro. Pero sí, ese es uno de los ejemplos que también he hecho que está disponible para su descarga, que también vamos a utilizar en la próxima conferencia también. Entonces, sí, eso sería todo para esta conferencia ahora mismo, uh, con los conjuntos de azulejos, realmente no hay. Es solo que tu creatividad es básicamente lo que te impide hacer cualquier cosa. En las herramientas hay realmente útiles, realmente geniales, y se pueden utilizar para todo tipo de otras cosas. Y sí, es decir, es básicamente para esta conferencia por el momento. Espero que hayas encontrado esto útil y aprendas algo nuevo. Mapas de teselas, un gran conjunto de herramientas Sue y mapas de prueba, una gran herramienta para básicamente crear tus propios niveles. Recibe cualquier duda, quédate, entonces por supuesto, siéntete libre de preguntar y me aseguraré de responder. Y sí. 90. (Unity Intermedio) animación: Muy bien, sigamos aquí la sección intermedia de unidad para el curso de unidad. Y en esta conferencia vamos a echar un vistazo rápido a las animaciones y cómo hacer animaciones. Entonces lo primero es lo primero, con nuestro nuevo mapa que por supuesto puedes obtener para el recurso. Especialmente en esta conferencia. Debe haber un recurso para el paquete donde solo se encuentre el nuevo conjunto de teselas. Y también por supuesto, el azulejo se puso a sí mismo y luego los sprites asociados con él. Si quieres eso, no necesariamente necesitas tener eso. Tus propios azulejos que funcionarían también. O tu viejo mapa de teselas, tal vez incluso el que usamos antes. Es sólo una especie de bonito espectáculo visualmente cuando estamos viendo nuestras animaciones ahora. Entonces duplicemos este mapa de título y hagamos 10 animaciones. Entonces cambiemos el nombre de eso a L diez animaciones y también empecemos eso. Y luego vamos a importar un nuevo sprite. Eso por supuesto también está disponible. Este será el brillante aventurero. Entonces esto está ahí. Y en primer lugar, eso tendrá que cambiarse un poco. Tendremos que realmente no demasiado, creo que solo apunte y luego no hay compresión aquí. Y luego por supuesto múltiple porque esos son múltiples otra vez. Entonces vamos a entrar al Sprite Editor. Déjame que me ponga rápidamente esto por aquí van. Y el tamaño de esos es de 80 por 110. Y luego vamos a rebanar esto y como puedes ver, encaja perfectamente ahí. Y entonces tenemos el tamaño para cada uno de esos. Y lo que vamos a hacer es básicamente vamos a hacer una animación de caminata corta así como una animación ociosa. Entonces esos no van a estar demasiado locos. No obstante, serán semifuncionales al menos digamos, y luego vamos a ver qué implica esto. Entonces vamos a aplicar esto. Por lo que una vez más, tenemos al aventurero y a todos los sprites particulares Múltiples debajo de él. Y entonces necesitamos en realidad ventanas específicas. Necesitamos la animación aquí, Ventana de animación. Y esto se abre en otra pantalla. Simplemente podemos poner eso aquí. Y luego también necesitamos animación y la ventana del animador. Y también personalmente puse esto aquí para que tenga básicamente el animador y la ventana de animación aquí abajo directamente donde está la consola. Y lo primero que podemos hacer es básicamente, bueno, aquí podemos seleccionar unas fotos diferentes. En realidad pongamos esta para que podamos ver realmente qué imagen es esta. Y la animación básicamente va a cambiar entre 02 aquí. No es la mejor animación ociosa para esta cosa en particular. Lo que pienso eso, eso, eso realmente funciona bien y me gusta sobre todo la mirada loca de esta cara. Entonces eso en realidad es bastante gracioso. Entonces lo que puedes hacer es lo que hemos aprendido es que si solo tomas una foto ahí dentro, así que un sprite, entonces simplemente crea un objeto de juego. No obstante, si lo hacemos también, entonces seleccionamos dos sprites aquí. Entonces por, por ejemplo, Bye. Seleccionando una de ellas y luego presionando Control y luego la otra, podemos seleccionar dos diferentes. Y si meto esa a la vista de escena, entonces como pueden ver, aquí se abre una nueva ventana. Dice crear nueva animación porque en este caso, realidad quiere que creemos una nueva animación. Y eso es lo que vamos a hacer en especie de nuestra carpeta de animaciones. Vamos a llamar a esto el jugador o vamos a llamar a esto la adventitia, aventura cruda. Aventura en inactividad ventral. Porque esta es la animación inactiva. Y vamos a guardar esto. Y ahora se ha hecho un montón de cosas por nosotros. Entonces si vamos a nuestra carpeta de animaciones, se puede ver que el guión bajo aventura 0, se ha creado un controlador de animación así como el clip de animación inactivo aventurero. Y el clip de animación es lo que nos interesa mucho y lo que podremos ver en el animador, por ejemplo, si seleccionamos nuestra aventura aquí es un, sí, Bueno, una especie de resumen de nuestras animaciones que tenemos. Y cada una de esas cajas básicamente. Entonces hay algunas cajas especiales diferentes, la entrada, esta es una especie de donde siempre entra. Hay algún estado, por lo que cualquier estado que pueda tomar la animación y animación real. Y luego hay una nota extra también. Y la idea es que lo que queremos definir en este animador son básicamente las transiciones entre diferentes estados. Para que puedas, por ejemplo, imaginar esto. Si me quedo quieto ahora mismo. Entonces ahora mismo está parado. Y luego tocamos la animación, ¿no? Y entonces él, no sé, balancea de izquierda a derecha e izquierda, derecha. Y luego desde esta nación insular, tal vez pueda o saltar o pueda caminar. Y luego el, básicamente podemos decir, vale, tenemos una animación ociosa, tenemos una animación de paseo, y tal vez incluso una animación de salto. Y luego queremos definir diferentes transiciones como esta, derecha, clic derecho y luego hacer una transición ahí. Ahora no vamos a hacer eso ahora mismo porque realmente vamos a hacer la segunda animación en poco tiempo. Pero todos estos nodos, por lo que cada uno de estos nodos, cada una de estas animaciones tiene básicamente una línea de tiempo, estás conectado con ella. Entonces si tuviera que hacer clic en el ídolo de aventura aquí, entonces se ve dentro de la ventana de animación, ahora obtenemos esta línea de tiempo. Y esta línea de tiempo cambia actualmente. Una cosa. Entonces tal vez has trabajado con, ya sabes, tal vez Premiere Pro o algún otro programa de edición de video o tal vez has visto fotos del mismo. Aquí es básicamente donde podemos definir fotogramas clave. Y la idea es que podemos una especie de agregar cosas a esta animación que nos permite básicamente cambiar ciertas cosas. Entonces si selecciono de nuevo nuestro romance de aventura, entonces puedes ver tengo este clip ocioso de aventura ahora seleccionado. Y actualmente lo que está cambiando es el sprite. Entonces como se puede ver al momento 000, el sprite es éste. Y luego si me muevo esto, entonces el sprite cambia a esto en el siguiente segundo. Ahora si yo tocara esto, entonces como pueden ver, es como se vería la nación insular es por supuesto, demasiado rápido, ¿verdad? Porque sólo tiene dos cuadros de largo. Y eso no sería demasiado bueno. Para que podamos alejarnos con sólo un ratón desplazándose hacia abajo. Y podemos mirar por aquí con el botón central del ratón y luego podemos tomar uno de esos fotogramas clave. Entonces por ejemplo, éste, el segundo. Imagen aquí. Y podemos arrastrarlo para que sea, por ejemplo, algo así como, bueno, digamos cinco fotogramas. Entonces si yo tocara este clip ahora como puedes ver, ahora, él tomaría y se quedaría por alrededor de un cuadro. Pero eso por supuesto, tampoco es exactamente lo que quiero, ¿verdad? Porque ahora este en particular sólo se muestra para alrededor de un marco y luego vuelve al otro. Entonces podría no ser eso lo que queremos. Lo que queremos es quizá que se quede así por un rato, más tiempo. Y bueno, ¿cómo podemos lograr eso? Bueno, tal vez por ejemplo, tomamos esto y luego podemos, por cierto, copiar algo, entonces Control C. Y entonces si voy por ejemplo a aquí, puedo poner en el control V y pegarlo. Y ahora en teoría, digamos que lo puse aquí mismo. Por lo que ahora se quedaría ahí por una serie de cuadros. Entonces esto serían otros seis cuadros, supongo. Y veamos esto ahora mismo. Ahora se vería así. Y eso es mucho más como una animación de Isla. Ahora no es la mejor animación ociosa. Como dije, es un poco inestable, pero bastará por ahora para que tengamos algo en absoluto. Entonces eso es una especie de cosa bonita. Ahora podrías, por supuesto, hacer de esta manera, mucho más rápido o más lento así. Podrías hacer esto un poco más o menos dependiendo de lo que quisieras hacer, ¿verdad? Podríamos arrastrar este año o hacer esto un poco más lento o más rápido. Ahí está, por supuesto que tú una vez más, solo estoy brindando las herramientas. Lo que haces con ellos depende de ti. Pero lo que podemos hacer ahora es también en otras propiedades. Entonces si lo pongo en las otras propiedades, puedes ver que básicamente las hay, creo que todas ellas, o al menos ciertos componentes están disponibles aquí para que yo cambie. Como puedes ver, básicamente todo lo que puedo cambiar dentro del renderizador sprite. Y entonces también podría, en teoría, cambiar las cosas en la transformación por una animación. Y esto es algo realmente genial. Por lo que puedes cambiar ciertas cosas en función del tiempo cuando se reproduce una animación. Ahora cambiar la transformación a veces es un poco no demasiado bueno. Yo sólo quería mencionar eso porque puede tener efectos torneados, sobre todo si estás cambiando la posición con algunas otras cosas. lo que normalmente debes tener cuidado con eso, excepto que si tuvieras especie del componente visual de un objeto de juego en particular sea diferente de la posición real. Entonces si tienes una especie de, soy un niño y un objeto de juego de padres, entonces podría haber una forma en que esto funcionaría. Sí, y entonces echemos un vistazo a la otra. Entonces el otro a través de la animación caminante que me gustaría va a ser también dos diferentes. Esto van a ser nueve y 10, creo. Entonces nueve y 10, Esa es la animación caminante que quiero poner. Y hay múltiples formas en que podemos hacerlo. O también podemos arrastrar eso en o el Y no recomendaría que lo que yo recomendaría sea simplemente ir aquí y decir Crear Nuevo Clip. Y luego lo vamos a decir en Ventura. Camina y guarda eso también. Y ahora si selecciono otra vez esta aventura y la aventura, un paseo está aquí, y entonces básicamente puedo arrastrar sobre nuestros sprites individuales. También podría decir en la propiedad sprite renderizador y luego decir sprite plus. Entonces ahora el sprite cambiará. Entonces pondré el nueve aquí y luego el 10 también. No queremos esa. En realidad vamos a mantenerlo así. Entonces, en realidad, tampoco quiero que se ponga de pie y luego cambia a caminar. En realidad quiero que comiencen con la caminata y luego cambien a ésta. Y luego cambiar de nuevo a la postura de caminar. Entonces algo así. Entonces veamos cómo se vería ese. Bueno, eso es, eso ya es más o menos una animación caminante. Un poco demasiado rápido, así que hagámoslo un poco más lento, tal vez algo así. Por lo que 15 marcos. Ahora eso estaría probablemente bien. Y eso ya funcionaría bastante bien. Entonces, vamos a guardar eso por ahora. Y entonces realmente vamos a conseguir algo de una conferencia muy vieja, de una muy vieja aquí. Y ese va a ser el guión de movimiento. Por lo que en realidad vamos a ir a Scripts, Crear nueva carpeta, animaciones de Elton. Esos van a ser los guiones de movimientos, ¿verdad? Pongamos el guión de movimiento por aquí. Y vamos a ver. Simplemente se va a recargar un momento y luego se irían, Abramos eso también. Y rápidamente agreguemos eso a nuestro aventurero también. Ahí lo tienes. En el guión de movimiento ahí. Déjenme llegar rápidamente esto por aquí y luego podremos echarle un vistazo a esto. Entonces esto simplemente nos permite mover a nuestro personaje, y ahora en realidad vamos a añadir otro componente aquí. Entonces otro campo entonces ese va a ser el animador. Este es el Animador. Ahora por suerte, porque esto está en el mismo objeto de juego, simplemente podemos decir este punto get componente animador. Entonces eso es realmente fácil. Y entonces lo que vamos a hacer es que vamos a hacer lo siguiente. Entonces cuando estamos dentro de nuestro, um, básicamente mover método. Y luego más tarde en la indirección, lo que quiero es que quiera una especie de establecer un componente de velocidad así como quiero voltear los componentes visuales. Entonces si escribo ahora, si fuera a empezar esto, lo que va a pasar es lo siguiente. Se va a ir. Si sí, Ahí vamos. Ahora comenzó, sólo va a tener la animación ociosa y ahora puedo caminar pero la animación ociosa aún se coloca, que por supuesto, eso no es del todo lo que quiero. El motivo por el que se juega la animación ociosa. Si voy al animador, como pueden ver, el punto de entrada es donde empezamos. Y entonces tenemos una transición al ídolo de aventura aquí. Y luego nada hacia la animación de paseo. No sabemos cuándo debemos caminar la animación se debe jugar. Por lo tanto, en realidad no hacemos nada aquí. Y bueno, ¿cómo podemos arreglar eso? ¿ Cómo podemos hacer que ciertas cosas jueguen? Bueno, podemos hacer que ciertas cosas se jueguen haciendo lo siguiente. Podemos definir parámetros y eso está a la izquierda aquí. En lugar de seleccionar jugadores, podemos seleccionar parámetros. Y esos parámetros son básicamente, bueno, pueden ser de diferentes tipos. Entonces flotar y entero, un toro o un gatillo. Vamos a seleccionar un flotador en este caso, y este flotador va a ser velocidad. Entonces esta es la velocidad a la que se mueve este personaje. Y dependiendo de la velocidad, vamos a o bien a la transición a la animación de caminata o vamos a volver a la transición. Entonces esa es básicamente la idea ahí. Entonces hagamos clic derecho en el ídolo de aventura aquí y hagamos la transición para luego moverlo hacia la aventura, un paseo. Y si ahora damos click en esta flecha pequeña, se puede ver que aquí hay algunas cosas y podemos o incluso ver una vista previa. Por lo que éste debe caminar y luego cambia a una animación caminante. Ahora bien, esto no es del todo lo que queremos. También podemos especie de ampliar los ajustes aquí. Y esto es una especie de, esto es una duración de transición aquí. Entonces básicamente estamos mirando una transición de una a otra. Ahora lo que personalmente creo es que en realidad no queremos un tiempo extra y tampoco queremos una transición aquí. En realidad sólo queremos que básicamente cambie de lugar. Y veamos qué dice éste. Esto no tiene tiempo extra. Sí. No tenemos ninguna condición puesta ahí todavía. Por eso estamos recibiendo esta advertencia aquí. Vamos a poner en un condicional lo suficientemente pronto. Entonces no hay tiempo de salida y no, bueno, no hay tiempo de salida y no hay duración. Y ahora en realidad tenemos que especificar una condición. Entonces si no tenemos un tiempo extra, entonces tenemos que tener un padecimiento. Y la condición va a ser velocidad va a ser, quiero decir, supongo que apenas mayor a 0.01. Eso es en realidad todo lo que quiero. 0.1. Hagamos 0, 0, 1, el ego. Entonces eso es todo eso, realmente uno. Entonces en cuanto la velocidad sea más de uno, entonces quiero también la animación de la OIT, un crossover a la animación de caminata. Y entonces también puedo decir, bueno, si estamos en la animación de paseo, tal vez en algún momento quiero volver a la emisión de la isla. Entonces si básicamente dejé de moverme, y esto básicamente sucederá si entro aquí y una vez más, entro en el, pospongo el tiempo extra y sin duración fija, sin transición por la duración. En realidad, lo siento, la ración fija es correcta, pero no hay duración de transición ahí. Entonces una vez más, obtengo la advertencia a, necesito una condición y esto simplemente va a ser velocidad es menor a 0.01. Y eso sería todo para ellos. Entonces en cuanto establecemos la velocidad, entonces básicamente podemos controlar en qué animación lo encuentra nuestro personaje. Ahora bien, esta velocidad no necesariamente tiene que correlacionarse perfectamente con nuestra velocidad que realmente tiene el jugador. Por lo que ahora podremos establecer la velocidad de una manera particular. Entonces si miramos lo siguiente, entonces lo que podemos hacer es cuando estamos dentro de nuestro método de movimiento. Por lo que esto se podría poner en cualquier lugar. Pero si lo estamos, hagamos lo siguiente. Hagamos esto en realidad. Por lo que dentro de nuestro animador, al principio, animador dot set float. La velocidad va a ser 0 f Así que esto es tan sencillo como esto va. Por lo que simplemente tenemos el nombre de la variable real así como entonces qué, dondequiera que la establezcamos. Ahora estamos estableciendo esto en el inicio, y luego también estamos fijando esto. Por ejemplo, si nos movemos en alguna dirección. Ahora lo que pasa es que podríamos por supuesto, poner esto en la dirección específica que estamos moviendo. Entonces podríamos decir, Hey, queremos que esto sea cualquiera que sea la dirección, veces la velocidad. Y entonces así tiene una velocidad negativa. Nos movemos a la, a la izquierda y luego lo positivo si te mueves a la derecha y así sucesivamente y así sucesivamente, no vamos a hacer eso. Simplemente lo vamos a poner a sí mismo ahora mismo para que sea positivo cuando nos movamos. Y entonces por supuesto también tenemos que restablecerlo de alguna manera para que esto funcione también. Entonces mientras éste funciona al principio, poco no funciona más adelante por la línea. Entonces lo que probablemente queremos es que probablemente quisiéramos que esto se llame dentro del método de actualización. Y sí, para que esto suceda. Y cuando no nos estamos moviendo, sin embargo, donde queremos que esto se establezca aquí al principio, para que no interfiera con nada. Ahora hay múltiples formas, por supuesto, una vez más, donde podríamos hacer esto con. Podríamos, por ejemplo, decir, bueno tal vez si no me estoy moviendo, entonces establecemos el y establecemos la velocidad en 0. También como esta velocidad también podría establecerse en 0, algo así. Pero esto va a estar bien. Esto va a funcionar. Y luego también va a haber un vacío privado flip visual, que ya vamos a implementar. Entonces esta es la dirección aquí, ninguna dirección. Esto es lo que quiero llamarlo. Y no pongamos nada ahí ahora mismo porque les voy a mostrar por qué vamos a necesitar esto en tan solo un momento. Pero en esto, con esta configuración, sin el volteo, visual, esto en realidad ya debería funcionar totalmente bien. Entonces, veamos si ese realmente es el caso. Por lo que a veces también puede ser útil porque ahora mismo tenemos al animador y las animaciones en nuestro guión de movimiento también. A veces podría ser mejor si realmente separamos esos, pero no es estrictamente necesario. Entonces ahora mismo estamos en la nación insular. Todo está funcionando muy bien. Y si me muevo y como pueden ver, hemos transitado de inmediato a la animación de caminata. Ahora, somos una especie de Moonwalking aquí. Déjame maximizar esto para que realmente podamos ver qué está pasando. Para que podamos caminar. Y luego si camino a la izquierda que no, estamos caminando de luna. Entonces estamos trabajando en el tipo de, ya sabes, detrás de nosotros, que por supuesto no es del todo lo que queremos. Por eso dije que aquí podemos voltear el valor x y luego simplemente volteamos el renderizador sprite. Y esto es lo que vamos a hacer con este método flip aquí. El flip visual simplemente va a decir este punto get componente sprite renderizador. Flip x es igual a punto de dirección x es menor que 0. Entonces el flip x es simplemente un bool. Y la dirección y es, bueno, o va a ser uno o 0. Y si lo es, Sí, exactamente porque el movimiento a la izquierda, entonces éste es negativo. Entonces sí, está por debajo de 0. Por lo tanto, flip x va a ser verdad, y de lo contrario va a ser falso. Entonces ahora aquí, voltea la dirección visual que vayas. Por supuesto, para ser franco, lo mejor que se puede hacer aquí es por supuesto también decir hacer este renderizador sprite privado. Renderizador Sprite arriba. En realidad configuramos esto aquí porque vamos, hagámoslo correctamente, cómo se supone que se haga. De lo contrario, ¿por qué incluso molestarse con ello? Ahí lo tienes. Sprite renderizador dot flip x. Y ahora todo está bien. Entonces no hagas el componente get llamado aquí mismo. Como lo he dicho en numerosas ocasiones. Y ahora debería voltear el visual si nos movemos hacia la izquierda. Y ahora en realidad deberíamos tener una animación bastante bien viable. Entonces la eliminación, como dije, no es la mejor, pero si nos estamos moviendo hacia la derecha, eso funciona. Y si nos estamos moviendo a la izquierda, eso también funciona. Y luego también da la vuelta a la imagen. Y lo grandioso de esto es que también se queda ahí. Entonces esa es una especie de forma en la que se podría hacer esto. Ahora si me muevo hacia arriba o hacia abajo, entonces la imagen real girará de nuevo hacia la derecha. Pero eso es algo muy menor que en realidad debería ser arreglable muy fácilmente, ¿verdad? Y sí, eso sería en realidad por la idea de las animaciones. Entonces hay mucho más, por supuesto, una vez más, por hacer en animaciones, ¿no? Al igual que de costumbre, estas son miradas muy someras de muchos sistemas porque tiene tantos sistemas que ofrecer. Es realmente difícil porque, quiero decir, cada uno de los sistemas podría probablemente ser su propio curso por derecho propio. Es decir, la mayoría de ellos, solo estoy pensando nuevamente en el sistema de partículas una vez más. Entonces esto es una especie de primera mirada a las animaciones. Hay cosas increíbles que se pueden hacer con él y la herramienta es increíblemente poderosa, como has visto. Hay tantas cosas que puedes cambiar con la animación aquí, así como el animador te ofrece tantas cosas por hacer. Y lo mejor, como dije, con lo que puedo dejarte una vez más, es sólo probar todo lo que alguna vez pensarás. Entonces cualquiera, deja que tu creatividad corra completamente salvaje y solo prueba algunas cosas y ve si puedes conseguir que algo funcione. Y sí, solo juega con él. Esa siempre es una gran idea. Y eso sería en realidad todo para la animación en este punto. Como siempre, espero que esto te resulte útil y aprendas algo nuevo. Agradecería mucho una crítica de ustedes. Y si siguen siendo alguna pregunta, por supuesto, siéntete siempre libre de preguntar y me aseguraré de responder. Y sí. 91. (Unity intermedio) Objetos escribibles: Muy bien, sigamos con la sección intermedia Unidad aquí para el curso de unidad. Y en esta conferencia, vamos a echar un vistazo a los objetos scriptables. Los objetos scriptables son un tipo específico de contenedor de datos. Por lo que hay una forma de almacenar datos que es independiente de una clase en particular básicamente. ¿ Y qué significa eso? Bueno, vamos a echarle un vistazo a eso. Y para eso vamos a crear una nueva escena. Por supuesto, este será L 11 objetos scriptables. Ahí lo tienes. Entonces abramos esa escena. Y luego también vamos a hacer una nueva carpeta de scripts. Esto va a ser L 11 objetos con capacidad de script. Ahora vamos a necesitar dos guiones para este, este va a ser el guión C-sharp, jugar cartas, jugar cartas. Y luego otro guión de C Sharp. De hecho, cierremos de todos esos. Y entonces hagamos otra. Y este va a ser el objeto capaz de guion de play card. Ahora también puedes llamar a este clics art. Entonces creo que llamarlo jugar acordes, scriptables, objetos en realidad está mal. De hecho, eliminemos eso de nuevo y hagamos de este objeto scriptable. Porque ese es un mejor nombre. Los objetos scriptables serían un poco raros tener que se nombrara en plural. Entonces Play Card, play card, script, able up, expulsar. Ahí lo tienes. Y eso estaría bien. Entonces abramos cada uno de esos. Entonces la carta de juego y los objetos scriptable. Y entonces podemos pensar o para nosotros mismos, bueno, ¿qué podría una mitad de juego de cartas? Entonces en nuestro ejemplo, lo que quisiéramos es que queremos una especie de nombre de tarjeta y tal vez, podrías imaginar tal vez HB y cantidad de valor. Entonces algo que sería parecido a una especie de juego de cartas en, no me gusta Magic The Gathering o Hearthstone o algo así. Y lo primero que vamos a hacer es que lo vamos a hacer, en lugar de heredar del comportamiento motor, aquí vamos a heredar de objetos scriptables. Y esto básicamente nos permitirá crear algo realmente bonito y fresco. Y lo siguiente que queremos aquí es por encima de la clase pública, en realidad queremos los corchetes aquí y dentro de ahí queremos crear el menú Asset, nombre de archivo es igual a cartas de juego. Entonces este es el, básicamente el nombre del nombre del archivo que vamos a crear y luego el nombre del menú va a ser tarjeta Palais. Vamos a ver qué hace eso en un rato. En primer lugar, pensemos en esto. Entonces los datos que queremos mostrar los objetos scriptables de corte para tener es, por ejemplo, un nombre, por lo que nombre de la tarjeta. Queremos que haya un, un entero, por ejemplo, HP y una forma de tarjeta. Entonces vamos a hacer MP, en realidad llamado MPI y luego también tal vez cambiar el sprite. Por lo que este sería un sprite de tarjeta que también podría guardarse en especie de este objeto scriptable. Entonces todo eso está bien y bien, pero ¿qué nos da eso? ¿ Qué hace eso por nosotros en este momento? Bueno, ahora mismo no lo hace. Mucho para nosotros, pero lo que podemos hacer ahora, y eso va a ser como una cosa realmente genial. Podemos hacer clic derecho en nuestra carpeta. Y luego podemos ir al menú Crear. Y en la parte superior verás, oh, ¿qué es esto? Play card es algo nuevo que podemos sumar ahora. Y esto agregará un objeto scriptable. Como se puede ver, se trata de una obra llamada objetos scriptables. Y ahora podemos cambiar esto por lo que queramos. Entonces, por ejemplo, podemos decir, bueno, as, as de corazones es el nombre de la tarjeta. Por ejemplo, se podría decir, bueno esto tiene 10 HB y 25 manera. Y entonces también podemos añadir un sprite de cartas aquí. Entonces podemos bajar a nuestros tribunales, por ejemplo, y luego simplemente añadir la cancha 0 porque ese es el as de corazones. Y sin embargo ahora en realidad tenemos una tarjeta nueva. Entonces llamemos a este as de corazones también. Por lo que este sería uno de los posibles objetos de datos que el objeto real puede tomar. Entonces construyamos también un bonito lugar de un objeto con el que básicamente podemos visualizar esto. Entonces sólo vamos a llevarnos el acorde 0 aquí y vamos a llamar a esto la carta de juego. Y luego le vamos a añadir un lienzo. Entonces estamos en realidad, solo agreguemos el texto Mesh Pro a ella. Y este lienzo entonces en realidad estará en el espacio mundial esta vez. Sé que esto es absolutamente loco, por supuesto, todavía con la cámara principal. Y entonces también tendremos dos ubicados en eso y lo haremos un poco mucho más pequeño. Entonces hagámoslo un 100 por un 100 por ahora. Lo mismo con el texto que va a ser un poco más pequeño. Hagamos el texto un poco más pequeño aquí por ahora. Y luego reduzcamos el tamaño. Y entonces podemos averiguar esto. Entonces, en realidad, también vamos a escalar un poco esto hacia abajo. Hagamos esto 0.5.5. Y nuestro empezar a llegar a donde queremos que esté, 0.5.05.05. Ahora allá vamos. De acuerdo, así que ahora el Canvas 000 está a la talla que queremos. Entonces podemos poner el texto aquí arriba. Y entonces realmente podemos hacerlo más grande otra vez, al menos un poco. Ahí lo tienes. Entonces eso estaría bien. Creo que si lo hagamos auto size, eso en realidad no funcionó del todo como quería que textuara auto size. ¿ Cuál es el tamaño mínimo ahí? Esa es probablemente la razón por la que no funcionó. Ahí lo tienes. Es 18, por supuesto, hacer este 10. Entonces va a estar ahí. Entonces este es el nombre de la tarjeta que queremos. Queremos esto básicamente especie de a los lados de la tarjeta así y entonces será el nombre de la tarjeta. Eso está bien. En realidad, eso podría ser incluso un poco más pequeño. Entonces esto podría incluso ser, digamos un ocho. Entonces también centroide. Así que eso es un poco bonito. Y entonces básicamente podemos copiar esto, por ejemplo, aquí abajo, sólo para que lo tengamos. Podemos hacer que el HP y la manera de valorar algo aquí y luego aquí. Y luego por supuesto, asegurándonos de que realmente renombramos esto, por lo que este texto nombre de tarjeta, Vamos a llamarlo así. Sí, este es el texto de acorde y esta es la tarjeta AMP textos por ejemplo. Y así sería esto, vamos a poner un, ya sabes, algo así como diez aquí. Y un 10 aquí. Sólo tienes algo ahí dentro. Sí, eso sería todo. Entonces por supuesto, cuando estemos en el juego, los artilujos estarían apagados. Entonces esto es lo que veríamos por esta tarjeta. Entonces eso es bastante guay. Y ahora básicamente lo que vamos a hacer es que primero nos apegaremos a los guiones de acordes reales de juego a ella. Entonces nuestro guión que hemos hecho no los objetos scriptables, sino el comportamiento moral que en realidad no hemos cambiado todavía y será lo que es. Básicamente podemos, podremos poner datos. Son tan distintos objetos scriptables, uno de los que ya hemos creado, así que solo, por el infierno de ello, creemos otra tarjeta de colega aquí. Y eso va a ser para el rey de corazones. Y el rey de corazones. Eso va a ser como una especie de bonita, por supuesto, en primer lugar, rey de corazones, el nombre de la tarjeta y luego esto va a ser como 25, alrededor de una 150 manera. Y el rey de corazones es el duodécimo año, así que eso está bastante bien. Entonces volvamos al rey de corazones el 12. Vamos a arrastrar esto. Y ahora tenemos dos ejemplos. Entonces el as de corazones y el rey de corazones. Y ahora por supuesto, todavía necesitamos agregar la funcionalidad para el propio corazón del lago, por supuesto. Y eso se va a ver algo así. El primero que vamos a tener es una tarjeta de juego privada, objetos scriptables, play chord script object hace los datos de la cancha, por supuesto, correcto, así que estos son los datos del acorde específico que se está mostrando. Vamos a añadirle un campo serializado para que básicamente podamos configurarlo con, ya sabes, en el constructor. Y entonces también tendremos el uso de t, usando la fila tmp. Vamos a tener un TMP privado, txt, TMP textos. Ahí lo tienes. Ahí va a haber el texto del nombre de la tarjeta. Y luego vamos a copiar esto. También tenemos un, un texto HP a texto HP. Y luego hagamos también un texto vacío. También serialicemos aquellos sólo aunque podamos ver en qué están tramando básicamente. Ahora esos pueden ser, por supuesto, también establecidos a través del método de inicio. Pero en realidad vamos a hacer eso dentro del constructor también. Y entonces lo que podemos decir es que básicamente será privado void set, establecer tarjetas a básicamente tarjetas datos. Ese es un método al que vamos a llamar. Y luego dentro de ahí vamos a decir get component sprite renderizador. Y somos porque sólo vamos a hacer esto una vez en el método de la tienda. En realidad no vamos a necesitar poder atrapar esto, Así que eso va a estar bien. Y voy a decir texto de nombre de cordón. El texto es, el texto en realidad es igual a los datos de la tarjeta, enseñó la coordenada de punto. Y luego vamos a copiar esto sobre los textos de HP aquí. Simplemente igual a los datos de la tarjeta punto-punto-punto cancha HP y MP texto es igual a la tarjeta mp. Ahora esto es por supuesto toString porque esos son valores enteros aquí y tienen que ser establecidos en string. Y entonces básicamente podemos llamar onStart la tarjeta set a los datos de la tarjeta. Y podríamos, por ejemplo, también tener en teoría un do, hacer un método de actualización y tener un punto de entrada. Keydown, keycode.edu para actualización, por ejemplo. Y luego también llamar a este método que son. Y luego básicamente actualizar qué a los datos que hayamos puesto ahí dentro. Por lo que esto en realidad ya debería funcionar muy bien. Entonces, vamos a ver. En primer lugar, por supuesto tenemos que establecer aquí los textos, así que nombra texto, texto HP y MP. Y luego también darle uno de nuestros objetos scriptable. Pongamos primero al rey de corazones. Entonces esto debería cambiar. Entonces, solo empecemos la escena o ablandemos el juego. Como se puede ver, rey de corazones, rey de corazones, brillante aparece con 25 HB y una manera 150. Ahora si tuviéramos que cambiar el as de corazones y reprimiéndote, entonces se actualizará a nuestra nueva tarjeta. Por supuesto, en teoría, podríamos hacer es algo así como un si los datos reales cambian, entonces podríamos ser capaces de actualizar también los visuales. Pero eso tampoco es del todo necesario. Y sí, y ahora básicamente podemos crear nuevas cartas de juego aquí. Entonces, por ejemplo, podemos hacer la reina de los clubes si puedo encontrar a la reina de los clubes. Entonces eso va a ser interesante. Entonces creo que eso fueron clubes. Por lo que reina de los clubes para P53, creo. Entonces. Reina de los clubes, ¿dónde está Ahí? Es 53. Añadamos que ahí como el sprite. Y esta es la reina de los clubes. Y esto tendría como tal vez 65 HB y un 140 MP. Entonces eso es como tarjeta realmente fuerte. Y lo grandioso es entonces, ahora simplemente puedo cambiar esto aquí. Y en cuanto arranque, se cargan los datos. Ahora en este caso, es un poco demasiado grande, pero está bien. Eso no es un tema. Eso es algo que podemos arreglar muy fácilmente. Entonces lo son, un auto tamaño probablemente sería mejor. Entonces básicamente podemos hacer sobrescribirlo con un tamaño automático y decir, bueno en realidad, hagamos un mínimo de seis y un máximo de 15, algo así. Y en cuanto hagamos eso, incluso entonces, cuando el nombre real sea demasiado grande, seguirá funcionando muy bien. Entonces eso es realmente genial. Entonces eso es como una de las clases de cosas que puedes hacer con objetos scriptables. Y en el futuro, realidad vamos a ver una buena aplicación para objetos scriptables donde realmente tenemos múltiples tipos de enemigos con eso. Por lo que los objetos scriptables realmente agradables a las tiendas como enormes cantidades de datos en por así decirlo. Y sin embargo lo son ahora, básicamente podemos tener múltiples de esos objetos aquí, almacenar diferentes tipos de datos. Y con eso, básicamente son independientes de cualquier clase. Y sí, eso sería para la conferencia de objetos scriptables. Como dije, una aplicación adecuada vamos a ver cuando hagamos nuestro próximo juego. Pero eso será todo para esta conferencia. Espero una vez más que te resulte útil y aprendas algo nuevo. Si hay alguna pregunta, como siempre, siéntete libre de preguntar y estaré debería responder. Y sí.