Hallo zusammen.
Ich studiere momentan Wirtschaftsinformatik im 2. Semester an einer dualen Hochschule.
Momentane Aufgabe in Programmieren ist es, ein MineSweeper Spiel in Java zu programmieren.
Da ich bis zu meinem Studienbeginn nahezu ohne Programmierkenntnisse war, bin ich recht froh, dass das ganze soweit läuft.
Allerdings gibt es noch ein Problem, was ich nicht lösen kann:
Trifft man ein Feld, an das keine Mine angrenzd, werden die herumliegenden solange aufgedeckt, bis eins dabei ist, an welches eine Mine grenzt.
Soweit klappt das auch ganz gut, nur manchmal passiert es, dass genau EIN Feld nicht aufgedeckt wird, welches aufgedeckt sein müsste.
Das ist allerdings nur manchmal der Fall und dann immer exakt ein Feld.
Mir ist aufgefallen, dass dieses Feld immer an eine Mine oder den Rand angrenzt.
hier ist der entsprechende Quellcode von der Spiellogik und der GUI:
Spiellogik:
GUI:
Ich studiere momentan Wirtschaftsinformatik im 2. Semester an einer dualen Hochschule.
Momentane Aufgabe in Programmieren ist es, ein MineSweeper Spiel in Java zu programmieren.
Da ich bis zu meinem Studienbeginn nahezu ohne Programmierkenntnisse war, bin ich recht froh, dass das ganze soweit läuft.
Allerdings gibt es noch ein Problem, was ich nicht lösen kann:
Trifft man ein Feld, an das keine Mine angrenzd, werden die herumliegenden solange aufgedeckt, bis eins dabei ist, an welches eine Mine grenzt.
Soweit klappt das auch ganz gut, nur manchmal passiert es, dass genau EIN Feld nicht aufgedeckt wird, welches aufgedeckt sein müsste.
Das ist allerdings nur manchmal der Fall und dann immer exakt ein Feld.
Mir ist aufgefallen, dass dieses Feld immer an eine Mine oder den Rand angrenzt.
hier ist der entsprechende Quellcode von der Spiellogik und der GUI:
Spiellogik:
Java:
/**
* Grenzt an ein Aufgedecktes Feld, welches noch nicht geprüft wurde, keine Mine,
* so werden die angrenzenden Felder ebenfalls darauf geprüft und in eine ArrayListe gepackt.
*
* @param x
* @param y
*/
public void proofZero(int x, int y){
for(int i=-1;i<2;i++){
for(int j=-1;j<2;j++){
if(x-i>=0&&x-i<höhe&&y-j>=0&&y-j<breite) {
if(!spielfeld[x-i][y-j].isProofed() && !spielfeld[x-i][y-j].isMarkiert() && !spielfeld[x-i][y-j].isMine())
{
spielfeld[x-i][y-j].setProofed(true);
aufdeckArray.add(spielfeld[x-i][y-j]);
if(spielfeld[x-i][y-j].getZahl()==0){
zeroArray.add(spielfeld[x-i][y-j]);
}
}
}
}
}
}
/**Die Felder in der ArrayListe werden wiederum mit obiger Methode geprüft,
* als proofed markiert und danach aus der Liste gelöscht.
*/
public void batchArrayList(){
int i=0;
int x;
int y;
while(zeroArray.size()>0 && i<zeroArray.size()){
Minenfeld zeromine = zeroArray.get(i);
zeroArray.remove(i);
x=zeromine.getX();
y=zeromine.getY();
i++;
proofZero(x,y);
}
}
//Folgende Methoden rufen Methoden eines Minenfeldobjektes auf
/**Feld wird aufgedeckt,
* Anzahl der aufgedeckten Felder wird erhöht
* @param x
* @param y
*/
public void aufdecken(int x, int y){
if(!spielfeld[x][y].isAufgedeckt())
spielfeld[x][y].aufdecken(true);
anzAufgedeckt++;
}GUI:
Java:
/**
* Aufdecken eines Minenfelds
*
* @param x
* @param y
*/
public void aufdecken(int x, int y){
if(s.getZahl(x,y)==0){
s.aufdecken(x, y);
buttons[x][y].setBackground(Color.LIGHT_GRAY);
buttons[x][y].setBorderPainted(false);
buttons[x][y].setEnabled(false);
s.proofZero(x,y);
s.batchArrayList();
batchArrayList(s.getAufdeckArray());
}
else {
s.aufdecken(x, y);
showZahl(x,y);
}
}
/**
* Aufdecken der geprüften Felder aus der Spiellogik
*
* @param aufdeckArray
*/
public void batchArrayList(ArrayList<Minenfeld> aufdeckArray){
int i=0;
int x;
int y;
while(aufdeckArray.size()>0 && i<aufdeckArray.size()){
Minenfeld aufdeckFeld = aufdeckArray.get(i);
aufdeckArray.remove(i);
x=aufdeckFeld.getX();
y=aufdeckFeld.getY();
i++;
aufdecken(x,y);
}
}
Zuletzt bearbeitet:
