Quelle est la meilleure approche pour la détection de collision 2D sur l'iPhone?

Question

travaille sur ce problème de la détection de collision et il semble y avoir 3 approches que je pourrais prendre:

1. approche Sprite et le masque. (Et le chevauchement des sprites et vérifiez un nombre différent de zéro dans les données de pixel sprite résultant).

2. Cercles de délimitation, rectangles ou polygones. (Créez une ou plusieurs formes qui entourent les sprites et effectuez les calculs de base pour vérifier les chevauchements).

3. Utilisez une bibliothèque d'images-objets existante.

La première approche, même si elle aurait été la façon dont je l'aurais fait dans les vieux jours de 16x16 blocs d'images-objets, il semble qu'il n'y est tout simplement pas un moyen facile d'obtenir à l'image individuelle données de pixel et/ou canal alpha dans Quartz (ou OPENGL d'ailleurs). Détecter le chevauchement de la boîte englobante est facile, mais ensuite créer une troisième image à partir du chevauchement et ensuite le tester pour les pixels est compliqué et mon intuition est que même si nous pouvions le faire fonctionner serait lent. Est-ce que je manque quelque chose de propre ici?

La deuxième approche consiste à diviser nos sprites en plusieurs polygones et à les tester pour les chevauchements. Plus il y a de polygones, plus la détection de collision est précise. L'avantage est que c'est rapide, et peut être précis. L'inconvénient est que cela rend la création de sprite plus compliquée. c'est-à-dire que nous devons créer les polygones pour chaque sprite. Pour la vitesse, la meilleure approche consiste à créer un arbre de polygones.

La troisième approche dont je ne suis pas sûr car elle implique l'achat de code (ou l'utilisation d'une licence open source). Je ne suis pas sûr de savoir quelle est la meilleure bibliothèque à utiliser ou si cela pourrait vous rendre la vie plus facile ou nous donner un problème pour l'intégrer dans notre application. Donc, en bref, je privilégie l'approche polygone et arborescence et je vous serais reconnaissant d'avoir des vues à ce sujet avant d'écrire beaucoup de code.

Meilleures salutations

Dave

Answer 1

Considérez polygonizing vos sprites. Gardez une représentation polygonale pour vos sprites "en arrière-plan" et faites des tests de collision avec la version polygonisée de votre monde de jeu. Cela produit des frais généraux et une complexité supplémentaire, mais est souvent très gratifiant en termes de possibilités supplémentaires. (ombres dynamiques, effets de lumière, détection de collision indépendante des graphiques de sprite, beaucoup plus de méthodes de détection de collision, intersection polygonale etc.)

Sinon, vous êtes bloqué avec l'approche basée sur les pixels que vous avez décrite, ce qui n'est pas mauvais non plus. (ORing the overlap) Vous pouvez le faire seul ou laisser OpenGL le faire dans le frame buffer. (Je ne me souviens pas des appels, je pense que ça s'appelle z-masking (?), ... désolé Pour les petits sprites cela peut même être plus lent ...) Pensez à utiliser des techniques de partitionnement d'espace binaire pour optimiser certains Par exemple:

Les arbres à quatre arbres, par exemple, vous permettent de trouver rapidement les sprites candidats pour les tests de collision. Ils sont applicables à la fois sur l'approche basée sur les pixels et sur les vertex. Ou utilisez simplement BSPTrees. Btw: Je pense que la précision des pixels sur la détection des collisions est en fait une fonctionnalité intéressante, je l'ai beaucoup utilisée dans Jump'n Runs. Peut-être pas applicable à votre jeu, cependant.