frame1.java

java 五子棋 v2.1 Java源码。

                      jEditorPane2.setText(aiText6);
                    }
                    if(user.maxValue4>1){ //检测3,3禁手
                      for(int i=0; i<user.number4; i++){
                        canvas.setForbidLocation(Integer.parseInt(user.maxX4.get(i).toString()), Integer.parseInt(user.maxY4.get(i).toString()));
                      }
                      jEditorPane2.setText(aiText6);
                    }

                    //记录棋子历史
                    userLastX.add(canvas.userX);
                    userLastY.add(canvas.userY);
                    aiLastX.add(aiX);
                    aiLastY.add(aiY);
                    lastText.add(tempText);
                    backStep++;

                    turn=0;
                  }
                }
              }
            }
            thread1.sleep(250);
          }
        }
        catch(Exception e1){
          e1.printStackTrace();
          JOptionPane.showMessageDialog(null, e1.toString(), "控制线程产生异常", JOptionPane.ERROR_MESSAGE);
        }
      }
    }

    /**
     *
     * <p>Title: 类说明</p>
     *
     * <p>Description: 回顾演示线程类</p>
     *
     * <p>Copyright: Copyright (c) 2006</p>
     *
     * <p>Company: </p>
     *
     * @author goodboy
     * @version 2.1
     */
    class RetroThread extends Thread{
      int index=0;
      boolean black=true;
      public void run(){
        try{
          while(true){
            if(!retroSuspend){
              if(index<backStep){
                if(black){ //显示用户棋子
                  board[Integer.parseInt(userLastX.get(index).toString())][Integer.parseInt(userLastY.get(index).toString())]=1;
                  canvas.board=board;
                  canvas.repaint();
                  playSound(1);
                  black=false;
                  retro.showStep(index*2+1);
                }
                else{ //显示AI棋子
                  board[Integer.parseInt(aiLastX.get(index).toString())][Integer.parseInt(aiLastY.get(index).toString())]=2;
                  canvas.board=board;
                  canvas.repaint();
                  playSound(1);
                  black=true;
                  retro.showStep(index*2+2);
                  index++;
                }
              }
              else{
                index=0;
                black=true;
                retroSuspend=true;
                retro.setVisible(false);
              }
            }
            thread2.sleep(2000-retroSpeed);
          }
        }
        catch(Exception e2){
          e2.printStackTrace();
          JOptionPane.showMessageDialog(null, e2.toString(), "回顾演示线程产生异常", JOptionPane.ERROR_MESSAGE);
        }
      }
    }

    /**
     * <p>Description: 初始化数据</p>
     */
    public void initData(){
      for(int i=0;i<size;i++){
        for(int j=0;j<size;j++){
          board[i][j]=0;
        }
      }

      canvas.initData();
      user.initData();
      ai.initData();
      canvas.aiColor=ai.color;
      canvas.userColor=user.color;
      canvas.avail=true;
      canvas.repaint();

      userLastX.clear();
      userLastY.clear();
      aiLastX.clear();
      aiLastY.clear();
      lastText.clear();

      time=0;
      turn=0;
      backStep=0;
      retroSuspend=true;
      winner=0;
      userStep=0;
      aiStep=0;
      userFourLine=0;
      aiFourLine=0;
      userThreeLine=0;
      aiThreeLine=0;
      userMultiLine=0;
      aiMultiLine=0;
      forbidStyle=0;
      regretTime=0;

      jMenuItem8.setEnabled(false);
      jEditorPane2.setText(aiText2);

      suspend=false;
    }

    /**
     * <p>Description: 预测扫描</p>
     * @param preBoard 预测数据表
     * @param i 棋子横坐标
     * @param j 棋子纵坐标
     * @param n 棋子控制者(1:用户 2:AI)
     * @return 棋子预测权值
     */
    public int[] preCheck(int[][] preBoard, int i, int j, int n){
      int[] value; //临时数组

      preBoard[i][j]=n;
      value=preCheckLine(preBoard, i, j, n);
      preBoard[i][j]=0;

      return value;
    }

    /**
     * <p>Description: 直线预测扫描</p>
     * @param preBoard 预测数据表
     * @param i 棋子横坐标
     * @param j 棋子纵坐标
     * @param n 棋子控制者(1:用户 2:AI)
     * @return 棋子预测权值
     */
    public int[] preCheckLine(int[][] preBoard, int i, int j, int n){
      int maxNumber=0; //最多相连棋子数
      int[] result={0, 0, 0, 0, 0, 0, 0}; //返回数值
      int[] label={0, 0, 0, 0, 0, 0, 0}; //成线标记
      int min=0; //坐标边界
      int max=0; //坐标边界

      //检查竖线
      for(int k=4; k>=0; k--){
        if(j-k>=0){
          min=j-k;
          break;
        }
      }
      for(int k=4; k>=0; k--){
        if(j+k<size){
          max=j+k+1;
          break;
        }
      }
      for(int k=min; k<max; k++){
        if(preBoard[i][k]==n){ //棋子计数
          maxNumber++;
        }
        else{
          maxNumber=0;
        }

        if(maxNumber==1){ //到达1子共线
          if(k+4<max&&preBoard[i][k+1]==0&&preBoard[i][k+2]==n&&preBoard[i][k+3]==0&&preBoard[i][k+4]==n){ //是否为1-1-1棋型
            label[4]++;
          }
          if(k-1>=min&&k+3<max&&preBoard[i][k-1]==0&&preBoard[i][k+1]==0&&preBoard[i][k+2]==n&&preBoard[i][k+3]==0){ //是否为-1-1-棋型
            label[6]++;
          }
          if((k-1>=min&&k+3<max&&preBoard[i][k-1]==0&&preBoard[i][k+1]==0&&preBoard[i][k+2]==0&&preBoard[i][k+3]==n)
             ||(k+4<max&&preBoard[i][k+1]==0&&preBoard[i][k+2]==0&&preBoard[i][k+3]==n&&preBoard[i][k+4]==0)){ //是否为-1--1棋型或1--1-棋型
            label[6]++;
          }
          if((k+4<max&&preBoard[i][k+1]==0&&preBoard[i][k+2]==n&&preBoard[i][k+3]==0&&preBoard[i][k+4]==0)
             ||(k-2>=min&&k+2<max&&preBoard[i][k-2]==0&&preBoard[i][k-1]==0&&preBoard[i][k+1]==0&&preBoard[i][k+2]==n)){ //是否为1-1--棋型或--1-1棋型
            label[6]++;
          }
          if(k+4<max&&preBoard[i][k+1]==0&&preBoard[i][k+2]==0&&preBoard[i][k+3]==0&&preBoard[i][k+4]==n){ //是否为1---1棋型
            label[6]++;
          }
        }
        else if(maxNumber==2){ //到达2子共线
          if(k+3<max&&preBoard[i][k+1]==0&&preBoard[i][k+2]==n&&preBoard[i][k+3]==n){ //是否为2-2棋型
            label[2]++;
          }
          if((k-4>=min&&k+1<max&&preBoard[i][k-2]==0&&preBoard[i][k-3]==n&&preBoard[i][k-4]==0&&preBoard[i][k+1]==0)
             ||(k-2>=min&&k+3<max&&preBoard[i][k-2]==0&&preBoard[i][k+2]==n&&preBoard[i][k+3]==0&&preBoard[i][k+1]==0)){ //是否为-1-2-棋型或-2-1-棋型
            label[3]++;
          }
          if((k+3<max&&preBoard[i][k+1]==0&&preBoard[i][k+2]==n&&preBoard[i][k+3]==0)
             ||(k-4>=min&&preBoard[i][k-4]==0&&preBoard[i][k-3]==n&&preBoard[i][k-2]==0)){ //是否为2-1-棋型或-1-2棋型
            label[4]++;
          }
          if((k+3<max&&preBoard[i][k+1]==0&&preBoard[i][k+2]==0&&preBoard[i][k+3]==n)
             ||(k-4>=min&&preBoard[i][k-4]==n&&preBoard[i][k-3]==0&&preBoard[i][k-2]==0)){ //是否为2--1棋型或1--2棋型
            label[4]++;
          }
          if((k-2>=min&&k+2<max&&preBoard[i][k-2]==0&&preBoard[i][k+1]==0&&preBoard[i][k+2]==n)
             ||(k-3>=min&&k+1<max&&preBoard[i][k-3]==n&&preBoard[i][k-2]==0&&preBoard[i][k+1]==0)){ //是否为-2-1棋型或1-2-棋型
            label[4]++;
          }
          if((k-3>=min&&k+1<max&&preBoard[i][k-3]==0&&preBoard[i][k-2]==0&&preBoard[i][k+1]==0)
             ||(k-2>=min&&k+2<max&&preBoard[i][k-2]==0&&preBoard[i][k+1]==0&&preBoard[i][k+2]==0)){ //是否为--2-棋型或-2--棋型
            label[5]++;
          }
          if((k-4>=min&&preBoard[i][k-4]==0&&preBoard[i][k-3]==0&&preBoard[i][k-2]==0)
             ||(k+3<max&&preBoard[i][k+1]==0&&preBoard[i][k+2]==0&&preBoard[i][k+3]==0)){ //是否为---2棋型或2---棋型
            label[6]++;
          }
        }
        else if(maxNumber==3){ //到达3子共线
          if((k-4>=min&&preBoard[i][k-3]==0&&preBoard[i][k-4]==n)
             ||(k+2<max&&preBoard[i][k+1]==0&&preBoard[i][k+2]==n)){ //是否为1-3棋型或3-1棋型
            label[2]++;
          }
          if((k-4>=min&&k+1<max&&preBoard[i][k-4]==0&&preBoard[i][k-3]==0&&preBoard[i][k+1]==0)
             ||(k-3>=min&&k+2<max&&preBoard[i][k-3]==0&&preBoard[i][k+1]==0&&preBoard[i][k+2]==0)){ //是否为--3-棋型或-3--棋型
            label[3]++;
          }
          if((k-4>=min&&preBoard[i][k-4]==0&&preBoard[i][k-3]==0)
             ||(k+2<max&&preBoard[i][k+1]==0&&preBoard[i][k+2]==0)){ //是否为--3棋型或3--棋型
            label[4]++;
          }
          if(k-3>=min&&k+1<max&&preBoard[i][k-3]==0&&preBoard[i][k+1]==0){ //是否为-3-棋型
            label[4]++;
          }
        }
        else if(maxNumber==4){ //到达4子共线
          if(k-4>=min&&k+1<max&&preBoard[i][k-4]==0&&preBoard[i][k+1]==0){ //是否为-4-棋型
            label[1]++;
          }
          if((k-4>=min&&preBoard[i][k-4]==0)||k+1<max&&preBoard[i][k+1]==0){ //是否为-4棋型或4-棋型
            label[2]++;
          }
        }
        else if(maxNumber>=5){ //到达5子共线
          label[0]++;
        }
      }
      //恢复数据
      maxNumber=0;
      for(int k=0; k<7; k++){
        if(label[k]>0){
          result[k]++;
          label[k]=0;
        }
      }

      //检查横线
      for(int k=4; k>=0; k--){
        if(i-k>=0){
          min=i-k;
          break;
        }
      }
      for(int k=4; k>=0; k--){
        if(i+k<size){
          max=i+k+1;
          break;
        }
      }
      for(int k=min; k<max; k++){
        if(preBoard[k][j]==n){ //棋子计数
          maxNumber++;
        }
        else{
          maxNumber=0;
        }

        if(maxNumber==1){ //到达1子共线
          if(k+4<max&&preBoard[k+1][j]==0&&preBoard[k+2][j]==n&&preBoard[k+3][j]==0&&preBoard[k+4][j]==n){ //是否为1-1-1棋型
            label[4]++;
          }
          if(k-1>=min&&k+3<max&&preBoard[k-1][j]==0&&preBoard[k+1][j]==0&&preBoard[k+2][j]==n&&preBoard[k+3][j]==0){ //是否为-1-1-棋型
            label[6]++;
          }
          if((k-1>=min&&k+3<max&&preBoard[k-1][j]==0&&preBoard[k+1][j]==0&&preBoard[k+2][j]==0&&preBoard[k+3][j]==n)
             ||(k+4<max&&preBoard[k+1][j]==0&&preBoard[k+2][j]==0&&preBoard[k+3][j]==n&&preBoard[k+4][j]==0)){ //是否为-1--1棋型或1--1-棋型
            label[6]++;
          }
          if((k+4<max&&preBoard[k+1][j]==0&&preBoard[k+2][j]==n&&preBoard[k+3][j]==0&&preBoard[k+4][j]==0)
             ||(k-2>=min&&k+2<max&&preBoard[k-2][j]==0&&preBoard[k-1][j]==0&&preBoard[k+1][j]==0&&preBoard[k+2][j]==n)){ //是否为1-1--棋型或--1-1棋型
            label[6]++;
          }
          if(k+4<max&&preBoard[k+1][j]==0&&preBoard[k+2][j]==0&&preBoard[k+3][j]==0&&preBoard[k+4][j]==n){ //是否为1---1棋型
            label[6]++;
          }
        }