java五子棋游戏代码.docx

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（））;