javaでオセロを作成したが反転に問題が生じて困っている

Question

前提・実現したいこと

java環境で8×8盤面のオセロを作成した。
- 石が置かれている、ひっくり返せないマスには置けない。
- 手番は考慮しない。
- 石を点(x,y)に置き、ひっくり返せる周囲の石を反転させたい。

発生している問題

石を反転させる処理に問題が生じる

(例)
初期配置から
黒石[5][3]
白石[3][2]
黒石[2][4]
白石[3][5]
の順に配置すると意図してない[4][4]の黒石が反転される。

問題があると思われるソースコード

 //石を置き他を反転させる
    void setStoneAndReverse(int x, int y, int s) {
	//8方向をチェック
	for (int d=0; d<8; d++) {
	    ArrayList<Integer> p = new ArrayList<Integer>();
	    p = getLine(x, y, direction[d]);
	    int cx = x;
	    int cy = y;
	    int n = 0;
	  
	    while ( n < p.size()-1 && p.get(n) != s && ste[cx][cy].obverse == s) {
		cx += direction[d].x;
		cy += direction[d].y;
		System.out.println(d);
		System.out.println("cx="+cx);
		System.out.println("cy="+cy);
		ste[cx][cy].doReverse(ste[cx][cy].obverse); 
		n++;
	    }
	}
    }

//盤面(x,y)から方向dに向かって石を順番に取得
    ArrayList<Integer> getLine(int x, int y, Point d) {
    ArrayList<Integer> line = new ArrayList<Integer>();
    int cx = x + d.x;
    int cy = y + d.y;
    while ( isOnBoard(cx, cy) && ste[cx][cy].obverse != 0) {
        line.add(ste[cx][cy].obverse); 
        cx += d.x;
        cy += d.y;
    }
    return line;
    }

試したこと

上記のsetStoneAndReverse(int x, int y, int s){}において、反転を行った方角を示すdirection[d]を出力した。
- 意図しない石が反転された際、予想外の方向にも反転を行っていることが分かった。
- このことから方角を取得するgetLine(int x, int y, Point d){}に問題があると考えた。

Stoneクラス

class Stone {
    public final static int black = 1;
    public final static int white = 2;
    public int obverse = 0;

    Stone() {
	obverse = 0;
    }

    //表面の色を設定
    void setObverse(int color) {
	if ( color == black || color == white)
	    obverse = color;
	else 
	    System.out.println("黒か白でなければいけません");
    }

    //白黒を入れ替える
    void doReverse(int color) { 
	if ( color == black )
	    obverse = white;
	else if ( color == white )
	    obverse = black;
	else 
	    System.out.println("黒か白でなければいけません");
    }

    //表面の色で中心p, 半径radの円を塗り潰す
    void paint(Graphics g, Point p, int rad) {
	if (obverse == black) {
	    g.setColor(Color.black);
	    g.fillOval(p.x - 32, p.y - 32, 2*rad, 2*rad);
	}
	else if (obverse == white) {
	    g.setColor(Color.white);
	    g.fillOval(p.x - 32, p.y - 32, 2*rad, 2*rad);
	}
    }
}

Boardクラス

class Board {
    Stone[][] ste = new Stone[8][8];
    public int num_grid_black;
    public int num_grid_white;
    private Point[] direction = new Point[8];
    public int[][] eval_black = new int[8][8];
    public int[][] eval_white = new int[8][8];
       
    //コンストラクタ初期化
    Board() {

	for(int i=0; i<8; i++) {
	    for(int j=0; j<8; j++) {
		ste[i][j] = new Stone();
	    }
	} 
	ste[3][3].setObverse(1);
	ste[3][4].setObverse(2);
	ste[4][3].setObverse(2);	
	ste[4][4].setObverse(1);
	//方向ベクトル
	direction[0] = new Point(1,0);
	direction[1] = new Point(1,1);
	direction[2] = new Point(0,1);
	direction[3] = new Point(-1,1);
	direction[4] = new Point(-1,0);
	direction[5] = new Point(-1,-1);
	direction[6] = new Point(0,-1);
	direction[7] = new Point(1,-1);
    }

    
    //盤面の中か？
    boolean isOnBoard(int x, int y) {
	if ( x<0 || 7<x || y<0 || 7<y)
	    return false;
	else 
	    return true;
    }

    //盤面(x,y)から方向dに向かって石を順番に取得
    ArrayList<Integer> getLine(int x, int y, Point d) {
	ArrayList<Integer> line = new ArrayList<Integer>();
	int cx = x + d.x;
	int cy = y + d.y;
	while ( isOnBoard(cx, cy) && ste[cx][cy].obverse > 0 ) {
	    line.add(ste[cx][cy].obverse); 
	    cx += d.x;
	    cy += d.y;
	}
	return line;
    }


    //盤面(x,y)に石sを置いた場合に反転できる石の数を数える
    int countReverseStone(int x, int y, int s) {
	//既に石が置かれていたら、置けない
	if (ste[x][y].obverse != 0) return -1;
	//8方向をチェック
	int cnt = 0;
	for (int d=0; d<8; d++) {
	    ArrayList<Integer> line = new ArrayList<Integer>();
	    line = getLine(x, y, direction[d]);
	    int n = 0;
	    while ( n < line.size() && line.get(n) != s) n++;
	    if (1 <= n && n < line.size()) cnt += n;
	}
	return cnt;
    }

    //石を置き他を反転させる
    void setStoneAndReverse(int x, int y, int s) {
	//8方向をチェック
	for (int d=0; d<8; d++) {
	    ArrayList<Integer> p = new ArrayList<Integer>();
	    p = getLine(x, y, direction[d]);
	    int cx = x;
	    int cy = y;
	    int n = 0;
	    while ( n < p.size()-1 && p.get(n) != s) {
		cx += direction[d].x;
		cy += direction[d].y;
		System.out.println(d);
		ste[cx][cy].doReverse(ste[cx][cy].obverse); 
		n++;
	    }
	}
    }


     
    //盤面を見る
    void evaluateBoard()
    {
	num_grid_black = 0;
	num_grid_white = 0;
	for ( int i=0; i<8; i++) {
	    for (int j=0; j<8; j++) {
		eval_black[i][j] = countReverseStone(i, j, 1);
		if (eval_black[i][j] > 0) num_grid_black++;
		eval_white[i][j] = countReverseStone(i, j, 2);
		if (eval_white[i][j] > 0) num_grid_white++;
	    }
	}
    } 
  
      
    //盤面をコンソールに表示する
    void printBoard() {
	for ( int i=0; i<8; i++) {
	    for (int j=0; j<8; j++) {
		System.out.printf("%2d ", ste[j][i].obverse);
	    }
	    System.out.println("");
	}
    }
 
    //盤面の評価結果をコンソールに表示する
    void printEval() {
	System.out.println("Black(1):");
	for ( int i=0; i<8; i++) { 
	    for ( int j=0; j<8; j++) {
		System.out.printf("%2d " , eval_black[j][i]);
	    }
	    System.out.println("");
	}
	System.out.println("White(2):");
	for ( int i=0; i<8; i++) { 
	    for ( int j=0; j<8; j++) {
		System.out.printf("%2d " , eval_white[j][i]);
	    } 
	    System.out.println("");
	}
    }
    

    //画面描画
    void paint(Graphics g, int unit_size) {
	
	//背景
	g.setColor(Color.black);
	g.fillRect(0, 0, unit_size*10, unit_size*10);
	
	//盤面
	g.setColor(new Color(0, 85, 0));
	g.fillRect(unit_size, unit_size, unit_size*8, unit_size*8);
	
	//横線
	g.setColor(Color.black);
	for (int i = 0; i<9 ; i++) {
	    g.drawLine(unit_size*(i+1), unit_size, unit_size*(i+1), unit_size*9 );
	}

	//縦線
	g.setColor(Color.black);
	for (int i = 0; i<9 ; i++) {
	    g.drawLine(unit_size, unit_size*(i+1), unit_size*9, unit_size*(i+1) );
	}
	
	// 目印
	for (int i=0; i<2; i++) {
	    for (int j=0; j<2; j++) {
		g.fillRect(unit_size*(3+4*i)-(unit_size/16), unit_size*(3+4*j)-(unit_size/16), (unit_size/8), (unit_size/8));
	    }	
	}
	
	//各マスの中心座標を計算した後描画
	Point p = new Point();
	int rad = ((unit_size/2) * 4 ) / 5;
	for(int i=0; i<8; i++) {
	    for(int j=0; j<8; j++) {
		p.x = (unit_size*(i+1) + unit_size*(i+2))/2;
		p.y = (unit_size*(j+1) + unit_size*(j+2))/2;
		ste[i][j].paint(g, p, rad);
	    }
	}
    }

    //クリックされたマス(x,y)に石sを配置する
    void setStone(int x, int y, int s) {
	ste[x][y].setObverse(s);
    }
}

Comments

[退会済みユーザー]

多分他にもあるけど一個だけ
Board#getLine(int x, int y, Point d)でline.add(ste[cy][cx].obverse);してるところで、cyとcxが逆。

[jimbe]

> 隣合う挟まれていない石まで反転されてしまいます
ご自身でお調べになっていると思いますが, どこまで状況と追跡されているでしょうか.

また, コードのご提示はファイル毎に分けて頂けると助かります.

[退会済みユーザー]

> また, コードのご提示はファイル毎に分けて頂けると助かります.

ご指摘ありがとうございます。問題のありそうな箇所を絞りました。

[swordone]

勘違いでコメントしました。すみません。

[退会済みユーザー]

いろいろな方がいろいろな意見を持ってるので、参考までにという話ですが、個人的な好みだけ言うと、コードは動かした方が解析が楽なので、現象を再現できる全てのコードを載せてもらった方がいいですね。
(自分で見つけてほしかったので)もうコメントする気もなかったのですが、書いてしまったので、最初のコメントで書かなかった他に気になった点も書いておきます。
・左クリックと右クリックで手番関係なく置けてしまうのが少し気になりました
・挟んでいる判定をする際に、敵色判定を抜けた後、最後が自色であることを確認してないコードがあったように思います

[swordone]

「問題があると思われるソースコード」と「Boardクラス」それぞれに存在するsetStoneAndReverseメソッドの内容が異なるのですが、現状どちらなのですか？
それから、その第3引数のsは石の色ということでいいのでしょうか？

[退会済みユーザー]

>それから、その第3引数のsは石の色ということでいいのでしょうか？
第３引数のSは石の色を表してます。

>「問題があると思われるソースコード」と「Boardクラス」それぞれに存在するsetStoneAndReverseメソッドの内容が異なるのですが、現状どちらなのですか？
すみません、修正いたします。
「Boardクラス」の方が誤りです。

Answer 1

まずは、ここ

        line.add(ste[cy][cx].obverse); 

は、こう

        line.add(ste[cx][cy].obverse); 

ですね。

あとは、順番に関係なく石を置けてしまう問題があります。
パスする処理も変です。

こちらで正常動作確認したソースコードです。

import java.awt.*;
import javax.swing.*;
import java.awt.event.*;
import java.util.*;

class Stone {
	public final static int black = 1;
	public final static int white = 2;
	public int obverse = 0;

	Stone() {
		obverse = 0;
	}

	void setObverse(int color) {
		if (color == black || color == white)
			obverse = color;
		else
			System.out.println("黒か白でなければいけません");
	}

	void doReverse(int color) {
		if (color == black)
			obverse = white;
		else if (color == white)
			obverse = black;
		else
			System.out.println("黒か白でなければいけません");
	}

	void paint(Graphics g, Point p, int rad) {
		if (obverse == black) {
			g.setColor(Color.black);
			g.fillOval(p.x - 32, p.y - 32, 2 * rad, 2 * rad);
		} else if (obverse == white) {
			g.setColor(Color.white);
			g.fillOval(p.x - 32, p.y - 32, 2 * rad, 2 * rad);
		}
	}
}

class Board {
	Stone[][] ste = new Stone[8][8];
	public int num_grid_black;
	public int num_grid_white;
	private Point[] direction = new Point[8];
	public int[][] eval_black = new int[8][8];
	public int[][] eval_white = new int[8][8];

	Board() {

		for (int x = 0; x < 8; x++) {
			for (int y = 0; y < 8; y++) {
				ste[x][y] = new Stone();
			}
		}
		ste[3][3].setObverse(1);
		ste[3][4].setObverse(2);
		ste[4][3].setObverse(2);
		ste[4][4].setObverse(1);

		direction[0] = new Point(1, 0);
		direction[1] = new Point(1, 1);
		direction[2] = new Point(0, 1);
		direction[3] = new Point(-1, 1);
		direction[4] = new Point(-1, 0);
		direction[5] = new Point(-1, -1);
		direction[6] = new Point(0, -1);
		direction[7] = new Point(1, -1);
	}

	boolean isOnBoard(int x, int y) {
		if (x < 0 || 7 < x || y < 0 || 7 < y)
			return false;
		else
			return true;
	}

	ArrayList<Integer> getLine(int x, int y, Point d) {
		ArrayList<Integer> line = new ArrayList<Integer>();
		int cx = x + d.x;
		int cy = y + d.y;
		while (isOnBoard(cx, cy) && ste[cx][cy].obverse != 0) {
			line.add(ste[cx][cy].obverse);
			cx += d.x;
			cy += d.y;
		}
		return line;
	}

	int countReverseStone(int x, int y, int s) {
		if (ste[x][y].obverse != 0)
			return -1;
		int cnt = 0;
		for (int d = 0; d < 8; d++) {
			ArrayList<Integer> line = new ArrayList<Integer>();
			line = getLine(x, y, direction[d]);
			int n = 0;
			while (n < line.size() && line.get(n) != s)
				n++;
			if (1 <= n && n < line.size())
				cnt += n;
		}
		return cnt;
	}

	void setStoneAndReverse(int x, int y, int s) {
		for (int d = 0; d < 8; d++) {
			ArrayList<Integer> p = new ArrayList<Integer>();
			p = getLine(x, y, direction[d]);
			int cx = x;
			int cy = y;
			int n = 0;

			while (n < p.size() - 1 && p.get(n) != s && ste[cx][cy].obverse == s) {
				cx += direction[d].x;
				cy += direction[d].y;
				System.out.println(d);
				System.out.println("cx=" + cx);
				System.out.println("cy=" + cy);
				ste[cx][cy].doReverse(ste[cx][cy].obverse);
				n++;
			}
		}
	}

	void evaluateBoard() {
		num_grid_black = 0;
		num_grid_white = 0;
		for (int i = 0; i < 8; i++) {
			for (int j = 0; j < 8; j++) {
				eval_black[i][j] = countReverseStone(i, j, 1);
				if (eval_black[i][j] > 0)
					num_grid_black++;
				eval_white[i][j] = countReverseStone(i, j, 2);
				if (eval_white[i][j] > 0)
					num_grid_white++;
			}
		}
	}

	void printBoard() {
		for (int y = 0; y < 8; y++) {
			for (int x = 0; x < 8; x++) {
				System.out.printf("%2d ", ste[x][y].obverse);
			}
			System.out.println("");
		}
	}

	void printEval() {
		System.out.println("Black(1):");
		for (int i = 0; i < 8; i++) {
			for (int j = 0; j < 8; j++) {
				System.out.printf("%2d ", eval_black[j][i]);
			}
			System.out.println("");
		}
		System.out.println("White(2):");
		for (int i = 0; i < 8; i++) {
			for (int j = 0; j < 8; j++) {
				System.out.printf("%2d ", eval_white[j][i]);
			}
			System.out.println("");
		}
	}

	void paint(Graphics g, int unit_size) {

		g.setColor(Color.black);
		g.fillRect(0, 0, unit_size * 10, unit_size * 10);

		g.setColor(new Color(0, 85, 0));
		g.fillRect(unit_size, unit_size, unit_size * 8, unit_size * 8);

		g.setColor(Color.black);
		for (int i = 0; i < 9; i++) {
			g.drawLine(unit_size * (i + 1), unit_size, unit_size * (i + 1), unit_size * 9);
		}

		g.setColor(Color.black);
		for (int i = 0; i < 9; i++) {
			g.drawLine(unit_size, unit_size * (i + 1), unit_size * 9, unit_size * (i + 1));
		}

		for (int i = 0; i < 2; i++) {
			for (int j = 0; j < 2; j++) {
				g.fillRect(unit_size * (3 + 4 * i) - (unit_size / 16), unit_size * (3 + 4 * j) - (unit_size / 16),
						(unit_size / 8), (unit_size / 8));
			}
		}

		Point p = new Point();
		int rad = ((unit_size / 2) * 4) / 5;
		for (int x = 0; x < 8; x++) {
			for (int y = 0; y < 8; y++) {
				p.x = (unit_size * (x + 1) + unit_size * (x + 2)) / 2;
				p.y = (unit_size * (y + 1) + unit_size * (y + 2)) / 2;
				ste[x][y].paint(g, p, rad);
			}
		}
	}

	void setStone(int x, int y, int s) {
		ste[x][y].setObverse(s);
	}
}

public class Reversi extends JPanel {
	private final static int UNIT_SIZE = 80;
	private Board board = new Board();

	private int turn = 1;

	public Reversi() {
		setPreferredSize(new Dimension(800, 800));
		addMouseListener(new MouseProc());
	}

	public void paintComponent(Graphics g) {
		board.paint(g, UNIT_SIZE);
	}

	void changeTurn() {
		if (turn == 1)
			turn = 2;
		else if (turn == 2)
			turn = 1;
	}

	void MessageDialog(String str) {
		JOptionPane.showMessageDialog(this, str, "情報", JOptionPane.INFORMATION_MESSAGE);
	}

	void EndMessageDialog(int num_black, int num_white) {
		if (num_black > num_white) {
			String str = "[黒:" + num_black + ",白:" + num_white + "]で黒の勝ち";
			JOptionPane.showMessageDialog(this, str, "ゲーム終了", JOptionPane.INFORMATION_MESSAGE);
		} else if (num_black == num_white) {
			String str = "[黒:" + num_black + ",白:" + num_white + "]で引き分け";
			JOptionPane.showMessageDialog(this, str, "ゲーム終了", JOptionPane.INFORMATION_MESSAGE);
		} else {
			String str = "[黒:" + num_black + ",白:" + num_white + "]で白の勝ち";
			JOptionPane.showMessageDialog(this, str, "ゲーム終了", JOptionPane.INFORMATION_MESSAGE);
		}

		System.exit(0);
	}

	class MouseProc extends MouseAdapter {
		public void mouseClicked(MouseEvent me) {
			Point point = me.getPoint();
			int btn = me.getButton();
			System.out.println("(" + point.x + "," + point.y + ")");
			board.evaluateBoard();
			if (turn == 1 && btn == MouseEvent.BUTTON1) {
				int x = point.x / UNIT_SIZE - 1;
				int y = point.y / UNIT_SIZE - 1;
				System.out.println("[" + x + "]" + "[" + y + "]");
				if (0 <= x && x < 8 && 0 <= y && y < 8) {
					if (board.eval_black[x][y] < 1) {
						System.out.println("そこに石を置けません");
					} else {
						board.setStone(x, y, 1);
						board.setStoneAndReverse(x, y, 1);
						repaint();
						board.printBoard();
						board.evaluateBoard();
						board.printEval();
						changeTurn();
						if (board.num_grid_black >= 1) {
							MessageDialog("白の番です");
						} else {
							changeTurn();
							MessageDialog("あなたはパスです");
						}
					}
				}
			} else if (turn == 2 && btn == MouseEvent.BUTTON3) {
				int x = point.x / UNIT_SIZE - 1;
				int y = point.y / UNIT_SIZE - 1;
				System.out.println("[" + x + "]" + "[" + y + "]");
				if (0 <= x && x < 8 && 0 <= y && y < 8) {
					if (board.eval_white[x][y] < 1) {
						System.out.println("そこに石を置けません");
					} else {
						board.setStone(x, y, 2);
						board.setStoneAndReverse(x, y, 2);
						repaint();
						board.printBoard();
						board.evaluateBoard();
						board.printEval();
						changeTurn();
						if (board.num_grid_black >= 1) {
							MessageDialog("黒の番です");
						} else {
							changeTurn();
							MessageDialog("あなたはパスです");
						}
					}
				}
			}

			int num_black = 0;
			int num_white = 0;
			for (int x = 0; x < 8; x++) {
				for (int y = 0; y < 8; y++) {
					if (board.ste[x][y].obverse == 1)
						num_black++;
					if (board.ste[x][y].obverse == 2)
						num_white++;
				}
			}

			if (board.num_grid_black < 1 && board.num_grid_white < 1) {
				EndMessageDialog(num_black, num_white);
			}
		}
	}

	public static void main(String[] args) {
		JFrame f = new JFrame();

		f.getContentPane().setLayout(new FlowLayout());
		f.getContentPane().add(new Reversi());
		f.pack();
		f.setResizable(false);
		f.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
		f.setVisible(true);
	}
}

Comments

[退会済みユーザー]

ご指摘ありがとうございます。

指定カ所を更新いたしました。

[shiracamus]

解決しませんか？

[退会済みユーザー]

解決しないですね…

[shiracamus]

*.class ファイルを全部削除して、再コンパイルしてみてはいかがでしょう？

[shiracamus]

動くようになったコードが自宅にあるので、帰宅したら修正ソースを添付します。

[shiracamus]

こちらで動作確認したソースコードを回答欄に追記しました。
文字数が多いと言われてしまったため、コメントをすべて削除してあります。

[退会済みユーザー]

追記ありがとうございます。
しかし、書いていただいたコードでも同じような問題が生じてしまいます…

Answer 2

「現在のターンの石では無い石があるか」は見ていますが, その先に現在のターンの石があるか, つまり ”挟んでいるか” という判定になっていないのではないでしょうか.

二つのメソッドを修正してみました.

  //盤面(x,y)に石sを置いた場合に反転できる石の数を数える
  int countReverseStone(int x, int y, int s) {
    //既に石が置かれていたら、置けない
    if(ste[x][y].obverse != 0)
      return -1;
    //8方向をチェック
    int cnt = 0;
    for(int d = 0; d < 8; d++) {
      ArrayList<Integer> line = new ArrayList<Integer>();
      line = getLine(x, y, direction[d]);
      //int n = 0;
      //while(n < line.size() && line.get(n) != s) n++;
      //if(1 <= n && n < line.size()) cnt += n;
      int n = line.indexOf(s);
      if(n > 0) cnt += n;
    }
    return cnt;
  }

  //石を置き他を反転させる
  void setStoneAndReverse(int x, int y, int s) {
    //8方向をチェック
    for(int d = 0; d < 8; d++) {
      ArrayList<Integer> p = getLine(x, y, direction[d]);
      int cx = x;
      int cy = y;
      int n = 0;
      //while(n < p.size() - 1 && p.get(n) != s) {
      while(n < p.indexOf(s)) {
        cx += direction[d].x;
        cy += direction[d].y;
        System.out.println(d);
        ste[cx][cy].doReverse(ste[cx][cy].obverse);
        n++;
      }
    }
  }

Comments

[退会済みユーザー]

そうですね。
”挟んでいるか”を判定をしていないですね…

[退会済みユーザー]

https://teratail.com/questions/30772
こちらの例を参考に書き直してみます。

[退会済みユーザー]

修正したところ問題無く動きました。
ありがとうございます！

[jimbe]

countReverseStone のほうの修正を for ループから indexOf に変更しました.

Answer 3

回答ではないですが、少しリファクタリングしてみました。
まだリファクタリングできるところはあると思います。

import java.util.*;
import java.util.stream.*;
import java.awt.*;
import java.awt.Point;
import java.awt.event.*;
import javax.swing.*;

interface Disk {
	public void paint(Graphics g, Point p, int size);
	public String toString();
}

class Disks {
	static final Disk NONE, BLACK, WHITE;

	static {
		NONE = new Disk() {
			public void paint(Graphics g, Point p, int size) {
			}

			public String toString() {
				return "□";
			}
		};

		BLACK = new Disk() {
			public void paint(Graphics g, Point p, int size) {
				int r = (size / 2) * 4 / 5;
				g.setColor(Color.black);
				g.fillOval(p.x - r, p.y - r, r * 2, r * 2);
			}

			public String toString() {
				return "×";
			}
		};

		WHITE = new Disk() {
			public void paint(Graphics g, Point p, int size) {
				int r = (size / 2) * 4 / 5;
				g.setColor(Color.white);
				g.fillOval(p.x - r, p.y - r, r * 2, r * 2);
			}

			public String toString() {
				return "●";
			}
		};
	}

	private static final Map<Disk, Disk> OPPOSITE = new HashMap<Disk, Disk>() {
		{
			put(NONE, NONE);
			put(BLACK, WHITE);
			put(WHITE, BLACK);
		}
	};

	static Disk opposite(Disk disk) {
		return OPPOSITE.get(disk);
	}
}

class Square {
	private Disk disk;

	Square() {
		this.disk = Disks.NONE;
	}

	boolean is_used() {
		return this.disk != Disks.NONE;
	}

	boolean is(Disk disk) {
		return this.disk == disk;
	}

	void put(Disk disk) {
		this.disk = disk;
	}

	void reverse() {
		this.disk = Disks.opposite(this.disk);
	}

	void paint(Graphics g, Point p, int size) {
		disk.paint(g, p, size);
	}

	public String toString() {
		return disk.toString();
	}
}

class Board {
	final Square[][] squares = new Square[8][8];
	final int[][] eval_black = new int[8][8];
	final int[][] eval_white = new int[8][8];

	private static final Color COLOR = new Color(0, 85, 0);
	private static final Point[] DIRECTION = {
		new Point(-1, -1),
		new Point( 0, -1),
		new Point( 1, -1),
		new Point(-1,  0),
		new Point( 1,  0),
		new Point(-1,  1),
		new Point( 0,  1),
		new Point( 1,  1),
	};

	Board() {
		for (int x = 0; x < 8; x++) {
			for (int y = 0; y < 8; y++) {
				squares[x][y] = new Square();
			}
		}
		squares[3][3].put(Disks.WHITE);
		squares[4][3].put(Disks.BLACK);
		squares[3][4].put(Disks.BLACK);
		squares[4][4].put(Disks.WHITE);
	}

	boolean isOnBoard(int x, int y) {
		return 0 <= x && x < 8 && 0 <= y && y < 8;
	}

	long count(Disk disk) {
		return Arrays.stream(squares)
		             .flatMap(Stream::of)
		             .filter(m -> m.is(disk))
		             .count();
	}

	class Reversible {
		final ArrayList<Point> points = new ArrayList<Point>();

		void add(Point point) {
			points.add(point);
		}

		void removeAll() {
			points.clear();
		}

		int count() {
			return points.size();
		}

		void reverse() {
			for (Point p: points) {
				squares[p.x][p.y].reverse();
			}
		}
	}

	Reversible getReversible(int x, int y, Point d, Disk s) {
		Reversible reversible = new Reversible();
		Disk opposite = Disks.opposite(s);
		x += d.x;
		y += d.y;
		while (isOnBoard(x, y) && squares[x][y].is(opposite)) {
			reversible.add(new Point(x, y));
			x += d.x;
			y += d.y;
		}
		if (!(isOnBoard(x, y) && squares[x][y].is(s)))
			reversible.removeAll();
		return reversible;
	}

	int countReversible(int x, int y, Disk s) {
		if (squares[x][y].is_used())
			return -1;

		return Arrays.stream(DIRECTION)
		             .mapToInt(d -> getReversible(x, y, d, s).count())
		             .sum();
	}

	void putAndReverse(int x, int y, Disk s) {
		squares[x][y].put(s);
		Arrays.stream(DIRECTION).forEach(d -> getReversible(x, y, d, s).reverse());
	}

	void evaluate() {
		for (int x = 0; x < 8; x++) {
			for (int y = 0; y < 8; y++) {
				eval_black[x][y] = countReversible(x, y, Disks.BLACK);
				eval_white[x][y] = countReversible(x, y, Disks.WHITE);
			}
		}
	}

	void printBoard() {
		for (int y = 0; y < 8; y++) {
			for (int x = 0; x < 8; x++) {
				System.out.printf("%s ", squares[x][y]);
			}
			System.out.println();
		}
	}

	void printEvaluation() {
		System.out.println("Black(" + Disks.BLACK + "):");
		for (int y = 0; y < 8; y++) {
			for (int x = 0; x < 8; x++) {
				System.out.printf("%2d ", eval_black[x][y]);
			}
			System.out.println();
		}
		System.out.println("White(" + Disks.WHITE + "):");
		for (int y = 0; y < 8; y++) {
			for (int x = 0; x < 8; x++) {
				System.out.printf("%2d ", eval_white[x][y]);
			}
			System.out.println();
		}
	}

	void paint(Graphics g, int square_size) {

		// Background
		g.setColor(Color.black);
		g.fillRect(0, 0, square_size * 10, square_size * 10);

		// Board
		g.setColor(Board.COLOR);
		g.fillRect(square_size, square_size, square_size * 8, square_size * 8);

		// Horizontal Line
		g.setColor(Color.black);
		for (int x = 0; x < 9; x++) {
			g.drawLine(square_size * (x + 1), square_size, square_size * (x + 1), square_size * 9);
		}

		// Vertical Line
		g.setColor(Color.black);
		for (int y = 0; y < 9; y++) {
			g.drawLine(square_size, square_size * (y + 1), square_size * 9, square_size * (y + 1));
		}

		// Dots
		for (int x = 0; x < 2; x++) {
			for (int y = 0; y < 2; y++) {
				g.fillRect(square_size * (3 + 4 * x) - (square_size / 16),
				           square_size * (3 + 4 * y) - (square_size / 16),
				           square_size / 8,
				           square_size / 8);
			}
		}

		// Disk
		Point p = new Point();
		for (int x = 0; x < 8; x++) {
			for (int y = 0; y < 8; y++) {
				p.x = square_size * (x + 1) + square_size / 2;
				p.y = square_size * (y + 1) + square_size / 2;
				squares[x][y].paint(g, p, square_size);
			}
		}
	}
}

class Player {
	private final String name;
	private final Disk disk;
	private final int[][] reversible;

	Player(String name, Disk disk, int[][] reversible) {
		this.name = name;
		this.disk = disk;
		this.reversible = reversible;
	}

	public String toString() {
		return name;
	}

	boolean putable(Board board, int x, int y) {
		return reversible[x][y] >= 1;
	}

	void putAndReverse(Board board, int x, int y) {
		board.putAndReverse(x, y, disk);
	}

	long count(Board board) {
		return board.count(disk);
	}

	boolean pass() {
		for (int[] row: reversible) {
			for (int n: row) {
				if (n >= 1)
					return false;
			}
		}
		return true;
	}
}

public class Reversi extends JPanel {
	private static final int SQUARE_SIZE = 80;
	private final Board board = new Board();
	private final Player player1 = new Player("黒", Disks.BLACK, board.eval_black);
	private final Player player2 = new Player("白", Disks.WHITE, board.eval_white);
	private Player player = player1;

	public Reversi() {
		setPreferredSize(new Dimension(800, 800));
		addMouseListener(new MouseHandler());
	}

	void turnPlayer() {
		player = player == player1 ? player2 : player1;
	}

	public void paintComponent(Graphics g) {
		board.paint(g, SQUARE_SIZE);
	}

	void showMessage(String message, String title) {
		JOptionPane.showMessageDialog(this, message, title, JOptionPane.INFORMATION_MESSAGE);
	}

	void showMessage(String message) {
		showMessage(message, "情報");
	}

	void endGameAndExit() {
		long num_player1 = player1.count(board);
		long num_player2 = player2.count(board);
		String message = "["
		               + player1 + ":" + num_player1 + ","
		               + player2 + ":" + num_player2 + "]で";
		if (num_player1 > num_player2) {
			message += player1 + "の勝ち";
		} else if (num_player1 <= num_player2) {
			message += player2 + "の勝ち";
		} else {
			message += "引き分け";
		}
		showMessage(message, "ゲーム終了");

		System.exit(0);
	}

	class MouseHandler extends MouseAdapter {
		public void mouseClicked(MouseEvent me) {
			board.printBoard();
			Point point = me.getPoint();
			System.out.println("(" + point.x + "," + point.y + ")");
			int x = point.x / SQUARE_SIZE - 1;
			int y = point.y / SQUARE_SIZE - 1;
			if (!(0 <= x && x < 8 && 0 <= y && y < 8)) return;
			System.out.println("[" + x + "]" + "[" + y + "]");
			int btn = me.getButton();
			if (player == player1 && btn == MouseEvent.BUTTON1 ||
			    player == player2 && btn == MouseEvent.BUTTON3) {
				put(x, y);
			}
		}
	}
	
	void put(int x, int y) {
		board.evaluate();
		if (!player.putable(board, x, y)) {
			System.out.println("そこに石を置けません");
			return;
		}
		player.putAndReverse(board, x, y);
		repaint();
		board.printBoard();
		board.evaluate();
		board.printEvaluation();

		if (player1.pass() && player2.pass()) {
			endGameAndExit();
		}
		turnPlayer();
		if (player.pass()) {
			showMessage(player + "はパスです");
			turnPlayer();
		}
		showMessage(player + "の番です");
	}

	public static void main(String[] args) {
		JFrame f = new JFrame();
		f.getContentPane().setLayout(new FlowLayout());
		f.getContentPane().add(new Reversi());
		f.pack();
		f.setResizable(false);
		f.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
		f.setVisible(true);
	}
}

Comments

[退会済みユーザー]

こちらのソースコードでは特に問題無く機能しておりました。