Transcripciones
1. Introducción: Bienvenido al desarrollo de juegos con Lua y clase Love. A lo largo de estas lecciones se estará discutiendo el proceso de creación de juegos desde cero, utilizando el amor, también comúnmente llamado Amor 2D. Y estaremos haciendo toda nuestra codificación en Lua. El tipo está basado en proyectos. El objetivo es crear aquí este juego, que podría servir de base para cualquier juego de estilo RPG. Este tipo de juego es una introducción perfecta ya que involucra el movimiento del jugador, lectura de la entrada del teclado, la adición de sprites, animaciones, colisiones con la física y el diseño de niveles usando teselas. Al trabajar en este proyecto, hablaremos a través de todos los fundamentos básicos de usar el amor para que
seas capaz de crear juegos únicos propios o construir sobre éste. No necesitas ninguna familiaridad con desarrollo de
juegos o el amor a de, para tomar esta clase. Hablaremos sobre cómo instalar todo y configurar en tu computadora para luego ir desde ahí. Yo sí te recomiendo que tengas algo de experiencia codificando sin embargo. Si has usado otros lenguajes de programación además de Lua antes, probablemente
puedas retomar el lenguaje bastante rápido. No obstante, si eres completamente nuevo en la codificación o solo quieres hacerte una idea por Lua. Tengo otra clase de Skillshare llamada introducción a la programación Lua, que no asume ningún conocimiento previo y te preparará por completo para esta clase de amor 2D. Cuando estés listo,
empezaremos las cosas instalando el amor y configurando las cosas para codificar nuestros juegos. Adelante a la siguiente lección.
2. Instalación y configuración: Hola amigos. En este video, voy a pasar por los pasos de instalar el marco del juego. Me encanta de, a tu computadora y también mostrar cómo configurar nuevos proyectos y cómo ejecutarlos. Instalar el amor es muy fácil. Sólo tienes que ir al amor a d.org. Y los enlaces de descarga están justo aquí en medio. Si estás en Mac, solo puedes descargar este archivo e instalar la aplicación. Y si estás en Windows, recomiendo el instalador. Mientras estás pasando por la configuración de Windows, asegúrate de hacer un seguimiento de esta ruta aquí mismo, la carpeta de destino. Vamos a estar usando eso en tan solo un segundo. Una vez finalizada la instalación, te
recomiendo crear un atajo para amar en tu escritorio. Si estás en Mac, solo puedes agregar la aplicación love a tu doc en Windows. Vamos a visitar ese camino
de instalación desde hace apenas un momento. En mi caso, está aquí en C Program Files, amor. Y si echamos un vistazo más de cerca, y encontraremos este archivo
EXE de love dot , justo en esta carpeta. Si no ves la parte de punto EXE, puedes subir a Ver y luego elegir estas extensiones de nombre de archivo. Y eso mostrará la extensión de cada archivo. Por lo que queremos crear un atajo a este punto de amor EXE. Entonces voy a bajar a Enviar al escritorio. Y luego veremos que aquí hay un atajo. Voy a seguir adelante y renombrar esto a amor. Una vez que esto esté listo, puedes
seguir adelante y hacer doble clic en él para empezar. O si estás en Mac, simplemente ejecuta la aplicación y deberías ver una ventana que se vea algo parecido a esto, solo alguna animación de aspecto extraño. Podría verse ligeramente diferente
dependiendo de qué versión de amor estés usando. Pero esta es la pantalla que muestra cuándo se está ejecutando el amor, pero no se encuentra ningún juego. Y si ves algo como esto, eso significa que todo va bien hasta ahora. El siguiente paso es instalar algún editor de texto que estarás usando para codificar. Puedes usar cualquier cosa con la que te sientas cómodo. Pero recomiendo encarecidamente Visual Studio Code, razón por la
que uso en estos videos. Y es completamente gratis. Puedes obtenerlo del código dot Visual Studio.com. Y los enlaces de descarga están justo aquí arriba. Basta con descargar el correcto para su sistema operativo. Una vez que hayas descargado e instalado el código de Visual Studio, adelante y arrancarlo. En este programa, podremos editar y crear archivos para nuestro juego. Para ello sin embargo, necesitaremos crear un nuevo proyecto de amor. Proyectos y me encantó D tienen una estructura muy sencilla para hacer uno. Simplemente vas a crear una nueva carpeta en
cualquier lugar de tu computadora. Y mi caso, solo haré mi en el escritorio para que haga clic derecho y elija Nueva carpeta. Y voy a llamar a esta carpeta mi juego. Entonces ahora solo tengo una carpeta llamada mi juego en el escritorio, o esta carpeta puede estar en cualquier lugar de tu computadora. Entonces de nuevo en el código de Visual Studio querrá abrir esa carpeta. Y lo podemos hacer con File. Y luego Abrir carpeta. Y creé mi carpeta en mi escritorio y aquí mismo, así que voy a seleccionar esta carpeta y elegir Seleccionar carpeta. Por lo que ahora nuestra carpeta está abierta. Podemos ver el nombre de mi juego en esta sección y la esquina superior izquierda justo aquí. Ahora que estamos aquí, el siguiente paso es
crear nuestro primer archivo Lua. Y lo podemos hacer usando este nuevo botón de archivo. Es posible que tenga que pasar el cursor sobre esta sección para verla, pero haga clic en Nuevo archivo y necesitamos nombrar a este archivo principal punto Lua. Debe tener este nombre exacto. Y una vez que presiones Enter, se creará
el archivo y debería abrir esta nueva pestaña por aquí. Dice principal punto lu arriba. Es solo un archivo vacío en este momento. Y esto es todo. Esta es la estructura simple de que todos amaban a los proyectos DIY comienzan con simplemente una carpeta que contiene un archivo llamado main que Lua. Por supuesto, estarás agregando más a esta carpeta, pero solo tener esto solo nos permite ejecutar el proyecto
a través del amor. Hay algunas formas en que puedes ejecutar un proyecto. Aquí tengo mi carpeta de proyectos, solo mi juego. Y como acabamos de ver, sólo contiene este archivo
main.py y que acabamos de crear. Y una forma en que podemos ejecutar este código es tomando la carpeta del proyecto y arrastrándola a un atajo de amor. Y si tiene éxito, debería aparecer. Una ventana de amor podría decir sin título, y es sólo una gran pantalla negra. Si ves esto, entonces eso significa que funcionó. Dado que nuestro archivo main.py está vacío, esto se espera un juego vacío. Una vez que agreguemos código a este archivo, la ventana empezará a mostrar lo que elijamos nuestro juego para ser. Como nota al margen, puedes arrastrar y soltar carpetas desde cualquier lugar de tu computadora. No tiene que ser específicamente desde el escritorio. Ahora bien, aunque arrastrar y soltar es fácil, podemos hacerlo aún más fácil ejecutando nuestro proyecto a través de Visual Studio Code. Para ello, solo necesitamos instalar una extensión. Y la extensión es solo un plug-in que hace que código
VS haga algo específico. Entonces en esta pestaña Extensiones de aquí mismo, vamos a buscar lo
específico que es esencial que queremos, que se llama soporte 2D amado. Por lo que cuando busques esto, debes encontrar este amor para hacer Plugin de Soporte. Para que puedas seguir adelante e instalar eso. Y una vez que veas los botones Desactivar y desinstalar, sabes que la extensión se instaló con éxito. partir de aquí sin embargo, sí necesitamos configurarlo un poco. Por lo que usando este icono de engranaje, podemos bajar a los ajustes de extensión. Y luego aquí dentro, necesitamos verificar que este camino, el camino 2D del amor, es preciso. Antes cuando instalas amor a D, Fuimos al camino donde se
instaló con el fin de crear el atajo. Ese mismo camino es lo que necesitamos incluir aquí. Si estás en Windows, el camino que se muestra aquí mismo, que es C Program Files, amor, amor, dot EXE. Este camino probablemente sea correcto. Y si estás en Mac, si instalaste la app love a tus aplicaciones, el camino probablemente será este camino que está en pantalla. Pero siempre asegúrate de volver a comprobar dónde realmente
instalaste y poner ese mismo camino aquí. Y una vez que tengas este camino especificar, podemos seguir adelante y cerrar estas pestañas y probarlo. Y solo puedes volver a tu pestaña inferior de punto principal en la parte superior, o subir a la porción del Explorador de archivos y hacer doble clic en main.py. Entonces una vez que
estemos aquí, podemos ejecutar el proyecto usando un comando. En Windows, el comando es Alt L, y si estás en Mac, el comando es Command L. Así que usando ese comando, voy a ejecutar Alt L. Y empieza nuestro juego. Tomó cualquier código que estuviera en esta carpeta de mi juego y lo ejecuta a través del amor. Lo mismo exacto es si
arrastramos y soltamos la carpeta. No obstante, esto es mucho más rápido y fácil. Así que asegúrate de mantener este comando en el fondo de tu mente cada vez que quieras ejecutar tu proyecto. En este punto, están todos preparados para comenzar a codificar su juego. Empezarás poniendo código en este archivo main.py. Y a medida que se
desarrolle, puede agregar más archivos a su carpeta de proyecto.
3. Movimiento de jugadores: Hola amigos. En este video, pasaré por cómo hacer un sencillo personaje de jugador enamorado de d, donde podrás moverlos por la pantalla con las teclas de flecha. Una vez que estés listo, tengo un proyecto totalmente nuevo listo para salir. Es solo una carpeta llamada mi juego y dentro de ella como un archivo llamado main.py. Esa es la base de cualquier proyecto de amor. Y podemos seguir adelante y ejecutar este archivo tal como está. Y veremos una pantalla negra la cual se espera ya que nuestro archivo main.py aún no tiene código en ella. El beneficio resultante que corre como sólo una ventana negra. El primero que debemos hacer con cualquier juego es poner en las tres funciones principales que
utilizamos para todos los proyectos de amor, que es función love dot load. Entonces función love dot update con DT en los paréntesis. Y luego función amó Dot draw. Y usando estas tres funciones, crearemos nuestro objeto de jugador y le
agregaremos algunos controles para que pueda moverse. Nota rápida antes de que empecemos, la función de carga ocurre justo cuando se inicia el juego. La función de actualización sucede cada fotograma. Por lo que actuará como nuestro bucle de juego. Y la función de dibujo es lo que muestra nuestros gráficos a la pantalla. No te preocupes si no estás completamente claro en todo esto. Una vez que tengamos algún código en su lugar, tendrá mucho más sentido. Para empezar, vamos a crear nuestra mesa de jugadores, que se llevará a cabo en carga de punto de amor. Haremos jugador igual, abriremos y cerraremos llaves. Ahora ten en cuenta que en Lua, tirantes
rizados tienden a referirse a las tablas. Entonces ya que estamos haciendo un corsé rizado abierto y cerrado justo aquí, eso significa que el jugador está siendo configurado para ser una mesa vacía. A continuación, le daremos algunas propiedades. Así que digamos jugador punto x es igual 0 y jugador punto y igual a 0. Estos actuarán como los valores de posición. El mundo del juego es como una gran cuadrícula donde el eje x va a izquierda
y derecha, y el eje y sube y baja. Nuestro jugador va a empezar en la posición 0, 0, o el origen de la pantalla. A continuación, usemos el objeto del jugador para dibujar algo a la ventana del juego. Todo el dibujo se lleva a cabo hacia abajo en la función de dibujo de punto de amor. Entonces aquí, sigamos adelante y
dibujemos un círculo que actuará como jugador por ahora. Diremos amados gráficos punto círculo. Y luego en los paréntesis tenemos cuatro parámetros diferentes que necesitamos proporcionar. En primer lugar está el modo. Tenemos dos opciones. Tenemos Phil o linea, así que rellena, así que nuestro círculo se llenará. Entonces necesitamos la exposición, que va a ser jugador dx. Entonces necesitamos la posición y, jugador punto y, y luego el radio del círculo. Puedes hacer esto lo que quieras. Haré los míos 100. Entonces, para recapitular, esta línea de aquí mismo va a dibujar un círculo en la posición 0, 0. El radio del círculo va a ser 100 y se va a llenar. Ahora si guardamos nuestro archivo y luego
corremos, veremos que tenemos un círculo de corte en la esquina superior izquierda. Ahora la razón por la que está cortada como porque el círculo está en la posición 0, 0, y 000 es la esquina superior izquierda de nuestra ventana de juego justo aquí. Cambiemos la posición de nuestro jugador a posición, digamos 400, 200. Entonces ahora nuestra posición x es 400 y nuestra posición y es 200. Si guardamos y corremos ahora, nuestro círculo está completamente en la ventana del juego y ahora lo podemos ver por completo. De manera más específica, el círculo se movió hacia la derecha, 400 píxeles sobre este punto justo aquí, y luego hacia abajo a 100 píxeles para que el centro del círculo esté en la posición cuatrocientos, doscientos. Y ten en cuenta que cuanto mayor sea tu valor y, más abajo de la pantalla vas. Entonces ya que dijimos 200 aquí, eso significa que bajamos a unos 100 píxeles. Ahora que tenemos un objeto de jugador que se está mostrando en pantalla, ahora
podemos trabajar para que se mueva. Esta lógica va a tener lugar en la función de actualización de love dot porque actualización
lambda ejecuta cada fotograma. Entonces para empezar, hagamos algo sencillo. Haremos jugador punto x igual jugador punto x más uno. Entonces, en otras palabras, cada jugador de fotogramas punto x va a aumentar en uno. Si salvamos y
corremos, veremos que nuestro círculo ahora se mueve lentamente hacia la derecha. Específicamente se está moviendo un píxel cada fotograma. esto me gusta llamar la ilusión del movimiento. Cada fotograma que está actualizando un poco, que hace que parezca que se está moviendo. De igual manera, si cambiáramos este uno a un tres, eso significa que ahora estamos cambiando la exposición por tres cada fotograma. Y si guardamos y corremos, sigue moviéndose hacia la derecha, pero ahora se mueve más rápido, específicamente, se mueve tres píxeles cada fotograma, así que eso es tres veces más rápido. Ahora nuestra tarea es hacer este mismo tipo de movimiento, pero hacer que corresponda a las teclas de flecha que presiona el jugador. Se puede leer la entrada del teclado muy fácilmente, y podemos hacerlo usando una sentencia if. Diremos que si amaba tablero de Schottky, punto está abajo. Y luego en los paréntesis aquí necesitamos especificar qué clave estamos revisando es hacia abajo. Y empezaremos con la derecha, o en otras palabras, con la tecla de flecha derecha. Entonces. Y vamos a sangrar esta línea y poner un final al final de la sentencia if. Entonces aquí te estamos preguntando, es la tecla de flecha derecha presionar hacia abajo. Y si es así, vamos a mover
al jugador a la derecha por tres píxeles. Y esto sucede cada fotograma. Por lo que está constantemente comprobando esto. Si guardamos y corremos ahora, el jugador no se mueve, pero en cuanto presiono la tecla de flecha derecha, se mueve. Y sólo va a hacer eso cuando
tenga esa tecla de flecha presionada hacia abajo. Ahora hagamos lo mismo, pero por una dirección diferente. Lo mantendremos fácil y empezaremos con la dirección izquierda. Por lo que esta vez en lugar de aumentar en tres, cada vez, disminuiremos en tres. Porque cuanto más pequeño sea el valor x del jugador, más a
la izquierda de la pantalla
estará si guardamos y corremos ahora,
si me mantengo a la derecha, se mueve a la derecha. Pero si me quedo a la izquierda, jugador ahora se mueve hacia la izquierda. Por lo que ahora tenemos trabajando las dos direcciones horizontales. A continuación, hagamos que el jugador sea capaz de moverse hacia abajo. Si volvemos a copiar esta sección y la pegamos aquí mismo, vamos a comprobar si está abajo la tecla de flecha abajo. Esta vez no queremos actualizar la
exposición de jugadores porque queremos movernos verticalmente. Moverse verticalmente significa que tenemos que actualizar la posición y de los jugadores. Por lo que el jugador punto y es igual al
jugador punto y y queremos movernos hacia abajo. Entonces eso significa que vamos a sumar tres. Si guardamos y corremos, si me mantengo pulsado, el jugador se mueve hacia abajo. Y finalmente tenemos una dirección más que hacer. Si copiamos esto, queremos revisar para arriba. Y si queremos avanzar hacia arriba, sólo
disminuimos en tres. Y con eso, deberíamos tener las cuatro direcciones izquierda, derecha, abajo, y arriba. Y en realidad es más que sólo las cuatro direcciones. Si sostengo las teclas de flecha a la vez, nos movemos en diagonal. Y esto se debe a que tanto las propiedades x como
las y podrían actualizarse al mismo tiempo, lo que da como resultado un movimiento diagonal. Antes de terminar el video, algo que podemos limpiar es que tenemos más 3 escritos en cuatro líneas diferentes. Esto es generalmente mala práctica porque si quisiera cambiar la velocidad de los jugadores o lo rápido que se mueve, tendría que cambiar estos tres en las cuatro líneas y eso se pone un poco molesto. Tendría más sentido si
creáramos una nueva propiedad para el jugador, digamos jugador velocidad de punto, y la pondremos igual a tres. Ahora puedo tomar esto y en lugar de escribir tres en todos estos lugares, puedo hacer player dot speed. Y ahora siempre que quiera actualizar la velocidad del jugador, solo
tengo que actualizar este valor aquí mismo. Digamos que quería aumentarlo a cinco. Ahora mi jugador se mueve a cinco píxeles por fotograma. Entonces si guardo y corro, ahora, nos estamos moviendo más rápido y es mucho más fácil de manejar. Y una última cosa que quiero mencionar es este d t o tiempo delta. Puedes usar este valor para que tu juego funcione
y se sienta igual independientemente de la velocidad de fotogramas. Sólo quería dar una cabeza arriba sobre eso. No es para nada urgente cuando apenas estás empezando. Estará construyendo sobre esto un poco más. En el siguiente video, mostraré cómo dibujar sprites reales en el juego, en lugar de simplemente un círculo llano como este.
4. Sprites y fondos: Hola amigos. En este video, te mostraré cómo agregar tus sprites o obras de arte reales, así
como fondos a tu juego enamorado. Para lucir esto, voy a estar construyendo sobre el código del video de movimiento del jugador. Básicamente tenemos esta mesa de jugadores. Y usando sus propiedades, bajamos a la función de empate y dibujamos un círculo en la posición del jugador. Y luego en nuestra función de actualización, tenemos estas declaraciones if que controlan al jugador con las teclas de flecha. Y al final, tenemos un círculo que podemos controlar alrededor y mover cuando presionamos las teclas de flecha. Ahora un círculo plano con fondo negro no es demasiado interesante. Entonces vamos a utilizar activos reales de arte o sprites. En cambio. Puedes utilizar cualquier imagen que quieras. Puedes dibujar algo tú mismo, o estaré usando esta simple imagen de padre
así como este punto de fondo hierba PNG. Si quieres usar las mismas imágenes que yo, puedes ir a la pestaña Proyectos y Recursos debajo de este video y encontrar los recursos a la derecha. Se puede descargar loro dot PNG y fondo que PNG a partir de ahí. Los demás recursos se utilizarán en lecciones posteriores. Cuando tengas tu expediente está listo. En realidad vamos a querer moverlos a nuestra carpeta de proyectos. Así que adelante y copia estos archivos. Y luego en tu carpeta de proyecto real el próximo año, main.py, vamos a crear una nueva carpeta. Voy a llamarlo sprites. Y dentro de esta carpeta vamos a pegar en esas dos imágenes, una para el fondo y otra para el jugador. Y una vez que tengas esto abajo, notarás que de vuelta en Visual Studio Code ahora tenemos una carpeta sprites. Y dentro tenemos fondo hasta PNG y parent dot PNG o los nombres que les diste. Ahora el siguiente paso es que necesitamos
incluir estas imágenes en nuestro código. Y empezaremos con el jugador sprite. Haremos esto fácil y organizado poniendo cualquier propiedad para la mesa de jugadores. Diremos jugador dot sprite igual love dot Gráficos, dot-dot-dot nueva imagen. Y entonces el perímetro aquí es el camino a donde tenemos almacenado este archivo y que
hemos almacenado en la carpeta sprites slash loro dot PNG. Y ese es nuestro sprite Player. Y ahora que tenemos esta imagen cargada en sprite de puntos de jugador, podemos usarla hacia abajo en la función de sorteo. Entonces en lugar de dibujar un círculo, nos desharemos de esto. Y en cambio diremos love dot Gráficos dot draw. Y el primer parámetro es lo que queremos soltar, que es player dot sprite. Siguiente es la posición punto x y el jugador punto y. y con esto en su lugar, si lo guardamos y lo
ejecutamos, veremos que nuestro jugador ahora está representado por nuestro sprite. En mi caso, es el loro. A continuación vamos a sacar los antecedentes dibujados en el mismo trato. Tenemos que cargar en esa imagen en una variable. Entonces vamos a poner en fondo iguales amados en los gráficos, esa nueva imagen. Y el camino es sprites slash fondo, PNG. Entonces ahora que lo tenemos almacenado en segundo plano, podemos usar esto una vez más abajo en la función de sorteo. Voy a poner en el amor dot Gráficos, dot draw. Fuimos a dibujar fondo y lo vamos a dibujar en la posición 0. 0. Ahora la posición que
proporcionamos para cualquiera de estas
llamadas a función de dibujo representa en realidad la esquina superior izquierda de la imagen que estamos dibujando. Entonces como nuestro fondo es un gran cuadrado o rectángulo, poniendo su posición a la derecha en 000, lo
alinearemos perfectamente con nuestra ventana de juego, ya que 00 es también la esquina superior izquierda de la ventana. Si guardamos y corremos, veremos que ahora nuestro fondo de pasto está en su lugar. Pero notarás que los jugadores desaparecieron repentinamente. Aquí está el problema. El jugador sigue ahí y sigue siendo dibujado, pero el fondo se está dibujando encima de él. Entonces simplemente ya no es visible para nosotros. Para dibujar sprites, el orden que los dibujas en materia. Entonces en nuestro caso, dibujamos el sprite jugador, pero luego hacemos el fondo después de él, lo que da como resultado que el fondo se coloque encima. Si quieres arreglar esto, solo
necesitamos cambiar este pedido. Si dibujamos primero el fondo, eso significa que se dibujará el fondo y luego se dibujará el sprite jugador encima de él. Por lo que al final, cuando ahorremos y corremos ahora, veremos a nuestro sprite Player dibujado sobre la parte superior de nuestro fondo de hierba. Y eso sobre cubre los fundamentos del dibujo sprites. A partir de aquí, me gustaría cambiar este spray para pájaros en más un humano con animaciones para caminar, lo cual es bastante fácil cuando
usamos algún software de código abierto. Hablaremos de esto en el próximo video.
5. Animaciones: Hola amigos. En este video, mostraré cómo agregar
animaciones a tu personaje jugador, donde se enfrentan y caminan en cualquier dirección en la que te estés moviendo. Estaré utilizando estos sprites los cuales fueron creados y proporcionados por ancho el amor al abrir juego art.org. Puedes descargar esta hoja de reproductor de archivos dot PNG de la pestaña de proyectos y recursos abajo. O eres libre de usar cualquier otra hoja de sprite que te gustaría usar. Echando un vistazo rápido a esta imagen, verás que hay cuatro filas, cada una representando una dirección diferente. Nuestro objetivo es utilizar cada fotograma individual desde una fila en particular con el fin de crear la animación. Cuando cada cuadro haya jugado en rápida sucesión, dará la ilusión de que el jugador está caminando. Una vez que tengas listo tu proyecto, sigue
adelante y crea una carpeta sprites junto a tu main.py si aún no tienes uno. Y por dentro, adelante y pega en esta hoja de reproductor punto PNG. Una vez que eso se hace de nuevo en Visual Studio Code, deberías ver que en tu
carpeta sprites tienes un reproductor que ella punteó PNG, que significa que todo está listo para salir. Simplemente necesitamos incluir ese archivo en nuestro código, que podemos hacer eso igual que cualquier otro sprite. Voy a hacer que sea una propiedad del objeto jugador, y lo llamaré jugador sprite hoja igual a amaron esos gráficos, esa nueva imagen. Y entonces necesitamos la ruta que es la carpeta sprites. Y el nombre del archivo es player dash sheet dot PNG. Ahora que esto es importado, querrá trabajar en convertir esto en una animación. Esto se logrará usando algún software de código abierto. En particular, estaremos usando este producto aquí llamado Animate. A pesar de que este repo tiene algunos años ahora, Todavía
es muy confiable y funciona muy bien para implementar animaciones enamoradas de D, Había algunas formas de
incluir este código en tu proyecto. Si tienes instalado Git, podrías ir a este menú desplegable de código, copiar este HTTPS, y luego hacer un clon git. O la otra forma de hacerlo es descargar el zip. Y una vez descargado este zip, puedes seguir adelante y extraerlo. Y luego aquí dentro encontraremos un punto animado lou un archivo. Vas a querer copiar esto. Y de vuelta en nuestra carpeta de proyectos, vamos a crear una carpeta nueva, llamaré bibliotecas. Y en esta carpeta vamos a pegar en ese punto animado Lua. Una vez que tengas eso, pegarlo y podrás verlo por aquí, querrás seguir adelante e importar esto a nuestro código. Voy a hacer esto justo en la parte superior de la carga de punto de amor. Y vamos a decir que animate equals requieren bibliotecas, que es esa carpeta que acabamos de crear. Y luego se anima el nombre del archivo. Ahora, todo eso animan ese pequeño código se almacena en esta variable global llamada animate. En este punto, podemos empezar a crear nuestras animaciones. El primer paso es crear una cuadrícula que ayude a la biblioteca a dividir tu hoja de cálculo en sus imágenes individuales. Puedes consultar la página de animates GitHub para obtener más detalles sobre todas estas cosas. Entonces, empecemos por crear una cuadrícula para el objeto jugador. Voy a llamarlo player dot grid igual animate dot new grid. Y en estos paréntesis aquí, hay varios parámetros que necesitamos definir versus el ancho y la altura de cada marco individual. Y en nuestro caso, cada fotograma tiene 12 píxeles de ancho y 18 píxeles de alto. Si miras de cerca la hoja de cálculo que estamos usando, verás que cada marco individual tiene un poco de espacio a su alrededor. Pero cuando incluimos esa brecha, cada imagen es de 12 por 18. Entonces después de redefinir esa dimensión, necesitamos dar el ancho y altura de la hoja de cálculo completa, que podemos conseguir muy fácilmente. Diremos Player dot hoja de cálculo. Y entonces podemos decir colon, conseguir ancho. Por lo que esta línea aquí va a conseguir el ancho de nuestra lámina sprite. Y de igual manera, queremos obtener la altura para el siguiente parámetro, puntos de
jugador, hoja sprite, llamar y obtener altura. Entonces eso es todo lo que necesitamos para definir nuestra grilla. Tenemos el ancho y alto de nuestros marcos individuales y el ancho y alto de la hoja sprite completa. Y al final, eso nos da nuestra grilla. Ahora usando esta cuadrícula, nuestro código sabrá dividir nuestra hoja de cálculo en las imágenes individuales. Y con eso, podemos crear nuestras animaciones. Entonces vamos a almacenar todas estas animaciones en una nueva mesa. En realidad, lo voy a llamar player dot animations es igual a nueva mesa vacía. Y empecemos con esta animación simple. Haremos animaciones de punto de jugador punto abajo. Esta será la primera animación. Después implementaremos la dirección descendente. Y para crear una animación, sí
animamos dot nueva animación. Y en estos paréntesis necesitamos definir qué marcos de esa hoja sprite queremos incluir. Y eso lo hacemos usando la grilla. Entonces diremos jugador esa grilla. Y luego en estos paréntesis, necesitamos definir qué filas y columnas queremos incluir. El primer parámetro aquí son las columnas que queremos incluir, que son las columnas de una a cuatro. Porque tenemos cuatro cuadros yendo de izquierda a derecha. Entonces decimos de uno a cuatro entre comillas simples al igual que esto. Entonces vamos a poner una coma. Y luego después de esto, queremos definir de qué fila queremos que venga esto, que en nuestro caso, la dirección descendente viene de la fila uno. Entonces solo pondremos uno aquí. Y luego después de definir información de
nuestra cuadrícula de jugador, ponemos coma. El siguiente parámetro es el tiempo en segundos entre cada fotograma. Entonces de nuevo, nuestros marcos van a estar jugando uno tras otro en rápida sucesión, pero necesitábamos encontrar lo rápido que queremos que se vayan. Voy a decir algo así como 0.2 y puedes ajustar esto más pequeño o más grande. Esto significa que el fotograma va a cambiar dos segundos para nuestra animación, lo cual es bastante rápido, pero verás que se ve realmente natural cuando reproducimos la animación. Entonces esto es todo lo que necesitamos para definir nuestra animación y se está almacenando en este reproductor las animaciones de punto abajo. Entonces en realidad voy a copiar esto y ahora necesitamos
actualizar esta animación y dibujar la animación. Entonces en actualización después de todo este código, voy a poner en juego esa animación es punto abajo actualización de colon. Y esta actualización requiere que pasemos en DT. Y otra vez, d t viene de aquí mismo. Enamorados de actualizar, simplemente estamos pasando este perímetro hacia abajo a nuestra actualización de animación. Y luego después de que eso se actualice, podemos bajar aquí y me
voy a deshacer de nuestro sorteo de círculo. O también puedes deshacerte de cualquier otro dibujo que estés haciendo además del fondo. Y voy a hacer animaciones de punto jugador, punto abajo cuadro de colon. Y el primer parámetro aquí es la hoja de cálculo que utilizamos para dibujar esta animación, que es la hoja de sprite de punto del jugador. Entonces después de esta es la posición que queremos dibujar esta animación, que es player dot x y player dot y. y eso debería hacerlo. Deberíamos ver la animación sonando. Entonces vamos a guardar este archivo y empezar. Y un problema, pero te
darás cuenta de inmediato es que esta animación es demasiado pequeña ya que fui con algunos gráficos retro, este sprite en realidad solo es de 12 píxeles por 800 píxeles, lo cual es muy pequeño, pero somos capaces de escalarlo un poco. Entonces sigamos adelante y en esta animación se dibuja. Hay algunos parámetros adicionales muy similares al regular amado nuestros gráficos para dibujar función. El siguiente parámetro aquí es el campo de rotación opcional. No queremos rotar la imagen. Entonces hagamos nada, es
decir, no cambies la rotación. Y luego después de cero como nuestro factor de escala X. Para que podamos poner algo así como 10. Y eso significa que la escala de nuestra animación se va a aumentar en diez veces. Y poner un valor para escala x significa que escala y también
adoptará ese valor ya que no especificamos nada para ello. Entonces con esto, deberíamos esperar que nuestro sprite sea 10 veces más grande, o debería decir nuestra animación. Entonces sigamos adelante y empecemos. Y ahí está. Es mucho más grande, pero un problema notable es que está borroso. Podemos evitar que nuestro escalado difumine las imágenes si subimos a la parte superior. Y lo haremos justo después de nuestra importación animada. Haremos amor die graphics dot set default filter. Y los valores aquí son más cercanos, más cercanos. Entonces con esta línea en su lugar, hará para que cuando escalemos nuestros gráficos, no haga ningún desenfoque. Simplemente toma los píxeles y los escala hacia arriba. Y ahora cuando empiezo, vemos trabajar nuestra animación y se ve bastante bien. Y como está atado a los valores de punto x e y del jugador, podemos movernos con normalidad, pero ahora nuestra siguiente tarea es conseguir las otras direcciones funcionen que tenemos abajo, pero ninguna de las otras. Entonces sigamos adelante y pongamos esos implementados. Las haremos de una manera muy similar a la que hicimos abajo. En realidad voy a copiar toda esta línea aquí mismo. Y vamos a hacer el siguiente. Diremos izquierda. Ahora la dirección izquierda está en la segunda fila. Voy a cambiar este a la fila dos. A continuación tenemos ahora mismo, derecha está en la fila tres. Y luego finalmente, tenemos arriba y arriba está en la fila cuatro. Ahora todas estas animaciones son muy similares. Simplemente se llevan a cabo en diferentes filas. Ahora viene el reto de cambiar entre las animaciones. Porque en este momento nuestra animación se está dibujando y actualizando manualmente escogiendo las animaciones de punto del jugador punto abajo tanto para aquí como para aquí. Cuando en realidad,
no sabemos qué buscar animaciones queremos usar. Podemos hacer un seguimiento de esto con una propiedad nueva. Yo lo voy a llamar player.com. Y lo pondremos igual a alguna animación, digamos jugador puntos animaciones punto a la izquierda. Entonces ahora nuestro jugador, esa propiedad contiene jugador a animaciones que se fueron. Por lo que podemos usar esto para rastrear la animación de nuestros jugadores. Por lo que en lugar de actualizarse manualmente, las animaciones se apagaron. Estamos en cambio, de acuerdo con la actualización player dot enum. Y lo mismo con nuestro sorteo. Simplemente vamos a hacer el empate de punto de jugador A&M. De esta manera, cualquiera que sea la animación que
hayamos asignado a este valor, esa es la que vamos a ver. Por lo que ahora mismo tenemos jugador a animaciones que dejaron asignadas a ella. Entonces si guardamos y
corremos, vemos que la
dirección hacia la izquierda ahora es la animación que vemos aquí. En este punto, sólo queremos cambiar la
animación de los jugadores para que coincida con cualquier dirección que se estén moviendo. Esto se puede hacer agregando a nuestros controles de movimiento y la función de actualización. Por ejemplo, aquí
estamos manteniendo presionada la tecla de flecha derecha. Eso significa que probablemente queremos cambiar la animación para ser player dot, animaciones dot, ¿verdad? Por lo que justo aquí. Yo puedo seguir adelante y hacer eso. Diré jugador punto nm igual las animaciones de
jugador punto, ¿verdad? Y de igual manera, podemos hacer exactamente lo mismo en las cuatro direcciones. Entonces esta queda, esta siguiente está abajo. Y finalmente esta última está arriba. Entonces con eso en su lugar, si guardo y corro, cada vez que cambié de dirección, la animación de los jugadores se actualiza para que coincida con esa dirección. Funciona bastante bien. El único problema que queda aquí es que el jugador sigue caminando en su lugar incluso después de que se detienen. E idealmente son animación también se detendrían y cambiarían a una posición quieta de pie. Esencialmente, queremos cambiar la imagen del jugador a este fotograma, el de pie, cuando no se presionan teclas de flecha hacia abajo. Notarás que estos marco de pie es la segunda imagen y cada una de estas filas. Por lo que cuando no se presionen teclas de flecha, obligará a la animación a pegarse con este segundo fotograma. Esto volverá a suceder en nuestra sección de actualización, vamos a necesitar revisar para ver si no se presionaron teclas de flecha ese marco. Por lo que haremos un seguimiento de esto con una variable local muy simple. Al inicio del marco se creará un local se está moviendo. Y pondremos esto en falso. Entonces queremos cambiar esto se está moviendo a la verdad. Si alguna de las teclas de flecha se presionó hacia abajo este marco. Y podemos hacer esto de nuevo, justo en esto es abajo declaración IF, simplemente
podemos decir que se mueve igual a verdadero. Porque si se presiona la tecla de flecha derecha hacia abajo, eso significa que nos estamos moviendo. Por lo que necesitamos cambiar este valor. Y sólo voy a copiar esta línea y ponerla dentro de las cuatro declaraciones si para cada una de las cuatro direcciones. Por lo que al final de nuestro método de actualización, sabremos que se
está moviendo va a ser ya sea falso si presionaron las teclas de flecha
nope o verdadero si alguna de ellas se presionó hacia fuera. Y si ninguno de ellos se presiona hacia abajo, y vamos a ver. Si está moviendo es igual a falso. Entonces en este punto de esta afirmación if, queremos cambiar la animación de los jugadores para
que sea ese segundo fotograma donde simplemente están parados. Y esto se hace con player.com. Y hay un colon ir a la función de marco. Y el marco al que queremos ir es el marco número dos, eso es parado marco. Si ahorramos y corremos ahora, el jugador se queda quieto. En cuanto me muevo, empieza a caminar nuevo en las cuatro direcciones. Y cuando me detengo, cambian de nuevo a un quieto parado. Y esto funciona para las cuatro direcciones.
6. Diseño de nivel y tejo: Hola amigos. En este video estaré mostrando los fundamentos de usar teselas, un fantástico editor de nivel que es un must have para frameworks de juegos como love 2D, que no tiene ningún tipo de editor incorporado, pasará por el proceso de agregar un hoja de estilo, diseñando un mapa, y una importando nuestro nivel a un juego 2D de amor. En primer lugar, querrás tener un conjunto de teselas para usar para esto. Esta es solo una imagen grande con un montón de piezas
individuales que
estaremos utilizando para diseñar nuestro nivel. Puedes descargar este conjunto de teselas dot PNG desde la pestaña de proyectos y recursos abajo. Una vez que lo tengas listo, me gusta mantener mis cosas organizadas. Entonces en mi carpeta de proyecto de juego, voy a crear una carpeta nueva y la voy a llamar mapas. Y luego justo en esta carpeta de mapas, voy a pegar en esa imagen PNG de punto de conjunto de teselas. A continuación necesitarás descargar mosaico. Tenga en cuenta que este es un nombre su propia herramienta de precio. Entonces aunque puedes descargarlo
gratis si lo encuentras útil, te recomiendo pagar alguna cantidad de dinero para apoyar al desarrollador. Una vez que hayas instalado mosaico, adelante y ponlo en marcha. Y podemos crear un nuevo mapa subiendo a Archivo nuevo, nuevo mapa. Y en esta ventana, lo siento, es un poco más pequeño. Este texto no escala bien aquí, pero las partes superiores aquí arriba pueden permanecer todos en sus valores predeterminados que es CSV
ortogonal y anotar. A continuación se presenta el tamaño del mapa. Podemos elegir cuántos azulejos anchos y altos será nuestro mapa. Creo que este defecto, 30 por 30 está bien aquí. Y luego, por último, necesitamos especificar nuestro tamaño de azulejo, que es el tamaño de cada azulejo individual. Esto depende del conjunto de teselas que estés usando. Pero con el mío, cada azulejo tiene 64 píxeles de ancho y 64 píxeles de alto. Y luego haremos clic en Guardar Como vas
a querer navegar a tu carpeta de proyecto de juego. Y voy a guardar esto en la carpeta de mapas. Y Alice simplemente llama a este mapa de prueba y haz clic en Guardar. Una vez que eso esté guardado, debería aparecer el editor de mosaico, que es donde estaremos diseñando nuestro nivel. En primer lugar, necesitamos importar nuestro conjunto de teselas sin embargo. Esto sucede abajo en esta esquina inferior derecha con este nuevo botón de conjunto de teselas. En primer lugar, tenemos que
volver a darle un nombre , lo siento, esto es pequeño. Voy a nombrar a estos mosaicos de prueba y luego me aseguraré de que tiene incrustar en el mapa activado. Entonces necesitamos un toot, nuestra fuente, que si
navegamos, vamos a navegar de nuevo a nuestra carpeta de mapas y encontrar nuestros mosaicos, esa imagen. Entonces otra vez especificar nuestro ancho y alto de loseta, que en nuestro caso es de 64 por 64, y luego margen y espaciado. Se pueden ajustar estos valores si hay huecos entre o alrededor de los mosaicos. Pero en mi caso, todos los azulejos están justo
al lado del otro sin huecos en el medio. Por lo que el espaciado va a ser 0 y
no hay margen alrededor del borde del conjunto de teselas. Por lo que el margen va a ser 0 también. ¿ Y cuál es el otro configurado? Adelante y clica, Ok. Y en la parte inferior derecha deberías ver pop up tu conjunto de azulejos. Ahora en este punto puedes hacer clic en cualquiera de estos mosaicos individuales y utilizarlos para dibujar en partes de tu mapa. Y puedes usar esto para diseñar tu nivel. En realidad voy a empezar por poner una línea de base de esta imagen de pasto. Y voy a usar esta herramienta de relleno de pintura para poner hierba por todas partes. Entonces desde aquí puedo elegir fichas individuales y usar la herramienta de sellos para dibujar como mis caminos individuales para el resto del nivel. Algo que podrías notar al diseñar es que si tratabas de hacer, digamos, uno de estos árboles y lo pones justo aquí, como
que elimina el pasto debajo de él. Entonces y esto se debe a que las porciones circundantes del azulejo son transparentes. Por lo que reemplaza el pasto
a su alrededor con esa misma transparencia. Podemos evitar esto haciendo una nueva capa. Ahora mismo estamos trabajando fuera de esta capa de azulejo 1. Bueno, podemos crear una nueva capa de azulejo y la llamaré árboles. Ahora si vuelvo a esta cola aire uno y sustituyo este azulejo por crass. En cuanto regrese a los árboles azulejo aire. Ahora en cualquier momento que ponga se pondrá en esta nueva capa. Entonces las cosas en azulejo, no van a ser reemplazados a
todos. Por lo que esto soluciona ese problema. Y mientras estamos en ello, bien podría reemplazar este nombre por algo así como tierra. Y luego a partir de aquí es solo cuestión de diseñar tu nivel. Así que adelante y sigue y diseña tu nivel como quieras. Yo mantengo esto muy sencillo por ahora, pero siempre que termines con tu mapa, puedes seguir adelante y guardar el proyecto y luego ir a File Export Como ahora vamos a exportar nuestro proyecto. Entonces navega a tu carpeta de proyecto de juego. Y de nuevo, voy a poner esta aversión a la exportación en nuestra carpeta de mapas. Y verás al fondo que lo estamos guardando como archivo Lua. Voy a llamarlo mapa de prueba. Entonces esto es muy conveniente ya que el amor hoy usa Lua que hace que el proceso de convertirlo sobre sea bastante simple. Así que adelante y ahorra. Y nuestro mapa es ahora exportarlo como un archivo Lua. Ahora para meter este mapa en nuestro proyecto de amor necesitará utilizar algún software de código abierto. Puedes usar esta URL para llegar a la página de GitHub para la implementación sencilla en mosaico de la biblioteca. Esta biblioteca leerá ese mapa explotado y ayudará a retirar todas esas fichas en el juego. Entonces para obtener este código, puedes o clonar este repo si sabes hacer eso, o si no sabes cómo hacerlo, puedes ir al código y solo descargaremos el archivo zip. Entonces una vez que se descargue, vas a querer extraer el archivo zip y luego navegar a estas carpetas. Y lo que realmente queremos es esta carpeta de STI. Sti es sinónimo de implementación sencilla en mosaico. Por supuesto. Ahora voy a copiar esta carpeta y luego volver a nuestra carpeta de proyecto de juego. A mí me gusta guardar todo mi código fuente abierto en la carpeta de una biblioteca, pero puedes organizarlo como quieras. Yo sólo voy a pegar en esa carpeta de STI. Y una vez que tengas preparada esa carpeta STI, podemos incluirla en nuestro código con love dot load. Pero en la cima del amor esa carga voy a poner en STI igual requieren. Y luego en estas comillas simples, voy a poner la ruta a esa carpeta, que era bibliotecas slash STI. Y que importan todo
el código STI a esta variable STI. Y luego después de esto, podemos crear nuestro mapa o cargarlo en el juego almacenándolo en una variable. Lo llamaré mapa de juegos igual a ITS, paréntesis. Y en estos paréntesis necesitamos proporcionar la ruta comillas
simples a nuestro archivo de mapa exportado, que eso estaba en la carpeta Mapas, prueba de
barra inclinada IMAP dot Lua. Desde que nuestro mapa fue exportado como un archivo Lua. Y ahora que este mapa está cargado en el mapa del juego, todo lo que queda por hacer es dibujarlo. Entonces aquí abajo y función de dibujo, vamos a deshacernos de cualquier otro fondo que estemos dibujando. Y en cambio voy a hacer mapa de juego, colon, empate. Y eso es todo. Una nota muy pequeña es que
si estás usando el proyecto de muestra, voy a cambiar esta escala
del jugador a seis frente a 10, solo para que coincida con los azulejos un poco mejor. Pero cuando estés listo, sigue adelante y guarda el proyecto y corre. Y funcionó. Tenemos nuestras fichas en su lugar y
podemos jugar el juego de forma normal. Eso cubre los conceptos básicos de usar mosaicos e importar mapas a tus proyectos 2D de amor. Sin embargo, un problema notable es que estamos atrapados en esta esquina superior izquierda de nuestro nivel de juego. Entonces no hay manera de que realmente podamos ver el resto de la misma. En el siguiente video, añadiremos una cámara que sigue al jugador alrededor que nos permitirá explorar todo el espacio.
7. Cámara: Hola amigos. En este video, te mostraré cómo agregar una cámara a tus juegos 2D de amor que siga al jugador alrededor y puedas explorar más de tus niveles. Todo lo que necesitas para empezar como a algún proyecto donde tienes algo que
quieres que siga la cámara. En mi caso, tengo este objeto jugador y jugador dot x y player dot y representa la posición del jugador. Si ejecuto el juego tal como está, así es como se ve actualmente. Pero claro que no hay cámara, así que realmente no puedo explorar todo el espacio. Lo mismo con muchas tareas. Podemos añadir una cámara muy fácilmente mediante la utilización de algún software de código abierto. Acude a esta URL para llegar a la página de GitHub para joroba, que significa ayuda o utilidades para progresión masiva. Hump es una colección de varias herramientas diferentes, entre ellas este archivo camera.capture. Adelante y clone este repo. O si no estás seguro de cómo hacerlo, puedes seguir adelante y subir al código y luego descargar esto como un Zip. Entonces solo querrás extraer este archivo zip. Y luego dentro de la carpeta
sólo encontraremos este archivo camera.capture. Adelante y copia eso. Y luego de vuelta en nuestra carpeta de proyecto de juego, dentro de la carpeta de la biblioteca, voy a seguir adelante y pegar en esta cámara dot lou un archivo. Si actualmente no tienes la carpeta de una biblioteca, puedes seguir adelante y crear una justo al lado tu punto principal Lua y llamarla bibliotecas. Una vez que eso se añada,
vuelve a tu código y vamos a conseguir este código de cámara se importe hasta en carga de punto de amor. Simplemente voy a hacer la cámara igual requieren. Y dentro de las comillas simples, haré el camino al archivo camera.capture, que es librerías slash camera. Por lo que ahora el archivo camera.capture se carga en esta variable de cámara, y podemos usar esto para crear un objeto de cámara real. Llamaré a esta cámara igual a cámara. Por lo que llamar a esto como una función esencialmente genera un objeto de cámara y se está almacenando dentro de CAM. Por lo que siempre que queramos trabajar con la cámara, estaremos llamando a esta variable de leva. Ahora que esto ha creado, podemos cambiar nuestras secciones de dibujo para que todo se vea a través de la lente de esta cámara. Hacemos esto por, al inicio de la sección de mandíbula. Haremos cam colon adjuntar, y luego sangraremos todo lo demás. Y luego después de que todo se dibuje, hará leva colon desprendimiento. esta manera, puede adjuntar marcas el punto donde empezamos a dibujar las cosas desde la perspectiva de la cámara. Y el desacoplamiento CAM es el punto donde dejamos de mirar a través de la cámara. Entonces en este caso, todo se está
dibujando desde la perspectiva de la cámara. Ahora si estás dibujando un mapa en mosaico usando implementación de teselas
simple como lo estoy haciendo aquí mismo. En realidad ya no podemos usar este mapa de juegos notación drauf colon. Esto lamentablemente entra un poco en conflicto con una cámara. Entonces, lo que necesitamos hacer es dibujar cada capa de nuestro mapa de teselas individualmente. Si echan un vistazo rápido a mi mapa de mosaico, tengo dos capas. Tengo tierra y tengo árboles. Por lo que necesitamos dibujar cada una de estas capas individualmente. Y puedo hacer eso deshaciéndome de
este mapa de juego mandíbula de colon. Y en cambio voy a hacer mapa de juego colon capa de dibujo. Y dentro de los paréntesis necesitamos especificar la capa que queremos dibujar
dibujará primero la capa de suelo. Entonces lo conseguimos con un mapa de juego, capas de puntos. Y luego entre corchetes necesitamos
especificar el nombre de cadena de nuestra capa, que es molida. Y mismo trato, voy a copiar esto y
vamos a hacer lo mismo, pero por los árboles. Por lo que en este punto tenemos todas
nuestras capas de mapa de juego siendo dibujadas, así
como el jugador que está siendo dibujado dentro de la perspectiva de la cámara. Si fuéramos a ahorrar y correr ahora, el juego probablemente no se verá diferente. Y eso se debe a que nuestra cámara está inmóvil en este momento. Tenemos que cambiarlo para que siempre siga. El jugador lo hará de nuevo en nuestro código en las secciones de actualización. Por lo que en amada actualización, probablemente en la parte inferior de la actualización de punto de amor. Después de todo esto, sólo voy a poner en el colon CAM. Mira, lo pondremos en posición jugador punto x y jugador punto y Así que cada fotograma va a mover la posición de las cámaras para igualar donde se encuentre el jugador. Si ahorramos y corremos ahora, está funcionando. Ahora la cámara está siguiendo al jugador. Puede notar un poco de un tema compensado sin embargo. El jugador está un poco fuera de centro, está un poco abajo y a la derecha demasiado. Y esto se debe a que
actualmente la cámara está siguiendo el player dot x y player dot y, que por el momento está representando la esquina superior izquierda de la imagen de nuestros jugadores. Por defecto, todas las animaciones y todos los sprites dibujarán en su punto superior izquierdo. Y en este caso, en realidad
preferiríamos estar dibujando desde el centro de la imagen para que nuestra cámara esté centrada con todo. Entonces de vuelta en nuestro código, bajaremos a donde dibujamos al jugador que está aquí mismo. Estamos dibujando nuestra animación. Y necesitamos actualizar esas variables offset. Entonces aquí tenemos nuestra rotación, después tenemos nuestra escala x. Y luego después de la escala x es la escala y, que pondrá como cero. Pero después de la escala y es 0 x y 0 y, que es lo que queremos especificar. Para OX, queremos la mitad del ancho del sprite, que es de 6, ya que el ancho es de 12. Entonces para el offset, por qué queremos la mitad de la altura, la altura es de 18, por lo que pondremos en nueve. Entonces con eso en su lugar, si guardamos y
corremos ahora, veremos que nuestra cámara ahora está centrada y el jugador está directamente en el centro de nuestra toma de cámara. Lo último que puedes abordar, y esto es completamente opcional, pero puedes evitar que la cámara muestre este fondo negro
fuera de pantalla que va más allá de donde está nuestro mapa, todo lo que tenemos que hacer es detener el cámara de moverse cuando llega demasiado lejos y cerca de la frontera. Empecemos dirigiéndonos primero a la frontera izquierda. Entonces en nuestra función de actualización, justo después de hacer nuestra mirada de leva, vamos a hacer una declaración if donde
comprobamos el ancho y la altura de la pantalla. Entonces primero obtengamos el ancho de la pantalla y la
almacenaremos en una variable W local. Y obtenemos el ancho haciendo amados
gráficos muertos y papá consigue ancho, y esto obtendrá el ancho de nuestra ventana de juego. Entonces vamos a hacer local h igual amados Ag gráficos punto GetHeight. Y esto conseguirá la altura de nuestra ventana de juego. Ahora cuando tenemos que hacer es comprobar la posición de la cámara y compararla con este ancho. Entonces vamos a hacer una declaración if. Diremos si cam dot x o la posición x de nuestra cámara es menos de la mitad del ancho, lo que significa que estamos justo en la frontera, pero no queremos ir más lejos. Entonces. Simplemente queremos cambiar cam dot EXE a la mitad del ancho. La mitad del ancho pone a la cámara lo suficientemente lejos del borde de nuestra pantalla para
que no muestre ese fondo negro. Y si ahorramos y corremos ahora, si voy demasiado lejos a la izquierda, veremos que las cámaras se detengan cuanto lleguemos a esa frontera. No está mostrando ese fondo negro en
ninguna parte del lado izquierdo de la pantalla. Hagamos lo mismo para la frontera superior. Hacemos esto de una manera muy similar. Yo sólo voy a copiar esto. Y en lugar de revisar Campbell x, vamos a estar revisando kim dot y en
estos dos spots y también revisando h Estamos revisando la altura de nuestra ventana de juego esta vez. Si ahorramos y
corremos ahora, veremos que ya no podemos pasar por esta frontera superior. No muestra el contorno negro. Entonces para la derecha y la parte inferior bordea un poco más complicada porque necesitamos obtener el ancho y la altura de nuestro fondo. Entonces aquí después de todo esto, voy a conseguir una, otra variable local. Voy a llamarlo mapa local W, como en el ancho en píxeles de nuestro mapa de juegos. Esto se hace con el mapa de juegos de puntos ancho tiempos nmap dot tile width. Y lo que esto representa es el número de fichas de ancho. Nuestro K-map es, esto representa cuántos píxeles de ancho tiene un mosaico en nuestro K-map. Como mencionaste, que esta parte sólo es posible si estás usando un mapa en mosaico. Si estás usando un fondo regular, entonces esto solo serían los fondos sin ninguno de este cálculo aquí mismo. Haremos lo mismo para la altura del mapa. Mapa h igual mapa de juego punto altura tiempos mapa de juego, papá, altura de marea. Por lo que ahora tenemos el ancho y la altura de nuestro mapa en píxeles. Y seguiré adelante y te mostraré el código final. Si hemos mapeado la altura del mapa wn, utilizamos esto para calcular dónde cam y cam, ¿por qué deben ir siempre que lleguen a los bordes derecho e inferior? Para el borde derecho, lo ponemos igual al ancho de nuestro mapa, que es esta variable aquí mismo, menos la mitad de nuestro ancho de ventanas de juego. Y eso nos pone justo en la frontera donde no muestra nada fuera de pantalla. Misma idea con la leva. Por qué obtenemos la altura de nuestro mapa. Entonces todo el camino al fondo,
restamos la mitad de la altura de nuestra ventana de juego, lo que pone a la cámara justo en la frontera donde no muestra nada de ese fondo negro. Si salvamos y corremos ahora, si caminé hacia abajo a la derecha, se detiene en la frontera derecha, y también se detiene en la frontera inferior. Por lo que ahora en este punto, nuestra cámara no puede salir de pantalla en absoluto. Una última cosa que quiero demostrar para la cámara es si querías tener un HUD o algo que simplemente aparece frente a la cámara. Esto se hace dibujando algo fuera de la lata desprenderse. Entonces, por ejemplo, vamos a probar esto con un love die graphics dot print. Y voy a imprimir hola. Y esto se imprimirá en la posición 10. 10. A pesar de que es muy pequeño, se
puede ver ese pequeño hola. Y la esquina superior izquierda, y se queda ahí sin importar a dónde
vaya la cámara porque se está
dibujando fuera de la perspectiva de las cámaras, actúa como un HUD. En la siguiente lección, discutiremos los fundamentos de la física, que es algo con lo que necesitamos estar familiarizados antes poder implementar colisiones reales en este juego.
8. Física: Hola amigos. En este video voy a cubrir los conceptos básicos de
usar la física dentro del amor 2D y cómo
podemos crear rápidamente colisionadores que interactúan entre
sí y opcionalmente responden a la gravedad. No necesitas nada para empezar con este cualquier proyecto 2D de amor, haremos incluso
uno nuevo si estás siguiendo junto con las lecciones anteriores, este video te brinda alguna información extra que necesitamos para cubrir antes de continuar con eso. Ahora para la física, hay un módulo para esto construido directamente en el amor, y es muy poderoso. Desafortunadamente, eso significa que también es complicado. Pero hay bibliotecas de código abierto por ahí que hacen mucho más fácil trabajar con la física. El más popular es el campo de viento. Cuando el campo proporciona un montón de herramientas
realmente fáciles de usar para que podamos usar que hacen que empezar sea mucho rápido y tu código será más fácil de escribir. Yo personalmente uso biblioteca para todos mis juegos, a
pesar de que se ha archivado recientemente, sigue siendo totalmente confiable con las últimas versiones del amor. Y realmente hace una gran diferencia. Para que este código se incluya en tu proyecto, puedes clonar el repo si sabes hacerlo, o puedes seguir adelante y ir al código y descargar el zip. Entonces solo querrás extraer la carpeta. Y luego dentro queremos encontrar esta carpeta de campo de viento que está justo al lado del Read Me. Así que adelante y copia esto y luego navega a tu carpeta de proyecto de juego. En mi caso, estoy usando una marca de
proyectos nuevos para esta demostración. Es solo un archivo main.py. Voy a crear una carpeta nueva. Voy a llamarlo bibliotecas. Ya que siempre pongo mi código
abierto en la carpeta de una biblioteca. Entraré aquí y luego pegaré en esa carpeta de campo de viento. Ahora adelante y abre tu punto principal Lua. Y para esta demostración
empiezo con un archivo vacío. Entonces para empezar, siempre pongo en la actualización de carga y dibujar funciones como lo hice aquí. Y lo primero que haremos es importar esa carpeta de campo de viento que acabamos de copiar en nuestras bibliotecas. Por lo que vamos a hacer eso con WWF igual requieren. Y luego entre estas comillas, haremos el camino a esa carpeta que era bibliotecas slash wind field. Ten en cuenta que estamos importando toda
una carpeta de campo de viento y se
va a poner en esta variable WWF. Y eso es importado, podemos usarlo para empezar a trabajar con la física. El primer paso para trabajar con la
física de amores es crear un mundo. Alguien iba a decir Mundo es igual a WWF dot new world. Un mundo es simplemente un espacio donde
existen objetos de física y usamos el mundo para realmente crear nuestros objetos. Al igual que por caso, vamos a crear un objeto de jugador. Jugador es igual a colon mundial. Y lo haremos un rectángulo. Diremos nuevo colisionador de rectángulo. Entonces estos paréntesis excepto unos pocos parámetros. El primero es la posición que queremos que empiece nuestro jugador. Entonces los pondré en la posición 354 x, y luego 100 para Y. Entonces queremos el ancho y la altura de nuestro rectángulo. Lo haré con AT y altura 80. Entonces ahora nuestro jugador es un colisionador de rectángulo y está siendo almacenado en esta variable de jugador. Y cuando digo colisionador, me refiero a un objeto de física que existe en nuestro mundo. Parte de lo que cuando hace campo es que hace que los colisionadores sean tan fáciles de trabajar. Normalmente con la biblioteca de física amada estándar, necesitas definir un cuerpo de accesorios y una forma para luego realizar un seguimiento de todo por separado. Un colisionador de campo de viento sin embargo, es una combinación de los tres en un solo lugar, haciéndolo mucho más simple. Antes de guardar y ejecutar el juego, debemos agregar dos cosas rápidas. En primer lugar, queremos agregar actualización mundial de colon. Por lo que esto asegura que el mundo esté actualizado y toda la física se actualice. Entonces en empate, voy a poner en sorteo mundial de colon. Ahora lo que hace el dibujo de colon mundial es que dibuja las formas de todos los colisionadores en nuestro mundo. Entonces voy a seguir adelante y ahorrar y correr. Y ahí está, este objeto rectángulo aquí
mismo es nuestro colisionador de jugadores. Aunque no está haciendo nada. Algo que podríamos hacer es darle algo de gravedad a este mundo. Esta nueva función mundial aquí mismo
acepta en realidad algunos parámetros opcionales, los dos primeros de los cuales es la definición de gravedad. Entonces si hago 0, Probemos 100. Esto sería la gravedad yendo a la baja. Este es el valor x para lo que es nuestra gravedad, y este es el valor y. Entonces como sólo tenemos un valor positivo para y, positivo significa ir a la baja. Por lo que todos nuestros objetos físicos
se ven afectados por una gravedad a la baja. Entonces si ahorramos ahora y
corremos, veremos que nuestro colisionador de jugadores ahora
está cayendo hacia abajo. Aunque caía bastante despacio. Entonces lo que podríamos hacer es chocar este 100 hasta 500. Esto hace que la gravedad sea más intensa. Por lo tanto, nuestro jugador cae a un ritmo más rápido. Sin embargo, no todos los objetos necesitan verse afectados por la gravedad. Demostremos esto creando una plataforma para que nuestro jugador aterrice. Lo llamaremos tierra, y haremos colon mundial, nuevo desorden de rectángulo. Y su posición. Lo pondré en cien. Cuatrocientos es su posición. Y entonces el ancho será 600 y la altura será de 100. Entonces si fuéramos a salvar y correr ahora, vemos nuestro terreno, pero también sigue con la gravedad. Para hacer que el suelo sea menos propenso a la gravedad o ignorar por completo la gravedad, necesitamos cambiar su tipo. Podemos hacer colon tierra tipo set a estático. Entonces si salvamos y corremos ahora, nuestro terreno es estático, lo que
significa que no se ve afectado por gravedad y el jugador aterriza sobre él. Y justo ahora mencioné que hay fuerzas que se pueden aplicar a los colisionadores. Hagamos saltar a nuestro jugador usando un impulso. Entonces abajo después de todo esto, voy a poner en una función amó nuestra tecla presionada. Y aquí dentro vamos a revisar para ver si la tecla es igual a AP, es
decir, presionamos la tecla de flecha arriba, entonces aplicaremos nuestro impulso. Vamos a decir que el colon jugador aplica impulso lineal. Y el impulso que aplicaremos es 0. Y probemos negativo 5000. Ahora, un impulso lineal es sólo una fuerza rápida que empuja sobre el colisionador. En este caso, aplicamos un valor y negativo siendo aplicado al jugador. Ya que este 5000 negativo está en la posición y, eso va a empujar al jugador hacia arriba porque el negativo sube. Si guardamos y corremos. Cuando presiono la tecla de flecha arriba, el jugador hace un pequeño salto porque estamos aplicando ese impulso lineal. Hay muchas otras acciones que puedes aplicar a un colisionador. Hagamos que el jugador se mueva a la izquierda y a la derecha
usando una fuerza esta vez en contraposición a un impulso. Entonces lo haremos en nuestra función de actualización, y luego ataremos esto a las teclas de flecha dirán, si amamos, que el punto del teclado está abajo y diremos izquierda. Entonces cuando se presiona la tecla de flecha izquierda, entonces aplicaremos una fuerza, diremos colon jugador aplicar fuerza. Y vamos a hacer negativo 5000 en la posición x esta vez. Entonces nos va a mover a la izquierda. Y entonces diremos otra cosa, si amaba nuestro teclado que está abajo para la derecha. Y en este caso, haremos lo mismo. Aplicar fuerza, pero haremos positivo 5000, que nos moverá a la derecha. Y eso debería ser suficiente si guardamos y corremos, donde si presiono a la izquierda, empiezo a mover a la izquierda, y si presiono a la derecha, empiezo a moverme a la derecha, especie de deslizamiento a lo largo del suelo. El tema a notar sobre las fuerzas sin embargo, es que el seguir apilándose y creciendo más intenso. Por qué el jugador acelera
tanto al moverse a izquierda y derecha. Si quisieras limitar esto, solo
podrías aplicar una fuerza en el jugador
no se está moviendo ya a velocidad máxima. Podemos cerrar de esto. Entonces vamos a aplicar esta fuerza aquí sólo si el jugador la necesita para llegar a la velocidad máxima. De lo contrario no queremos aplicarlo, lo contrario habrá yendo demasiado rápido. Entonces primero en conseguir a los jugadores velocidad real como está en este marco, podemos hacer PX local,
PY es igual a colon jugador, obtener velocidad lineal. Y esta función aquí va a agarrar la velocidad de los jugadores y poner su valor x en p x y su valor y en PY. Por lo que ahora podemos comprobar
aquí el valor P x para determinar si realmente
queremos aplicar esta fuerza. Entonces aquí en esta línea voy a decir, y px es mayor que 300 negativo. Entonces lo haremos para que el negativo 300 sea la velocidad máxima a la que podemos ir. Entonces sólo vamos a aplicar la fuerza si estamos por debajo de ese umbral. Lo mismo para el derecho. Diremos, y P x es menor que 300 positivo. Por lo que haciendo negativo 300 para la dirección izquierda, moviéndose a la izquierda y positivo para la dirección derecha. Además, para hacer las cosas un poco más rápidas, voy a cambiar este 5000 de aquí a 8000. Eso nos hará acelerar un poco más rápido. Entonces si guardo y corro ahora, si me quedo a la izquierda, me he movido a la izquierda, y si sostengo a la derecha, me muevo a la derecha. Pero te darás cuenta de que no
termino yendo demasiado rápido como lo hacía antes. En general, sin embargo, este juego que acabamos de crear podría ser el inicio de un proyecto completo de plataformas. Y pudimos configurarlo con bastante rapidez. La página de GitHub para el campo eólico proporciona toneladas de información útil sobre el trabajo con la física. Recomiendo mucho leer a través de ella. Para el siguiente video, estaré tomando los conceptos aquí discutidos y aplicándolos al juego de estilo de arriba hacia abajo de los videos anteriores.
9. Collisions: Hola amigos. En este video estaré mostrando cómo agregar muros y colisiones a tu juego
2D de amor para que tu personaje no
pueda simplemente caminar por paredes. Adicionalmente, estaré mostrando cómo generar estos muros en juego desde tu azulejo a mapa. Para empezar, tendremos que utilizar cuando campo, lo que hablé en un video anterior. Estos primeros pasos serán los mismos de ese video. Y primero vas a ir a la página de GitHub aquí mismo y o clonarlo en tu proyecto o puedes descargarlo como Zip. Entonces por supuesto querrás extraer este archivo zip. Y luego vamos a entrar aquí y agarrar esta carpeta de campo de viento. Está justo al lado de este archivo README. Voy a copiar esto. Y de vuelta en nuestra carpeta de proyectos de juego, voy a ir a la carpeta de nuestra biblioteca y pegar esta carpeta de campo de viento justo aquí. Una vez que esa carpeta esté lista, tendremos que incluirla en nuestro código. Por lo que en la parte superior voy a sumar en WWF igual requieren. Y entonces el camino es bibliotecas slash campo de viento. Ten en cuenta que esto carga toda
la carpeta de campo de viento en esta variable WWF. Ahora podemos usar esta variable para crear nuestro mundo, diremos Mundo igual a WWF y ese nuevo mundo. Y luego para los parámetros de gravedad, se
trata de un juego de estilo RPG de arriba hacia abajo. Entonces no vamos a tener gravedad 0 coma 0. También necesitamos actualizar el mundo, por lo que abajo y nuestra función de actualización. Y vamos a poner esto después nuestro código de movimiento de jugadores. Así que probablemente aquí mismo. Y vamos a decir Actualización mundial de colon. Y entonces tenemos que pasar en DT así como así. Y luego finalmente abajo y dibujar temporalmente, vamos a dibujar el mundo. Entonces vamos a decir sorteo mundial de colon. Esto nos permitirá ver los colisionadores que creamos. Pero al final, probablemente
querremos quitar esto ya que
no queremos ver realmente todos esos planeadores y el producto final. También sepan que lo estamos dibujando dentro de nuestra cámara para que aparezca dentro de la lente de la cámara. Ahora que eso está en su lugar, necesitamos
darle a nuestro jugador un colisionador, o esencialmente un objeto de física que le permita colisionar con paredes. Por lo que retrocede en la parte superior donde definimos a nuestro jugador. También le voy a dar un colisionador. Entonces el colisionador de puntos jugador es igual a colon mundial, y luego vamos a convertirlo en un rectángulo BSG. Tan nuevo colisionador de rectángulo BSG. Ahora, un rectángulo BSG se parece mucho a un rectángulo regular, pero sus esquinas están derrumbadas en un poco. Es más como una forma octogonal, que en mi experiencia funciona un
poco mejor para los personajes de jugador. Ahora para los parámetros, la primera son las posiciones x e y. Entonces para x voy a hacer 400, y para y voy a hacer 250. Entonces necesitamos el tamaño, el ancho y la altura de este rectángulo BSG con voy a hacer 40 y altura voy a hacer 80. Y luego hay un parámetro más que determina hasta dónde están estos rincones. Para ayudar a demostrar esto, voy a hacer
que sean 14 para empezar. Y luego una cosa más que voy a hacer con este Collider no va a hacer que sea incapaz de
rotar algo como un jugador punto colisionador colon establecer la rotación fija a verdadera. Por lo que esto evita que el colisionador rote alrededor. Entonces ahora que esto está en su lugar, voy a ahorrar y correr. Y podemos ver que nuestro desorden está justo aquí. Y se puede ver a lo que me refiero con las esquinas están derrumbadas, así que es como un rectángulo regular, pero estas esquinas están inclinadas, así que es más de una forma ovalada, más técnicamente es un octágono. Pero notarás que el colisionador no se mueve actualmente, solo
se queda justo en su lugar. Lo que realmente queremos ahora es que
la posición del jugador siempre coincida con esta posición de colisionadores aquí. Para ayudar con esto, vamos a, después de actualizar el mundo, también
vamos a establecer jugador punto x igual al jugador dot collider, colon getX. Y lo mismo con el jugador blanco punto y igual jugador dot collider colon get
yAsí que ahora la posición del jugador siempre
se alineará con el colisionador. Ahorramos y corremos ahora, estamos igualados de manera uniforme, aunque probablemente el tamaño necesite ajustarse un poco. Entonces hagámoslo primero. Voy a desplazarme de nuevo
hasta donde creamos el colisionador para el jugador. Voy a aumentar el ancho, digamos a 50. Y vamos a hacer este 100. Y también puedo cambiar este 14 por lo que es menos cóncavo. Lo cambiaré por algo así como diez. Entonces probemos eso. Eso está mucho mejor. Está mucho más cerca de igualar los parámetros de los jugadores o el tamaño del jugador. Te darás cuenta aunque ahora que ya no podemos movernos. Y esto se debe a que siempre estamos bloqueando la posición del jugador a la posición de colisionadores. Y como el Colisionador no se mueve, tampoco
podemos movernos. Entonces para abordar esto, vamos a reelaborar todo el código de movimiento que hicimos por el jugador,
pero cambiarlo para que se esté dirigiendo al colisionador en su lugar. Entonces todo este código está sucediendo en actualización para estos si las declaraciones que están revisando la entrada del teclado y cómo nos estamos moviendo normalmente está cambiando la exposición. Pero en cambio lo que vamos a hacer es cambiar la velocidad del colisionador. Entonces para ayudar con esto, voy a crear algunas nuevas variables locales. Diré vx local y pondré eso 0 y VY local y pondré eso en 0. Por lo que estos van a representar la velocidad en la dirección x y la dirección y de nuestro colisionador. Ahora en lugar de actualizar Plato dot x, vamos en su lugar a establecer vx igual a la velocidad del jugador. Y lo mismo con todos estos otros, cambiará vx. Igual a la velocidad de punto del jugador. Pero como nos estamos moviendo a la izquierda, queremos que esto sea negativo. Por lo que estamos multiplicando velocidad jugada veces negativo 1. Y luego aquí abajo para arriba y abajo, vamos a actualizar VY. Vy iguala velocidad de reproducción para abajo, y luego v y iguala al jugador esa velocidad. Pero como estamos avanzando hacia arriba, necesitamos
multiplicar esto por uno negativo. Y luego después de todo lo que se hace, nuestros valores VX y VY se actualizan para que coincida con lo que fuera nuestra entrada de teclado. Por lo que simplemente podemos decir jugador de punto colisionador, conjunto de
colon velocidad lineal. Y esta función de velocidad lineal toma en dos parámetros, uno para la velocidad x y otro para la velocidad y. Entonces podemos pasar en v x para la x y luego v y para la y. Entonces, cualquiera que sea la entrada de teclado que pongamos, se va a alinear con estos dos parámetros y actualizar la velocidad lineal de nuestro colisionador. Entonces si ahorramos y probamos esto ahora, si sostengo algunas direcciones, podemos ver que me estoy moviendo,
pero me estoy moviendo muy despacio. Y esto se debe a que estamos actualizando estos valores a la velocidad de punto del jugador. Y si nos desplazamos hacia arriba, probablemente
encontraremos a ese jugador que la velocidad, sí, jugador que la velocidad es muy baja. Son sólo cinco. Necesitamos algo más cercano a los 300. Esa es la velocidad más apropiada. Entonces si ahorramos y corremos ahora, cuando me muevo, el jugador se mueve más específicamente el colisionador se mueve. Y está emparejando lo que sea jugador a x y jugador que y es. Por lo que nuestro personaje jugador se mueve con él. Y con este cambio, no debes notar ninguna diferencia con la forma en que el jugador se siente al controlar. Ahora el siguiente paso es poner en algunas paredes para que el jugador colisione con. Desde ahora solo puedo caminar por estos árboles y los edificios y esas cosas. Pongamos un colisionador muy simple para demostrar. Por lo que en la parte inferior de nuestra querida función de carga de puntos, voy a poner un nuevo colisionador de pared. Yo lo llamaré muro local iguala colon
mundo, nuevo colisionador de rectángulo. Whoops, nuevo colisionador de rectángulo, no rectángulo BSG. Entonces con este nuevo colisionador de rectángulo, necesitamos darle una posición salida en la posición cien, doscientas. Y luego por un ancho, no lo sé, voy a hacer un ancho de 120 y luego una altura de 300. Entonces con eso en su lugar, deberíamos ver que si guardamos y corremos ahí es este gran rectángulo aquí mismo está nuestra pared. Pero te darás cuenta de que cuando entramos en él, el muro simplemente se cae. Espero que sean capaces de ver que está un poco descolorido, pero el muro sí se cae porque ambos de nuestros colisionadores son dinámicos. En cambio, necesitamos nuestro tipo de conjunto de colon de pared a estático. Estático significa que no se ve impactado por colisiones y no se alejará. Entonces si ahorramos y corremos ahora, cuando me topo con el muro, el muro se queda justo en su lugar y el personaje también se detuvo cuando entramos en él. Por cierto, mirando más de cerca, parece que el borde de nuestro colisionador no coincide exactamente con el sprite jugador. Si lo deseabas, puedes aumentar el ancho para ser más preciso. Pero en mi opinión, estar lo suficientemente cerca es bueno. En fin, tenemos nuestro muro funcionando y se detiene al jugador. Lo que queremos hacer ahora es hacerlo para que podamos generar estos muros a partir de baldosas. Y ten en cuenta que esto requiere que tengas configurada una implementación
sencilla en mosaico para tu proyecto. Así que adelante y echa un vistazo a este video en la esquina para ponerte al día. Tan implicado para nuestro mapa, vamos a empezar por ir aquí y crear una nueva capa de objetos. Y lo vamos a llamar muros. Ahora que
se crea esta capa de muros y la tenemos seleccionada, podemos usar estas herramientas aquí arriba para objetos. Entonces voy a hacer clic en esta herramienta de rectángulo, y voy a dibujar en algunos objetos encima de lugares donde quiero que haya un muro. Entonces dibujé dos objetos. Y si utilizas este selector morado aquí arriba, puedes editarlos, puedes
moverlos y cambiar sus tamaños. Pero tengo dos objetos dibujados. Un consejo más si no se está ajustando a la cuadrícula como lo es para mí, puedes subir a View snapping y luego elegir tu opción aquí para snapping si necesitas
hacerlo más preciso o hacerlo chasquido a la cuadrícula. Entonces con esos dos objetos dibujados, voy a guardar el mapa. Pero luego también suba a exportar archivo como. Y luego asegúrate de que
lo estás exportando al lugar correcto. En mi caso, está en mi carpeta de juegos, mapas, y luego es este mapa de prueba.llegar a un archivo. Voy a ahorrar por encima de eso. Y eso hace que nuestro mapa se exporte. En cualquier momento que realices algún cambio en tu mapa, debes asegurarte de guardar y exportar, lo contrario, esos cambios no aparecerán en el juego. Ahora necesitamos crear mientras colisionadores que coincidan con esos objetos que dibujamos para mosaico. Entonces vamos a hacer algunas cosas por esto. Lo primero que voy a hacer es crear una tabla WALS. Entonces esto va a contener cada objeto de
pared que creemos. A continuación necesitamos una declaración if. Vamos a decir si mapa de juego capas de
puntos con corchetes y decir paredes. Entonces, lo que esta declaración si está haciendo es
comprobando que tenemos una capa llamada Walls. De lo contrario no haremos nada más. Entonces si tenemos una capa de mapa de juegos llamada Walls, entonces vamos a iterar a través todos los objetos de esa capa. Y eso lo hacemos con un bucle for. Diremos para i coma en pares. Y luego en los paréntesis aquí especificamos mapa de
juego que capas. Lo mismo que antes, muros. Pero entonces decimos objetos de punto. Por lo que esto nos consigue cada objeto en la capa de paredes. Y luego decimos hacer y terminar. Ahora dentro de este for-loop es donde realmente
vamos a estar generando nuestros objetos de pared. Y en realidad podemos tomar este código
aquí mismo y utilizarlo. Entonces vamos a pegar esto justo aquí y formatearlo un poco. Ahora. Ahora mismo estamos codificando estas como ciento
doscientas cosas como parámetros. Pero en cambio lo que queremos hacer es tomar el objeto
aquí mismo de azulejos y usar esos valores para estos. Entonces voy a decir obj dot x y obj dot y para el valor x e y. Y lo mismo con ancho y altura. Ancho y altura de punto obs. Y guarde eso. Entonces ahora sea cual sea la pared
que creemos, está tomando esos valores directamente del objeto que dibujamos en azulejo. Y una última cosa queremos insertar Este objeto de pared que acabamos crear en nuestra mesa de muros. Entonces voy a decir mesa, insertar muros,
muro, que pone nuestro objeto de pared en las paredes. Esto nos ayuda a hacer un seguimiento de todo lo que creamos. Tan solo para ayudar a aclarar por qué funciona esto, si selecciono uno de estos objetos que
creamos, podemos ver que tiene una propiedad x, y, anchura y altura, que podemos ver por aquí a la izquierda. Y esas son las propiedades exactas a las que estamos accediendo cuando estamos creando este muro. Sigamos adelante y salvemos y corremos. Y podemos ver un poco el contorno blanco. Pero cuando entro en estas casas aquí donde dibujé esos objetos, ya no
podemos caminar por él. Y esto es lo mismo con este de aquí arriba. Dondequiera que dibujamos un objeto en azulejo, ahora
hay una ley sentada ahí y por la que ya no podemos caminar. Y una vez que dibujas en el resto de los objetos en azulejos, ya no
tenemos que dibujar el mundo porque todo es preciso al nivel mismo. Entonces si quitamos esto, ya no
veremos los colisionadores, que es exactamente lo que queremos. Si guardamos y corremos ahora, todo vuelve a la normalidad, pero el jugador tiene un hit box y cada uno de estos muros ya no puede estar caminando. Entonces todo parece estar en su lugar. Y eso sobre lo cubre todo. Ahora tenemos una base muy sólida para un tipo de juego RPG.
10. Para terminar: Eso sobre envuelve el contenido principal de esta clase. Al igual que todas las clases de Skillshare, existe la opción de presentar un proyecto de clase. De verdad quiero que cualquiera que tome esta clase sea lo más creativo posible. Entonces el proyecto de clase es simplemente
hacer cualquier cosa que te guste en el amor. Esto puede incluir agregar algo nuevo al juego que creamos en los videos o comenzar algo nuevo. Sea lo que sea que hagas sin embargo, te
animo mucho a mantener las cosas simples al principio y luego a construir cosas más complicadas. Mi primer juego con amor fue un clon de Breakout muy básico. Y cada juego después de eso, construido sobre la complejidad, esta es una gran manera de aprender y practicar, y siempre animo a mis alumnos a hacer lo mismo. Trabajar por su cuenta puede ser un reto sin importar. Por lo que hay algunos consejos que me gustaría compartir. En primer lugar es utilizar el wiki de amor 2D. Este sitio describe todo lo que posiblemente podrías necesitar sobre el amor 2D y todas sus características. Aquí se esboza detalladamente cada función y capacidad. Y encontrarlo es bastante fácil. Por ejemplo, si me olvidé de los parámetros para el amor demographics dot draw, puedo simplemente Google en línea para el amor 2D, me
encantó nuestros gráficos dibujo. Y la página de la wiki aparecerá justo arriba. Constantemente estoy revisando cosas en este sitio cada vez que estoy trabajando en mis propios juegos. Entonces si tienes alguna pregunta específica sobre algo, asegúrate de echar un vistazo a los foros 2D de amor. Aquí la comunidad es muy activa y gente siempre está dispuesta a ayudar si estás atascado en algo. Otra cosa útil es encontrar algunos proyectos de amor de código abierto en
línea y ver cómo
codificaron ciertas características para empezar. Tengo un gran recurso en mi página de GitHub, que es un juego completo de amor 2D de código abierto. Puedes descargarlo y ejecutarlo localmente para jugar. Y entonces todo el código fuente está disponible para que usted mire a través, aprenda de, y lo use directamente para sus propios juegos. Entonces a medida que estás trabajando en algo con amor, definitivamente baja a la pestaña de proyectos y recursos y haz clic en el botón Crear Proyecto, sube algunas capturas de pantalla y describe en qué estás trabajando. Estoy muy emocionado de ver qué tipo de cosas se le ocurre a la gente. De nuevo sin embargo, intenta mantenerlo simple al principio y trabaja tu camino hacia arriba. Empezar fácil es la clave para sentirse cómodo con esto. Y yo diría que vamos a concluir esta clase. Muchas gracias por pasar por este material. Si aún no lo has hecho, por favor deja una opinión y si
disfrutaste de la clase, por favor lo recomiendo. Agradezco mucho el apoyo desde aquí. Siéntase libre de contactarme con cualquier pregunta de Lua, amor o programación general. Siempre estoy dispuesto a ayudar sin embargo
puedo con todo lo dicho, creo que eso cubre todo. Gracias de nuevo por tomar mi clase y
espero verlos en la siguiente.