Methoden Maze

[xtc21]

Hallo!
Ich versuche gerade den algorithmus von dieser Seite zu implementieren:
MazeWorks - How to Build a Maze

Allerdings arbeite ich nicht mit Wänden, sondern will ganze Blöcke als "Wände" haben.
Jetzt komme ich nicht weiter bei

find all neighbors of CurrentCell with all walls intact

Mein Code sieht immo noch so aus:

    public void mazeGen() {
        ArrayList cellStack = new ArrayList();
        int totalCells = 36 * 36;
        Point currentCell = new Point(1, 1);
        int visited = 1;
        while(visited < totalCells){ ???
            
        }
    }

Währ sehr nett, wenn mir jemand dabei helfen könnte

 

[Marco13]

Hm. Vermutlich gibt's da auch eine einfache und elegante Lösung dafür (vielleicht weiß die spontan jemand) aber... ich frage mich wie es aussehen würde, wenn man (um die Lösung von der Seite mit möglichst wenig Aufwand darauf übertragen zu können) eine "Zelle" des Gitters einfach durch

XXX
X X
XXX

8 Blöcke modelliert... :reflect:

 

[xtc21]

ginge wohl... aber dann hätest du immer ein Feld, wie bei Bombeman

# # # # #

# # # # #

# # # # #

und das will ich eigentlich nicht haben... eigentlich lieber eine ganz normale Maze (nur halt mit ganzen Blöcken als wänden^^)

 

[SlaterB]

das letzte Posting verstehe ich nicht, ansonsten scheint die Aufgabe mit Blockwänden nicht unbedingt schwierige als vorher,
wobei du gewisse Regeln selber definieren musst, ist etwa folgendes erlaubt?

#######
ooo####
o##ooo#
o####o#
oooooo#
#######

x ist Mauer o als Weg,
ist also erlaubt dass die Wege nur eine Zeile versetzt verlaufen könnten oder müssen sie immer in gerade Spalten/ Zeilen verlaufen,
das thematisiert vielleicht auch dein letztes Posting?

----

jedenfalls bist du an irgendeiner Position x und betrachtest Nachbarfeld y,

???
xy?
???

jetzt stell dir vor y wäre auch ein Weg, wäre das schlimm?
mit normalen Wänden ist allein entscheidend, ob in diesem Beispiel nach oben, nach rechts und nach unten eine Wand besteht,
was bei dir die Bedingung ist musst du selber festlegen, kann niemand anders für dich entscheiden,

vielleicht ist es wieder die Frage ob die Blöcke oben, rechts und unten noch Wand sind, vielleicht ist auch der Zustand der Blöcke Nordost + Südost wichtig?

 

[Marco13]

Hm...? Die Seite habe ich nicht im Detail nachvollzogen, aber wenn dort immer Wände weggenommen werden, wären das doch die Y's in

XYX
Y Y
XYX

Und wenn man da ein paar zusammensetzt, könnte z.B. sowas rauskommen wie

XYXYX
Y   Y
XYX X
Y   Y
XYXYX

... Vielleicht müßte ich da aber auch nochmal genauer schauen...

 

[xtc21]

Also ihr habt mir schonmal sehr geholfen!

aber der Algorithmus, so wie ich ihn jetzt implementiert hab macht einfach nicht das, was ich will^^
vllt könnt ihr nochmal einen Blick drüber werfen und mir sagen, woran es liegt

     /**
     * Erstellt eine Maze und schreibt diese direkt in die Hashmap (mapmodel,
     * mapmain) rein.
     */
    public void mazeGen() {

        for (int i = 0; i < 41; i++) {
            for (int j = 0; j < 41; j++) {
                mapmodel.put(new Point(i, j), ECharacter.Wall);
            }
        }

        Stack<Point> cellStack = new Stack<Point>();
        int totalCells = 36 * 36;
        Point currentCell = new Point(1, 1);
        int visited = 1;
        while (visited < totalCells) {
            ArrayList neighbours = new ArrayList(neighbours(currentCell));
            if(!neighbours.isEmpty()){
                Random random = new Random(neighbours.size());
                int rnd = random.nextInt();
                mapmodel.put((Point)neighbours.get(rnd), ECharacter.None);
                cellStack.add(currentCell);
                currentCell = (Point)neighbours.get(rnd);
                visited = visited + 1;
            }else{
                currentCell = cellStack.pop();
            }
        }
    }
    /**
     * Eine hilfsmethode für den Maze generator.
     * @param p Der Punkt, der überprüft werden soll.
     * @return gibt eine liste mit nachbarn wieder, die besucht werden können.
     */
    private ArrayList neighbours(Point p){
        ArrayList<Point> neighbours = new ArrayList<Point>();
        if(!((p.x <= 0) && (p.y <= 0) && (p.x >= 37) && (p.y >= 37))){
            Point n = new Point((p.x) - 1, p.y);
            Point s = new Point((p.x) + 1, p.y);
            Point w = new Point(p.x, (p.y) - 1);
            Point o = new Point(p.x, (p.y) + 1);
            if(mapmodel.get(new Point(n.x, (n.y)-1)).equals(ECharacter.Wall)
                    && mapmodel.get(new Point(n.x, (n.y)+1)).equals(ECharacter.Wall)
                    && mapmodel.get(new Point((n.x)+1, n.y)).equals(ECharacter.Wall)){
                neighbours.add(n);
            }
            if(mapmodel.get(new Point(s.x, (s.y)-1)).equals(ECharacter.Wall)
                    && mapmodel.get(new Point(s.x, (s.y)+1)).equals(ECharacter.Wall)
                    && mapmodel.get(new Point((s.x)-1, s.y)).equals(ECharacter.Wall)){
                neighbours.add(s);
            }
            if(mapmodel.get(new Point((w.x)+1, w.y)).equals(ECharacter.Wall)
                    && mapmodel.get(new Point((w.x)-1, w.y)).equals(ECharacter.Wall)
                    && mapmodel.get(new Point(w.x, (w.y)+1)).equals(ECharacter.Wall)){
                neighbours.add(w);
            }
            if(mapmodel.get(new Point((o.x)+1, o.y)).equals(ECharacter.Wall)
                    && mapmodel.get(new Point((o.x)-1, o.y)).equals(ECharacter.Wall)
                    && mapmodel.get(new Point(o.x, (o.y)-1)).equals(ECharacter.Wall)){
                neighbours.add(o);
            }
        }
        return neighbours;
    }

Ich habe einfach mal das unfertige Programm angehängt, in der Hoffnung, dass ihr damit evtl was anfangen könnt

 

[SlaterB]

> if(mapmodel.get(new Point((w.x)+1, w.y)).equals(ECharacter.Wall)
solche Zeilen 12x hinzuschreiben oder gefühlt das ganze Programm vollzukleistern ist nicht schön,
definiere dir doch Hilfsmethoden a la
if(isWall(w, 1, 0)) // die beiden Parameter sind +-x, +-y,

aber zum Thema: debuggen kannst du das doch eigentlich selber, gerade bei so einem anschaulichen Thema,
den Zufall mache reproduzierbar indem du nur ein Random-Objekt verwendest (sowieso viel besser!) und diesem einen Startwert wie 42 gibst

dann schaue dir doch an was exakt passiert, welches ist das erste Feld, welcher Nachbar davon wird als erster angeschaut,
richtig ausgewählt?, welcher der 3-4Nachbarn kommt dran usw.,
was ist überhaupt der Fehler?
wenn nötig gib nach jeder Auswahl die komplette Maze aus usw.

all das müssten andere wahrscheinlich genauso machen, je früher du das selber lernst desto besser (für die anderen )