五子棋项目总结
程序员文章站
2022-06-14 10:57:51
...
[size=medium]其实上个学期接触了一点安卓，就有做人人算法的五子棋了，并且这学期开学不久做了简单的人机，但人太懒没有总结。目前主要还是在学习java版的程序，索性把java版的五子棋编出来，做个总结，也算是个交代吧。
记得熊哥说过，如果你会画布重绘，那么就能做五子棋项目了。确实如此，五子棋棋盘不就是一条一条的直线吗？而棋子的话也很简单，两种颜色的实心圆，当然高级点可以用图片代替。而这个项目的关键是五子棋的一些算法，比如判断输赢算法、悔棋实现和人机算法，我觉得人人算法这没什么，就是按顺序轮流下。 判断输赢的话也很简单，假设我们下的棋子分别是黑棋和白棋，可以定义一个静态二维数组，在黑棋下的地方赋标志1，白棋下的地方赋标志-1，当然没下的地方就是0 了。五子棋赢即同色的棋五子连珠，所以只需判断四个方向上有没有连续的1或者-1即可。而且赋标志也有好处，在重绘的时候根据标志就可以把原来下的棋子画出来了。
当然如果要悔棋的话，最后是把棋子的坐标存入自定义队列当中，这样可以实现任意步的悔棋。在安卓做的五子棋的时候，我还用队列存的棋子坐标重绘，感觉没有根据赋标志的二维数组重绘简单明了。
人机算法的话主要还是汪洋学弟教我的，那时还没有讲队列啥的。其主要方法是根据人下的棋子情况给每个没下的位置赋权值，权值越大表示该位置越危险，也是机方需要下的地方，当然这只是对人下棋子的简单防守。在网上，我找到某位大神写的防守权值表，这个应该算比较高级的了！见下图：
[img]http://dl2.iteye.com/upload/attachment/0095/2126/b3c72dce-c1fe-323e-a145-16aa0ec9e411.png[/img]
当然还可以根据电脑自己下的情况确定是否进攻，比如电脑有有三三连或者活四或者死四情况而人没有时，就可以毫不犹豫的进攻了，我后来给电脑加了进攻，但是电脑依旧很弱，大概人十几步就能搞定电脑！而高级的五子棋人机算法有待以后有时间研究！[/size]
[color=blue][size=medium]下面是我做的效果图：
初始化界面，提示需要选择菜单栏中的对战模式：
[img]http://dl2.iteye.com/upload/attachment/0095/2120/a306655f-3053-30f7-a303-4a86a7fcc0de.png[/img]
人机大战，电脑赢（白棋），可惜没有考虑选择棋子颜色的设置
[img]http://dl2.iteye.com/upload/attachment/0095/2124/39a0feda-a718-38ab-91fc-0dee0aa588ef.png[/img]
[/size][/color][size=large]下面给出了我的五子棋代码：
[color=red]首先是一些常数和静态变量的定义接口[/color]：[/size]
[color=red][size=large]然后是棋子坐标队列的棋子类：[/size][/color]public class Qizi {
public int int_x;
public int int_y;
}
[/code]
[color=red][size=large]紧接着是初始化窗口，对中间面板上的画布重绘：
再就是监听器的对象类，包含人人和人机算法：[/size][/color]
[color=red][size=medium]最后是输赢判断：[/size][/color]
[/size][/color]
[color=darkred][size=x-large]
期待下一次能做个高级的五子棋人机算法项目和网络版五子棋！[/size][/color]
记得熊哥说过，如果你会画布重绘，那么就能做五子棋项目了。确实如此，五子棋棋盘不就是一条一条的直线吗？而棋子的话也很简单，两种颜色的实心圆，当然高级点可以用图片代替。而这个项目的关键是五子棋的一些算法，比如判断输赢算法、悔棋实现和人机算法，我觉得人人算法这没什么，就是按顺序轮流下。 判断输赢的话也很简单，假设我们下的棋子分别是黑棋和白棋，可以定义一个静态二维数组，在黑棋下的地方赋标志1，白棋下的地方赋标志-1，当然没下的地方就是0 了。五子棋赢即同色的棋五子连珠，所以只需判断四个方向上有没有连续的1或者-1即可。而且赋标志也有好处，在重绘的时候根据标志就可以把原来下的棋子画出来了。
当然如果要悔棋的话，最后是把棋子的坐标存入自定义队列当中，这样可以实现任意步的悔棋。在安卓做的五子棋的时候，我还用队列存的棋子坐标重绘，感觉没有根据赋标志的二维数组重绘简单明了。
人机算法的话主要还是汪洋学弟教我的，那时还没有讲队列啥的。其主要方法是根据人下的棋子情况给每个没下的位置赋权值，权值越大表示该位置越危险，也是机方需要下的地方，当然这只是对人下棋子的简单防守。在网上，我找到某位大神写的防守权值表，这个应该算比较高级的了！见下图：
[img]http://dl2.iteye.com/upload/attachment/0095/2126/b3c72dce-c1fe-323e-a145-16aa0ec9e411.png[/img]
当然还可以根据电脑自己下的情况确定是否进攻，比如电脑有有三三连或者活四或者死四情况而人没有时，就可以毫不犹豫的进攻了，我后来给电脑加了进攻，但是电脑依旧很弱，大概人十几步就能搞定电脑！而高级的五子棋人机算法有待以后有时间研究！[/size]
[color=blue][size=medium]下面是我做的效果图：
初始化界面，提示需要选择菜单栏中的对战模式：
[img]http://dl2.iteye.com/upload/attachment/0095/2120/a306655f-3053-30f7-a303-4a86a7fcc0de.png[/img]
人机大战，电脑赢（白棋），可惜没有考虑选择棋子颜色的设置
[img]http://dl2.iteye.com/upload/attachment/0095/2124/39a0feda-a718-38ab-91fc-0dee0aa588ef.png[/img]
[/size][/color][size=large]下面给出了我的五子棋代码：
[color=red]首先是一些常数和静态变量的定义接口[/color]：[/size]
public interface Config {
public static final int X0=30;//表格左上角的起点x坐标
public static final int Y0=30;//表格左上角的起点Y坐标
public static final int ROWS=17;//横向线的条数
public static final int COLUMNS=17;//纵向线的条数
public static final int CHESS_SIZE=35;
public static final int SIZE=35;//棋盘单元格大小（默认final？？？？
public static boolean ct=false;
public static final int point[][]= new int [Config.COLUMNS][Config.ROWS];
public static List<Qizi> list_chess= new ArrayList<Qizi>();
//防守权值数组
public static final int list_quan[]={0,5,10,150,650,700,3000,9000,10000};
//进攻权值数组
public static final int list_quan_gong[]={150,650,4000,5000,30000,30000};
}
[color=red][size=large]然后是棋子坐标队列的棋子类：[/size][/color]public class Qizi {
public int int_x;
public int int_y;
}
[/code]
[color=red][size=large]紧接着是初始化窗口，对中间面板上的画布重绘：
import java.awt.BasicStroke;
import java.awt.BorderLayout;
import java.awt.Color;
import java.awt.Dimension;
import java.awt.FlowLayout;
import java.awt.Graphics;
import java.awt.Graphics2D;
import java.awt.Shape;
import java.awt.Stroke;
import java.awt.TextArea;
import java.awt.event.ActionListener;
import javax.swing.ImageIcon;
import javax.swing.JButton;
import javax.swing.JComponent;
import javax.swing.JFrame;
import javax.swing.JLabel;
import javax.swing.JMenu;
import javax.swing.JMenuBar;
import javax.swing.JMenuItem;
import javax.swing.JOptionPane;
import javax.swing.JPanel;
import javax.swing.JTextField;
import javax.swing.plaf.PanelUI;
public class Fivechess extends JFrame{
//传入背景图片
ImageIcon image_table=new ImageIcon("images/table.jpg");
Mylistener my;//创建继承动作和鼠标监听的类对象
JTextField jtf=new JTextField();//显示当前模式文本框
private String str_btn;
public String getStr(){
return this.str_btn;
}
public static void main(String[] args) {
// TODO Auto-generated method stub
Fivechess fc=new Fivechess();
fc.initUI();// 初始化界面
JOptionPane.showMessageDialog(null, "请选择对战模式，否则默认为人人对战", "Game Start", JOptionPane.INFORMATION_MESSAGE);
}
public void initUI(){
//创建窗口，设置标题，大小，位置，窗口不可改变，关闭后结束程序
this.setTitle("ZQ五子棋V1.0");
this.setSize(new Dimension(750,700));
this.setLocationRelativeTo(null);
this.setResizable(false);
this.setDefaultCloseOperation(3);
//this.setLayout(new BorderLayout());窗口默认边框布局
//新建东边面板和中间面板
JPanel centerPanel = new JPanel(){
//setOpaque(false); 设置面板透明
public void paint(Graphics g){
super.paint(g);//重写父类方法
//给画布添加背景图片
g.drawImage(image_table.getImage(), 0, 0, null);
drawTable(g);//画棋盘方法
//重绘棋子
for(int i=0;i<Config.COLUMNS;i++){
for(int j=0;j<Config.ROWS;j++){
if(Config.point[i][j]==1){
g.setColor(Color.black);
g.fillOval(Config.X0+Config.SIZE*i-Config.SIZE/2,Config.Y0+Config.SIZE*j-Config.SIZE/2,Config.SIZE,Config.SIZE);
}
else if(Config.point[i][j]==-1){
//g.setColor(JColorChooser.showDialog(null, null, Color.black));
g.setColor(Color.white);
g.fillOval(Config.X0+Config.SIZE*i-Config.SIZE/2,Config.Y0+Config.SIZE*j-Config.SIZE/2,Config.SIZE,Config.SIZE);
}
}
//最后一个索引位置
int last=Config.list_chess.size()-1;
if(last>=0){
g.setColor(Color.red);
int x=Config.list_chess.get(last).int_x;
int y=Config.list_chess.get(last).int_y;
//绝对坐标
int xx=Config.X0+Config.SIZE*x;
int yy=Config.Y0+Config.SIZE*y;
g.drawLine(xx-7, yy, xx+7, yy);
g.drawLine(xx, yy-7, xx, yy+7);
}
// //给最后一个棋子加标记
// if(Config.list_chess.size()>1){
// //如果棋子为偶数个数
// if(Config.list_chess.size()%2==0){
// g.setColor(Color.white);
// }
// else{
// g.setColor(Color.black);
// }
// }
}
}
};
// centerPanel.setOpaque(false);//设置面板透明
// ImageIcon image=new ImageIcon("image/table.jpg");
//创建监听器对象，并添加到中间面板上，这一步必须在创建东边面板上的按钮之前
my=new Mylistener(centerPanel,jtf);
centerPanel.addMouseListener(my);
//创建菜单栏
JMenuBar jmb=creatmenubar();
//将菜单工具栏添加到窗体中
this.setJMenuBar(jmb);
//创建东边面板对象
JPanel eastPanel = creatEastPanel();
//将东边面板和中间面板添加到窗体上
this.add(eastPanel, BorderLayout.EAST);
this.add(centerPanel,BorderLayout.CENTER);
//设置窗体可见
this.setVisible(true);
}
//创建菜单栏方法
public JMenuBar creatmenubar(){
//新建菜单工具栏
JMenuBar jmb=new JMenuBar();
jmb.setPreferredSize(new Dimension(0,35));
//创建JMenu菜单对象
//JMenu jm1=new JMenu("开始");
JMenu jm2=new JMenu("对战模式");
//创建两个菜单项
JMenuItem jmi_1=new JMenuItem("人人对战");
jmi_1.addActionListener(my);
JMenuItem jmi_2=new JMenuItem("人机对战");
jmi_2.addActionListener(my);
//菜单项添加到菜单对象中
jm2.add(jmi_1);
jm2.add(jmi_2);
//菜单对象添加到菜单工具栏中
//jmb.add(jm1);
jmb.add(jm2);
return (jmb);
}
//创建东边面板及其上面的按钮方法
public JPanel creatEastPanel(){
JPanel panel = new JPanel();
panel.setPreferredSize(new Dimension(120,0));
panel.setBackground(new Color(190,180,230));
panel.setLayout(null);//设置绝对布局
String [] str_btn = {"重新开始","悔棋"};
for(int i=0; i<str_btn.length; i++){
JButton button = new JButton(str_btn[i]);
//button.setPreferredSize(new Dimension(90, 35));
button.setBounds(15,100+60*i, 90, 30);
button.setActionCommand(str_btn[i]);
//给按钮添加监听器对象
button.addActionListener(my);
panel.add(button);
//panel.setLayout(new FlowLayout());//设置流式布局
JLabel jla1=new JLabel("当前模式:");
jla1.setBounds(5, 300, 80, 30);
panel.add(jla1);
jtf.setText("人人对战");
jtf.setBounds(5, 350, 80, 30);
panel.add(jtf);
}
return panel;
}
//画棋盘方法
public void drawTable(Graphics g){
g.setColor(Color.BLACK);
Graphics2D gg=(Graphics2D)g;
gg.setStroke(new BasicStroke(2F,BasicStroke.CAP_ROUND,BasicStroke.JOIN_ROUND));
//画竖线
for(int i=0;i<Config.COLUMNS;i++){
//g.getFont()
gg.drawLine(Config.X0+Config.SIZE*i , Config.Y0, Config.X0+Config.SIZE*i, Config.Y0+Config.SIZE*(Config.ROWS-1));
}
//画行线
for(int j=0;j<Config.ROWS;j++){
gg.drawLine(Config.X0, Config.Y0+Config.SIZE *j, Config.X0+Config.SIZE *(Config.COLUMNS-1), Config.Y0+Config.SIZE*j);
}
//画四个标志
//距边沿距离
int d1=Config.SIZE*3;
int d2=5;
gg.fillRect(Config.X0+d1-d2, Config.Y0+d1-d2, 2*d2, 2*d2);
gg.fillRect(Config.X0+Config.SIZE*(Config.COLUMNS-1)-d1-d2, Config.Y0+d1-d2, 2*d2, 2*d2);
gg.fillRect(Config.X0+d1-d2, Config.Y0+Config.SIZE*(Config.ROWS-1)-d1-d2, 2*d2, 2*d2);
gg.fillRect(Config.X0+Config.SIZE*(Config.COLUMNS-1)-d1-d2, Config.Y0+Config.SIZE*(Config.ROWS-1)-d1-d2, 2*d2, 2*d2);
}
}
[color=red][size=medium]再就是监听器的对象类，包含人人和人机算法：[/size][/color]
import java.awt.Color;
import java.awt.Graphics;
import java.awt.TextField;
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;
import java.awt.event.MouseAdapter;
import java.awt.event.MouseEvent;
import java.util.ArrayList;
import java.util.List;
import javax.swing.JPanel;
import javax.swing.JTextField;
public class Mylistener extends MouseAdapter implements ActionListener {
private Graphics g;
private String str_cmd;
private String mode="人人对战";//默认人人大战
private JPanel panel;
private JTextField jtf;
private boolean ct ;
private boolean over=false;//分出胜负
//用于记录棋盘每个位置的权值大小
int quanzhi[][]=new int[Config.COLUMNS][Config.ROWS];
//构造方法，传入窗体和面板
public Mylistener(JPanel panel,JTextField jtf){
this.panel=panel;
this.jtf=jtf;
}
@Override
public void actionPerformed(ActionEvent e) {
// TODO Auto-generated method stub
//得到动作按钮
str_cmd=e.getActionCommand();
if(str_cmd.equals("人人对战")||str_cmd.equals("人机对战")){
mode=str_cmd;
jtf.setText(mode);
}
//以下动作都表示重新开始
if(str_cmd.equals("重新开始")||str_cmd.equals("人人对战")||str_cmd.equals("人机对战")){
over=false;//游戏结束位初始化
Config.list_chess.clear();
for( int ii=0;ii< Config.COLUMNS;ii++){
for( int jj=0;jj<Config.ROWS;jj++){
Config.point[ii][jj]=0;
}
}
panel.repaint();
}
//人人对战的悔棋
if(mode.equals("人人对战")&&str_cmd.equals("悔棋") && Config.list_chess.size()>0){
over=false;//游戏可能刚结束，将结束标志位初始化
//悔棋的话取反ct
ct=!ct;
//得到队列最后一个棋子坐标
int x=Config.list_chess.get(Config.list_chess.size()-1).int_x;
int y=Config.list_chess.get(Config.list_chess.size()-1).int_y;
//System.out.println(x+" "+y);
//将其坐标标志设为空
Config.point[x][y]=0;
//移除队列最后元素
Config.list_chess.remove(Config.list_chess.size()-1);
//重绘
panel.repaint();
//System.out.println("已执行repaint()");
}
//人机对战的悔棋，相当于清除队列中的最后两个
if(mode.equals("人机对战")&&str_cmd.equals("悔棋") && Config.list_chess.size()>0){
//得到队列最后一个棋子坐标
int x=Config.list_chess.get(Config.list_chess.size()-1).int_x;
int y=Config.list_chess.get(Config.list_chess.size()-1).int_y;
//将其坐标标志设为空
Config.point[x][y]=0;
//移除队列最后元素
Config.list_chess.remove(Config.list_chess.size()-1);
if(over==false||(over==true&&Config.list_chess.size()%2==1)){
//得到队列最后一个棋子坐标
x=Config.list_chess.get(Config.list_chess.size()-1).int_x;
y=Config.list_chess.get(Config.list_chess.size()-1).int_y;
//将其坐标标志设为空
Config.point[x][y]=0;
//移除队列最后元素
Config.list_chess.remove(Config.list_chess.size()-1);
}
over=false;//游戏可能刚结束，将结束标志位初始化
//重绘
panel.repaint();
//System.out.println("已执行repaint()");
}
}
//鼠标监听，判断下棋
public void mouseReleased(MouseEvent e) {
//System.out.println(fc.getStr());
//得到传入面板画布
this.g=panel.getGraphics();
//得到鼠标释放处坐标
int x_point=e.getX();
int y_point=e.getY();
//转化得到棋盘上的位置
int chess_x= (x_point-Config.X0)/Config.SIZE;
int chess_y= (y_point-Config.Y0)/Config.SIZE;
if((x_point-Config.X0)%Config.SIZE>Config.SIZE/2){
chess_x++;
}
if((y_point-Config.Y0)%Config.SIZE>Config.SIZE/2){
chess_y++;
}
//当该位置没下棋子时，按顺序下好
if(over==false&&Config.point[chess_x][chess_y]==0){
//System.out.println(mode);
if(mode.equals("人人对战")){
this.renren(chess_x,chess_y);
}
else {
this.renji(chess_x,chess_y);
}
}
}
public void renren(int x,int y){
if(ct==false){
g.setColor(Color.black);
Config.point[x][y]=1;
ct=true;
}
else{
g.setColor(Color.white);
Config.point[x][y]=-1;
ct=false;
}
g.fillOval(Config.X0+Config.SIZE*x-Config.SIZE/2,Config.Y0+Config.SIZE*y-Config.SIZE/2,Config.SIZE,Config.SIZE);
//下好棋子后，保存到队列中
Qizi qizi=new Qizi();
qizi.int_x=x;
qizi.int_y=y;
Config.list_chess.add(qizi);
//并判断下完该棋子输赢情况，ct为ture时，表示刚才下的是黑棋，否则为白棋
Win_lose wl = new Win_lose(x,y,ct);
panel.repaint();
//如果分出胜负
if(wl.getresult()){
over=true;
}
}
public void renji(int x,int y){
//首先，人下好该位置
g.setColor(Color.black);
g.fillOval(Config.X0+Config.SIZE*x-Config.SIZE/2,Config.Y0+Config.SIZE*y-Config.SIZE/2,Config.SIZE,Config.SIZE);
//赋标志位
Config.point[x][y]=1;
//下好棋子后，保存到队列中
Qizi qizi=new Qizi();
qizi.int_x=x;
qizi.int_y=y;
Config.list_chess.add(qizi);
//并判断下完该棋子输赢情况，ct为ture时，表示刚才下的是黑棋，否则为白棋
Win_lose wl = new Win_lose(x,y,true);
panel.repaint();
if(wl.getresult()==false){
this.jixia();
}
else {
over=true;
}
}
//当人下完后，电脑下棋位置判断
public void jixia(){
//最大权值初始化
int quanzhi_max=0;
//权值最大的地方的坐标；
int m=0;
int n=0;
//遍历棋盘判断坐标点
for( int ii=0;ii< Config.COLUMNS;ii++){
for( int jj=0;jj<Config.ROWS;jj++){
//当棋子没下时，更新最大权值
if(Config.point[ii][jj]==0){
if(quanzhi_max<=count_quanzhi(ii,jj)){
m=ii;
n=jj;
quanzhi_max=quanzhi[ii][jj];
}
}
}
}
g.setColor(Color.white);
g.fillOval(Config.X0+Config.SIZE*m-Config.SIZE/2,Config.Y0+Config.SIZE*n-Config.SIZE/2,Config.SIZE,Config.SIZE);
Config.point[m][n]=-1;
Qizi qz=new Qizi();
qz.int_x=m;
qz.int_y=n;
Config.list_chess.add(qz);
//并判断下完该棋子输赢情况，ct为ture时，表示刚才下的是黑棋，否则为白棋
Win_lose wl = new Win_lose(m,n,false);
panel.repaint();
//如果分出胜负
if(wl.getresult()){
over=true;
}
}
public int count_quanzhi(int ii,int jj){
quanzhi[ii][jj]=0;
//**********将左右方向的权值计入总权值
//往右计数,累加权值
int num=0;
int num_gong;
for(int m=ii+1;m<Config.COLUMNS;m++){
if(Config.point[m][jj]==1){
num=num+2;
}
else if(Config.point[m][jj]==-1){
num=num-1;
if(num<0){
num=0;
}
break;
}
else break;
}
//往左计数,累加权值
for(int m=ii-1;m>0;m--){
if(Config.point[m][jj]==1){
num=num+2;
}
else if(Config.point[m][jj]==-1){
num=num-1;
if(num<0){
num=0;
}
break;
}
else break;
}
quanzhi[ii][jj]=quanzhi[ii][jj]+Config.list_quan[num];
//**********将上下方向的权值计入总权值
//往下计数,累加权值
num=0;
for(int m=jj+1;m<Config.ROWS;m++){
if(Config.point[ii][m]==1){
num=num+2;
}
else if(Config.point[ii][m]==-1){
num=num-1;
if(num<0){
num=0;
}
break;
}
else break;
}
//往上计数,累加权值
for(int m=jj-1;m>0;m--){
if(Config.point[ii][m]==1){
num=num+2;
}
else if(Config.point[ii][m]==-1){
num=num-1;
if(num<0){
num=0;
}
break;
}
else break;
}
quanzhi[ii][jj]=quanzhi[ii][jj]+Config.list_quan[num];
//**********将东北到西南方向的权值计入总权值
//往东北计数,累加权值
num=0;
for(int m=ii+1,n=jj-1;m<Config.COLUMNS&&n>0;m++,n--){
if(Config.point[m][n]==1){
num=num+2;
}
else if(Config.point[m][n]==-1){
num=num-1;
if(num<0){
num=0;
}
break;
}
else break;
}
//往西南计数,累加权值
for(int m=ii-1,n=jj+1;m>0&&n<Config.ROWS;m--,n++){
if(Config.point[m][n]==1){
num=num+2;
}
else if(Config.point[m][n]==-1){
num=num-1;
if(num<0){
num=0;
}
break;
}
else break;
}
quanzhi[ii][jj]=quanzhi[ii][jj]+Config.list_quan[num];
//**********将到东南到西北方向的权值计入总权值
//往东南计数,累加权值
num=0;
for(int m=ii+1,n=jj+1;m<Config.COLUMNS&&n<Config.ROWS;m++,n++){
if(Config.point[m][n]==1){
num=num+2;
}
else if(Config.point[m][n]==-1){
num=num-1;
if(num<0){
num=0;
}
break;
}
else break;
}
//往西南计数,累加权值
for(int m=ii-1,n=jj-1;m>0&&n>0;m--,n--){
if(Config.point[m][n]==1){
num=num+2;
}
else if(Config.point[m][n]==-1){
num=num-1;
if(num<0){
num=0;
}
break;
}
else break;
}
quanzhi[ii][jj]=quanzhi[ii][jj]+Config.list_quan[num];
//**************进攻权值判断
//往右判断攻击棋子数量，赋权值
num_gong=0;
for(int m=ii+1;m<Config.COLUMNS;m++){
if(Config.point[m][jj]==-1){
num_gong++;
}
else
break;
}
//往左判断攻击棋子数量，赋权值
for(int m=ii-1;m>0;m--){
if(Config.point[m][jj]==-1){
num_gong++;
}
else if(Config.point[m][jj]==1){
if(num_gong>=2){
quanzhi[ii][jj]=quanzhi[ii][jj]+Config.list_quan_gong[2*num_gong-4];
}
break;
}
else if(Config.point[m][jj]==0){
if(num_gong>=2){
quanzhi[ii][jj]=quanzhi[ii][jj]+Config.list_quan_gong[2*num_gong-3];
}
break;
}
}
//往下判断攻击棋子数量，赋权值
num_gong=0;
for(int m=jj+1;m<Config.ROWS;m++){
if(Config.point[ii][m]==-1){
num_gong++;
}
else if(Config.point[ii][m]==1){
// if(num_gong>=2){
// quanzhi[ii][jj]=quanzhi[ii][jj]+Config.list_quan_gong[2*num_gong-4];
// }
break;
}
else if(Config.point[ii][m]==0){
// if(num_gong>=2){
// quanzhi[ii][jj]=quanzhi[ii][jj]+Config.list_quan_gong[2*num_gong-3];
// }
break;
}
}
//往上判断攻击棋子数量，赋权值
//num_gong=0;
for(int m=jj-1;m>0;m--){
if(Config.point[ii][m]==-1){
num_gong++;
}
else if(Config.point[ii][m]==1){
if(num_gong>=2){
quanzhi[ii][jj]=quanzhi[ii][jj]+Config.list_quan_gong[2*num_gong-4];
}
break;
}
else if(Config.point[ii][m]==0){
if(num_gong>=2){
quanzhi[ii][jj]=quanzhi[ii][jj]+Config.list_quan_gong[2*num_gong-3];
}
break;
}
}
//往东南方向判断攻击棋子数量，赋权值
num_gong=0;
for(int m=ii+1,n=jj+1;m<Config.COLUMNS&&n<Config.ROWS;m++,n++){
if(Config.point[m][n]==-1){
num_gong++;
}
else if(Config.point[m][n]==1){
// if(num_gong>=2){
// quanzhi[ii][jj]=quanzhi[ii][jj]+Config.list_quan_gong[2*num_gong-4];
// }
break;
}
else if(Config.point[m][n]==0){
// if(num_gong>=2){
// quanzhi[ii][jj]=quanzhi[ii][jj]+Config.list_quan_gong[2*num_gong-3];
// }
break;
}
}
//往西北方向判断攻击棋子数量，赋权值
//num_gong=0;
for(int m=ii-1,n=jj-1;m>0&&n>0;m--,n--){
if(Config.point[m][n]==-1){
num_gong++;
}
else if(Config.point[m][n]==1){
// if(num_gong>=2){
// quanzhi[ii][jj]=quanzhi[ii][jj]+Config.list_quan_gong[2*num_gong-4];
// }
break;
}
else if(Config.point[m][n]==0){
// if(num_gong>=2){
// quanzhi[ii][jj]=quanzhi[ii][jj]+Config.list_quan_gong[2*num_gong-3];
// }
break;
}
}
//往东北向判断攻击棋子数量，赋权值
num_gong=0;
for(int m=ii+1,n=jj-1;m<Config.COLUMNS&&n>0;m++,n--){
if(Config.point[m][n]==-1){
num_gong++;
}
else if(Config.point[m][n]==1){
// if(num_gong>=2){
// quanzhi[ii][jj]=quanzhi[ii][jj]+Config.list_quan_gong[2*num_gong-4];
// }
break;
}
else if(Config.point[m][n]==0){
// if(num_gong>=2){
// quanzhi[ii][jj]=quanzhi[ii][jj]+Config.list_quan_gong[2*num_gong-3];
// }r
break;
}
}
//往西南向判断攻击棋子数量，赋权值
//num_gong=0;
for(int m=ii-1,n=jj+1;m>0&&n<Config.ROWS;m--,n++){
if(Config.point[m][n]==-1){
num_gong++;
}
else if(Config.point[m][n]==1){
if(num_gong>=2){
quanzhi[ii][jj]=quanzhi[ii][jj]+Config.list_quan_gong[2*num_gong-4];
}
break;
}
else if(Config.point[m][n]==0){
if(num_gong>=2){
quanzhi[ii][jj]=quanzhi[ii][jj]+Config.list_quan_gong[2*num_gong-3];
}
break;
}
}
return quanzhi[ii][jj];
}
}
[color=red][size=medium]最后是输赢判断：[/size][/color]
import java.awt.Dialog;
import javax.swing.JOptionPane;
public class Win_lose {
int ii,jj;
private boolean ct;
private boolean over;
public boolean getresult(){
return over;
}
public Win_lose(int ii,int jj,Boolean ct){
this.ii=ii;
this.jj=jj;
this.ct=ct;
over=false;
if(check_Row(ii,jj)>=5||check_Column(ii,jj)>=5||check_zsyx(ii,jj)>=5||check_yszx(ii,jj)>=5){
over=true;
if(ct==true){
//黑棋赢
System.out.println("黑棋胜利");
JOptionPane.showMessageDialog(null, "黑棋胜利", "Game Over", JOptionPane.INFORMATION_MESSAGE);
}
else {
//白棋赢
System.out.println("白棋胜利");
JOptionPane.showMessageDialog(null, "白棋胜利", "Game Over", JOptionPane.INFORMATION_MESSAGE);
}
}
}
//检测某个棋子水平方向的个数
public int check_Row(int x,int y){
int count=0;
//int count1=0;
//往右计数
for(int i=x+1;i<Config.COLUMNS;i++){
if(Config.point[i][y]==Config.point[x][y]){
count++;
}
else
break;
}
//往左数
for(int i=x;i>0;i--){
if(Config.point[i][y]==Config.point[x][y]){
count++;
}
else
break;
}
return count;
}
//检测某个棋子竖直的个数
public int check_Column(int x,int y){
int count=0;
//往下计数
for(int i=y+1;i<Config.ROWS;i++){
if(Config.point[x][i]==Config.point[x][y]){
count++;
}
else
break;
}
//往上计数
for(int i=y;i>0;i--){
if(Config.point[x][i]==Config.point[x][y]){
count++;
}
else
break;
}
return count;
}
//检测某个棋子左上到右下方向的个数
public int check_zsyx(int x,int y){
int count=0;
//往东南计数
for(int i=x+1,j=y+1;i<Config.COLUMNS&&j<Config.ROWS;i++,j++){
if(Config.point[i][j]==Config.point[x][y]){
count++;
}
else
break;
}
//往西北计数
for(int i=x,j=y;i>=0&&j>=0;i--,j--){
if(Config.point[i][j]==Config.point[x][y]){
count++;
}
else
break;
}
return count;
}
//检测某个棋子右上到左下方向的个数
public int check_yszx(int x,int y){
int count=0;
//往东北计数
for(int i=x+1,j=y-1;i<Config.COLUMNS&&j>0;i++,j--){
if(Config.point[i][j]==Config.point[x][y]){
count++;
}
else
break;
}
//往西南计数
for(int i=x,j=y;i>0&&j<Config.ROWS;i--,j++){
if(Config.point[i][j]==Config.point[x][y]){
count++;
}
else
break;
}
return count;
}
}
[/size][/color]
[color=darkred][size=x-large]
期待下一次能做个高级的五子棋人机算法项目和网络版五子棋！[/size][/color]