✔ Funtionen nacheinander ausführen

Leugim

Leugim

Erfahrenes Mitglied
Ich habe ein Funktion, die den _alpha wert eines MCs animiert (einblendet oder ausblendet) hierfür verwende ich ein Interval.

Nun würde ich gerne erfahren, ob diese animation fertig ist, oder nicht, um die nächste Funktion ausführen zu lassen.

Es soll ein MC ausgeblendet und gelöscht werden, und erst dann sollte eine Funktion ausgeführt werden die einen MC mit gleichen Namen wie den vorherigen erzeugt, mit neuem Inhalt versieht und einblendet.

Ich dachte das ganze wäre mit returns zu lösen, allerdings haut das nicht hin.

Fade Funktion:
Code: 
function fadeIt(that:MovieClip, direccion:String, paso) {
	var cb:Boolean = false;
	// Hier wird die Geschwindigket der animation bestimmt.
	var step:Number = (paso != undefined) ? (paso == "fast") ? -6 : paso*-1 : -2;
	var limit:Number = 0;
	if (direccion == "in") {
		step *= -1;
		limit = 100;
	}
	
	var fade:Number = setInterval(fadeein, vel, step, limit);
	function fadeein(step:Number, limit:Number) {
		that._alpha += step;
		if (direccion == "in") {
			if (that._alpha>=limit-5) {
				clearInterval(fade);
				that._alpha = limit;
				cb = true;
			}
		} else {
			if (that._alpha<=limit+5) {
				clearInterval(fade);
				that._alpha = limit;
				removeMovieClip(that);
				cb = true;
			}
		}
	}
	return cb;
}

Und hier der Teil der nicht klappt...
Code: 
prev.onRelease = function() {
	var buh = _root.fadeIt(imagen, "out", "fast");
	_root.fadeIt(textos,"out","fast");
	_root.fadeIt(prev,"out","fast");
	_root.fadeIt(prox,"out","fast");
	this.onEnterFrame = function() {
		trace(buh);
		if (buh) {
			imgBox(ziel.ide,ziel.dat);
			delete imagen;
			delete textos;
			delete prev;
			delete prox;
			delete this.onEnterFrame;
		}
	}
}
Die variable buh gibt immer nur undefined aus.
Wie bekomme ich ein vernünftiges feedback hin, um die Funktion imgBox() im richtigen Zeitpunkt auszuführen?
 
Hallo,

mal abgesehen vom undefined wird diese Logik nicht funktionieren, weil der fadeIn in der übergeordneten Funktion ausgeführt wird, also erstens gleich beim Aufruf der Funktion und zweitens unabhängig vom Interval oder dem Fortschritt des Fades. Für solche Fälle empfiehlt sich die Verwendung von Event-Listenern und auch eine Klasse bietet sich eigentlich an. Wenn du nun keine Klassen verwenden willst, kannst du auch einfach ein Fade-Objekt erstellen, dass die Funktion fadeIt als Eigenschaft hat. Wenn du mit Funktionen arbeitest, musst du immer stärker referenzieren (siehe Code unten).
Nun musst du den Event-Dispatcher initialisieren. Dafür muss der Dispatcher drei leere Funktionen aufweisen, addEventListener, removeEventListener und dispatchEvent, welche ich auch als Eigenschaften des Objekts registriert habe (siehe unten).
Nun musst du den Dispatcher noch registrieren und den Fade aufrufen.

Hier der Code:
Code: 
var fadeObject: Object = {
	//fadeIt Funktion
	fadeIt: function (that:MovieClip, direccion:String, paso) {
		var cb:Boolean = false;
		// Hier wird die Geschwindigket der animation bestimmt.
		var step:Number = (paso != undefined) ? (paso == "fast") ? -6 : paso*-1 : -2;
		var limit:Number = 0;
		if (direccion == "in") {
			step *= -1;
			limit = 100;
		}
		
		//Mit this registrierst du hier die Funktion als Eigenschaft und nur so kann sie vom Intervall
		//so wie ich ihn aufrufe (siehe unten) erkannt werden
		this.fadeein = function (step:Number, limit:Number) {
			that._alpha += step;
			if (direccion == "in") {
				if (that._alpha>=limit-5) {
					clearInterval(fade);
					//Hier wird der complete-Status dispatcht. Du kannst dieses Objekt beliebig erweitern, es wird nachher 
					//als Argument an die Listener-Funktion übergeben. Wichtig ist die Eigenschaft type, welche für den Event-
					//namen steht
					this.dispatchEvent ({type: "complete", direccion: direccion, that: that})
					that._alpha = limit;
					cb = true;
				}
			} else {
				if (that._alpha<=limit+5) {
					clearInterval(fade);
					//Siehe oben
					this.dispatchEvent ({type: "complete", direccion: direccion, that: that})
					that._alpha = limit;
					removeMovieClip(that);
					cb = true;
				}
			}
		}
		//Aufruf des Intervals, alternative Methode: Das erste Argument steht für das Binding sprich
		//welches Objekt innerhalb der geloopten Funktion als "this" gilt, zweites Argument ist die Funktion als String,
		// dann das übliche
		var fade:Number = setInterval(this, "fadeein", 100, step, limit);
	},
	//EventListener-Funktionen 
	addEventListener: function () {},
	removeEventListener: function () {},
	dispatchEvent: function () {}
}

//Initialisiert das Objekt als Dispatcher
mx.events.EventDispatcher.initialize(fadeObject);

//Funktion complete erhält als Argument das Event-Objekt, das dispatch wurde
function complete(obj: Object) {
	trace (obj.type);
	trace (obj.direccion);
	trace (obj.that);
	trace ("****");
}

//Fügt dem fadeObject einen Listener hinzu. Es können beliebig viele Listener hinzugefügt werden
fadeObject.addEventListener ("complete", complete);
fadeObject.fadeIt(test, "in");

Gruss
 
luke_the_duke! Erstmal danke für deine Lösung.
Ich muss leider zugeben, nicht verstanden zu haben, wie das mit dem EventDispatcher auf sich hat.
Leider habe ich den Umstieg auf AS3 noch nicht hinbekommen (liegt warscheinlich an meiner Unfähigkeit Klassen und Objekte zu verstehen).
Daher auch die nicht-Verwendung von Klassen. :)

Wie siehts denn aus, wenn ich einen MC faden möchte, der nicht auf _root liegt?
Geht dass dann per
Code: 
_root.fadeObject.addEventListener ("complete", complete);
_root.fadeObject.fadeIt(imagen, "out")
?

Oder ist das fadeObject-Objekt global ansprechbar?
Wie bekomme ich denn bei deiner Methode diesen complete-Bescheid um die nächste Funktion auszuführen bzw wo wird dieser Wert abgespeichert? Oder muss ich die complete-Funktion ändern?

nochmals Danke!
 
Hallo,

das fadeObjekt kannst du global machen, indem du eine globale Referenz darauf speicherst:
Code: 
_global.fadeObject = fadeObject;

Das Event-System funktioniert eigentlich ganz einfach:
Du hast einen Auslöser (Dispatcher), in deinem Fall das fadeObject. Dieser Auslöser feuert (dispatchEvent) unabhängig davon, ob es irgendjemanden interessiert, seine Ereignisse (Events), bei diesem Beispiel nun das complete-Ereignis. Nun kannst du irgendwelche Zuhörer (Listener) für ein bestimmtes Ereignis anmelden (addEventListener). Sie reagieren nur dann, wenn ihr Ereignis eintrifft. Diese Zuhörer sind in der Regel Funktionen. Das Tolle an diesem System ist, dass es dem Auslöser schnuppe ist, wer und wieviele Zuhörer angemeldet sind und auch wo sie sich befinden. Man muss einzig aufpassen, dass man die Zuhörer, die man angemeldet hat, auch wieder abmeldet, falls sie nicht mehr auf das Ereignis reagieren sollen (removeEventListener).

In deinem Fall kannst du nun dein (ev. globales) fadeObject mit irgendeiner MovieClip-Instanz aufrufen und x-beliebige Funktionen für das complete-Ereignis anmelden. Ein Beispiel:

Drei Funktionen, die drei völlig verschiedene Dinge tun
Code: 
function doSomething () {
     trace ("doSomething");
}

function doSomethingElse () {
     trace ("doSomethingElse");
}

function doSomethingTotallyDifferent () {
     trace ("doSomethingTotallyDifferent");
}
Nun meldest du all diese Funktionen als Zuhörer bei deinem globalen fadeObject an und zwar als Zuhörer des Ereignisses complete. Gäbe es ein weiteres Ereignis, sie würden es ignorieren.
Code: 
_global.fadeObject.addEventListener ("complete", doSomething);
_global.fadeObject.addEventListener ("complete", doSomethingElse);
_global.fadeObject.addEventListener ("complete", doSomethingTotallyDifferent);

Merke: Wo sich diese Funktionen befinden, ist egal. Wäre Funktion doSomething im MovieClip myMc.MyButton.myTween, müsste das Anmelde-Verfahren einfach diesen Referenz-Pfad beinhalten:
Code: 
_global.fadeObject.addEventListener ("complete", myMc.MyButton.myTween.doSomething);

Nun rufst du deine fadeObject-Funktion mit irgendeinem MovieClip auf:
Code: 
_global.fadeObject.fadeIt(myMc.MyButton, "in");

Wenn die Funktion nun das Ereignis "complete" feuert, werden alle drei Funktionen ausgeführt. Deine nächste Funktion müsstest du also entweder selbst anmelden oder über eine Zwischenfunktion aufrufen, welche du dann wiederum anmeldest.

Gruss
 
Ah, ich glaube ich verstehe so langsam!
Verstehe ich richtig, dass alle aktiven Lauscher reagieren sobald ein MC zu ende fadet?

Eine Sache bekomme ich nicht hin.... den eventListener zu löschen..
folgendes:
Code: 
//Funktion complete erhält als Argument das Event-Objekt, das dispatch wurde
function weiterMachen(obj: Object) {
	fadeObject.fadeIt(testMC2,"out",10);
	fadeObject.removeListener(testMC2);
	trace(obj.type);
}

//Fügt dem fadeObject einen Listener hinzu. Es können beliebig viele Listener hinzugefügt werden
fadeObject.addEventListener ("complete", weiterMachen);
fadeObject.fadeIt(testMC1, "in",6);
traced immer wieder complete
und hört nicht auf... .

Tausend Dank!
 
Zuletzt bearbeitet:
Hallo,

ganz genau. Zumindest in diesem konkreten Fall. Du kannst ja eigene Events dispatchen, indem du dispatchEvent ausführst, z.B. ein update-Event, der bei jedem Loop gefeuert wird usw.
Die Funktion heisst removeEventListener und nicht removeListener. Dann sollte es eigentlich klappen.

Gruss
 
Um antworten zu können musst du eingeloggt sein.

Neue Beiträge

Zurück