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五子棋的资料请关注我们其它相关文章！
赞 (0)
相关推荐
-
java Swing实现五子棋游戏
本文实例为大家分享了java实现五子棋项目,供大家参考,具体内容如下 运行结果 视频经过压缩画质略显粗糙. 标题 1)绘制网格棋盘: 重写JPanel的paint(Graphics g)方法,绘制16*16网格. 如图: 2)代码如下(仅包含部分代码): public class Board extends JPanel{ int width = Toolkit.getDefaultToolkit().getScreenSize().width; int height = Toolkit.get
-
Java swing五子棋的实现方法
今天给大家介绍一下如何用Java swing实现五子棋的开发即用Java开发图形界面程序五子棋,代码由于太多,只贴部分,最下面会附上下载地址,废话不多说,下面我们先看一下运行结果: 接下来我们看代码: 首先是创建主frame框架界面: package org.liky.game.frame; import java.awt.Color; import java.awt.Font; import java.awt.Graphics; import java.awt.Toolkit; import
-
java开发实现五子棋游戏
本文实例为大家分享了java实现五子棋游戏的具体代码,供大家参考,具体内容如下 此游戏具有双人对战功能和人机对战功能 一.游戏界面的实现 一个游戏首先从设计界面开始 1.首先创建一个类,作用是通过对窗体组件的一些设置来实现简单游戏界面 public void gameUI(){ //窗体组件 MyFrame jf = new MyFrame(); jf.setSize(900, 800); jf.setTitle("冷丁-五子棋"); //居中显示 jf.setLocationRela
-
Java实现五子棋游戏
本文实例为大家分享了Java实现五子棋游戏的具体代码,供大家参考,具体内容如下 一.功能分析 五子棋的实现还是较为简单的,通过下期的流程我们可以知道大概要实现一下功能: 1.格界面 2.点击下棋 3.悔棋 4.判断输赢 二.功能实现 根据之前的功能分析,要有网格先要有窗体,我们先重新写一个类,来继承JFrame类,以便在窗口变动的情况下,对窗口进行重绘(防止在窗口大小发生改变的时候,之前的绘画会消失),这里我们重写paint方法,画出网格线 public class MyFrame extend
-
java swing实现简单的五子棋游戏
用java swing写的一个简单的五子棋游戏. 下面是Main.java. package com.crossing.main; import com.crossing.view.GameWindow; public class Main { /** * @param args */ public static void main(String[] args) { GameWindow gameWindow = new GameWindow(); } } 下面是GameWindow.java.
-
java基于swing实现的五子棋游戏代码
本文实例讲述了java基于swing实现的五子棋游戏代码.分享给大家供大家参考. 主要功能代码如下: 复制代码 代码如下: import java.awt.*; import javax.swing.*; import java.awt.event.*; public class Main extends JFrame implements ActionListener{ private static final long serialVersionUID = 1L;
-
java实现简易的五子棋游戏
本文实例为大家分享了java实现简易五子棋游戏的具体代码,供大家参考,具体内容如下 先上效果图 一.问题分析 1.五子棋游戏分析: 五子棋作为较为普遍且简易的娱乐游戏,受到众多人的热爱,且五子棋AI也是一个较为容易实现的AI.下面我们先来分析游戏规则.(哈哈,虽然大家都知道,但我还是想写写)双方分别使用黑白两色棋子,下在棋盘横线交叉处,先连成五子者胜利.(黑棋禁手啥的规则在我的程序里没加,就不赘述了). 2.程序分析: (1)首先,五子棋开始,我们需要一个棋盘,15*15的棋盘,需要黑白棋子.
-
Java+Swing实现经典五子棋游戏
目录 前言 主要需求 主要设计 功能截图 代码实现 总结 前言 五子棋是世界智力运动会竞技项目之一,是一种两人对弈的纯策略型棋类游戏,是世界智力运动会竞技项目之一,通常双方分别使用黑白两色的棋子,下在棋盘直线与横线的交叉点上,先形成5子连线者获胜. 棋具与围棋通用,起源于中国上古时代的传统黑白棋种之一.主要流行于华人和汉字文化圈的国家以及欧美一些地区,是世界上最古老的棋. 容易上手,老少皆宜,而且趣味横生,引人入胜:不仅能增强思维能力,提高智力,而且富含哲理,有助于修身养性. 用java语言实现
-
Java+swing实现经典贪吃蛇游戏
目录 前言 主要设计 功能截图 代码实现 总结 前言 贪吃蛇(也叫做贪食蛇)游戏是一款休闲益智类游戏,有PC和手机等多平台版本.既简单又耐玩.该游戏通过控制蛇头方向吃东西,从而使得蛇变得越来越长. 本程序是通过java的swing来实现<贪吃蛇大作战>这款游戏. 主要需求 1.通过上下左右控制蛇的方向,寻找吃的东西,每吃一口就能得到一定的积分,蛇的身体会变长 2.蛇头碰到自己的身体,则算失败 主要设计 1.设置swing的窗体大小 2.随机初始化蛇的位置和食物的位置,且食物不能落在蛇的身体上.
-
Java实现两人五子棋游戏(三) 画出棋子
上一篇文章讲的是Java实现两人五子棋游戏(二) 画出棋盘,已经画好棋盘,接下来要实现控制功能,主要功能: 1)选择棋子 2)画棋子 3)判断胜负 4)交换行棋方 先实现画棋子PART -------------画棋子代码示例如下-------------- 首先,定义一个棋子类,这个类有两个属性,棋子颜色(0-表示黑色,1-表示白色),是否落子(我计划用一个二维数组才存储棋子的落子信息) Chessman.java package xchen.test.simpleGobang; public
-
Java实现两人五子棋游戏(二) 画出棋盘
本文为大家分享了java画出五子棋游戏棋盘的方法,供大家参考,具体内容如下 棋盘模块: 画五子棋棋盘:19条横线.19条竖线 步骤一:显示棋盘 我有一张名为chessboard.png的棋盘,位置为根目录/res/drawable/chessboard/png,现在我要显示这张图片. DrawChessBoard.java package xchen.test.simpleGobang; import java.awt.Graphics; import java.awt.Image; impor
-
Java实现两人五子棋游戏(七) 屏幕提示信息
之前的两篇文章:Java实现两人五子棋游戏(二) 画出棋盘:Java实现两人五子棋游戏(三) 画出棋子:Java实现两人五子棋游戏(四) 落子动作的实现:Java实现两人五子棋游戏(六) 行棋方变换,可以点击查看. 接下来我们要实现的功能是在有五连珠的时候,在屏幕上提示信息.直接在mousePressed函数的isWin部分使用showMessageDialog即可. mousePressed函数代码如下: @Override //当用户按下鼠标按钮时发生 public void mousePr
-
Java实现两人五子棋游戏(六) 行棋方变换
之前的两篇文章:Java实现两人五子棋游戏(二) 画出棋盘:Java实现两人五子棋游戏(三) 画出棋子:Java实现两人五子棋游戏(四) 落子动作的实现,可以点击查看. 前面我们已经画好棋盘和棋子,并可以自由落子,且可以判断棋盘中是否有五连珠.接下来的工作是,每次落子后交换行棋方(即将下一棋子颜色由白->黑或黑->白),并将胜出判断增加颜色判断条件(棋盘上存在五连珠->棋盘上存在同色的五连珠). 主模块Main.java和棋子类Chessman.java不变,我们要对DrawChessB
-
Java实现两人五子棋游戏(五) 判断是否有一方胜出
之前的两篇文章:Java实现两人五子棋游戏(二) 画出棋盘:Java实现两人五子棋游戏(三) 画出棋子:Java实现两人五子棋游戏(四) 落子动作的实现,可以点击查看. 前面我们已经画好了棋盘.棋子并且可以自由的落子了,那么接下来要实现的功能是判断是否有五连珠(暂时不考虑行棋方). 我们采用遍历棋盘已经落子的位置,查看每个落子点,在它的上下,左右,左下右上,左上右下四个方向的任一方向上是否有五个连续的棋子. 第一步,对棋子类进行改造,之前我们的棋子类只有颜色信息和落子状态,现在要新增一个int型
-
Java实现两人五子棋游戏(四) 落子动作的实现
之前的两篇文章:Java实现两人五子棋游戏(二) 画出棋盘:Java实现两人五子棋游戏(三) 画出棋子 前面,我们已经画好的棋盘和棋子,接下来,我们要通过鼠标点击屏幕获取落子位置并落子(先不考虑行棋方和胜负判断). 步骤: 1)捕捉鼠标按下的位置 2)经过坐标变换(由像素位置->0-19的棋盘位置) 3)更新记录棋盘状态的二维数组 4)重新渲染绘制棋盘. -------------落子动作代码示例如下-------------- 一个棋子类Chessman.java package xchen.
-
Java Swing实现坦克大战游戏
一.引言 90坦克大战,很经典的一款游戏,当年与小伙伴一人一个手柄,搬上小板凳坐在电视机前,身体时不时跟随手柄摇晃着,时而表情严肃.眉头紧锁,时而欢呼雀跃.喜笑颜开,全身心投入到游戏中,在消灭一只只坦克.守住关卡.坦克升级.晋级通关的时候,更是手舞足蹈.击掌庆祝,如今想想也是记忆犹新.回味无穷!于是乎就我就自己用java写了一个,找一下当年的感觉,顺便虐一下电脑,嘻嘻嘻嘻嘻(ming式笑声). 二.效果图 三.实现 绘图时将这个鹰的图标用 g.drawImage 的方式绘制在界面中央最下方,然后