AS3 Performance: Beaucoup de tableaux vs One Array + 'est'

Question

J'ai beaucoup d'objets d'affichage à gérer pendant l'exécution, donc Im actuellement en utilisant des tableaux pour les gérer. Mais le problème est que j'ai peu de types d'objets d'affichage (par exemple, Tile, Npc et Building) qui sont essentiellement des MovieClips liés à la bibliothèque. Chaque objet d'affichage joue un rôle différent où il sera vérifié sur entrer dans le cadre, une boucle.

Méthode 2 semble beaucoup plus rapide et extensible mais Im inquiet si elle aurait une incidence sur le taux de contrôle de chaque objet d'affichage lors de l'exécution que les affichages: Array grandir et faire probablement glitch

Alors que l'un des la méthode suivante est plus rapide et moins glitchy et explique pourquoi vous l'avez choisie.

Merci d'avance.

Méthode 1

var tiles:Array = new Array() 
var npcs:Array = new Array() 
var buildings:Array = new Array() 

function createTiles(){ 
for(var i:Number=0; i<10; i++){ 
var t:Tile = new Tile() //Display object in the library 
t.x = i * 50 
t.y = i * 50 
addChild(t) 
tiles.push(t) 
} 
} 

function createNpcs(){...} 
function createBuildings(){...} 

addEventListener(Event.ENTER_FRAME, loop) 

function loop(e:Event){ 
for(var i:Number=0; i<tiles.length; i++){ 
//some codes 
} 
for(var j:Number=0; j<npcs.length; j++){ 
//some codes 
} 
for(var k:Number=0; k<buildings.length; k++){ 
//some codes 
} 
} 

---

Méthode 2

var displays:Array = new Array(); 

function createDispalys(){ 
for(var i:Number=0; i<10; i++){ 
var t:Tile = new Tile() //Display object in the library 
t.x = i * 50 
t.y = i * 50 
addChild(t) 
displays.push(t) 
} 
for(var j:Number=0; j<10; j++){ 
//some code 
displays.push(t) 
} 
for(var k:Number=0;k<10; k++){ 
//some codes 
displays.push(t) 
} 
} 
addEventListener(Event.ENTER_FRAME, loop) 
function loop(e:Event){ 
for(var i:Number=0; i<display.length; i++){ 
if(display[i] is Tile){ 
//some codes 
}else if(display[i] is Npc){ 
//some codes 
}else if(display[i] is Building){ 
//some codes 
} 
} 
} 

Answer 1

Si la performance est ce que vous recherchez, vous devriez utiliser Vectors à la place.

Answer 2

Qu'en est-il étendre ces classes (tuiles, Npc, Bâtiment), d'une classe de base - disons , qui classe de types a une méthode réinscriptible getType().

Cette méthode renvoie « Aucun » par défaut, mais en élargissant la classe et écrasez la méthode qu'il peut revenir « tuile », « Npc » ou « bâtiment » ...

Avec cela, il est possible de faire commutateur déclarations, et fondamentalement plus facile de gérer le code ...

switch (anObject.getType()){ 
    case "etc"... 
} 

Answer 3

Avez-vous envisagé la méthode de refactoring 2 pour mettre la logique à l'intérieur de la classe elle-même?

Ie:

public interface DisplayAsset 
{ 
    void onEnterFrame(); 
} 

// Implementations ommitted 
public class Npc implements DisplayAsset {} 
public class Tile implements DisplayAsset {} 
public class Building implements DisplayAsset {} 

Ensuite, votre boucle reste extensible (il suffit d'ajouter un autre impl DisplayAsset.), Et rapide - votre code devient:

var displays:Array = new Array(); // As per Gregor Kiddie's comment, use a vector here if possible 
// as a vector: 
// var displays:Vector.<DisplayAsset> = new Vector.<DisplayAsset>(); 

function createDispalys(){ 
    for(var i:Number=0; i<10; i++){ 
    var t:Tile = new Tile() //Display object in the library 
    t.x = i * 50 
    t.y = i * 50 
    addChild(t) 
    displays.push(t) 
    } 
    for(var j:Number=0; j<10; j++){ 
     //some code 
     displays.push(t) 
    } 
    for(var k:Number=0;k<10; k++){ 
     //some codes 
     displays.push(t) 
    } 
} 
addEventListener(Event.ENTER_FRAME, loop) 
function loop(e:Event){ 
    for each (var displayAsset:DisplayAsset in displays) 
    { 
      displayAsset.onEnterFrame(); 
    } 
}