自从开始接触Swing以来，就喜欢写写各种管理系统，写多了就萌生了一种类似于实时在线对战的游戏，经过一番构思后就开始着手设计这个网络对战版本的五子棋了。
游戏代码包含两部分，常规的C/S模式(C代表客户端，S代表服务端)
下载代码后先启动服务器，服务器正常启动后，你会在控制台看到相关的日志(这里注意，服务器是没有做界面管理的)，接着启动客户端(可以启动多个客户端)，连接服务器后点击菜单栏联网、对战、匹配等操作
链接：https://pan.baidu.com/s/1-Bt8tcuZGkVj-jFxN4YDbg 密码：w2oy
要求：jdk环境 1.6或以上
使用方式：环境正常安装后，解压下载的文件，点击 startClient.bat 就可以打开了
备注：若你只开一个客户端，进行匹配的话可能没人跟你玩，建议不是为了技术纯测试的话与你和你的朋友一起对战
阅读本文前，您需要了解：
package cn.xt.net;
import java.text.SimpleDateFormat;
import java.util.Date;
import java.util.UUID;
public class Const {
public static final int PORT = 7001; // 监听端口
// 基础数据(key)
public static final String ID = "id";
public static final String MSG = "msg";
// 基础数据(value)
public static final String ID_STATUS_ERROR = "idError"; // 错误信息
public static final String ID_STATUS_INIT = "初始化客户端"; // 向服务器请求初始化
public static final String ID_STATUS_PP = "匹配玩家";
public static final String PP_SUCCESS = "匹配成功";
public static final String ID_STATUS_PUT = "传送落子位置";
public static final String ID_STATUS_GET = "获取落子位置";
public static final String ID_STATUS_OVER = "对局结束";
public static final String ID_STATUS_MSG = "聊天消息";
public static final String ID_STATUS_BACK = "请求悔棋";
public static final String ID_STATUS_FAIL = "认输";
public static final String ID_STATUS_HANDSNAKE = "初次握手";
public static final String ID_STATUS_BACK_RESULT = "请求悔棋结果";
public static final String ID_STATUS_OVERTIME = "游戏超时";
public static final String SIZE = "棋盘长度";
public static final String EXISTS = "该用户名已存在系统中";
public static final String USER_NAME = "userName";
public static final String INIT_SUCCESS = "初始化成功";
public static final String X = "x";
public static final String Y = "y";
public static final String STATUS = "status"; // 当前棋子的状态
public static final String COLOR = "落子颜色";
public static final String SYSTEM_MSG = "系统消息";
// key - value
public static final String MY = "my"; // 玩家
public static final String YOU = "you"; // 对家
public static final String FIRST = "先手方"; // 1：先手; 0：后手
// 属于页面的专属数据
private static SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd");
public static String getId() {
return getSysDate() + "-" + UUID.randomUUID().toString();
}
public static String getSysDate(){
return sdf.format(new Date());
}
// public static void main(String[] args) {
// System.out.println(Const.getId());
// }
}
保存客户端所有信息的Map:
private static volatile Map<String, UserData> client = new HashMap<>();
实体类定义(类名：UserData)：
private MessageFormat msgFormat; // 处理消息的对象
private Socket socket; // 客户端套接字对象
private Thread thread; // 处理消息的线程
private String userId; // 登陆的用户(唯一性)
private String userName; // 客户的名字(自己取的名称)
private String status; // 状态(0：登陆; 1：准备; 2：对局开始; 3：观战)
private String enemy; // 对家
private String isFirst; // 是否为先手
private List<Chess> chessBoard; // 棋盘
private boolean isOver; // 对局是否结束
private ServerSocket ss;
private Socket s;
private boolean start = false;
private static volatile Map<String, UserData> client = new HashMap<>();
public static void main(String[] args) {
SuperServlet servlet = new SuperServlet();
servlet.startService();
}
public SuperServlet() {
try {
ss = new ServerSocket(Const.PORT);
} catch (IOException e) {
e.printStackTrace();
}
}
// 线程用来接收客户端连接的请求
@Override
public void run() {
try {
while (start) {
s = ss.accept(); // 一直监听客户端的请求
synchronized (s) {
String userId = Const.getId(); // 返回一个唯一id
MessageFormat cs = new MessageFormat(s); // 建立传输入数据的线程(服务类)
// 为每个连接的客户端定义一个线程为其服务
Thread th = new Thread(cs);
// 定义用户信息类
UserData ud = new UserData();
ud.setUserId(userId);
ud.setMsgFormat(cs);
ud.setSocket(s);
ud.setThread(th);
client.put(userId, ud); // 将这个用户保存到服务器中
th.start(); // 启动这个线程
// 将识别ID发给客户端保存
JSONObject responseMsg = new JSONObject();
responseMsg.put(Const.ID, Const.ID_STATUS_HANDSNAKE);
responseMsg.put(Const.MSG, userId);
cs.send(responseMsg); // 发送消息给客户端
System.out.println("一个客户连接... 在线数量：" + client.size());
}
}
} catch (Exception er) {
System.out.println("服务已启动或端口被占用!");
er.printStackTrace();
System.exit(0);
}
}
// 默认构造器，对新连接的客户端的I/O流进行封装
public MessageFormat(Socket s)
// 重写该线程的run方法，用于循环监听客户端的发送的信息
public void run()
// 发送信息给该客户端
public void send(final JSONObject msg)
// 该客户端主动发送信息给别的客户端
public void send(String userId, JSONObject msg)
// 客户端断开时关闭I/O流
public void close()
// 消息处理中心(msg为客户端发过来的json数据)
public void addInfo(String msg)
对着下面的代码，我们先是循环监听客户端发过来的信息，dis.readUTF()是一个阻塞式的方法，若客户端发过来信息则返回一个字符串，接着在这里只是进行简单的打印就将信息传送给了addInfo() 这个方法；在我的catch中进行了相关处理，这里主要处理客户端若遇到不可描述的事情断开后，服务器应主动踢出这个客户端，这里我是先遍历了服务器中所有的客户端，找到一个线程ID与之匹配的，然后把这个线程踢出Map
@Override
public void run() {
while (clientStart) {
try {
// 客户端传来的信息
String requestMsg = dis.readUTF();
System.out.println("service do in：" + requestMsg);
// LogUtils.write("service do in：" + requestMsg);
// 消息处理
addInfo(requestMsg);
} catch (IOException e) {
// 如果无法接收客户端的信息
for(Entry<String, UserData> set : SuperServlet.getClient().entrySet()){
String userId = set.getKey();
UserData ud = set.getValue();
// 匹配退出的客户端进程
if(this == ud.getMsgFormat()){
// 给对手发送退出信息
JSONObject responseMsg = new JSONObject();
responseMsg.put(Const.ID, Const.ID_STATUS_FAIL);
UserData clientData = SuperServlet.getClient().get(ud.getEnemy());
if(clientData != null && !clientData.isOver()){
clientData.getMsgFormat().send(responseMsg);
}
MessageFormatHelper.ppList.remove(ud.getUserId());
System.out.println("退出的客户端为："+ ud.getUserName() + " --> " + ud.getUserId());
SuperServlet.getClient().remove(userId); // 服务器移除这个用户
System.out.println("在线数量：" + SuperServlet.getClient().size());
// ud.getThread().interrupt(); // 等待线程关闭
close(); // 关闭相应的流
clientStart = false; // 预先停止 while循环
ud.getThread().stop(); // 等待线程关闭
}
}
}
}
}
对着下面代码，我们先是将传过来的信息进行转义替换，然后转换成JSON，取到开始时常量类里面定义的key，进行switch匹配，匹配到对应的ID就做对应的事，这种做法在SpringMVC中跟RequestMapper有着异曲同工之想法。在这里，有一处地方我没有做讲解，MessageFormatHelper这个类是做什么的呢？在我们写Javaweb项目时，常会写一个dao 与 daoImpl，在这里MessageFormatHelper相当于 daoImpl类，也就是实现具体功能的类。
public void addInfo(String msg) {
JSONObject json = JSONObject.fromObject(msg.replaceAll("\"", "\\\""));
MessageFormatHelper.initialized(json); // 优先初始化服务器数据
String id = json.get(Const.ID).toString();
switch (id) {
// 初始化
case Const.ID_STATUS_INIT:
MessageFormatHelper.init();
break;
// 匹配玩家
case Const.ID_STATUS_PP:
MessageFormatHelper.matchUser();
break;
// 落子
case Const.ID_STATUS_PUT:
MessageFormatHelper.putChess();
break;
// 获取棋子
// case Const.ID_STATUS_GET:
// MessageFormatHelper.getChess();
// break;
// 对局结束
case Const.ID_STATUS_OVER:
MessageFormatHelper.gameOver();
break;
// 悔棋请求
case Const.ID_STATUS_BACK:
MessageFormatHelper.toBack();
break;
// 悔棋请求的结果
case Const.ID_STATUS_BACK_RESULT:
MessageFormatHelper.toBackResult();
break;
// 认输
case Const.ID_STATUS_FAIL:
MessageFormatHelper.fail();
break;
// 聊天消息
case Const.ID_STATUS_MSG:
MessageFormatHelper.chatMsg();
break;
// 游戏超时
case Const.ID_STATUS_OVERTIME:
MessageFormatHelper.overTime();
break;
default:
System.out.println("server: 未匹配到分支; id:" + id);
break;
}
// 未找到匹配分支
// JSONObject result = new JSONObject();
// result.put(Const.ID, "未找到匹配分支");
// return result;
}
/**
* 双方棋子互传
*/
public static void putChess() {
// 设置我方棋盘
String userId = json.getString(Const.MY);
// 获取坐标
int x = json.getInt(Const.X);
int y = json.getInt(Const.Y);
String color = json.getString(Const.COLOR);
// 更新我方棋盘
UserData my = SuperServlet.getClient().get(userId);
my.getChessBoard().add(new Chess(x, y, color));
// 更新对方棋盘
UserData you = SuperServlet.getClient().get(my.getEnemy());
you.getChessBoard().add(new Chess(x, y, color));
// 更新服务器数据
SuperServlet.updateClient(userId, my);
SuperServlet.updateClient(you.getUserId(), you);
// 将棋子同步给对手
if(!you.isOver()){
json.put(Const.ID, Const.ID_STATUS_GET);
you.getMsgFormat().send(json);
} else {
System.out.println("无将棋子同步给对手, 对方已结束游戏");
}
}
/**
* 聊天消息处理
*/
public static void chatMsg() {
result.put(Const.ID, Const.ID_STATUS_MSG);
String userId = json.getString(Const.MY);
UserData my = SuperServlet.getClient().get(userId);
// 获取对手名称
UserData you = SuperServlet.getClient().get(my.getEnemy());
if(you != null){
result.put(Const.MSG, json.getString(Const.MSG));
result.put(Const.MY, my.getUserName());
you.getMsgFormat().send(result);
}
}
/**
* 悔棋请求
*/
public static void toBack(){
String userId = json.getString(Const.MY);
UserData my = SuperServlet.getClient().get(userId);
result.put(Const.ID, Const.ID_STATUS_BACK);
UserData you = SuperServlet.getClient().get(my.getEnemy());
you.getMsgFormat().send(result);
}
/**
* 悔棋结果
*/
public static void toBackResult(){
String userId = json.getString(Const.MY);
UserData my = SuperServlet.getClient().get(userId);
result.put(Const.ID, Const.ID_STATUS_BACK_RESULT);
result.put(Const.MSG, json.getString(Const.MSG));
UserData you = SuperServlet.getClient().get(my.getEnemy());
you.getMsgFormat().send(result);
// 更新服务器棋盘以备观战
if("同意".equals(json.getString(Const.MSG))){
my.getChessBoard().remove(my.getChessBoard().size() - 1);
you.getChessBoard().remove(you.getChessBoard().size() - 1);
SuperServlet.updateClient(my.getUserId(), my);
SuperServlet.updateClient(you.getUserId(), you);
}
}
/**
* 相关属性定义
*/
private int span = 35; // 棋盘格子宽度
private int margin = 22;
private final int DIAMETER = 35; // 直径
private final int row = 15; // 棋盘行、列
private final int col = 15;
private int i = 0;
private boolean isBlack = true;
private boolean isPicture = true;// 是否用图片作为背景(图片是正常游戏背景，false为测试游戏背景)
private ImageIcon img = new ImageIcon("src/images/board.jpg");
private List<Chess> list = new LinkedList<Chess>(); // 整个棋盘
public boolean gameOver = true; // 默认结束游戏
// 网络数据
public boolean isNetworkPK = false;
public boolean myChessColor = false; // 记录我方落子的颜色
public boolean failFlag = false; // 认输标记
public MessageQueuePanel MQPanel;
public String userName = null; // 我的名称
public String userId = null; // 我的ID
以上定义中，棋盘就是我们的List，重写 JPanel 的Paint方法绘制游戏棋盘
@Override
public void paint(Graphics g) {
super.paint(g);
// span = this.getHeight() / row; // 当窗口被拖动，动态刷新窗口
Graphics2D g2 = (Graphics2D) g;
// 正常游戏绘制的棋盘是一张背景图片
g.drawImage(img.getImage(), 1, 0, null);
RadialGradientPaint rgp = null;
// 画棋子
for (i = 0; i < list.size(); ++i) {
Chess chess = list.get(i);
int xPos = chess.getX() * span + margin; // 将真实坐标转换成网格坐标
int yPos = chess.getY() * span + margin;
g2.setColor(chess.getColors()); // 设置画笔颜色
if (chess.getColors() == Color.BLACK) {
rgp = new RadialGradientPaint(xPos - DIAMETER / 2 + 26, //
yPos - DIAMETER / 2 + 12, 20, new float[] { 0.0f, 1.0f }, //
new Color[] { Color.WHITE, Color.BLACK });
g2.setPaint(rgp);
} else {
// x, y, 直径, 渐变度, 渐变色
rgp = new RadialGradientPaint(xPos - DIAMETER / 2 + 25, //
yPos - DIAMETER / 2 - 30, 60, new float[] { 0f, 1f }, //
new Color[] { Color.BLACK, Color.WHITE });
g2.setPaint(rgp);
}
// 去锯齿
g2.setRenderingHint(RenderingHints.KEY_ANTIALIASING, RenderingHints.VALUE_ANTIALIAS_ON);
g2.setRenderingHint(RenderingHints.KEY_ALPHA_INTERPOLATION, RenderingHints.VALUE_ALPHA_INTERPOLATION_DEFAULT);
g2.fillOval(xPos - DIAMETER / 2, yPos - DIAMETER / 2, span - 1, span);
// 画红色矩形
g2.setColor(Color.RED);
if (i == list.size() - 1)
g2.draw3DRect(xPos - DIAMETER / 2 - 1, //
yPos - DIAMETER / 2 - 1, span, span + 1, true);
}
}
// 判断胜利的方法
private boolean isWin(List<Chess> list, int xPos, int yPos, boolean isBlack) {
int chessCount = 1;
final int max = 5; // 连子数
int x = 0, y = 0;
Color color = (isBlack ? Color.BLACK : Color.WHITE);
// 当前位置向左
for (x = xPos - 1; x >= 0; --x) {
if (getChess(list, x, yPos, color) != null)
chessCount++;
else
break;
}
// 当前位置向右
for (x = xPos + 1; x <= row; ++x) {
if (getChess(list, x, yPos, color) != null)
chessCount++;
else
break;
}
if (chessCount >= max)
return true;
else
chessCount = 1;
// 当前位置向上
for (y = yPos - 1; y >= 0; --y) {
if (getChess(list, xPos, y, color) != null)
chessCount++;
else
break;
}
// 当前位置向下
for (y = yPos + 1; y <= col; ++y) {
if (getChess(list, xPos, y, color) != null)
chessCount++;
else
break;
}
if (chessCount >= max)
return true;
else
chessCount = 1;
// 左斜着向上
for (x = xPos - 1, y = yPos - 1; x >= 0 && y >= 0; --x, --y) {
if (getChess(list, x, y, color) != null)
chessCount++;
else
break;
}
// 右斜着向下
for (x = xPos + 1, y = yPos + 1; x <= row && y <= col; ++x, ++y) {
if (getChess(list, x, y, color) != null)
chessCount++;
else
break;
}
if (chessCount >= max)
return true;
else
chessCount = 1;
// 右斜着向上
for (x = xPos + 1, y = yPos - 1; x <= row && y >= 0; ++x, --y) {
if (getChess(list, x, y, color) != null)
chessCount++;
else
break;
}
// 左斜着向下
for (x = xPos - 1, y = yPos + 1; x >= 0 && y <= col; --x, ++y) {
if (getChess(list, x, y, color) != null)
chessCount++;
else
break;
}
if (chessCount >= max)
return true;
else
chessCount = 1;
return false;
}