Labyrinth erstellen

Stromberg

Ich hab in eine Klasse namens "neuer_weg" in dieser gibt es eine Methode namens "Weg_erstellen". Die Methode "Weg_erstellen" soll mit Hilfe des Arrays "Karte[25][80]" ein zufälliges Labyrinth erstellen. "0" steht für KEIN WEG, "1" steht für WEG.
Anfangs wird eine Zufallszahl zwischen 1 und 4 (mit der Methode Zufall ebenfalls aus der Klasser "neuer_weg") erstellt die in der Variable "richtung" gespeichert wird. Wie man im Code-Kommentar erkennen kann steht 1 für rechts, 2 für links...! Somit entscheidet er also die Richtung.
Den weiteren Teil der Methode hab ich in eine FOR-SCHLEIFE "gesteckt" da ich möchte das der Computer immer mind. 3 Felder zeichnet, sonst schaut das blöd aus, sonst is alles ganz konfus. Höchstens es kommt der Rand oder ein anders Feld dazwischen Bsp. für x (rechts) "((x+1)>79 || Karte[x+1][y]==1)" (ich möchte nicht das sich Felder kreuzen). Wenn irgend so ein Problem auftritt, dann ruft er einfach die Methode "Weg_erstellen" rekursiv auf, und "flüchtet" sozusagen vor dem Problem (guter Programmierstil???).
Nach jedem FOR-Schleifen durchlauf wird die jeweilige Position in den jeweiligen Elementvariablen "x" und "y" festgehalten. Außerdem wird auch noch die Karte immer um ein Feld weitergezeichnet, in dem die Methode den Weg in die Elementvariable "Karte[80][25] einträgt.
So ich hoffe es versteht jetzt jemand den Code halbwegs.
Nun zum Problem, mein Programm stürzt immer ab, entweder wird die Karte noch bis zu einem bestimmten Punkt gezeichnte und es kommt dann:
EDIT: DIE KARTE KOMMT HIER IRGENDWIE N BISSCHEN VERSCHOBEN RÜBER

.###############################################################################
.###############################################################################
.###############################################################################
.###############################################################################
.###############################################################################
.###############################################################################
.###############################################################################
.###############################################################################
.###############################################################################
....############################################################################
###.############################################################################
###.############################################################################
....############################################################################
.###############################################################################
.###############################################################################
....############################################################################
################################################################################
################################################################################
################################################################################
################################################################################
################################################################################
################################################################################
Process returned -1073741819 (0xC0000005) execution time : 0.296 s
Press any key to continue.

oder es kommt gleich:

Process returned -1073741819 (0xC0000005) execution time : 0.031 s
Press any key to continue.

Irgendwas is an meiner Methode "Weg_erstellen" nicht ganz "koscher"!!!
Weiß jemand weiter? Sieht jemand den Fehler, bzw. gibts Verbesserungsvorschläge, oder hat sowas ähnliches wie das schon mal jemand von euch gecodet...?
Dankeschön schon mal im Voraus.

void neuer_weg::Weg_erstellen()
{
    int richtung=Zufall(1,4); // 1=rechts 2=links 3=unten 4=oben
    for (int l=0;l<3;l++)
    {
        switch(richtung)
        {
            case 1:
            if ((x+1)>79 || Karte[x+1][y]==1)  Weg_erstellen();
            else x=x+1; //rechts
            break;
            case 2:
            if ((x-1)<0 || Karte[x-1][y]==1) Weg_erstellen();
            else x=x-1; //links
            break;
            case 3:
            if ((y+1)>24 || Karte[x][y+1]==1) Weg_erstellen();
            else y=y+1; //unten
            break;
            case 4:
            if ((y-1)<0 || Karte[x][y-1]==1) Weg_erstellen();
            else y=y-1; //oben
            break;
        }
        Karte[x][y]=1;
    }

}

Andrey

ähm... ich weis jetzt nicht _genau_ wo das problem liegt, aber die rekursive funktion des "strassenbaus" erscheint mir doch äußerst suspekt, überleg doch mal, was die funktion macht, wenn du mal in der sackgasse landest (warum darf man hier keine bilder eifügen? öööh...)

-------------------------------
#####################----------
---XXXXXXX†---------#----------
---X-----############----------
---X-----#---------------------
---X-----#---------------------
---X-----#---------------------
---X-----##############--------
XXXX---------------------------
-------------------------------

- =kein weg
# =der erste von drei gebauten wegen
X =der zweite weg, der gerade gebaut wird
† = (x y)-deine momentane position

so, jetzt stell dir mal vor, dass du per zufall noch ein paar mal nach rechts laufen kannst, dann gibt es aber keine möglichkeit, in irgendeine richtung zu gehen, weil die wege sich ja nicht kreuzen dürfen...

du "flüchtest rekursiv von dem fehler" (applaus ) und zwar solange, bis deine funktion ca. 6782848234265 mal rekursiv aufgerufen wird, und dein programm irgendwann mal den ganzen stack-speicher vollmüllt und... naja...^^

hoffentlich hilfts was...
aber das ist eigentlich recht schwierig, das richtig zu machen=das ist genau dasselbe wie gute KI für "snake", wo der snake sich eben nie auf den schwanz treten darf... hm...

Andrey

ausserdem... irgendwie verstehe ich den sinn des ganzen gar nicht... ein "labyrinth" das aus drei sich nicht verzweigenden, sich nciht kreuzenden wegen besteht? habe ich das programm überhaupt halbwegs richtig verstanden? hat die rekursion etwa irgendwas mit verzweigungen zu tun...?

wenn du jetzt die verzweigungen rekursiv herstellen wolltest, wars eine gar nicht mal so üble (eigentlich sehr gute ) idee, nur dann musst du irgendeine maximale rekursionstife festlegen, und jeweils die koordinaten von so einem verzweigungs-knotenpunkt in lokalen variablen deiner funktion zwischenspeichern, und nicht immer an einen und derselben stelle weiterzeichnen.

Shinja

Ich denke (als Anfänger) auch, dass es an der Rekursonstiefe liegen könnte. Auszerdem denke ich, dass nicht der Zweck erfüllt wird, den du haben willst mit der Rekursion.

Ein Beispiel, wo es schiefgehen könnte.
du bist ein Feld vom rechten Rand entfernt als weg finden aufgerufen wird. Die Funktion würfelt rechts, ok, also gehst du nach rechts (ein for-Schleifendurchlauf) beim nächsten durchlauf kannst du nicht mehr nach rechts, die Methode ruft sich selbst auf, zeichnet diesmal 3 Felder nach unten, dann nach links, dann wieder nach unten, und kommt aber dann wieder zurück in die Schleife, wo du angefangen hast sie rekursiv aufzurufen! (den Teil scheinst du zu vergessen, dass du dahin wieder zurückkommst) Und jetzt geht es genau da weiter, wo du die Methode aufgerufen hast, das case wird beendet und jetzt kommt dann eben der letzte durchlauf der for-schleife, wo diesmal nur ein Feld nach rechts gezeichnet wird (statt wie du wünschst immer 3) und dann ist die Methode fertig.

Auf gleiche Weise kann es dann eben auch zu Problemen und Sackgassen kommen. (rechts, unten, links, oben... und jetzt hängen wir fest)

Von daher würde ich das mit dem rekursiven in dieser Form sein lassen. das musst du dir anders überlegen. (vielleicht bisschen ähnlich wie beim sudoku, man versucht eine Zahl, ruft sudoku selbst wieder auf, und wenn man irgendwann ankommt dass nichts mehr geht geht man soviele schritte zurück bis man wieder irgendwo eine Zahl einsetzen kann)