java五子棋游戏代码.docx
《java五子棋游戏代码.docx》由会员分享，可在线阅读，更多相关《java五子棋游戏代码.docx（49页珍藏版）》请在冰豆网上搜索。
java五子棋游戏代码
packageserver;
importjava.io.*;
import.*;
importjava.awt.*;
importjava.util.*;
importjava.awt.event.*;
/**
*显示服务器及用户信息的Panel类
*/
classMessageServerPanelextendsPanel{
//主消息窗口
TextAreamessageBoard=newTextArea（"",22,50,TextArea.SCROLLBARS_VERTICAL_ONLY）;
LabelstatusLabel=newLabel（"当前连接数:
",Label.LEFT）;
PanelboardPanel=newPanel（）;//主显示区Panel
PanelstatusPanel=newPanel（）;//连接状态Panel
MessageServerPanel（）{
setSize（350,300）;
setBackground（newColor（204,204,204））;
setLayout（newBorderLayout（））;
boardPanel.setLayout（newFlowLayout（））;
boardPanel.setSize（210,210）;
statusPanel.setLayout（newBorderLayout（））;
statusPanel.setSize（210,50）;
boardPanel.add（messageBoard）;
statusPanel.add（statusLabel,BorderLayout.WEST）;
add（boardPanel,BorderLayout.CENTER）;
add（statusPanel,BorderLayout.NORTH）;
}
}
/**
*服务器线程,主要用于服务器与客户端的通信
*/
classServerThreadextendsThread{
SocketclientSocket;
HashtableclientDataHash;//Socket与发送数据的流的映射
HashtableclientNameHash;//Socket与用户名的映射
HashtablechessPeerHash;//对弈的两个客户端用户名的映射
MessageServerPanelserver;
booleanisClientClosed=false;
/**
*服务器端线程的构造函数，用于初始化一些对象。
*/
ServerThread（SocketclientSocket,HashtableclientDataHash,HashtableclientNameHash,HashtablechessPeerHash,
MessageServerPanelserver）{
this.clientSocket=clientSocket;
this.clientDataHash=clientDataHash;
this.clientNameHash=clientNameHash;
this.chessPeerHash=chessPeerHash;
this.server=server;
}
/**
*对客户端发来的消息处理的函数，处理后转发回客户端。
处理消息的过程比较复杂，要针对很多种情况分别处理。
*/
publicvoidmessageTransfer（Stringmessage）{
StringclientName,peerName;
/////////////命令处理///////////////////////////////
//如果消息以“/”开头，表明是命令消息。
if（message.startsWith（"/"））{
//如果消息以“/list”开头，则将其回馈到客户端以更新用户列表
if（message.equals（"/list"））{
Feedback（getUserList（））;
}
//如果消息以"/creatgame[inchess]"开头，则修改clientNameHash映射
//和chessPeerHash映射。
elseif（message.startsWith（"/creatgame[inchess]"））{
//
StringchessServerName=message.substring（20）;
synchronized（clientNameHash）{
clientNameHash.put（clientSocket,message.substring（11））;
}
synchronized（chessPeerHash）{//刚创建，等待其他人加入
chessPeerHash.put（chessServerName,"wait"）;
}
Feedback（"/yourname"+clientNameHash.get（clientSocket））;
chessPeerTalk（chessServerName,"/OK"）;
publicTalk（getUserList（））;
}
//如果消息以“/joingame”开头，则将消息的服务端名字和本地用户名提取出来，
//然后修改clientNameHash表和chessPeerHash表。
if（message.startsWith（"/joingame"））{
StringTokenizeruserToken=newStringTokenizer（message,""）;
StringgetUserToken,serverName,selfName;
String[]chessNameOpt={"0","0"};
intgetOptNum=0;
//提取服务端用户名和本地用户名
while（userToken.hasMoreTokens（））{
getUserToken=（String）userToken.nextToken（""）;
if（getOptNum>=1&&getOptNum<=2）{
chessNameOpt[getOptNum-1]=getUserToken;
}
getOptNum++;
}
serverName=chessNameOpt[0];
selfName=chessNameOpt[1];
//如果有服务端在等待开始棋局
if（chessPeerHash.containsKey（serverName）&&chessPeerHash.get（serverName）.equals（"wait"））{
//修改Socket和名字映射
synchronized（clientNameHash）{
clientNameHash.put（clientSocket,（"[inchess]"+selfName））;
}
//修改chessPeerHash映射
synchronized（chessPeerHash）{
chessPeerHash.put（serverName,selfName）;
}
publicTalk（getUserList（））;
chessPeerTalk（selfName,（"/peer"+"[inchess]"+serverName））;
chessPeerTalk（serverName,（"/peer"+"[inchess]"+selfName））;
}else{
chessPeerTalk（selfName,"/reject"）;
try{
clientClose（）;
}catch（Exceptionez）{
}
}
}
//如果消息以“/[inchess]”开头，则获取要发送消息的用户名和发送的消息
//然后发送出去。
elseif（message.startsWith（"/[inchess]"））{
intfirstLocation=0,lastLocation;
lastLocation=message.indexOf（"",0）;
peerName=message.substring（（firstLocation+1）,lastLocation）;
message=message.substring（（lastLocation+1））;
if（chessPeerTalk（peerName,message））{
Feedback（"/error"）;
}
}
//如果消息以“/giveup”开头，则判断是对弈双方哪方放弃了。
elseif（message.startsWith（"/giveup"））{
StringchessClientName=message.substring（8）;
if（chessPeerHash.containsKey（chessClientName）
&&!
（（String）chessPeerHash.get（chessClientName））.equals（"wait"））{
//如果服务方放弃，则发送消息“/youwin”表明对方获胜
chessPeerTalk（（String）chessPeerHash.get（chessClientName）,"/youwin"）;
//剔除这对对弈的人。
。
synchronized（chessPeerHash）{
chessPeerHash.remove（chessClientName）;
}
}
if（chessPeerHash.containsValue（chessClientName））{
//如果客户方放弃，也发送消息“/youwin”表明对方获胜
chessPeerTalk（（String）getHashKey（chessPeerHash,chessClientName）,"/youwin"）;
synchronized（chessPeerHash）{
chessPeerHash.remove（（String）getHashKey（chessPeerHash,chessClientName））;
}
}
}
//如果找不到发送消息的用户，则输出消息说“没有这个用户”
else{
intfirstLocation=0,lastLocation;
lastLocation=message.indexOf（"",0）;
if（lastLocation==-1）{
Feedback（"无效命令"）;
return;
}else{
peerName=message.substring（（firstLocation+1）,lastLocation）;
message=message.substring（（lastLocation+1））;
message=（String）clientNameHash.get（clientSocket）+">"+message;
if（peerTalk（peerName,message））{
Feedback（"没有这个用户:
"+peerName+"\n"）;
}
}
}
}
////////////////////////////////////////////////
//如果不以“/”开头，表明是普通消息，直接发送
else{
message=clientNameHash.get（clientSocket）+">"+message;
server.messageBoard.append（message+"\n"）;
publicTalk（message）;
server.messageBoard.setCaretPosition（server.messageBoard.getText（）.length（））;
}
}
/**
*发送公共消息的函数，将消息向每个客户端都发送一份
*/
publicvoidpublicTalk（StringpublicTalkMessage）{
synchronized（clientDataHash）{
//枚举遍历所有客户端输出流。
。
for（Enumerationenu=clientDataHash.elements（）;enu.hasMoreElements（）;）{
DataOutputStreamoutData=（DataOutputStream）enu.nextElement（）;
try{
//输出信息。
。
这里会阻塞
outData.writeUTF（publicTalkMessage）;
}catch（IOExceptiones）{
//打印异常堆栈。
。
。
终止程序。
。
es.printStackTrace（）;
}
}
}
}
/**
*选择对象发送消息，参数peerTalk为发送的用户名，后面的参数为发送的消息
*/
publicbooleanpeerTalk（StringpeerTalk,StringtalkMessage）{
//
for（Enumerationenu=clientDataHash.keys（）;enu.hasMoreElements（）;）{
SocketuserClient=（Socket）enu.nextElement（）;
//找到发送消息的对象，获取它的输出流以发送消息
if（peerTalk.equals（（String）clientNameHash.get（userClient））
&&!
peerTalk.equals（（String）clientNameHash.get（clientSocket）））{
synchronized（clientDataHash）{
DataOutputStreampeerOutData=（DataOutputStream）clientDataHash.get（userClient）;
try{
peerOutData.writeUTF（talkMessage）;
}catch（IOExceptiones）{
es.printStackTrace（）;
}
}
Feedback（talkMessage）;
return（false）;
}
//如果是发给自己的，直接回馈
elseif（peerTalk.equals（（String）clientNameHash.get（clientSocket）））{
Feedback（talkMessage）;
return（false）;
}
}
return（true）;
}
/**
*此函数也用于选择发送消息，但不能发送给自己。
*/
publicbooleanchessPeerTalk（StringchessPeerTalk,StringchessTalkMessage）{
for（Enumerationenu=clientDataHash.keys（）;enu.hasMoreElements（）;）{
SocketuserClient=（Socket）enu.nextElement（）;
if（chessPeerTalk.equals（（String）clientNameHash.get（userClient））
&&!
chessPeerTalk.equals（（String）clientNameHash.get（clientSocket）））{
synchronized（clientDataHash）{
DataOutputStreampeerOutData=（DataOutputStream）clientDataHash.get（userClient）;
try{
peerOutData.writeUTF（chessTalkMessage）;
}catch（IOExceptiones）{
es.printStackTrace（）;
}
}
return（false）;
}
}
return（true）;
}
/**
*用于处理消息回馈的函数
*/
publicvoidFeedback（StringfeedbackString）{
synchronized（clientDataHash）{
//得到输出流。
。
。
DataOutputStreamoutData=（DataOutputStream）clientDataHash.get（clientSocket）;
try{
//输出信息。
。
。
outData.writeUTF（feedbackString）;
}catch（Exceptioneb）{
//打印堆栈轨迹，程序终止。
。
eb.printStackTrace（）;
}
}
}
/**
*获取用户列表的函数，此函数读取clientNameHash获取用户列表，然后将其保存在一个字符串userList中。
*/
publicStringgetUserList（）{
StringuserList="/userlist";
//遍历hashtable中的values，以空格分割连接起来
for（Enumerationenu=clientNameHash.elements（）;enu.hasMoreElements（）;）{
userList=userList+""+（String）enu.nextElement（）;
}
returnuserList;
}
/**
*给出HashTable和值对象，获取相对应得键值的函数。
*/
publicObjectgetHashKey（HashtabletargetHash,ObjecthashValue）{
ObjecthashKey;
for（Enumerationenu=targetHash.keys（）;enu.hasMoreElements（）;）{
hashKey=（Object）enu.nextElement（）;
//如果键对应的值与hashValue相等,则返回这个key
if（hashValue.equals（（Object）targetHash.get（hashKey）））
return（hashKey）;
}
return（null）;
}
publicvoidfirstCome（）{
//新用户第一次加入、广播用户列表。
。
publicTalk（getUserList（））;
//反馈给这个用户，以修改相应显示信息。
。
Feedback（"/yourname"+（String）clientNameHash.get（clientSocket））;
Feedback（"Java五子棋聊天客户端"）;
Feedback（"/changename<你的名字>--更改名字"）;
Feedback（"/list--更新用户列表"）;
Feedback（"/<用户名><要说的话>--私聊"）;
Feedback（"注意：
用命令的时候，先把谈话的对象定为所有人"）;
}
/**
*用于和客户端断开的函数。
*/
publicvoidclientClose（）{
server.messageBoard.append（"用户断开:
"+clientSocket+"\n"）;
//如果是游戏客户端主机
synchronized（chessPeerHash）{
if（chessPeerHash.containsKey（clientNameHash.get（clientSocket）））{
chessPeerHash.remove（（String）clientNameHash.get（clientSocket））;
}
if（chessPeerHash.containsValue（clientNameHash.get（clientSocket）））{
chessPeerHash.put（（String）getHashKey（chessPeerHash,（String）clientNameHash.get（clientSocket））,
"tobeclosed"）;
}
}
//将保留的HashTable里的数据清除
synchronized（clientDataHash）{
clientDataHash.remove（clientSocket）;
}
synchronized（clientNameHash）{
clientNameHash.remove（clientSocket）;
}
//广播更新用户列表。
。
。
publicTalk（getUserList（））;
//计算当前连接数，并显示在状态框中
server.statusLabel.setText（"当前连接数:
"+clientDataHash.size（））;
try{
clientSocket.close（）;
}catch（IOExceptionexx）{
}
isClientClosed=true;
}
publicvoidrun（）{
DataInputStreaminData;
synchronized（clientDataHash）{
server.statusLabel.setText（"当前连接数:
"+clientDataHash.size（））;
}
try{
inData=newDataInputStream（clientSocket.getInputStream（））;
升级会员 