java网络五子棋的源代码(一)

 
  
 java网络五子棋的源代码(一) 
［ 来源：CSDN    点击数：555    作者：不详 ］

 下面的源代码分为4个文件；
chessClient.java:客户端主程序。
chessInterface.java:客户端的界面。
chessPad.java:棋盘的绘制。
chessServer.java:服务器端。
可同时容纳50个人同时在线下棋，聊天。
没有加上详细注释，不过绝对可以运行，j2sdk1.4下通过。

/*********************************************************************************************
1.chessClient.java
**********************************************************************************************/

import java.awt.*;
import java.awt.event.*;
import java.io.*;
import java.net.*;
import java.util.*;

class clientThread extends Thread
{
 chessClient chessclient;

 clientThread(chessClient chessclient)
 {
  this.chessclient=chessclient;
 }

 public void acceptMessage(String recMessage)
 {
  if(recMessage.startsWith("/userlist "))
  {
   StringTokenizer userToken=new StringTokenizer(recMessage," ");
   int userNumber=0;

   chessclient.userpad.userList.removeAll();
   chessclient.inputpad.userChoice.removeAll();
   chessclient.inputpad.userChoice.addItem("所有人");
   while(userToken.hasMoreTokens())
   {
    String user=(String)userToken.nextToken(" ");
    if(userNumber>0 && !user.startsWith("[inchess]"))
    {
     chessclient.userpad.userList.add(user);
     chessclient.inputpad.userChoice.addItem(user);
    }

    userNumber++;
   }
   chessclient.inputpad.userChoice.select("所有人");
  }
  else if(recMessage.startsWith("/yourname "))
  {
   chessclient.chessClientName=recMessage.substring(10);
   chessclient.setTitle("Java五子棋客户端   "+"用户名:"+chessclient.chessClientName);
  }
  else if(recMessage.equals("/reject"))
  {
   try
   {
    chessclient.chesspad.statusText.setText("不能加入游戏");
    chessclient.controlpad.cancelGameButton.setEnabled(false);
    chessclient.controlpad.joinGameButton.setEnabled(true);
    chessclient.controlpad.creatGameButton.setEnabled(true);
   }
   catch(Exception ef)
   {
    chessclient.chatpad.chatLineArea.setText("chessclient.chesspad.chessSocket.close无法关闭");
   }
   chessclient.controlpad.joinGameButton.setEnabled(true);
  }
  else if(recMessage.startsWith("/peer "))
  {
   chessclient.chesspad.chessPeerName=recMessage.substring(6);
   if(chessclient.isServer)
   {
    chessclient.chesspad.chessColor=1;
    chessclient.chesspad.isMouseEnabled=true;
    chessclient.chesspad.statusText.setText("请黑棋下子");
   }
   else if(chessclient.isClient)
   {
    chessclient.chesspad.chessColor=-1;
    chessclient.chesspad.statusText.setText("已加入游戏，等待对方下子...");
   }

  }
  else if(recMessage.equals("/youwin"))
  {
   chessclient.isOnChess=false;
   chessclient.chesspad.chessVictory(chessclient.chesspad.chessColor);
   chessclient.chesspad.statusText.setText("对方退出，请点放弃游戏退出连接");
   chessclient.chesspad.isMouseEnabled=false;
  }
  else if(recMessage.equals("/OK"))
  {
   chessclient.chesspad.statusText.setText("创建游戏成功，等待别人加入...");
  }
  else if(recMessage.equals("/error"))
  {
   chessclient.chatpad.chatLineArea.append("传输错误：请退出程序，重新加入 /n");
  }
  else
  {
   chessclient.chatpad.chatLineArea.append(recMessage+"/n");
   chessclient.chatpad.chatLineArea.setCaretPosition(
    chessclient.chatpad.chatLineArea.getText().length());
  }
 }

 public void run()
 {
     String message="";
     try
     {
   while(true)
   {
    message=chessclient.in.readUTF();
    acceptMessage(message);
   }
  }
  catch(IOException es)
  {
  }
 }

}

 

 

public class chessClient extends Frame implements ActionListener,KeyListener
{
 userPad userpad=new userPad();
 chatPad chatpad=new chatPad();
 controlPad controlpad=new controlPad();
 chessPad chesspad=new chessPad();
 inputPad inputpad=new inputPad();

 Socket chatSocket;
 DataInputStream in;
 DataOutputStream out;
 String chessClientName=null;
 String host=null;
 int port=4331;

 boolean isOnChat=false;  //在聊天？
 boolean isOnChess=false; //在下棋？
 boolean isGameConnected=false; //下棋的客户端连接？
 boolean isServer=false; //如果是下棋的主机
 boolean isClient=false; //如果是下棋的客户端

 Panel southPanel=new Panel();
 Panel northPanel=new Panel();
 Panel centerPanel=new Panel();
 Panel westPanel=new Panel();
 Panel eastPanel=new Panel();

 chessClient()
 {
  super("Java五子棋客户端");
  setLayout(new BorderLayout());
  host=controlpad.inputIP.getText();

  westPanel.setLayout(new BorderLayout());
  westPanel.add(userpad,BorderLayout.NORTH);
  westPanel.add(chatpad,BorderLayout.CENTER);
  westPanel.setBackground(Color.pink);

  inputpad.inputWords.addKeyListener(this);
  chesspad.host=controlpad.inputIP.getText();

  centerPanel.add(chesspad,BorderLayout.CENTER);
  centerPanel.add(inputpad,BorderLayout.SOUTH);
  centerPanel.setBackground(Color.pink);

  controlpad.connectButton.addActionListener(this);
  controlpad.creatGameButton.addActionListener(this);
  controlpad.joinGameButton.addActionListener(this);
  controlpad.cancelGameButton.addActionListener(this);
  controlpad.exitGameButton.addActionListener(this);

  controlpad.creatGameButton.setEnabled(false);
  controlpad.joinGameButton.setEnabled(false);
  controlpad.cancelGameButton.setEnabled(false);

  southPanel.add(controlpad,BorderLayout.CENTER);
  southPanel.setBackground(Color.pink);

  addWindowListener(new WindowAdapter()
  {
   public void windowClosing(WindowEvent e)
   {
     if(isOnChat)
     {
      try
      {
       chatSocket.close();
      }
      catch(Exception ed)
      {
      }
     }
     if(isOnChess || isGameConnected)
     {
      try
      {
       chesspad.chessSocket.close();
      }
      catch(Exception ee)
      {
      }
     }
    System.exit(0);
   }
   public void windowActivated(WindowEvent ea)
   {

   }
  });

       add(westPanel,BorderLayout.WEST);
      add(centerPanel,BorderLayout.CENTER);
      add(southPanel,BorderLayout.SOUTH);

  pack();
  setSize(670,548);
  setVisible(true);
  setResizable(false);
  validate();
 }

 

 public boolean connectServer(String serverIP,int serverPort) throws Exception
 {
  try
  {
   chatSocket=new Socket(serverIP,serverPort);
   in=new DataInputStream(chatSocket.getInputStream());
   out=new DataOutputStream(chatSocket.getOutputStream());

   clientThread clientthread=new clientThread(this);
   clientthread.start();
   isOnChat=true;
   return true;
  }
  catch(IOException ex)
  {
   chatpad.chatLineArea.setText("chessClient:connectServer:无法连接,建议重新启动程序 /n");
  }
  return false;
 }

  public void actionPerformed(ActionEvent e)
  {
   if(e.getSource()==controlpad.connectButton)
   {
    host=chesspad.host=controlpad.inputIP.getText();
    try
    {
     if(connectServer(host,port))
     {
      chatpad.chatLineArea.setText("");
      controlpad.connectButton.setEnabled(false);
      controlpad.creatGameButton.setEnabled(true);
      controlpad.joinGameButton.setEnabled(true);
      chesspad.statusText.setText("连接成功，请创建游戏或加入游戏");
     }

    }
    catch(Exception ei)
    {
     chatpad.chatLineArea.setText("controlpad.connectButton:无法连接,建议重新启动程序 /n");
    }
    }
    if(e.getSource()==controlpad.exitGameButton)
    {
     if(isOnChat)
     {
      try
      {
       chatSocket.close();
      }
      catch(Exception ed)
      {
      }
     }
     if(isOnChess || isGameConnected)
     {
      try
      {
       chesspad.chessSocket.close();
      }
      catch(Exception ee)
      {
      }
     }
     System.exit(0);

    }
    if(e.getSource()==controlpad.joinGameButton)
    {
     String selectedUser=userpad.userList.getSelectedItem();
     if(selectedUser==null || selectedUser.startsWith("[inchess]") ||
       selectedUser.equals(chessClientName))
     {
      chesspad.statusText.setText("必须先选定一个有效用户");
     }
     else
     {
      try
      {
       if(!isGameConnected)
       {
        if(chesspad.connectServer(chesspad.host,chesspad.port))
        {
         isGameConnected=true;
         isOnChess=true;
         isClient=true;
         controlpad.creatGameButton.setEnabled(false);
         controlpad.joinGameButton.setEnabled(false);
         controlpad.cancelGameButton.setEnabled(true);
         chesspad.chessthread.sendMessage("/joingame "+userpad.userList.getSelectedItem()+" "+chessClientName);
        }
       }
       else
       {
        isOnChess=true;
        isClient=true;
        controlpad.creatGameButton.setEnabled(false);
        controlpad.joinGameButton.setEnabled(false);
        controlpad.cancelGameButton.setEnabled(true);
        chesspad.chessthread.sendMessage("/joingame "+userpad.userList.getSelectedItem()+" "+chessClientName);
       }

      }
      catch(Exception ee)
      {
       isGameConnected=false;
       isOnChess=false;
       isClient=false;
       controlpad.creatGameButton.setEnabled(true);
       controlpad.joinGameButton.setEnabled(true);
       controlpad.cancelGameButton.setEnabled(false);
       chatpad.chatLineArea.setText("chesspad.connectServer无法连接 /n"+ee);
      }

     }
    }
    if(e.getSource()==controlpad.creatGameButton)
    {
     try
     {
      if(!isGameConnected)
      {
       if(chesspad.connectServer(chesspad.host,chesspad.port))
       {
        isGameConnected=true;
        isOnChess=true;
        isServer=true;
        controlpad.creatGameButton.setEnabled(false);
        controlpad.joinGameButton.setEnabled(false);
        controlpad.cancelGameButton.setEnabled(true);
        chesspad.chessthread.sendMessage("/creatgame "+"[inchess]"+chessClientName);
       }
      }
      else
      {
       isOnChess=true;
       isServer=true;
       controlpad.creatGameButton.setEnabled(false);
       controlpad.joinGameButton.setEnabled(false);
       controlpad.cancelGameButton.setEnabled(true);
       chesspad.chessthread.sendMessage("/creatgame "+"[inchess]"+chessClientName);
      }
     }
     catch(Exception ec)
     {
      isGameConnected=false;
      isOnChess=false;
      isServer=false;
      controlpad.creatGameButton.setEnabled(true);
      controlpad.joinGameButton.setEnabled(true);
      controlpad.cancelGameButton.setEnabled(false);
      ec.printStackTrace();
      chatpad.chatLineArea.setText("chesspad.connectServer无法连接 /n"+ec);
     }

    }
    if(e.getSource()==controlpad.cancelGameButton)
    {
        if(isOnChess)
        {
      chesspad.chessthread.sendMessage("/giveup "+chessClientName);
      chesspad.chessVictory(-1*chesspad.chessColor);
      controlpad.creatGameButton.setEnabled(true);
      controlpad.joinGameButton.setEnabled(true);
      controlpad.cancelGameButton.setEnabled(false);
      chesspad.statusText.setText("请建立游戏或者加入游戏");
     }
     if(!isOnChess)
     {
      controlpad.creatGameButton.setEnabled(true);
      controlpad.joinGameButton.setEnabled(true);
      controlpad.cancelGameButton.setEnabled(false);
      chesspad.statusText.setText("请建立游戏或者加入游戏");
     }
     isClient=isServer=false;
     }

   }

 

   public void keyPressed(KeyEvent e)
   {
    TextField inputWords=(TextField)e.getSource();

    if(e.getKeyCode()==KeyEvent.VK_ENTER)
    {
     if(inputpad.userChoice.getSelectedItem().equals("所有人"))
     {
      try
      {
       out.writeUTF(inputWords.getText());
       inputWords.setText("");
      }
      catch(Exception ea)
      {
       chatpad.chatLineArea.setText("chessClient:KeyPressed无法连接,建议重新连接 /n");
       userpad.userList.removeAll();
       inputpad.userChoice.removeAll();
       inputWords.setText("");
       controlpad.connectButton.setEnabled(true);
      }
     }
     else
     {
      try
      {
       out.writeUTF("/"+inputpad.userChoice.getSelectedItem()+" "+inputWords.getText());
       inputWords.setText("");
      }
      catch(Exception ea)
      {
       chatpad.chatLineArea.setText("chessClient:KeyPressed无法连接,建议重新连接 /n");
       userpad.userList.removeAll();
       inputpad.userChoice.removeAll();
       inputWords.setText("");
       controlpad.connectButton.setEnabled(true);
      }
     }
      }

   }

   public void keyTyped(KeyEvent e)
   {
   }
   public void keyReleased(KeyEvent e)
   {
   }

 

   public static void main(String args[])
   {
    chessClient chessClient=new chessClient();
   }
}

 

 

/******************************************************************************************
下面是：chessInteface.java
******************************************************************************************/

import java.awt.*;
import java.awt.event.*;
import java.io.*;
import java.net.*;

class userPad extends Panel
{
 List userList=new List(10);

 userPad()
 {
  setLayout(new BorderLayout());

  for(int i=0;i<50;i++)
  {
   userList.add(i+"."+"没有用户");
  }
  add(userList,BorderLayout.CENTER);

 }

}

class chatPad extends Panel
{
 TextArea chatLineArea=new TextArea("",18,30,TextArea.SCROLLBARS_VERTICAL_ONLY);

 chatPad()
 {
  setLayout(new BorderLayout());

  add(chatLineArea,BorderLayout.CENTER);
 }

}

 

class controlPad extends Panel
{
 Label IPlabel=new Label("IP",Label.LEFT);
 TextField inputIP=new TextField("localhost",10);
 Button connectButton=new Button("连接主机");
 Button creatGameButton=new Button("建立游戏");
 Button joinGameButton=new Button("加入游戏");
 Button cancelGameButton=new Button("放弃游戏");
 Button exitGameButton=new Button("关闭程序");

 controlPad()
 {
  setLayout(new FlowLayout(FlowLayout.LEFT));
        setBackground(Color.pink);

  add(IPlabel);
  add(inputIP);
  add(connectButton);
  add(creatGameButton);
  add(joinGameButton);
  add(cancelGameButton);
  add(exitGameButton);
 }

}

class inputPad extends Panel
{
 TextField inputWords=new TextField("",40);
 Choice userChoice=new Choice();

 inputPad()
 {
  setLayout(new FlowLayout(FlowLayout.LEFT));
  for(int i=0;i<50;i++)
  {
   userChoice.addItem(i+"."+"没有用户");
  }
  userChoice.setSize(60,24);
  add(userChoice);
  add(inputWords);
 }
}

 

/**********************************************************************************************
下面是：chessPad.java
**********************************************************************************************/
import java.awt.*;
import java.awt.event.*;
import java.io.*;
import java.net.*;
import java.util.*;

class chessThread extends Thread
{
 chessPad chesspad;

 chessThread(chessPad chesspad)
 {
  this.chesspad=chesspad;
 }

 public void sendMessage(String sndMessage)
 {
  try
  {
   chesspad.outData.writeUTF(sndMessage);
  }
  catch(Exception ea)
  {
   System.out.println("chessThread.sendMessage:"+ea);
  }
 }

 public void acceptMessage(String recMessage)
 {
  if(recMessage.startsWith("/chess "))
  {
   StringTokenizer userToken=new StringTokenizer(recMessage," ");
   String chessToken;
   String[] chessOpt={"-1","-1","0"};
   int chessOptNum=0;

   while(userToken.hasMoreTokens())
   {
    chessToken=(String)userToken.nextToken(" ");
    if(chessOptNum>=1 && chessOptNum<=3)
    {
     chessOpt[chessOptNum-1]=chessToken;

    }
    chessOptNum++;
   }
   chesspad.netChessPaint(Integer.parseInt(chessOpt[0]),Integer.parseInt(chessOpt[1]),Integer.parseInt(chessOpt[2]));

  }
  else if(recMessage.startsWith("/yourname "))
  {
   chesspad.chessSelfName=recMessage.substring(10);
  }
  else if(recMessage.equals("/error"))
  {
   chesspad.statusText.setText("错误:没有这个用户，请退出程序，重新加入");
  }
  else
  {
   //System.out.println(recMessage);
  }
 }

 public void run()
 {
     String message="";
     try
     {
   while(true)
   {
    message=chesspad.inData.readUTF();
    acceptMessage(message);
   }
  }
  catch(IOException es)
  {
  }
 }

}

 

class chessPad extends Panel implements MouseListener,ActionListener
{
 int chessPoint_x=-1,chessPoint_y=-1,chessColor=1;
 int chessBlack_x[]=new int[200];
 int chessBlack_y[]=new int[200];
 int chessWhite_x[]=new int[200];
 int chessWhite_y[]=new int[200];
 int chessBlackCount=0,chessWhiteCount=0;
 int chessBlackWin=0,chessWhiteWin=0;
 boolean isMouseEnabled=false,isWin=false,isInGame=false;
 TextField statusText=new TextField("请先连接服务器");

    Socket chessSocket;
 DataInputStream inData;
 DataOutputStream outData;

 String chessSelfName=null;
 String chessPeerName=null;
 String host=null;
 int port=4331;
 chessThread chessthread=new chessThread(this);

    chessPad()
    {
  setSize(440,440);
     setLayout(null);
     setBackground(Color.pink);
     addMouseListener(this);
     add(statusText);
     statusText.setBounds(40,5,360,24);
     statusText.setEditable(false);
    }

  public boolean connectServer(String ServerIP,int ServerPort) throws Exception
  {
   try
   {
    chessSocket=new Socket(ServerIP,ServerPort);
    inData=new DataInputStream(chessSocket.getInputStream());
    outData=new DataOutputStream(chessSocket.getOutputStream());
     chessthread.start();
    return true;
   }
   catch(IOException ex)
   {
    statusText.setText("chessPad:connectServer:无法连接 /n");
   }
   return false;
  }

     public void chessVictory(int chessColorWin)
     {
    this.removeAll();
     for(int i=0;i<=chessBlackCount;i++)
    {
     chessBlack_x[i]=0;
          chessBlack_y[i]=0;
    }
    for(int i=0;i<=chessWhiteCount;i++)
    {
     chessWhite_x[i]=0;
          chessWhite_y[i]=0;
    }
    chessBlackCount=0;
    chessWhiteCount=0;
    add(statusText);
    statusText.setBounds(40,5,360,24);

         if(chessColorWin==1)
   { chessBlackWin++;
    statusText.setText("黑棋胜,黑:白为"+chessBlackWin+":"+chessWhiteWin+",重新开局,等待白棋下子...");
   }
      else if(chessColorWin==-1)
      {
    chessWhiteWin++;
    statusText.setText("白棋胜,黑:白为"+chessBlackWin+":"+chessWhiteWin+",重新开局,等待黑棋下子...");
   }
  }

 

     public void getLocation(int a,int b,int color)
     {

   if(color==1)
   {
    chessBlack_x[chessBlackCount]=a*20;
    chessBlack_y[chessBlackCount]=b*20;
    chessBlackCount++;
   }
   else if(color==-1)
   {
    chessWhite_x[chessWhiteCount]=a*20;
    chessWhite_y[chessWhiteCount]=b*20;
    chessWhiteCount++;
   }
  }

     public boolean checkWin(int a,int b,int checkColor)
     {
   int step=1,chessLink=1,chessLinkTest=1,chessCompare=0;
   if(checkColor==1)
   {
    chessLink=1;
    for(step=1;step<=4;step++)
    {
     for(chessCompare=0;chessCompare<=chessBlackCount;chessCompare++)
     {
      if(((a+step)*20==chessBlack_x[chessCompare]) && ((b*20)==chessBlack_y[chessCompare]))
      {
       chessLink=chessLink+1;
       if(chessLink==5)
       {
        return(true);
       }
      }
      }
      if(chessLink==(chessLinkTest+1))
      chessLinkTest++;
      else
      break;
     }
    for(step=1;step<=4;step++)
    {
     for(chessCompare=0;chessCompare<=chessBlackCount;chessCompare++)
     {
      if(((a-step)*20==chessBlack_x[chessCompare]) && (b*20==chessBlack_y[chessCompare]))
      {
       chessLink++;
       if(chessLink==5)
       {
        return(true);
       }
       }
      }
      if(chessLink==(chessLinkTest+1))
      chessLinkTest++;
      else
      break;
     }
    chessLink=1;
    chessLinkTest=1;
    for(step=1;step<=4;step++)
    {
     for(chessCompare=0;chessCompare<=chessBlackCount;chessCompare++)
     {
      if((a*20==chessBlack_x[chessCompare]) && ((b+step)*20==chessBlack_y[chessCompare]))
      {
       chessLink++;
       if(chessLink==5)
       {
        return(true);
       }
       }
         }
         if(chessLink==(chessLinkTest+1))
         chessLinkTest++;
         else
         break;
     }
    for(step=1;step<=4;step++)
    {
     for(chessCompare=0;chessCompare<=chessBlackCount;chessCompare++)
     {
      if((a*20==chessBlack_x[chessCompare]) && ((b-step)*20==chessBlack_y[chessCompare]))
      {
       chessLink++;
       if(chessLink==5)
       {
        return(true);
       }
       }
      }
      if(chessLink==(chessLinkTest+1))
      chessLinkTest++;
      else
      break;
     }
      chessLink=1;
      chessLinkTest=1;
      for(step=1;step<=4;step++)
      {
       for(chessCompare=0;chessCompare<=chessBlackCount;chessCompare++)
       {
        if(((a-step)*20==chessBlack_x[chessCompare]) && ((b+step)*20==chessBlack_y[chessCompare]))
        {
         chessLink++;
       if(chessLink==5)
       {
        return(true);
        }
         }
     }
     if(chessLink==(chessLinkTest+1))
     chessLinkTest++;
     else
     break;
      }
      for(step=1;step<=4;step++)
      {
       for(chessCompare=0;chessCompare<=chessBlackCount;chessCompare++)
       {
        if(((a+step)*20==chessBlack_x[chessCompare]) && ((b-step)*20==chessBlack_y[chessCompare]))
        {
         chessLink++;
       if(chessLink==5)
       {
        return(true);
        }
         }
        }
        if(chessLink==(chessLinkTest+1))
        chessLinkTest++;
        else
        break;
       }
      chessLink=1;
      chessLinkTest=1;
      for(step=1;step<=4;step++)
      {
       for(chessCompare=0;chessCompare<=chessBlackCount;chessCompare++)
       {
        if(((a+step)*20==chessBlack_x[chessCompare]) && ((b+step)*20==chessBlack_y[chessCompare]))
        {
         chessLink++;
       if(chessLink==5)
       {
        return(true);
        }
         }
        }
        if(chessLink==(chessLinkTest+1))
        chessLinkTest++;
        else
        break;
      }
      for(step=1;step<=4;step++)
      {
       for(chessCompare=0;chessCompare<=chessBlackCount;chessCompare++)
       {
        if(((a-step)*20==chessBlack_x[chessCompare]) && ((b-step)*20==chessBlack_y[chessCompare]))
        {
         chessLink++;
         if(chessLink==5)
         {
          return(true);
          }
      }
     }
        if(chessLink==(chessLinkTest+1))
        chessLinkTest++;
        else
        break;
       }
   }
     else if(checkColor==-1)
     {
    chessLink=1;
    for(step=1;step<=4;step++)
    {
     for(chessCompare=0;chessCompare<=chessWhiteCount;chessCompare++)
     {
      if(((a+step)*20==chessWhite_x[chessCompare]) && (b*20==chessWhite_y[chessCompare]))
      {
       chessLink++;
       if(chessLink==5)
       {
        return(true);
       }
       }
      }
      if(chessLink==(chessLinkTest+1))
      chessLinkTest++;
      else
      break;
     }
    for(step=1;step<=4;step++)
    {
     for(chessCompare=0;chessCompare<=chessWhiteCount;chessCompare++)
     {
      if(((a-step)*20==chessWhite_x[chessCompare]) && (b*20==chessWhite_y[chessCompare]))
      {
       chessLink++;
       if(chessLink==5)
       {
        return(true);
       }
       }
      }
      if(chessLink==(chessLinkTest+1))
      chessLinkTest++;
      else
      break;
     }
    chessLink=1;
    chessLinkTest=1;
    for(step=1;step<=4;step++)
    {
     for(chessCompare=0;chessCompare<=chessWhiteCount;chessCompare++)
     {
      if((a*20==chessWhite_x[chessCompare]) && ((b+step)*20==chessWhite_y[chessCompare]))
      {
       chessLink++;
       if(chessLink==5)
       {
        return(true);
       }
       }
      }
      if(chessLink==(chessLinkTest+1))
      chessLinkTest++;
      else
      break;
     }
    for(step=1;step<=4;step++)
    {
     for(chessCompare=0;chessCompare<=chessWhiteCount;chessCompare++)
     {
      if((a*20==chessWhite_x[chessCompare]) && ((b-step)*20==chessWhite_y[chessCompare]))
      {
       chessLink++;
       if(chessLink==5)
       {
        return(true);
       }
       }
      }
      if(chessLink==(chessLinkTest+1))
      chessLinkTest++;
      else
      break;
      }
      chessLink=1;
      chessLinkTest=1;
      for(step=1;step<=4;step++)
      {
       for(chessCompare=0;chessCompare<=chessWhiteCount;chessCompare++)
       {
        if(((a-step)*20==chessWhite_x[chessCompare]) && ((b+step)*20==chessWhite_y[chessCompare]))
        {
         chessLink++;
       if(chessLink==5)
       {
        return(true);
       }
       }
      }
      if(chessLink==(chessLinkTest+1))
      chessLinkTest++;
      else
      break;
      }
      for(step=1;step<=4;step++)
      {
       for(chessCompare=0;chessCompare<=chessWhiteCount;chessCompare++)
       {
        if(((a+step)*20==chessWhite_x[chessCompare]) && ((b-step)*20==chessWhite_y[chessCompare]))
        {
         chessLink++;
         if(chessLink==5)
         {
          return(true);
       }
         }
        }
        if(chessLink==(chessLinkTest+1))
        chessLinkTest++;
        else
        break;
      }
      chessLink=1;
      chessLinkTest=1;
      for(step=1;step<=4;step++)
      {
       for(chessCompare=0;chessCompare<=chessWhiteCount;chessCompare++)
       {
        if(((a+step)*20==chessWhite_x[chessCompare]) && ((b+step)*20==chessWhite_y[chessCompare]))
        {
         chessLink++;
         if(chessLink==5)
         {
          return(true);
          }
       }
      }
      if(chessLink==(chessLinkTest+1))
      chessLinkTest++;
      else
      break;
      }
      for(step=1;step<=4;step++)
      {
       for(chessCompare=0;chessCompare<=chessWhiteCount;chessCompare++)
       {
        if(((a-step)*20==chessWhite_x[chessCompare]) && ((b-step)*20==chessWhite_y[chessCompare]))
        {
         chessLink++;
         if(chessLink==5)
         {
          return(true);
          }
         }
      }
      if(chessLink==(chessLinkTest+1))
      chessLinkTest++;
      else
      break;
      }
     }
           return(false);
    }

 

 

     public void paint(Graphics g)
     {
   for (int i=40;i<=380;i=i+20)
      {
    g.drawLine(40,i,400,i);
   }
   g.drawLine(40,400,400,400);
         for(int j=40;j<=380;j=j+20)
         {
    g.drawLine(j,40,j,400);
   }
         g.drawLine(400,40,400,400);
         g.fillOval(97,97,6,6);
         g.fillOval(337,97,6,6);
         g.fillOval(97,337,6,6);
         g.fillOval(337,337,6,6);
         g.fillOval(217,217,6,6);
      }

      public void chessPaint(int chessPoint_a,int chessPoint_b,int color)
      {
    chessPoint_black chesspoint_black=new chessPoint_black(this);
    chessPoint_white chesspoint_white=new chessPoint_white(this);

    if(color==1 && isMouseEnabled)
    {
     getLocation(chessPoint_a,chessPoint_b,color);
     isWin=checkWin(chessPoint_a,chessPoint_b,color);
     if(isWin==false)
     {
      chessthread.sendMessage("/"+chessPeerName+" /chess "+chessPoint_a+" "+chessPoint_b+" "+color);
      this.add(chesspoint_black);
      chesspoint_black.setBounds(chessPoint_a*20-7,chessPoint_b*20-7,16,16);
      statusText.setText("黑(第"+chessBlackCount+"步)"+chessPoint_a+" "+chessPoint_b+",请白棋下子");
      isMouseEnabled=false;
     }
     else
     {
      chessthread.sendMessage("/"+chessPeerName+" /chess "+chessPoint_a+" "+chessPoint_b+" "+color);
      this.add(chesspoint_black);
      chesspoint_black.setBounds(chessPoint_a*20-7,chessPoint_b*20-7,16,16);
      chessVictory(1);
      isMouseEnabled=false;
     }
    }
    else if(color==-1 && isMouseEnabled)
    {
     getLocation(chessPoint_a,chessPoint_b,color);
     isWin=checkWin(chessPoint_a,chessPoint_b,color);
     if(isWin==false)
     {
      chessthread.sendMessage("/"+chessPeerName+" /chess "+chessPoint_a+" "+chessPoint_b+" "+color);
      this.add(chesspoint_white);
      chesspoint_white.setBounds(chessPoint_a*20-7,chessPoint_b*20-7,16,16);
      statusText.setText("白(第"+chessWhiteCount+"步)"+chessPoint_a+" "+chessPoint_b+",请黑棋下子");
      isMouseEnabled=false;
     }
     else
     {
      chessthread.sendMessage("/"+chessPeerName+" /chess "+chessPoint_a+" "+chessPoint_b+" "+color);
      this.add(chesspoint_white);
      chesspoint_white.setBounds(chessPoint_a*20-7,chessPoint_b*20-7,16,16);
      chessVictory(-1);
      isMouseEnabled=false;
     }
    }
   }

      public void netChessPaint(int chessPoint_a,int chessPoint_b,int color)
      {
    chessPoint_black chesspoint_black=new chessPoint_black(this);
    chessPoint_white chesspoint_white=new chessPoint_white(this);
    getLocation(chessPoint_a,chessPoint_b,color);
    if(color==1)
    {
     isWin=checkWin(chessPoint_a,chessPoint_b,color);
     if(isWin==false)
     {

      this.add(chesspoint_black);
      chesspoint_black.setBounds(chessPoint_a*20-7,chessPoint_b*20-7,16,16);
      statusText.setText("黑(第"+chessBlackCount+"步)"+chessPoint_a+" "+chessPoint_b+",请白棋下子");
      isMouseEnabled=true;
     }
     else
     {
      this.add(chesspoint_black);
      chesspoint_black.setBounds(chessPoint_a*20-7,chessPoint_b*20-7,16,16);
      chessVictory(1);
      isMouseEnabled=true;
     }
    }
    else if(color==-1)
    {
     isWin=checkWin(chessPoint_a,chessPoint_b,color);
     if(isWin==false)
     {
      this.add(chesspoint_white);
      chesspoint_white.setBounds(chessPoint_a*20-7,chessPoint_b*20-7,16,16);
      statusText.setText("白(第"+chessWhiteCount+"步)"+chessPoint_a+" "+chessPoint_b+",请黑棋下子");
      isMouseEnabled=true;
     }
     else
     {
      chessthread.sendMessage("/"+chessPeerName+" /victory "+color);
      this.add(chesspoint_white);
      chesspoint_white.setBounds(chessPoint_a*20-7,chessPoint_b*20-7,16,16);
      chessVictory(-1);
      isMouseEnabled=true;
     }
    }
   }

      public void mousePressed(MouseEvent e)
      {
    if (e.getModifiers()==InputEvent.BUTTON1_MASK)
    {
     chessPoint_x=(int)e.getX();
     chessPoint_y=(int)e.getY();
     int a=(chessPoint_x+10)/20,b=(chessPoint_y+10)/20;
     if(chessPoint_x/20<2||chessPoint_y/20<2||chessPoint_x/20>19||chessPoint_y/20>19)
     {}
     else
     {
      chessPaint(a,b,chessColor);
     }
   }
  }

  public void mouseReleased(MouseEvent e){}
  public void mouseEntered(MouseEvent e) {}
  public void mouseExited(MouseEvent e) {}
  public void mouseClicked(MouseEvent e) {}

  public void actionPerformed(ActionEvent e)
  {

  }
}

class chessPoint_black extends Canvas implements MouseListener
{
 chessPad chesspad=null;
 chessPoint_black(chessPad p)
 {
  setSize(20,20);
  chesspad=p;
  addMouseListener(this);
 }

 public void paint(Graphics g)
 {
  g.setColor(Color.black);
  g.fillOval(0,0,14,14);
 }

 public void mousePressed(MouseEvent e)
 {
//  if(e.getModifiers()==InputEvent.BUTTON3_MASK)
//  {
//   chesspad.remove(this);
//   chesspad.chessColor=1;
//   chesspad.text_2.setText("");
//   chesspad.text_1.setText("请黑棋下子");
//  }
 }
 public void mouseReleased(MouseEvent e){}
 public void mouseEntered(MouseEvent e) {}
 public void mouseExited(MouseEvent e) {}
 public void mouseClicked(MouseEvent e) {}
}

class chessPoint_white extends Canvas implements MouseListener
{
 chessPad chesspad=null;
 chessPoint_white(chessPad p)
 {
  setSize(20,20);
  addMouseListener(this);
  chesspad=p;
 }

 public void paint(Graphics g)
 {
  g.setColor(Color.white);
  g.fillOval(0,0,14,14);
 }

 public void mousePressed(MouseEvent e)
 {
//  if(e.getModifiers()==InputEvent.BUTTON3_MASK)
//  {
//   chesspad.remove(this);
//   chesspad.chessColor=-1;
//   chesspad.text_2.setText("请白旗下子");
//   chesspad.text_1.setText("");
//  }
 }
 public void mouseReleased(MouseEvent e){}
 public void mouseEntered(MouseEvent e) {}
 public void mouseExited(MouseEvent e) {}
 public void mouseClicked(MouseEvent e)
 {
//  if(e.getClickCount()>=2)
//  chesspad.remove(this);
 }
}