verzögernd aufbauende Matrix via MovieClip.prototype & "außenliegendes" Memory-Array

[pumaman]

Hallo,

ich hoffe, jemand kann mir helfen. Die folgende Funktion ermöglicht es, eine 2D-Matrix (in meinem Fall aus leeren Quadraten) zeichnen zu lassen, bei der jedes Quadrat zeitverzögert angezeigt wird. Das funzt auch soweit.

Was ich nun aber möchte, ist, den Instanznamen eines jeden Quadrats, das via attachMovie "angeheftet" wird, in einem "Memory"-Array zu speichern, damit ich später darauf zugreifen kann (zB wenn ich alle Quadrate wieder von der Bühne entfernen möchte).

Was ich aber absolut nicht hinkrieg, ist, dieses Memory-Array aus dem Prototyp heraus anzusprechen. Geht das überhaupt? Sind wir da schon in OOP?

So sieht der Code bis jetzt aus:

PHP-Code:

// Das soll ds Memory-Array sein:
remListeQ = new Array();

// diese funk löscht das Memory-Array
function killMemory(welchesArray) {
    for (var j in welchesArray) {
        welchesArray[j].removeMovieClip();
        welchesArray.pop();
trace("Length: "+welchesArray.length);
    }
}

// memory-Array mit Instanznamen füllen
function populateArray(welchesArray, clipPfad) {
    welchesArray.push(clipPfad);
trace("Length: "+welchesArray.length);
}
//
//
Movieclip.prototype.createMatrix = function(ebene, neueClipID, xPos, yPos, anz1, dist, proZeile, intv, welchesArray){
    this.ebene = ebene;
    this.neueClipID = neueClipID; // Instanzname des Quadrats
    this.xPos = xPos;
    this.yPos = yPos;
    this.anz1 = anz1;
    this.dist = dist;
    this.proZeile = proZeile;
    this.intv = intv; // Verzögerung
    this.welchesArray = welchesArray; // ?????
    this.counter = 0;
    this.divisor = 1;
    //
    var myID = setInterval(function (objekt) {
        // creating instance to container movieclip
        var ref = objekt;
        //
        if (ref.ebene<=ref.anz1) {
            xOffSet = 25*ref.counter;
            //
            if ((ref.ebene/proZeile) == (ref.divisor)) {
                _this.movieRoot.h++;
                xOffSet = 0;
                yOffSet += 25;
                ref.divisor++;
                ref.counter = 0;
            }
            trace("Ebene: "+ref.ebene);
            // attach and pass init object
            var tmp = ref.attachMovie(ref.neueClipID, ref.neueClipID+ref.ebene, ref.ebene+20, {_x:ref.xPos+xOffSet, _y:ref.yPos+yOffSet});
            // NÄCHSTEN 2 ZEILEN: HIER: ?????
            _root.populateArray(welchesArray, (ref.neueClipID+ref.ebene));
            trace("welchesArray: "+_root.welchesArray());
            //
            ref.ebene++;
            ref.counter++;
        } else {
            clearInterval(myID);
        }
    }, this.intv, this);
    // Y-OffSet wieder auf Null setzen
    yOffSet = 0;
};
// creating menu_container_mc
this.createEmptyMovieClip('menu_mc', 1);
//
mc1.onRelease = function() {
    // function(ebene, neueClipID, xPos, yPos, anz1, dist, proZeile, intv, welchesArray)
    menu_mc.createMatrix(0, 'quader', 10, 10, 19, 25, 5, 80, remListQ);
}; 


Ich bitte um Hilfe!
Danke!

[Janoscharlipp]

also hier

_root.populateArray(welchesArray, (ref.neueClipID+ref.ebene)); 

solltest du für welchesArray natürlich _root.remListeQ einsetzen, um eine Referenz zu erhalten, solltest du statt ref.neueClipID+ref.ebene eher schreiben:
_root[ref.neueClipID+ref.ebene]

[pumaman]

Danke dir! Bin froh, dass man aus prototypen heraus andere Funktionen ansprechen kann... war da schon in Sorge.

[pumaman]

Es ergibt sich nun ein weiteres Problem: Die mcs werden derzeit zeitverzögert aufgebaut und auch im MemoryArray gespeichert. Eine eigene Funktion deleteMemory ermöglicht es mir nun auch, diese mcs ebenso zeitverzögert wieder von der Bühne verschwinden zu lassen (was einen ganzen netten Effekt ergibt):

PHP-Code:

// Matrix wieder löschen
Movieclip.prototype.deleteMatrix = function(intv, welcheRemList){
    trace("\n**********************************\nDELETE MATRIX "+welcheRemList+" called");
    this.intv = intv; // Verzögerung
    this.welcheRemList = welcheRemList;
    //
    var myDeleteID = setInterval(function(objekt) {
        // erzeuge Instanz zum container mc
        var referenz = objekt;
        anzahl = referenz.welcheRemList.length;
        trace("Array Anzahl: "+anzahl);        
        //
        if (anzahl != 0) {
            trace("remListLength vorPop: "+referenz.welcheRemList.length);
            trace("MovieClip to remove: "+referenz.welcheRemList[anzahl-1]);
            // DoppelArray: (im Folgenden)
            // referenz hat [], weil 
            // und welcheRemList ist ein Array, dessen Elemente nur über [] angesprochen werden können
            referenz[referenz.welcheRemList[anzahl-1]].play();
            referenz.welcheRemList.pop();
            anzahl--;
            //
            trace("remListLength nachPop: "+referenz.welcheRemList.length);            
            trace("Anzahl "+anzahl);
            return "weiter=0";
        } else {
            clearInterval(myDeleteID);
            return "weiter=1";
        }
    }, this.intv, this);
}; 


Wie man sich vielleicht vorstellen kann, soll die Matrix immer dann neu aufgebaut werden, wenn man auf einen Button druckt. Nachdem über diese Buttons aber immer verschiedene Anzahlen von Quadraten weitergeleitet werden, muss ich zunächst die alten auf der Bühne befindlichen Quadrate löschen (via dem MemoryArray) und dann die neuen aufbauen lassen. D.h. für mich:

1. Checken, ob das fragliche MemoryArray leer ist oder Einträge besitzt
2. Wenn Einträge vorhanden sind, die deleteMatrix aufrufen
3. erst wenn die (ebenfalls zeitverzögerte) deleteMatrix fertig ist, die createMatrix aufrufen

Das zu lösen ist allesdings ein Problem für mich. Bisher habe ich mich mit return-Werten beschäftigt, die in der If-Schleife der deleteMatrix-func zu sehen sind: return "weiter=0" bzw. return "weiter=1", allerdings weiß ich echt nicht, wie man diese return-Werte weiterverwertet (weiß nur, wie man sie in ein Textfeld schickt...).

2 Möglichkeiten hab ich durchprobiert:

1. die Anweisung am Button selbst damit "hinzuhalten":

PHP-Code:

mc_q1.onRelease = function() {
    if(_thisMovieRoot._remListQ.length != 0){
        trace("RemListQ NICHT ist leer");
        _thisMovieRoot.deleteMatrix(80, remListQ);
    } else {
        trace("RemListQ ist leer");
        // WERTE: level, neueClipID, neuerClipName, xPos, yPos, anz1, anz2, dist, proZeile, intv, alphaWert, absAlpha, welcheRemList
        _thisMovieRoot.createMatrix(0, 'quader', 'q_', 660, 0, 24, 11, 25, 5, 80, 20, 100, remListQ);
    }
    
};
// andere "Kontroll-BTNS"
mc_q0.onRelease = function() {
    // function(intv, welcheRemList)
    _thisMovieRoot.deleteMatrix(80, remListQ);
};
mc_qRemList.onRelease = function() {
    trace("display RemListQ: "+remListQ);
}; 


2. in der createMatrix ziemlich gleich am Anfang:

PHP-Code:

...
this.alphaWert = alphaWert;
    this.absAlpha = absAlpha;
    this.counter = 0;
    // checken if array leer ist
    if (this.welcheRemList.length != 0) {
        trace("LENGTH: "+this.welcheRemList.length);
        _thisMovieRoot.deleteMatrix(20, this.welcheRemList);
    }
    //
if(weiter=1){
var myID = setInterval(function (objekt) { 
... 


Nachdem der erste Aufbau der Matrix erfolgt ist, wird bei beiden Lösungen das fragliche Array immer als NICHT LEER erkannt und sodann die deleteMatrix auch ausgeführt - ABER: die createMatrix dafür nicht mehr. Und wenn ich in weiterer folge auf einen createMatrix-BTN klicke, wird das Array weiterhin als NICHT LEER erkannt, obwohl es gerade geleert wurde...

Kann mir da jemand einen Tipp geben? (Vorzugsweise für die BTN-Lösung, weil ich ganz gerne die Funktionen unangetastet lassen möchte...)

Danke schon mal fürs Bis-hierher-lesen und überhaupt im Voraus!

[pumaman]

Kann hier niemand helfen? Zumindest die return-Wert-Geschichte wär schon eine große Hilfe!