setInterval -> Interval per Variable steuern?

[bestboy]

moin,

gibt es irgendeine Möglichkeit, unter ActionScript bei setInterval das Intreval per Variable zu steuren bzw. zu verändern? Ich hab hier nämlich verschiedene Aktionen, die der Reihe nach, aber mit unterschiedlichen Zeit-Abständen ausgeführt werden sollen. Quasi die erste nach 3 Sekunden , die zweite nach 5 Sekunden, die dritte nach 2 Sekunden usw.

Mein Problem ist, dass meine Variable "intervalzeit" beim ersten Interval ganz ignoriert wird, die Aktion wird also sofort ausgeführt.
Bei den anderen Interwal nimmt sich Flash immer den Anfangswert und nicht die Werte, die ich in meiner Funktion immer wieder neu ausgebe.

Hier der aufs wesendliche reduzierte AS-Code:

count = 1;
intervalzeit = 1000;
function lieblingsfunktion() {
	switch (count) {
	case 1 :
		trace("case 1");
		intervalzeit = 2000;
		nextcase = 2;
		count = 0;
		hans._x = 300;
		break;
	case 2 :
		trace("case 2");
		intervalzeit = 3000;
		nextcase = 1;
		count = 0;
		hans._x = 200;
		break;
	default :
		break;
	}
}
function counter() {
	count = nextcase;
}
testinterval = setInterval(counter, intervalzeit);
updateAfterEvent();
onEnterFrame = lieblingsfunktion;

Ich hab ja die Vermutung, dass man das Interval nicht nachträglich ändern kann. Ab dem Zwiten durchlauf wird dann nur die der Wert der als erstes definierten Variable genommen, da vorher kein Interval angegeben war.

Was ist an meiner Vermutung dran? Geht das, was ich vorhabe überhabt? Wenn ja, was hab ich falsch gemacht?


Grüße
Bestboy

[rendner[i]]

Der Aufruf von "updateAfterEvent" ist an der Stelle Sinnlos.
Wenn man ein Intervall mit "setInterval" erstellt kann man die Zeit nicht ändern da du ihm ja keine Referenz auf die Variable übergibst sondern den Wert der Variablen.
Wenn du aber das Intervall eventuell nach einer anderen Zeit starten willst musst du es mit clearInterval( ... ) löschen und ein neues starten.

[bestboy]

das heißt in meinem fall dann, ich starte erst ein interval mit § Sekunden, lösche es und starte aus dem interval ein neues mit 5 Sekunden usw.

Richtig?

[rendner[i]]

Ja, sobald du das Intervall in anderen Abständen ablaufen lassen willst als wie du es erstellt hast dann musst du dieses löschen und ein neues mit deinem gewünschtem Wert setzen.

Wie oft wird den so ein Intervall von dir ausgeführt bevor es eine andere Zeitspanne erhält?

[bestboy]

Das würde jewils 1mal ablaufen, bzw. wenn alle Zeitspannen durch sind, ginge das halt wieder von vorne los.
Die Reihe der verschiedenen Zeitspannen möchte ich am liebsten zufällig festlegen.

Ist ein Interval dafür denn überhaubt zu empfehlen, oder würdest du das anders lösen?

[rendner[i]]

Ich würde eine Funktion setTimeOut schreiben die quasi ein Intervall nur einmal ausführt und dieses automatisch löscht.

Oder halt 3 Intervalle starten aber dann so das es wirkt als würde man dauernd zwischen diesen wechseln, also die Zeitspanne vergrössern.

Da du es aber dynamisch haben willst ist Variante 1 besser...

[bestboy]

Du würdest also eine Funktion schreiben, die sich immer wieder per Interval selbst aufruft, richtig?

Ich weis nicht so ganz, wie ich das angehen soll, aner ich versuchs mal und schreib das ergebnis hierein, oder meld mich wenns nicht klappt.

[bestboy]

Okay, hier mal mein Versuch. Ich hab zwei Intervalle gebraucht: 1 Kick-Off Intervall, welches die Function zumersten mal aufruft und dann halt Das aus der setTimeOut-Function.

time = 100;
kickOff = setInterval(setTimeOut, 200);
function setTimeOut() {
	clearInterval(timeOut);
	trace("tach "+time);
	time *= 2;
	timeOut = setInterval(setTimeOut, time);
	clearInterval(kickOff);
}

Kann man das noch vereinfachen?

[rendner[i]]

Naja ne setTimeOut hatte ich mir eher so vorgestellt:

PHP-Code:

function setTimeOut()
{
    arguments.push( arguments[ 0 ] );
    
    arguments[ 0 ] = function()
    {
        clearInterval( Number( arguments.pop()[0] ) );
        arguments.pop().apply( null, arguments );
    }

    var id = [];
    arguments.push( id );
    id.push( setInterval.apply( null, arguments ) );
}

var interval = function() { trace("Intervallfunktion aufgerufen"); }

setTimeOut( interval, 1000 ); 


Sieht ziemlich wild aus, der eigentliche Trick dabei ist, das man die Funktion die aufgerufen werden soll nochmal ins Array arguments ( mal in der Flashhilfe dannach gucken, dieses Array besitzt jede Funktion ) hinten einfügt und vorne mit einer Funktion überschreibt.
Diese ( neue ) Funktion löscht dann quasi das Intervall und ruft die gewünschte Funktion dann auf.

Nachteil bei dieser Variante solche Aufrufe funktionieren leider nicht:

PHP-Code:

var obj = new Object();
obj.func = function(){ trace( "Freibier für alle!" ); };
setTimeOut( obj, "func", 1000 ); 


Aber vielleicht fühlt sich einer inspiriert und baut das noch mit ein ( ich finds nämlich ganz schön lecker ).

Und wenn du willst das deine Funktion schon vorher einmal aufgerufen wird dann müsstest du das so machen:

PHP-Code:

// vorher selber aufrufen
interval();
// dann noch einmal durch setTimeOut
setTimeOut( interval, 1000 ); 


[bestboy]

Das ich nicht das allerbeste SctionScript schreibe, is mir klar. Ich bin eher Gestalter und als Programmierer.Mein Script hat gegenüber deinem für mich den Vorteil, das ich es verstehe

Bei deiner Variante Blick ich irgendwie nicht durch. Insbesondere verstehe ich nicht, wie da immer wieder ein neues Intervall gestartet wird?!
Ich möchte das nur ungerne blind rüberpasten...

[rendner[i]]

Insbesondere verstehe ich nicht, wie da immer wieder ein neues Intervall gestartet wird?!

Da kommst du ja jetzt ins Spiel, die Funktion setTimeOut habe ich so geschrieben das sie wie setInterval funktioniert und dieses aber nur 1 mal ausgeführt wid.
Nun kannst du das mit deinen verschiedenen Zeitwerten steuern ohne das du Intervalle selber löschen musst.
Darum ging es dir doch, oder ?

[rendner[i]]

Hier nochmal eine überarbeitet Version die jetzt genauso wie das setInterval funktionieren müsste ( von der Parameterübergabe ).

PHP-Code:

function setTimeOut() 
{ 
     var id = []; 
    var arg = arguments;
    var fIndex = ( typeof arg[ 0 ] == "function" ) ? 0 : 1;

    arg.push( ( fIndex == 1 ) ? arg.shift()[ arg[ 0 ] ] : arg[ 0 ] ); 
     
    arg[ 0 ] = function() 
    { 
        clearInterval( Number( arguments.pop()[0] ) ); 
        arguments.pop().apply( null, arguments ); 
    }
    
    arg.push( id ); 
    id.push( setInterval.apply( null, arg ) ); 
} 

// Testaufruf:
var o= new Object;
o.eins = function( w ) { trace( "o.eins " + w ); }

function zwei( w ) { trace( "zwei " + w ); }

setTimeOut( o, "eins", 1000, "hallo!" );
setTimeOut( zwei, 1000, "hallo!" ); 


Und hier die etwas auskommentierte Version:

PHP-Code:

function setTimeOut() 
{ 
    // leeres Array in dem die IntervallID gespeichert wird
     var id = []; 
    
    // ein Referenz auf arguments in arg speichern da das weniger schreibarbeit ist ;)
    var arg = arguments;    
    
    // pruefen ob an 1ter oder 2ter Stelle im Array die Funktion steht die 
    // aufgerufen werden soll
        // Bsp.: setTimeOut( zwei, intervalzeit, "hallo!" );      -> Funktion an 1ter Stelle
        // Bsp.: setTimeOut( o, "eins", intervalzeit, "hallo!" ); -> Funktion an 2ter Stelle
    var fIndex = ( typeof arg[ 0 ] == "function" ) ? 0 : 1;    

    // jetzt die eigentlich gewuenschte Funktion nochmals hinten in das Array arg
    // einfuegen
        // ( fIndex == 1 ) ? arg.shift()[ arg[ 0 ] ] : arg[ 0 ] )
        // bedeutet: wenn die Funktion an 2ter Stelle stand ( beim Aufruf von setTimeOut ) 
        // dann entferne das 1te Element aus dem Array ( an der Stelle 0 ! ) und "Verknüpfe" 
        // dies mit dem Elemet was an Stelle 0 nachgerueckt ist 
        // ( waere dann ja die Funktion die vorher an Stelle 1 im Array stand )
        // und trage dieses in das Array hinten ein
        
        // wenn die Funktion nicht an 1ter Stelle stand ( beim Aufruf von setTimeOut )
        // dann trage das 1te Element ( == die Funktion ) des Array's arg hinten ein
    arg.push( ( fIndex == 1 ) ? arg.shift()[ arg[ 0 ] ] : arg[ 0 ] ); 
     
    // ueberschreibe die Referenz auf die "original" Funktion
    // da wir ja mit dem Intervall diese Funktion die jetzt in arg[0] gespeichert wird 
    // aufrufen wollen, die nix anderes macht als das Intervall zu loeschen
    // und danach die Funktion aufzurufen die Eigentlich dem setInterval 
    // Befehl uebergeben werden sollte
    arg[ 0 ] = function() 
    { 
        // da wir ja das Array id auch noch im Array arg gespeichert haben
        // enthaelt das Array arguments dieser Funktion dieses auch an letzter Stelle
        // das kann man mit pop einfach entfernen und da es ein Array ist muss angegeben 
        // werden welches Element dieses Array's die gewuenschte Referenz auf das Intervall hat
        clearInterval( Number( arguments.pop()[0] ) ); 
        
        // hier holen wir wieder das letzte Element aus dem Array, das ist jetzt die
        // eigentliche Funktion die wir aufrufen wollen und uebergeben ihr den restlichen Inhalt 
        // des Array's als Parameter
        arguments.pop().apply( null, arguments ); 
    }
    
    // eine Referenz des noch leere Array's id in arg speichern
    arg.push( id ); 
    
    //den Befehl setInterval starten und mit apply das Array arg uebergeben
        // apply zerlegt ein Array so, als wuerde man die einzelnen Elemente des Arrays
        //selber als einzelne Parameter der Funktion uebergeben
        // Bsp.: array[ 100, "a" ],   function.apply( null, array )
        // ist das "gleiche" wie: function( 100, "a" );
    // die Referenz die setInterval zum spaeten loeschen zurueckgibt im Array id speichern
    id.push( setInterval.apply( null, arg ) ); 
} 


[bestboy]

Hattest du das Script schon fertig, oder hast du die extra geschrieben?

Bei dem Script, welches du als letztes gepostet hast, sind zuviehel Befehle, die mir neu sind. Von daher hab ich das erste für meine Zwecke umgeschrieben:

PHP-Code:

intervalzeit = 1000;
function setTimeOut() {
    arguments.push(arguments[0]);
    arguments[0] = function () {
        clearInterval(Number(arguments.pop()[0]));
        arguments.pop().apply(null, arguments);
    };
    var id = [];
    arguments.push(id);
    id.push(setInterval.apply(null, arguments));
}
var interval = function () {
    trace(intervalzeit);
    trace("Intervallfunktion aufgerufen");
    intervalzeit *= 2;
    setTimeOut(interval, intervalzeit);
};
setTimeOut(interval, intervalzeit); 


Kann man das so machen?

Du warst übrigens vollkommen zurecht skeptisch, was meinen ersten SetTimeOut-Versuch anbelengt, die Funktion war nämlich dafür verantwortlich dafür, das mein Film den Prozessor ausgelastet hat.

[rendner[i]]

Kann man das so machen?

Ich denke schon .
Jetzt müsstest du halt nur noch sehen das er zwischen deinen gewollten werten "pendelt".