Unlimited WordPress themes, graphics, videos & courses! Unlimited asset downloads! From $16.50/m
Advertisement
  1. Game Development
  2. Platformer
Gamedevelopment

Física básica de plataformas 2D, Parte 7: Cimentación de las pendientes

by
Difficulty:IntermediateLength:LongLanguages:
This post is part of a series called Basic 2D Platformer Physics .
Basic 2D Platformer Physics, Part 6: Object vs. Object Collision Response

Spanish (Español) translation by Luis Chiabrera (you can also view the original English article)

Final product image
What You'll Be Creating

Demostración

La demostración muestra el resultado final de la implementación de la pendiente. Usa WASD para mover el personaje. El botón derecho del mouse crea un mosaico. Puede usar la rueda de desplazamiento o las teclas de flecha para seleccionar un mosaico que desea colocar. Los controles deslizantes cambian el tamaño del personaje del jugador.

La demostración se publicó bajo Unity 5.5.2f1, y el código fuente también es compatible con esta versión de Unity.

Pendientes

Las pendientes agregan mucha versatilidad a un juego, tanto en términos de posibles interacciones con el terreno del juego como en la variación visual, pero su implementación puede ser muy compleja, especialmente si queremos admitir un gran número de tipos de taludes.

Al igual que en las partes anteriores de la serie, continuaremos nuestro trabajo desde el momento en que dejamos la última parte, a pesar de que volveremos a procesar una gran parte del código que ya hemos escrito. Lo que necesitaremos desde el principio es un personaje móvil en movimiento y un mapa de mosaicos.

Puede descargar los archivos del proyecto de la parte anterior y escribir el código junto con este tutorial.

Cambios en la integración del movimiento

Como hacer que las pistas funcionen es bastante difícil, sería bueno si pudiéramos facilitar las cosas en algunos aspectos. Hace un tiempo me topé con una publicación de blog sobre cómo Matt Thorson maneja la física en sus juegos. Básicamente, en este método, el movimiento siempre se realiza en intervalos de 1px. Si un movimiento para un cuadro en particular es más grande que un píxel, entonces el vector de movimiento se divide en muchos movimientos de 1px, y después de cada uno se verifican las condiciones para la colisión con el terreno.

Esto nos ahorra el dolor de cabeza de tratar de encontrar obstáculos a lo largo de la línea de movimiento a la vez, y en su lugar, podemos hacerlo de forma iterativa. Esto simplifica la implementación, pero desafortunadamente también aumenta el número de controles de colisión realizados, por lo que podría ser inapropiado para juegos donde hay muchos objetos en movimiento, especialmente juegos de alta resolución donde naturalmente la velocidad a la que los objetos se mueven es mayor. El lado positivo es que a pesar de que habrá más controles de colisión, cada control será mucho más simple ya que sabe que el personaje se mueve por un solo píxel cada vez.

Datos de las pendientes

Comencemos definiendo los datos que necesitaremos para representar las pendientes. En primer lugar, necesitaremos un mapa de altura de una pendiente, que definirá su forma. Comencemos con una pendiente clásica de 45 grados.

Slopes Data

Vamos a definir también otra forma de pendiente; este servirá más como un golpe en el suelo que cualquier otra cosa.

Another slope shape

Of course we will want to use variants of these slopes, depending where we'd like to place them. For example, in the case of our defined 45-degree slope, it will fit nicely if there's a solid block to its right, but if the solid block is on its left then we'd like to use a flipped version of the tile we defined. Tendremos que poder voltear las pendientes en el eje X y el eje Y, así como rotarlos 90 grados para poder acceder a todas las variantes de una pendiente predefinida.

Veamos cómo son las transformaciones de la pendiente de 45 grados.

Transformations of the 45 degree slope

Como puede ver, en este caso podemos obtener todas las variantes usando volteos. Realmente no necesitamos girar la pendiente 90 grados, pero veamos cómo se ven las cosas para la segunda pendiente que definimos antes.

Rotating slopes

En este caso, la transformación de rotación de 90 grados hace posible colocar la pendiente en la pared.

Calcular compensaciones

Usemos nuestros datos definidos para calcular los desplazamientos que deberán aplicarse al objeto que se superpone con un mosaico. El desplazamiento llevará la información sobre:

  • cuánto necesita mover un objeto hacia arriba / abajo / izquierda / derecha para no colisionar con un azulejo
  • cuánto debe moverse un objeto para estar justo al lado de la superficie superior / inferior / izquierda / derecha de una pendiente
Calculating Offsets

Las partes verdes de la imagen de arriba son las partes donde el objeto se superpone con las partes vacías del mosaico, y los cuadrados amarillos indican el área en la cual el objeto se superpone con la pendiente.

Ahora, comencemos a ver cómo calculamos el desplazamiento para el caso número 1.

El objeto no choca con ninguna parte de la pendiente. Eso significa que realmente no necesitamos moverlo fuera de la colisión, por lo que la primera parte de nuestro desplazamiento se establecerá en 0.

Para la segunda parte del desplazamiento, si queremos que la parte inferior del objeto toque la pendiente, tendríamos que moverla 3 píxeles hacia abajo. Si quisiéramos que el lado derecho del objeto tocara la pendiente, tendríamos que moverlo 3 píxeles hacia la derecha. Para que el lado izquierdo del objeto toque el borde derecho de la pendiente, tendríamos que moverlo 16 píxeles hacia la derecha. De manera similar, si quisiéramos que el borde superior del objeto tocara la pendiente, tendríamos que mover el objeto 16 píxeles hacia abajo.

Ahora, ¿por qué necesitaríamos la información de cuánta distancia hay entre el borde del objeto y la pendiente? Esta información nos será muy útil cuando queremos que un objeto se adhiera a la pendiente.

Entonces, por ejemplo, digamos que un objeto se mueve hacia la izquierda en nuestra pendiente de 45 grados. Si se mueve lo suficientemente rápido, terminará en el aire, y luego caerá de nuevo en la pendiente, y así sucesivamente. Si queremos que permanezca en la pendiente, cada vez que se mueva hacia la izquierda, querremos empujarlo hacia abajo para que permanezca en contacto con la pendiente. La animación siguiente muestra la diferencia entre tener habilitada o inhabilitada la pendiente para un personaje.

Animation of moving down a slope

Estaremos almacenando en el caché una gran cantidad de datos aquí; básicamente, queremos calcular un desplazamiento para cada posible solapamiento con un mosaico. Esto significa que para cada posición y para cada tamaño de superposición, tendremos una referencia rápida de cuánto mover un objeto. Tenga en cuenta que no podemos almacenar en caché los desplazamientos finales porque no podemos almacenar en caché un desplazamiento para cada AABB posible, pero es fácil ajustar el desplazamiento sabiendo la superposición de AABB con el mosaico de la pendiente.

Definiendo mosaicos

Definiremos todos los datos de pendiente en una clase estática de Pendientes.

En primer lugar, manejemos los mapas de altura. Vamos a definir algunos de ellos para procesar más adelante.

Agreguemos los tipos de mosaicos de prueba para las pendientes definidas.

Creemos también otra enumeración para el tipo de colisión de mosaicos. Esto será útil para asignar el mismo tipo de colisión a diferentes mosaicos, por ejemplo, una pendiente herbácea de 45 grados o una pendiente de piedra de 45 grados.

Ahora vamos a crear una matriz que contendrá todos los mapas de altura de los mosaicos. Esta matriz se indexará mediante la enumeración TileCollisionType.

Procesando las pendientes

Antes de que comencemos a calcular los desplazamientos, querremos desplegar nuestros mapas de altura en mapas de bits de colisión completa. Esto facilitará determinar si un AABB está colisionando con un mosaico y también habilitará formas de mosaico más complejas si eso es lo que necesitamos. Vamos a crear una matriz para esos mapas de bits.

Ahora creemos una función que ampliará el mapa de alturas en el mapa de bits.

Nada complicado aquí: si una posición particular en el mosaico es sólida, la configuramos en 1; si no es así, está configurado en 0.

Ahora vamos a crear nuestra función Init, que eventualmente hará todo el trabajo de caché que necesitamos haber hecho en las pendientes.

Vamos a crear las matrices de contenedores aquí.

Ahora hagamos que cada tipo de colisión de mosaico apunte a los datos en caché correspondientes.

Estructura de compensación

Ahora podemos definir nuestra estructura de compensación.

Como se explicó anteriormente, las variables freeLeft, freeRight, freeDown y freeUp corresponden a la compensación que se debe aplicar para que el objeto ya no colisione con la pendiente, mientras que collidingLeft, collidingRight, collidingTop y collidingBottom son la distancia que el objeto necesita ser desplazado para tocar la pendiente sin superponerla.

Es hora de crear nuestra función de caché para trabajos pesados, pero justo antes de hacerlo, creemos un contenedor que contenga toda esa información.

Y crea la matriz en la función Init.

Problemas de memoria

Como puede ver, esta matriz tiene muchas dimensiones y cada tipo de mosaico nuevo requerirá bastante memoria. Para cada posición X en el mosaico, para cada posición Y en el mosaico, para cada Ancho posible en el mosaico y para cada Altura posible, habrá un cálculo de valor de compensación por separado.

Dado que los mosaicos que estamos utilizando son 16x16, esto significa que la cantidad de datos necesarios para cada tipo de mosaico será de 16 * 16 * 16 * 16 * 8 bytes, lo que equivale a 512 kB. Se trata de una gran cantidad de datos, pero aún manejables, y por supuesto si el almacenamiento en caché de esta cantidad de información es inviable, tendremos que cambiar al cálculo de las compensaciones en tiempo real, probablemente utilizando un método más eficiente que el que estamos utilizando para almacenamiento en caché, u optimice nuestros datos.

En este momento, si el tamaño del mosaico en nuestro juego fuera mayor, digamos 32x32, cada tipo de mosaico ocuparía 8 MB, y si usáramos 64x64, sería 128MB. Estas cantidades parecen demasiado grandes para ser útiles, especialmente si queremos tener bastantes tipos de pendientes en el juego. Una solución sensata a esto parece ser dividir las grandes fichas de colisión en fichas más pequeñas. Tenga en cuenta que solo cada pendiente recién definida requiere más espacio; las transformaciones usan los mismos datos.

Verificación de colisiones dentro de un mosaico

Antes de que comencemos a calcular los desplazamientos, necesitamos saber si un objeto en una posición particular colisionará con las partes sólidas de la losa. Vamos a crear esta función primero.

La función toma el mapa de bits de colisión, la posición de la superposición y el tamaño de superposición. La posición es el píxel inferior izquierdo del objeto, y el tamaño es el ancho y la altura basados en 0. Por 0, me refiero a que el ancho de 0 significa que el objeto es realmente de 1 píxel de ancho y el ancho igual a 15 significa que el objeto tiene 16 píxeles de ancho. La función es muy simple: si alguno de los píxeles del objeto se superpone con una pendiente, devolvemos el valor verdadero; de lo contrario, devolveremos el valor falso.

Calcular las compensaciones

Ahora comencemos a calcular las compensaciones.

De nuevo, para calcular el desplazamiento, necesitaremos el mapa de bits de colisión, la posición y el tamaño de la superposición. Comencemos por declarar los valores de compensación.

Ahora calculemos cuánto necesitamos mover el objeto para que no colisione con la pendiente. Para hacer eso, mientras el objeto colisiona con la pendiente, debemos seguir moviéndolo hacia arriba y verificar la colisión hasta que no haya superposición con las partes sólidas de la losa.

No overlaps

Arriba está la ilustración de cómo calculamos el desplazamiento. En el primer caso, dado que el objeto está tocando el límite superior del mosaico, en lugar de solo moverlo, también tenemos que disminuir su altura. Esto se debe a que si alguna parte de AABB se mueve fuera de los límites, ya no estamos interesados en ella. De manera similar, los desplazamientos se calculan para todas las demás direcciones, por lo que para el ejemplo anterior, los desplazamientos serían:

  • 4 para el desplazamiento hacia arriba
  • -4 para el desplazamiento a la izquierda
  • -16 para el desplazamiento hacia abajo: esa es la distancia máxima porque, básicamente, si movemos el objeto hacia abajo, tenemos que moverlo completamente fuera de los límites de la losa para dejar de colisionar con la pendiente
  • 16 para el desplazamiento correcto

Comencemos por declarar la variable temporal para la altura del objeto. Como se mencionó anteriormente, esto cambiará dependiendo de qué tan alto estemos moviendo el objeto.

Ahora es el momento de la condición principal. Siempre que el objeto no se haya salido de los límites del mosaico y colisione con las partes sólidas del mosaico, necesitamos aumentar el offsetUp.

Finalmente, ajustaremos el tamaño del área de superposición de mosaico de objeto si el objeto se mueve fuera de los límites del mosaico.

Ahora hagamos lo mismo para el desplazamiento a la izquierda. Tenga en cuenta que cuando estamos moviendo el objeto a la izquierda y el objeto se está moviendo fuera de los límites del mosaico, no es necesario que modifiquemos la posición; en cambio, simplemente cambiamos el ancho de la superposición. Esto se ilustra en el lado derecho de la animación que ilustra el cálculo de compensación.

Pero aquí, dado que no estábamos moviendo el desplazamiento freeLeft en el camino ya que estábamos disminuyendo el ancho, necesitamos convertir el tamaño reducido en offset.

Ahora hagamos lo mismo para los desplazamientos hacia abajo y hacia la derecha.

Muy bien, hemos calculado la primera parte del desplazamiento: es cuánto debemos mover el objeto para que deje de colisionar con la pendiente. Ahora es el momento de descubrir las compensaciones que se supone que mueven el objeto justo al lado de las partes sólidas de la losa.

Tenga en cuenta que si tenemos que mover el objeto de la colisión, ya lo estamos haciendo, porque paramos justo después de que la colisión ya no existe.

Move the object out of collision

En el caso de la derecha, el desplazamiento hacia arriba es 4, pero también es el desplazamiento el que necesitamos para mover el objeto para que su borde inferior se asiente en un píxel sólido. Lo mismo aplica para los otros lados.

Ahora el caso de la izquierda es donde tenemos que encontrar los desplazamientos nosotros mismos. Si queremos encontrar el desplazamiento CollidingBottom allí, tenemos que mover el objeto 3 píxeles hacia abajo. Los cálculos necesarios aquí son similares a los anteriores, pero esta vez buscaremos cuando el objeto colisionará con la pendiente, y luego moviéndonos mientras reducimos el desplazamiento en uno, por lo que apenas toca los píxeles sólidos en lugar de superponerlos .

Si freeUp es igual a 0, el down libre también debe ser igual a 0, así que podemos incluir los cálculos para collidingTop bajo los mismos paréntesis. Una vez más, estos cálculos son análogos a lo que hemos estado haciendo hasta ahora.

Hagamos lo mismo para los desplazamientos izquierdo y derecho.

Almacenamiento en caché de los datos

Ahora que todos los desplazamientos se calculan, podemos devolver el desplazamiento para este conjunto de datos en particular.

Vamos a crear un contenedor para todos nuestros datos en caché.

Inicializa la matriz.

Y finalmente, crea la función de almacenamiento en caché.

La función en sí es muy simple, por lo que es muy fácil ver la cantidad de datos que almacena en caché para satisfacer nuestros requisitos.

Ahora asegúrese de guardar en caché los desplazamientos para cada tipo de colisión de mosaicos.

¡Y eso es todo, nuestra función principal de caché está terminada!

Cálculo de la compensación espacial mundial

Ahora usemos los datos en caché para crear una función que devolverá un desplazamiento para un personaje que existe en un espacio mundial.

El desplazamiento que vamos a devolver no es la misma estructura que utilizamos para los datos en caché, ya que los desplazamientos espaciales mundiales pueden llegar a ser más grandes que los límites del byte único. La estructura es básicamente la misma cosa, pero usando enteros.

Los parámetros son los siguientes:

  • el centro espacial mundial de la baldosa
  • los bordes izquierdo, derecho, inferior y superior de la AABB queremos recibir la compensación para
  • el tipo de baldosa que queremos recibir el desplazamiento para

Primero, necesitamos descubrir cómo se superpone AABB con un mosaico de pendiente. Necesitamos saber dónde comienza la superposición (la esquina inferior izquierda), y también cuánto se extiende la superposición sobre la ficha.

Para calcular esto, primero declaremos las variables.

Ahora calculemos los bordes de la losa en el espacio mundial.

Ahora esto debería ser bastante fácil. Hay dos categorías principales de casos que podemos encontrar aquí. Primero, la superposición está dentro de los límites del mosaico.

El píxel azul oscuro es la posición de la superposición, y la altura y el ancho están marcados con las teselas azules. Aquí las cosas son bastante sencillas, por lo que calcular la posición y el tamaño de la superposición no requiere ninguna acción adicional.

La segunda categoría de casos se ve de la siguiente manera, y en el juego nos ocuparemos principalmente de esos casos:

Veamos una situación de ejemplo en la foto de arriba. Como puede ver, el AABB se extiende mucho más allá del mosaico, pero lo que necesitamos averiguar es la posición y el tamaño de la superposición dentro del mismo mosaico, de modo que podamos recuperar nuestro valor de compensación en caché. En este momento, realmente no nos importa nada que esté más allá de los límites. Esto requerirá que fijemos la posición y el tamaño de superposición a los límites del mosaico.

La posición x es igual al desplazamiento entre el borde izquierdo de la AABB y el borde izquierdo de la losa. Si AABB está a la izquierda del borde izquierdo del mosaico, la posición debe sujetarse a 0. Para obtener el ancho de superposición, debemos restar el borde derecho del AABB de la posición x de la superposición, que ya calculamos.

Los valores para el eje Y se calculan de la misma manera.

Ahora podemos recuperar los desplazamientos almacenados en caché para la superposición.

Ajuste la compensación

Antes de devolver el desplazamiento, es posible que tengamos que ajustarlo. Considera la siguiente situación.

Veamos cómo se vería nuestro desplazamiento en caché para tal superposición. Cuando almacenamos en caché, solo nos preocupaba la superposición dentro de los límites del mosaico, por lo que en este caso, el desplazamiento hacia arriba sería igual a 9. Puede ver que si movimos el área de superposición dentro de los límites de mosaico 9 píxeles hacia arriba, dejaría de colisionar con la pendiente, pero si movemos todo el AABB, entonces el área que está debajo de los límites del mosaico se moverá hacia la colisión.

Básicamente, lo que tenemos que hacer aquí es ajustar el desplazamiento hacia arriba por el número de píxeles que AABB se extiende por debajo de los límites del mosaico.

Lo mismo debe hacerse para todas las demás compensaciones: izquierda, derecha y abajo, excepto que por ahora omitiremos el manejo de los desplazamientos izquierdo y derecho de esta manera, ya que no es necesario hacerlo.

Una vez que hayamos terminado, podemos devolver el desplazamiento ajustado. La función terminada debería verse así.

Por supuesto, aún no está completamente hecho. Más tarde, también manejaremos las transformaciones de teselas aquí, de modo que la compensación se devuelve de manera apropiada dependiendo de si la tesela ha sido volteada en los ejes XY o girada 90 grados. Por ahora, sin embargo, solo jugaremos con las fichas no transformadas.

Implementando la Física de Paso de un Píxel

Visión general

Mover los objetos en un píxel hará que sea bastante fácil manejar muchas cosas, especialmente las colisiones contra pendientes para objetos rápidos, pero aunque vamos a verificar si hay colisión en cada píxel que movemos, debemos movernos en un patrón específico para Asegure la precisión. Este patrón dependerá de la velocidad del objeto.

Checking 1-pixel collisions

En la imagen de arriba, puedes ver que si movemos ciegamente el objeto primero todos los píxeles que necesita para moverlo horizontalmente, y después de eso verticalmente, la flecha terminará colisionando con un bloque sólido que no está realmente en su curso. El orden de movimiento debe basarse en la relación de la velocidad vertical a la horizontal; de esta forma sabremos cuántos píxeles necesitamos mover verticalmente para cada píxel movido horizontalmente.

Definir los datos

Pasemos a nuestra clase de objetos en movimiento y definamos algunas nuevas variables.

En primer lugar, nuestra variable principal de mPosition solo mantendrá los números enteros, y mantendremos otra variable llamada mRemainder para mantener el valor después del punto flotante.

A continuación, agregaremos algunas nuevas variables de estado de posición para indicar si el personaje se encuentra actualmente en la pendiente. En este punto, será bueno si empaquetamos todo el estado de posición en una estructura única.

Ahora declaremos una instancia de la estructura para el objeto.

Otra variable que necesitaremos es la pendiente de la pendiente.

Implementación básica

Comencemos creando las funciones básicas de comprobación de colisiones; estos no manejarán las pendientes todavía.

Controles de colisión

Comencemos con el lado derecho.

Los parámetros utilizados aquí son la posición actual del objeto, sus esquinas superior derecha e inferior izquierda, y el estado de posición. Antes que nada, calculemos el mosaico superior derecho y el superior izquierdo para nuestro objeto.

Ahora iteremos a través de todos los mosaicos a lo largo del borde derecho del objeto.

Ahora, dependiendo del mosaico de colisión, reaccionamos adecuadamente.

Como puede ver, por ahora omitiremos el manejo de las pendientes; solo queremos hacer la configuración básica antes de profundizar en eso.

En general, la función por ahora debería verse así:

Haremos lo mismo para las otras tres direcciones: izquierda, arriba y abajo.

Funciones de movimiento

Ahora que tenemos esto cubierto, podemos comenzar a crear dos funciones responsables del movimiento. Uno manejará el movimiento horizontalmente, y otro manejará el movimiento vertical.

Los argumentos que usaremos en esta función son la posición actual, un booleano que indica si encontramos un obstáculo en el camino o no, un desplazamiento que define cuánto debemos mover, un paso que es un valor que movemos el objeto con cada iteración, los vértices inferiores izquierdos y superiores de AABB, y finalmente el estado de posición.

Básicamente, lo que queremos hacer aquí es mover el objeto un paso tantas veces, de modo que los pasos se sumen al desplazamiento. Por supuesto, si encontramos un obstáculo, debemos dejar de movernos también.

Con cada iteración, restamos el paso del desplazamiento, por lo que el desplazamiento finalmente se convierte en cero, y sabemos que movimos tantos píxeles como necesitábamos.

Con cada paso, queremos verificar si colisionamos con un mosaico. Si nos movemos bien, queremos verificar si colisionamos con una pared a la derecha; si nos movemos hacia la izquierda, queremos verificar si hay obstáculos a la izquierda.

Si no encontramos un obstáculo, podemos mover el objeto.

Finalmente, después de movernos, buscamos colisiones hacia arriba y hacia abajo, porque podríamos deslizarnos justo debajo o encima de un bloque. Esto es solo para actualizar el estado de la posición para que sea precisa.

La función MoveY funciona de manera similar.

Consolidar el movimiento

Ahora que tenemos funciones responsables del movimiento vertical y horizontal, podemos crear la función principal responsable del movimiento.

La función toma el valor de cuánto mover el objeto, la velocidad actual del objeto, su posición actual junto con el resto del punto flotante, el AABB del objeto y el estado de la posición.

Lo primero que haremos aquí es agregar el desplazamiento al resto, para que en el resto tengamos el valor total de cuánto debe moverse nuestro personaje.

Como llamaremos a las funciones MoveX y MoveY de esta, tendremos que pasar las esquinas superior derecha e inferior izquierda de AABB, así que calculemos ahora.

También necesitamos obtener el vector de paso. Se usará como una dirección en la que moveremos nuestro objeto.

Ahora veamos cuántos píxeles realmente necesitamos mover. Necesitamos redondear el resto, porque siempre vamos a mover un número entero, y luego tenemos que restar ese valor del resto.

Ahora dividamos el movimiento en cuatro casos, dependiendo de nuestros valores de vectores de movimiento. Si los valores x e y del vector de movimiento son iguales a 0, no hay movimiento que realizar, por lo que solo podemos regresar.

Si solo el valor y es 0, vamos a movernos solo horizontalmente.

Si solo el valor x es 0, vamos a mover solo verticalmente.

Si necesitamos mover ambos en los ejes x e y, necesitamos movernos en un patrón que se describió anteriormente. Primero, calculemos la relación de velocidad.

Declaremos también el acumulador vertical que contendrá la cantidad de píxeles que necesitamos mover verticalmente con cada ciclo.

La condición para detener el movimiento será que nos encontramos con un obstáculo en cualquiera de los ejes o el objeto fue movido por el vector de movimiento completo.

Ahora calculemos cuántos píxeles verticalmente deberíamos mover el objeto.

Para el movimiento, primero avanzamos un paso horizontalmente.

Y después de esto podemos movernos verticalmente. Aquí sabemos que necesitamos mover el objeto por el valor contenido en vertAccum, pero en caso de imprecisiones, si nos movimos completamente en el eje X, también tenemos que mover todo el camino en el eje Y.

Con todo, la función debería verse así:

Ahora podemos usar las funciones que hemos creado para componer nuestra función principal UpdatePhysics.

Desarrollar la función de actualización de física

En primer lugar, queremos actualizar el estado de la posición, de modo que todos los datos del cuadro anterior vayan a las variables adecuadas, y los datos del cuadro actual se restablezcan.

Ahora actualice el estado de colisión de nuestro objeto. Hacemos esto para que, antes de mover nuestro objeto, hayamos actualizado los datos sobre si está en el suelo o si está presionando otras fichas. Normalmente, los datos del cuadro anterior seguirían estando actualizados si el terreno no pudiese modificarse y otros objetos no podrían moverlo, pero supongamos que esto podría suceder.

CollidesWithTiles simplemente llama a todas las funciones de colisión que hemos escrito.

Luego actualiza la velocidad.

Y actualiza la posición. Primero, ahorremos el anterior.

Calcule el nuevo.

Calcule el desplazamiento entre los dos.

Ahora, en caso de que el desplazamiento no sea cero, podemos llamar a nuestra función Mover.

Finalmente, actualice el AABB del objeto y el estado de la posición.

¡Eso es! Este sistema ahora reemplaza al anterior, los resultados deberían ser los mismos, aunque la forma en que lo hacemos es bastante diferente.

Resumen

¡Eso es todo para sentar las bases de las pendientes, entonces lo que queda es llenar esos huecos en nuestros controles de colisión! Hemos realizado la mayor parte de nuestro trabajo de almacenamiento en caché y hemos eliminado muchas complejidades geométricas al implementar la integración de movimiento de un píxel.

Esto hará que la implementación de la pendiente sea sencilla, en comparación con lo que necesitaríamos hacer de otra manera. Terminaremos el trabajo en la próxima parte de la serie.

Gracias por leer!

Advertisement
Advertisement
Advertisement
Advertisement
Looking for something to help kick start your next project?
Envato Market has a range of items for sale to help get you started.