Herausforderung für Flashperten!! Parser, 5-dim. Navigation

[Neutrino]

Hallo!
Ich habe ein riesen Problem und bin schon total verzweifelt!
Hoffentlich könnt ihr mir weiterhelfen.

Ich bin dabei, eine verschachtelte Navigation (Menütiefe: 5) auszulesen
und diese durch Flash auf den Screen zu bringen.

Dazu baue ich eine Art Parser, der mir die Struktur (durch Tabs und ~ getrennt)
in ein 5-dimensionales Array konvertiert.

Manche meinen jetzt bestimmt, ein 2-dimensionales hätte es auch getan, allerdings
würde dadurch die spätere Ausgabe viel schwieriger werden.

Es ist nämlich geplant, beim Drücken auf einen Menüpunkt alle nachfolgenden "auszuklappen".
Bei einem zweidimensionalen Array müsste ich dann jedesmal überprüfen, wieviele Unterpunkte
in einem "Paket" stecken.
Bei der Mehrfach-Array-Methode wüsste ich das einfach durch "array.length".

Ich habe schon etwas programmiert, allerdings funzt das noch nicht richtig
(Bei der Ausgabe vertauscht er spalte 2 mit 1)

BITTE BITTE helft mir weiter!
Danke im voraus!

P.S.: Zum richtigen Betrachten des Codes in Flash solltet Ihr übrigens in der Skript-
Ansicht eine Monotype-Schrift, wie Lucida_Console benutzen.

spalten = [];
anz = [];
 
function einlesen(zeile){
        //// Zeile für Zeile, String für String auslesen
        // wenn tab   : eine spalte weiter (spalte++;)
        // wenn ~     : ein zeichen weiter
        
        
        spalte = 1;
        // Zeichen für Zeichen vorwärts:
        //  mp.slice(-1) ====== letztes element
        for (i=0; i<= zeile.length; i++){
                if (zeile.substr(i,1) <> "~")
                {
                        // Neue Spalte:
                        if ((zeile.substr(i,1) == "\t") or (i == zeile.length))
                        {
                                if (wort_temp <>"")
                                {
                                        anz[1] = _root.mp.length-1; // Anzahl der Elemente innerhalb eines arrays
                                        anz[2] = _root.mp[anz[1]].length-1;
                                        anz[3] = _root.mp[anz[1]]._root.mp[anz[2]].length-1;
                                        if (spalte == 1)
                                        {
                                                if (_root.mp[0] == undef) {_root.mp = new Array();}
                                                _root.mp.push(wort_temp);
                                        }
                                        if (spalte == 2)
                                        {
                                                if (_root.mp[anz[1]][0] == undef) {_root.mp[anz[1]] = new Array();}
                                                _root.mp[anz[1]].push(wort_temp);
                                        }
                                        if (spalte == 3)
                                        {
                                                //  usw
                                                //  usw
                                        }////if (spalte == 3)
                                        
                                        if (spalte == 4)
                                        {
                                        }////if (spalte == 4)
                                        if (spalte == 5)
                                        {
                                        }////if (spalte == 5)
                                        wort_temp = "";
                                }
                                spalte++;
                        }
                        else
                        // Wort zusammensetzen
                        {
                                wort_temp+= zeile.substr(i,1);
                        }
                }
        }
}
 
//        spalte 1          spalte 2    spalte 3    spalte 4
einlesen("mp[0]~~~~~~~~~~~~ mp[0][0] mp[0][0][0]");
einlesen("~~~~~~~~~~~~~~~~~ ~~~~~~~~ mp[0][0][1]");
einlesen("~~~~~~~~~~~~~~~~~ ~~~~~~~~ mp[0][0][2]");
einlesen("~~~~~~~~~~~~~~~~~ ~~~~~~~~ mp[0][0][3]");
einlesen("~~~~~~~~~~~~~~~~~ ~~~~~~~~ mp[0][0][4]");
einlesen(" mp[1]~~~~~~~~~~~~    mp[1][0]    mp[1][0][0] mp[1][0][0][0]");
einlesen(" ~~~~~~~~~~~~~~~~~    ~~~~~~~~    ~~~~~~~~~~~ mp[1][0][1][1]");
einlesen(" ~~~~~~~~~~~~~~~~~    ~~~~~~~~    ~~~~~~~~~~~ mp[1][0][2][2]");
einlesen(" ~~~~~~~~~~~~~~~~~    mp[1][1]    mp[1][1][0] mp[1][1][0][0]");
einlesen(" ~~~~~~~~~~~~~~~~~    ~~~~~~~~    ~~~~~~~~~~~ mp[1][1][0][1]");
 
trace("spalte 1:");
trace(_root.mp[0]);
trace(_root.mp[1]);
trace("spalte 2:");
trace(_root.mp[0][0]);
trace(_root.mp[1][0]);
trace("spalte 3:");
trace(_root.mp[0][0][0]);
trace(_root.mp[1][0][0]); 

[Neutrino]

Hallo, nochmal,


habe nochmal ein bisschen rumprobiert.
Es scheint ein grundsätzliches Problem mit dem Array zu sein,
siehe folgendes Progrämmchen:

mp = [[]];
 
mp[0][0] = "[0][0]";
trace (mp[0][0]); // Ausgabe: [0][0], Super, wunderbar!
 
mp[0] = 1;
trace (mp[0]); // Ausgabe: 1, so wie´s sein soll
 
trace (mp[0][0]); // Selber Befehl wie Zeile 4, Ausgabe: undefined, Sch*** 
 

Ergo: Wird mp[0] als eindimensionales Array angesprochen, wird die dahinter
liegende 2-dimensionalen (bzw. n-dimensionalen) Werte überschrieben!!!

Ich dachte, ich könnte die mehrdimensionale Struktur nach und nach aufbauen,
also bei jedem Menüpunkt, den ich einparse, hinzuzufügen.
Anscheinend werden aber dadurch einige Punkte wieder gelöscht.

Kann das sein? Stelle ich mich nur dämlich an? Welche andere Möglichkeit gäbe es?

Könnte ich evtl. die Punkt-Notation nutzen?
Also sowas wie: _root.mp.spalte1.spalte2.spalte3.usw...??

Ein verzweifelter Newbie :-)

[NastyFrog]

Also wenn du aufbauen willst, dann nimm push(wert). Dann werden die Werte hinten angereiht. arr[0].push("hallo")

[secp]

Ich glaub du stellst dich nur ...

schau mal die ausgabe:

mp = [[]];
 
mp[0][0] = "[0][0]";
trace (mp[0][0]); // Ausgabe: [0][0], Super, wunderbar!
 
trace( mp[0] ); 

mit ... = 1 würdest du ein array wieder überschreiben

[Neutrino]

Hallo!

Vielen Dank an alle!
Ich habe mich jetzt damit abgefunden, das ganze doch in einer 2d-struktur zu machen.

gruß,
neutrino