Methoden 4 Gewinnt checkDiagonal Methode

[Kart0]

Hi, ich soll ein 4 Gewinnt Spiel programmieren, welches überprüft, welcher Spieler das Spiel gewinnt.

Ich steck momentan bei der checkDiagonal() Methode fest, bei der true zurückgegeben werden soll, wenn 4 gleiche Spielsteine diagonal auf einer Linie stehen.

Die checkRow() und checkColumn() Methoden funktionieren:

private boolean checkColumn() {
        for (int j = 0; j < 7; ++j) {
            int count = 0;
            for (int i = 1; i < 7; ++i) {
                if (this.board[j] != '-' &&
                    this.board[j] == this.board[i-1][j]) {
                    ++count;
                }
                else {
                    count = 1;
                }
                if (count >= 4) {
                    return true;
                }
            }
        }
        return false;
    }

    private boolean checkRow() {
        for (int i = 0; i < 7; ++i) {
            int count = 0;
            for (int j = 1; j < 7; ++j) {
                if (this.board[j] != '-' &&
                    this.board[j] == this.board[j-1]) {
                    ++count;
                }
                else {
                    count = 1;
                }
                if (count >= 4) {
                    return true;
                }
            }
        }
        return false;
    }

checkDiagonal() Methode:

private boolean checkDiagonal() {
        int count = 0;
        for (int i = 0; i < 4; i++) {
            if (count >= 4) {
                break;
            }
            count = 0;
            for (int j = 0; j < 6; j++) {
                if (i + j >= 6) {
                    break;
                }
                if (this.board[i+j][j] == this.board[i+j+1][j+1]) {
                    count++;
                    if (count >= 4) {
                        break;
                    }
                }
                else {
                    count = 0;
                }
            }
        }
        if (count >= 4) {
            return true;
        }
        else {
            for (int i = 3; i < 7; i++) {
                if (count >= 4) {
                    break;
                }
                count = 0;
                for (int j = 0; j < 6; j++) {
                    if (i - j <= 0) {
                        break;
                    }
                    if (this.board[i-j][j] == this.board[i-j-1][j+1]) {
                        count++;
                        if (count >= 4) {
                            break;
                        }
                    }
                    else {
                        count = 0;
                    }
                }
            }
            if (count >= 4) {
                return true;
            }
            else {
                return false;
            }
        }
    }

Was muss geändert werden?

 

[VfL_Freak]

Moin,

>> Was muss geändert werden?
Beschreib' doch mal erst, was nicht klappt !!
Hier wird keiner wild rumraten wollen

http://www.java-forum.org/forum-faq-beitraege/7407-man-fragen-richtig-stellt.html

Gruß Klaus

 

[Kart0]

Das Problem ist, dass wenn 4 Spielsteine diagonal stehen kein Gewinner ausgegeben wird, sondern das Spiel einfach fortgesetzt wird. Nur wenn eine Reihe oder eine Spalte mit 4 gleichen Spielsteinen gefüllt ist, wird ein Gewinner ausgegeben. Das heißt, ich habe etwas in checkDiagonal() falsch gemacht.

 

[Thallius]

Was macht Java eigentlich aus

if(this.board[j]==this.board[i-1][j])

Nimmt es automatisch den ersten Index wenn man bei einem zweidimensionalen Array nur einen Index angibt oder was passiert da? Ist das ein "Hidden Fetaure", denn gewollt kann das doch eigentlich nicht sein oder? oder ist board eine eigene Klasse mit entsprechend 2 verschiedenen Gettern? Dann finde ich die Implementierung aber auch sehr unglücklich.

Gruß

Claus

 

[Flown]

Wenn board ein 2d-Array ist, dann wird hier this.board[j]==this.board[i-1][j] der Compiler "nein" sagen, mit folgendem Output: "Incompatible operand types T[] and T"

 

[Thallius]

Wenn board ein 2d-Array ist, dann wird hier this.board[j]==this.board[i-1][j] der Compiler "nein" sagen, mit folgendem Output: "Incompatible operand types T[] and T"

Und wie funktioniert das dann?

 

[VfL_Freak]

na ja, Du musst halt bei beiden Operanden ZWEI Indexe angeben !
Wobei ich diesen Vergleich oben im Code nicht sehe ....

gruß Klaus

 

[Thallius]

na ja, Du musst halt bei beiden Operanden ZWEI Indexe angeben !
Wobei ich diesen Vergleich oben im Code nicht sehe ....

gruß Klaus

Also ich sehe das in der ersten Methode

 

[VfL_Freak]

Also ich sehe das in der ersten Methode

oops - mea maxima culpa
Ich glaube, ich habe eben nicht weit genug nach oben gescrollt
Ich lege mich wohl besser wieder hin

Gruß Klaus

 

[Joose]

Also ich sehe das in der ersten Methode

Ich nehme das die Codeblöcke erst nachträglich in Java Tags gefasst wurden und die fehlenden [i] durch die Vorschau verschluckt wurden

 

[Blender3D]

Ich habe Deinen Code nicht wirklich durchgesehen, aber dafür eine kurze Klasse geschrieben die die Diagonale auf Gewinn prüft. Das Problem: Code wird immer unübersichtlich, wenn man viele Schleifen ineinander verschachtelt und mit vielen Bedingungen kombiniert. Die Lösung hier nennt sich Teile und herrsche. Das Bedeutet: Zerlege Dein Problem in kleinere Teilprobleme. Und löse diese hintereinander. Hier benutzt checkDiagonal() serachDiagonal(), um das Problem zu lösen.
SearchDiagonal()
Merkt sich den Type im Bord ( Leer , Gelb, Rot ) beim Aufruf.
Wenn leer gib falsch zurück.
Sonst speichere diesen Typ und bewege dich 3 mal diagonal nach oben.
Wenn noch 3 mal der gleiche Type gefunden wird dann gib wahr zurück.
Andern Falls gib falsch zurück.
checkDiagonal()
Geht das 2 dimmensionale Feld von (0,0) - (Weite - WIN + 1, Höhe - WIN +1) durch und testet an jeder Position mittels searchDiagonal() ob eine fertige Diagonale gefunden wird.

WIN ist 4. Daher kann von der Höhe und der Weite jeweils 3 abgezogen werden( -WIN+1 == -(WIN-1) ), da ab diesen Positionen keine 4er Reihe mehr möglich ist.
Die eigentliche Funktion ist checkWin() . Dies benutzt checkDiagonal(), auch nur als Teillösung für das eigentliche Problem 4 Gleiche in dem Feld zu finden.

public class Board {
   public final static int EMPTY = 0;
   public final static int YELLOW = 1;
   public final static int RED = 2;
   private static int WIN = 4;
   private int[][] board = null; // [0][0] is board's origin
   private int width = 0;// board's width
   private int height = 0;// board's height

   public Board(int width, int height) {
     board = new int[width][height]; 
     this.width = width;
     this.height = height;
   }

   public boolean addStone(int stone, int x) {
     if (x < 0 || x >= width)
       throw new IndexOutOfBoundsException();
     int y = height - 1;
     while (board[x][y] == EMPTY && y > 0) // find next empty
       y--;
     if (y == height - 1) // column is full
       return false;
     if (y != 0 || y == 0 && board[x][y] != EMPTY)
       y = y + 1;
     board[x][y] = stone; // set stone
     return true;
   }
   private boolean checkDiagonal() {
     for (int x = 0; x < width - WIN + 1; x++) {
       for (int y = 0; y < height - WIN + 1; y++) {
         if (searchDiagonal(x, y))
           return true;
       }
     }
     return false;
   }

   public boolean checkWin() {
     if (checkDiagonal())
       return true;
     // checkHorizontal();
     // checkVertical();
     return false;
   }
   private boolean searchDiagonal(int x, int y) {
     int count = 1;
     int type = board[x][y];
     if (type == EMPTY)
       return false;
     for (int i = 1; i < WIN; i++) {
       if (board[x + i][y +i] != type)
         return false;
       count++;
     }
     return count == WIN;
   }
}

•