Test Kommentare ergänzt und Read.me korrigiert

README.md

@@ -3,15 +3,15 @@
 
 <h3><span style="color:red">Beschreibung:</h3>
 Mein Spiel ist das klassische Vier gewinnt. <br>
-Ziel des Spieles ist es, vier eigene Steine horizontal,diagonal 
+Ziel des Spieles ist es, vier eigene Steine horizontal, diagonal 
 oder waagerecht in eine Linie zu bringen. <br>
-Gleichzeitig muss man aber auch verhindern, dass der Gegner nicht das Selbe 
+Gleichzeitig muss man aber auch verhindern, dass der Gegner nicht dasselbe 
 schafft. <br>
-Es wird abwecheselnd auf ein 7 x 7 Felder großes Feld Steine gesetzt, 
-wird eine Spalte für ein Zug ausgewählt, rutscht der Stein bis zum untersten
+Das Spielfeld besteht aus 7 Spalten und 6 Reihen, es wird abwechselnd gespielt. <br>
+Wird eine Spalte für einen Zug ausgewählt, rutscht der Stein bis zum untersten
 freien Platz in der Spalte. <br>
 Das Spiel endet unentschieden, wenn alle Felder voll sind, ohne dass ein Spieler 
-eine Viererlinie gebildet hat. (84 Wörter) <br>
+eine Linie mit vier Steinen bilden konnte. (87 Wörter) <br>
 
 <br>
 
@@ -22,8 +22,8 @@ eine Viererlinie gebildet hat. (84 Wörter) <br>
 
 <h3><span style="color:red">Bedienungshinweise:</h3>
 Zu Beginn des Spieles wird mit den Tasten P und B ausgewählt, 
-ob man gegen einen Bot (B) spielen möchte oder gegen einen anderen Player (P). <br>
-Danach beginnt das Spiel und man kann mit den Tasten 1-7 eine Zeile auswählen, wo der Stein gesetzt werden werden soll. <br>
+ob man gegen einen Bot (B) oder gegen einen anderen Player (P) spielen möchte. <br>
+Danach beginnt das Spiel und man kann mit den Tasten 1-7 eine Zeile auswählen, wo der Stein gesetzt werden soll. <br>
 Falls man aus Versehen einen falschen Zug gespielt hat, kann man ihn mit der Taste U rückgängig machen. <br>
 Wenn man das Spiel zurücksetzen möchte, kann man die Taste R drücken und das ganze Spiel wird zurückgesetzt. <br>
 <br>

app/src/main/java/PIS_HU1/Draw.java

@@ -46,11 +46,11 @@ public class Draw extends PApplet {
       int i = 1;
       while (w < 49) {
         long mask = 1L << w;
-        if ((game.playerBoard[0] & mask) != 0L) {
+        if ((game.getPlayerBoard()[0] & mask) != 0L) {
           fill(252, 215, 3);
           ellipse(x * i, y, 75, 75);
 
-        } else if ((game.playerBoard[1] & mask) != 0L) {
+        } else if ((game.getPlayerBoard()[1] & mask) != 0L) {
           fill(252, 44, 3);
           ellipse(x * i, y, 75, 75);
 
@@ -65,7 +65,7 @@ public class Draw extends PApplet {
     }
     PImage winner = loadImage("app/Pictures/winner.png");
     winner.resize(350, 350);
-    if (game.isWin(game.playerBoard[0])) {
+    if (game.isWin(game.getPlayerBoard()[0])) {
       background(50, 96, 114);
       textSize(60);
       fill(255);
@@ -73,7 +73,7 @@ public class Draw extends PApplet {
       textSize(30);
       text("Press R for restart", 100, 230);
       image(winner, 150, 250);
-    } else if (game.isWin(game.playerBoard[1])) {
+    } else if (game.isWin(game.getPlayerBoard()[1])) {
       background(50, 96, 114);
       textSize(60);
       fill(255);
@@ -106,9 +106,6 @@ public class Draw extends PApplet {
 
   @Override
   public void keyPressed() {
-    if (key == '0') {
-      System.out.println(game.toString());
-    }
     switch (key) {
       case '1', '2', '3', '4', '5', '6', '7' -> {
         game.makeMove(Integer.parseInt(String.valueOf(key))-1);
@@ -138,11 +135,10 @@ public class Draw extends PApplet {
 
   public void bot() {
     GameEngine test = new GameEngine();
-    test.playerBoard = Arrays.copyOf(game.playerBoard, game.playerBoard.length);
-    test.move = Arrays.copyOf(game.move, game.move.length);
-    test.heightCol = Arrays.copyOf(game.heightCol, game.heightCol.length);
-    test.count = game.count;
-    System.out.println(test.chooseBestMove(test, 100));
+    test.setGetPlayerBoard(Arrays.copyOf(game.getPlayerBoard(), game.getPlayerBoard().length));
+    test.setMove(Arrays.copyOf(game.getMove(), game.getMove().length));
+    test.setHeightCol(Arrays.copyOf(game.getHeightCol(), game.getHeightCol().length));
+    test.setCount(game.getCount());
     game.makeMove(test.chooseBestMove(test, 100));
   }
 }

app/src/main/java/PIS_HU1/GameEngine.java

@@ -13,12 +13,11 @@ public class GameEngine implements GameInterface {
   private final int column = (1 << heightBottom) - 1;
   private final long bottom = all / column;
   private final long top = bottom << height;
-  private int draw = 0;
-  long[] playerBoard = new long[] {0L, 0L};
-  int[] heightCol = new int[7]; // Zählt wieviele Steine in dem Column sind
-  int[] move = new int[43]; // Moves werden gezählt, wenn das Array voll ist, ist das Spiel vorbei
-  int count = 0;
+  private int[] heightCol = new int[7]; // Zählt wieviele Steine in dem Column sind
+  private int[] move = new int[42]; // Moves werden gezählt, wenn das Array voll ist, ist das Spiel vorbei
+  private int count = 0;
 
+  // prüft, ob jemand gewonnen hat
   @Override
   public boolean isWin(long board) {
     int[] directions = {1, 7, 6, 8};
@@ -30,6 +29,7 @@ public class GameEngine implements GameInterface {
     return false;
   }
 
+  // führt einen Zug aus
   @Override
   public void makeMove(int col) {
     if (!isPlayable(col)) {
@@ -37,38 +37,41 @@ public class GameEngine implements GameInterface {
       return;
     }
     long moving = 1L << heightCol[col]++;
-    playerBoard[count & 1] ^= moving;
+    getPlayerBoard[count & 1] ^= moving;
     move[count++] = col;
-    draw+=1;
-    if (draw > 42) System.out.println("Draw");
-    System.out.println(Long.toBinaryString(playerBoard[0]));
+    if (count > 42) System.out.println("Draw");
+    // System.out.println(Long.toBinaryString(getPlayerBoard[0]));
     // "+Long.toBinaryString(playerBoard[0]));
   }
 
+  // nimmt ein Zug zurück
   @Override
   public void undoMove() {
     int col = move[--count];
     long move = 1L << --heightCol[col];
-    playerBoard[count & 1] ^= move;
+    getPlayerBoard[count & 1] ^= move;
   }
 
+  // Setzt das Spiel und das Board zurück
   public void reset() {
     count = 0;
-    playerBoard[0] = 0L;
-    playerBoard[1] = 0L;
+    getPlayerBoard[0] = 0L;
+    getPlayerBoard[1] = 0L;
     for (int i = 0; i < width; i++) {
       heightCol[i] = heightBottom * i;
     }
-    // System.out.println(Long.toBinaryString(playerBoard[0])+" "+Long.toBinaryString(playerBoard[0]));
+    // System.out.println(Long.toBinaryString(playerBoard[0])+"
+    // "+Long.toBinaryString(playerBoard[0]));
   }
 
+  // Hilfsvariable für isPlayable
   public boolean isLegal(long board) {
     return ((board & top) == 0L); // ist die oberste Stelle frei und ist der Zug gültig
   }
 
   public boolean isPlayable(int col) {
     return isLegal(
-        playerBoard[count & 1] | (1L << heightCol[col])); // Prüft, ob der move spielbar ist.
+        getPlayerBoard[count & 1] | (1L << heightCol[col])); // Prüft, ob der move spielbar ist.
   }
 
   // Montecarlo Bot
@@ -83,14 +86,16 @@ public class GameEngine implements GameInterface {
   }
 
   public int playRandomly(GameEngine board) {
-    int value = board.isWin(board.playerBoard[0]) ? 1 : board.isWin(board.playerBoard[1]) ? -1 : 0;
+    int value =
+        board.isWin(board.getPlayerBoard[0]) ? 1 : board.isWin(board.getPlayerBoard[1]) ? -1 : 0;
     Random rnd = new Random();
     while (value == 0) {
       ArrayList<Integer> moves = board.listMoves();
       if (moves.isEmpty()) return 0;
       int randomMove = moves.get(rnd.nextInt(moves.size()));
       board.makeMove(randomMove);
-      value = board.isWin(board.playerBoard[0]) ? 1 : board.isWin(board.playerBoard[1]) ? -1 : 0;
+      value =
+          board.isWin(board.getPlayerBoard[0]) ? 1 : board.isWin(board.getPlayerBoard[1]) ? -1 : 0;
     }
     return value;
   }
@@ -100,7 +105,8 @@ public class GameEngine implements GameInterface {
     int count = board.count;
     while (number > 0) {
       GameEngine test = new GameEngine();
-      test.playerBoard = Arrays.copyOf(board.playerBoard, board.playerBoard.length); // NUR CLONE
+      test.getPlayerBoard =
+          Arrays.copyOf(board.getPlayerBoard, board.getPlayerBoard.length); // NUR CLONE
       test.move = Arrays.copyOf(board.move, board.move.length);
       test.heightCol = Arrays.copyOf(board.heightCol, board.heightCol.length);
       test.count = count;
@@ -139,24 +145,37 @@ public class GameEngine implements GameInterface {
     return moves.get(bestIndex);
   }
 
-  @Override
-  public String toString() {
-    StringBuilder s = new StringBuilder();
-    for (int i = 0; i < width; i++) {
-      s.append(" ").append(i).append(" ");
-    }
-    s.append("\n");
-    for (int h = height - 1; h >= 0; h--) {
-      int w = h;
-      while (w < size1) {
-        long mask = 1L << w;
-        if ((playerBoard[0] & mask) != 0L) s.append(" X ");
-        else if ((playerBoard[1] & mask) != 0L) s.append(" 0 ");
-        else s.append(" . ");
-        w += heightBottom;
-      }
-      s.append("\n");
-    }
-    return s.toString();
+  public long[] getPlayerBoard() {
+    return getPlayerBoard;
+  }
+
+  public void setGetPlayerBoard(long[] getPlayerBoard) {
+    this.getPlayerBoard = getPlayerBoard;
+  }
+
+  private long[] getPlayerBoard = new long[] {0L, 0L};
+
+  public int[] getHeightCol() {
+    return heightCol;
+  }
+
+  public void setHeightCol(int[] heightCol) {
+    this.heightCol = heightCol;
+  }
+
+  public int[] getMove() {
+    return move;
+  }
+
+  public void setMove(int[] move) {
+    this.move = move;
+  }
+
+  public int getCount() {
+    return count;
+  }
+
+  public void setCount(int count) {
+    this.count = count;
   }
 }

app/src/test/java/PIS_HU1/AppTest.java

@@ -10,49 +10,34 @@ import static org.junit.Assert.*;
 public class AppTest {
   private GameEngine game = new GameEngine();
 
-  // gewinnen möglich
-  // methodes work
-  // listMoves
-  // make Move
-  // win
-  // undoMove
-  // falscher Zug
-  // board
-  // is legal
-  // is playable
-  // ungefülltes board
-  // Game Over testen
-  //Test player Turn
-  // test more move
-  //col voll
-  //move Counter
-  //cloc app/src/main/java/PIS_HU1/GameEngine.java
-
-
-
   //Es wird geschaut, ob das Board bei Spielbeginn leer ist
   @Test
   public void testEmptyBoard() {
-     Assert.assertArrayEquals("Das Spielfeld ist nicht leer, obwohl das Spiel neu gestartet wurde",game.playerBoard, new long[] {0L, 0L});
+     Assert.assertArrayEquals("Das Spielfeld ist nicht leer, obwohl das Spiel neu gestartet wurde",game.getPlayerBoard(), new long[] {0L, 0L});
   }
 
   //Es wird geprüft, ob der Zug korrekt ausgeführt worden ist und dieser richtig gespeichert wird
   @Test
   public void testMove() {
-    game.makeMove(1);
-    Assert.assertEquals("Der Zug wurde nicht richtig gespeichert","1", Long.toBinaryString(game.playerBoard[0]));
+    game.reset();
+    game.makeMove(0);
+    Assert.assertEquals("Der Zug wurde nicht richtig gespeichert","1", Long.toBinaryString(game.getPlayerBoard()[0]));
   }
 
   //es wird mehrere Züge geprüft (Warum geht es nicht mit noch mehr zügen)
   @Test
   public void testMoreMove(){
     game.makeMove(0);
+    game.makeMove(2);
+    game.makeMove(4);
     game.makeMove(1);
+    game.makeMove(2);
     game.makeMove(0);
-    Assert.assertEquals("Die Zuege wurden nicht korrekt gespeichert", "11", Long.toBinaryString(game.playerBoard[0]));
+    Assert.assertEquals("Die Zuege wurden nicht korrekt gespeichert", "10000000000001000000000000001", Long.toBinaryString(game.getPlayerBoard()[0]));
   }
 
-  /*
+  //Es wird geprüft, ob der andere Spieler nach einem Zug dran ist
+  @Test
   public void testPlayerTurn(){
     game.makeMove(0);
     Assert.assertEquals(, game.playerBoard[0]);
@@ -76,8 +61,8 @@ public class AppTest {
   @Test
   public void testWin() {
     // 1000000100000010000001 horizontal win
-    game.playerBoard[0] = Long.parseLong("1000000100000010000001", 2);
-    assertTrue("Es gibt vier Steine in Reihe,isWin erkennt dies nicht",game.isWin(game.playerBoard[0]));
+    game.getPlayerBoard()[0] = Long.parseLong("1000000100000010000001", 2);
+    assertTrue("Es gibt vier Steine in Reihe,isWin erkennt dies nicht",game.isWin(game.getPlayerBoard()[0]));
   }
 
   //Es wird ein Beispiel für einen diagonalen Sieg im Board gespeichert und dann die isWin Methode für horizontale Viererlinien getestet
@@ -136,6 +121,7 @@ public class AppTest {
     Assert.assertNotEquals(null, game.listMoves());
   }
 
+  //Prüft, ob die Methode simulatePlays auch wirklich Spiele simuliert
   @Test
   public void testSimulatePlays() {
     int[] i = {0, 0, 0};
@@ -156,4 +142,17 @@ public class AppTest {
     game.makeMove(0);
     Assert.assertEquals(0, game.chooseBestMove(game, 100));
   }
+
+  //Es wird geprüft, ob das Spiel unentschieden ausgegangen ist
+  @Test
+  public void testDraw(){
+    game.reset();
+    int[] drawCol = {6,13,20,27,34,41,48};
+    game.setHeightCol(drawCol); //heightCol prüft, ob man noch ein Stein in die Zeile setzen kann und wird hier auf den vollen Wert für alle Spalten gesetzt
+    Assert.assertTrue("Test", game.listMoves().isEmpty()); //listMoves gibt die nächsten möglichen Züge aus
+
+
+  }
+
+
 }