关键词:
游戏介绍
五子棋是全国智力运动会竞技项目之一,是一种两人对弈的纯策略型棋类游戏。
五子棋有两种玩法。玩法一:双方分别使用黑白两色的棋子,下在棋盘直线与横线的交叉点上,先形成五子连线者获胜。玩法二:自己形成五子连线就替换对方任意一枚棋子。被替换的棋子可以和对方交换棋子。最后以先出完所有棋子的一方为胜。
五子棋的棋具与围棋通用,是一种传统的棋种。
五子棋容易上手,老少皆宜,而且趣味横生,引人入胜:它不仅能增强思维能力,提高智力,而且富含哲理,有助于修身养性。
游戏规则
(1)对局双方各执一色棋子。
(2)空棋盘开局。
(3)黑先、白后,交替下子,每次只能下一子。
(4)棋子下在棋盘的空白点上,棋子下定后,不得向其它点移动,不得从棋盘上拿掉或拿起另落别处。
(5)黑方的第一枚棋子必须下在天元点上,即中心交叉点
(6)轮流下子是双方的权利,但允许任何一方放弃下子权(即:PASS权)。
五子棋对局,执行黑方指定开局、三手可交换、五手两打的规定。整个对局过程中黑方有禁手,白方无禁手。黑方禁手有三三禁手、四四禁手和长连禁手三种。
项目结构
项目代码
启动类代码
import javax.swing.*;
import java.awt.*;
import java.awt.event.*;
@SuppressWarnings("serial")
public class ChessMap extends JFrame
private ImageIcon map; //棋盘背景位图
private ImageIcon blackchess; //黑子位图
private ImageIcon whitechess; //白子位图
private ChessPanel cp; //棋盘
private JPanel east;
private JPanel west;
private static final int FINAL_WIDTH = 450;
private static final int FINAL_HEIGHT = 500;
//以下为下拉菜单
private JMenuBar menubar;
private JMenu[] menu=new JMenu("开始"),new JMenu("设置"),new JMenu("帮助");
private JMenuItem[] menuitem1=new JMenuItem("重新开始"),new JMenuItem("悔棋"),new JMenuItem("退出");
private JMenuItem[] menuitem2=new JMenuItem("禁手选择"),new JMenuItem("人机博弈"),new JMenuItem("人人对弈");
private JMenuItem[] menuitem3=new JMenuItem("规则"),new JMenuItem("关于");
private boolean haveai=true; //人与人下还是人与电脑下,true与电脑下
Mouseclicked mouseclicked=new Mouseclicked();
MouseMoved mousemoved=new MouseMoved();
Menuitemclicked menuclicked=new Menuitemclicked();
//构造函数
public ChessMap()
//改变系统默认字体
Font font = new Font("Dialog", Font.PLAIN, 12);
java.util.Enumeration keys = UIManager.getDefaults().keys();
while (keys.hasMoreElements())
Object key = keys.nextElement();
Object value = UIManager.get(key);
if (value instanceof javax.swing.plaf.FontUIResource)
UIManager.put(key, font);
setTitle("五子棋 ");
setSize(FINAL_WIDTH,FINAL_HEIGHT);
setResizable(false);
init();
setLocation(Toolkit.getDefaultToolkit().getScreenSize().width / 2
- FINAL_WIDTH / 2, Toolkit.getDefaultToolkit()
.getScreenSize().height
/ 2 - FINAL_HEIGHT / 2);
setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
cp.reset();
setVisible(true);
//初始化与默认值
public void init()
map=new ImageIcon(getClass().getResource("img/bg.jpg"));
blackchess=new ImageIcon(getClass().getResource("img/blackchess.gif"));
whitechess=new ImageIcon(getClass().getResource("img/whitechess.gif"));
cp=new ChessPanel(map,blackchess,whitechess);
menubar=new JMenuBar();
menuitem1[0].setActionCommand("Restart");
menuitem1[1].setActionCommand("Rollback");
menuitem1[2].setActionCommand("Exit");
menuitem2[0].setActionCommand("Forbid");
menuitem2[1].setActionCommand("Robot");
menuitem2[2].setActionCommand("Human");
menuitem3[0].setActionCommand("Rule");
menuitem3[1].setActionCommand("About");
for(int i=0;i<3;i++)
menu[0].add(menuitem1[i]);
for(int i=0;i<3;i++)
menu[1].add(menuitem2[i]);
for(int i=0;i<2;i++)
menu[2].add(menuitem3[i]);
for(int i=0;i<3;i++)
menubar.add(menu[i]);
Container p = getContentPane();
setJMenuBar(menubar);
east = new JPanel();
west = new JPanel();
p.add(east, "East");
p.add(west, "West");
p.add(cp, "Center");
cp.addMouseListener(mouseclicked);
cp.addMouseMotionListener(mousemoved);
menuitem1[0].addActionListener(menuclicked);
menuitem1[1].addActionListener(menuclicked);
menuitem1[2].addActionListener(menuclicked);
menuitem2[0].addActionListener(menuclicked);
menuitem2[1].addActionListener(menuclicked);
menuitem2[2].addActionListener(menuclicked);
menuitem3[0].addActionListener(menuclicked);
menuitem3[1].addActionListener(menuclicked);
class Mouseclicked extends MouseAdapter //判断鼠标左击并通知棋盘和电脑
public void mouseClicked(MouseEvent e)
if(cp.win==false)
if(haveai) //和电脑博弈
Point p1=new Point();
p1=cp.getPoint(e.getX(),e.getY());
int x=p1.x;
int y=p1.y;
// 如果该位置已经放置棋子
System.out.println("x="+x+",y="+y);
if (cp.isChessOn[x][y] != 2)
return;
// 玩家为黑棋,考虑禁手
if( cp.able_flag && cp.bw == 0)
int type = cp.getType(x,y,cp.bw);
String str = null;
switch(type)
case 20:
str = "黑长连禁手!请选择其它位置下棋!";
break;
case 21:
str = "黑四四禁手!请选择其它位置下棋!";
break;
case 22:
str = "黑三三禁手!请选择其它位置下棋!";
break;
default : break;
if(str != null)
JOptionPane.showMessageDialog(null,str);
return;
boolean flag=cp.haveWin(x, y, cp.bw);
cp.update( x, y );
cp.putVoice(); //落子声音
// 第一步棋,需初始化设置边界值
if( cp.chess_num == 1)
if(x-1>=0)
cp.x_min = x-1;
if(x-1<=15)
cp.x_max = x+1;
if(y-1>=0)
cp.y_min = y-1;
if(y-1<=15)
cp.y_max = y+1;
else
cp.resetMaxMin(x,y);
if (flag)
cp.wined(1 - cp.bw);
return;
cp.putOne(cp.bw);
else //和人博弈
Point p1=new Point();
p1=cp.getPoint(e.getX(),e.getY());
int x=p1.x;
int y=p1.y;
// 如果该位置已经放置棋子
System.out.println("x="+x+",y="+y);
if (cp.isChessOn[x][y] != 2)
return;
// 玩家为黑棋,考虑禁手
if( cp.able_flag && cp.bw == 0)
int type = cp.getType(x,y,cp.bw);
String str = null;
switch(type)
case 20:
str = "黑长连禁手!请选择其它位置下棋!";
break;
case 21:
str = "黑四四禁手!请选择其它位置下棋!";
break;
case 22:
str = "黑三三禁手!请选择其它位置下棋!";
break;
default : break;
if(str != null)
JOptionPane.showMessageDialog(null,str);
return;
boolean flag=cp.haveWin(x, y, cp.bw);
cp.update( x, y );
cp.putVoice(); //落子声音
cp.repaint();
// 第一步棋,需初始化设置边界值
if( cp.chess_num == 1)
if(x-1>=0)
cp.x_min = x-1;
if(x-1<=15)
cp.x_max = x+1;
if(y-1>=0)
cp.y_min = y-1;
if(y-1<=15)
cp.y_max = y+1;
else
cp.resetMaxMin(x,y);
if (flag)
cp.wined(1 - cp.bw);
return;
class MouseMoved implements MouseMotionListener //调试用,获得鼠标位置
public void mouseMoved(MouseEvent e)
cp.showMousePos(e.getPoint());
public void mouseDragged(MouseEvent e)
class Menuitemclicked implements ActionListener //菜单消息处理
public void actionPerformed(ActionEvent e)
JMenuItem target = (JMenuItem)e.getSource();
String actionCommand = target.getActionCommand();
if(actionCommand.equals("Restart")) //重开一局
cp.reset();
if(cp.sbw==cp.WHITE_ONE)
cp.update(7, 7);
//player=cp.BLACK_ONE;
if(actionCommand.equals("Rollback")) //悔棋
if(cp.win)
JOptionPane.showMessageDialog(null,"棋局已经结束,不能悔棋!请重新开始新的棋局!");
return;
// 当前轮到玩家下棋,取消两步 否则,取消一步
if(cp.chess_num >= 2 && cp.bw == cp.sbw)
cp.isChessOn[cp.pre[cp.chess_num-1][0]][cp.pre[cp.chess_num-1][1]] = 2;
cp.isChessOn[cp.pre[cp.chess_num-2][0]][cp.pre[cp.chess_num-2][1]] = 2;
cp.chess_num -= 2;
cp.repaint();
else if(cp.chess_num >= 1 && cp.bw == 1-cp.sbw)
cp.isChessOn[cp.pre[cp.chess_num-1][0]][cp.pre[cp.chess_num-1][1]] = 2;
cp.chess_num --;
cp.repaint();
else if(actionCommand.equals("Exit")) //退出
System.exit(1);
else if(actionCommand.equals("Forbid")) //禁手选择
Object[] options = "无禁手", "有禁手" ;
int sel = JOptionPane.showOptionDialog(
null, "你的选择:", "禁手选择",
JOptionPane.DEFAULT_OPTION,
JOptionPane.QUESTION_MESSAGE, null,
options, options[0]);
if(sel==1)
cp.able_flag=true;
System.out.println("有禁手");
else
cp.able_flag=false;
System.out.println("无禁手");
else if(actionCommand.equals("Robot")) //人机博弈
haveai=true;
Object[] options = "人类先手", "机器先手" ;
int sel = JOptionPane.showOptionDialog(
null, "你的选择:", "先手选择",
JOptionPane.DEFAULT_OPTION,
JOptionPane.QUESTION_MESSAGE, null,
options, options[0]);
if(sel==1) //机器先手
cp.sbw=cp.WHITE_ONE;
cp.update(7, 7);
System.out.println("机器先手");
else //人先手
//player=cp.BLACK_ONE;
cp.sbw=cp.BLACK_ONE;
System.out.println("人先手");
else if(actionCommand.equals("Human")) //人人博弈
haveai=false;
cp.setHumanhuman(true);
else if(actionCommand.equals("Rule")) //规则
JOptionPane.showConfirmDialog(null,
"1、无禁手:" +"\\n"+
" 黑白双方依次落子,任一方先在棋盘上形成连续的五个(含五个以上)棋子的一方为胜。" +"\\n"+
"2、有禁手:(走禁手就输,禁手不能落子)" +"\\n"+
" 鉴于无禁手规则黑棋必胜,人们不断采用一些方法限制黑棋先行的优势,以平衡黑白双方的形式。" +"\\n"+
" 于是针对黑棋的各种禁手逐渐形成。" +"\\n"+
" 禁手主要分为以下几类:" +"\\n"+
" (1)黑长连禁手:连成六个以上连续相同的棋子。" +"\\n"+
" (2)黑三三禁手:两个以上的活三。" + "\\n"+
" (3)黑四四禁手:两个以上的四。" + "\\n"+
" 禁手是针对黑棋而言的,白棋没有任何禁手。" ,"规则",JOptionPane.CLOSED_OPTION,JOptionPane.INFORMATION_MESSAGE);
else if(actionCommand.equals("About")) //版权与帮助
JOptionPane.showConfirmDialog(null,"团队成员:\\n" +
"陈江涛 07061229\\n" +
"夏军 07061225\\n" +
"李盘龙 07061230\\n" +
"郝云焘 07061207\\n","关于",JOptionPane.CLOSED_OPTION,JOptionPane.INFORMATION_MESSAGE);
public static void main(String[] args)
new ChessMap();
排序工具类
import java.util.Comparator;
/**
* 排序 Comparator
*/
class ArrComparator implements Comparator<Object>
int column = 2;
int sortOrder = -1; // 递减
public ArrComparator()
public int compare(Object a, Object b)
if (a instanceof int[])
return sortOrder * (((int[]) a)[column] - ((int[]) b)[column]);
throw new IllegalArgumentException("param a,b must int[].");
五子棋逻辑类
import javax.swing.*;
import java.applet.AudioClip;
import java.awt.*;
import java.net.URL;
import java.util.Arrays;
import java.util.Random;
@SuppressWarnings("serial")
public class ChessPanel extends JPanel
private ImageIcon map; //棋盘背景位图
private ImageIcon blackchess; //黑子位图
private ImageIcon whitechess; //白子位图
public int isChessOn [][]; //棋局
protected boolean win = false; // 是否已经分出胜负
protected int win_bw; // 胜利棋色
protected int deep = 3, weight = 7; // 搜索的深度以及广度
public int drawn_num = 110; // 和棋步数
int chess_num = 0; // 总落子数目
public int[][] pre = new int[drawn_num + 1][2]; // 记录下棋点的x,y坐标 最多 (drawn_num + 1) 个
public int sbw = 0; //玩家棋色黑色0,白色1
public int bw = 0; // 当前应该下的棋色 0:黑色(默认), 1:白色
// 边界值,用于速度优化
protected int x_max = 15, x_min = 0;
protected int y_max = 15, y_min = 0;
protected boolean able_flag = true; // 是否选择禁手标志 0:无禁手 1:有禁手(默认
private int h; //棋子长
private int w; //棋子宽
private int insx; //插入棋子的位置
private int insy;
private Point mousePoint; //鼠标当前位置
private int winer; //获胜方
private boolean humanhuman=false; //是否是人人对弈
private int plast=0; //走了几步了,
public int BLACK_ONE; //0表黑子
public int WHITE_ONE; //1表白子
public int NONE_ONE; //2表无子
public int N; //棋盘边长
//-------声音
String[] choics = "wav/put.wav", "wav/win.wav", "wav/lost.wav"; //声音文件名数组
URL file1 = getClass().getResource(choics[0]); //落子声音文件
URL file2 = getClass().getResource(choics[1]); //获胜声音文件
URL file3 = getClass().getResource(choics[2]); //失败声音文件
AudioClip soundPut = java.applet.Applet.newAudioClip(file1); //落子声音剪辑对象
AudioClip soundWin = java.applet.Applet.newAudioClip(file2); //获胜声音剪辑对象
AudioClip soundLost = java.applet.Applet.newAudioClip(file3); //失败声音剪辑对象
public ChessPanel(ImageIcon r_map,ImageIcon r_blackchess,ImageIcon r_whitechess)
N=15;
map=new ImageIcon();
blackchess=new ImageIcon();
whitechess=new ImageIcon();
map=r_map;
blackchess=r_blackchess;
whitechess=r_whitechess;
NONE_ONE=2;
BLACK_ONE=0;
WHITE_ONE=1;
winer=NONE_ONE;
isChessOn=new int[N][N];
h=blackchess.getIconHeight()*(N-1);
w=blackchess.getIconWidth()*(N-1);
insx=0;
insy=0;
mousePoint=new Point();
public void reset() //重开一局
winer=NONE_ONE;
for(int i=0;i<N;i++)
for(int j=0;j<N;j++)
isChessOn[i][j]=NONE_ONE;
chess_num = 0;
win = false;
win_bw=2;
bw = 0;
x_max = 15; x_min = 0;
y_max = 15;y_min = 0;
repaint();
public void showMousePos(Point p) //调试用,显示鼠标位置
int cw;
cw=h/N;
mousePoint.x=p.x/cw;
mousePoint.y=p.y/cw;
repaint();
public Point getPoint(int x,int y)
int cw;
insx=x;
insy=y;
cw=h/N;
Point r=new Point(x/cw,y/cw);
return r;
public void gameOver(int r_winer) //游戏胜负已分
winer=r_winer;
public void paint(Graphics g) //整体布局
super.paint(g);
paintChessMap(g);
paintChess(g);
if(winer==BLACK_ONE)
g.drawString(new String("游戏结束!黑棋获胜!"),500,200);
else if(winer==WHITE_ONE)
g.drawString(new String("游戏结束!白棋获胜!"),500,200);
private void paintChessMap(Graphics g) //画棋盘
map.paintIcon(this,g,10,10);
int j;
g.setColor(Color.BLACK);
for(j=0;j<N;j++) //画线
g.drawLine(h/N/2,h/N*j+h/N/2,w-w/N+(N%2)*(h/N/2),h/N*j+h/N/2);
g.drawLine(w/N*j+h/N/2,h/N/2,w/N*j+h/N/2,h-h/N+(N%2)*(h/N/2));
g.fillRect(w/N*7+h/N/2-3,h/N*7+h/N/2-3,6,6);//画5个黑方块
g.fillRect(w/N*3+h/N/2-3,h/N*3+h/N/2-3,6,6);
g.fillRect(w/N*11+h/N/2-3,h/N*3+h/N/2-3,6,6);
g.fillRect(w/N*3+h/N/2-3,h/N*11+h/N/2-3,6,6);
g.fillRect(w/N*11+h/N/2-3,h/N*11+h/N/2-3,6,6);
private void paintChess(Graphics g) //画棋子
int i,j;
for(i=0;i<N;i++)
for(j=0;j<N;j++)
if(isChessOn[i][j]==BLACK_ONE)
blackchess.paintIcon(this,g,w/N*i,h/N*j);
else if(isChessOn[i][j]==WHITE_ONE)
whitechess.paintIcon(this,g,w/N*i,h/N*j);
//-------------------------------下棋声音设置-------------------------------------------------
//落子声音
public void putVoice()
soundPut.play();
//获胜声音
public void winVoice()
soundWin.play();
//失败声音
public void lostVoice()
soundLost.play();
//----------------------电脑下棋-------------------------------//
public void putOne(int bwf ) //bwf 棋色 0:黑色 1:白色
int x, y, mx = -100000000;
x = y = -1;
// 搜索最优下棋点
int[][] bests = getBests( bwf );
for (int k = 0; k < bests.length; k++)
int i = bests[k][0];
int j = bests[k][1];
// 有成5,则直接下子,并退出循环..没有,则思考对方情况
if (getType(i, j, bwf) == 1)
x = i;
y = j;
break;
if (getType(i, j,1 - bwf) == 1)
x = i;
y = j;
break;
// 预存当前边界值
int temp1=x_min,temp2=x_max,temp3=y_min,temp4=y_max;
// 预设己方下棋,并更新边界值
isChessOn[i][j] = bwf;
resetMaxMin(i,j);
// 预测未来
int t = findMin(-100000000, 100000000, deep);
// 还原预设下棋位置以及边界值
isChessOn[i][j] = 2;
x_min=temp1;
x_max=temp2;
y_min=temp3;
y_max=temp4;
// 差距小于1000,50%概率随机选取
//System.out.println("外 :" + i + "," + j + " mx:" + mx + " t:" + t);
if (t - mx > 1000 || Math.abs(t - mx)<1000 && randomTest(3))
x = i;
y = j;
mx = t;
//System.out.println(i + "," + j + " mx:" + mx + " t:" + t);
System.out.println("x="+x+",y="+y);
// addChess(x,y,(bwf+1)%2,true);
// repaint();
int step=0;
step++;
System.out.println("step "+step+":-----------------------------------------------");
for(int i=0;i<15;i++,System.out.print("\\n"))
for(int j=0;j<15;j++)
if(isChessOn[j][i]!=2)System.out.print(isChessOn[j][i]);
else System.out.print(isChessOn[j][i]);
// 判断是否已分胜负
boolean flag = haveWin(x, y, bwf);
//记录
update( x, y );
repaint();
// 重设边界值
resetMaxMin(x,y);
// 胜负已分
if (flag)
wined(bwf);
if (!flag && chess_num >= drawn_num)
win = true;
String str = drawn_num + "步没分胜负,判和棋!";
JOptionPane.showMessageDialog(null,str);
return;
//---------搜索当前搜索状态极大值--------------------------------//
//alpha 祖先节点得到的当前最小最大值,用于alpha 剪枝
//beta 祖先节点得到的当前最大最小值,用于beta 剪枝。
//step 还要搜索的步数
//return 当前搜索子树极大值
protected int findMax(int alpha, int beta, int step)
int max = alpha;
if (step == 0)
return evaluate();
int[][] rt = getBests(1 - sbw);
for (int i = 0; i < rt.length; i++)
int x = rt[i][0];
int y = rt[i][1];
if (getType(x, y, 1 - sbw) == 1) //电脑可取胜
return 100 * ( getMark(1) + step*1000 );
isChessOn[x][y] = 1 - sbw;
// 预存当前边界值
int temp1=x_min,temp2=x_max,temp3=y_min,temp4=y_max;
resetMaxMin(x,y);
int t = findMin(max, beta, step - 1);
isChessOn[x][y] = 2;
// 还原预设边界值
x_min=temp1;
x_max=temp2;
y_min=temp3;
y_max=temp4;
if (t > max)
max = t;
//beta 剪枝
if (max >= beta)
return max;
return max;
//-----------------------搜索当前搜索状态极小值---------------------------------//
//alpha 祖先节点得到的当前最小最大值,用于alpha 剪枝
//beta 祖先节点得到的当前最大最小值,用于beta 剪枝
//step 还要搜索的步数
//return 当前搜索子树极小值。
protected int findMin(int alpha, int beta, int step)
int min = beta;
if (step == 0)
return evaluate();
int[][] rt = getBests(sbw);
for (int i = 0; i < rt.length; i++)
int x = rt[i][0];
int y = rt[i][1];
int type = getType(x, y, sbw);
if (type == 1) //玩家成5
return -100 * ( getMark(1) + step*1000 );
// 预存当前边界值
int temp1=x_min,temp2=x_max,temp3=y_min,temp4=y_max;
isChessOn[x][y] = sbw;
resetMaxMin(x,y);
int t = findMax( alpha, min, step - 1 );
isChessOn[x][y] = 2;
// 还原预设边界值
x_min=temp1;
x_max=temp2;
y_min=temp3;
y_max=temp4;
if (t < min)
min = t;
//alpha 剪枝
if (min <= alpha)
return min;
return min;
//-----------------选取局部最优的几个落子点作为下一次扩展的节点---------//
//bwf 棋色 0:黑棋 1:白棋
//return 选出来的节点坐标
private int[][] getBests(int bwf)
int i_min=(x_min==0 ? x_min:x_min-1);
int j_min=(y_min==0 ? y_min:y_min-1);
int i_max=(x_max==15 ? x_max:x_max+1);
int j_max=(y_max==15 ? y_max:y_max+1);
int n = 0;
int type_1,type_2;
int[][] rt = new int[(i_max-i_min) * (j_max-j_min)][3];
for ( int i = i_min; i < i_max; i++)
for (int j = j_min; j < j_max; j++)
if (isChessOn[i][j] == 2)
type_1 = getType(i, j, bwf);
type_2 = getType(i, j, 1 - bwf);
if(able_flag && bwf==0 && (type_1 == 20 || type_1 == 21 || type_1 == 22)) // 禁手棋位置,不记录
continue;
rt[n][0] = i;
rt[n][1] = j;
rt[n][2] = getMark(type_1) + getMark(type_2);
n++;
// 对二维数组排序
Arrays.sort(rt, new ArrComparator());
int size = weight > n? n:weight;
int[][] bests = new int[size][3];
System.arraycopy(rt, 0, bests, 0, size);
return bests;
//----------------------------计算指定方位上的棋型-------------------//
// x,y 方向线基准一点。
//ex,ey 指定方向步进向量。
// k 棋子颜色,0:黑色,1:白色
// 该方向上的棋子数目 以及 活度
private int[] count(int x, int y, int ex, int ey, int bwf)
// 该方向没意义,返回0
if( !makesense(x, y, ex, ey, bwf))
return new int[] 0, 1;
// 正方向 以及 反方向棋子个数
int rt_1 = 1,rt_2 = 1;
// 总棋子个数
int rt = 1;
// 正方向 以及 反方向连子的活度
int ok_1 = 0,ok_2 =0;
// 总活度
int ok = 0;
// 连子中间有无空格
boolean flag_mid1 =false,flag_mid2 = false;
// 连子中间空格的位置
int flag_i1 = 1,flag_i2 = 1;
if (isChessOn[x][y] != 2)
throw new IllegalArgumentException("position x,y must be empty!..");
int i;
// 往正方向搜索
for (i = 1; x + i * ex < 15 && x + i * ex >= 0 && y + i * ey < 15 && y + i * ey >= 0; i++)
if (isChessOn[x + i * ex][y + i * ey] == bwf)
rt_1++;
// 位置为空,若中空标志为false,则记为中空并继续搜索 否则,break
else if(isChessOn[x + i * ex][y + i * ey] == 2)
if(!flag_mid1)
flag_mid1 = true;
flag_i1 = i;
else
break;
// 位置为对方棋子
else
break;
// 计算正方向活度,,
// 最后一个位置不超过边界
if (x + i * ex < 15 && x + i * ex >= 0 && y + i * ey < 15 && y + i * ey >= 0)
// 最后一个位置为空位 +1活
if( isChessOn[x + i * ex][y + i * ey] == 2)
ok_1++;
// 若是在尾部检测到连续的空格而退出搜索,则不算有中空
if(rt_1 == flag_i1)
flag_mid1 = false;
// 若中空的位置在4以下 且 棋子数>=4,则这一边的4非活
if(flag_mid1 && rt_1 > 3 && flag_i1 < 4)
ok_1--;
// 最后一个位置不是空格,且搜索了2步以上,若前一个是空格, 则不算中空,且为活的边
else if( isChessOn[x + i * ex][y + i * ey] != bwf && i >= 2)
if(isChessOn[x + (i-1) * ex][y + (i-1) * ey] == 2)
ok_1++;
flag_mid1 = false;
// 最后一个位置是边界 搜索了2步以上,且前一个是空格, 则不算中空,且为活的边
else if(i >= 2 && isChessOn[x + (i-1) * ex][y + (i-1) * ey] == 2)
ok_1++;
flag_mid1 = false;
// 往反方向搜索
for (i = 1; x - i * ex >= 0 && x - i * ex < 15 && y - i * ey >= 0 && y - i * ey < 15; i++)
if (isChessOn[x - i * ex][y - i * ey] == bwf)
rt_2++;
else if(isChessOn[x - i * ex][y - i * ey] == 2)
if(!flag_mid2)
flag_mid2 = true;
flag_i2 = i;
else
break;
else
break;
// 计算反方向活度
if (x - i * ex < 15 && x - i * ex >= 0 && y - i * ey < 15 && y - i * ey >= 0)
if( isChessOn[x - i * ex][y - i * ey] == 2)
ok_2++;
if(rt_2 == flag_i2)
flag_mid2 = false;
if(flag_mid2 && rt_2 > 3 && flag_i2 < 4)
ok_2--;
else if( isChessOn[x - i * ex][y - i * ey] != bwf && i >= 2 )
if(isChessOn[x - (i-1) * ex][y - (i-1) * ey] == 2)
ok_2++;
flag_mid2 = false;
else if(i >= 2 && isChessOn[x - (i-1) * ex][y - (i-1) * ey] == 2)
ok_2++;
flag_mid2 = false;
//------------------分析棋子类型
// 两边都没中空,直接合成
if( !flag_mid1 && !flag_mid2 )
rt = rt_1 + rt_2 - 1;
ok = ok_1 + ok_2;
return new int[] rt, ok;
// 两边都有中空
else if( flag_mid1 && flag_mid2 )
int temp = flag_i1 + flag_i2 - 1;
// 判断中间的纯连子数,在5以上,直接返回; 为4,返回活4;
if(temp >= 5)
return new int[] temp, 2;
if(temp == 4)
return new int[] temp, 2;
// 先看有没死4,再看有没活3,剩下只能是死3
if(rt_1 + flag_i2 - 1 >= 4 || rt_2 + flag_i1 - 1 >= 4)
return new int[] 4, 1;
if(rt_1+flag_i2-1 == 3 && ok_1 > 0 || rt_2+flag_i1-1 == 3 && ok_2 > 0)
return new int[] 3, 2;
return new int[] 3, 1;
// 有一边有中空
else
// 总棋子数少于5,直接合成
if( rt_1 + rt_2 - 1 < 5 )
return new int[] rt_1 + rt_2 - 1, ok_1 + ok_2;
// 多于5,先找成5,再找活4,剩下的只能是死4
else
if(flag_mid1 && rt_2 + flag_i1 - 1 >= 5)
return new int[] rt_2 + flag_i1 - 1, ok_2 + 1;
if(flag_mid2 && rt_1 + flag_i2 - 1 >= 5)
return new int[] rt_1 + flag_i2 - 1, ok_1 + 1;
if(flag_mid1 && (rt_2 + flag_i1 - 1 == 4 && ok_2 == 1 || flag_i1 == 4) )
return new int[] 4, 2;
if(flag_mid2 && (rt_1 + flag_i2 - 1 == 4 && ok_1 == 1 || flag_i2 == 4) )
return new int[] 4, 2;
return new int[] 4, 1;
//----------------------------判断指定方向下棋是否有意义,即最大可能的棋子数是否 >=5-------------------------------//
// x,y 评估的基准点
// ex,ey 方向向量
// k 棋色
// true:有意义 false:没意义
private Boolean makesense(int x, int y, int ex, int ey, int bwf)
int rt = 1;
for (int i = 1; x + i * ex < 15 && x + i * ex >= 0 && y + i * ey < 15 && y + i * ey >= 0 && rt < 5; i++)
if (isChessOn[x + i * ex][y + i * ey] != 1 - bwf)
rt++;
else
break;
for (int i = 1; x - i * ex >= 0 && x - i * ex < 15 && y - i * ey >= 0 && y - i * ey < 15 && rt < 5; i++)
if (isChessOn[x - i * ex][y - i * ey] != 1 - bwf)
rt++;
else
break;
return (rt >= 5);
//------------------------------------ 棋型判别-------------------------------------//
// x,y 落子位置
// bwf 棋色 0:黑子,1:白子
// 对应的棋型: 棋型代码对应如下:
// 1:成5
// 2:成活4或者是双死4或者是死4活3
// 3:成双活3
// 4:成死3活3
// 5:成死4
// 6:单活3
// 7:成双活2
// 8:成死3
// 9:成死2活2
// 10:成活2
// 11:成死2
// 12: 其他
// 20: 长连禁手
// 21: 双四禁手
// 22: 双活三禁手
protected int getType(int x, int y, int bwf)
if (isChessOn[x][y] != 2)
return -1;
int[][] types = new int[4][2];
types[0] = count(x, y, 0, 1, bwf); // 竖直
types[1] = count(x, y, 1, 0, bwf); // 横向
types[2] = count(x, y, -1, 1, bwf); // 斜上
types[3] = count(x, y, 1, 1, bwf); // 斜下
// 各种棋型的方向的数目
int longfive = 0;
int five_OR_more = 0;
int four_died = 0, four_live = 0;
int three_died = 0, three_live = 0;
int two_died = 0, two_live = 0;
// 各方向上棋型的判别
for (int k = 0; k < 4; k++)
if (types[k][0] > 5)
longfive++; // 长连
five_OR_more++;
else if (types[k][0] == 5)
five_OR_more++; // 成5
else if (types[k][0] == 4 && types[k][1] == 2)
four_live++; // 活4
else if (types[k][0] == 4 && types[k][1] != 2)
four_died++; // 死4
else if (types[k][0] == 3 && types[k][1] == 2)
three_live ++; // 活3
else if (types[k][0] == 3 && types[k][1] != 2)
three_died++; // 死3
else if (types[k][0] == 2 && types[k][1] == 2)
two_live++; // 活2
else if (types[k][0] == 2 && types[k][1] != 2)
two_died++; // 死2
else
;
// 总棋型的判别
if(bwf == 0 && able_flag) // 黑棋且选择有禁手
if (longfive != 0) // 长连禁手
return 20;
if (four_live + four_died >=2) // 双4禁手
return 21;
if (three_live >=2) // 双活三禁手
return 22;
if (five_OR_more != 0)
return 1; // 成5
if (four_live != 0 || four_died >= 2 || four_died != 0 && three_live != 0)
return 2; // 成活4或者是双死4或者是死4活3
if (three_live >= 2)
return 3; // 成双活3
if (three_died != 0 && three_live != 0)
return 4; // 成死3活3
if (four_died != 0)
return 5; // 成死4
if (three_live != 0)
return 6; // 单活3
if (two_live >= 2)
return 7; // 成双活2
if (three_died != 0)
return 8; // 成死3
if (two_live != 0 && two_died != 0)
return 9; // 成死2活2
if (two_live != 0)
return 10; // 成活2
if (two_died != 0)
return 11; // 成死2
return 12;
//--------------------------对当前棋面进行打分------------------------------------------------------------//
protected int evaluate()
int rt = 0, mt_c = 1, mt_m = 1;
if(bw == sbw)
mt_m = 2;
else
mt_c = 2;
int i_min=(x_min==0 ? x_min:x_min-1);
int j_min=(y_min==0 ? y_min:y_min-1);
int i_max=(x_max==15 ? x_max:x_max+1);
int j_max=(y_max==15 ? y_max:y_max+1);
for (int i = i_min; i < i_max; i++)
for (int j = j_min; j < j_max; j++)
if (isChessOn[i][j] == 2)
// 电脑棋面分数
int type = getType(i, j, 1 - sbw );
if(type == 1) // 棋型1,棋型2以及棋型3,加权. 防止"4个双活3"的局分大于"1个双四"之类的错误出现
rt += 30 * mt_c * getMark(type);
else if(type == 2)
rt += 10 * mt_c * getMark(type);
else if(type == 3)
rt += 3 * mt_c * getMark(type);
else
rt += mt_c * getMark(type);
// 玩家棋面分数
type = getType(i, j, sbw );
if(type == 1)
rt -= 30 * mt_m * getMark(type);
else if(type == 2)
rt -= 10 * mt_m * getMark(type);
else if(type == 3)
rt -= 3 * mt_m * getMark(type);
else
rt -= mt_m * getMark(type);
return rt;
//--------------------------------下棋后,更新信息-----------------------------//
void update(int x,int y)
isChessOn[x][y] = bw;
bw = 1 - bw;
pre[chess_num][0] = x;
pre[chess_num][1] = y;
chess_num++;
//-------------------------------------- 下棋后,重设边界值------------------------------//
// x 当前下棋位置的x坐标
// y 当前下棋位置的y坐标
public void resetMaxMin(int x,int y)
if(x-1>=0)
x_min = (x_min<x-1 ? x_min:x-1);
if(x+1<=15)
x_max = (x_max>x+1 ? x_max:x+1);
if(y-1>=0)
y_min = (y_min<y-1 ? y_min:y-1);
if(y+1<=15)
y_max = (y_max>y+1 ? y_max:y+1);
//------------------------------------------对分数相同的落子点,随机选取-------------------//
// kt 随机因子 值越小,被选取的概率越大
// return 是否选择该位置
private boolean randomTest(int kt)
Random rm = new Random();
return rm.nextInt() % kt == 0;
//------------------------------------- 不同棋型对应分数---------------------------------
// k 棋型代号
//return 对应分数
private int getMark(int k)
switch (k)
case 1:
return 100000;
case 2:
return 30000;
case 3:
return 5000;
case 4:
return 1000;
case 5:
return 500;
case 6:
return 200;
case 7:
return 100;
case 8:
return 50;
case 9:
return 10;
case 10:
return 5;
case 11:
return 3;
case 12:
return 2;
default: //禁手棋型
return 0;
//--------------------------------------- 判断是否已分出胜负---------------------------------------------
// x 落子点x坐标 y 落子点y坐标
// bwf 棋色 0:黑色 1:白色
// return true:分出胜负 false:未分出胜负
public boolean haveWin(int x, int y, int bwf)
boolean flag = false;
if (count(x, y, 1, 0, bwf)[0] >= 5)
flag = true;
if (!flag && count(x, y, 0, 1, bwf)[0] >= 5)
flag = true;
if (!flag && count(x, y, 1, 0, bwf)[0] >= 5)
flag = true;
if (!flag && count(x, y, 1, -1, bwf)[0] >= 5)
flag = true;
if (!flag && count(x, y, 1, 1, bwf)[0] >= 5)
flag = true;
// 测试用,激活此行代码,不会有输赢.. flag = false;
return flag;
public void wined(int bw)
boolean hh=getHumanhuman();
if(!hh) //不是人人对弈
win = true;
win_bw = bw;
String str = (bw == sbw ? "恭喜!你赢了!" : "电脑赢了,你还要继续努力啊!");
if(bw==sbw)
winVoice();
else
lostVoice();
JOptionPane.showMessageDialog(null,str);
else //人人对弈
win = true;
win_bw = bw;
String str = (bw == BLACK_ONE ? "恭喜!黑棋获胜!" : "恭喜!白棋获胜!");
winVoice();
JOptionPane.showMessageDialog(null,str);
public void setHumanhuman(boolean humanhuman)
this.humanhuman = humanhuman;
public boolean getHumanhuman()
return humanhuman;
游戏截图
游戏源码和游戏素材下载地址
cocos2d-x小试牛刀五子连珠游戏
Cocos2d-x小试牛刀五子连珠游戏声明:本文游戏使用的是cocos2d-x-3.13的代码 游戏介绍本文将介绍有Cocos编写经典游戏,五子连珠。游戏规则,有一个10*10的棋盘,里面有六种颜色的珠子,点击棋盘的珠子可以移动到任意有开放路... 查看详情
linux实现五子棋(人人对战)(代码片段)
分步解析对于game函数的解析playermove——用户落子isover——判定四种情况chessout——求特定方向的连珠数使用全局变量xy的原因showboard——数组内容可视化完整代码1.game.c#include"game.h"intx=0;inty=0;voidmenu()printf("****************... 查看详情
使用pygame实现一个简单的五子棋游戏(代码片段)
前言写程序已经丢掉很长一段时间了,最近觉得完全把技术丢掉可能是个死路,还是应该捡起来,所以打算借CSDN来记录学习过程,由于以前没事的时候断断续续学习过python和用flask框架写过点web,所以第一步想捡起python,但是,... 查看详情
c语言实现简单的三子棋(代码片段)
...Tic-Tac-Toe,是一种在3*3格子上进行的连珠游戏,和五子棋类似,由于棋盘一般不画边框,格线排成井字故得名。游戏需要的工具仅为纸和笔, 查看详情
c语言——五子棋游戏(代码片段)
...、作者遇到的坑点十、完整的代码一、前言本文将先介绍五子棋运行所需要的函数,最后串联成完整代码。我们需要实现的功能有:1.菜单menu函数 2.初始化棋盘I 查看详情
python小游戏五子棋小游戏设计与实现(代码片段)
...个今年(2022)最新完成的毕业设计项目作品python小游戏毕设五子棋小游戏设计与实现(源码)🥇学长根据实现的难度和等级对项目进行评分(最低0分,满分5分)难度系数:3分工作量:3分创新点:4分1游戏介绍基于pyt... 查看详情
java实现三子棋小游戏(代码片段)
...#前言之前在学习C语言的时候,做过一个三子棋的小游戏,最近开始学习Java,就想着能不能用Java再把之前的练习重新实现一边,既然有这个想法了,那就开始行动啦~。再写的过程中 查看详情
五子棋(机器人随机下棋简单版本)(代码片段)
相信大家小时候都玩过五子棋游戏,五子棋是起源于中国古代的传统黑白棋之一,在一块类似围棋的棋盘上,你和对手轮流放下黑白棋子,无论是横竖还是斜。只要有五颗相同颜色的棋子连成一线即可获得一句胜... 查看详情
ai人机对战五子棋游戏python(pygame)+ai并实现软件输出(代码片段)
...是很清楚的可以参考文章点击这里目录1.系统架构分析1.1五子棋的基本棋型1.2功能模块2.具体实现2.1设置基础参数2.2绘制棋盘2.3编写函数intoNextTurn()2.4编写函数getLocate()2.5编写函数getIdex()2.6编写函数isInside()2.7编写函数isEmpty()2.8编写... 查看详情
2018.10.4二连爆搜+再次出锅
T1:五子棋【题目描述】五子棋是世界智力运动会竞技项目之一,是一种两人对弈的纯策略型棋类游戏。通常双方分别使用黑白两色的棋子,下在棋盘直线与横线的交叉点上,先形成五子连珠者获胜。五子连珠是在横线,纵线,... 查看详情
java项目开发----五子棋(代码片段)
java项目开发(一)----五子棋项目(一)------五子棋开发思路五子棋的要素两个用户黑白棋子棋盘游戏的几个界面---登录、模式选择、胜负弹窗、游戏界面游戏规则游戏窗口的创建创建窗口对象窗口创建思路代码... 查看详情
项目实战轻松实现c/c++大作业:五子棋游戏(代码片段)
...个C语言小项目,提升你的编程能力! 基于EasyX的五子棋软件。算法部分想了很久,也参考了网上的其他游戏的。原理主要就是:遍历每个空闲的点,根据下在那个点后连成的棋形来判断其分值,再选出分... 查看详情
java五子棋游戏——控制台版(代码片段)
该项目为Java编程语言编写的五子棋游戏(控制台版),用到二维数组、for循环、if语句、while()语句、ScannerUntil包,此项目主要是对数组的使用。该项目的功能有落子、输出棋盘、判断输赢。代码条:packageedu.qizi.ga... 查看详情
《游戏学习》java实现潜艇大战游戏源码(代码片段)
项目目录项目代码启动类SubmarineWarMain代码packagecom.stj.views;importjava.util.Observable;publicclassSubmarineWarMain publicstaticvoidmain(String[]args) Observableob=newFrameObservable(); MyFramemf= 查看详情
《游戏学习》java实现潜艇大战游戏源码(代码片段)
项目目录项目代码启动类SubmarineWarMain代码packagecom.stj.views;importjava.util.Observable;publicclassSubmarineWarMain publicstaticvoidmain(String[]args) Observableob=newFrameObservable(); MyFramemf= 查看详情
基于javaswing五子棋小游戏设计和实现(代码片段)
订阅专栏获取源码前言: 五子棋相传起源于四千多年前的尧帝时期,比围棋的历史还要悠久,可能早在“尧造围棋”之前,民间就已有五子棋游戏。有关早期五子棋的文史资料与围棋有相似之处,... 查看详情
基于javaswing五子棋小游戏设计和实现(代码片段)
订阅专栏获取源码前言: 五子棋相传起源于四千多年前的尧帝时期,比围棋的历史还要悠久,可能早在“尧造围棋”之前,民间就已有五子棋游戏。有关早期五子棋的文史资料与围棋有相似之处,... 查看详情
java五子棋(人机版),昨天买的棋子今天就用不上了(代码片段)
Java五子棋,老程序员也花了3天作者简介作者名:编程界明世隐简介:CSDN博客专家,从事软件开发多年,精通Java、JavaScript,博主也是从零开始一步步把学习成长、深知学习和积累的重要性,喜欢跟广... 查看详情