Swing 2d Array zeichnen

[Todo]

Hi @ all.

leider nochmals wegen den Labyrinth....sorry habs noch nicht ganz geschafft.
Habe meine Klasse Labyrinth durch recherchieren und eigenen Ideen fertig gestellt.
Wenn ich mein zwei dimensionales Array in der Konsole ausgebe sieht es auch stark nach ein Labyrinth aus.
Leider bekomme ich es nicht hin, das Punkt für Punkt der KLasse Labyrinthendarstellung zu übergeben.
Entweder fehlen mit die Ideen oder der entscheidene Zündfunken

Habe mir schon überlegt, dass wenn ich zwei einsen in der Horizontalen oder Vertikalen habe diese zusammenfasse und damit eine Wand zeichne klaüüt aber noch nicht so ganz.

Wäre euch sehr sehr dankbar wenn ihr mir nochmal helfen könntet.
Danke im vor raus.

Hier mein halbfertiger Quellcode:

import java.util.Random;


/**
* Labyrinth.java - einen Labyrinthgenerator der ein zufälliges Labyrinth kreiert.
* @author T
* @version 1.0
*/

class Labyrinth
{
        Random r = new Random();
        boolean istFertig;
        int startX, startY;
        int zielX, ZielY;
        int breite, hoehe;
        int Labyrinth[][];
        Punkt startPunkte[];
        Punkt zielPunkte[];
        int index = 0;

    Labyrinth(int BREITE, int HOEHE) {
        this.hoehe = HOEHE;                 //die Hoehe zuweism
        this.breite = BREITE;               //die Breite zuweisen
        startPunkte = new Punkt[10000];     //startPunkte deklarieren (einfach beliebige Größe) (muss noch geändert werden)
        zielPunkte = new Punkt[10000];      ///zielPunkte deklarieren (einfach beliebige Größe) (muss noch geändert werden)
        Labyrinth = new int[hoehe][breite]; //zwei Dimensionales Labyrinth Array des Types Integer deklarieren mit der Größe [hoehe][breite]
        istFertig =false;                   //boolean Variable zum prüfen ob man fertig ist
        for(int j=0;j<hoehe;j++)            //Das Labyrinth Array mit Wämdem füllen
                for(int k=0;k<breite;k++)   //
                        Labyrinth[j][k] = 1;//Ende des durchlaufes der doppelten for-Schleifen für das Int-Array
        startX = Math.abs(r.nextInt()%(breite-3))+1;
        startY = Math.abs(r.nextInt()%(hoehe-3))+1;
        erzeuge(startX,startY);
    }


    /**
    * Gibt die Breite des Labyrinthes zurück.
    * @return eine Integer Variable
    */
     int gibBreite() {
        return this.breite;
    }

    /**
    * Gibt die Hoehe des Labyrinthes zurück.
    * @return eine Integer Variable
    */
    int gibHoehe() {
        return this.hoehe;
    }

    /**
    * Gibt die Anzahl der Wandelemnte des Labyrinthes zurück.
    * @return eine Integer Variable
    */
    int gibAnzahlWandelemente() {
        int i=0;
            while(startPunkte[i] != null)
                i++;
        return i;
    }

    /**
    * Gibt die StartPunkte des Labyrinthes zurück.
    * @param i eine Variable des Typ Integer
    * @return ein Array des Types Object
    */
    Punkt gibStartpunkt(int i) {
        return startPunkte[i];
    }

    /**
    * Gibt die EndPunkte des Labyrinthes zurück.
    * @param i eine Variable des Typ Integer
    * @return ein Array des Types Object
    */
    Punkt gibEndpunkt(int i) {
        return zielPunkte[i];
    }


    /**
    * Methode zum Erzeugen neuer Wege
    * @param x eine Integer Variable
    * @param y eine Integer Variable
    */
    void erzeuge(int x, int y) {
        ausgabe();
        boolean orientierung[];
        orientierung = new boolean[4];
        int erstell;

        if(!istFertig && x==breite-1) {
            System.out.println("Hier wird auf 0 gesetzt :" + Labyrinth[y][x]);
                Labyrinth[y][x] = 0;
                istFertig = true;
                return;
        } //Ende der der If-Schleife

        else {
                Labyrinth[y][x]=0;
                System.out.println("Hier wird auf 0 gesetzt :" + y + "/" + x);
                Orientierung(orientierung,x,y);

                while(erzeugeZug(orientierung)) {
                        erstell = gibGuektigenZug(orientierung);
                        if (erstell == 3)  erzeuge(x,y+1); //runter
                        if (erstell == 2)  erzeuge(x,y-1); //hoch
                        if (erstell == 1)  erzeuge(x+1,y); //rechts
                        if (erstell == 0)  erzeuge(x-1,y); //links
                        Orientierung(orientierung,x,y);
                } //Ende der While-Schleife
         } //Emde der Else-Schleife
    } //Emder der erzeuge-Funktion


    /*
     * Methode zum festlegen der möglichen Bewegungen
     * @param  orientierung[] ein Array zum festlegen der Orientierung
     * @param x eine Integer Variable für die Koordinate x
     * @param y eine Integer Variable für die Koordinate y
     */
    void Orientierung(boolean orientierung[], int x, int y) {
        orientierung[3]=ueberpruefe(3,x,y); //runter
        orientierung[2]=ueberpruefe(2,x,y); //hoch
        orientierung[1]=ueberpruefe(1,x,y); //rechts
        orientierung[0]=ueberpruefe(0,x,y); //links
    } //Ende der Orientungsmethode

    /** boolean ueberpruefe
     * @param Richtung eine Intergervatiable
     * @param x eine Integervariable
     * @param y eine Integervariable
    Die Methode überprüft eine Richtung um sicherzustellen, dass es ein gültiges Labyrinth bilden.
    Das heißt es sollen keine Loops entstehen.
    */
    boolean ueberpruefe(int Richtung, int x, int y) {
        int sum = 0;
        switch (Richtung)
        {
                case 0: //links
                        if(x-1==0)
                                return false;
                        else
                                sum=(Labyrinth[y-1][x-2]+Labyrinth[y-1][x-1]+Labyrinth[y][x-2]+Labyrinth[y][x-1]+Labyrinth[y+1][x-2]+Labyrinth[y+1][x-1]);
                        break; //Ende für links
                
                case 1: //rechts
                        if(istFertig && x+1 == breite-1)
                                return false;
                        else if(x+1 == breite-1)
                        {
                                return((Labyrinth[y-1][x+1]+Labyrinth[y][x+1]+Labyrinth[y+1][x+1])==3);
                        }
                        else
                                sum=(Labyrinth[y-1][x+1]+Labyrinth[y][x+1]+Labyrinth[y+1][x+1]+Labyrinth[y-1][x+2]+Labyrinth[y][x+2]+Labyrinth[y+1][x+2]);
                        break; //Ende für rechts

                case 2: //hoch
                        if(y-1==0)
                                return false;
                        else
                                sum=(Labyrinth[y-2][x-1]+Labyrinth[y-2][x]+Labyrinth[y-2][x+1]+Labyrinth[y-1][x-1]+Labyrinth[y-1][x]+Labyrinth[y-1][x+1]);
                        break; //Ende für hoch
                
                case 3: //runter
                        if(y+1 == hoehe-1)
                                return false;
                        else
                                sum=(Labyrinth[y+1][x-1]+Labyrinth[y+1][x]+Labyrinth[y+1][x+1]+Labyrinth[y+2][x-1]+Labyrinth[y+2][x]+Labyrinth[y+2][x+1]);
                        break; //Ende für runter
        }; //Ende sitch(Richtung)
        if (sum ==6)
                return true;
        else
                return false;
    }//Ende der Methode ueberpruefe

    /** boolean erzeugeZug
     * @param orientierung[] boolean Array
     * @return true für gültigen Zug
    */
    boolean erzeugeZug(boolean orientierung[]) {
        int j=0;
            while(!orientierung[j]) {
                j++;
                if(j==4)
                        return false;
            } //Ende der while
        return true;
    } //end movesleft


    /** int gibGuektigenZug
        Erzeugt einen gültigen Zug für den Generator
     * @param orientierung[] boolean Array
     * @return welcherPunkt Integer Vatiable
    */
    int gibGuektigenZug(boolean orientierung[]) {
        int welcherPunkt;
        welcherPunkt=(Math.abs(r.nextInt()))%4;
            while(!orientierung[welcherPunkt]) {
                welcherPunkt=(Math.abs(r.nextInt()))%4;
            }
        return welcherPunkt;
    }//Ende der pickmind


    void ausgabe() {
         for(int j=0;j<hoehe;j++) {
                for(int k=0;k<breite;k++) {
                        System.out.print(Labyrinth[j][k]);
                }
                System.out.println();
            }
        System.out.println("---------------------");
    }

   
}

 

[André Uhres]

Wenn mich nicht alles täuscht, ist diese Lösung überhaupt nicht als Linienmuster darstellbar, denn die Wandelemente (1) nehmen ja genauso viel Platz ein wie die Zwischenräume (0), nämlich jeweils genau ein Kästchen (ausser man zeichnet die Linie jeweils in der Mitte der Wandkästchen, aber dann sind die Zwischenräume nicht immer gleich breit).

 

[Todo]

hm ok da glaub ich dir mal,
dann werd ich wohl leider aufgeben müssen ich bekomm es einfach nicht hin

Edit:
Aber kann man nicht erstmal eine Klasse Wände schreiben wo alle Start und ZielPunkte im Array gespeichert werden, und jedes mal, wenn ich eine Wand rausnehme, die auch da jeweils löschen?
Oder habe ich das wieder ein Gedankenfehler?

 

[Todo]

Habs mal anders probiert, er läuft zwar bis jetzt nur runter, aber das Programm hängt sich bei dem Punkt 1/13 einfach auf, denke das liegt irgendwo inder Abbruchbedingung von einer while finde ich aber einfach nicht wäre nett wenn einer mal da drüber gucken kann und gegebenfalls den Fehler sagen kann danke schonmal

/*
 * To change this template, choose Tools | Templates
 * and open the template in the editor.
 */

/**
 *
 * @author T
 */
class Labyrinth {
    Punkt wandpunkte[];
    boolean Labyrinth[][];
    Punkt startPunkte[];
    Punkt zielPunkte[];
    boolean mZuege[];
    int startX, startY;
    int zielX, ZielY;
    int breite, hoehe;

    Labyrinth(int BREITE, int HOEHE) {
        this.breite = BREITE;
        this.hoehe = HOEHE;
        this.wandpunkte = new Punkt[2*breite+2*hoehe];
        this.startPunkte = new Punkt[(2*breite + 2*hoehe)];
        this.zielPunkte = new Punkt[(2*breite + 2*hoehe)];
        this.mZuege = new boolean[4];
        Labyrinth = new boolean[breite][hoehe]; //zwei Dimensionales Labyrinth Array des Types Integer deklarieren mit der Größe [hoehe][breite]
        
        this.deklarierewandpunkte();
        this.deklarierewandpunkteimArray();
        this.ausgabeArray();
        this.zeigeWandPunkte();
        System.out.println("-----------------");
        this.erstelllabyrinth();
        //Punkt p = this.gibStartPunkt();
        this.zeigeStartPunkte();
    }

        void deklarierewandpunkte(){
        int index = 0;
        for(int j=0;j<hoehe;j++) {
                for(int k=0;k<breite;k++) {
                        if(j==0 && k>0 && k<breite-1 || j==hoehe-1 && k>0 && k<breite-1) {
                            wandpunkte[index] = new Punkt(k,j);
                            index++;
                        }
                        if(k==0 && j>0 && j<hoehe-1 || k==breite-1 && j>0 && j<hoehe-1) {
                            wandpunkte[index] = new Punkt(k,j);
                            index++;
                        }
                }
        }
    }

        void deklarierewandpunkteimArray(){
        int index = 0;
        for(int j=0;j<hoehe;j++) {
                for(int k=0;k<breite;k++) {
                        if(j==0  || j==hoehe-1) {
                            Labyrinth[k][j] = true;
                        }
                        if(k==0 || k==breite-1 ) {
                            Labyrinth[k][j] = true;
                        }
                }
        }
    }

        int gibAnzWand() {
        int i = 0;
        while(wandpunkte[i] != null) {
            i++;
        }
        return i;
    }

        void ausgabeArray() {
             for(int j=0;j<hoehe;j++) {
                for(int k=0;k<breite;k++) {
                       System.out.print(Labyrinth[k][j]);
                }
                System.out.println();
            }
        }

    Punkt gibWandpunkt(){
        int zufall = (int) Math.random()*gibAnzWand();
        int i = zufall;
        Punkt temp = wandpunkte[zufall];

        while(wandpunkte[i] != null) {
            wandpunkte[i] = wandpunkte[i+1];
            i++;
        }
        return temp;
    }

    int gibAnzStart() {
        int i = 0;
        while(startPunkte[i] != null) {
            i++;
        }
        return i;
    }

     int gibAnzZiel() {
        int i = 0;
        while(zielPunkte[i] != null) {
            i++;
        }
        return i;
    }

    void erstelllabyrinth() {
        int i = 0;
        boolean abbruch = false;
        while(gibAnzWand() != 0) {
            Punkt tempstart = gibWandpunkt();
            Punkt tempziel = lauf(tempstart);

            System.out.println("Anfang tempstart " + tempstart.gibX() + "/" + tempstart.gibY());
            System.out.println("Anfang tempziel " + tempziel.gibX() + "/" + tempziel.gibY());
            
            while(tempziel.gibX() != 0 && tempziel.gibY() != 0 ) {
                    do {
                    System.out.println("in der wiile erstell labyrinth");
                    startPunkte[i] = tempstart;
                    Labyrinth[startPunkte[i].gibX()][startPunkte[i].gibY()] = true;
                    zielPunkte[i] = tempziel;
                    Labyrinth[zielPunkte[i].gibX()][zielPunkte[i].gibY()] = true;
                    System.out.println("tempstart " + tempstart.gibX() + "/" + tempstart.gibY());
                    System.out.println("tempziel " + tempziel.gibX() + "/" + tempziel.gibY());
                    i++;
                    tempstart = tempziel;
                    tempziel = lauf(tempstart);
                    System.out.println("i" + i);
                    ausgabeArray();
                    }while(tempziel.gibX() != 0 && tempziel.gibY() != 0);
                   }
        }

    }

    void möglicheBewegungen(int x, int y) {
        mZuege[3]=pruefe(3,x,y); //3 für down
        mZuege[2]=pruefe(2,x,y); //2 für up
        mZuege[1]=pruefe(1,x,y); //1 für right
        mZuege[0]=pruefe(0,x,y); //0 für left
    }

    boolean pruefe(int direction, int x, int y) {
                if(direction == 0) { //left
                        if(x-1==0 ||  x==0)
                                return false;
                            else if(Labyrinth[x-1][y] == true) return false;
                        else
                                return true;
                }//end left

                if(direction == 1) //right
                        if(x+1 == breite || Labyrinth[x+1][y] == true || x==breite)
                                return false;
                        else
                                return true;
                        //end right
                if(direction == 2) //up
                        if(y-1==0 || y==0) return false;
                            else if(Labyrinth[x][y-1] == true) return false;
                        else
                                return true;
                        //end up
                if(direction == 3) //down
                        if(y+1 == hoehe || Labyrinth[x][y+1] == true || y==hoehe)
                                return false;
                        else
                                return true;
                        //end down
        return false;
    }

    Punkt lauf(Punkt p) {
        int index = 0;
        boolean zug = false;
        int x = p.gibX();
        int y = p.gibY();
        int zufall = (int) Math.random()*4;
        möglicheBewegungen(x,y);
        System.out.println("die moeglichen Zuege " + mZuege[0]+mZuege[1]+mZuege[2]+mZuege[3]);
        while(index != 3 || mZuege[index] != true){
            index++;
        }
            if(index == 0) return new Punkt(x-1,y);    //left
            if(index == 1) return new Punkt(x+1,y);    //right
            if(index == 2) return new Punkt(x,y-1);    //up
            if(index == 3) return new Punkt(x,y+1);    //down

        else return new Punkt(0,0);
    }

    int gibBreite() {
        return this.breite;
    }

    int gibHoehe() {
        return this.hoehe;
    }

    int gibAnzahlWandelemente() {
        return 5;
    }

    Punkt gibStartpunkt(int i) {
        return startPunkte[i];
    }

    Punkt gibEndpunkt(int i) {
        return zielPunkte[i];
    }

    void zeigeWandPunkte() {
          for (int k = 0; k < gibAnzWand(); k++)    {
              System.out.println(k);
                                System.out.println("Die Punkte: " + wandpunkte[k]);
                        }
    }

    void zeigeStartPunkte() {
        System.out.println("------------------------------");
        System.out.println("es gibt startpunkte" + gibAnzStart());
          for (int k = 0; k < gibAnzStart(); k++)    {
              System.out.println(k);
                                System.out.println("Die Punkte: " + startPunkte[k]);
                        }
    }
}

 

[André Uhres]

Folgende Version sieht ein wenig anders, vielleicht gibt dir das eine Idee:

import java.util.*;
public class Labyrinth {
    private int breite;
    private int hoehe;
    private Punkt startPunkt;
    private Punkt endPunkt;
    public static int WALLS = 0, PUNKT = 1;//Cell-Elemente
    public static int NORTH = 0, EAST = 1, SOUTH = 2, WEST = 3;//Direction-Elemente
    private Object[][] array;
    private Stack<Object> stack;
    private int totalCells, visitedCells;
    private Object[] currentCell, neighborCell;
    private final Random r;
    Labyrinth(int BREITE, int HOEHE) {
        breite = BREITE;
        hoehe = HOEHE;
        r = new Random();
        startPunkt = new Punkt(0, Math.abs(r.nextInt() % hoehe));
        endPunkt = new Punkt(breite - 1, Math.abs(r.nextInt() % hoehe));
        initArray();
        createLabyrinth();
        createInOut();
    }
    int gibBreite() {
        return breite;
    }
    int gibHoehe() {
        return hoehe;
    }
    int gibAnzahlWandelemente() {
        return breite * hoehe * 4;
    }
    Punkt gibStartpunkt(int i) {
        int column = (i / 4) % breite;
        int row = (i / 4) / breite;
        int n = i % 4;
        Punkt start = null;
        if (n == 0) {           //oben links
            start = new Punkt(column, row);
        } else if (n == 1) {    //oben rechts
            start = new Punkt(column + 1, row);
        } else if (n == 2) {    //unten rechts
            start = new Punkt(column + 1, row + 1);
        } else {                //unten links
            start = new Punkt(column, row + 1);
        }
        return start;
    }
    Punkt gibEndpunkt(int i) {
        int column = (i / 4) % breite;
        int row = (i / 4) / breite;
        Object[] cell = (Object[]) array[row][column];
        Boolean[] walls = (Boolean[]) cell[WALLS];
        int n = i % 4;
        Punkt end = null;
        if (n == 0) {           //oben rechts
            end = new Punkt(column + 1, row);
            if (!walls[NORTH]) {
                end = new Punkt(column, row);           //end=start
            }
        } else if (n == 1) {    //unten rechts
            end = new Punkt(column + 1, row + 1);
            if (!walls[EAST]) {
                end = new Punkt(column + 1, row);       //end=start
            }
        } else if (n == 2) {    //unten links
            end = new Punkt(column, row + 1);
            if (!walls[SOUTH]) {
                end = new Punkt(column + 1, row + 1);   //end=start
            }
        } else {                //oben links
            end = new Punkt(column, row);
            if (!walls[WEST]) {
                end = new Punkt(column, row + 1);       //end=start
            }
        }
        return end;
    }
    private void initArray() {
        Boolean[] wall;
        Punkt punkt;
        array = new Object[hoehe][breite];
        for (int row = 0; row < array.length; row++) {
            for (int column = 0; column < array[row].length; column++) {
                wall = new Boolean[]{Boolean.TRUE, Boolean.TRUE, Boolean.TRUE, Boolean.TRUE};
                punkt = new Punkt(column, row);
                array[row][column] = new Object[]{wall, punkt};
            }
        }
    }
    public void createLabyrinth() {
        stack = new Stack();
        totalCells = hoehe * breite;
        currentCell = random();
        visitedCells = 1;
        while (visitedCells < totalCells) {
            neighborCell = randomNeighborCellWithWallsUp(currentCell);
            if (neighborCell == null) {
                currentCell = (Object[]) stack.pop();
            } else {
                removeWall(currentCell, neighborCell);
                stack.push(currentCell);
                currentCell = neighborCell;
                visitedCells++;
            }
        }
    }
    private void createInOut() {
        Object[] cell = (Object[]) array[startPunkt.gibY()][startPunkt.gibX()];
        Boolean[] walls = (Boolean[]) cell[WALLS];
        walls[WEST] = Boolean.FALSE;
        cell = (Object[]) array[endPunkt.gibY()][endPunkt.gibX()];
        walls = (Boolean[]) cell[WALLS];
        walls[EAST] = Boolean.FALSE;
    }
    public Object[] random() {
        int row = Math.abs(r.nextInt()) % hoehe;
        int column = Math.abs(r.nextInt()) % breite;
        return (Object[]) array[row][column];
    }
    public Object[] randomNeighborCellWithWallsUp(final Object[] currentCell) {
        int column = ((Punkt) currentCell[PUNKT]).gibX();
        int row = ((Punkt) currentCell[PUNKT]).gibY();
        List<Object[]> neighborCells = new ArrayList<Object[]>();
        Object[] neighbor = null;
        if (row - 1 > -1) {
            neighbor = (Object[]) array[row - 1][column];
            if (allWallsUp(neighbor)) {
                neighborCells.add(neighbor);
            }
        }
        if (column + 1 < breite) {
            neighbor = (Object[]) array[row][column + 1];
            if (allWallsUp(neighbor)) {
                neighborCells.add(neighbor);
            }
        }
        if (row + 1 < hoehe) {
            neighbor = (Object[]) array[row + 1][column];
            if (allWallsUp(neighbor)) {
                neighborCells.add(neighbor);
            }
        }
        if (column - 1 > -1) {
            neighbor = (Object[]) array[row][column - 1];
            if (allWallsUp(neighbor)) {
                neighborCells.add(neighbor);
            }
        }
        if (neighborCells.size() == 0) {
            return null;
        }
        int index = Math.abs(r.nextInt()) % neighborCells.size();
        return neighborCells.get(index);
    }
    private boolean allWallsUp(Object[] neighbor) {
        Boolean[] walls = (Boolean[]) neighbor[WALLS];
        return walls[EAST] && walls[WEST]
                && walls[SOUTH] && walls[NORTH];
    }
    private void removeWall(final Object[] currentCell, final Object[] neighborCell) {
        int column = ((Punkt) currentCell[PUNKT]).gibX();
        int row = ((Punkt) currentCell[PUNKT]).gibY();
        int columnN = ((Punkt) neighborCell[PUNKT]).gibX();
        int rowN = ((Punkt) neighborCell[PUNKT]).gibY();
        if (row - 1 == rowN) {//Nord-Süd Durchbruch
            ((Boolean[]) currentCell[WALLS])[NORTH] = Boolean.FALSE;
            ((Boolean[]) neighborCell[WALLS])[SOUTH] = Boolean.FALSE;
        } else if (column + 1 == columnN) {//Ost-West Durchbruch
            ((Boolean[]) currentCell[WALLS])[EAST] = Boolean.FALSE;
            ((Boolean[]) neighborCell[WALLS])[WEST] = Boolean.FALSE;
        } else if (row + 1 == rowN) {//Süd-Nord Durchbruch
            ((Boolean[]) currentCell[WALLS])[SOUTH] = Boolean.FALSE;
            ((Boolean[]) neighborCell[WALLS])[NORTH] = Boolean.FALSE;
        } else if (column - 1 == columnN) {//West-Ost Durchbruch
            ((Boolean[]) currentCell[WALLS])[WEST] = Boolean.FALSE;
            ((Boolean[]) neighborCell[WALLS])[EAST] = Boolean.FALSE;
        }
    }
}