chesspanel.java~40~

是JB的2D网络游戏

package wuziqiclient;

import java.awt.*;
import com.borland.jbcl.layout.*;
import javax.swing.*;
import java.awt.event.*;
import java.io.*;
import java.net.*;
import java.util.*;
//游戏进行时数据传输线程
class chessThread  extends Thread {
  chessPanel chesspanel;//游戏面板
  chessThread(chessPanel chesspanel) {
    this.chesspanel = chesspanel;
  }
  //chessThread发送消息部分；
  public void sendMessage(String sndMessage){
    try{
      System.out.println("客户端发送的消息:"+sndMessage);
      chesspanel.outData.writeUTF(sndMessage);
    }
    catch (Exception ea){
      System.out.println("chessThread.sendMessage:" + ea);
    }
  }
  //游戏线程的消息处理部分；
  public void acceptMessage(String recMessage){
    System.out.println("客户端接受的消息为:"+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++;
      }
      chesspanel.netChessPaint(Integer.parseInt(chessOpt[0]),
                             Integer.parseInt(chessOpt[1]),
                             Integer.parseInt(chessOpt[2]));

    }
    else if(recMessage.startsWith("/yourname ")){
      chesspanel.chessSelfName = recMessage.substring(10);
    }
    else if(recMessage.equals("/error")){
      chesspanel.jTextField1.setText("错误:没有这个用户，请退出程序，重新加入");
    }
    else {
    //System.out.println(recMessage);
    }
  }
  public void run(){
    String message = "";
    try{
      while (true){
        message = chesspanel.inData.readUTF();
        acceptMessage(message);
      }
    }
    catch (IOException es){
    }
  }
}
//含有围棋棋盘和监控用户的输入；
//定义chessPoint_x,chessPoint_y坐标表示当前下象棋的点;
//用四个200的整型数组纪录黑白双方下棋的坐标位置;
//chessBlackCount,chessWhiteCount分别表示当前点数;
//chessBlackWin,chessWhiteWin分别表示黑白双方胜的盘数;
//Socket:chessSocket表示下棋的连接Socket;下棋的相关信息由该Socket接收和发送;
//DataInputStream inData表示下棋的输入流;
//DataOutputStream outData表示下棋的输出流;
//启动一个chessThread负责信息的接收和发送;

public class chessPanel extends JPanel implements MouseListener{
  XYLayout xYLayout1 = new XYLayout();
  JTextField jTextField1 = new JTextField("请首先连接数据库");
  //添加成员变量;
  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;
  Socket chessSocket;      //游戏连接Socket;
  DataInputStream inData;  //游戏进行的输入流
  DataOutputStream outData;//游戏进行的输出流
  String chessSelfName = null;//自己的名字;
  String chessPeerName = null;//游戏对家的名字
  String host = null;//连接的服务器
  int port = 4331;//连接的端口号
  chessThread chessthread = new chessThread(this);

  public chessPanel(){
    try {
      jbInit();
    }
    catch(Exception ex) {
      ex.printStackTrace();
    }
  }
  //连接服务器,根据服务器地址和端口；连接服务器的同时，启动客户端线程；
  public boolean connectServer(String ServerIP, int ServerPort)throws
      Exception{
    try{
      chessSocket = new Socket(ServerIP, ServerPort);
     //System.out.println("下象棋的Socket的地址:"+chessSocket);
      inData = new DataInputStream(chessSocket.getInputStream());
      outData = new DataOutputStream(chessSocket.getOutputStream());
      chessthread.start();
      return true;
    }
    catch (IOException ex){
      this.jTextField1.setText("chessPad:connectServer:无法连接 \n");
    }
    return false;
  }
  //a,b代表棋盘的横和竖，可以计算出坐标位置分别放入对应的数组中；
 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 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;
     this.paintComponent(this.getGraphics());
     //重新添加jTextField1到当前面板;
     this.add(jTextField1, new XYConstraints(0, 3, 434, 24));
     if (chessColorWin == 1){
       chessBlackWin++;
       jTextField1.setText("黑棋胜,黑:白为" + chessBlackWin + ":" + chessWhiteWin +
                          ",重新开局,等待白棋下子...");
     }
     else if (chessColorWin == -1){
       chessWhiteWin++;
       jTextField1.setText("白棋胜,黑:白为" + chessBlackWin + ":" + chessWhiteWin +
                          ",重新开局,等待黑棋下子...");
     }

    }
 //在当前Panel上画出当前下的棋子，用Canvas实现,根据chessPoint_a,chessPoint_b功能和颜色；
 //并且把该信息发送给对手，格式为:/chesspeerName /chess chessPoint_a chessPoint_b color;
 public void chessPaint(int chessPoint_a, int chessPoint_b, int color){
   chessPoint_black chesspoint_black = new chessPoint_black();
   chessPoint_white chesspoint_white = new chessPoint_white();
   if(color == 1 && isMouseEnabled){
     //获得位置；用处为了checkwin使用；
     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);
       jTextField1.setText("黑(第" + chessBlackCount + "步)" + chessPoint_a + " " +
                          chessPoint_b + ",请白棋下子");
       isMouseEnabled = false;
     }
     else{
      //发送当前坐标信息给对手；
      //格式为:/chessPeerName /chess chessPoint_a chessPoint_b color;
       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);
       jTextField1.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();
    chessPoint_white chesspoint_white = new chessPoint_white();
    //获得棋盘该点的坐标，为了checkWin使用
    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);
      jTextField1.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);
        jTextField1.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 boolean checkWin(int a, int b, int checkColor){
    int step = 1, chessLink = 1, chessLinkTest = 1, chessCompare = 0;
    if (checkColor == 1){
      chessLink = 1;
      //横向黑棋是否能够胜利，分别从a,b点的左和右开始检查；
      //从右边开始，首先看右边第一格，右边第二格，右边第三个格
      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);
            }
          }
        }
        //判断中间是否存在间隔的白子，如果有则chessLink!=chessLinkTest+1,则需要在右边计算
        //直接break就可以
        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);