Le moteur physique est la partie du jeu qui va prendre en compte tous les mouvements des joueurs et des objets ainsi que leurs interactions et toutes les forces pouvant entrer modifier les comportements (gravité, force de poussée, etc). Pour un jeu 2D, le moteur physique est généralement facile à implémenter, il calcule tout simplement les collisions en utilisant la comparaison de couleurs entre les pixels de plusieurs objets et détermine les nouveaux comportements de ces objets en conséquence.
La détection de collision en utilisant les pixels
L’idée est de comparer 2 images que l’on souhaite vérifier si il y a collision ou non : chacune de ces images contient un fond transparent, donc si un pixel non transparent est rencontré sur une image, il s’agit forcément d’un pixel composant l’objet dessiné sur cette image. A partir de là, on peut dire que si des images se touchent, et que de surcroît au moins 1 pixel de chacune de ces images n’est pas transparent et se superpose, alors 2 objets sont en collision.

Les images ne se touchent pas, la collision est impossible

Les images se touchent, mais aucun pixel de chacun des objets ne se superpose

Les images se touchent et les pixels de chaque objet se superposent
Au-dessus 3 images permettent d’illustrer l’idée de la collision par pixels : sur l’image 2, on voit en couleur rouge claire que des pixels des 2 images se touchent, mais se sont des pixels transparents de l’un ou de l’autre côté, donc il ne peut pas il y avoir de collision entres les 2 objets. Sur l’image 3 en revanche, une partie des pixels de l’objet 1 se superposent aux pixels de l’objet 2 (en rouge), il y a donc collision entre les 2 objets. L’algorithme de détection va adopter le même principe en utilisant des fonctions pratiques des librairies de XNA.
L’exemple suivant illustre une fonction XNA qui gère une collision simple par pixels entre 2 objets contenus dans 2 images :
public bool IsPixelCollision(Rectangle rectangleA,
Color[] dataA,
Rectangle rectangleB,
Color[] dataB)
{
int top = Math.Max(rectangleA.Top, rectangleB.Top);
int bottom = Math.Min(rectangleA.Bottom, rectangleB.Bottom);
int left = Math.Max(rectangleA.Left, rectangleB.Left);
int right = Math.Min(rectangleA.Right, rectangleB.Right);
for (int y = bottom - 1; y >= top; y--)
{
for (int x = left; x < right; x++)
{
Color colorA = dataA[(x-rectangleA.Left)+
(y-rectangleA.Top)*
rectangleA.Width];
Color colorB = dataB[(x-rectangleB.Left)+
(y-rectangleB.Top)*
rectangleB.Width];
if (colorA.A != 0 && colorB.A != 0)
return true;
}
}
return (false);
}
Cette fonction peut être appelée de la manière suivante dans le code :
Texture2D TextureA = Content.Load<texture2d>("image1");
Texture2D TextureB = Content.Load<texture2d>("image2");
Color[] ColorsA = new Color[textureA.Width*textureA.Height];
Color[] ColorsB = new Color[textureB.Width*textureB.Height];
TextureA.GetData(ColorsA);
TextureB.GetData(ColorsB);
Rectangle RectangleA = new Rectangle(0, 0, TextureA.Width,
TextureA.Height);
Rectangle RectangleB = new Rectangle(0, 0, TextureB.Width,
TextureB.Height);
bool IsCollision = IsPixelCollision(RectangleA, ColorsA,
RectangleB, ColorsB);
Aucun commentaire:
Enregistrer un commentaire