J
JavaAnfänger
Hi ihr,
ihr seit meine letzte Hoffnung.
Also ich muss ne KLasse Labyrinth schreiben, die im Array Start und ZielPunkte speichert bis es ein komplettes Labyrinth ist.
Leider bekomme ich nur eine schleife hin oder schlange wie man es nennen möchte, ich such mir ein zufälligen Wandpunkt und guck wie ich von da aus laufen kann.
Ja das klappt wohl auch, aber da ich keine maximale Länge oder so angebe entsteht eine Schlange und nicht mein gewünschtes Labyrinth.
Habe Klasse Punkt UILabyrinth und Labyrinthdarstellung vorgegeben, die Klasse zeichnet mir alles Start und Zielpunkte die ich angebe.
Hier mein Code vielleicht hab ihr ja ein entscheidenen Tipp für mich wäre super
ihr seit meine letzte Hoffnung.
Also ich muss ne KLasse Labyrinth schreiben, die im Array Start und ZielPunkte speichert bis es ein komplettes Labyrinth ist.
Leider bekomme ich nur eine schleife hin oder schlange wie man es nennen möchte, ich such mir ein zufälligen Wandpunkt und guck wie ich von da aus laufen kann.
Ja das klappt wohl auch, aber da ich keine maximale Länge oder so angebe entsteht eine Schlange und nicht mein gewünschtes Labyrinth.
Habe Klasse Punkt UILabyrinth und Labyrinthdarstellung vorgegeben, die Klasse zeichnet mir alles Start und Zielpunkte die ich angebe.
Hier mein Code vielleicht hab ihr ja ein entscheidenen Tipp für mich wäre super
Java:
class Labyrinth {
Punkt wandpunkte[]; //Array für die exestierenden Wandpunkte
boolean Labyrinth[][]; //zwei Dimensionales Array für die Punkte im Labyrinth
Punkt startPunkte[]; //Array für alle exestierenden Startpunkte
Punkt zielPunkte[]; //Array für alle exestierenden Zielpunkte
boolean mZuege[]; //boolean Array für die möglichen Züge
int breite, hoehe; //breite und hoehe des Labyrinthes
/* Konstruktor für die Klasse Labyrinth
*
*/
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();
this.erstellGrundriss();
}
/*
* Methode deklarierewandpunkte()
* speichert alle möglichen Wandpunkte in ein Array
*/
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 || j==hoehe && k>0 && k<breite) {
wandpunkte[index] = new Punkt(k,j);
index++;
}
if(k==0 && j>0 && j<hoehe || k==breite && j>0 && j<hoehe) {
wandpunkte[index] = new Punkt(k,j);
index++;
}
}
}
}
/*
* Methode deklarierewandpunkteimArray()
* speichert die möglichen Wandpunkte im boolean Array
* ermöglicht das überprüfen der Punkte, ob ein Punkt schonmal besucht wurde
*/
void deklarierewandpunkteimArray(){
int index = 0;
for(int j=0;j<hoehe;j++) {
for(int k=0;k<breite;k++) {
if(j==0 || j==hoehe) {
Labyrinth[k][j] = true;
}
if(k==0 || k==breite ) {
Labyrinth[k][j] = true;
}
}
}
}
/*
* Methode intAnzWand()
* gibt die Anzahl der vorhandenen Wandpunkte zurück
*/
int gibAnzWand() {
int i = 0;
while(wandpunkte[i] != null) {
i++;
}
return i;
}
/*
* Methode ausgabeArray()
* zum überprüfen des boolean Array in der Konsole
*/
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();
}
}
/*
* Methode gibWandpunkt()
* gibt ein zufälligen Wandpunkt des Labyrinthes zurück
*/
Punkt gibWandpunkt(){
int zufall = (int)(Math.random()* (gibAnzWand() + 1));
int i = zufall;
System.out.println("Die Zufallszahl" + zufall);
Punkt temp = wandpunkte[zufall];
while(wandpunkte[i] != null) {
wandpunkte[i] = wandpunkte[i+1];
i++;
}
wandpunkte[i] = null;
return temp;
}
/*
* Methode gibAnzStart()
* gibt die Anzahl der StartElemente zurück
*/
int gibAnzStart() {
int i = 0;
while(startPunkte[i] != null) {
i++;
}
return i;
}
/*
* Methode gibAnzZiel()
* gibt die Anzahl der Zielpunkte zurück
*
*/
int gibAnzZiel() {
int i = 0;
while(zielPunkte[i] != null) {
i++;
}
return i;
}
/*
* Methode erstelllabyrinth()
* erstellt das Labyrinth
*/
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);
}
}*/
int i = 6;
Punkt tempstart = new Punkt(0,1); //gibWandpunkt();
Punkt tempziel = lauf(tempstart);
while(i!=40){
startPunkte[i] = tempstart;
zielPunkte[i] = tempziel;
tempstart = tempziel;
tempziel = lauf(tempstart);
Labyrinth[startPunkte[i].gibX()][startPunkte[i].gibY()] = true;
Labyrinth[zielPunkte[i].gibX()][zielPunkte[i].gibY()] = true;
if(tempziel.gibX() == -1 && tempziel.gibY() == -1) System.out.println("----------------------hier-------------------");
i++;
}
this.ausgabeArray();
}
/*
* Methode moeglicheBewegungen()
* legt fest, was für Bewegungen man von einen Punkt aus machen kann
*/
void moeglicheBewegungen(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
}
/*
* Mehtode prufe()
* diese Methode überprüft, ob die Bewegung direction ausführbar ist
* @ param direction , die Bewegung die ausgeführt werden muss
* @ param x die x-Koordinate vom ausgehenden Punkt
* @ param y die y-Koordinate vom ausgehenden Punkt
* @ return false wenn diese Bewegung nicht ausführbar ist
* @ return true wenn sie ausführbar ist
*
*
*/
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 || y==hoehe) return false;
else if( Labyrinth[x][y+1] == true) return false;
else
return true;
//end down
return false;
}
/* Methode lauf()
* überprüft welche möglichen Bewegungen exestieren und sich sich einen zufälligen Weg der exestierenden Möglichkeiten
* @ param Punkt p der Startpunkt von dem diese Methode eine neue Wand erzeugen soll
* @ return liefert den errechneten Zielpunkt, wenn es keinen mehr gibt liefert sie den Punkt (-1,-1)
*/
Punkt lauf(Punkt p) {
int index = 0;
boolean ende = false;
boolean zug [] = new boolean[3];
int x = p.gibX();
int y = p.gibY();
moeglicheBewegungen(x,y);
System.out.println("die moeglichen Zuege " + mZuege[0] + mZuege[1] + mZuege[2] + mZuege[3]);
if(mZuege[0] == false && mZuege[1] == false && mZuege[2] == false &&mZuege[3] == false ) ende = true;
while(ende !=true) {
if(mZuege[0] == true) {
System.out.println("wir laufen links");
return new Punkt(x-1,y);
} //left
if(mZuege[1] == true) {
System.out.println("wir laufen rechts");
return new Punkt(x+1,y);
} //right
if(mZuege[2] == true) {
System.out.println("wir laufen hoch");
return new Punkt(x,y-1);
} //up
if(mZuege[3] == true) {
System.out.println("wir laufen runter");
return new Punkt(x,y+1);
} //down
}
return new Punkt(-1,-1);
}
int gibBreite() {
return this.breite;
}
int gibHoehe() {
return this.hoehe;
}
int gibAnzahlWandelemente() {
return 40;
}
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]);
}
}
/*
* Methode erstellGrundriss()
* erstellt den Grundriss des Labyrinths
*/
void erstellGrundriss() {
startPunkte[0] = new Punkt(0,0);
zielPunkte[0] = new Punkt(breite,0);
startPunkte[1] = new Punkt(breite,0);
zielPunkte[1] = new Punkt(breite,hoehe/2);
startPunkte[2] = new Punkt(breite,hoehe/2+1);
zielPunkte[2] = new Punkt(breite,hoehe);
startPunkte[3] = new Punkt(breite,hoehe);
zielPunkte[3] = new Punkt(0,hoehe);
startPunkte[4] = new Punkt(0,hoehe);
zielPunkte[4] = new Punkt(0,hoehe/2+1);
startPunkte[5] = new Punkt(0,hoehe/2);
zielPunkte[5] = new Punkt(0,0);
}
}
