五子棋算法研究

最新推荐文章于 2021-03-20 11:45:54 发布
最新推荐文章于 2021-03-20 11:45:54 发布
阅读量1.3k 收藏 3
点赞数
文章标签： 算法 table exception null file string
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/anshufeng1988/article/details/6488442
版权
/*仅供个人学习交流使用
  严禁任何商业用途，违者必究
*/
/** 五子棋程序
* @author ShuFeng An
* @author BeijingUiniversitiyOfChemicalTechnology
* @version 1.1
*/
import java.awt.image.BufferedImage;
import javax.swing.JFrame;
import java.awt.Image;
import java.io.IOException;
import javax.swing.JPanel;
import javax.imageio.ImageIO;
import java.awt.Graphics;
import java.awt.Dimension;
import java.io.File ;
import java.awt.event.MouseEvent;
import java.awt.event.MouseMotionAdapter;
import java.awt.event.MouseAdapter;
import javax.swing.JOptionPane;
import java.awt.HeadlessException;
 
public class WuZiQi
{
    //棋盘位图
    BufferedImage table;
    //黑色棋子位图
    BufferedImage black;
    //白色棋子位图
    BufferedImage white;
    //鼠标移动时候的选择框
    BufferedImage selected;
    //棋子类型，是五子棋还是六字棋......
    private final int TYPE = 5;
    //标志符号，一个人不能连走
    private static  long n = -1;
    //定义棋盘大小
    private static int BOARD_SIZE = 15;
    //定义棋盘宽高多少个像素
    private final int TABLE_WIDTH = 535;
    private final int TABLE_HETGHT = 536;
    //定义棋盘坐标的像素值和棋盘数组之间的比率
    private final int RATE = TABLE_WIDTH/BOARD_SIZE;
    //定义棋盘坐标的像素值和棋盘数组之间的偏移距
    private final int X_OFFSET = 5;
    private final int Y_OFFSET = 6;
    //结束标志d=TYPE结束
    private int d = 0;
    //定义一个二维数组来充当棋盘
    private String[][] board = new String[BOARD_SIZE][BOARD_SIZE];
    //五子棋的游戏窗口
    JFrame f = new JFrame("树峰五子棋");
    //五子棋游戏棋盘对应的Canvas组件
    ChessBoard chessBoard = new ChessBoard();
    //当前选中点的坐标
    private  int selectedX = -1;
    private  int selectedY = -1;
  
    public void init() throws Exception
    {
        table = ImageIO.read(new File("image/board.jpg"));
        black = ImageIO.read(new File("image/black.gif"));
        white = ImageIO.read(new File("image/white.gif"));
        selected = ImageIO.read(new File("image/selected.gif"));
       
        //把每个元素赋为"╋",用于在控制台画出棋盘
        for (int i = 0; i < BOARD_SIZE; i++)
        {
            for (int j = 0; j < BOARD_SIZE; j++)
            {
                board[i][j] = "╋";
            }
        }
       
        chessBoard.setPreferredSize(new Dimension(TABLE_WIDTH,
         TABLE_HETGHT));
        
        chessBoard.addMouseListener(new MouseAdapter()
        {
            public void mouseClicked(MouseEvent e)
            {
                //将用户鼠标事件的坐标转换成棋子数组的坐标
                int xPox = (int) ((e.getX() - X_OFFSET) / RATE);
                int yPos = (int) ((e.getY() - Y_OFFSET) / RATE);
                //如果鼠标单击点儿无子绘一个子且轮流绘黑白子
                if(n % 2 == 0 && board[xPox][yPos] == "╋")
                {
                    board[xPox][yPos] = "●";
                    n++;
                  
                }
                else if(board[xPox][yPos] == "╋")
                {
                     board[xPox][yPos] = "○";
                     n++;                  
                }
                chessBoard.repaint();
                //判断游戏是否结束
                overOrNot(xPox, yPos);
          }
          //当鼠标退出棋盘区后复位选中点坐标
          public void mouseExited(MouseEvent e)
          {
              selectedX =-1;
              selectedY = -1;
              chessBoard.repaint();
          }
        });
       
        //当用户单击退出按钮时退出
        f.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
       
        //当鼠标移动时改变选中点坐标
        chessBoard.addMouseMotionListener(new MouseMotionAdapter()
        {
            public void mouseMoved(MouseEvent e)
            {
                selectedX = (int) ((e.getX() - X_OFFSET) / RATE);
                selectedY = (int)(e.getY() - Y_OFFSET) / RATE;
                chessBoard.repaint();
            }
        });
       
        f.add(chessBoard);
        //设置窗口图片为bfi
        Image bfi = null;
        try
        {
            bfi = ImageIO.read(new File("D://homework//image//myself.jpg"));
        }
        catch(IOException e)
        {
            e.printStackTrace();
        }       
        f.setIconImage(bfi);
        //设置窗口大小不可调
        f.setResizable(false);
        f.pack();
        f.setVisible(true);
       
    }
   
    public static void main(String[] args) throws Exception
    {
        System.out.println("欢迎使用树峰五子棋程序!");
        WuZiQi wzq = new WuZiQi();
        wzq.init();
    }
   
    public  void overOrNot(int a, int b)
    {
        int i = 0;
        //从左往右数有四个黑子
      if(d <= TYPE)                                  
     {
      for(i = a, d = 0;i <= a + 4; i++)                                                                       
      {
       if(board[i][b] == "●" && i < BOARD_SIZE)
        d++;
        else
        {
         d=0;
         break;
        }
        if(d == TYPE)
        {
            happyEndBlack();
            System.out.println("黑方胜出!树峰欢迎你下次光临!");
            System.exit(0);
        }
      }
     }
     //从右往左数有5个黑子
     if(d <= TYPE)
     {
      for(i = a, d = 0;i >= a-4; i--)                   
      {
       if(board[i][b] == "●" && i >= 0)
        d++;
       else
       {
        d = 0;
        break;
       }
       if(d == TYPE)
       {
           happyEndBlack();
           System.out.println("黑方胜出!树峰欢迎您的下次光临！");
           System.exit(0);
       }
      }
     }
     //从上往下数有5个黑子
     if(d <= TYPE)                                                                                                           
     {
      for(i = b, d = 0;i <= b + 4; i++)
      {
       if(board[a][i] == "●" && i < BOARD_SIZE)
        d++;
       else
       {  
           d = 0;
        break;
       }
       if(d == TYPE)
        {
            happyEndBlack();
            System.out.println("黑方胜出！树峰欢迎你下次光临!");
            System.exit(0);
        }
      }
     }
     //从下往上数有5个黑子
     if(d <= TYPE)
     {
      for(i = b, d = 0; i >= b-4; i--)                          
      {
       if(board[a][i] == "●" && i >= 0)
        d++;
       else
       {
        d = 0;
        break;
       }
       if(d == TYPE)
        {
            happyEndBlack();
            System.out.println("黑方胜出！树峰欢迎你下次光临!");
            System.exit(0);
        }
         }
     }
     //斜着往左下方数5个
     if(d <= TYPE)                                                                           
     {
      for(i = 0, d = 0; i <= 4; i++)
      {
       if(board[a-i][b+i] == "●" && (a-i) >=0
       && (b+i) < BOARD_SIZE)
        d++;
       else
       {
        d = 0;
        break;
       }
       if(d == TYPE)
        {
            happyEndBlack();
            System.out.println("黑方胜出！树峰欢迎你下次光临!");
            System.exit(0);
        }
         
      }
     }
     //斜着右上方有五个黑子
     if(d <= TYPE)
     {
      for(i = 0, d = 0; i <= 4; i++)
      {
       if(board[a+i][b-i] == "●" && (a+i) < BOARD_SIZE
        && (b-i) >= 0)
        d++;
       else
       {
        d = 0;
        break;
       }
       if(d == TYPE)
        {
            happyEndBlack();
            System.out.println("黑方胜出！树峰欢迎你下次光临!");
            System.exit(0);
        }
      }
     }
     //斜着右下方有5个子
     if(d <= TYPE)
     {
      for(i = 0, d = 0; i <= 4;i++)
      {
       if(board[a+i][b+i] == "●" && (a+i) < BOARD_SIZE
       && (b+i) < BOARD_SIZE)
        d++;
       else
       {
        d = 0;
        break;
       }
       if(d == TYPE)
        {
            happyEndBlack();
            System.out.println("黑方胜出！树峰欢迎你下次光临!");
            System.exit(0);
        }
      }
     }
     //斜着左上方有5个子
     if(d <= TYPE)
     {
      for(i = 0, d = 0; i <= 4; i++)
      {
       if(board[a-i][b-i] == "●" && (a-i) >= 0 && (b-i) >= 0)
        d++;
       else
       {
        d = 0;
        break;
       }
       if(d == TYPE)
        {
            happyEndBlack();
            System.out.println("黑方胜出！树峰欢迎你下次光临!");
            System.exit(0);
        }
      }
     }
     //此子正下方有一个正上方有三个一条纵线
     if(d<=TYPE)
     {
      for(i = 0,d = 1;i <= 3;i++)
      {
       if(board[a][b-i] == "●" && board[a][b+1] == "●" && (b-i) >= 0 && (b+1) < BOARD_SIZE)
        d++;
       else
       {
        d = 0;
        break;
       }
       if(d == TYPE)
        {
            happyEndBlack();
            System.out.println("黑方胜出！树峰欢迎你下次光临!");
            System.exit(0);
        }
      }
     }
     //此子正上方有一个正下方有三个黑子
     if(d <= TYPE)
     {
      for(i = 0, d = 1; i <= 3; i++)
      {
       if(board[a][b+i] == "●" && board[a][b-1] == "●"
       && (b+i) < BOARD_SIZE && (b-1) >= 0)
        d++;
       else
       {
        d = 0;
        break;
       }
       if(d == TYPE)
        {
            happyEndBlack();
            System.out.println("黑方胜出！树峰欢迎你下次光临!");
            System.exit(0);
        }
      }
     }
     //此子在正中间正上方有两个正下方有两个子
     if(d <= TYPE)
     {
      for(i = 0, d = 2; i <= 2; i++)
      {
       if(board[a][b-i] == "●" && board[a][b+i] == "●"
       &&( b-i) >= 0 &&( b+i) < BOARD_SIZE)
        d++;
       else
       {
        d = 0;
        break;
       }
       if(d == TYPE)
        {
            happyEndBlack();
            System.out.println("黑方胜出！树峰欢迎你下次光临!");
            System.exit(0);
        }
      }
     }
     //斜右向下有一个子斜左向上有三个
     if(d <= TYPE)
     {
      for(i = 0, d = 1; i <= 3; i++)
      {
       if(board[a-i][b-i] == "●" && board[a+1][b+1] == "●"
       && (a-i) >= 0 && (b-i) >= 0 && (a+1) < BOARD_SIZE
       && (b+1) < BOARD_SIZE)
        d++;
       else
       {
        d = 0;
        break;
       }
       if(d == TYPE)
        {
            happyEndBlack();
            System.out.println("黑方胜出！树峰欢迎你下次光临!");
            System.exit(0);
        }
      }
     }
     //此子斜左向上有两个子右向下有两个子
     if(d <= TYPE)
     {
      for(i = 0, d = 2; i <= 2; i++)
      {
       if(board[a-i][b-i] == "●" && board[a+i][b+i] == "●"
       &&(a-i) >= 0 && (b-i) >= 0 && (a+i) < BOARD_SIZE
       && (b+i) < BOARD_SIZE)
        d++;
       else
       {
        d = 0;
        break;
       }
       if(d == TYPE)
        {
            happyEndBlack();
            System.out.println("黑方胜出！树峰欢迎你下次光临!");
            System.exit(0);
        }
      }
     }
     //此子左斜向上有一子右向下有三个子
     if(d <= TYPE)
     {
      for(i = 0, d = 1; i <= 3; i++)
      {
       if(board[a+i][b+i] == "●" && board[a-1][b-1] == "●"
       && (a-1) >= 0 && (b-1) >= 0 && (a+i) < BOARD_SIZE
       && (b+i) < BOARD_SIZE)
        d++;
       else
       {
        d=0;
        break;
       }
       if(d == TYPE)
        {
            happyEndBlack();
            System.out.println("黑方胜出！树峰欢迎你下次光临!");
            System.exit(0);
        }
      }
     }
     //此子左向下有两个子右向上有两个子
     if(d <= TYPE)
     {
      for(i = 0, d = 2; i <= 2; i++)
      {
       if(board[a-i][b+i] == "●" && board[a+i][b-i] == "●"
       && (a-i) >= 0 && (b-i) >= 0 && ( b+i) < BOARD_SIZE
       && (a+i) < BOARD_SIZE)
        d++;
       else
       {
        d = 0;
        break;
       }
       if(d == TYPE)
        {
            happyEndBlack();
            System.out.println("黑方胜出！树峰欢迎你下次光临!");
            System.exit(0);
        }
      }
     }
     //此子右向上有一个子左向下有三个子
     if(d <= TYPE)
     {
      for(i = 0,d = 1; i <= 3;i++)
      {
       if(board[a-i][b+i] == "●" && board[a+1][b-1] == "●"
       && (a-i) >= 0 && (b-1) >= 0 && (b+i) < BOARD_SIZE
       && (a+1) < BOARD_SIZE)
        d++;
       else
       {
        d = 0;
        break;
       }
       if(d == TYPE)
        {
            happyEndBlack();
            System.out.println("黑方胜出！树峰欢迎你下次光临!");
            System.exit(0);
        }
      }
     }
     //斜右向下一个子斜左向上三个子
     if(d <= TYPE)
     {
      for(i = 0,d = 1; i <= 3; i++)
      {
       if(board[a+i][b-i] == "●" && board[a-1][b+1] == "●"
       && (a+i) < BOARD_SIZE && (b-i) >= 0 && (a-1)>=0
       && (b+1) < BOARD_SIZE)
        d++;
       else
       {
        d = 0;
        break;
       }
       if(d == TYPE)
        {
            happyEndBlack();
            System.out.println("黑方胜出！树峰欢迎你下次光临!");
            System.exit(0);
        }
      }
     }
     //与此子一条横线右边一个左边三个子
     if(d <= TYPE)
     {
      for(i = 0, d = 1; i <= 3; i++)
      {
       if(board[a-i][b] == "●" && board[a+1][b] == "●"
       && (a-i) >= 0 && (a+1) < BOARD_SIZE)
        d++;
       else
       {
        d = 0;
        break;
       }
       if(d == TYPE)
        {
            happyEndBlack();
            System.out.println("黑方胜出！树峰欢迎你下次光临!");
            System.exit(0);
        }
       
      }
     }
     //与此子一条横线左边两个右边两个
     if(d <= TYPE)
     {
      for(i = 0, d = 2; i <= 2; i++)
      {
       if(board[a-i][b] == "●" && board[a+i][b] == "●"
       && (a-i) >= 0 && (a+i)<BOARD_SIZE)
        d++;
       else
       {
        d = 0;
        break;
       }
       if(d == TYPE)
        {
            happyEndBlack();
            System.out.println("黑方胜出！树峰欢迎你下次光临!");
            System.exit(0);
        }
      }
     }
     //与此子一条横线左边一个右边三个
     if(d <= TYPE)
     {
      for(i = 0, d = 1; i <= 3; i++)
      {
       if(board[a+i][b] == "●" && board[a-1][b] == "●"
       && (a+i) < BOARD_SIZE && (a-1) >= 0)
        d++;
       else
       {
        d = 0;
        break;
       }
       if(d == TYPE)
        {
            happyEndBlack();
            System.out.println("黑方胜出！树峰欢迎你下次光临!");
            System.exit(0);
        }
      }
     }
     //与此子一条横线左边三个右边一个白子
     if(d <= TYPE)
     {
      for(i = 0, d = 1; i <= 3; i++)
      {
       if(board[a-i][b] == "○" && board[a+1][b] == "○"
       &&(a-i) >= 0 &&(a+1) < BOARD_SIZE)
        d++;
       else
       {
        d = 0;
        break;
       }
       if(d == TYPE)
        {
            happyEndWhite();
            System.out.println("白方胜出！树峰欢迎你下次光临!");
            System.exit(0);
        }
       
      }
     }
     //与此子一条纵线下边一个上边三个白子
     if(d <= TYPE)
     {
      for(i = 0, d = 1; i <= 3; i++)
      {
       if(board[a][b-i] == "○" && board[a][b+1 ] == "○"
       && (b-i) >= 0 && (b+1) < BOARD_SIZE)
        d++;
       else
       {
        d = 0;
        break;
       }
       if(d == TYPE)
        {
            happyEndWhite();
            System.out.println("白方胜出！树峰欢迎你下次光临!");
            System.exit(0);
        }
      }
     }
     //与此子一条纵线左边一个右边三个白子
     if(d <= TYPE)
     {
      for(i = 0, d = 1; i <= 3; i++)
      {
       if(board[a][b+i] == "○" && board[a][b-1] == "○"
       && (b+i) < BOARD_SIZE && (b-1) >= 0)
        d++;
       else
       {
        d = 0;
        break;
       }
       if(d == TYPE)
        {
            happyEndWhite();
            System.out.println("白方胜出！树峰欢迎你下次光临!");
            System.exit(0);
        }
      }
     }
     //与此子一条纵线左边两个右边两个白子
     if(d <= TYPE)
     {
      for(i = 0, d = 2; i <= 2; i++)
      {
       if(board[a][b-i] == "○" && board[a][b+i] == "○"
       && (b-i) >= 0 && (b+i) < BOARD_SIZE)
        d++;
       else
       {
        d = 0;
        break;
       }
       if(d == TYPE)
        {
            happyEndWhite();
            System.out.println("白方胜出！树峰欢迎你下次光临!");
            System.exit(0);
        }
      }
     }
     //此子斜右向下一个左向上三个白子
     if(d <= TYPE)
     {
      for(i = 0, d = 1; i <= 3; i++)
      {
       if(board[a-i][b-i] == "○" && board[a+1][b+1] == "○"
       && (a-i) >=0 && (b-i) >=0 && (a+1) < BOARD_SIZE
       && (b+1) < BOARD_SIZE)
        d++;
       else
       {
        d = 0;
        break;
       }
       if(d == TYPE)
        {
            happyEndWhite();
            System.out.println("白方胜出！树峰欢迎你下次光临!");
            System.exit(0);
        }
      }
     }
     //此子左向上两个右向下两个白子
     if(d <= TYPE)
     {
      for(i = 0, d = 2; i <= 2; i++)
      {
       if(board[a-i][b-i] == "○" && board[a+i][b+i] == "○"
       && (a-i) >= 0 &&(b-i) >= 0 && (a+i) < BOARD_SIZE
       && (b+i) < BOARD_SIZE)
        d++;
       else
       {
        d = 0;
        break;
       }
       if(d == TYPE)
        {
            happyEndWhite();
            System.out.println("白方胜出！树峰欢迎你下次光临!");
            System.exit(0);
        }
      }
     }
     //此子左向上一个右向下三个白子
     if(d<=TYPE)
     {
      for(i = 0, d = 1; i <= 3; i++)
      {
       if(board[a+i][b+i] == "○" && board[a-1][b-1] == "○"
       && (a+i) < BOARD_SIZE && (b+i) < BOARD_SIZE
       && (a-1) >= 0 && (b-1) >= 0)
        d++;
       else
       {
        d = 0;
        break;
       }
       if(d == TYPE)
        {
            happyEndWhite();
            System.out.println("白方胜出！树峰欢迎你下次光临!");
            System.exit(0);
        }
      }
     }
     //此子左向上两个右向下两个
     if(d <= TYPE)
     {
      for(i = 0, d = 2; i <= 2; i++)
      {
       if(board[a-i][b+i] == "○" && board[a+i][b-i] == "○"
       && (a-i) >= 0 && (b-i) >= 0 && (a+i) < BOARD_SIZE
       && (b+i) < BOARD_SIZE)
        d++;
       else
       {
        d = 0;
        break;
       }
       if(d == TYPE)
        {
            happyEndWhite();
            System.out.println("白方胜出！树峰欢迎你下次光临!");
            System.exit(0);
        }
      }
     }
     //此子右向上一个左向下三个
     if(d <= TYPE)
     {
      for(i = 0, d = 1; i <= 3; i++)
      {
       if(board[a-i][b+i] == "○" && board[a+1][b-1] == "○"
       &&(a-i) >= 0 && (b+i) < BOARD_SIZE && (a+1) < BOARD_SIZE
       &&(b-1) >= 0)
        d++;
       else
       {
        d = 0;
        break;
       }
       if(d == TYPE)
        {
            happyEndWhite();
            System.out.println("白方胜出！树峰欢迎你下次光临!");
            System.exit(0);
        }
      }
     }
     //此子左向上一个右向上三个白子
     if(d <= TYPE)
     {
      for(i = 0, d = 1; i <= 3; i++)
      {
       if(board[a+i][b-i] == "○" && board[a-1][b-1] == "○"
       && (a+i) < BOARD_SIZE && (b-i) >= 0 && (a-1) >= 0 && (b-1) >= 0)
        d++;
       else
       {
        d = 0;
        break;
       }
       if(d == TYPE)
        {
            happyEndWhite();
            System.out.println("白方胜出！树峰欢迎你下次光临!");
            System.exit(0);
        }
      }
     }
     //与此子一条横线左边两个右边两个
     if(d <= TYPE)
     {
      for(i = 0, d = 2; i <= 2; i++)
      {
       if(board[a-i][b] == "○" && board[a+i][b] == "○"
       && (a-i) >= 0 && (a+i) < BOARD_SIZE)
        d++;
       else
       {
        d = 0;
        break;
       }
       if(d == TYPE)
        {
            happyEndWhite();
            System.out.println("白方胜出！树峰欢迎你下次光临!");
            System.exit(0);
        }
      }
     }
     //与此子一条横线左边一个右边三个
     if(d <= TYPE)
     {
      for(i = 0, d = 1; i <= 3 ; i++)
      {
       if(board[a+i][b] == "○" && board[a-1][b] == "○"
       && (a + i) < BOARD_SIZE)
        d++;
       else
       {
        d = 0;
        break;
       }
       if(d == TYPE)
        {
            happyEndWhite();
            System.out.println("白方胜出！树峰欢迎你下次光临!");
            System.exit(0);
        }
      }
     }
     //从左往右数有四个一条横线
     if(d <= TYPE)
     {
      for(d = 0, i = a; i <= a + 4; i++)
      {
       if(board[i][b] == "○" && i < BOARD_SIZE)
        d++;
       else
       {
        d = 0;
        break;
       }
       if(d == TYPE)
        {
            happyEndWhite();
            System.out.println("白方胜出！树峰欢迎你下次光临!");
            System.exit(0);
        }
      }
     }
     //从右往左数有四个白子一条横线
     if(d <= TYPE)
     {
      for(i = a, d = 0; i >= a - 4; i--)
      {
       if(board[i][b] == "○" && i >= 0)
        d++;
       else
       {
        d = 0;
        break;
       }
       if(d == TYPE)
        {
            happyEndWhite();
            System.out.println("白方胜出！树峰欢迎你下次光临!");
            System.exit(0);
        }
      }
     }
     //从上往下数有四个一条纵线
     if(d <= TYPE)
     {
      for(i = b, d = 0; i <= b + 4; i++)
      {
       if(board[a][i] == "○" && i < BOARD_SIZE)
        d++;
       else
       {
        d = 0;
        break;
       }
       if(d == TYPE)
        {
            happyEndWhite();
            System.out.println("白方胜出！树峰欢迎你下次光临!");
            System.exit(0);
        }
      }
     }
     //从下往上数有四个
     if(d <= TYPE)
     {
      for(i = b, d = 0; i >= b - 4; i--)
      {
       if(board[a][i] == "○" && i >= 0)
        d++;
       else
       {
        d = 0;
        break;
       }
       if(d == TYPE)
        {
            happyEndWhite();
            System.out.println("白方胜出！树峰欢迎你下次光临!");
            System.exit(0);
        }
      }
     }
     //斜左向下有四个白子
     if(d <= TYPE)
     {
      for(i = 0, d = 0; i <= 4; i++)
      {
       if(board[a-i][b+i] == "○" && (a - i) >= 0
       && (b + i) < BOARD_SIZE)
        d++;
       else
       {
        d = 0;
        break;
       }
       if(d == TYPE)
        {
            happyEndWhite();
            System.out.println("白方胜出！树峰欢迎你下次光临!");
            System.exit(0);
        }
      }
     }
     //斜右向上有四个白子
     if(d <= TYPE)
     {
      for(i = 0, d = 0; i <= 4 ; i++)
      {
       if(board[a+i][b-i] == "○" && (a + i) < BOARD_SIZE
        && (b - i) >= 0)
        d++;
       else
       {
        d = 0;
        break;
       }
       if(d == TYPE)
        {
            happyEndWhite();
            System.out.println("白方胜出！树峰欢迎你下次光临!");
            System.exit(0);
        }
      }
     }
     //斜右向下四个白子
     if(d <= TYPE)
     {
      for(i = 0, d = 0; i <= 4; i++)
      {
       if(board[a+i][b+i] == "○" && (a + i) < BOARD_SIZE
       && (b + i) < BOARD_SIZE)
        d++;
       else
       {
        d = 0;
        break;
       }
       if(d == TYPE)
        {
            happyEndWhite();
            System.out.println("白方胜出！树峰欢迎你下次光临!");
            System.exit(0);
        }
      }
     }
     //斜左向上有四个子
     if(d <= TYPE)
     {
      for(i = 0, d = 0; i <= 4; i++)
      {
       if(board[a-i][b-i] == "○" && (a - i) >= 0 && (b - i) >= 0)
        d++;
       else
       {
        d = 0;
        break;
       }
       if(d == TYPE)
        {
            happyEndWhite();
            System.out.println("白方胜出！树峰欢迎你下次光临!");
            System.exit(0);
        }
      }
     }
    } 
   
    public void happyEndBlack()
    {
        try
        {
        JOptionPane.showMessageDialog(f,"黑方：恭喜你！赢了，哈哈！");
                                    
        }catch (HeadlessException e)
        {
            e.printStackTrace();
        }                
     }
    
     public void happyEndWhite()
     {
        try
        {
        JOptionPane.showMessageDialog(f,"白方：恭喜你！赢了，哈哈！");
                                    
        }catch (HeadlessException e)
        {
            e.printStackTrace();
        }                
     } 
   
    class ChessBoard extends JPanel
    {
        //重写JPanel的paint方法,实现画
        public void paint(Graphics g)
        {
            //绘制五子棋棋盘
            g.drawImage(table, 0, 0, null);
            if(selectedX >= 0 && selectedY >= 0)
                //绘制选中点的红框
                g.drawImage(selected, selectedX * RATE + X_OFFSET,
                    selectedY * RATE + Y_OFFSET, null);
            //遍历数组,绘制棋子
            for (int i = 0; i < BOARD_SIZE; i++)
            {
                for (int j = 0; j < BOARD_SIZE; j++)
                {
                    if (board[i][j].equals("●"))
                    {
                        g.drawImage(black, i * RATE + X_OFFSET,
                         j * RATE + Y_OFFSET,  null);
                    }
                    if(board[i][j].equals("○"))
                    {
                        g.drawImage(white, i * RATE + X_OFFSET,
                         j * RATE + Y_OFFSET,  null);
                    }
                }
            }
        }
    }
   
}
自己用JAVA写的五子棋，人人对弈算法，望大家赐教！
anshufeng1988
关注
五子棋算法探讨
w9521423的博客
10-03 2143
近来随着计算机的快速发展，各种棋类游戏被纷纷请进了电脑，使得那些喜爱下棋，又常常苦于没有对手的棋迷们能随时过足棋瘾。而且这类软件个个水平颇高，大有与人脑分庭抗礼之势。其中战胜过国际象棋世界冠军-卡斯帕罗夫的“深蓝”便是最具说服力的代表；其它像围棋的“手淡”、象棋的“将族”等也以其优秀的人工智能深受棋迷喜爱；而我们今天将向大家介绍的是五子棋的算法。　　当我们与电脑对战时，您知道这些软件是怎样象人脑一
java的第一个程序——五子棋
bigfang
11-03 258
今天，终于完成了五子棋之人人大战的大部分设想，真是有点艰辛。虽然，这个程序还有很多可以改进的地方。 一、项目背景、功能说明 五子棋的棋盘规格：15*15，这里的15指的是线的条数。可以两个人对弈。界面未做大量修饰，只有“重新开始”一个按键。默认黑方为先下方。另外加了几个效果，给最后一个下的棋子做十字的标记；当鼠标移到已经下好的棋时，会显示一个不可下棋的标志；鼠标在棋盘上移动，也会有...
五子棋 人人对弈
12-15
基于opencv编写的五子棋游戏，界面美观，实现了悔棋等功能，用到vector存储数据
java五子棋开题报告
01-21
怎么运行五子棋的 怎么玩五子棋 步骤如何
人工智能-五子棋算法研究
06-02
### 人工智能与五子棋算法研究 #### 引言 人工智能作为一门综合性的前沿科学，其发展速度迅猛，尤其在博弈领域展现出了巨大的潜力。博弈，尤其是棋类游戏，被视为检验人工智能水平的重要试验场，它涉及到推理技术...
人机对战版五子棋算法研究
03-18
### 人机对战版五子棋算法研究 #### 一、引言 五子棋是一种源远流长的棋类游戏，在中国有着悠久的历史。它不仅是一种休闲娱乐活动，也是一种锻炼逻辑思维能力和策略制定能力的有效方式。近年来，随着人工智能技术...
基于博弈树的五子棋算法研究
05-11
### 基于博弈树的五子棋算法研究 #### 摘要 本文探讨了一种基于博弈树的五子棋算法。该算法在实现过程中采用了α-β剪枝法和最大最小树理论来确定最佳落子位置。然而，由于广度优先搜索导致的时间复杂度随着搜索...
基于蒙特卡洛树搜索和策略价值网络（强化学习）的AI五子棋算法设计.docx
02-25
综上所述，本文详细介绍了如何利用强化学习中的蒙特卡洛树搜索和策略价值网络来设计AI五子棋算法，展示了这一方法在游戏博弈问题上的高效性和准确性，为人工智能在棋类游戏领域的研究提供了新的思路和实践案例。
五子棋（人人和人机两种对弈模式）
02-20
基于MFC的五子棋程序，里面有人人和人机对弈模式，AI水平还不错，可以下载参考啦，里面是一个完整的工程，代码后面有足够详细的注释
五子棋的核心算法
键者天行
07-08 2046
五子棋是一种受大众广泛喜爱的游戏，其规则简单，变化多端，非常富有趣味性和消遣性。这里设计和实现了一个人机对下的五子棋程序，采用了博弈树的方法，应用了剪枝和最大最小树原理进行搜索发现最好的下子位置。介绍五子棋程序的数据结构、评分规则、胜负判断方法和搜索算法过程。 一、相关的数据结构     关于盘面情况的表示，以链表形式表示当前盘面的情况，目的是可以允许用户进行悔棋、回退等操作。     CList
五子棋AI算法的实现
tianjifou的博客
08-03 8619
五子棋五子棋是比较流行的棋类游戏了，玩法简单，基本上人人会玩，在此就不介绍游戏规则了。下面使用 swift实现五子棋这个游戏，主要实现AI算法，包括极大值极小值算法，深度搜索算法，估值函数，Alpha Beta 剪枝算法等等。
基于java的五子棋游戏的设计_基于Java的五子棋游戏的设计
weixin_31147757的博客
02-16 1213
摘要五子棋作为一个棋类竞技运动，在民间十分流行，为了熟悉五子棋规则及技巧，以及研究简单的人工智能，决定用JAVA开发五子棋游戏。主要完成了人机对战和玩家之间联网对战2个功能。网络连接部分为Socket编程应用，客户端和服务器端的交互用ClassMessage定义，有很好的可扩展性，客户端负责界面维护和收集用户输入的信息，及错误处理。服务器维护在线用户的基本信息和任意两个对战用户的棋盘信息，动...
java五子棋教程_java 简单五子棋
weixin_35919125的博客
02-21 3256
1.需求分析无论我们使用什么语言，去编写一个什么样的项目，我们的第一步，总是去分析这个项目需要满足怎样的需求。五子棋需要满足什么需求呢，首先我们要有确定打算下棋的界面，还要有实现下棋的功能，下了棋子以后还要可以进行判断输赢。之后我们就要扩展游戏的功能了，比如创建新游戏，悔棋，认输，人机对战，人人对战等等。这些功能实现后就可以完成整个五子棋程序了。2.实现步奏(1)界面构建那么，首先我们开始构建基础...
五子棋算法
thinker28754的专栏
06-09 2万+
 任何一种棋类游戏其关键是对当前棋局是否有正确的评分,评分越准确则电脑的AI越高。五子棋游戏也是如此，但在打分之前，我们先扫描整个棋盘，把每个空位从八个方向上的棋型填入数组gStyle(2, 15, 15, 8, 2)，其中第一个下标为1时表示黑棋，为2时表示白棋，第二和第三个下标表示(x,y)，第四个下标表示8个方向，最后一个下标为1时表示棋子数，为2时表示空格数，如：gStyle(1,2,
五子棋智能算法-博弈树算法思想详解（一）
热门推荐
viafcccy的博客
05-28 3万+
学习这个算法之前必会链表 关于链表看这两篇博文 https://blog.csdn.net/viafcccy/article/details/84502334 https://blog.csdn.net/viafcccy/article/details/85041942 在五子棋下棋中 我们最容易想到的算法就是对于棋局的推演 从而找到一种最佳的情况去使棋局向这个方向发展 为了简单思考...
机器学习 五子棋算法
后端学习
03-20 994
强化学习 五子棋算法 蒙特卡洛树搜索 MCTS 蒙特卡洛树搜索算法 上限置信区间算法 UCT Minimax算法与纳什均衡 alpha beta剪枝 估值函数 优化与总结 具体请点击 网址：https://blog.csdn.net/LiXenon/article/details/108858181?spm=1001.2014.3001.5501 ...
智能五子棋算法：人机博弈的探索
在人工智能领域，五子棋算法是一种重要的研究课题，它涉及到推理技术、搜索方法和决策规划等多个方面。五子棋，又称Gobang，是一种简单但策略性极强的双人对弈游戏，目标是先在棋盘上连成五子直线的一方获胜。在...
评论 3
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值