Fix Bug ReversiModel. fixes #310 @30m

src/main/java/com/mizo0203/shiki/domain/Translator.java

@@ -36,9 +36,12 @@ public Date parseTime(String time) {
   }
 
   public boolean play(ReversiModel reversiModel, String message, Pieces pieces) {
+    if (message.length() != 2) {
+      return false;
+    }
     int x = parseX(message);
     int y = parseY(message);
-    return reversiModel.play(x, y, pieces);
+    return x != 0 && y != 0 && reversiModel.play(x, y, pieces);
   }
 
   private int parseX(String message) {
@@ -74,8 +77,12 @@ private int parseX(String message) {
   }
 
   private int parseY(String message) {
-    String y = message.substring(1, 2);
-    return Integer.parseInt(y);
+    try {
+      String y = message.substring(1, 2);
+      return Integer.parseInt(y);
+    } catch (NumberFormatException e) {
+      return 0;
+    }
   }
 
   public String parseLineMessageText(ReversiModel reversiModel, Pieces pieces) {

src/main/java/com/mizo0203/shiki/domain/model/ReversiModel.java

@@ -4,7 +4,6 @@
 import javax.validation.constraints.Min;
 import javax.validation.constraints.NotNull;
 import java.util.Arrays;
-import java.util.logging.Logger;
 
 public class ReversiModel {
   public static final int A = 1;
@@ -15,43 +14,40 @@ public class ReversiModel {
   public static final int F = 6;
   public static final int G = 7;
   public static final int H = 8;
-  public static final int PERIMETER = 8;
-  private static final Logger LOG = Logger.getLogger(ReversiModel.class.getName());
-  private final Pieces[][] borad = new Pieces[10][10];
+  private static final int PERIMETER = 8;
+  private final Pieces[][] board = new Pieces[10][10];
   private final int[] dx_array = new int[] {-1, 0, 1, -1, 1, -1, 0, 1};
   private final int[] dy_array = new int[] {-1, -1, -1, 0, 0, 1, 1, 1};
 
   public boolean play(@Min(1) @Max(8) int x, @Min(1) @Max(8) int y, Pieces pieces) {
-    LOG.info("play x: " + x + " y: " + y + " p: " + pieces);
     if (reversePieces(x, y, pieces) == 0) {
       return false;
     }
-    borad[x][y] = pieces;
+    board[y][x] = pieces;
     return true;
   }
 
   public void setPieces(@Min(1) @Max(8) int x, @Min(1) @Max(8) int y, Pieces pieces) {
-    borad[x][y] = pieces;
+    board[y][x] = pieces;
   }
 
   @NotNull
   public Pieces getPieces(@Min(1) @Max(8) int x, @Min(1) @Max(8) int y) {
-    return borad[x][y];
+    return board[y][x];
   }
 
   public void reset() {
-    for (Pieces[] piecesLine : borad) {
+    for (Pieces[] piecesLine : board) {
       Arrays.fill(piecesLine, Pieces.EMPTY);
     }
-    borad[4][D] = Pieces.WHITE;
-    borad[4][E] = Pieces.BLACK;
-    borad[5][D] = Pieces.BLACK;
-    borad[5][E] = Pieces.WHITE;
+    board[4][D] = Pieces.WHITE;
+    board[4][E] = Pieces.BLACK;
+    board[5][D] = Pieces.BLACK;
+    board[5][E] = Pieces.WHITE;
   }
 
   private int reversePieces(@Min(1) @Max(8) int x, @Min(1) @Max(8) int y, Pieces oneself) {
-    if (borad[y][x] != Pieces.EMPTY) {
-      LOG.info("reversePieces 1 cnt: " + 0);
+    if (board[y][x] != Pieces.EMPTY) {
       return 0;
     }
     int cnt = 0;
@@ -60,44 +56,32 @@ private int reversePieces(@Min(1) @Max(8) int x, @Min(1) @Max(8) int y, Pieces o
       int dy = dy_array[i];
       int dx = dx_array[i];
       int d = 1;
-      while (borad[y + (dy * d)][x + (dx * d)] == opponent) {
+      while (board[y + (dy * d)][x + (dx * d)] == opponent) {
         d++;
       }
-      LOG.info(
-          "dx: "
-              + dx
-              + " dy: "
-              + dy
-              + " d: "
-              + d
-              + " b: "
-              + borad[y + (dy * d)][x + (dx * d)]
-              + " oneself: "
-              + oneself);
-      if (borad[y + (dy * d)][x + (dx * d)] == oneself) {
+      if (board[y + (dy * d)][x + (dx * d)] == oneself) {
         for (int j = 1; j < d; j++) {
-          borad[y + (dy * j)][x + (dx * j)] = oneself;
+          board[y + (dy * j)][x + (dx * j)] = oneself;
           cnt++;
         }
       }
     }
-    LOG.info("reversePieces 2 cnt: " + cnt);
     return cnt;
   }
 
   private boolean canReversePieces(@Min(1) @Max(8) int x, @Min(1) @Max(8) int y, Pieces oneself) {
-    if (borad[y][x] != Pieces.EMPTY) {
+    if (board[y][x] != Pieces.EMPTY) {
       return false;
     }
     Pieces opponent = oneself.getOpponent();
     for (int i = 0; i < PERIMETER; i++) {
       int dy = dy_array[i];
       int dx = dx_array[i];
       int d = 1;
-      while (borad[y + (dy * d)][x + (dx * d)] == opponent) {
+      while (board[y + (dy * d)][x + (dx * d)] == opponent) {
         d++;
       }
-      if (borad[y + (dy * d)][x + (dx * d)] == oneself) {
+      if (board[y + (dy * d)][x + (dx * d)] == oneself) {
         if (1 < d) {
           return true;
         }