chessserver.java

JAVA五子期网络对战源代码,用Java开发的五子棋对战平台

/******************************************************************************************
最后是：chessServer.java
*******************************************************************************************/
import java.io.*;
import java.net.*;
import java.awt.*;
import java.util.*;
import java.awt.event.*;

class MessageServer extends Panel //implements ActionListener
{
  TextArea messageBoard=new TextArea("",22,50,TextArea.SCROLLBARS_VERTICAL_ONLY);
  Label statusLabel=new Label("当前连接数:",Label.LEFT);
  Panel boardPanel=new Panel();
  Panel statusPanel=new Panel();

  MessageServer()
  {
    setSize(350,300);
    setBackground(Color.pink);
    setLayout(new BorderLayout());
    boardPanel.setLayout(new FlowLayout());
    boardPanel.setSize(210,210);
    statusPanel.setLayout(new BorderLayout());
    statusPanel.setSize(210,50);
    boardPanel.add(messageBoard);
    statusPanel.add(statusLabel,BorderLayout.WEST);
    add(boardPanel,BorderLayout.CENTER);
    add(statusPanel,BorderLayout.NORTH);
  }
}


class ServerThread extends Thread
{
  Socket clientSocket;
  Hashtable clientDataHash;
  Hashtable clientNameHash;
  Hashtable chessPeerHash;
  MessageServer server;

  boolean isClientClosed=false;

  ServerThread(Socket clientSocket,Hashtable clientDataHash,Hashtable clientNameHash,Hashtable chessPeerHash,MessageServer server)
  {
    this.clientSocket=clientSocket;
    this.clientDataHash=clientDataHash;
    this.clientNameHash=clientNameHash;
    this.chessPeerHash=chessPeerHash;
    this.server=server;
  }



  public void messageTransfer(String message)
  {
    String clientName,peerName;

    if(message.startsWith("/"))
    {

      if(message.startsWith("/changename "))
      {
        clientName=message.substring(12);
        if( clientName.length()<=0 || clientName.length()>20 ||
          clientName.startsWith("/") || clientNameHash.containsValue(clientName) ||
          clientName.startsWith("changename")|| clientName.startsWith("list") ||
          clientName.startsWith("[inchess]") || clientName.startsWith("creatgame") ||
          clientName.startsWith("joingame") || clientName.startsWith("yourname") ||
          clientName.startsWith("userlist") || clientName.startsWith("chess") ||
          clientName.startsWith("OK") || clientName.startsWith("reject") ||
          clientName.startsWith("peer") || clientName.startsWith("peername") ||
          clientName.startsWith("giveup") || clientName.startsWith("youwin") ||
          clientName.startsWith("所有人"))
        {
          message="无效命令";
          Feedback(message);
        }
        else
        {
          if(clientNameHash.containsValue(("[inchess]"+(String)clientNameHash.get(clientSocket))))
          {
            synchronized(clientNameHash)
            {
              clientNameHash.put((Socket)getHashKey(clientNameHash,("[inchess]"+clientNameHash.get(clientSocket))),
              ("[inchess]"+clientName));
              chessPeerTalk(("[inchess]"+clientName),("/yourname "+("[inchess]"+clientName)));
            }
          }
          else if(chessPeerHash.containsKey(clientNameHash.get(clientSocket)))
          {
            //游戏客户端改名字
            synchronized(clientNameHash)
            {
              clientNameHash.put((Socket)getHashKey(clientNameHash,("[inchess]"+clientNameHash.get(clientSocket))),
              ("[inchess]"+clientName));
            }

            synchronized(chessPeerHash)
            {
              //chessPeerHash添加新名字映射
              chessPeerHash.put(clientName,chessPeerHash.get(clientNameHash.get(clientSocket)));
              //chessPeerHash删除旧映射
              chessPeerHash.remove(clientNameHash.get(clientSocket));
            }
            //向游戏客户端发送新名字
            chessPeerTalk(("[inchess]"+clientName),("/yourname "+("[inchess]"+clientName)));
            //向peer游戏客户端发送
            chessPeerTalk((String)chessPeerHash.get(clientName),("/peer "+"[inchess]"+clientName));

          }
          else if(chessPeerHash.containsValue(clientNameHash.get(clientSocket)))
          {
            synchronized(clientNameHash)
            {
              //游戏客户端改名字
              clientNameHash.put((Socket)getHashKey(clientNameHash,("[inchess]"+clientNameHash.get(clientSocket))),
              ("[inchess]"+clientName));
            }
            synchronized(chessPeerHash)
            {
              //chessPeerHash重新映射
              chessPeerHash.put((String)getHashKey(chessPeerHash,clientNameHash.get(clientSocket)),clientName);
              //向游戏客户端发送新名字
              chessPeerTalk(("[inchess]"+clientName),("/yourname "+("[inchess]"+clientName)));
            }
            //向peer游戏客户端发送
            chessPeerTalk((String)getHashKey(chessPeerHash,clientName),("/peer "+"[inchess]"+clientName));

          }

          message=clientNameHash.get(clientSocket)+"改名为:"+clientName;
          synchronized(clientNameHash)
          {
            clientNameHash.put(clientSocket,clientName);
          }
          publicTalk(message);
          Feedback("/yourname "+(String)clientNameHash.get(clientSocket));
          publicTalk(getUserList());

        }

      }
      else if(message.equals("/list"))
      {
         Feedback(getUserList());
      }
      else if(message.startsWith("/creatgame [inchess]"))
      {
        String chessServerName=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());
      }
      else if(message.startsWith("/joingame "))
      {
        StringTokenizer userToken=new StringTokenizer(message," ");
        String getUserToken,serverName,selfName;
        String[] chessNameOpt={"0","0"};
        int getOptNum=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"))
        {
          synchronized(clientNameHash)
          {
            clientNameHash.put(clientSocket,("[inchess]"+selfName));
          }
          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(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.messageBoard.append(message+"\n");
      publicTalk(message);
      server.messageBoard.setCaretPosition(server.messageBoard.getText().length());
    }




  }


  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();
        }
      }
    }

  }



  public boolean peerTalk(String peerTalk,String talkMessage)
  {

    for(Enumeration enu=clientDataHash.keys();enu.hasMoreElements();)
    {
      Socket userClient=(Socket)enu.nextElement();