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:
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:
Java:
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("---------------------");
}
}