java实现的五子棋

创建一个简单的五子棋游戏，带GUI界面。不多说，上代码。首先上的是五子棋模型。这个模型提供简单的放置棋子，判断是否五子相连，也就是是否赢了。代码如下所示。

/**game five in a row
* */
public class FiveInARowModel {
public static final int EMPTY=0;//no chessman
public static final int BLACK=1;//black chessman
public static final int WHITE=2;//white chessman
private int[][]board;
private int lastPutRow,lastPutCol;
public FiveInARowModel(int dimension){
board=new int[dimension][dimension];
clear();
}
public int getDimension(){
return board.length;
}
public int getChessman(int row,int col){
return board[row][col];
}
public boolean isEmpty(int row,int col){
return EMPTY==getChessman(row, col);
}
public boolean isFull(){
for(int k=0;k<board.length;++k)
for(int j=0;j<board.length;++j)
if(isEmpty(k, j))
return false;
return true;
}
public void clear(){
//board=new int[board.length][board.length];
for(int k=0;k<board.length;++k)
for(int j=0;j<board.length;++j)
board[k][j]=EMPTY;
lastPutRow=lastPutCol=-1;
}
/**@return last position of the chessman put on the board
* */
public int[]getLastPut(){
return new int[]{lastPutRow,lastPutCol};
}
public boolean trySetChessman(int row,int col,int chessman){
if(!isEmpty(row, col))
return false;
if(chessman!=BLACK&&chessman!=WHITE)
return false;
board[row][col]=chessman;
//lastPutRow=row;
//lastPutCol=col;
boolean win= checkWin(row, col);
board[row][col]=EMPTY;
return win;
}
/**put a chessman on the board
* @param row row of position to put chessman
* @param col column of position to put chessman
* @param chessman type of chessman to put
* @return true if the putter wins
* */
public boolean setChessman(int row,int col,int chessman) throws Exception{
if(!isEmpty(row, col))
throw new Exception("Non-empty position!");
if(chessman!=BLACK&&chessman!=WHITE)
throw new Exception("Invalid chessman");
board[row][col]=chessman;
lastPutRow=row;
lastPutCol=col;
return checkWin(row, col);
}
//chech whether five chessmans in a line
private boolean checkWin(int row,int col){
//left->right
int chessman=getChessman(row, col);
int selfChessManNum=1;
for(int left=col-1;
left>=0&&getChessman(row, left)==chessman;
--left,++selfChessManNum);
for(int right=col+1;
right<getDimension()&&getChessman(row, right)==chessman;
++right,++selfChessManNum);
if(selfChessManNum>=5)
return true;
//up->down
selfChessManNum=1;
for(int up=row-1;
up>=0&&getChessman(up,col)==chessman;
--up,++selfChessManNum);
for(int down=row+1;
down<getDimension()&&getChessman(down,col)==chessman;
++down,++selfChessManNum);
if(selfChessManNum>=5)
return true;
//left-up->right-down
selfChessManNum=1;
for(int left=col-1,up=row-1;
left>=0&&up>=0&&getChessman(up, left)==chessman;
--left,--up,++selfChessManNum);
for(int right=col+1,down=row+1;
right<getDimension()&&down<getDimension()&&getChessman(down, right)==chessman;
++right,++down,++selfChessManNum);
if(selfChessManNum>=5)
return true;
//right-up->left-down
selfChessManNum=1;
for(int left=col-1,down=row+1;
left>=0&&down<getDimension()&&getChessman(down, left)==chessman;
--left,++down,++selfChessManNum);
for(int right=col+1,up=row-1;
right<getDimension()&&up>=0&&getChessman(up, right)==chessman;
++right,--up,++selfChessManNum);
if(selfChessManNum>=5)
return true;
return false;
}
}
接着是计算机玩家的代码。这里只是个简单的框架，只做最简单的判断，首先看是否有四子相连，则直接赢棋，否则就是下子堵另一方。
import java.util.Random;

//
public class ComputerPlayer {
private FiveInARowModel board;
private int chessman;
public ComputerPlayer(FiveInARowModel board,int chessman){
this.board=board;
this.chessman=chessman;
}
/**
* put a chessman on board
* @return true if computer wins
* */
public boolean play(){
int[]anotherPlayerPut=board.getLastPut();
if(anotherPlayerPut[0]<0){
try {
board.setChessman(board.getDimension()/2, board.getDimension()/2, chessman);
} catch (Exception e) {
}
return false;
}
int row=anotherPlayerPut[0],col=anotherPlayerPut[1];
int nearRow=-1,nearCol=-1,dis=2*board.getDimension();
//search a position if player can win
for(int k=0;k<board.getDimension();++k)
for(int j=0;j<board.getDimension();++j)
if(board.isEmpty(k, j)){
if(Math.abs(k-row)+Math.abs(j-col)<dis){
nearCol=j;
nearRow=k;
dis=Math.abs(k-row)+Math.abs(j-col);
}
if(board.trySetChessman(k, j, chessman)){
try {
return board.setChessman(k, j, chessman);
} catch (Exception e) {
//impossible to get here
return false;
}
}
}
//
//left->right
//check whether another player has more than 3 chessman in a row
if(checkLeftToRight(row, col))
return false;
if(checkUpToDown(row, col))
return false;
if(checkLeftUpToRightDown(row, col))
return false;
if(checkLeftDownToRightUp(row, col))
return false;
//choose a position randomly
try {
board.setChessman(nearRow, nearCol, chessman);
} catch (Exception e) {
}
return false;
}
private boolean checkLeftToRight(int row,int col){
return check(row,col,0,1);
}
private boolean checkUpToDown(int row,int col){
return check(row,col,1,0);
}
private boolean checkLeftUpToRightDown(int row,int col){
return check(row,col,1,1);
}
private boolean checkLeftDownToRightUp(int row,int col){
return check(row,col,-1,1);
}
//check chessmans in a line. If more than 3 chessmans in a row, then blocked it
private boolean check(int row,int col,int drow,int dcol){
int startRow=row-drow,startCol=col-dcol,
endRow=row+drow,endCol=col+dcol;
int chessman=board.getChessman(row, col);
int sameChessNum=1;
while(startRow>=0&&startCol>=0&&board.getChessman(startRow, startCol)==chessman){
startRow-=drow;
startCol-=dcol;
++sameChessNum;
}
while(endRow<board.getDimension()
&&endCol<board.getDimension()
&&board.getChessman(endRow, endCol)==chessman){
endRow+=drow;
endCol+=dcol;
++sameChessNum;
}
if(sameChessNum>=3){//more than 3 chessman in a row
if(startRow>=0&&startCol>=0&&board.isEmpty(startRow, startCol)){
try {
board.setChessman(startRow, startCol, this.chessman);
return true;
} catch (Exception e) {
}
}else if(endRow<board.getDimension()
&&endCol<board.getDimension()&&board.isEmpty(endRow, endCol)){
try {
board.setChessman(endRow, endCol, this.chessman);
return true;
} catch (Exception e) {
}
}
}
return false;
}
}


然后创建一个棋盘面板。显示棋局，设置好鼠标事件处理。
import java.awt.Color;
import java.awt.FontMetrics;
import java.awt.Graphics;
import java.awt.Graphics2D;
import java.awt.Point;
import java.awt.event.MouseAdapter;
import java.awt.event.MouseEvent;
import java.awt.geom.Rectangle2D;

import javax.swing.JOptionPane;
import javax.swing.JPanel;

public class BoardPanel extends JPanel {
public static final int WIDTH=600;
public static final int HEIGHT=600;
private static int MARGIN=20;
private FiveInARowModel board;//chessman board
private ComputerPlayer computerPlayer;
public BoardPanel(FiveInARowModel board){
this.board=board;
computerPlayer=new ComputerPlayer(board, FiveInARowModel.BLACK);
this.setBackground(Color.WHITE);
addMouseListener(new MouseAdapter() {
public void mouseClicked(MouseEvent e) {
Point p=e.getPoint();
int row,col;
int dim=BoardPanel.this.board.getDimension();
int cellWidth=(getWidth()-2*MARGIN)/dim;
if(p.y>=MARGIN&&p.y<MARGIN+dim*cellWidth&&
p.x>=MARGIN&&p.x<MARGIN+dim*cellWidth){
row=(p.y-MARGIN)/cellWidth;
col=(p.x-MARGIN)/cellWidth;
if(!BoardPanel.this.board.isEmpty(row, col))
return;
try {
//user put a chessman
boolean win=BoardPanel.this.board.setChessman(row, col, FiveInARowModel.WHITE);
BoardPanel.this.drawChessman(row, col);
if(win){//user wins
JOptionPane.showMessageDialog(BoardPanel.this, "You win!");
BoardPanel.this.board.clear();
BoardPanel.this.repaint();
}else if(BoardPanel.this.board.isFull()){//full
JOptionPane.showMessageDialog(BoardPanel.this, "No empty cell!");
BoardPanel.this.board.clear();
BoardPanel.this.repaint();
}else{
//computer put a chessman
win=computerPlayer.play();
int[]last=BoardPanel.this.board.getLastPut();
row=last[0];
col=last[1];
BoardPanel.this.drawChessman(row, col);
if(win){//computer wins
JOptionPane.showMessageDialog(BoardPanel.this, "Computer win!");
BoardPanel.this.board.clear();
BoardPanel.this.repaint();
}else if(BoardPanel.this.board.isFull()){
JOptionPane.showMessageDialog(BoardPanel.this, "No empty cell!");
BoardPanel.this.board.clear();
BoardPanel.this.repaint();
}
}
} catch (Exception e1) {
e1.printStackTrace();
}
}
}
});
}
public int getWidth() {
return WIDTH;
}
public int getHeight() {
return HEIGHT;
}
public void paint(Graphics g) {
Graphics2D g2d=(Graphics2D) g;
//fill white back ground
g2d.setColor(Color.CYAN);
g2d.fillRect(0, 0, WIDTH, HEIGHT);
//write tip
g2d.setColor(Color.BLACK);
g2d.drawString("Computer", MARGIN, MARGIN*2/3);
FontMetrics fm=g2d.getFontMetrics();
Rectangle2D rect=fm.getStringBounds("Computer", g2d);
int r=MARGIN-2;
g2d.drawOval(MARGIN+(int)rect.getWidth()+r, 0, r, r);
g2d.fillOval(MARGIN+(int)rect.getWidth()+r, 0, r, r);

g2d.drawString("User", WIDTH/2, MARGIN*2/3);
rect=fm.getStringBounds("User", g2d);
g2d.drawOval(WIDTH/2+(int)rect.getWidth()+r, 0, r, r);
g2d.setColor(Color.WHITE);
g2d.fillOval(WIDTH/2+(int)rect.getWidth()+r, 0, r, r);

//draw background of board
int cellWidth=(getWidth()-2*MARGIN)/board.getDimension();
g2d.setColor(Color.GRAY);
g2d.fillRect(MARGIN, MARGIN,
cellWidth*board.getDimension(), cellWidth*board.getDimension());
//draw lines
g2d.setColor(Color.BLACK);
for(int k=0;k<board.getDimension()+1;++k){
g2d.drawLine(MARGIN+k*cellWidth, MARGIN,
MARGIN+k*cellWidth, MARGIN+cellWidth*board.getDimension());
g2d.drawLine(MARGIN, MARGIN+k*cellWidth,
MARGIN+cellWidth*board.getDimension(), MARGIN+k*cellWidth);
}
for(int k=0;k<board.getDimension();++k){
for(int j=0;j<board.getDimension();++j)
drawChessman(k, j);
}
}
private void drawChessman(int row,int col){
int chessman=board.getChessman(row, col);
if(chessman!=FiveInARowModel.BLACK&&chessman!=FiveInARowModel.WHITE)
return;
int x,y;
int cellWidth=(getWidth()-2*MARGIN)/board.getDimension();
x=MARGIN+col*cellWidth;
y=MARGIN+row*cellWidth;
Graphics2D g2d=(Graphics2D) this.getGraphics();
int pad=2;
Color color=chessman==FiveInARowModel.BLACK?Color.BLACK:Color.WHITE;
g2d.setColor(color);
g2d.fillOval(x+pad, y+pad, cellWidth-2*pad, cellWidth-2*pad);
}
}


接着就是创建一个主窗口，将棋盘放在中央。
import java.awt.BorderLayout;

import javax.swing.JFrame;

public class MainFrame extends JFrame {
public MainFrame() {
FiveInARowModel board=new FiveInARowModel(19);
BoardPanel panel=new BoardPanel(board);
getContentPane().add(panel,BorderLayout.CENTER);
setSize(panel.getWidth(),10+panel.getHeight());
setResizable(false);
setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
}

}


终于，到了主函数了。
public class Main {
public static void main(String[]args){
MainFrame mf=new MainFrame();
mf.setVisible(true);
}

}
好了。看看结果吧。这是初始界面。



接着是下棋的界面。



好了，最后是用户赢了。



总体就是这样了，代码很简单。主要就是计算机的智能太低了，不过显然这是可以改进的。当然了，五子棋模型类也需要改进，毕竟现在不支持退回。