diverse Intervalle und deren Ende

Hidiho. Ich versuche gerade per AS dyn. Navigationselemente zu erzeugen. Das ganze soll per attachMovie passieren. Ich möchte nun, dass sich diese Elemente nach einem bestimmten Schema aufbauen: sie sollen einblenden und der"Labeltext" soll drauftickern.
Das passiert über Funktionen, die in bestimmten Intervallen aufgerufen werden, damit das ganze noch zusätzlichen "Aufbau-Charme" erhält.
Das klappt auch alles schon (ansatzweise):

System.useCodepage = true;
loadVariablesNum("testvars.txt", 0);
//loadVariablesNum("testvars.php", 0);
//--------------- Intervall Functions ---------------\\
initInterval = function (id, funktion, interval, p1, p2, p3, p4, p5) {
    _root.IDnr = id;
    _root["dynID"+id] = setInterval(funktion, interval, p1, p2, p3, p4, p5);
};
killInterval = function () {
    clearInterval(_root["dynID"+IDnr]);
};
//--------------- Blend Function ---------------\\
blenden = function (art, ziel) {
    switch (art) {
    case "aus" :
        ziel._alpha--;
        if (ziel._alpha<=0) {
            killInterval();
        }
        break;
    default :
        ziel._alpha++;
        if (ziel._alpha>=100) {
            killInterval();
        }
    }
    trace("blendenIntervall");
};
//--------------- Ticker Function ---------------\\
var charCount = 0;
ticker = function (txt, zielfeld) {
    var allChars = (txt.length+1);
    if (charCount<=allChars) {
        zielfeld.label = txt.substr(0, charCount);
        charCount++;
    } else {
        killInterval();
        charCount = 0;
    }
    trace("tickerIntervall");
};
//--------------- Initiate Content Navigation ---------------\\
var n = 0;
var gn = 5;
var sY = 80;
conNavi = function () {
    if (n<gn) {
        _root.attachMovie("mc_nav_balken", ["newBtn"+n], n);
        _root["newBtn"+_root.n]._y = sY;
        _root["newBtn"+_root.n]._x = 50;
        _root["newBtn"+_root.n]._alpha = 0;
        initInterval(random(99999), blenden, 10, "ein", _root["newBtn"+n]);
        initInterval(random(99999), ticker, 200, _root["n"+n], _root["newBtn"+n]);
        sY += 20;
        n++;
    } else {
        sY = 80;
        killInterval();
    }
    trace("conNaviIntervall");
};
stop(); 

Das Problem dabei ist, dass ich die Intervalle nach Vollendung ihrer Arbeit löschen möchte, aber irgendwie bekommen sich die Intervalle so in die Haare, dass die blenden-Funktion nicht bis zum Ende ausgeführt wird und alle andere Intervalle einfach weiterlaufen.
Nun frage ich mich, wie lös ich das, bzw. wo hab ich nen Fehler?!

Überprüf mal die IDnr in der killInterval-Funktion. Woher kommt diese Variable? Evtl. solltest du es mal mit _root.IDnr versuchen oder der Funktion die richtige IDnr als Parameter übergeben.

hm... habe jetzt mal die funktion geändert:

//--------------- Intervall Functions ---------------\\
id = 1;
kid = 1;
initInterval = function (id, funktion, interval, p1, p2, p3, p4, p5) {
    _root.IDnr = _root.id;
    _root["dynID"+id] = setInterval(funktion, interval, p1, p2, p3, p4, p5);
    _root.id++;
};
killInterval = function () {
    clearInterval(_root.kid);
    _root.kid++;
}; 

aber das haut auch nicht hin... irgendwie sprengt das meinen intellekt....
wie muss ich denn das anlegen, dass ich mehrere instanzen der funtionen in verschiedenen intervallen ausführen kann und diese nach ablauf wieder löschen?!

so , ich hab aufgegeben. anderer versuch:
auf nem button liegt der aufruf:

on (release) {
    _root.portfolio = setInterval(conNavi, 125, _root.portfolio);
} 

nun möchte ich in der funktion die übergebene variable (_root.portfolio) das entsprechende interval löschen:

conNavi = function (iid) {
    if (n<gn) {
        _root.attachMovie("mc_nav_balken", ["newBtn"+n], n);
        newName = _root["newBtn"+_root.n];
        ....
        n++;
    } else {
        clearInterval(iid);
    }
}; 

Wird aber nicht gelöscht, woran könnte das liegen?

[nky]

ich lösch meine Intervalle imme rso - und das funzt auch


a=setInterval.....

clearInterval(a).....


das sollte klappen !!!

Gruss nky

[RustyCake]

Yo nky zustimm!!

move = function (mc) {
    mc._x += 5;
    mc._y += 5;
    if (_root.move_mc._x>=200) {
        mc._x = 200;
        mc._y = 200;
        mc._xscale += 10;
        mc._yscale += 10;
    }
    if (mc._xscale>=300 && mc._yscale>=300) {
        clearInterval(Mover_ID);
    }
};
var Mover_ID = setInterval(move, 20, _root.move_mc); 

so löscht ma sauber Intervale

super, aber wenn ich das clearInterval in der funktion integriert haben möchte und gleichzeitig aber die variable zum clearen dynamisch halten möchte, wie gehe ich denn dann vor?

[nky]

wo ist das Problem - du kannst doch den bezeichner dynamisch wählen ....mußt ihn nur irgendwo zwischenspeichern...

noch dynamischer gehts doch schon fast gar nimma ...

könntest vielleicht ein array mit intervallbezeichnern machen ...
und die immer raus und rein poppen..
dann hättest du die volle Kontrolle ....
über die verfügbaren Bezeichner

Gruss nky


edit : zum clearen könntest du dann einfach das array durchlaufen und alle aktiven bezeichenr löschen.....ich merke gerade das man das voll fett ausbauen kann *g

was ich aber nach euren vorschlägen (abgesehen von dem mit dem array, damit müsste ich mich erstmal länger auseinander setzen) nicht verstehe ist, dass wenn ich z.b. diese funktion

conNavi = function () {
    if (n<gn) {
        _root.attachMovie("mc_nav_balken", ["newBtn"+n], n);
        newName = _root["newBtn"+_root.n];
        newName._y = sY;
        newName._x = 50;
        newName._alpha = 0;
        newName.label = _root["n"+n];
        xyz = setInterval(blenden, 15, "ein", newName);
        newName.onRelease = function() {
            trace("RELEASE");
        };
        newName.onPress = function() {
            trace("PRESS");
        };
        sY += 20;
        n++;
    } else {
        sY = 80;
        clearInterval(portfolio);
        trace("ende");
    }
}; 

habe und diese funktion ruft dann 5 mal diese funktion auf

blenden = function (art, ziel) {
    switch (art) {
    case "aus" :
        ziel._alpha--;
        if (ziel._alpha<=0) {
            clearInterval(xyz);
            trace("laeuft noch");
        }
        break;
    default :
        ziel._alpha++;
        if (ziel._alpha>=100) {
            clearInterval(xyz);
            trace("laeuft noch");
        }
    }
}; 

dann bekommen sich die clearIntervals in die haare und es läuft einfach weiter. ist ja auch logisch, da xyz ja nachdem es einmal gelöscht wurde weg ist und nichts mehr gelöscht werden kann, oder seh ich das falsch?

zu der array variante: krieg ich n tipp, wie das ungefähr geht? ich hab heute keine energie mehr, darüber nachzudenken

[nky]

wenn du dei intervalle verwalten willst - dann bau dir halt die entsprechende struktur ..
ich würd das ganze ungefähr so angehen

ein array mit den möglichen Intervallnamen

eine funktion zum name holen - und eine zum namen schreiben

also getItnervalName & setInterVallName

wenn du den namen holst mußt du ihn aus dem array löschen..

und wenn du iden interval löschst - dann schreibst du den "freigegebenen" namen wieder ins array....so kannst du sichergehen - das sich keine intervalle überschreiben..

evtl kannst du sogar noch ein array machen indem du die derzeit aktiven intervalle einträgst Dann fällt das löschen später leichter...

Gruss nky

[rniessner]

Nur der Vollständigkeit halber:

Ich hatte das selbe Problem, daß die Intervalle einfach nicht zu stoppen waren. Die Lösung ist allerdings einfach:

wenn man die Variable zur Speicherung der Intervall-ID erzeugt, ist diese natürlich nur lokal in der Funktion ansprechbar, d.h. in der Funktion wo clearInterval() aufgerufen wird, ist die Variable leer!

Das umgeht man, indem man die Variable als _global definiert.

Nur so als Beispiel ein Ablauf, der ein MC einblendet, nach 5 Sekunden wieder ausblendet und dazwischen keine weiteres Einblenden erlaubt.

// Stage mit 25fps
 
// Start der ganzen Geschichte, ev. auf einer Schaltfläche liegend
if (_global.einblendenIntervall == undefined) {
                _global.einblendenIntervall = setInterval(einblenden, 40, "meinMovieclip");
}
 
 
function einblenden(objekt) {
    if (_root[objekt]._alpha < 100) {
        _root[objekt]._alpha += 10;
    } else {
        _root[objekt]._alpha = 100;
        clearInterval(_global.einblendenIntervall);
        _global.timerIntervall = setInterval(timer, 5000);
    }
}
 
function ausblenden(objekt) {
    if (_root[objekt]._alpha > 0) {
        _root[objekt]._alpha -= 10;
    } else {
        _root[objekt]._alpha = 0;
        _global.einblendenIntervall = undefined;
        clearInterval(_global.ausblendenIntervall);
    }
}
 
function timer() {
    _global.ausblendenIntervall = setInterval(ausblenden, 40, "meinMovieclip");
    clearInterval(_global.timerIntervall);
}