Code:
public class Main {
static final int MINE = 99;
public static void main(String[] args) {
boolean[][] field;
// solange man spielen will
do {
// S1) Einlesen der Feldgroesse
int w = readFieldWidth();
int h = readFieldHeight();
// S2) Einlesen der Bombenwahrscheinlichkeit
double prob = readBombProb();
// S3) Erstellen eines entsprechenden Feldes
field = createField(w, h, prob);
// Testausgabe
printFieldForTesting(field);
// S4) Spielen des Spieles
boolean won = play(field);
if (won) {
IO.writeLn("Gratuliere ! Gewonnen");
} else {
IO.writeLn("Beng!!! Leider im Kampf gefallen!");
}
// S5) Fragen ob noch einmal gespielt werden soll.
} while (playAgain());
}
static void printFieldForTesting(boolean[][] f) {
IO.writeLn();
for (int i = 0; i < f.length; i++) {
for (int j = 0; j < f[i].length; j++) {
if (f[i][j]) {
IO.write(" * ");
} else {
IO.write(" - ");
}
}
IO.writeLn();
}
IO.writeLn();
}
static int readFieldWidth() {
IO.write("Feldbreite: ");
return IO.readInt();
}
static int readFieldHeight() {
IO.write("Feldhoehe: ");
return IO.readInt();
}
static double readBombProb() {
IO.write("Wahrscheinlichkeit fuer Mine: ");
return IO.readDouble();
}
static boolean[][] createField(int w, int h, double prob) {
boolean[][] f = new boolean[h][w];
for (int i = 0; i < f.length; i++) {
for (int j = 0; j < f[i].length; j++) {
f[i][j] = Math.random() < prob;
}
}
return f;
}
static boolean playAgain() {
IO.writeLn();
IO.writeLn("Wollen Sie es nochmals versuchen (j|n)?");
return IO.read() == 'j';
}
static boolean play(boolean[][] field) {
int[][] uncovered;
uncovered = createUncovered(field.length, field[0].length);
int row, col;
boolean dead = false;
// Ausgeben der aufgedeckten Felder
print(uncovered);
do {
// Einlesen des nächsten Feldes das aufgedeckt werden soll
IO.write("Zeile: ");
row = IO.readInt();
IO.write("Spalte: ");
col = IO.readInt();
// Aufdecken: entweder Mine erwischt oder Anzahl der nachbarminen anzeigen
dead = uncover(row, col, field, uncovered);
// Ausgeben der aufgedeckten Felder
print(uncovered);
//solange bis alle nicht-Minen aufgedeckt oder !field[row][col])
} while (! allUncovered(uncovered, field) && ! dead);
// return won
return ! dead;
}
static boolean uncover(int r, int c, boolean[][] f, int[][] uc) {
if (! inField(r, c, f)) {
IO.writeLn("Zeile " + r + ", Spalte " + c + " nicht in Feld");
return false;
}
if (f[r][c]) {
uc[r][c] = MINE;
return true;
}
uc[r][c] = countMines(f, r, c); // Nachbarnminen
return false;
}
static int countMines(boolean[][] f, int r, int c) {
int n = 0;
for (int i = r-1; i <= r+1; i++) {
for (int j= c-1; j <= c+1; j++) {
if (inField(i, j, f) && f[i][j]) {
n++;
}
}
}
return n;
}
static boolean inField(int r, int c, boolean[][] f) {
return r >= 0 && c >= 0 && r < f.length && c < f[0].length;
}
static boolean allUncovered(int[][] uc, boolean[][] f) {
for (int i = 0; i < f.length; i++) {
for (int j = 0; j < f[i].length; j++) {
// wenn keine Mine auf i, j soll es aufgedeckt sein
if (! f[i][j] && uc[i][j] == -1) {
return false;
}
}
}
return true;
}
static void print(int[][] uc) {
IO.writeLn();
for (int i = 0; i < uc.length; i++) {
for (int j = 0; j < uc[i].length; j++) {
if (uc[i][j] == -1) {
IO.write(" - ");
} else if (uc[i][j] == MINE) {
IO.write(" * ");
} else {
IO.write(" " + uc[i][j] + " ");
}
}
IO.writeLn();
}
}
static int[][] createUncovered(int h, int w) {
int [][] uc = new int[h][w];
for (int i = 0; i < uc.length; i++) {
for (int j = 0; j < uc[i].length; j++) {
uc[i][j] = -1;
}
}
return uc;
}
}Hi hab hier den code meines programmes nur irgendwie funktioniert es nicht irgendwie wenn ich das programm starte hängt sich irgendwie auf in der eingabeforderung und es wird irgendwie immer ausgegeben dass ich eine bombe erwische hat wer ne ahnung was da fehler sein kann?
Hier die anforderungen meiner übung:
Wir wollen uns nun selbst ein Minesweeper-Spiel programmieren. Das Spiel soll folgend laufen:
Zuerst wird eine gewünschte Größe des Spielfeldes eingelesen.
Dann werden im Spielfeld zufällig Minen gelegt. Wir wollen durchschnittlich auf 20% der Felder Minen
setzen, d.h. jedes Feld erhält mit der Wahrscheinlichkeit 0,2 eine Mine (verwenden Sie Math.random()).
Der Spieler hat nun solange die Möglichkeit Felder aufzudecken, bis er entweder alle freien Felder
aufgedeckt hat (dann hat er gewonnen) oder er auf eine Mine „tritt“ (dann hat er verloren). Ein Feld wird
aufgedeckt, indem die Zeile und Spalte des Feldes eingelesen wird.
Es wird nach jedem Zug der Spielstand angezeigt, indem für nicht-aufgedeckte Felder das Zeichen '-', für
aufgedeckte freie Plätze die Anzahl der Minen in den Nachbarfeldern und für Minenfelder der Stern '*'
ausgegeben wird.
Man soll eine beliebige Anzahl von Spielen spielen können.
Beispiel:
Breite des Feldes: 4
Hoehe des Feldes: 4
0 1 2 3
0 - - - -
1 - - - -
2 - - - -
3 - - - -
Feld aufdecken (x y): 2 2
0 1 2 3
0 - - - -
1 - - - -
2 - - 1 -
3 - - - -
Feld aufdecken (x y): 1 2
0 1 2 3
0 - - - -
1 - - 1 -
2 - - 1 -
3 - - - -
Feld aufdecken (x y): 0 1
0 1 2 3
0 – 1 - -
1 - - 1 -
2 - - 1 -
3 - - - -
...
Feld aufdecken (x y): 3 0
0 1 2 3
0 1 1 - -
1 - - 1 1
2 - - 1 -
3 * - - -
Beng!!!! Mine erwischt und verloren.
Wollen Sie es nochmals versuchen (j|n)? j
