开通博客赚积分
发布资源赚积分
分类

源码开发语言/平台
当前位置：首页 > 源码/资料 > 游戏 > 棋牌游戏 > 查看源码
BoardPanel.java
资源名称：java五子棋.zip　[点击查看]
上传用户：ptnike
上传日期：2007-06-15
资源大小：61k
文件大小：26k
源码类别：

棋牌游戏

开发平台：

Java

BoardPanel.java：源码内容
  1. import java.awt.*;
  2. import java.awt.event.*;
  3. import java.util.Arrays;
  4. import javax.swing.*;
  5. import java.io.*;
  7. /**
  8.  * <p>Title: chesser</p>
  9.  * <p>Description: wu zi qi game</p>
  10.  * <p>Copyright: Copyright (c) 2003</p>
  11.  * <p>Company: e-top</p>
  12.  * @author cylix
  13.  * @version 1.0
  14.  */
  16. public class BoardPanel extends JPanel{
  17.     private  static Image white = null;
  18.     private  static Image black = null;
  19.     private static int xp;           // position of x to put chessman
  20.     private static int yp;           // position of y to put chessman
  21.     private Cursor handCursor;
  22.     private Cursor defaultCursor;
  23.     protected static int board[][];    // record of each position black or white
  24.     private int color=1;             // record player's chess color 1=black 2=white    
  25.     
  26.     int STEPCOUNTER=0;
  27.     int BASE=5;
  28.     int DEEPTH=3;
  29.     int MINDEEPTH=3;
  30.     int MAX1=5;
  31.     long INVALID=9000000;
  32.     int chessBoard[][];    
  34.     // draw the line number with x/y direction
  35.     String line = "a        b        c       d        e        f        g        h         i         j        k         l        m       n        o";
  36.     char [] rowNum1 = {'1','2','3','4','5','6','7','8','9'};
  37.     char [] rowNum2={'1','0','1','1','1','2','1','3','1','4','1','5'};
  39.      public BoardPanel(){
  40. //        this.wzq=wz;
  41.         try {
  42.             handCursor=new Cursor(12);
  43.             defaultCursor = new Cursor(0);
  44.             board = new int[15][15];
  45. //            black = wzq.black;
  46. //            white = wzq.white;
  48.           //  this.setBackground(Color.yellow);
  49.             //this.setForeground(Color.BLUE);
  50.           //  this.setBorder(BorderFactory.createLoweredBevelBorder());
  52.             jbInit();
  53.         }
  54.         catch(Exception e) {
  55.             e.printStackTrace();
  56.         }
  57.     }
  59.     public void paint(Graphics gc){
  60.         super.paint(gc);
  61.         //this.setBackground(Color.gray);
  62.         //this.invalidate();
  63.         gc.setColor(Color.blue);
  64.         //gc.setColor(new Color(255, 255, 240));
  65.         // draw number of X direction
  66.         gc.drawString(line,25,15);
  67.         // draw number of Y direction
  68.         for(int i=0;i<9;i++){
  69.             gc.drawChars(rowNum1,i,1,10,35+i*30);
  70.         }
  71.         for(int i=9,j=0;i<15;i++,j+=2){
  72.             gc.drawChars(rowNum2,j,2,10,35+i*30);
  73.         }
  74.         // draw the chess board
  75.         for (int i = 0; i < 15; i++) {
  76.             gc.drawLine(30, 30 + i * 30, 450, 30 + i * 30); //draw raw
  77.             gc.drawLine(30 + i * 30, 30, 30 + i * 30, 450); //draw column
  78.         }
  79.         gc.drawLine(25, 25, 455, 25);
  80.         gc.drawLine(25, 25, 25, 455);
  81.         gc.drawLine(25, 455, 455, 455);
  82.         gc.drawLine(455, 25, 455, 455);
  84.         //when window repaint to replay the original status of board
  85.         for(int i=0;i<15;i++){
  86.             for (int j = 0; j < 15; j++) {
  87.                 xp=16+i*30;
  88.                 yp=16+j*30;
  89.                 if (board[i][j] == 1){
  90.                     gc.setColor(Color.black);
  91.                     gc.fillOval(xp,yp,28,28);
  92.                     //gc.drawImage(black, 16 + i * 30, 16 + j * 30, this);
  93.                 }
  94.                 if (board[i][j] == 2){
  95.                     gc.setColor(Color.white);
  96.                     gc.fillOval(xp,yp,28,28);
  97.                     //gc.drawImage(white, 16 + i * 30, 16 + j * 30, this);
  98.                 }
  99.             }
  100.         }
  101.     }
  103.     private void jbInit() throws Exception {
  104.         this.addMouseMotionListener(new ChessWZQ_this_mouseMotionAdapter(this));
  105.         this.addMouseListener(new ChessWZQ_this_mouseAdapter(this));
  106.     }
  107.     public int getColor(){
  108.         return color;
  109.     }
  110.     public void setColor(int cr){
  111.         color=cr;
  112.     }
  113.     /**
  114.      * clear board when updated
  115.      */
  116.     public void clearBoard(){
  117.         for(int i=0;i<15;i++){
  118.             for(int j=0;j<15;j++)
  119.                 board[i][j]=0;
  120.         }
  121.         repaint();
  122.     }
  124.     void this_mouseClicked(MouseEvent e) {
  125.         int x=0,y=0;
  126.         if(color==0){
  127.             return;
  128.         }
  129.         x=e.getX();
  130.         y=e.getY();
  131.         if(x>20&&x<460&&y>20&&y<460&&(x%30<10||x%30>20)&&(y%30<10||y%30>20)){
  132.             if(ChessWZQ.beginFlag==false){
  133.                 ChessWZQ.label6.setText("You may not do that");
  134.                 return;
  135.             }
  136.             xp = x / 30 * 30 - 14;
  137.             yp = y / 30 * 30 - 14;
  138.             if (x % 30 > 20) {
  139.                 xp += 30;
  140.             }
  141.             if (y % 30 > 20) {
  142.                 yp += 30;
  143.             }
  144.             x=xp/30;y=yp/30;
  145.             if(board[x][y]!=0){
  146.                 return;
  147.             }
  148.             // client 's board
  149.             board[xp / 30][yp / 30] = color;
  151.             Graphics g=this.getGraphics();
  152.             if(color==1){//black
  153.                 g.setColor(Color.black);
  154.             }
  155.             if(color==2){//white
  156.                 g.setColor(Color.white);
  157.             }
  158.             g.fillOval(xp, yp, 28, 28);
  160.             ChessWZQ.beginFlag=false;
  162.             // setting coordinate (x,y)
  163. //            x=xp/30;y=yp/30;
  164.             if(ChessWZQ.ptocFlag==false){
  165.                 Message msg = new Message();
  166.                 msg.color = color;
  167.                 msg.coordinateX = x;
  168.                 msg.coordinateY = y;
  169.                 msg.type = 2; //press chessman
  171.                 //send message to server
  172.                 try {
  173.                     ChessWZQ.out.writeObject(msg);
  174.                 }
  175.                 catch (IOException ee) {
  176.                     ee.printStackTrace();
  177.                 }
  178.             }
  179.            char cc = (char)(x+65);
  180.            ChessWZQ.label6.setText("put on ( "+cc+" , "+(y+1)+" )");
  181.            /// computer to put
  182.            if(ChessWZQ.ptocFlag==true){
  183.                if(judge(xp/30,yp/30,color)==true){
  184.                    //System.out.println("people win");
  185.                    Message ms = new Message();
  186.                    ms.type=20;
  187.                    strToCharArray("You",ms.msg);
  188.                    try{
  189.                        ChessWZQ.out.writeObject(ms);
  190.                    }catch(IOException er){
  191.                        er.printStackTrace();
  192.                    }
  193.                }
  194.                ChessWZQ.beginFlag = false;
  195.                int position = 0, bestX = 0, bestY = 0;
  196.                Analyse aa = new Analyse(BoardPanel.board);
  197.                position = aa.computerDo();
  198.                bestY = position % 100 - 1;
  199.                bestX = position / 100 - 1;
  200.                updateBoard(bestX, bestY);
  201.                drawChess(bestX, bestY);
  202.                ChessWZQ.beginFlag = true; //for people to put
  203.                cc=(char)(bestX+65);
  204.                ChessWZQ.label6.setText("put on ( "+cc+" , "+(bestY+1)+" )");
  205.                if(judge(bestX,bestY,ChessWZQ.cColor)==true){
  206.                    //System.out.println("computer win");
  207.                    Message msg = new Message();
  208.                    msg.type=20;
  209.                    strToCharArray("Computer",msg.msg);
  210.                    try{
  211.                        ChessWZQ.out.writeObject(msg);
  212.                    }catch(IOException err){
  213.                        err.printStackTrace();
  214.                    }
  215.                }
  216.            }
  217.         }
  218.     }
  219.     // convert string to array which is end with ''
  220.     public void strToCharArray(String str,char [] arr){
  221.         int i;
  222.         for(i=0;i<str.length()&&i<49;i++){
  223.             arr[i] = str.charAt(i);
  224.         }
  225.         arr[i]='';
  226.     }
  228.     /**
  229.      * return the chessman's x coordinate  0<=x<15
  230.      * @return
  231.      */
  232.     protected int getXP(){
  233.         return xp/30;
  234.     }
  235.     protected int getYP(){
  236.         return yp/30;
  237.     }
  238.     /**
  239.      * put a chessman and display it (x,y) position on the panel
  240.      * draw chessman on (x,y)
  241.      * @param x
  242.      * @param y
  243.      */
  244.     public void drawChess(int x,int y){
  245.         Graphics g=this.getGraphics();
  246.         char cc = (char)(x+65);
  247.         int temp = y+1;
  248.         x=x*30+16;
  249.         y=y*30+16;
  250.         if(color==1)
  251.             g.setColor(Color.white);
  252.         else
  253.             g.setColor(Color.black);
  254.         g.fillOval(x, y, 28, 28);
  255.         ChessWZQ.label6.setText("Player put on ( "+cc+" , "+temp+" )");
  256.     }
  257.     /**
  258.      * update board status when B put a chessman
  259.      * @param x B's chessman's X coordinate 0<=x<15
  260.      * @param y B's chessman's Y coordinate 0<=y<15
  261.      */
  262.     public void updateBoard(int x,int y){
  263.         int tcolor=0;
  264.         if(color==1) tcolor=2;
  265.         else tcolor=1;
  266.         board[x][y]=tcolor;
  267.     }
  269.     public char intToChar(int x){
  270.         char temp='';
  271.         if(x>=0&&x<=9)
  272.             temp=(char)(48+x);
  273.         else if(x>=10 &&x<=15){
  274.             temp=(char)(55+x);
  275.         }
  276.         return temp;
  277.     }
  279.     /**
  280.      * mouseMoved Event
  281.      * @param e
  282.      */
  283.     void this_mouseMoved(MouseEvent e) {
  284.         int x=0,y=0;
  285.         x=e.getX();
  286.         y=e.getY();
  287.         if(x>20&&x<460&&y>20&&y<460&&(x%30<10||x%30>20)&&(y%30<10||y%30>20)){
  288.             this.setCursor(handCursor); //HAND_CURSOR
  289.         }
  290.         else{
  291.             this.setCursor(defaultCursor);
  292.         }
  293.     }
  294.     /**
  295.      * judge if a man win the game
  296.      * @param x  the newest kid's x coordinate
  297.      * @param y  the newest kid's y coordinate
  298.      * @return
  299.      */
  300.     protected boolean judge(int x,int y,int clr){
  301.         int i=0,j=0,count=0;
  302.         // x direction
  303.         for(i=0,count=0;x-i>=0&&i<5;i++){
  304.             if (clr==board[x-i][y]){
  305.                 count++;
  306.             }else{
  307.                 break;
  308.             }
  309.   //          System.out.println("( "+x+" , "+y+" )"+"count = "+count);
  310.             if(count==5)
  311.                 return true;
  312.         }
  313.         for(i=1;x+i<15&&i<5;i++){
  314.             if(clr==board[x+i][y]){
  315.                 count++;
  316.             }else{
  317.                 break;
  318.             }
  319.             if(count==5)
  320.                 return true;
  321.         }
  322.         // y direction
  323.         for(i=0,count=0;y-i>=0&&i<5;i++){
  324.             if (clr==board[x][y-i]){
  325.                 count++;
  326.             }else{
  327.                 break;
  328.             }
  329. //            System.out.println("( "+x+" , "+y+" )"+"count = "+count);
  330.             if(count==5)
  331.                 return true;
  332.         }
  333.         for(i=1;y+i<15&&i<5;i++){
  334.             if(clr==board[x][y+i]){
  335.                 count++;
  336.             }else{
  337.                 break;
  338.             }
  339.     //        System.out.println("( "+x+" , "+y+" )"+"count = "+count);
  340.             if(count==5)
  341.                 return true;
  342.         }
  343.         // '' direction
  344.         for(i=0,count=0;x-i>=0&&y-i>=0&&i<5;i++){
  345.             if(clr==board[x-i][y-i]){
  346.                 count++;
  347.             }else{
  348.                 break;
  349.             }
  350. //            System.out.println("( "+x+" , "+y+" )"+"count = "+count);
  351.             if(count==5)
  352.                 return true;
  353.         }
  354.         for(i=1;x+i<15&&y+i<15&&i<5;i++){
  355.             if(clr==board[x+i][y+i]){
  356.                 count++;
  357.             }else{
  358.                 break;
  359.             }
  360.   //          System.out.println("( "+x+" , "+y+" )"+"count = "+count);
  361.             if(count==5){
  362.                 return true;
  363.             }
  364.         }
  365.         // '/' direction
  366.         for(i=0,count=0;x+i<15 && y-i>=0 &&i<5; i++){
  367.             if(clr==board[x+i][y-i]){
  368.                 count++;
  369.             }else{
  370.                 count=0;
  371.             }
  372.   //          System.out.println("( "+x+" , "+y+" )"+"count = "+count);
  373.             if(count==5)
  374.                 return true;
  375.         }
  376.         for(i=1;x-i>=0 && y+i<15 &&i<5;i++){
  377.             if(clr==board[x-i][y+i]){
  378.                 count++;
  379.             }else{
  380.                 break;
  381.             }
  382. //            System.out.println("( "+x+" , "+y+" )"+"count = "+count);
  383.             if(count==5){
  384.                 return true;
  385.             }
  386.         }
  387.         return false;
  388.     }
  389.     class Queue{
  390.         int position;
  391.         long mark;
  392.     } ;
  393.     
  394.     class Analyse {
  395.     
  396.     Analyse(int chessc[][]){
  397.         int i, j;
  398.         chessBoard = new int[17][17];
  399.         for (i = 0; i <= 16; i++) {
  400.             for (j = 0; j <= 16; j++) {
  401.                 if (i == 0 || j == 0 || i == 16 || j == 16) {
  402.                     chessBoard[i][j] = 4;
  403.                 }
  404.                 else {
  405.                     chessBoard[i][j] = chessc[i - 1][j - 1];
  406.                 }
  407.             }
  408.         }
  409.     }
  410.     /**
  411.      *
  412.      * @param base
  413.      * @param pow
  414.      * @return
  415.      */
  416.     private long pow(int base, int pow){
  417.        int i;
  418.        long result=1;
  419.        for(i=1;i<=pow;i++){
  420.            result*=base;
  421.        }
  422.        return result;
  423.    }
  424.    /**
  425.     *
  426.     * @param x
  427.     * @param y
  428.     * @param side
  429.     * @return
  430.     */
  431.    private long analyseUd(int x, int y, int side){
  432.        int tt[][] = new int[17][17];
  433.        int i, j;
  434.        int tempx, tempy;
  435.        long mark = 0;
  436.        int base = BASE;
  437.        int uppersign = 0;
  438.        int downsign = 0;
  439.        int c_count = 1;
  441.        for (i = 0; i < 17; i++) {
  442.            for (j = 0; j < 17; j++) {
  443.                tt[i][j] = chessBoard[i][j];
  444.            }
  445.        }
  446.        tt[y][x] = side;
  447.       // up and down
  448.        tempx = x;
  449.        tempy = y;
  450.        if (tt[tempy - 1][tempx] != side) {
  451.            if (tt[tempy - 1][tempx] == 0) {
  452.                uppersign = 1;
  453.            }
  454.            if (tt[tempy - 1][tempx] != 0) {
  455.                uppersign = 0;
  456.            }
  457.        }
  458.        else {
  459.            tempy -= 1;
  460.            while (tt[tempy][tempx] == side) {
  461.                c_count += 1;
  462.                tempy--;
  463.            }
  464.            if (tt[tempy][tempx] == 0) {
  465.                uppersign = 1;
  466.            }
  467.            if (tt[tempy][tempx] != 0) {
  468.                uppersign = 0;
  469.            }
  470.        }
  471.        tempx = x;
  472.        tempy = y;
  473.        if (tt[tempy + 1][tempx] != side) {
  474.            if (tt[tempy + 1][tempx] == 0) {
  475.                downsign = 1;
  476.            }
  477.            if (tt[tempy + 1][tempx] != 0) {
  478.                downsign = 0;
  479.            }
  480.        }
  481.        else {
  482.            tempy += 1;
  483.            while (tt[tempy][tempx] == side) {
  484.                c_count += 1;
  485.                tempy++;
  486.            }
  487.            if (tt[tempy][tempx] == 0) {
  488.                downsign = 1;
  489.            }
  490.            if (tt[tempy][tempx] != 0) {
  491.                downsign = 0;
  492.            }
  493.        }
  494.        mark += pow(base, c_count);
  495.        if ( (uppersign + downsign) > 0) {
  496.            if ( (uppersign + downsign) == 2) {
  497.                mark *= (uppersign + downsign);
  498.            }
  499.            if ( (uppersign + downsign) == 1) {
  500.                mark = mark / 2;
  501.            }
  502.        }
  503.        else if (c_count == 5) {
  504.            mark *= 4;
  505.        }
  506.        else {
  507.            mark = 0;
  508.        }
  509.        if (c_count == 5) {
  510.            mark += INVALID;
  511.        }
  512.        return mark;
  513.    }
  514.    /**
  515.     *
  516.     * @param x
  517.     * @param y
  518.     * @param side
  519.     * @return
  520.     */
  521.    private long analyseLr(int x, int y, int side){
  522.        int tt[][] = new int[17][17];
  523.        int i, j,tx, ty;
  524.        long mark = 0;
  526.        int base = BASE,uppersign = 0,downsign = 0,c_count = 1;
  527.        for (i = 0; i < 17; i++) {
  528.            for (j = 0; j < 17; j++) {
  529.                tt[i][j] = chessBoard[i][j];
  530.            }
  531.        }
  532.        tt[y][x] = side;
  533.        // left and right
  534.        tx = x;
  535.        ty = y;
  536.        if (tt[ty][tx - 1] != side) {
  537.            if (tt[ty][tx - 1] == 0) {
  538.                uppersign = 1;
  539.            }
  540.            if (tt[ty][tx - 1] != 0) {
  541.                uppersign = 0;
  542.            }
  543.        }
  544.        else {
  545.            tx -= 1;
  546.            while (tt[ty][tx] == side) {
  547.                c_count += 1;
  548.                tx--;
  549.            }
  550.            if (tt[ty][tx] == 0) {
  551.                uppersign = 1;
  552.            }
  553.            if (tt[ty][tx] != 0) {
  554.                uppersign = 0;
  555.            }
  556.        }
  557.        tx = x;
  558.        ty = y;
  559.        if (tt[ty][tx + 1] != side) {
  560.            if (tt[ty][tx + 1] == 0) {
  561.                downsign = 1;
  562.            }
  563.            if (tt[ty][tx + 1] != 0) {
  564.                downsign = 0;
  565.            }
  566.        }
  567.        else {
  568.            tx += 1;
  569.            while (tt[ty][tx] == side) {
  570.                c_count += 1;
  571.                tx++;
  572.            }
  573.            if (tt[ty][tx] == 0) {
  574.                downsign = 1;
  575.            }
  576.            if (tt[ty][tx] != 0) {
  577.                downsign = 0;
  578.            }
  579.        }
  580.        mark += pow(base, c_count);
  581.        if ( (uppersign + downsign) > 0) {
  582.            if ( (uppersign + downsign) == 2) {
  583.                mark *= (uppersign + downsign);
  584.            }
  585.            if ( (uppersign + downsign) == 1) {
  586.                mark = mark / 2;
  587.            }
  588.        }
  589.        else if (c_count == 5) {
  590.            mark *= 4;
  591.        }
  592.        else {
  593.            mark = 0;
  594.        }
  595.        if (c_count == 5) {
  596.            mark += INVALID;
  597.        }
  598.        return mark;
  599.    }
  600.    /**
  601.     *
  602.     * @param x
  603.     * @param y
  604.     * @param side
  605.     * @return
  606.     */
  607.    private long analyseLdru(int x, int y, int side){
  608.        int tt[][] = new int[17][17];
  609.        int i, j;
  610.        int tx, ty;
  611.        long mark = 0;
  613.        int base = BASE;
  614.        int uppersign = 0;
  615.        int downsign = 0;
  616.        int c_count = 1;
  617.        for (i = 0; i < 17; i++) {
  618.            for (j = 0; j < 17; j++) {
  619.                tt[i][j] = chessBoard[i][j];
  620.            }
  621.        }
  622.        tt[y][x] = side;
  623.        /* left down and right upper */
  624.        tx = x;
  625.        ty = y;
  626.        if (tt[ty - 1][tx - 1] != side) {
  627.            if (tt[ty - 1][tx - 1] == 0) {
  628.                uppersign = 1;
  629.            }
  630.            if (tt[ty - 1][tx - 1] != 0) {
  631.                uppersign = 0;
  632.            }
  633.        }
  634.        else {
  635.            tx -= 1;
  636.            ty -= 1;
  637.            while (tt[ty][tx] == side) {
  638.                c_count += 1;
  639.                tx--;
  640.                ty--;
  641.            }
  642.            if (tt[ty][tx] == 0) {
  643.                uppersign = 1;
  644.            }
  645.            if (tt[ty][tx] != 0) {
  646.                uppersign = 0;
  647.            }
  648.        }
  649.        tx = x;
  650.        ty = y;
  651.        if (tt[ty + 1][tx + 1] != side) {
  652.            if (tt[ty + 1][tx + 1] == 0) {
  653.                downsign = 1;
  654.            }
  655.            if (tt[ty + 1][tx + 1] != 0) {
  656.                downsign = 0;
  657.            }
  658.        }
  659.        else {
  660.            tx += 1;
  661.            ty += 1;
  662.            while (tt[ty][tx] == side) {
  663.                c_count += 1;
  664.                tx++;
  665.                ty++;
  666.            }
  667.            if (tt[ty][tx] == 0) {
  668.                downsign = 1;
  669.            }
  670.            if (tt[ty][tx] != 0) {
  671.                downsign = 0;
  672.            }
  673.        }
  674.        mark += pow(base, c_count);
  675.        if ( (uppersign + downsign) > 0) {
  676.            //mark*=(uppersign+downsign);
  677.            if ( (uppersign + downsign) == 2) {
  678.                mark *= (uppersign + downsign);
  679.            }
  680.            if ( (uppersign + downsign) == 1) {
  681.                mark = mark / 2;
  682.            }
  683.        }
  684.        else if (c_count == 5) {
  685.            mark *= 4;
  686.        }
  687.        else {
  688.            mark = 0;
  689.        }
  690.        if (c_count == 5) {
  691.            mark += INVALID;
  692.        }
  693.        return mark;
  694.    }
  695.    private long analyseRdlu(int x, int y, int side){
  696.        int tt[][] = new int[17][17];
  697.        int i, j;
  698.        int tx, ty;
  699.        long mark = 0;
  701.        int base = BASE;
  702.        int uppersign = 0;
  703.        int downsign = 0;
  704.        int c_count = 1;
  705.        for (i = 0; i < 17; i++) {
  706.            for (j = 0; j < 17; j++) {
  707.                tt[i][j] = chessBoard[i][j];
  708.            }
  709.        }
  710.        tt[y][x] = side;
  711.        /* left down and right upper */
  712.        tx = x;
  713.        ty = y;
  714.        if (tt[ty - 1][tx + 1] != side) {
  715.            if (tt[ty - 1][tx + 1] == 0) {
  716.                uppersign = 1;
  717.            }
  718.            if (tt[ty - 1][tx + 1] != 0) {
  719.                uppersign = 0;
  720.            }
  721.        }
  722.        else {
  723.            tx += 1;
  724.            ty -= 1;
  725.            while (tt[ty][tx] == side) {
  726.                c_count += 1;
  727.                tx++;
  728.                ty--;
  729.            }
  730.            if (tt[ty][tx] == 0) {
  731.                uppersign = 1;
  732.            }
  733.            if (tt[ty][tx] != 0) {
  734.                uppersign = 0;
  735.            }
  736.        }
  737.        tx = x;
  738.        ty = y;
  739.        if (tt[ty + 1][tx - 1] != side) {
  740.            if (tt[ty + 1][tx - 1] == 0) {
  741.                downsign = 1;
  742.            }
  743.            if (tt[ty + 1][tx - 1] != 0) {
  744.                downsign = 0;
  745.            }
  746.        }
  747.        else {
  748.            tx -= 1;
  749.            ty += 1;
  750.            while (tt[ty][tx] == side) {
  751.                c_count += 1;
  752.                tx--;
  753.                ty++;
  754.            }
  755.            if (tt[ty][tx] == 0) {
  756.                downsign = 1;
  757.            }
  758.            if (tt[ty][tx] != 0) {
  759.                downsign = 0;
  760.            }
  761.        }
  762.        mark += pow(base, c_count);
  763.        if ( (uppersign + downsign) > 0) {
  764.            if ( (uppersign + downsign) == 2) {
  765.                mark *= (uppersign + downsign);
  766.            }
  767.            if ( (uppersign + downsign) == 1) {
  768.                mark = mark / 2;
  769.            }
  770.        }
  771.        else if (c_count == 5) {
  772.            mark *= 4;
  773.        }
  774.        else {
  775.            mark = 0;
  776.        }
  777.        if (c_count == 5) {
  778.            mark += INVALID;
  779.        }
  780.        return mark;
  781.    }
  782.    /**
  783.     *
  784.     * @param x
  785.     * @param y
  786.     * @param side
  787.     * @return
  788.     */
  789.    private long analyse(int x, int y, int side){
  790.        long mark = 0;
  791.        mark += analyseUd(x, y, side);
  792.        mark += analyseLr(x, y, side);
  793.        mark += analyseLdru(x, y, side);
  794.        mark += analyseRdlu(x, y, side);
  795.        return mark;
  796.    }
  797.    /**
  798.     *
  799.     * @param chess
  800.     * @param deepth
  801.     * @return
  802.     */
  803.    private Queue searchPoint(int chess[][],int deepth){
  804.        //temp
  805.        int cx, cy;
  806.        //int newdeepth;
  807.        char s[] = new char[10];
  808.        //temp
  809.        Queue pq[] = null, pq_temp[] = null, pq_final;
  810.        int temp_chess[][] = new int[17][17];
  811.        long mark = 0;
  812.        int duce;
  813.        int i, j;
  814.        int m, n, p, q;
  815.        int media;
  816.        int MAX;
  817.        int k, b;
  818.        //mark
  819.        MAX=MAX1<=(225-STEPCOUNTER)?MAX1:(225-STEPCOUNTER);
  820.             if(MAX==(225-STEPCOUNTER)){
  821.         MINDEEPTH=1;
  822.             }
  823.        pq = new Queue[MAX + 1];
  824.        for (m = 0; m < MAX; m++) {
  825.            pq[m] = new Queue();
  826.        }
  827.        for (m = 0; m < MAX; m++) {
  828.            pq[m].mark = 0;
  829.            pq[m].position = 0;
  830.        }
  831.        for (i = 1; i <= 15; i++) {
  832.          //  System.out.println();
  833.            for (j = 1; j <= 15; j++) {
  834.                if (chess[i][j] != 0) {
  835.                    mark = 0;
  836.                }
  837.                else {
  838.                    mark = analyse(j, i, 1) / 2 + analyse(j, i, 2);
  839.            //        System.out.print("t" + mark);
  840.                }
  842.                //tempboard[i][j]=mark;
  843.                for (m = 0; m < MAX; m++) {
  844.                    if (mark > pq[m].mark) {
  845.                        for (n = MAX - 1; n > m; n--) {
  846.                            pq[n].mark = pq[n - 1].mark;
  847.                            pq[n].position = pq[n - 1].position;
  848.                        }
  849.                        pq[m].mark = mark;
  850.                        pq[m].position = i * 100 + j;
  851.                        break;
  852.                    }
  853.                }
  854.            }
  855.        }
  856.        //newdeepth=maxdeepth;
  857.        if (pq[0].mark >= INVALID / 2) {
  858.            MINDEEPTH = deepth;
  859.        }
  860.        if (deepth < MINDEEPTH) {
  861.            for (m = 0; m < MAX; m++) {
  862.                for (p = 0; p <= 16; p++) {
  863.                    for (q = 0; q <= 16; q++) {
  864.                        temp_chess[p][q] = chess[p][q];
  865.                    }
  866.                }
  867.                if (deepth % 2 == 1) {
  868.                    media = 2;
  869.                }
  870.                else {
  871.                    media = 1;
  872.                }
  873.                temp_chess[pq[m].position / 100][pq[m].position % 100] = media;
  874.                pq[m] = searchPoint(temp_chess, deepth + 1);
  875.            }
  876.        }
  877.        pq_temp = new Queue[MAX + 1];
  878.        for (m = 0; m < MAX; m++) {
  879.            pq_temp[m] = new Queue();
  880.        }
  882.        for (p = 0; p < MAX; p++) {
  883.            pq_temp[p].mark = 0;
  884.            pq_temp[p].position = 0;
  885.        }
  886.        for (p = 0; p < MAX; p++) {
  887.            for (q = 0; q < MAX; q++) {
  888.                if (pq[p].mark > pq_temp[q].mark) {
  889.                    for (i = MAX - 1; i > q; i--) {
  890.                        pq_temp[i] = pq_temp[i - 1];
  891.                    }
  892.                    pq_temp[q] = pq[p];
  893.                    break;
  894.                }
  895.            }
  896.        }
  897.        pq_final = pq_temp[0];
  898.        return pq_final;
  899.    }
  900.    public int computerDo(){
  901.        int position = 0;
  902.        int cx, cy;
  903.        position = (searchPoint(chessBoard, 3)).position;
  904.        cx = position % 100;
  905.        cy = position / 100;
  906. //       System.out.print("n" + cy + "t" + cx + "n");
  907.        if (cx == 0 && cy == 0) {
  908.            return 1;
  909.        }
  910.        return position;
  911.    }
  912. } ///:-)
  915. }///:-)
  916. /**
  917.  * mouse Adapter
  918.  * <p>Title: </p>
  919.  * <p>Description: </p>
  920.  * <p>Copyright: Copyright (c) 2003</p>
  921.  * <p>Company: e-top</p>
  922.  * @author cylix
  923.  * @version 1.0
  924.  */
  925. class ChessWZQ_this_mouseAdapter extends java.awt.event.MouseAdapter {
  926.     BoardPanel adaptee;
  928.     ChessWZQ_this_mouseAdapter(BoardPanel adaptee) {
  929.         this.adaptee = adaptee;
  930.     }
  931.     public void mouseClicked(MouseEvent e) {
  932.         adaptee.this_mouseClicked(e);
  933.     }
  934. }///:-)
  935. /**
  936.  * mouse Adapter
  937.  * <p>Title: </p>
  938.  * <p>Description: </p>
  939.  * <p>Copyright: Copyright (c) 2003</p>
  940.  * <p>Company: e-top</p>
  941.  * @author cylix
  942.  * @version 1.0
  943.  */
  944. class ChessWZQ_this_mouseMotionAdapter extends java.awt.event.MouseMotionAdapter {
  945.     BoardPanel adaptee;
  947.     ChessWZQ_this_mouseMotionAdapter(BoardPanel adaptee) {
  948.         this.adaptee = adaptee;
  949.     }
  950.     public void mouseMoved(MouseEvent e) {
  951.         adaptee.this_mouseMoved(e);
  952.     }
  953. }///:-)