Tijdens het ontwikkelen van de site voor mijn eindwerk in december liep de emmer over: Alweer een project waarin het ActionScript tweenen niet wilde lukken. Gerrit kwam me helpen, en na even zoeken kon hij me vertellen dat de fout inderdaad niet bij mij lag, maar bij de garbage collector in de Flash Player.
Mijn probleem was vanaf dan opgelost, en in elk project waar ik nu ActionScript-matige tweens aanmaak kan ik dat probleem meteen uit de weg gaan, maar ik zie nog enorm veel vragen opduiken waarin dit exact zelfde probleem besproken wordt.

Hoe ontstaat dit probleem?
Het probleem zelf ontstaat (voor zover ik het heb gezien) als je in een functie/handler een lokale tween aanmaakt, zonder externe referenties te behouden.

Voorbeeld:

function someHandler(e:Event):void{
var tween:Tween = new Tween(someMC,'scaleX',Regular.easeOut,0,1,5,true);
}

In bovenstaand voorbeeld wordt de functie someHandler opgeroepen eens er een event gedispatched wordt. Op dat moment wordt een tween aangemaakt in de scope van die functie. Eens deze functie doorlopen is, wordt deze verlaten, en zomee is deze scope niet meer in gebruik. Er is op dat moment geen referentie meer naar je tween object, dat je zonet hebt aangemaakt.

De garbage collector verwijdert variablen/objecten aan de hand van die referenties: Als er objecten zijn in scopes waar niets meer naar verwijst, is dat ‘garbage’ en kan zomee verwijderd worden.
Het tween object is hier ook onderhevig aan: Eens je de scope van die someHandler functie verlaat, is er geen referentie meer aanwezig naar je tween object, ookal is die visueel actief op de stage van je Flash movie. Als de garbage collector van de Flash Player dan voorbij komt om op te ruimen wordt je tween object verwijderd: op het scherm stopt je tween voordat hij klaar is.

De oplossing?
Er zijn verschillende manieren om de garbage collector te vertellen dat we ons tween object nog nodig hebben.

• We declareren de tween globaal. Hiermee zal hij altijd in main scope aanwezig zijn, en zomee niet verwijderd worden tenzij wij dat zelf aangeven.
• We kunnen diezelfde globale tween ‘hergebruiken’ in diepere scopes. (Handig als je maar 1 tween hebt, waarvan je zeker weet dat hij zichzelf nooit zal overschrijven/vervangen.)
• We maken een globale array aan, waar we elke tween aan toevoegen. Op die manier is er ten alle tijde een referentie naar ons tween object, en zal de garbage collector het niet kunnen verwijderen, tenzij we de tween uit de array verwijderen.

De laatste oplossing heeft mij al veel gediend, en is weinig moeite.

var garbage:Array = new Array();
function someHandler(e:Event):void{
var tween:Tween = new Tween(someMC,'scaleX',Regular.easeOut,0,1,5,true);
garbage.push(tween);
}

Dit is een nogal onprofessionele manier Ik vind dit nogal een vuile manier om het probleem uit de wereld te helpen, maar het is wel de essentie van de oplossing.
Bij extreem veel tweens in een applicatie die lang in gebruik is, is het misschien geen slecht idee om die array af en toe wat uit te kuisen: Tweens die niet meer gebruikt worden uit deze array verwijderen.

Er zijn mensen die me zeggen dat het gebruik van Tweener of TweenLite dit probleem ook meteen oplost. Ikzelf heb nog niet genoeg met Tweener gewerkt om daar zelf een oordeel over te kunnen vellen.

Ik hoop dat ik hier een aantal mensen kan mee helpen, gezien dit toch een populair probleem schijnt te blijven.