Detección de colisiones deslizando contra un plano en XNA

Question

Estoy intentando diseñar un algoritmo de detección de colisiones para un cliente personalizado de Minecraft que estoy creando. Básicamente, todo el mundo está formado por cubos, y el jugador (o cámara) debe poder pararse y moverse contra estos cubos. El resultado que quiero se ilustra en esta imagen:

La línea verde es el vector de movimiento del jugador. Cuando el jugador está cepillando contra un plano de uno de los cubos, quiero que el vector cambie a uno que sea perpendicular al plano. El vector debería, sin embargo, mantener toda su velocidad en la dirección del avión, pero perder toda la velocidad hacia el plano.

Espero haber aclarado mi pregunta. ¿Cuál es la mejor y más eficiente forma de implementar un sistema de detección de colisión como este? Además, ¿un sistema como este permitirá un simple componente de gravedad?

EDITAR: Olvidé mencionar que los cubos se almacenan en una matriz tridimensional, [x, y, z].

Answer 1

Un enfoque simple para implementar esto sería detectar la colisión de la pelota y el avión. Calcule la profundidad de penetración, esto es hasta qué punto la pelota realmente ha pasado el avión, y empuje la pelota hacia atrás en la dirección de la normal del avión.

Esto tendrá el efecto de poner la pelota en la superficie del avión. Si haces esto para cada cuadro, la pelota se deslizará efectivamente a lo largo del plano, asumiendo por supuesto que el vector de velocidad de la pelota no es paralelo a la normal del avión.

El campo de detección de colisión es grande y complejo, y dependiendo de su juego, debe determinar qué es suficiente para sus necesidades en términos del nivel de realismo que necesita y los requisitos de rendimiento. Siempre debe buscar la solución más simple que brinde una retroalimentación lo suficientemente realista, dependiendo del juego, a menudo no tiene que ser perfecto.

Básicamente debe romper su detección de colisión en 2 fases, generalmente conocidas como fase amplia y fase estrecha.

La fase amplia podría ser tan simple como realizar una verificación de caja rápida para determinar posibles colisiones y luego enviar esa colisión potencial a la detección de colisión de fase estrecha para realizar comprobaciones más detalladas donde determinar si realmente hubo una colisión y la profundidad de la colisión Si tiene muchos objetos, la fase amplia puede usar algún tipo de indexación de quadtree para seleccionar solo los bloques cercanos a su objeto para realizar la detección de colisión.

Answer 2

En un mundo de cubos Axis Alineados, esto es realmente fácil. Es fácil pensar que necesitas algo complicado, pero en realidad es muy simple. Esto es por experiencia después de escribir mi propio clon de Minecraft.

Así es como:

position.X += velocity.X; 
if(colliding()) 
    position.X -= velocity.X; 

position.Y += velocity.Y; 
if(colliding()) 
    position.Y -= velocity.Y; 

position.Z += velocity.Z; 
if(colliding()) 
    position.Z -= velocity.Z; 

Aquí está el código para saber si está o no en colisión:

bool colliding() 
{ 
    int minX = Position.X - size.X/2; 
    int minY = Position.Y - size.Y/2; 
    int minZ = Position.Z - size.Z/2; 

    int maxX = Position.X + size.X/2; 
    int maxY = Position.Y + size.Y/2; 
    int maxZ = Position.Z + size.Z/2; 

    for (int x = minX; x <= maxX; x++) 
    for (int y = minY; y <= maxY; y++) 
     for (int z = minZ; z <= maxZ; z++) 
     { 
     if(blockType[x, y, z] != 0) 
      return true; 
     } 

    return false; 
}