AI版五子棋 - Wayne's Blog

使用了博弈树和剪枝算法，至于水平如何，反正作为作者我是下不过它。

=================Main.java=====================
import java.awt.Color;
import java.awt.Graphics;
import java.awt.event.MouseEvent;
import java.awt.event.MouseListener;
import javax.swing.JFrame;

public class Main extends JFrame implements MouseListener {

 int AI_WIN, PEROP_WIN;
 int Winning; // 胜率
 boolean draw_chessboard = true, draw_chess = false;
 boolean init = true;
 boolean AI_play = false;
 int winner = 0;
 int x, y; // 棋子坐标
 int _x, _y; // 鼠标指针坐标
 int count = 0;
 int[][] chess = new int[23][23];

 int w = 26; // 设置每个格子的间距
 int px = 100, py = 100;
 int pxw = (px + w), pyw = (py + w); // 设置每个格子的间距
 int width = w * 22, height = w * 22;
 int vline = (width + px);
 int hline = (height + py);
 AI computer = new AI();
 Thread thread = new Thread();
 String statistics = new String();

 public Main() {
  this.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
  this.addMouseListener(this);
  this.setSize(900, 750);
  this.setVisible(true);
 }

 public void paint(Graphics Graph) {
  if (draw_chessboard) {
   Graph.clearRect(0, 0, this.getWidth(), this.getHeight()); // 清除面板
   Graph.setColor(Color.green);// 设置棋盘的颜色
   Graph.fill3DRect(px, py, width, height, true);// 设置棋盘位置
   Graph.setColor(Color.black); // 设置网格颜色
   Graph.drawRect(px, py, width, height);// 设置面板的边界
   Graph.drawString("五子棋——AI版", 110, 70);// 设置标题

   /**
    * 画每条横线和竖线
    */
   for (int i = 0; i < 21; i++) {
    Graph.drawLine(pxw + i * w, py, pxw + i * w, hline); // 画竖线
    Graph.drawLine(px, pyw + i * w, vline, pyw + i * w); // 画横线
   }
   init = true;
   draw_chessboard = false; // 表示棋盘已经画好
  }
  if (init) {
   count = 1;
   _x = _y = x = y = 386;
   draw_chess = true;
   chess[11][11] = 1; // 设置中间位置为黑子
   init = false;
  }

  statistics = String.format("电脑胜了%d局", AI_WIN);
  Graph.clearRect(700, 120, 140, 25);
  Graph.setColor(Color.BLUE);
  Graph.drawString(statistics, 700, 125);

  statistics = String.format("你胜了%d局", PEROP_WIN);
  Graph.clearRect(700, 150, 140, 25);
  Graph.setColor(Color.BLUE);
  Graph.drawString(statistics, 700, 155);

  if (AI_WIN == 0 && PEROP_WIN > 0)
   Winning = 100;
  else if (AI_WIN == 0 && PEROP_WIN == 0)
   Winning = 0;
  else {
   Winning = (int) (((double) PEROP_WIN / (double) (AI_WIN + PEROP_WIN)) * 100);
  }
  statistics = String.format("你的胜率%d%%", Winning);
  Graph.clearRect(700, 180, 140, 25);
  Graph.setColor(Color.BLUE);
  Graph.drawString(statistics, 700, 185);

  Graph.clearRect(580, 50, 140, 25); // 擦除上次消息
  Graph.clearRect(350, 690, 100, 25);
  if (count == 2) {
   Graph.setColor(Color.black);
   Graph.drawString("轮到黑棋落子", 350, 700);
   Graph.setColor(Color.WHITE);
  } else {
   Graph.setColor(Color.black);
   Graph.drawString("轮到白棋落子", 350, 700);
   Graph.setColor(Color.BLACK);
  }
  if ((_x >= 100 && _x <= 672) && (_y >= 100 && _y <= 672)) // 判断落子坐标是否在棋盘内
  {
   if (draw_chess) {
    Graph.fillArc(x - w / 2, y - w / 2, w, w, 0, 360); // 给圆填充颜色
   } else {
    Graph.setColor(Color.red);
    Graph.drawString("请不要重复落子", 580, 70);
   }
  } else {
   Graph.setColor(Color.red);
   Graph.drawString("请落子在棋盘内", 580, 70);
  }
  if (winner != 0) {
   if (winner == 2) {
    Graph.setColor(Color.red);
    Graph.drawString("恭喜！你赢了。", 580, 70);
    PEROP_WIN++;
    draw_chessboard = true; // 需要重新画棋盘
    winner = 0;
    AI_play = false;
    for (int y = 0; y < 23; y++) {
     for (int x = 0; x < 23; x++) {
      chess[x][y] = 0; // 初始化棋盘布局
     }
    }
    return;
   } else {
    Graph.setColor(Color.red);
    Graph.drawString("电脑赢了！", 580, 70);
    AI_WIN++;
    winner = 0;
    AI_play = false;
    draw_chessboard = true;
    for (int y = 0; y < 23; y++) {
     for (int x = 0; x < 23; x++) {
      chess[x][y] = 0;
     }
    }
    return;
   }
  }
  if (AI_play) {
   AI_play();
   count = 1;
   AI_play = false;
   this.repaint();
   return;
  }
 }

 @Override
 // 获取鼠标事件
 public void mouseClicked(MouseEvent e) {

  int m, n;

  // 获取鼠标指针的坐标
  _x = e.getX();
  _y = e.getY();

  if (draw_chessboard) {
   _x = _y = x = y = 0;
  }
  // 判断落子是否在棋盘内
  if ((_x - 100 >= 0) && (_x - 100) <= 572 && (_y - 100 >= 0)
    && (_y - 100 <= 572)) {
   // 判断落子在哪个位置
   for (m = 0; m <= 22; m++) {
    if ((_x - (100 + 26 * m)) <= 10) { // 得到落子点Y坐标
     x = 100 + 26 * m;
     break;
    }
   }
   for (n = 0; n <= 22; n++) {
    if ((_y - (100 + 26 * n)) <= 10) { // 得到落子点Y坐标
     y = 100 + 26 * n;
     break;
    }
   }
   // 判断落子处是否已有棋子
   if (chess[m][n] == 0) {
    // m代表X坐标，n代表Y坐标,1:黑子；2:白子
    count = 2; // 画白子
    draw_chess = true;
    chess[m][n] = 2;
    winner = Traversal_chessboard(); // 检查是否有获胜的玩家
    AI_play = true;
   } else {
    draw_chess = false;
   }
  }

  this.repaint();
 }

 void AI_play() {
  int[] AI_coord = new int[2];
  AI_coord = computer.play(chess);
  count = 1; // 画黑子
  x = 100 + 26 * AI_coord[0];
  y = 100 + 26 * AI_coord[1];
  chess[AI_coord[0]][AI_coord[1]] = 1;
  winner = Traversal_chessboard(); // 检查是否有获胜的玩家
 }

 // 遍历棋盘上的所有棋子
 int Traversal_chessboard() {
  for (int i = 0; i < 23; i++) {
   for (int j = 0; j < 23; j++) {
    if (chess[i][j] != 0) {
     if (judgement_win(i, j)) // 以某一棋子为中心检查是否连够五个
      return chess[i][j];
    }
   }
  }
  return 0;
 }

 // 判断当前颜色的棋子是否胜利.。
 // 传入棋子的X,Y坐标
 boolean judgement_win(int chess_x, int chess_y) {
  boolean win = false;
  int last_chess = chess[chess_x][chess_y];
  int x_t = 0, y_t = 0;

  // 分别检查八个方向
  for (int i = 0; i < 8;) {
   switch (i) {
   case 0:
    x_t++;
    break;
   case 1:
    x_t++;
    y_t++;
    break;
   case 2:
    y_t++;
    break;
   case 3:
    x_t--;
    y_t++;
    break;
   case 4:
    x_t--;
    break;
   case 5:
    y_t--;
    x_t--;
    break;
   case 6:
    y_t--;
    break;
   case 7:
    y_t--;
    x_t++;
    break;
   }

   try {
    if (chess[chess_x + x_t][chess_y + y_t] != last_chess) {
     i++;
     y_t = x_t = 0;
     win = false;
     continue;
    } else {
     win = true;
    }
   } catch (Exception e) {
    i++;
    y_t = x_t = 0;
    win = false;
   }
   if (Math.abs(x_t) == 4 || Math.abs(y_t) == 4) {
    if (win)
     return true;
    y_t = x_t = 0;
    i++;
   }
  }
  return false;
 }

 @Override
 public void mouseEntered(MouseEvent arg0) {
  // TODO Auto-generated method stub

 }

 @Override
 public void mouseExited(MouseEvent arg0) {
  // TODO Auto-generated method stub

 }

 @Override
 public void mousePressed(MouseEvent arg0) {
  // TODO Auto-generated method stub

 }

 @Override
 public void mouseReleased(MouseEvent arg0) {
  // TODO Auto-generated method stub

 }

 public static void main(String args[]) {

  // TODO: handle exception

  Main start = new Main();// 执行构造函数
 }
}

 

 

=====================AI.java============================

import java.util.Random;

public class AI {
 static int Traversal_x = 0, Traversal_y = 0;
 int Intercept_status;
 int[][] chessboard = new int[23][23];
 int[] Best_direct = new int[4];
 Random rand = new Random();

 // 传入棋盘布局的二维数组，返回计算机落子的坐标，首元素为X，末元素为Y。
 public int[] play(int[][] chess) {
  Traversal_x = Traversal_y = 0;
  int[] coord = new int[2];
  int[] target_coord = new int[3]; // 前两个元素表示起始棋子坐标，末元素表示连续方向。
  // Traversal_x=Traversal_y=0;
  System.arraycopy(chess, 0, chessboard, 0, chess.length); // 复制数组

  // 首先检查黑棋是否有连够4个的情况。
  Traversal_x = Traversal_y = 0; // 从棋盘左上角开始遍历。
  while (Traversal_x != 22 || Traversal_y != 22) {
   if ((target_coord = Traversal_chessboard(4, 1))[0] != -1) {
    // 取得这串黑棋的围堵情况
    Intercept_status = Check_Intercept(target_coord[0],
      target_coord[1], target_coord[2]);
    switch (Intercept_status) {
    case 1: // 首部被堵住了，但是尾部没有被堵住。
     // 在尾部添加一棋子
     coord = block_tail(target_coord[0], target_coord[1],
       target_coord[2]);
     return coord;
    case 2: // 尾部被堵住了，但是首部没有被堵住。
     // 在首部添加一棋子
     coord = block_header(target_coord[0], target_coord[1],
       target_coord[2]);
     return coord;
    case 0: // 两边都没有被堵住。
     // 在尾部添加一棋子
     coord = block_tail(target_coord[0], target_coord[1],
       target_coord[2]);
     return coord;
    default: // 两边都被堵住了。
     Traversal_x++;
     break;
    }
   }
  }

  // 检查是否有三黑一空一黑的情况
  Traversal_x = Traversal_y = 0; // 从棋盘左上角重新开始遍历。
  while (Traversal_x != 22 || Traversal_y != 22) {
   // 首先取得有三个连续黑棋的情况。
   if ((target_coord = Traversal_chessboard(3, 1))[0] != -1) {
    // 取得这串黑棋子围堵的情况
    Intercept_status = Check_Intercept(target_coord[0],
      target_coord[1], target_coord[2]);
    if (Intercept_status != 3) {
     switch (sangeyi(target_coord[0], target_coord[1],
       target_coord[2], Intercept_status)) {
     case 1:
      coord = block_tail(target_coord[0], target_coord[1],
        target_coord[2]);
      return coord;
     case 2:
      coord = block_header(target_coord[0], target_coord[1],
        target_coord[2]);
      return coord;
     default:
      break;
     }
    }
    Traversal_x++;
   }
  }

  // 检查是否有两黑一空两黑的情况。
  Traversal_x = Traversal_y = 0; // 从棋盘左上角重新开始遍历。
  while (Traversal_x != 22 || Traversal_y != 22) {
   // 首先取得有两个连续黑棋的情况。
   if ((target_coord = Traversal_chessboard(2, 1))[0] != -1) {
    // 取得这串黑棋子围堵的情况
    Intercept_status = Check_Intercept(target_coord[0],
      target_coord[1], target_coord[2]);
    if (Intercept_status != 3) {
     switch (ergeyilianer(target_coord[0], target_coord[1],
       target_coord[2], Intercept_status)) {
     case 1:
      coord = block_tail(target_coord[0], target_coord[1],
        target_coord[2]);
      return coord;
     case 2:
      coord = block_header(target_coord[0], target_coord[1],
        target_coord[2]);
      return coord;
     default:
      break;
     }
    }
    Traversal_x++;
   }
  }

  // 检查白子是否有连够4个的情况
  Traversal_x = Traversal_y = 0; // 从棋盘左上角重新开始遍历。
  while (Traversal_x != 22 || Traversal_y != 22) {
   if ((target_coord = Traversal_chessboard(4, 2))[0] != -1) {
    // 取得这串白棋子围堵的情况
    Intercept_status = Check_Intercept(target_coord[0],
      target_coord[1], target_coord[2]);
    switch (Intercept_status) {
    case 1: // 首部堵住了，但是尾部没有堵住。
     coord = block_tail(target_coord[0], target_coord[1],
       target_coord[2]);
     return coord;
    case 2: // 尾部堵住了，但是首部没有被堵住。
     coord = block_header(target_coord[0], target_coord[1],
       target_coord[2]);
     return coord;
    case 0: // 头部和尾部都没堵住
     coord = block_header(target_coord[0], target_coord[1],
       target_coord[2]);
     return coord;
    default: // 头部和尾部都被堵住了
     Traversal_x++; // 遍历的坐标向X轴正向移一位。
     break;
    }
   }
  }

  // 检查是否有三白一空一白的情况
  Traversal_x = Traversal_y = 0; // 从棋盘左上角重新开始遍历。
  while (Traversal_x != 22 || Traversal_y != 22) {
   // 首先取得有三个连续白棋的情况。
   if ((target_coord = Traversal_chessboard(3, 2))[0] != -1) {
    // 取得这串白棋子围堵的情况
    Intercept_status = Check_Intercept(target_coord[0],
      target_coord[1], target_coord[2]);
    if (Intercept_status != 3) {
     switch (sangeyi(target_coord[0], target_coord[1],
       target_coord[2], Intercept_status)) {
     case 1:
      coord = block_tail(target_coord[0], target_coord[1],
        target_coord[2]);
      return coord;
     case 2:
      coord = block_header(target_coord[0], target_coord[1],
        target_coord[2]);
      return coord;
     default:
      break;
     }
    }
    Traversal_x++;
   }
  }

  // 检查是否有两白一空两白的情况。
  Traversal_x = Traversal_y = 0; // 从棋盘左上角重新开始遍历。
  while (Traversal_x != 22 || Traversal_y != 22) {
   // 首先取得有两个连续黑棋的情况。
   if ((target_coord = Traversal_chessboard(2, 2))[0] != -1) {
    // 取得这串黑棋子围堵的情况
    Intercept_status = Check_Intercept(target_coord[0],
      target_coord[1], target_coord[2]);
    if (Intercept_status != 3) {
     switch (ergeyilianer(target_coord[0], target_coord[1],
       target_coord[2], Intercept_status)) {
     case 1:
      coord = block_tail(target_coord[0], target_coord[1],
        target_coord[2]);
      return coord;
     case 2:
      coord = block_header(target_coord[0], target_coord[1],
        target_coord[2]);
      return coord;
     default:
      break;
     }
    }
    Traversal_x++;
   }
  }

  // 检查黑子是否有连够3个且两边都没堵的情况。
  boolean random = false;
  int _x = 0, _y = 0;
  Traversal_x = Traversal_y = 0;
  while (Traversal_x != 22 || Traversal_y != 22) {
   if ((target_coord = Traversal_chessboard(3, 1))[0] != -1) {
    // 取得这串黑棋子围堵的情况
    Intercept_status = Check_Intercept(target_coord[0],
      target_coord[1], target_coord[2]);
    switch (Intercept_status) {
    case 0: // 头部和尾部都没堵住
     switch (target_coord[2]) {
     case 0:
      _x = 4;
      break;
     case 1:
      _x = 4;
      _y = 4;
      break;
     case 2:
      _y = 4;
      break;
     case 3:
      _y = 4;
      _x = -4;
      break;
     case 4:
      _x = -4;
      break;
     case 5:
      _x = -4;
      _y = -4;
      break;
     case 6:
      _y = -4;
      break;
     case 7:
      _y = -4;
      _x = 4;
      break;
     }
     try { // 试探尾棋子可否再增加
      if (chessboard[target_coord[0] + _x][target_coord[1]
        + _y] != 2) {
       // 尾棋子可再增加
       switch (target_coord[2]) {
       case 0:
        _x = -2;
        break;
       case 1:
        _x = -2;
        _y = -2;
        break;
       case 2:
        _y = -2;
        break;
       case 3:
        _y = -2;
        _x = 2;
        break;
       case 4:
        _x = 2;
        break;
       case 5:
        _x = 2;
        _y = 2;
        break;
       case 6:
        _y = 2;
        break;
       case 7:
        _y = 2;
        _x = -2;
        break;
       }
       try { // 试探首棋子是否可再增加
        if (chessboard[target_coord[0] + _x][target_coord[1]
          + _y] != 2) {
         // 首棋子也可继续增加
         random = true; // 可随机选择增加位置
        } else {
         // 首棋子不可再增加，只能增加到尾棋子处
         coord = block_tail(target_coord[0],
           target_coord[1], target_coord[2]);
         return coord;
        }
       } catch (Exception e) {
        // TODO: handle exception
        coord = block_tail(target_coord[0],
          target_coord[2], target_coord[2]);
        return coord;
       }
      } else { // 尾棋子已不可再加，试探首棋子可再加否
       switch (target_coord[2]) {
       case 0:
        _x = -2;
        break;
       case 1:
        _x = -2;
        _y = -2;
        break;
       case 2:
        _y = -2;
        break;
       case 3:
        _y = -2;
        _x = 2;
        break;
       case 4:
        _x = 2;
        break;
       case 5:
        _x = 2;
        _y = 2;
        break;
       case 6:
        _y = 2;
        break;
       case 7:
        _y = 2;
        _x = -2;
        break;
       }
       try {
        if (chessboard[target_coord[0] + _x][target_coord[1]
          + _y] != 2) {
         // 首棋子可再增加
         coord = block_header(target_coord[0],
           target_coord[1], target_coord[2]);
         return coord;
        } else
         break; // 首棋子和尾棋子都不可再增加
       } catch (Exception e2) {
        // TODO: handle exception
        break; // 首棋子和尾棋子都不可再增加
       }
      }
     } catch (Exception e) {
      // 尾棋子不可再增加，试探首棋子是否可再增加
      // TODO: handle exception
      switch (target_coord[2]) {
      case 0:
       _x = -2;
       break;
      case 1:
       _x = -2;
       _y = -2;
       break;
      case 2:
       _y = -2;
       break;
      case 3:
       _y = -2;
       _x = 2;
       break;
      case 4:
       _x = 2;
       break;
      case 5:
       _x = 2;
       _y = 2;
       break;
      case 6:
       _y = 2;
       break;
      case 7:
       _y = 2;
       _x = -2;
       break;
      }
      try {
       if (chessboard[target_coord[0] + _x][target_coord[1]
         + _y] != 2) {
        // 首棋子可再增加
        coord = block_header(target_coord[0],
          target_coord[1], target_coord[2]);
        return coord;
       } else
        break; // 首棋子和尾棋子都不可再增加
      } catch (Exception e2) {
       // TODO: handle exception
       break; // 首棋子和尾棋子都不可再增加
      }
     }
     if (random) {
      if (rand.nextInt() % 2 == 0) {
       coord = block_tail(target_coord[0],
         target_coord[1], target_coord[2]);
      } else {
       coord = block_header(target_coord[0],
         target_coord[1], target_coord[2]);
      }
      return coord;
     }
     break;
    default:
     break;
    }
    Traversal_x++; // 遍历的坐标向X轴正向移一位。
   }
  }

  // 检查有无断夹角为2断连三的情况
  if ((coord = duanjiajiao_siliansan(1))[0] != -1) {
   return coord;
  }

  // 检查是否有两黑一空一黑的情况。
  Traversal_x = Traversal_y = 0; // 从棋盘左上角重新开始遍历。
  while (Traversal_x != 22 || Traversal_y != 22) {
   // 首先取得有两个连续黑棋的情况。
   if ((target_coord = Traversal_chessboard(2, 1))[0] != -1) {
    // 取得这串黑棋子围堵的情况
    Intercept_status = Check_Intercept(target_coord[0],
      target_coord[1], target_coord[2]);
    if (Intercept_status != 3) {
     switch (ergeyilianyi(target_coord[0], target_coord[1],
       target_coord[2], Intercept_status)) {
     case 1:
      coord = block_tail(target_coord[0], target_coord[1],
        target_coord[2]);
      return coord;
     case 2:
      coord = block_header(target_coord[0], target_coord[1],
        target_coord[2]);
      return coord;
     default:
      break;
     }
    }
    Traversal_x++;
   }
  }

  // 检查是否有三连一边堵的情况
  Traversal_x = Traversal_y = 0;
  while (Traversal_x != 22 || Traversal_y != 22) {
   if ((target_coord = Traversal_chessboard(3, 1))[0] != -1) {
    // 取得这串黑棋子围堵的情况
    Intercept_status = Check_Intercept(target_coord[0],
      target_coord[1], target_coord[2]);
    switch (Intercept_status) {
    case 1:
     if (Liansi(target_coord[0], target_coord[1],
       target_coord[2], Intercept_status)) {
      coord = block_tail(target_coord[0], target_coord[1],
        target_coord[2]);
      return coord;
     } else {
      break;
     }
    default:
     break;
    }
    Traversal_x++; // 遍历的坐标向X轴正向移一位。
   }
  }

  // 检查白棋有无断夹角为2断连三的情况
  if ((coord = duanjiajiao_siliansan(2))[0] != -1) {
   return coord;
  }

  // 检查白子是否有连够3个的情况。
  Traversal_x = Traversal_y = 0;
  while (Traversal_x != 22 || Traversal_y != 22) {
   if ((target_coord = Traversal_chessboard(3, 2))[0] != -1) {
    // 取得这串白棋子围堵的情况
    Intercept_status = Check_Intercept(target_coord[0],
      target_coord[1], target_coord[2]);
    switch (Intercept_status) {
    case 0: // 表示这串白棋没有被围堵
     if (rand.nextInt() % 2 == 0) {
      coord = block_header(target_coord[0], target_coord[1],
        target_coord[2]);
      return coord;
     } else {
      coord = block_tail(target_coord[0], target_coord[1],
        target_coord[2]);
      return coord;
     }
    default:
     break;
    }
    Traversal_x++;
   }
  }

  // 检查是否有两白一空一白的情况。
  Traversal_x = Traversal_y = 0; // 从棋盘左上角重新开始遍历。
  while (Traversal_x != 22 || Traversal_y != 22) {
   // 首先取得有两个连续白棋的情况。
   if ((target_coord = Traversal_chessboard(2, 2))[0] != -1) {
    // 取得这串白棋子围堵的情况
    Intercept_status = Check_Intercept(target_coord[0],
      target_coord[1], target_coord[2]);
    if (Intercept_status == 0) {
     switch (ergeyilianyi(target_coord[0], target_coord[1],
       target_coord[2], Intercept_status)) {
     case 1:
      coord = block_tail(target_coord[0], target_coord[1],
        target_coord[2]);
      return coord;
     case 2:
      coord = block_header(target_coord[0], target_coord[1],
        target_coord[2]);
      return coord;
     case 0:
     default:
      break;
     }
    }
    Traversal_x++;
   }
  }

  // 检查是黑棋否有T形图案
  if ((coord = T_pattern(1))[0] != -1) {
   return coord;
  }
  // 检查黑子是否有空十字的图案
  if ((coord = Check_Cross(1))[0] != -1) {
   return coord;
  }

  // 检查黑子是否有断夹角图案
  if ((coord = duanjiajiao(1))[0] != -1) {
   return coord;
  }

  // 检查黑棋是否有连够2个的情况
  _x = _y = 0;
  random = false;
  Traversal_x = Traversal_y = 0;
  while (Traversal_x != 22 || Traversal_y != 22) {
   if ((target_coord = Traversal_chessboard(2, 1))[0] != -1) {
    // 取得这串黑棋子围堵的情况
    Intercept_status = Check_Intercept(target_coord[0],
      target_coord[1], target_coord[2]);
    switch (Intercept_status) {
    case 0: // 表示这串黑棋没有被围堵
     switch (target_coord[2]) {
     case 0:
      _x = 3;
      break;
     case 1:
      _x = 3;
      _y = 3;
      break;
     case 2:
      _y = 3;
      break;
     case 3:
      _y = 3;
      _x = -3;
      break;
     case 4:
      _x = -3;
      break;
     case 5:
      _x = -3;
      _y = -3;
      break;
     case 6:
      _y = -3;
      break;
     case 7:
      _y = -3;
      _x = 3;
      break;
     }
     try { // 试探尾棋子可否再增加
      if (chessboard[target_coord[0] + _x][target_coord[1]
        + _y] != 2) {
       // 尾棋子可再增加
       switch (target_coord[2]) {
       case 0:
        _x = -2;
        break;
       case 1:
        _x = -2;
        _y = -2;
        break;
       case 2:
        _y = -2;
        break;
       case 3:
        _y = -2;
        _x = 2;
        break;
       case 4:
        _x = 2;
        break;
       case 5:
        _x = 2;
        _y = 2;
        break;
       case 6:
        _y = 2;
        break;
       case 7:
        _y = 2;
        _x = -2;
        break;
       }
       try { // 试探首棋子是否可再增加
        if (chessboard[target_coord[0] + _x][target_coord[1]
          + _y] != 2) {
         // 首棋子也可继续增加
         random = true; // 可随机选择增加位置
         break;
        } else {
         // 首棋子不可再增加，只能增加到尾棋子处
         coord = block_tail(target_coord[0],
           target_coord[1], target_coord[2]);
         return coord;
        }
       } catch (Exception e) {
        // TODO: handle exception
        coord = block_tail(target_coord[0],
          target_coord[2], target_coord[2]);
        return coord;
       }
      } else { // 尾棋子已不可再加，试探首棋子可再加否
       switch (target_coord[2]) {
       case 0:
        _x = -2;
        break;
       case 1:
        _x = -2;
        _y = -2;
        break;
       case 2:
        _y = -2;
        break;
       case 3:
        _y = -2;
        _x = 2;
        break;
       case 4:
        _x = 2;
        break;
       case 5:
        _x = 2;
        _y = 2;
        break;
       case 6:
        _y = 2;
        break;
       case 7:
        _y = 2;
        _x = -2;
        break;
       }
       try {
        if (chessboard[target_coord[0] + _x][target_coord[1]
          + _y] != 2) {
         // 首棋子可再增加
         coord = block_header(target_coord[0],
           target_coord[1], target_coord[2]);
         return coord;
        } else
         break; // 首棋子和尾棋子都不可再增加
       } catch (Exception e2) {
        // TODO: handle exception
        break; // 首棋子和尾棋子都不可再增加
       }
      }
     } catch (Exception e) {
      // 尾棋子不可再增加，试探首棋子是否可再增加
      // TODO: handle exception
      switch (target_coord[2]) {
      case 0:
       _x = -2;
       break;
      case 1:
       _x = -2;
       _y = -2;
       break;
      case 2:
       _y = -2;
       break;
      case 3:
       _y = -2;
       _x = 2;
       break;
      case 4:
       _x = 2;
       break;
      case 5:
       _x = 2;
       _y = 2;
       break;
      case 6:
       _y = 2;
       break;
      case 7:
       _y = 2;
       _x = -2;
       break;
      }
      try {
       if (chessboard[target_coord[0] + _x][target_coord[1]
         + _y] != 2) {
        // 首棋子可再增加
        coord = block_header(target_coord[0],
          target_coord[1], target_coord[2]);
        return coord;
       } else
        break; // 首棋子和尾棋子都不可再增加
      } catch (Exception e2) {
       // TODO: handle exception
       break; // 首棋子和尾棋子都不可再增加
      }
     }
    default:
     break;
    }
    if (random)
     if (rand.nextInt() % 2 == 0) {
      coord = block_header(target_coord[0], target_coord[1],
        target_coord[2]);
      return coord;
     } else {
      coord = block_tail(target_coord[0], target_coord[1],
        target_coord[2]);
      return coord;
     }
    Traversal_x++;
   }
  }

  // 检查是白棋否有T形图案
  if ((coord = T_pattern(2))[0] != -1) {
   return coord;
  }
  // 检查白子是否有空十字的图案
  if ((coord = Check_Cross(2))[0] != -1) {
   return coord;
  }

  // 检查白子是否有断夹角图案
  if ((coord = duanjiajiao(2))[0] != -1) {
   return coord;
  }

  // 找出一黑隔一黑的情况
  if ((coord = yigeyi(1))[0] != -1) {
   return coord;
  }

  // 找出最好位置的单独黑棋
  int direction = 0;
  boolean skip = false;
  boolean draw_chess = false;
  Traversal_x = Traversal_y = 0;
  while (Traversal_x != 22 || Traversal_y != 22) {
   if ((target_coord = Traversal_chessboard(1, 1))[0] != -1) {
    Best_direct = Best_Position(target_coord[0], target_coord[1]);
    for (int i = 0; i < Best_direct.length; i++) {
    }
    skip = false;
    draw_chess = true;
    if (rand.nextInt() % 2 == 0) {
     if (Best_direct[0] == 8 && Best_direct[1] == 8) {
      if (rand.nextInt() % 2 == 0)
       direction = 1;
      else {
       direction = 3;
      }
     } else {
      if (Best_direct[0] == 8)
       direction = 1;
      else if (Best_direct[1] == 8)
       direction = 3;
      else {
       skip = true;
      }
     }
    } else {
     if (Best_direct[2] == 8 && Best_direct[3] == 8) {
      if (rand.nextInt() % 2 == 0)
       direction = 2;
      else {
       direction = 0;
      }
     } else {
      if (Best_direct[2] == 8)
       direction = 2;
      else if (Best_direct[3] == 8)
       direction = 0;
      else {
       draw_chess = false;
      }
     }
    }
    if (skip) {
     if (Best_direct[2] == 8 && Best_direct[3] == 8) {
      if (rand.nextInt() % 2 == 0)
       direction = 2;
      else {
       direction = 0;
      }
     } else {
      if (Best_direct[2] == 8)
       direction = 2;
      else if (Best_direct[3] == 8)
       direction = 0;
      else {
       draw_chess = false;
      }
     }
    }
    if (draw_chess) {
     if (rand.nextInt() % 2 == 0)
      coord = block_header(target_coord[0], target_coord[1],
        direction);
     else {
      coord = block_tail(target_coord[0], target_coord[1],
        direction);
     }
     return coord;
    }
    Traversal_x++;
   }
  }

  // 找出一白隔一白的情况
  if ((coord = yigeyi(2))[0] != -1) {
   return coord;
  }

  // 检查白棋是否有连够2个的情况
  Traversal_x = Traversal_y = 0;
  while (Traversal_x != 22 || Traversal_y != 22) {
   if ((target_coord = Traversal_chessboard(2, 2))[0] != -1) {
    // 取得这串白棋子围堵的情况
    Intercept_status = Check_Intercept(target_coord[0],
      target_coord[1], target_coord[2]);
    switch (Intercept_status) {
    case 0: // 表示这串白棋没有被围堵
     if (rand.nextInt() % 2 == 0) {
      coord = block_header(target_coord[0], target_coord[1],
        target_coord[2]);
      return coord;
     } else {
      coord = block_tail(target_coord[0], target_coord[1],
        target_coord[2]);
      return coord;
     }
    default:
     break;
    }
    Traversal_x++;
   }
  }

  // 检查黑棋是否有连够2个的情况(一面被堵，一面开放)
  Traversal_x = Traversal_y = 0;
  while (Traversal_x != 22 || Traversal_y != 22) {
   if ((target_coord = Traversal_chessboard(2, 1))[0] != -1) {
    // 取得这串黑棋子围堵的情况
    Intercept_status = Check_Intercept(target_coord[0],
      target_coord[1], target_coord[2]);
    switch (Intercept_status) {
    case 1: // 首棋子被堵
     if (Liansan(target_coord[0], target_coord[1],
       target_coord[2])) {
      coord[0] = target_coord[0];
      coord[1] = target_coord[1];
      return coord;
     }
    default:
     break;
    }
    Traversal_x++;
   }
  }

  // 已经没棋可下了
  coord = irregular();
  return coord;
 }

 // 遍历棋盘
 int[] Traversal_chessboard(int series, int player) {
  int[] target_coord = new int[3]; // 前两位表示首棋子坐标，末位表示连续方向。
  target_coord[0] = target_coord[1] = -1;
  for (; Traversal_y < 23; Traversal_y++) {
   for (; Traversal_x < 23; Traversal_x++) {
    if (chessboard[Traversal_x][Traversal_y] == player) {
     if (series <= 1) {
      target_coord[0] = Traversal_x;
      target_coord[1] = Traversal_y;
      return target_coord;
     }
     if ((target_coord[2] = judgement(Traversal_x, Traversal_y,
       series)) != -1) { // 以某一棋子为中心检查是否连够变量series个
      target_coord[0] = Traversal_x;
      target_coord[1] = Traversal_y;
      return target_coord;
     }
    }
    if (Traversal_x == 22 && Traversal_y == 22)
     return target_coord;
   }
   Traversal_x = 0;
  }
  return target_coord;
 }

 // 传入棋子的坐标和需要检查的长度,返回值若不为-1则表明返回的是连续方向。
 int judgement(int chess_x, int chess_y, int series) {
  boolean status = false;
  int player = chessboard[chess_x][chess_y];
  int x_t = 0, y_t = 0;

  // 分别检查八个方向
  for (int direct = 0; direct < 8;) {
   switch (direct) {
   case 0:
    x_t++;
    break;
   case 1:
    x_t++;
    y_t++;
    break;
   case 2:
    y_t++;
    break;
   case 3:
    x_t--;
    y_t++;
    break;
   case 4:
    x_t--;
    break;
   case 5:
    y_t--;
    x_t--;
    break;
   case 6:
    y_t--;
    break;
   case 7:
    y_t--;
    x_t++;
    break;
   }

   try {
    if (chessboard[chess_x + x_t][chess_y + y_t] != player) {
     direct++;
     y_t = x_t = 0;
     status = false;
     continue;
    } else {
     status = true;
    }
   } catch (Exception e) {
    direct++;
    y_t = x_t = 0;
    status = false;
    continue;
   }
   if (Math.abs(x_t) == (series - 1) || Math.abs(y_t) == (series - 1)) {
    if (status)
     return direct;
    y_t = x_t = 0;
    direct++;
   }
  }
  return -1;
 }

 // 检查这串棋子是否被堵上了,传入首棋子的坐标和检查方向。
 // 返回值：0:两边都没堵上.1,只有首棋子堵上了,2:只有尾棋子堵上了。3：两边全堵上了。
 int Check_Intercept(int x, int y, int direct) {
  int player = chessboard[x][y]; // 获取当期棋子的玩家
  int _x = 0, _y = 0;
  boolean header = false, tail = false;

  switch (direct) {
  case 0:
   _x = -1;
   break;
  case 1:
   _x = -1;
   _y = -1;
   break;
  case 2:
   _y = -1;
   break;
  case 3:
   _x = 1;
   _y = -1;
   break;
  case 4:
   _x = 1;
   break;
  case 5:
   _x = 1;
   _y = 1;
   break;
  case 6:
   _y = 1;
   break;
  case 7:
   _y = 1;
   _x = -1;
   break;
  }
  try {
   if (chessboard[x + _x][y + _y] != 0) {
    header = false;
   } else {
    header = true;
   }
  } catch (Exception e) {
   // TODO: handle exception
   header = false;
  }
  while (true) {
   switch (direct) {
   case 0:
    _x++;
    break;
   case 1:
    _x++;
    _y++;
    break;
   case 2:
    _y++;
    break;
   case 3:
    _y++;
    _x--;
    break;
   case 4:
    _x--;
    break;
   case 5:
    _x--;
    _y--;
    break;
   case 6:
    _y--;
    break;
   case 7:
    _x++;
    _y--;
    break;
   }
   try {
    if (chessboard[x + _x][y + _y] == player)
     continue;
    else if (chessboard[x + _x][y + _y] == 0) {
     tail = true;
     break;
    } else {
     tail = false;
     break;
    }
   } catch (Exception e) {
    // TODO: handle exception
    tail = false;
    break;
   }
  }
  if (header && tail)
   return 0;
  else if (header)
   return 2;
  else if (tail)
   return 1;
  else {
   return 3;
  }
 }

 // 围堵尾部，传入首部坐标和方向，返回落子坐标
 int[] block_tail(int head_x, int head_y, int direct) {
  int[] coord = new int[2];
  int _x = 0, _y = 0;
  while (true) {
   switch (direct) {
   case 0:
    _x++;
    break;
   case 1:
    _x++;
    _y++;
    break;
   case 2:
    _y++;
    break;
   case 3:
    _y++;
    _x--;
    break;
   case 4:
    _x--;
    break;
   case 5:
    _y--;
    _x--;
    break;
   case 6:
    _y--;
    break;
   case 7:
    _x++;
    _y--;
    break;
   }
   try {
    if (chessboard[head_x + _x][head_y + _y] == 0) {
     coord[0] = head_x + _x;
     coord[1] = head_y + _y;
     return coord;
    }
   } catch (Exception e) {
    coord[0] = coord[1] = -1;
    break;
   }
  }
  return coord;
 }

 // 围堵头部，传入首部坐标和方向，返回落子坐标
 int[] block_header(int head_x, int head_y, int direct) {
  int[] coord = new int[2];
  int _x = 0, _y = 0;
  switch (direct) {
  case 0:
   _x--;
   break;
  case 1:
   _x--;
   _y--;
   break;
  case 2:
   _y--;
   break;
  case 3:
   _y--;
   _x++;
   break;
  case 4:
   _x++;
   break;
  case 5:
   _y++;
   _x++;
   break;
  case 6:
   _y++;
   break;
  case 7:
   _x--;
   _y++;
   break;
  }
  coord[0] = head_x + _x;
  coord[1] = head_y + _y;
  return coord;
 }

 int[] Best_Position(int x, int y) {
  // 方向1：左上-右下；方向2：右上-左下；方向3：上下；方向4：左右。
  int[] status = new int[4];
  try {
   int _x = 0, _y = 0;
   for (_x = 1, _y = 1; _x <= 4; _x++, _y++) {
    if (chessboard[x + _x][y + _y] == 0)
     ;
    else {
     status[0] = _x - 1;
     break;
    }
    if (_x == 4) {
     status[0] = _x;
     break;
    }
   }
   for (_x = -1, _y = -1; _x >= -4; _x--, _y--) {
    if (chessboard[x + _x][y + _y] == 0)
     ;
    else {
     status[0] += Math.abs(_x + 1);
     break;
    }
    if (Math.abs(_x) == 4) {
     status[0] += 4;
     break;
    }
   }

   for (_x = -1, _y = 1; _y <= 4; _x--, _y++) {
    if (chessboard[x + _x][y + _y] == 0)
     ;
    else {
     status[1] = _y - 1;
     break;
    }
    if (_y == 4) {
     status[1] = _y;
     break;
    }
   }
   for (_x = 1, _y = -1; _x <= 4; _x++, _y--) {
    if (chessboard[x + _x][y + _y] == 0)
     ;
    else {
     status[1] += Math.abs(_x - 1);
     break;
    }
    if (Math.abs(_x) == 4) {
     status[1] += 4;
     break;
    }
   }

   for (_y = 1, _x = 0; _y <= 4; _y++) {
    if (chessboard[x + _x][y + _y] == 0)
     ;
    else {
     status[2] = _y - 1;
     break;
    }
    if (_y == 4) {
     status[2] = _y;
     break;
    }
   }
   for (_x = 0, _y = -1; _y >= -4; _y--) {
    if (chessboard[x + _x][y + _y] == 0)
     ;
    else {
     status[2] += Math.abs(_y + 1);
     break;
    }
    if (Math.abs(_y) == 4) {
     status[2] += 4;
     break;
    }
   }

   for (_y = 0, _x = 1; _x <= 4; _x++) {
    if (chessboard[x + _x][y + _y] == 0)
     ;
    else {
     status[3] = _x - 1;
     break;
    }
    if (_x == 4) {
     status[3] = _x;
     break;
    }
   }
   for (_x = -1, _y = 0; _x >= -4; _x--) {
    if (chessboard[x + _x][y + _y] == 0)
     ;
    else {
     status[3] += Math.abs(_x + 1);
     break;
    }
    if (Math.abs(_x) == 4) {
     status[3] += 4;
     break;
    }
   }
   return status;
  } catch (Exception e) {
   // TODO: handle exception
   status[0] = status[1] = status[2] = status[3] = -1;
   return status;
  }
 }

 int sangeyi(int x, int y, int direct, int Intercept) {
  int player = chessboard[x][y];
  boolean loop = false;
  if (Intercept == 0) {
   Intercept = 1;
   loop = true;
  }

  int _x = 0, _y = 0;
  if (Intercept == 1) { // 首棋子被堵，尾棋子没有被堵
   switch (direct) {
   case 0:
    _x = 4;
    break;
   case 1:
    _x = _y = 4;
    break;
   case 2:
    _y = 4;
    break;
   case 3:
    _x = -4;
    _y = 4;
    break;
   case 4:
    _x = -4;
    break;
   case 5:
    _x = _y = -4;
    break;
   case 6:
    _y = -4;
    break;
   case 7:
    _x = 4;
    _y = -4;
    break;
   }
   try {
    if (chessboard[x + _x][y + _y] == player) {
     return Intercept;
    } else {
     if (loop) {
      Intercept = 2;
      loop = false;
     }
    }

   } catch (Exception e) {
    // TODO: handle exception
    if (loop) {
     Intercept = 2;
     loop = false;
    }
   }

   if (Intercept == 2) { // 尾棋子被堵，首棋子没有被堵
    switch (direct) {
    case 0:
     _x = -2;
     break;
    case 1:
     _x = _y = -2;
     break;
    case 2:
     _y = -2;
     break;
    case 3:
     _x = 2;
     _y = -2;
     break;
    case 4:
     _x = 2;
     break;
    case 5:
     _x = _y = 2;
     break;
    case 6:
     _y = 2;
     break;
    case 7:
     _x = -2;
     _y = 2;
     break;
    }
    try {
     if (chessboard[x + _x][y + _y] == player) {
      return Intercept;
     } else {
      return -1;
     }

    } catch (Exception e) {
     // TODO: handle exception
     return -1;
    }
   }
   if (loop) {
    Intercept = 2;
    if (sangeyi(x, y, direct, Intercept) != -1)
     return Intercept;
   }
   return -1;
  }
  return -1;
 }

 int ergeyilianer(int x, int y, int direct, int Intercept) {
  int player = chessboard[x][y];
  boolean loop = false;
  if (Intercept == 0) {
   Intercept = 1;
   loop = true;
  }

  int _x = 0, _y = 0;
  if (Intercept == 1) { // 首棋子被堵，尾棋子没有被堵
   switch (direct) {
   case 0:
    _x = 3;
    break;
   case 1:
    _x = _y = 3;
    break;
   case 2:
    _y = 3;
    break;
   case 3:
    _x = -3;
    _y = 3;
    break;
   case 4:
    _x = -3;
    break;
   case 5:
    _x = _y = -3;
    break;
   case 6:
    _y = -3;
    break;
   case 7:
    _x = 3;
    _y = -3;
    break;
   }
   try {
    if (chessboard[x + _x][y + _y] == player) {
     if (_x == 3)
      _x = 4;
     if (_x == -3)
      _x = -4;
     if (_y == 3)
      _y = 4;
     if (_y == -3)
      _y = -4;
     if (chessboard[x + _x][y + _y] == player) {
      return Intercept;
     } else {
      if (loop) {
       Intercept = 2;
       loop = false;
      }
     }
    } else {
     if (loop) {
      Intercept = 2;
      loop = false;
     }
    }

   } catch (Exception e) {
    // TODO: handle exception
    if (loop) {
     Intercept = 2;
     loop = false;
    }
   }
  }

  if (Intercept == 2) { // 首棋子被堵，尾棋子没有被堵
   switch (direct) {
   case 0:
    _x = -2;
    break;
   case 1:
    _x = _y = -2;
    break;
   case 2:
    _y = -2;
    break;
   case 3:
    _x = 2;
    _y = -2;
    break;
   case 4:
    _x = 2;
    break;
   case 5:
    _x = _y = 2;
    break;
   case 6:
    _y = 2;
    break;
   case 7:
    _x = -2;
    _y = 2;
    break;
   }
   try {
    if (chessboard[x + _x][y + _y] == player) {
     if (_x == 2)
      _x = 3;
     if (_x == -2)
      _x = -3;
     if (_y == 2)
      _y = 3;
     if (_y == -2)
      _y = -3;
     if (chessboard[x + _x][y + _y] == player) {
      return Intercept;
     } else {
      return -1;
     }
    } else {
     return -1;
    }

   } catch (Exception e) {
    // TODO: handle exception
    return -1;
   }
  }
  if (loop) {
   Intercept = 2;
   if (ergeyilianer(x, y, direct, Intercept) != -1)
    return Intercept;
  }
  return -1;
 }

 int ergeyilianyi(int x, int y, int direct, int Intercept) {
  int player = chessboard[x][y];
  int opponent = 0;
  if (player == 1)
   opponent = 2;
  else {
   opponent = 1;
  }
  boolean loop = false;
  if (Intercept == 0) {
   Intercept = 1;
   loop = true;
  }

  int _x = 0, _y = 0;
  if (Intercept == 1) { // 首棋子被堵
   switch (direct) {
   case 0:
    _x = 3;
    break;
   case 1:
    _x = _y = 3;
    break;
   case 2:
    _y = 3;
    break;
   case 3:
    _x = -3;
    _y = 3;
    break;
   case 4:
    _x = -3;
    break;
   case 5:
    _x = _y = -3;
    break;
   case 6:
    _y = -3;
    break;
   case 7:
    _x = 3;
    _y = -3;
    break;
   }
   try {
    if (chessboard[x + _x][y + _y] == player) {
     switch (direct) {
     case 0:
      _x = 4;
      break;
     case 1:
      _x = _y = 4;
      break;
     case 2:
      _y = 4;
      break;
     case 3:
      _x = -4;
      _y = 4;
      break;
     case 4:
      _x = -4;
      break;
     case 5:
      _x = _y = -4;
      break;
     case 6:
      _y = -4;
      break;
     case 7:
      _x = 4;
      _y = -4;
      break;
     }
     if (chessboard[x + _x][y + _y] != opponent)
      return Intercept;
     else {
      if (loop) {
       Intercept = 2;
       loop = false;
      }
     }
    } else {
     if (loop) {
      Intercept = 2;
      loop = false;
     }
    }

   } catch (Exception e) {
    // TODO: handle exception
    if (loop) {
     Intercept = 2;
     loop = false;
    }
   }
  }

  if (Intercept == 2) { // 尾棋子被堵，首棋子没有被堵
   switch (direct) {
   case 0:
    _x = -2;
    break;
   case 1:
    _x = _y = -2;
    break;
   case 2:
    _y = -2;
    break;
   case 3:
    _x = 2;
    _y = -2;
    break;
   case 4:
    _x = 2;
    break;
   case 5:
    _x = _y = 2;
    break;
   case 6:
    _y = 2;
    break;
   case 7:
    _x = -2;
    _y = 2;
    break;
   }
   try {
    if (chessboard[x + _x][y + _y] == player) {
     switch (direct) {
     case 0:
      _x = -3;
      break;
     case 1:
      _x = _y = -3;
      break;
     case 2:
      _y = -3;
      break;
     case 3:
      _x = 3;
      _y = -3;
      break;
     case 4:
      _x = 3;
      break;
     case 5:
      _x = _y = 3;
      break;
     case 6:
      _y = 3;
      break;
     case 7:
      _x = -3;
      _y = 3;
      break;
     }
     if (chessboard[x + _x][y + _y] != opponent)
      return Intercept;
     else {
      return -1;
     }
    } else {
     return -1;
    }

   } catch (Exception e) {
    // TODO: handle exception
    return -1;
   }
  }
  if (loop) {
   Intercept = 2;
   if (ergeyilianyi(x, y, direct, Intercept) != -1)
    return Intercept;
  }
  return -1;
 }

 boolean Liansi(int x, int y, int direct, int Intercept) {
  int player = chessboard[x][y];
  int _x = 0, _y = 0;
  if (Intercept == 1) {
   switch (direct) {
   case 0:
    _x = 4;
    break;
   case 1:
    _x = 4;
    _y = 4;
    break;
   case 2:
    _y = 4;
    break;
   case 3:
    _x = -4;
    _y = 4;
    break;
   case 4:
    _x = -4;
    break;
   case 5:
    _x = -4;
    _y = -4;
    break;
   case 6:
    _y = -4;
    break;
   case 7:
    _x = 4;
    _y = -4;
    break;
   }
   try {
    if (chessboard[x + _x][y + _y] == 0
      || chessboard[x + _x][y + _y] == player) {
     return true;
    } else {
     return false;
    }
   } catch (Exception e) {
    // TODO: handle exception
    return false;
   }
  }

  if (Intercept == 2) {
   switch (direct) {
   case 0:
    _x = -2;
    break;
   case 1:
    _x = -2;
    _y = -2;
    break;
   case 2:
    _y = -2;
    break;
   case 3:
    _x = 2;
    _y = -2;
    break;
   case 4:
    _x = 2;
    break;
   case 5:
    _x = 2;
    _y = 2;
    break;
   case 6:
    _y = 2;
    break;
   case 7:
    _x = -2;
    _y = 2;
    break;
   default:
    break;
   }
   try {
    if (chessboard[x + _x][y + _y] == 0
      || chessboard[x + _x][y + _y] == player) {
     return true;
    } else {
     return false;
    }
   } catch (Exception e) {
    // TODO: handle exception
    return false;
   }
  }
  return false;
 }

 int[] Check_Cross(int player) {
  int opponent;
  if (player == 1)
   opponent = 2;
  else {
   opponent = 1;
  }
  int x = 0, y = 0;
  int[] coord_t = new int[2];
  coord_t[0] = coord_t[1] = -1;
  for (y = 0; y < 23; y++) {
   for (x = 0; x < 23; x++) {
    if (chessboard[x][y] == 0)
     try {
      if (chessboard[x + 1][y] == player) {
       if (chessboard[x + 2][y] != opponent)
        if (chessboard[x - 1][y] == player)
         if (chessboard[x - 2][y] != opponent) {
          try {
           if (chessboard[x][y + 1] == player)
            if (chessboard[x][y + 2] != opponent)
             if (chessboard[x][y - 1] == player)
              if (chessboard[x][y - 2] != opponent) {
               coord_t[0] = x;
               coord_t[1] = y;
               return coord_t;
              }
          } catch (Exception e) {
           // TODO: handle exception
          }
          try {
           if (chessboard[x + 1][y + 1] == player)
            if (chessboard[x + 2][y + 2] != opponent)
             if (chessboard[x - 1][y - 1] == player)
              if (chessboard[x - 2][y - 2] != opponent) {
               coord_t[0] = x;
               coord_t[1] = y;
               return coord_t;
              }
          } catch (Exception e) {
           // TODO: handle exception
          }
          try {
           if (chessboard[x + 1][y - 1] == player)
            if (chessboard[x + 2][y - 2] != opponent)
             if (chessboard[x - 1][y + 1] == player)
              if (chessboard[x - 2][y + 2] != opponent) {
               coord_t[0] = x;
               coord_t[1] = y;
               return coord_t;
              }
          } catch (Exception e) {
           // TODO: handle exception
          }
         }
      }
     } catch (Exception e) {
      // TODO: handle exception
      continue;
     }
    try {
     if (chessboard[x][y + 1] == player)
      if (chessboard[x][y + 2] != opponent)
       if (chessboard[x][y - 1] == player)
        if (chessboard[x][y - 2] != opponent) {
         try {
          if (chessboard[x + 1][y + 1] == player)
           if (chessboard[x + 2][y + 2] != opponent)
            if (chessboard[x - 1][y - 1] == player)
             if (chessboard[x - 2][y - 2] != opponent) {
              coord_t[0] = x;
              coord_t[1] = y;
              return coord_t;
             }
         } catch (Exception e) {
          // TODO: handle exception
         }
         try {
          if (chessboard[x - 1][y + 1] == player)
           if (chessboard[x - 2][y + 2] != opponent)
            if (chessboard[x + 1][y - 1] == player)
             if (chessboard[x + 2][y - 2] != opponent) {
              coord_t[0] = x;
              coord_t[1] = y;
              return coord_t;
             }
         } catch (Exception e) {
          // TODO: handle exception
         }
        }
    } catch (Exception e) {
     // TODO: handle exception
    }
    try {
     if (chessboard[x + 1][y + 1] == player) {
      if (chessboard[x + 2][y + 2] != opponent)
       if (chessboard[x - 1][y - 1] == player)
        if (chessboard[x - 2][y - 2] != opponent) {
         try {
          if (chessboard[x - 1][y + 1] == player)
           if (chessboard[x - 2][y + 2] != opponent)
            if (chessboard[x + 1][y - 1] == player)
             if (chessboard[x + 2][y - 2] != opponent) {
              coord_t[0] = x;
              coord_t[1] = y;
              return coord_t;
             }
         } catch (Exception e) {
          // TODO: handle exception
         }
        }
     }
    } catch (Exception e) {
     // TODO: handle exception
     continue;
    }
   }
  }
  return coord_t;
 }

 int[] yigeyi(int player) {
  int opponent;
  if (player == 1)
   opponent = 2;
  else {
   opponent = 1;
  }
  int x, y;
  int[] coord_t = new int[2];
  coord_t[0] = coord_t[1] = -1;

  for (y = 0; y < 23; y++) {
   for (x = 0; x < 23; x++) {
    if (chessboard[x][y] == 0)
     try {
      if (chessboard[x + 1][y] == player) {
       if (chessboard[x + 2][y] != opponent)
        if (chessboard[x - 1][y] == player)
         if (chessboard[x - 2][y] != opponent) {
          coord_t[0] = x;
          coord_t[1] = y;
          return coord_t;
         }
      }
      if (chessboard[x + 1][y + 1] == player) {
       if (chessboard[x + 2][y + 2] != opponent)
        if (chessboard[x - 1][y - 1] == player)
         if (chessboard[x - 2][y - 2] != opponent) {
          coord_t[0] = x;
          coord_t[1] = y;
          return coord_t;
         }
      }
      if (chessboard[x][y + 1] == player) {
       if (chessboard[x][y + 2] != opponent)
        if (chessboard[x][y - 1] == player)
         if (chessboard[x][y - 2] != opponent) {
          coord_t[0] = x;
          coord_t[1] = y;
          return coord_t;
         }
      }
      if (chessboard[x - 1][y + 1] == player) {
       if (chessboard[x - 2][y + 2] != opponent)
        if (chessboard[x + 1][y - 1] == player)
         if (chessboard[x + 2][y - 2] != opponent) {
          coord_t[0] = x;
          coord_t[1] = y;
          return coord_t;
         }
      }
     } catch (Exception e) {
      // TODO: handle exception
      continue;
     }
   }
  }

  return coord_t;
 }

 boolean Liansan(int x, int y, int direct) {
  int _x = 0, _y = 0;
  for (int i = 0; i < 5; i++) {
   switch (direct) {
   case 0:
    _x++;
    break;
   case 1:
    _x++;
    _y++;
    break;
   case 2:
    _y++;
    break;
   case 3:
    _x--;
    _y++;
    break;
   case 4:
    _x--;
    break;
   case 5:
    _x--;
    _y--;
   case 6:
    _y--;
    break;
   case 7:
    _y--;
    _x++;
    break;
   default:
    break;
   }
   try {
    if (chessboard[x + _x][y + _y] == 2) {
     return false;
    }
    if (Math.abs(_x) == 4) {
     return true;
    }
   } catch (Exception e) {
    // TODO: handle exception
    return false;
   }
  }
  return false;
 }

 int[] duanjiajiao(int player) {
  int x = 0, y = 0;
  int[] coord_t = new int[2];
  coord_t[0] = coord_t[1] = -1;
  int opponrnt = 0;
  if (player == 1)
   opponrnt = 2;
  else {
   opponrnt = 1;
  }
  for (y = 0; y < 23; y++) {
   for (x = 0; x < 23; x++) {
    if (chessboard[x][y] == 0) {
     try { // 试探0方向
      if (chessboard[x + 1][y] == player
        && chessboard[x + 2][y] == player)
       if (chessboard[x + 3][y] != opponrnt)
        if (chessboard[x - 1][y] != opponrnt)
         if (duanjiajiao_judgement(x, y, 0, player) != -1) {
          coord_t[0] = x;
          coord_t[1] = y;
          return coord_t;
         }
     } catch (Exception e) {
      // TODO: handle exception
     }

     try { // 试探1方向
      if (chessboard[x + 1][y + 1] == player
        && chessboard[x + 2][y + 2] == player)
       if (chessboard[x + 3][y + 3] != opponrnt)
        if (chessboard[x - 1][y - 1] != opponrnt)
         if (duanjiajiao_judgement(x, y, 1, player) != -1) {
          coord_t[0] = x;
          coord_t[1] = y;
          return coord_t;
         }
     } catch (Exception e) {
      // TODO: handle exception
     }

     try { // 试探2方向
      if (chessboard[x][y + 1] == player
        && chessboard[x][y + 2] == player)
       if (chessboard[x][y + 3] != opponrnt)
        if (chessboard[x][y - 1] != opponrnt)
         if (duanjiajiao_judgement(x, y, 2, player) != -1) {
          coord_t[0] = x;
          coord_t[1] = y;
          return coord_t;
         }
     } catch (Exception e) {
      // TODO: handle exception
     }

     try { // 试探3方向
      if (chessboard[x - 1][y + 1] == player
        && chessboard[x - 2][y + 2] == player)
       if (chessboard[x - 3][y + 3] != opponrnt)
        if (chessboard[x + 1][y - 1] != opponrnt)
         if (duanjiajiao_judgement(x, y, 3, player) != -1) {
          coord_t[0] = x;
          coord_t[1] = y;
          return coord_t;
         }
     } catch (Exception e) {
      // TODO: handle exception
     }

     try { // 试探4方向
      if (chessboard[x - 1][y] == player
        && chessboard[x - 2][y] == player)
       if (chessboard[x - 3][y] != opponrnt)
        if (chessboard[x + 1][y] != opponrnt)
         if (duanjiajiao_judgement(x, y, 4, player) != -1) {
          coord_t[0] = x;
          coord_t[1] = y;
          return coord_t;
         }
     } catch (Exception e) {
      // TODO: handle exception
     }

     try { // 试探5方向
      if (chessboard[x - 1][y - 1] == player
        && chessboard[x - 2][y - 2] == player)
       if (chessboard[x - 3][y - 3] != opponrnt)
        if (chessboard[x + 1][y + 1] != opponrnt)
         if (duanjiajiao_judgement(x, y, 5, player) != -1) {
          coord_t[0] = x;
          coord_t[1] = y;
          return coord_t;
         }
     } catch (Exception e) {
      // TODO: handle exception
     }

     try { // 试探6方向
      if (chessboard[x][y - 1] == player
        && chessboard[x][y - 2] == player)
       if (chessboard[x][y - 3] != opponrnt)
        if (chessboard[x][y + 1] != opponrnt)
         if (duanjiajiao_judgement(x, y, 6, player) != -1) {
          coord_t[0] = x;
          coord_t[1] = y;
          return coord_t;
         }
     } catch (Exception e) {
      // TODO: handle exception
     }

     try { // 试探7方向
      if (chessboard[x + 1][y - 1] == player
        && chessboard[x + 2][y - 2] == player)
       if (chessboard[x + 3][y - 3] != opponrnt)
        if (chessboard[x - 1][y + 1] != opponrnt)
         if (duanjiajiao_judgement(x, y, 7, player) != -1) {
          coord_t[0] = x;
          coord_t[1] = y;
          return coord_t;
         }
     } catch (Exception e) {
      // TODO: handle exception
     }
    }
   }
  }
  return coord_t;
 }

 int duanjiajiao_judgement(int x, int y, int mydirect, int player) {

  int direct;
  if (mydirect == 7)
   direct = 0;
  else {
   direct = mydirect + 1;
  }
  int _x = 0, _y = 0, i = 0, k = 0;
  int opponent = 0;
  if (player == 1)
   opponent = 2;
  else {
   opponent = 1;
  }
  for (i = 0, _x = _y = 0; i < 7; i++) {
   for (k = 0; k < 3; k++) {
    switch (direct) {
    case 0:
     _x++;
     break;
    case 1:
     _x++;
     _y++;
     break;
    case 2:
     _y++;
     break;
    case 3:
     _x--;
     _y++;
     break;
    case 4:
     _x--;
     break;
    case 5:
     _y--;
     _x--;
     break;
    case 6:
     _y--;
     break;
    case 7:
     _x++;
     _y--;
     break;
    }
    try {
     if (chessboard[x + _x][y + _y] != opponent
       && chessboard[x + _x][y + _y] != 0) {
      if (k == 1) {
       switch (direct) {
       case 0:
        _x++;
        break;
       case 1:
        _x++;
        _y++;
        break;
       case 2:
        _y++;
        break;
       case 3:
        _x--;
        _y++;
        break;
       case 4:
        _x--;
        break;
       case 5:
        _y--;
        _x--;
        break;
       case 6:
        _y--;
        break;
       case 7:
        _x++;
        _y--;
        break;
       }
       try {
        if (chessboard[x + _x][y + _y] != opponent) {
         return direct;
        } else {
         direct++;
         if (direct == 8) {
          direct = 0;
         }
         _x = _y = 0;
         break;
        }
       } catch (Exception e) {
        // TODO: handle exception
        direct++;
        if (direct == 8) {
         direct = 0;
        }
        _x = _y = 0;
        break;
       }

      }
     } else {
      direct++;
      if (direct == 8) {
       direct = 0;
      }
      _x = _y = 0;
      break;
     }
    } catch (Exception e) {
     // TODO: handle exception
     direct++;
     if (direct == 8) {
      direct = 0;
     }
     _x = _y = 0;
     break;
    }
   }
  }
  return -1;
 }

 int[] duanjiajiao_siliansan(int player) {
  int x = 0, y = 0;
  int jiajiao_direct = 0;
  int[] coord_t = new int[2];
  coord_t[0] = coord_t[1] = -1;
  int opponrnt = 0;
  if (player == 1)
   opponrnt = 2;
  else {
   opponrnt = 1;
  }
  for (y = 0; y < 23; y++) {
   for (x = 0; x < 23; x++) {
    if (chessboard[x][y] == 0) {
     try { // 试探0方向
      if (chessboard[x + 1][y] == player
        && chessboard[x + 2][y] == player)
       if (chessboard[x + 3][y] != opponrnt)
        if (chessboard[x - 1][y] != opponrnt)
         if ((jiajiao_direct = duanjiajiao_judgement(
           x, y, 0, player)) != -1)
          if (duanjiajiao_judgement_siliansan(x,
            y, 0, jiajiao_direct, player)) {
           coord_t[0] = x;
           coord_t[1] = y;
           return coord_t;
          }
     } catch (Exception e) {
      // TODO: handle exception
     }

     try { // 试探1方向
      if (chessboard[x + 1][y + 1] == player
        && chessboard[x + 2][y + 2] == player)
       if (chessboard[x + 3][y + 3] != opponrnt)
        if (chessboard[x - 1][y - 1] != opponrnt)
         if ((jiajiao_direct = duanjiajiao_judgement(
           x, y, 1, player)) != -1)
          if (duanjiajiao_judgement_siliansan(x,
            y, 1, jiajiao_direct, player)) {
           coord_t[0] = x;
           coord_t[1] = y;
           return coord_t;
          }
     } catch (Exception e) {
      // TODO: handle exception
     }

     try { // 试探2方向
      if (chessboard[x][y + 1] == player
        && chessboard[x][y + 2] == player)
       if (chessboard[x][y + 3] != opponrnt)
        if (chessboard[x][y - 1] != opponrnt)
         if ((jiajiao_direct = duanjiajiao_judgement(
           x, y, 2, player)) != -1)
          if (duanjiajiao_judgement_siliansan(x,
            y, 2, jiajiao_direct, player)) {
           coord_t[0] = x;
           coord_t[1] = y;
           return coord_t;
          }
     } catch (Exception e) {
      // TODO: handle exception
     }

     try { // 试探3方向
      if (chessboard[x - 1][y + 1] == player
        && chessboard[x - 2][y + 2] == player)
       if (chessboard[x - 3][y + 3] != opponrnt)
        if (chessboard[x + 1][y - 1] != opponrnt)
         if ((jiajiao_direct = duanjiajiao_judgement(
           x, y, 3, player)) != -1)
          if (duanjiajiao_judgement_siliansan(x,
            y, 3, jiajiao_direct, player)) {
           coord_t[0] = x;
           coord_t[1] = y;
           return coord_t;
          }
     } catch (Exception e) {
      // TODO: handle exception
     }

     try { // 试探4方向
      if (chessboard[x - 1][y] == player
        && chessboard[x - 2][y] == player)
       if (chessboard[x - 3][y] != opponrnt)
        if (chessboard[x + 1][y] != opponrnt)
         if ((jiajiao_direct = duanjiajiao_judgement(
           x, y, 4, player)) != -1)
          if (duanjiajiao_judgement_siliansan(x,
            y, 4, jiajiao_direct, player)) {
           coord_t[0] = x;
           coord_t[1] = y;
           return coord_t;
          }
     } catch (Exception e) {
      // TODO: handle exception
     }

     try { // 试探5方向
      if (chessboard[x - 1][y - 1] == player
        && chessboard[x - 2][y - 2] == player)
       if (chessboard[x - 3][y - 3] != opponrnt)
        if (chessboard[x + 1][y + 1] != opponrnt)
         if ((jiajiao_direct = duanjiajiao_judgement(
           x, y, 5, player)) != -1)
          if (duanjiajiao_judgement_siliansan(x,
            y, 5, jiajiao_direct, player)) {
           coord_t[0] = x;
           coord_t[1] = y;
           return coord_t;
          }
     } catch (Exception e) {
      // TODO: handle exception
     }

     try { // 试探6方向
      if (chessboard[x][y - 1] == player
        && chessboard[x][y - 2] == player)
       if (chessboard[x][y - 3] != opponrnt)
        if (chessboard[x][y + 1] != opponrnt)
         if ((jiajiao_direct = duanjiajiao_judgement(
           x, y, 6, player)) != -1)
          if (duanjiajiao_judgement_siliansan(x,
            y, 6, jiajiao_direct, player)) {
           coord_t[0] = x;
           coord_t[1] = y;
           return coord_t;
          }
     } catch (Exception e) {
      // TODO: handle exception
     }

     try { // 试探7方向
      if (chessboard[x + 1][y - 1] == player
        && chessboard[x + 2][y - 2] == player)
       if (chessboard[x + 3][y - 3] != opponrnt)
        if (chessboard[x - 1][y + 1] != opponrnt)
         if ((jiajiao_direct = duanjiajiao_judgement(
           x, y, 7, player)) != -1)
          if (duanjiajiao_judgement_siliansan(x,
            y, 7, jiajiao_direct, player)) {
           coord_t[0] = x;
           coord_t[1] = y;
           return coord_t;
          }
     } catch (Exception e) {
      // TODO: handle exception
     }
    }
   }
  }
  return coord_t;
 }

 boolean duanjiajiao_judgement_siliansan(int x, int y, int direct_1,
   int direct_2, int player) {
  int _x = 0, _y = 0;
  boolean playid_1 = false;
  boolean playid_2 = false;
  switch (direct_1) {
  case 0:
   _x = 4;
   break;
  case 1:
   _x = 4;
   _y = 4;
   break;
  case 2:
   _y = 4;
   break;
  case 3:
   _x = -4;
   _y = 4;
   break;
  case 4:
   _x = -4;
   break;
  case 5:
   _x = -4;
   _y = -4;
   break;
  case 6:
   _y = -4;
   break;
  case 7:
   _y = -4;
   _x = 4;
   break;
  default:
   break;
  }
  try {
   if (chessboard[x + _x][y + _y] == player) {
    playid_1 = true;
   } else {
    playid_1 = false;
   }
  } catch (Exception e) {
   // TODO: handle exception
   playid_1 = false;
  }
  switch (direct_2) {
  case 0:
   _x = 4;
   break;
  case 1:
   _x = 4;
   _y = 4;
   break;
  case 2:
   _y = 4;
   break;
  case 3:
   _x = -4;
   _y = 4;
   break;
  case 4:
   _x = -4;
   break;
  case 5:
   _x = -4;
   _y = -4;
   break;
  case 6:
   _y = -4;
   break;
  case 7:
   _y = -4;
   _x = 4;
   break;
  default:
   break;
  }
  try {
   if (chessboard[x + _x][y + _y] == player) {
    playid_2 = true;
   } else {
    playid_2 = false;
   }
  } catch (Exception e) {
   // TODO: handle exception
   playid_2 = false;
  }
  if (playid_1 || playid_2)
   return true;
  return false;
 }

 int[] T_pattern(int player) {
  int[] coord_t = new int[2];
  coord_t[0] = coord_t[1] = -1;
  int opponent;
  if (player == 1)
   opponent = 2;
  else {
   opponent = 2;
  }
  for (int y = 0; y < 23; y++) {
   for (int x = 0; x < 23; x++) {
    if (chessboard[x][y] == 0) {
     try { // 试探1方向
      if (chessboard[x + 1][y] == player)
       if (chessboard[x + 2][y] != opponent)
        if (chessboard[x - 1][y] == player)
         if (chessboard[x - 2][y] != opponent)
          if (T_pattern_judgement(x, y, player, 1)) {
           coord_t[0] = x;
           coord_t[1] = y;
           return coord_t;
          }
     } catch (Exception e) {
      // TODO: handle exception
     }
     try { // 试探2方向
      if (chessboard[x + 1][y + 1] == player)
       if (chessboard[x + 2][y + 2] != opponent)
        if (chessboard[x - 1][y - 1] == player)
         if (chessboard[x - 2][y - 2] != opponent)
          if (T_pattern_judgement(x, y, player, 2)) {
           coord_t[0] = x;
           coord_t[1] = y;
           return coord_t;
          }
     } catch (Exception e) {
      // TODO: handle exception
     }
     try { // 试探3方向
      if (chessboard[x][y + 1] == player)
       if (chessboard[x][y + 2] != opponent)
        if (chessboard[x][y - 1] == player)
         if (chessboard[x][y - 2] != opponent)
          if (T_pattern_judgement(x, y, player, 3)) {
           coord_t[0] = x;
           coord_t[1] = y;
           return coord_t;
          }
     } catch (Exception e) {
      // TODO: handle exception
     }
     try { // 试探4方向
      if (chessboard[x - 1][y + 1] == player)
       if (chessboard[x - 2][y + 2] != opponent)
        if (chessboard[x + 1][y - 1] == player)
         if (chessboard[x + 2][y - 2] != opponent)
          if (T_pattern_judgement(x, y, player, 4)) {
           coord_t[0] = x;
           coord_t[1] = y;
           return coord_t;
          }
     } catch (Exception e) {
      // TODO: handle exception
     }
    }
   }
  }
  return coord_t;
 }

 boolean T_pattern_judgement(int x, int y, int player, int direct) {
  int _x = 0, _y = 0;
  int opponent = 0;
  int skip_direction;
  int num = 0;
  if (player == 1)
   opponent = 2;
  else {
   opponent = 1;
  }
  switch (direct) {
  case 1:
   skip_direction = 4;
   break;
  case 2:
   skip_direction = 5;
   break;
  case 3:
   skip_direction = 6;
   break;
  case 4:
   skip_direction = 7;
   break;
  default:
   return false;
  }
  for (int i = 0; i < 7;) {
   if (direct == skip_direction) {
    direct++;
    i++;
    _x = _y = 0;
    continue;
   }
   if (direct == 8) {
    direct = 0;
   }
   switch (direct) {
   case 0:
    _x++;
    break;
   case 1:
    _x++;
    _y++;
    break;
   case 2:
    _y++;
    break;
   case 3:
    _y++;
    _x--;
    break;
   case 4:
    _x--;
    break;
   case 5:
    _x--;
    _y--;
    break;
   case 6:
    _y--;
    break;
   case 7:
    _y--;
    _x++;
    break;
   }
   try {
    if (num < 2) {
     if (chessboard[x + _x][y + _y] == player) {
      num++;
     } else {
      direct++;
      i++;
      _x = _y = 0;
     }
    } else {
     if (chessboard[x + _x][y + _y] != opponent) {
      if (_x == 3)
       _x = -1;
      if (_x == -3)
       _x = 1;
      if (_y == 3)
       _y = -1;
      if (_y == -3)
       _y = 1;
      if (chessboard[x + _x][y + _y] != opponent) {
       return true;
      } else {
       direct++;
       i++;
       _x = _y = 0;
      }

     } else {
      if (_x == 3)
       _x = -1;
      if (_x == -3)
       _x = 1;
      if (_y == 3)
       _y = -1;
      if (_y == -3)
       _y = 1;
      if (chessboard[x + _x][y + _y] != opponent) {
       if (_x == -1)
        _x = -2;
       if (_x == 1)
        _x = 2;
       if (_y == 1)
        _y = 2;
       if (_y == -1)
        _y = 2;
       if (chessboard[x + _x][y + _y] != opponent)
        return true;
       else {
        direct++;
        i++;
        _x = _y = 0;
       }
      } else {
       direct++;
       i++;
       _x = _y = 0;
      }
     }
    }

   } catch (Exception e) {
    // TODO: handle exception
    direct++;
    i++;
    _x = _y = 0;
   }
  }
  return false;
 }

 int[] irregular() {
  int x, y;
  int[] coord_t = new int[2];
  for (y = 0; y < 23; y++) {
   for (x = 0; x < 23; x++) {
    if (chessboard[x][y] == 0) {
     coord_t[0] = x;
     coord_t[1] = y;
     return coord_t;
    }
   }
  }
  return coord_t;
 }
}

打赏

有符号大整数计算器

C语言编程来使网卡工作在混杂模式

You may also like

Java的反射机...

Leave a Comment Cancel Reply