En primer lugar, solo he estado escribiendo mi propia lógica de juego por un corto tiempo, así que me disculpo si esto puede parecer sencillo.
He estado leyendo mucho sobre los árboles cuádruples y la detección de colisiones basada en cuadrículas. Entiendo la lógica: básicamente, no verifique la colisión a menos que los objetos estén cerca básicamente. Pero nunca se menciona cómo realmente ejecutan esto.
Tengo un par de métodos posibles en mi cabeza pero no estoy seguro de cuál es el mejor
Prueba de colisión general: sin optimización
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
}
}almacenar vecinos (método 1) Pero, ¿qué pasa si queremos optimizar las colisiones para verificar solo los objetos que están cerca? ¿Todavía corremos a través de todos los objetos, o creamos una matriz con objetos cercanos para verificar?
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
}
}
}recorrer todos los objetos pero solo verificar la colisión de los vecinos (método 3) La otra posibilidad es que todavía recorremos todo pero verificamos si los objetos están cerca antes de probar la colisión.
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
}
}
}
}Almacenar objetos en datos de mosaico (método 3) Usar un sistema basado en mosaico permite otra opción; Almacene los objetos que están en un mosaico específico en los datos del mosaico en sí. Verifique en qué mosaico está el objeto. Los mosaicos circundantes contienen objetos con los que podría chocar:
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
}
}
}Siempre trato de ver el mundo real como un ejemplo. Si quisiera comparar artículos con el mismo color, parecería ilógico verificar cada artículo completo, incluso si no coinciden con el color (Método 2, verifique cada artículo). Probablemente recolectaría los artículos con el mismo color (objetos que están cerca uno del otro) y los vería (método 1), en lugar de verificar todo.
Esta no es una comparación adecuada ya que los elementos en la verificación de colisión se mueven constantemente, por lo que el orden se confunde. Eso es lo que me confunde.
¿Sería más eficiente verificar cada elemento, eliminando así la tensión de seguir generando una serie de vecinos?
¿O es más eficiente encontrar vecinos para no tener que recorrer tantos objetos para verificar la colisión?
Seguir cambiando los datos en cada mosaico también parece muy intensivo, así que no estoy seguro de si es una buena idea.
He estado pensando en un juego de defensa de la torre donde la torre necesita detectar objetos si los objetos están dentro del alcance antes de dispararle. Y parece una tontería comprobar todos los elementos, mientras que en ocasiones no habrá ningún objeto cerca.
Pido disculpas por la larga publicación, siempre tengo problemas para explicarme.