wuziqiserver.java~54~

是JB的2D网络游戏

         }
         else{
           chessPeerTalk(selfName, "/reject");
           try {
             clientClose();
           }
           catch (Exception ez) {
           }
         }
       }
       else if (message.startsWith("/[inchess]")){
         int firstLocation = 0, lastLocation;
         lastLocation = message.indexOf(" ", 0);
         peerName = message.substring( (firstLocation + 1), lastLocation);
         message = message.substring( (lastLocation + 1));
         if (chessPeerTalk(peerName, message)) {
           Feedback("/error");
         }
       }
       else if (message.startsWith("/giveup ")){
         String chessClientName = message.substring(8);
         if (chessPeerHash.containsKey(chessClientName) &&
             ! ( (String) chessPeerHash.get(chessClientName)).equals("wait")){
           chessPeerTalk( (String) chessPeerHash.get(chessClientName), "/youwin");
           synchronized (chessPeerHash){
             chessPeerHash.remove(chessClientName);
           }
         }
         if (chessPeerHash.containsValue(chessClientName)){
           chessPeerTalk( (String) getHashKey(chessPeerHash, chessClientName),
                         "/youwin");
           synchronized (chessPeerHash) {
             chessPeerHash.remove( (String) getHashKey(chessPeerHash,
                 chessClientName));
           }
         }
       }
       else {
         int firstLocation = 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.jTextArea1.append(message + "\n");
       publicTalk(message);
       server.jTextArea1.setCaretPosition(server.jTextArea1.getText().length());
     }
   }
   //向客户端发送数据，直接从clientDataHash中取出
   public void publicTalk(String publicTalkMessage){
     synchronized (clientDataHash){
       for(Enumeration enu = clientDataHash.elements();enu.hasMoreElements();){
         DataOutputStream outData = (DataOutputStream)enu.nextElement();
         try{
           outData.writeUTF(publicTalkMessage);
         }
         catch(IOException es){
           es.printStackTrace();
         }
       }
     }
   }
   //私聊信息，把talkMessage字符串转发给名字为peerTalk的用户；
   //所谓转发直接调用名字为peerTalk的socket的输出流，把信息；
   //使用wirteUTF(String)发送即可；并且发送给自己反馈信息；
   public boolean peerTalk(String peerTalk, String talkMessage){
     for (Enumeration enu = clientDataHash.keys(); enu.hasMoreElements();){
       Socket userClient = (Socket)enu.nextElement();
       //判断peerTalk字符串和clientNameHash中的某个用户名字是否一样，
       //同时不能和当前用户的名字一样；
       if (peerTalk.equals((String)clientNameHash.get(userClient))&&
           !peerTalk.equals( (String)clientNameHash.get(clientSocket))) {
         synchronized (clientDataHash){
           DataOutputStream peerOutData = (DataOutputStream)clientDataHash.get(userClient);
           try{
             peerOutData.writeUTF(talkMessage);
           }
           catch (IOException es) {
             es.printStackTrace();
           }
         }
         Feedback(talkMessage);
         return (false);
       }
       else if (peerTalk.equals( (String) clientNameHash.get(clientSocket))) {
         Feedback(talkMessage);
         return (false);
       }
     }
     return (true);
   }
   //和peerTalk()代码相同,给对应的chesspeerTalk发送信息chessTalkMessage;
   public boolean chessPeerTalk(String chessPeerTalk, String chessTalkMessage){
     for (Enumeration enu = clientDataHash.keys(); enu.hasMoreElements();){
       Socket userClient = (Socket) enu.nextElement();
       if(chessPeerTalk.equals((String) clientNameHash.get(userClient)) &&
           !chessPeerTalk.equals((String) clientNameHash.get(clientSocket))){
         synchronized (clientDataHash){
           DataOutputStream peerOutData = (DataOutputStream) clientDataHash.get(
               userClient);
           try{
             peerOutData.writeUTF(chessTalkMessage);
           }
           catch (IOException es){
             es.printStackTrace();
           }
         }
         return (false);
       }
     }
     return (true);
   }
  //字符串反馈给当前用户；
   public void Feedback(String feedbackString){
     synchronized (clientDataHash){
       DataOutputStream outData = (DataOutputStream) clientDataHash.get(
           clientSocket);
       try {
         outData.writeUTF(feedbackString);
       }
       catch (Exception eb){
         eb.printStackTrace();
       }
     }
   }
   public String getUserList(){
     String userList = "/userlist";
     for(Enumeration enu = clientNameHash.elements(); enu.hasMoreElements();)
     {
       userList = userList + " " + (String) enu.nextElement();
     }
     return (userList);
   }
   //根据Hashtable表的Value获得其Key;
   public Object getHashKey(Hashtable targetHash, Object hashValue){
     Object hashKey;
     //遍历Hashtable中的每对元素，选择与hashValue对象值相等的Key;
     for(Enumeration enu = targetHash.keys(); enu.hasMoreElements();){
       hashKey = (Object)enu.nextElement();
       if(hashValue.equals((Object)targetHash.get(hashKey)))
         return (hashKey);
     }
     return (null);
   }
   public void firstCome(){
     publicTalk(getUserList());
     Feedback("/yourname " + (String)clientNameHash.get(clientSocket));
     Feedback("Java五子棋聊天客户端");
     Feedback("/changename <你的名字> --更改名字");
     Feedback("/list --更新用户列表");
     Feedback("/<用户名> <要说的话> --私聊");
     Feedback("注意：用命令的时候，先把谈话的对象定为所有人");
   }
   public void clientClose(){
     server.jTextArea1.append("用户断开:" + clientSocket + "\n");
     //如果是游戏客户端主机,直接从chessPeerHash把该对元素移出
     synchronized (chessPeerHash){
       if (chessPeerHash.containsKey(clientNameHash.get(clientSocket))){
         chessPeerHash.remove((String) clientNameHash.get(clientSocket));
       }
       //如果是游戏客户端从机，则把其对应的主机对应元素设置成"tobeclosed"
       if (chessPeerHash.containsValue(clientNameHash.get(clientSocket))){
         chessPeerHash.put((String)getHashKey(chessPeerHash,
                                                (String)clientNameHash.get(clientSocket)),
                           "tobeclosed");
       }
     }
     synchronized (clientDataHash){
       clientDataHash.remove(clientSocket);
     }
     synchronized (clientNameHash){
       clientNameHash.remove(clientSocket);
     }
     publicTalk(getUserList());
     server.jLabel1.setText("当前连接数:" + clientDataHash.size());
     try {
       clientSocket.close();
     }
     catch (IOException exx) {
     }
     isClientClosed = true;
   }
   public void run(){
     DataInputStream inData;
     synchronized (clientDataHash){
       server.jLabel1.setText("当前连接数:" + clientDataHash.size());
     }
     try {
       inData = new DataInputStream(clientSocket.getInputStream());
       firstCome();
       while (true){
         String message = inData.readUTF();
         messageTransfer(message);
       }
     }
     catch(IOException esx){
     }
     finally{
       if(!isClientClosed){
         clientClose();
       }
     }
   }
 }