Java+Swing实现经典五子棋游戏
作者：小虚竹and掘金
五子棋是世界智力运动会竞技项目之一，是一种两人对弈的纯策略型棋类游戏，是世界智力运动会竞技项目之一。本文将采用Java Swing实现这一经典游戏，需要的可以参考一下
前言
五子棋是世界智力运动会竞技项目之一，是一种两人对弈的纯策略型棋类游戏，是世界智力运动会竞技项目之一，通常双方分别使用黑白两色的棋子，下在棋盘直线与横线的交叉点上，先形成5子连线者获胜。
棋具与围棋通用，起源于中国上古时代的传统黑白棋种之一。主要流行于华人和汉字文化圈的国家以及欧美一些地区，是世界上最古老的棋。
容易上手，老少皆宜，而且趣味横生，引人入胜；不仅能增强思维能力，提高智力，而且富含哲理，有助于修身养性。
用java语言实现，采用了swing技术进行了界面化处理，设计思路用了面向对象思想。
主要需求
1、对局双方各执一色棋子。
2、空棋盘开局。
3、黑先、白后，交替下子，每次只能下一子。
4、棋子下在棋盘的空白点上，棋子下定后，不得向其它点移动，不得从棋盘上拿掉或拿起另落别处。
5、黑方的第一枚棋子可下在棋盘任意交叉点上。
6、轮流下子是双方的权利，但允许任何一方放弃下子权，先形成5子连线者获胜。
主要设计
1、由于是两人的游戏，非单机版，所以要有多个客户端相互通信，这时就要用到socket 技术
2、设计socket服务端，用来维护socket客户端连接
3、设计socket客户端，用来实现五子棋逻辑和效果
4、客户端要能设置连接服务端的IP，用来连接服务端
5、客户端1创建游戏后，客户端2可以选择客户端1进行联机对战
6、游戏规则：
- 对局双方各执一色棋子。
- 空棋盘开局。
- 黑先、白后，交替下子，每次只能下一子。
- 棋子下在棋盘的空白点上，棋子下定后，不得向其它点移动，不得从棋盘上拿掉或拿起另落别处。
- 黑方的第一枚棋子可下在棋盘任意交叉点上。
- 轮流下子是双方的权利，但允许任何一方放弃下子权，先形成5子连线者获胜。
功能截图
服务端启动
客户端1启动
客户端2启动
对战效果
代码实现
服务端启动类
public class ServerRunner extends Frame implements ActionListener {
JButton clearMsgButton = new JButton("清空");
JButton serverStatusButton = new JButton("状态");
JButton closeServerButton = new JButton("关闭");
Panel buttonPanel = new Panel();
ServerMsgPanel serverMsgPanel = new ServerMsgPanel();
ServerSocket serverSocket;
int clientAccessNumber = 1;
/**
* 将客户端套接口和输出流绑定
*/
Hashtable clientDataHash = new Hashtable(50);
/**
* 将客户端套接口和客户名绑定
*/
Hashtable clientNameHash = new Hashtable(50);
/**
* 将游戏创建者和游戏加入者绑定
*/
Hashtable chessPeerHash = new Hashtable(50);
public ServerRunner() {
super("网络游戏对战平台服务器控制平台");
setBackground(Color.PINK);
buttonPanel.setLayout(new FlowLayout());
clearMsgButton.setSize(50, 30);
buttonPanel.add(clearMsgButton);
clearMsgButton.addActionListener(this);
serverStatusButton.setSize(50, 30);
buttonPanel.add(serverStatusButton);
serverStatusButton.addActionListener(this);
closeServerButton.setSize(50, 30);
buttonPanel.add(closeServerButton);
closeServerButton.addActionListener(this);
add(serverMsgPanel, BorderLayout.CENTER);
add(buttonPanel, BorderLayout.SOUTH);
addWindowListener(new WindowAdapter() {
@Override
public void windowClosing(WindowEvent e) {
System.exit(0);
}
});
pack();
setVisible(true);
setSize(600, 440);
setResizable(false);
validate();
try {
createServer(1234, serverMsgPanel);
} catch (Exception e) {
e.printStackTrace();
}
}
/**
* 用指定端口和面板创建服务器
* @param port
* @param serverMsgPanel
* @throws IOException
*/
public void createServer(int port, ServerMsgPanel serverMsgPanel) throws IOException {
// 客户端套接口
Socket clientSocket;
// 设定当前主机
this.serverMsgPanel = serverMsgPanel;
try {
serverSocket = new ServerSocket(port);
serverMsgPanel.msgTextArea.setText("服务器启动:"
+ InetAddress.getLocalHost() + ":"
+ serverSocket.getLocalPort() + "\n");
while (true) {
// 监听客户端套接口的信息
clientSocket = serverSocket.accept();
serverMsgPanel.msgTextArea.append("已连接用户:" +
"毅慎" + clientAccessNumber +"\n" + clientSocket + "\n");
// 建立客户端输出流
DataOutputStream outputData = new DataOutputStream(clientSocket.getOutputStream());
// 将客户端套接口和输出流绑定
clientDataHash.put(clientSocket, outputData);
// 将客户端套接口和客户名绑定
clientNameHash.put(clientSocket, ("毅慎" + clientAccessNumber++));
// 创建并运行服务器端线程
ServerThread thread = new ServerThread(clientSocket,
clientDataHash, clientNameHash, chessPeerHash, serverMsgPanel);
thread.start();
}
} catch (IOException ex) {
ex.printStackTrace();
}
}
@Override
public void actionPerformed(ActionEvent e) {
// 清空服务器信息
if (e.getSource() == clearMsgButton) {
serverMsgPanel.msgTextArea.setText("");
}
// 显示服务器信息
if (e.getSource() == serverStatusButton) {
try {
serverMsgPanel.msgTextArea.append("用户信息：" + "毅慎"
+ (clientAccessNumber - 1) + "\n服务器信息:"
+ InetAddress.getLocalHost() + ":"
+ serverSocket.getLocalPort() + "\n");
} catch (Exception ee) {
ee.printStackTrace();
}
}
}
public static void main(String[] args) {
new ServerRunner();
}
}客户端启动类
/**
* @Author: Mr_OO
* @Date: 2019/12/22 9:05
* 客户端
*/
public class ClientChess extends Frame implements ActionListener, KeyListener {
/**
* 客户端套接口
*/
public Socket clientSocket;
/**
* 数据输入流
*/
public DataInputStream inputStream;
/**
* 数据输出流
*/
public DataOutputStream outputStream;
/**
* 用户名
*/
public String chessClientName = null;
/**
* 主机地址
*/
public String host = null;
/**
* 主机端口
*/
public int port = 1234;
/**
* 是否在聊天
*/
public boolean isOnChat = false;
/**
* 是否在下棋
*/
public boolean isOnChess = false;
/**
* 游戏是否进行中
*/
public boolean isGameConnected = false;
/**
* 是否为游戏创建者
*/
public boolean isCreator = false;
/**
* 是否为游戏加入者
*/
public boolean isParticipant = false;
/**
* 用户列表区
*/
public UserList userListPad = new UserList();
/**
* 用户聊天区
*/
protected UserChat userChatPad = new UserChat();
/**
* 用户操作区
*/
public UserController userControlPad = new UserController();
/**
* 用户输入区
*/
protected UserInput userInputPad = new UserInput();
/**
* 下棋区
*/
ChessBoard chessBoard = new ChessBoard();
/**
* 面板区
*/
private Panel southPanel = new Panel();
private Panel centerPanel = new Panel();
private Panel eastPanel = new Panel();
/**
* 构造方法，创建界面
*/
public ClientChess() {
super("五子棋客户端");
setLayout(new BorderLayout());
host = userControlPad.ipInputted.getText();
eastPanel.setLayout(new BorderLayout());
eastPanel.add(userListPad, BorderLayout.NORTH);
eastPanel.add(userChatPad, BorderLayout.CENTER);
eastPanel.setBackground(new Color(238, 154, 73));
userInputPad.contentInputted.addKeyListener(this);
chessBoard.host = (userControlPad.ipInputted.getText());
centerPanel.add(chessBoard, BorderLayout.CENTER);
centerPanel.add(userInputPad, BorderLayout.SOUTH);
centerPanel.setBackground(new Color(238, 154, 73));
userControlPad.connectButton.addActionListener(this);
userControlPad.createButton.addActionListener(this);
userControlPad.joinButton.addActionListener(this);
userControlPad.cancelButton.addActionListener(this);
userControlPad.exitButton.addActionListener(this);
userControlPad.createButton.setEnabled(false);
userControlPad.joinButton.setEnabled(false);
userControlPad.cancelButton.setEnabled(false);
southPanel.add(userControlPad, BorderLayout.CENTER);
southPanel.setBackground(PINK);
addWindowListener(new WindowAdapter() {
@Override
public void windowClosing(WindowEvent e) {
// 聊天中
if (isOnChat) {
// 关闭客户端套接口
try {
clientSocket.close();
}
catch (Exception ed){}
}
if (isOnChess || isGameConnected) {
// 下棋中
try {
// 关闭下棋端口
chessBoard.chessSocket.close();
}
catch (Exception ee){}
}
System.exit(0);
}
});
add(eastPanel, BorderLayout.EAST);
add(centerPanel, BorderLayout.CENTER);
add(southPanel, BorderLayout.SOUTH);
pack();
setSize(1000, 700);
setVisible(true);
setResizable(false);
this.validate();
}
/**
* 按指定的IP地址和端口连接到服务器
* @param serverIP
* @param serverPort
* @return
* @throws Exception
*/
public boolean connectToServer(String serverIP, int serverPort) throws Exception {
try {
// 创建客户端套接口
clientSocket = new Socket(serverIP, serverPort);
// 创建输入流
inputStream = new DataInputStream(clientSocket.getInputStream());
// 创建输出流
outputStream = new DataOutputStream(clientSocket.getOutputStream());
// 创建客户端线程
ClientThread clientThread = new ClientThread(this);
// 启动线程，等待聊天信息
clientThread.start();
isOnChat = true;
return true;
} catch (IOException ex) {
userChatPad.chatTextArea.setText("Sorry,无法连接!!!\n");
}
return false;
}
/**
* 客户端事件处理
* @param e
*/
@Override
public void actionPerformed(ActionEvent e) {
// 连接到主机按钮单击事件
if (e.getSource() == userControlPad.connectButton) {
// 取得主机地址
host = chessBoard.host = userControlPad.ipInputted.getText();
try {
// 成功连接到主机时，设置客户端相应的界面状态
if (connectToServer(host, port)) {
userChatPad.chatTextArea.setText("");
userControlPad.connectButton.setEnabled(false);
userControlPad.createButton.setEnabled(true);
userControlPad.joinButton.setEnabled(true);
chessBoard.statusText.setText("连接成功，请等待!!!");
}
} catch (Exception ei) {
userChatPad.chatTextArea.setText("Sorry,不能连接!!!\n");
}
}
// 离开游戏按钮单击事件
if (e.getSource() == userControlPad.exitButton) {
// 若用户处于聊天状态中
if (isOnChat) {
try {
// 关闭客户端套接口
clientSocket.close();
}
catch (Exception ed){}
}
// 若用户处于游戏状态中
if (isOnChess || isGameConnected) {
try {
// 关闭游戏端口
chessBoard.chessSocket.close();
}
catch (Exception ee){}
}
System.exit(0);
}
// 加入游戏按钮单击事件
if (e.getSource() == userControlPad.joinButton) {
// 取得要加入的游戏
String selectedUser = userListPad.userList.getSelectedItem();
// 若未选中要加入的用户，或选中的用户已经在游戏，则给出提示信息
if (selectedUser == null || selectedUser.startsWith("[inchess]") ||
selectedUser.equals(chessClientName)) {
chessBoard.statusText.setText("必须选择一个用户!");
} else {
// 执行加入游戏的操作
try {
// 若游戏套接口未连接
if (!isGameConnected) {
// 若连接到主机成功
if (chessBoard.connectServer(chessBoard.host, chessBoard.port)) {
isGameConnected = true;
isOnChess = true;
isParticipant = true;
userControlPad.createButton.setEnabled(false);
userControlPad.joinButton.setEnabled(false);
userControlPad.cancelButton.setEnabled(true);
chessBoard.chessThread.sendMessage("/joingame "
+ userListPad.userList.getSelectedItem() + " "
+ chessClientName);
}
} else {
// 若游戏端口连接中
isOnChess = true;
isParticipant = true;
userControlPad.createButton.setEnabled(false);
userControlPad.joinButton.setEnabled(false);
userControlPad.cancelButton.setEnabled(true);
chessBoard.chessThread.sendMessage("/joingame "
+ userListPad.userList.getSelectedItem() + " "
+ chessClientName);
}
} catch (Exception ee) {
isGameConnected = false;
isOnChess = false;
isParticipant = false;
userControlPad.createButton.setEnabled(true);
userControlPad.joinButton.setEnabled(true);
userControlPad.cancelButton.setEnabled(false);
userChatPad.chatTextArea.setText("不能连接: \n" + ee);
}
}
}
// 创建游戏按钮单击事件
if (e.getSource() == userControlPad.createButton) {
try {
// 若游戏端口未连接
if (!isGameConnected) {
if (chessBoard.connectServer(chessBoard.host, chessBoard.port)) {
// 若连接到主机成功
isGameConnected = true;
isOnChess = true;
isCreator = true;
userControlPad.createButton.setEnabled(false);
userControlPad.joinButton.setEnabled(false);
userControlPad.cancelButton.setEnabled(true);
chessBoard.chessThread.sendMessage("/creatgame " + "[inchess]" + chessClientName);
}
} else {
// 若游戏端口连接中
isOnChess = true;
isCreator = true;
userControlPad.createButton.setEnabled(false);
userControlPad.joinButton.setEnabled(false);
userControlPad.cancelButton.setEnabled(true);
chessBoard.chessThread.sendMessage("/creatgame "
+ "[inchess]" + chessClientName);
}
} catch (Exception ec) {
isGameConnected = false;
isOnChess = false;
isCreator = false;
userControlPad.createButton.setEnabled(true);
userControlPad.joinButton.setEnabled(true);
userControlPad.cancelButton.setEnabled(false);
ec.printStackTrace();
userChatPad.chatTextArea.setText("Sorry,不能连接: \n" + ec);
}
}
// 退出游戏按钮单击事件
if (e.getSource() == userControlPad.cancelButton) {
// 游戏中
if (isOnChess) {
chessBoard.chessThread.sendMessage("/giveup " + chessClientName);
chessBoard.setVicStatus(-1 * chessBoard.chessColor);
userControlPad.createButton.setEnabled(true);
userControlPad.joinButton.setEnabled(true);
userControlPad.cancelButton.setEnabled(false);
chessBoard.statusText.setText("请选择创建房间或加入游戏!!!");
} if (!isOnChess) {
// 非游戏中
userControlPad.createButton.setEnabled(true);
userControlPad.joinButton.setEnabled(true);
userControlPad.cancelButton.setEnabled(false);
chessBoard.statusText.setText("请选择创建房间或加入游戏!!!");
}
isParticipant = isCreator = false;
}
}
@Override
public void keyPressed(KeyEvent e) {
TextField inputwords = (TextField) e.getSource();
// 处理回车按键事件
if (e.getKeyCode() == KeyEvent.VK_ENTER) {
// 给所有人发信息
if (userInputPad.userChoice.getSelectedItem().equals("所有用户")) {
try {
// 发送信息
outputStream.writeUTF(inputwords.getText());
inputwords.setText("");
} catch (Exception ea) {
userChatPad.chatTextArea.setText("Sorry,不能连接到服务器!\n");
userListPad.userList.removeAll();
userInputPad.userChoice.removeAll();
inputwords.setText("");
userControlPad.connectButton.setEnabled(true);
}
} else {
// 给指定人发信息
try {
outputStream.writeUTF("/" + userInputPad.userChoice.getSelectedItem()
+ " " + inputwords.getText());
inputwords.setText("");
} catch (Exception ea) {
userChatPad.chatTextArea.setText("Sorry,不能连接到服务器!\n");
userListPad.userList.removeAll();
userInputPad.userChoice.removeAll();
inputwords.setText("");
userControlPad.connectButton.setEnabled(true);
}
}
}
}
@Override
public void keyTyped(KeyEvent e) {}
@Override
public void keyReleased(KeyEvent e) {}
public static void main(String[] args) {
new ClientChess();
}
}棋盘五子棋核心算法类
public class ChessBoard extends Panel implements MouseListener, ActionListener {
public int dis = 30;
// 鼠标是否能使用
public boolean isMouseEnabled = false;
// 是否胜利
public boolean isWon = false;
// 棋子的x轴坐标位
public int chessX_POS = -1;
// 棋子的y轴坐标位
public int chessY_POS = -1;
// 棋子的颜色
public int chessColor = 1;
// 黑棋x轴坐标位数组
public int chessBlack_XPOS[] = new int[200];
// 黑棋y轴坐标位数组
public int chessBlack_YPOS[] = new int[200];
// 白棋x轴坐标位数组
public int chessWhite_XPOS[] = new int[200];
// 白棋y轴坐标位数组
public int chessWhite_YPOS[] = new int[200];
// 黑棋数量
public int chessBlackCount = 0;
// 白棋数量
public int chessWhiteCount = 0;
// 黑棋获胜次数
public int chessBlackVicTimes = 0;
// 白棋获胜次数
public int chessWhiteVicTimes = 0;
// 套接口
public Socket chessSocket;
protected DataInputStream inputData;
protected DataOutputStream outputData;
public String chessSelfName = null;
public String chessPeerName = null;
public String host = null;
public int port = 1234;
public TextField statusText = new TextField("请先连接服务器！！！");
public ChessThread chessThread = new ChessThread(this);
public ChessBoard() {
setSize(600, 600);
setLayout(null);
setBackground(new Color(205, 133, 63));
addMouseListener(this);
add(statusText);
statusText.setBounds(new Rectangle(80, 5, 440, 24));
statusText.setEditable(false);
}
/**
* 连接到主机
* @param ServerIP
* @param ServerPort
* @return
* @throws Exception
*/
public boolean connectServer(String ServerIP, int ServerPort) throws Exception {
try {
// 取得主机端口
chessSocket = new Socket(ServerIP, ServerPort);
// 取得输入流
inputData = new DataInputStream(chessSocket.getInputStream());
// 取得输出流
outputData = new DataOutputStream(chessSocket.getOutputStream());
chessThread.start();
return true;
} catch (IOException ex) {
statusText.setText("sorry，连接失败!!! \n");
}
return false;
}
/**
* 设定胜利时的棋盘状态
* @param vicChessColor
*/
public void setVicStatus(int vicChessColor) {
// 清空棋盘
this.removeAll();
// 将黑棋的位置设置到零点
for (int i = 0; i <= chessBlackCount; i++) {
chessBlack_XPOS[i] = 0;
chessBlack_YPOS[i] = 0;
}
// 将白棋的位置设置到零点
for (int i = 0; i <= chessWhiteCount; i++) {
chessWhite_XPOS[i] = 0;
chessWhite_YPOS[i] = 0;
}
// 清空棋盘上的黑棋数
chessBlackCount = 0;
// 清空棋盘上的白棋数
chessWhiteCount = 0;
add(statusText);
statusText.setBounds(40, 5, 200, 24);
// 黑棋胜
if (vicChessColor == 1) {
chessBlackVicTimes++;
statusText.setText("恭喜黑方胜！！！黑VS白 " + chessBlackVicTimes + ":" + chessWhiteVicTimes
+ ".游戏重启，等待白方...");
// 白棋胜
} else if (vicChessColor == -1) {
chessWhiteVicTimes++;
statusText.setText("恭喜白方胜！！！黑VS白 " + chessBlackVicTimes + ":" + chessWhiteVicTimes
+ ".游戏重启,等待黑方...");
}
}
/**
* 取得指定棋子的位置
* @param xPos
* @param yPos
* @param chessColor
*/
public void setLocation(int xPos, int yPos, int chessColor) {
// 棋子为黑棋时
if (chessColor == 1) {
chessBlack_XPOS[chessBlackCount] = xPos * dis;
chessBlack_YPOS[chessBlackCount] = yPos * dis;
chessBlackCount++;
// 棋子为白棋时
} else if (chessColor == -1) {
chessWhite_XPOS[chessWhiteCount] = xPos * dis;
chessWhite_YPOS[chessWhiteCount] = yPos * dis;
chessWhiteCount++;
}
}
/**
* 五子棋核心算法
* @param xPos
* @param yPos
* @param chessColor
* @return
*/
public boolean checkVicStatus(int xPos, int yPos, int chessColor) {
// 连接棋子数
int chessLinkedCount = 1;
// 用于比较是否要继续遍历一个棋子的相邻网格
int chessLinkedCompare = 1;
// 要比较的棋子在数组中的索引位置
int chessToCompareIndex = 0;
// 相邻网格的位置
int closeGrid = 1;
// 黑棋时
if (chessColor == 1) {
// 将该棋子自身算入的话，初始连接数为1
chessLinkedCount = 1;
//以下每对for循环语句为一组，因为下棋的位置能位于中间而非两端
// 遍历相邻4个网格
// 判断当前下的棋子的右边4个棋子是否都为黑棋
for (closeGrid = 1; closeGrid <= 4; closeGrid++) {
// 遍历棋盘上所有黑棋子
for (chessToCompareIndex = 0; chessToCompareIndex <= chessBlackCount; chessToCompareIndex++) {
if (((xPos + closeGrid) * dis == chessBlack_XPOS[chessToCompareIndex])
&& ((yPos * dis) == chessBlack_YPOS[chessToCompareIndex])) {
// 连接数加1
chessLinkedCount = chessLinkedCount + 1;
// 五子相连时，胜利
if (chessLinkedCount == 5) {
return true;
}
}
}
if (chessLinkedCount == (chessLinkedCompare + 1)) {
chessLinkedCompare++;
// 若中间有一个棋子非黑棋，则会进入此分支，此时无需再遍历
} else {
break;
}
}
// 判断当前下的棋子的左边4个棋子是否都为黑棋
for (closeGrid = 1; closeGrid <= 4; closeGrid++) {
for (chessToCompareIndex = 0; chessToCompareIndex <= chessBlackCount; chessToCompareIndex++) {
if (((xPos - closeGrid) * dis == chessBlack_XPOS[chessToCompareIndex])
&& (yPos * dis == chessBlack_YPOS[chessToCompareIndex])) {
chessLinkedCount++;
if (chessLinkedCount == 5) {
return true;
}
}
}
if (chessLinkedCount == (chessLinkedCompare + 1)) {
chessLinkedCompare++;
} else {
break;
}
}
// 进入新的一组for循环时要将连接数等重置
chessLinkedCount = 1;
chessLinkedCompare = 1;
// 判断当前下的棋子的上边4个棋子是否都为黑棋
for (closeGrid = 1; closeGrid <= 4; closeGrid++) {
for (chessToCompareIndex = 0; chessToCompareIndex <= chessBlackCount; chessToCompareIndex++) {
if ((xPos * dis == chessBlack_XPOS[chessToCompareIndex])
&& ((yPos + closeGrid) * dis == chessBlack_YPOS[chessToCompareIndex])) {
chessLinkedCount++;
if (chessLinkedCount == 5) {
return true;
}
}
}
if (chessLinkedCount == (chessLinkedCompare + 1)) {
chessLinkedCompare++;
} else {
break;
}
}
// 判断当前下的棋子的下边4个棋子是否都为黑棋
for (closeGrid = 1; closeGrid <= 4; closeGrid++) {
for (chessToCompareIndex = 0; chessToCompareIndex <= chessBlackCount; chessToCompareIndex++) {
if ((xPos * dis == chessBlack_XPOS[chessToCompareIndex])
&& ((yPos - closeGrid) * dis == chessBlack_YPOS[chessToCompareIndex])) {
chessLinkedCount++;
if (chessLinkedCount == 5) {
return true;
}
}
}
if (chessLinkedCount == (chessLinkedCompare + 1)) {
chessLinkedCompare++;
} else {
break;
}
}
chessLinkedCount = 1;
chessLinkedCompare = 1;
for (closeGrid = 1; closeGrid <= 4; closeGrid++) {
for (chessToCompareIndex = 0; chessToCompareIndex <= chessBlackCount; chessToCompareIndex++) {
// 判断当前下的棋子的左上方向4个棋子是否都为黑棋
if (((xPos - closeGrid) * dis == chessBlack_XPOS[chessToCompareIndex])
&& ((yPos + closeGrid) * dis == chessBlack_YPOS[chessToCompareIndex])) {
chessLinkedCount++;
if (chessLinkedCount == 5) {
return true;
}
}
}
if (chessLinkedCount == (chessLinkedCompare + 1)) {
chessLinkedCompare++;
} else {
break;
}
}
for (closeGrid = 1; closeGrid <= 4; closeGrid++) {
for (chessToCompareIndex = 0; chessToCompareIndex <= chessBlackCount; chessToCompareIndex++) {
// 判断当前下的棋子的右下方向4个棋子是否都为黑棋
if (((xPos + closeGrid) * dis == chessBlack_XPOS[chessToCompareIndex])
&& ((yPos - closeGrid) * dis == chessBlack_YPOS[chessToCompareIndex])) {
chessLinkedCount++;
if (chessLinkedCount == 5) {
return true;
}
}
}
if (chessLinkedCount == (chessLinkedCompare + 1)) {
chessLinkedCompare++;
} else {
break;
}
}
chessLinkedCount = 1;
chessLinkedCompare = 1;
// 判断当前下的棋子的右上方向4个棋子是否都为黑棋
for (closeGrid = 1; closeGrid <= 4; closeGrid++) {
for (chessToCompareIndex = 0; chessToCompareIndex <= chessBlackCount; chessToCompareIndex++) {
if (((xPos + closeGrid) * dis == chessBlack_XPOS[chessToCompareIndex])
&& ((yPos + closeGrid) * dis == chessBlack_YPOS[chessToCompareIndex])) {
chessLinkedCount++;
if (chessLinkedCount == 5) {
return true;
}
}
}
if (chessLinkedCount == (chessLinkedCompare + 1)) {
chessLinkedCompare++;
} else {
break;
}
}
// 判断当前下的棋子的左下方向4个棋子是否都为黑棋
for (closeGrid = 1; closeGrid <= 4; closeGrid++) {
for (chessToCompareIndex = 0; chessToCompareIndex <= chessBlackCount; chessToCompareIndex++) {
if (((xPos - closeGrid) * dis == chessBlack_XPOS[chessToCompareIndex])
&& ((yPos - closeGrid) * dis == chessBlack_YPOS[chessToCompareIndex])) {
chessLinkedCount++;
if (chessLinkedCount == 5) {
return true;
}
}
}
if (chessLinkedCount == (chessLinkedCompare + 1)) {
chessLinkedCompare++;
} else {
break;
}
}
// 白棋的情况
} else if (chessColor == -1) {
chessLinkedCount = 1;
// 判断当前下的棋子的右边4个棋子是否都为白棋
for (closeGrid = 1; closeGrid <= 4; closeGrid++) {
for (chessToCompareIndex = 0; chessToCompareIndex <= chessWhiteCount; chessToCompareIndex++) {
if (((xPos + closeGrid) * dis == chessWhite_XPOS[chessToCompareIndex])
&& (yPos * dis == chessWhite_YPOS[chessToCompareIndex])) {
chessLinkedCount++;
if (chessLinkedCount == 5) {
return true;
}
}
}
if (chessLinkedCount == (chessLinkedCompare + 1)) {
chessLinkedCompare++;
} else {
break;
}
}
// 判断当前下的棋子的左边4个棋子是否都为白棋
for (closeGrid = 1; closeGrid <= 4; closeGrid++) {
for (chessToCompareIndex = 0; chessToCompareIndex <= chessWhiteCount; chessToCompareIndex++) {
if (((xPos - closeGrid) * dis == chessWhite_XPOS[chessToCompareIndex])
&& (yPos * dis == chessWhite_YPOS[chessToCompareIndex])) {
chessLinkedCount++;
if (chessLinkedCount == 5) {
return true;
}
}
}
if (chessLinkedCount == (chessLinkedCompare + 1)) {
chessLinkedCompare++;
} else {
break;
}
}
chessLinkedCount = 1;
chessLinkedCompare = 1;
// 判断当前下的棋子的上边4个棋子是否都为白棋
for (closeGrid = 1; closeGrid <= 4; closeGrid++) {
for (chessToCompareIndex = 0; chessToCompareIndex <= chessWhiteCount; chessToCompareIndex++) {
if ((xPos * dis == chessWhite_XPOS[chessToCompareIndex])
&& ((yPos + closeGrid) * dis == chessWhite_YPOS[chessToCompareIndex])) {
chessLinkedCount++;
if (chessLinkedCount == 5) {
return true;
}
}
}
if (chessLinkedCount == (chessLinkedCompare + 1)) {
chessLinkedCompare++;
} else {
break;
}
}
// 判断当前下的棋子的下边4个棋子是否都为白棋
for (closeGrid = 1; closeGrid <= 4; closeGrid++) {
for (chessToCompareIndex = 0; chessToCompareIndex <= chessWhiteCount; chessToCompareIndex++) {
if ((xPos * dis == chessWhite_XPOS[chessToCompareIndex])
&& ((yPos - closeGrid) * dis == chessWhite_YPOS[chessToCompareIndex])) {
chessLinkedCount++;
if (chessLinkedCount == 5) {
return true;
}
}
}
if (chessLinkedCount == (chessLinkedCompare + 1)) {
chessLinkedCompare++;
} else {
break;
}
}
chessLinkedCount = 1;
chessLinkedCompare = 1;
// 判断当前下的棋子的左上方向4个棋子是否都为白棋
for (closeGrid = 1; closeGrid <= 4; closeGrid++) {
for (chessToCompareIndex = 0; chessToCompareIndex <= chessWhiteCount; chessToCompareIndex++) {
if (((xPos - closeGrid) * dis == chessWhite_XPOS[chessToCompareIndex])
&& ((yPos + closeGrid) * dis == chessWhite_YPOS[chessToCompareIndex])) {
chessLinkedCount++;
if (chessLinkedCount == 5) {
return true;
}
}
}
if (chessLinkedCount == (chessLinkedCompare + 1)) {
chessLinkedCompare++;
} else {
break;
}
}
// 判断当前下的棋子的右下方向4个棋子是否都为白棋
for (closeGrid = 1; closeGrid <= 4; closeGrid++) {
for (chessToCompareIndex = 0; chessToCompareIndex <= chessWhiteCount; chessToCompareIndex++) {
if (((xPos + closeGrid) * dis == chessWhite_XPOS[chessToCompareIndex])
&& ((yPos - closeGrid) * dis == chessWhite_YPOS[chessToCompareIndex])) {
chessLinkedCount++;
if (chessLinkedCount == 5) {
return true;
}
}
}
if (chessLinkedCount == (chessLinkedCompare + 1)) {
chessLinkedCompare++;
} else {
break;
}
}
chessLinkedCount = 1;
chessLinkedCompare = 1;
// 判断当前下的棋子的右上方向4个棋子是否都为白棋
for (closeGrid = 1; closeGrid <= 4; closeGrid++) {
for (chessToCompareIndex = 0; chessToCompareIndex <= chessWhiteCount; chessToCompareIndex++) {
if (((xPos + closeGrid) * dis == chessWhite_XPOS[chessToCompareIndex])
&& ((yPos + closeGrid) * dis == chessWhite_YPOS[chessToCompareIndex])) {
chessLinkedCount++;
if (chessLinkedCount == 5) {
return true;
}
}
}
if (chessLinkedCount == (chessLinkedCompare + 1)) {
chessLinkedCompare++;
} else {
break;
}
}
// 判断当前下的棋子的左下方向4个棋子是否都为白棋
for (closeGrid = 1; closeGrid <= 4; closeGrid++) {
for (chessToCompareIndex = 0; chessToCompareIndex <= chessWhiteCount; chessToCompareIndex++) {
if (((xPos - closeGrid) * dis == chessWhite_XPOS[chessToCompareIndex])
&& ((yPos - closeGrid) * dis == chessWhite_YPOS[chessToCompareIndex])) {
chessLinkedCount++;
if (chessLinkedCount == 5) {
return (true);
}
}
}
if (chessLinkedCount == (chessLinkedCompare + 1)) {
chessLinkedCompare++;
} else {
break;
}
}
}
return false;
}
/**
* 画棋盘
*/
@Override
public void paint(Graphics g) {
for (int i = 40; i <= 580; i = i + 30) {
g.drawLine(40, i, 580, i);
}
for (int j = 40; j <= 580; j = j + 30) {
g.drawLine(j, 40, j, 580);
}
g.fillOval(127, 127, 8, 8);
g.fillOval(487, 127, 8, 8);
g.fillOval(127, 487, 8, 8);
g.fillOval(487, 487, 8, 8);
g.fillOval(307, 307, 8, 8);
}
/**
* 画棋子
* @param xPos
* @param yPos
* @param chessColor
*/
public void paintChessPoint(int xPos, int yPos, int chessColor) {
ChessBlack chessBlack = new ChessBlack(this);
ChessWhite chessWhite = new ChessWhite(this);
// 黑棋
if (chessColor == 1 && isMouseEnabled) {
// 设置棋子的位置
setLocation(xPos, yPos, chessColor);
// 取得当前局面状态
isWon = checkVicStatus(xPos, yPos, chessColor);
// 非胜利状态
if (isWon == false) {
chessThread.sendMessage("/" + chessPeerName + " /chess "
+ xPos + " " + yPos + " " + chessColor);
// 将棋子添加到棋盘中
this.add(chessBlack);
// 设置棋子边界
chessBlack.setBounds(xPos * dis -4, yPos * dis -3, 30, 30);
statusText.setText("黑(第" + chessBlackCount + "步)" + xPos + " " + yPos + ",轮到白方.");
// 将鼠标设为不可用
isMouseEnabled = false;
// 胜利状态
} else {
chessThread.sendMessage("/" + chessPeerName + " /chess "
+ xPos + " " + yPos + " " + chessColor);
this.add(chessBlack);
chessBlack.setBounds(xPos * dis -4, yPos * dis -3, 30, 30);
// 调用胜利方法，传入参数为黑棋胜利
setVicStatus(1);
isMouseEnabled = false;
}
// 白棋
} else if (chessColor == -1 && isMouseEnabled) {
setLocation(xPos, yPos, chessColor);
isWon = checkVicStatus(xPos, yPos, chessColor);
if (isWon == false) {
chessThread.sendMessage("/" + chessPeerName + " /chess "
+ xPos + " " + yPos + " " + chessColor);
this.add(chessWhite);
chessWhite.setBounds(xPos * dis -4, yPos * dis-3 , 30, 30);
statusText.setText("白(第" + chessWhiteCount + "步)" + xPos + " " + yPos + ",轮到黑方.");
isMouseEnabled = false;
} else {
chessThread.sendMessage("/" + chessPeerName + " /chess "
+ xPos + " " + yPos + " " + chessColor);
this.add(chessWhite);
chessWhite.setBounds(xPos * dis-4 , yPos * dis -3, 30, 30);
// 调用胜利方法，传入参数为白棋
setVicStatus(-1);
isMouseEnabled = false;
}
}
}
/**
* 画网络棋盘
* @param xPos
* @param yPos
* @param chessColor
*/
public void paintNetChessPoint(int xPos, int yPos, int chessColor) {
ChessBlack chessBlack = new ChessBlack(this);
ChessWhite chessWhite = new ChessWhite(this);
setLocation(xPos, yPos, chessColor);
if (chessColor == 1) {
isWon = checkVicStatus(xPos, yPos, chessColor);
if (isWon == false) {
this.add(chessBlack);
chessBlack.setBounds(xPos * dis-4 , yPos * dis -3, 30, 30);
statusText.setText("黑(第" + chessBlackCount + "步)" + xPos + " " + yPos + ",轮到白方.");
isMouseEnabled = true;
} else {
chessThread.sendMessage("/" + chessPeerName + " /victory " + chessColor);
this.add(chessBlack);
chessBlack.setBounds(xPos * dis -4, yPos * dis-3, 30, 30);
setVicStatus(1);
isMouseEnabled = true;
}
} else if (chessColor == -1) {
isWon = checkVicStatus(xPos, yPos, chessColor);
if (isWon == false) {
this.add(chessWhite);
chessWhite.setBounds(xPos * dis-4, yPos * dis-3, 30, 30);
statusText.setText("白(第" + chessWhiteCount + "步)" + xPos + " " + yPos + ",轮到黑方.");
isMouseEnabled = true;
} else {
chessThread.sendMessage("/" + chessPeerName + " /victory " + chessColor);
this.add(chessWhite);
chessWhite.setBounds(xPos * dis-4, yPos * dis-3, 30, 30);
setVicStatus(-1);
isMouseEnabled = true;
}
}
}
/**
* 捕获下棋事件
* @param e
*/
@Override
public void mousePressed(MouseEvent e) {
if (e.getModifiers() == InputEvent.BUTTON1_MASK) {
chessX_POS = e.getX();
System.out.println(chessX_POS);
chessY_POS = e.getY();
System.out.println(chessY_POS);
int a = (chessX_POS) / dis, b = (chessY_POS) / dis;
System.out.println("a="+a);
System.out.println("b="+b);
// 下棋位置不正确时，不执行任何操作
if (chessX_POS / dis < 2 || chessY_POS / dis < 2
|| chessX_POS / dis > 19 || chessY_POS / dis > 19) {
} else {
// 画棋子
paintChessPoint(a, b, chessColor);
}
}
}
@Override
public void actionPerformed(ActionEvent e) {}
@Override
public void mouseClicked(MouseEvent e) {}
@Override
public void mouseReleased(MouseEvent e) {}
@Override
public void mouseEntered(MouseEvent e) {}
@Override
public void mouseExited(MouseEvent e) {}
}总结
通过此次的《五子棋》游戏实现，让我对swing的相关知识有了进一步的了解，对java这门语言也有了比以前更深刻的认识。
java的一些基本语法，比如数据类型、运算符、程序流程控制和数组等，理解更加透彻。java最核心的核心就是面向对象思想，对于这一个概念，终于悟到了一些。
以上就是Java+Swing实现经典五子棋游戏的详细内容，更多关于Java Swing五子棋的资料请关注脚本之家其它相关文章！