Prima di tutto, ho scritto la mia logica di gioco solo per un breve periodo, quindi mi scuso se potrebbe sembrare semplice.
Ho letto molto sugli alberi dei quad e sul rilevamento delle collisioni basato sulla griglia. Capisco la logica - fondamentalmente non controllare la collisione a meno che gli oggetti non siano praticamente vicini. Ma non viene mai menzionato come eseguono effettivamente questo.
Ho un paio di possibili metodi nella mia testa ma non sono sicuro di quale sia il migliore
Test di collisione generale: nessuna ottimizzazione
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
}
}store neighbors (metodo 1) Ma cosa succede se vogliamo ottimizzare le collisioni per controllare solo gli oggetti vicini. Eseguiamo ancora tutti gli oggetti o creiamo un array con oggetti vicini da controllare?
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
}
}
}esegui il ciclo di tutti gli oggetti ma controlla solo i vicini per la collisione (metodo 3) L'altra possibilità è che eseguiamo ancora il ciclo di tutto, ma controlliamo se gli oggetti sono vicini prima di testare la collisione.
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
}
}
}
}Memorizza oggetti nei dati delle tessere (metodo 3) L' uso di un sistema basato su tessere consente un'altra opzione; Conservare gli oggetti che si trovano su un riquadro specifico nei dati del riquadro stesso. Controlla per vedere su quale riquadro sono le tessere circostanti che contengono eventuali oggetti con cui potrebbe scontrarsi:
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
}
}
}Cerco sempre di guardare al mondo reale come esempio. Se volessi confrontare gli articoli con lo stesso colore, sarebbe illogico controllare ogni intero articolo anche se non corrispondono al colore (Metodo 2, controlla ogni articolo). Probabilmente raccoglierei gli oggetti con lo stesso colore (oggetti vicini l'uno all'altro) e controllerei quelli (metodo 1), invece di controllare tutto.
Questo non è un confronto appropriato poiché gli articoli nel controllo delle collisioni si muovono costantemente, quindi l'ordine viene confuso. Questo mi confonde.
Sarebbe più efficiente controllare ogni articolo, eliminando così lo sforzo di continuare a generare una serie di vicini.
O è più efficace trovare vicini di casa, quindi non dover passare attraverso così tanti oggetti per controllare la collisione?
Continuare a modificare i dati su ogni riquadro sembra molto intenso, quindi non sono sicuro che sia una buona idea ..
Ho pensato a un gioco di difesa della torre in cui la torre ha bisogno di rilevare oggetti se gli oggetti si trovano nel raggio prima di sparargli. E sembra sciocco controllare tutti gli oggetti mentre a volte non ci saranno oggetti vicini.
Mi scuso per il lungo post, avendo sempre problemi a spiegarmi!