Tout d'abord, je n'écris ma propre logique de jeu que depuis peu de temps, donc je m'excuse si cela peut sembler simple.
J'ai beaucoup lu sur les arbres quadruples et la détection de collision basée sur une grille. Je comprends la logique - fondamentalement, ne vérifie pas la collision à moins que les objets ne soient proches à la base. Mais il n'est jamais mentionné comment l'exécuter réellement.
J'ai quelques méthodes possibles dans ma tête, mais je ne sais pas laquelle est la meilleure
Test de collision général - pas d'optimisation
for(var i:int = 0; i < objects.length; i++){
//find object A
var objectA = objects[i];
for(var j:int = i + 1; j < objects.length; j++){
//find object B
var objectB = objects[j];
if(objectA.collidesWith(objectB){
//handle collision logic
}
}
stocker les voisins (méthode 1) Mais que faire si nous voulons optimiser les collisions pour ne vérifier que les objets qui sont proches. Passons-nous toujours en revue tous les objets, ou créons-nous un tableau avec des objets proches à vérifier?
var objects:Array = new Array();
var neighbours:Array = new Array();
for(var i:int = 0; i < objects.length; i++){
//find object A
var objectA = objects[i];
for(var j:int = i + 1; j < objects.length; j++){
//find object B
var objectB = objects[j];
if(objectA.isNear(objectB){
neighbours.push(objectA, objectB);
}
}
}
//somewhere else
for(i:int = 0; i < neighbours.length; i++){
//only check neighbours
for(j:int = i + 1; j < neighbours.length; j++){
if(objectA.collidesWith(objectB){
//handle collision logic
}
}
}
boucle tous les objets mais vérifie seulement les voisins pour la collision (méthode 3) L'autre possibilité est que nous bouclons tout, mais vérifions si les objets sont proches avant de tester la collision.
for(var i:int = 0; i < objects.length; i++){
//find object A
var objectA = objects[i];
for(var j:int = i + 1; j < objects.length; j++){
//find object B
var objectB = objects[j];
if(objectA.isNear(objectB){
//they are near - check collision!
if(objectA.collidesWith(objectB){
//handle collision logic
}
}
}
}
Stocker des objets dans les données de tuiles (méthode 3) L' utilisation d'un système basé sur les tuiles permet une autre option; Stockez les objets qui se trouvent sur une tuile spécifique dans les données de tuiles elles-mêmes. Vérifiez pour voir sur quelle tuile l'objet est les tuiles environnantes contiennent tous les objets avec lesquels il pourrait entrer en collision:
var ObjectA;
for(var i:int = 0; i < 4; i ++){
//check 4 surrounding tiles from object A
if(Object.currentTile + surroundingTile[i] CONTAINS collidable object){
//check collision!
if(objectA.collidesWith(surroundingTile.object){
//handle collision logic
}
}
}
J'essaie toujours de regarder le monde réel comme exemple. Si je voulais comparer des articles de la même couleur, il semblerait illogique de vérifier chaque article entier même s'ils ne correspondent pas à la couleur (méthode 2, vérifiez chaque article). Je collecterais probablement les articles de la même couleur (objets qui sont proches les uns des autres) et les vérifierais (méthode 1), au lieu de tout vérifier.
Ce n'est pas une comparaison appropriée, car les éléments de la vérification des collisions se déplacent constamment, de sorte que la commande est mélangée. C'est ce qui me déroute.
Serait-il plus efficace de vérifier chaque élément, supprimant ainsi la contrainte de continuer à générer un tableau de voisins.
Ou est-il plus efficace de trouver des voisins sans avoir à parcourir autant d'objets pour vérifier la collision?
Continuer à changer les données sur chaque tuile semble également très intensif, donc je ne sais pas si c'est une bonne idée ..
J'ai pensé à un jeu de tower defense où la tour doit détecter des objets si des objets sont à portée avant de lui tirer dessus. Et il semble juste stupide de vérifier tous les éléments alors qu'à certains moments, il n'y aura aucun objet à proximité.
Je m'excuse pour le long post, j'ai toujours du mal à m'expliquer!