沉沦的夏天
- 浏览: 10579 次
- 性别:
-
文章分类
其实上个学期接触了一点安卓，就有做人人算法的五子棋了，并且这学期开学不久做了简单的人机，但人太懒没有总结。目前主要还是在学习java版的程序，索性把java版的五子棋编出来，做个总结，也算是个交代吧。
记得熊哥说过，如果你会画布重绘，那么就能做五子棋项目了。确实如此，五子棋棋盘不就是一条一条的直线吗？而棋子的话也很简单，两种颜色的实心圆，当然高级点可以用图片代替。而这个项目的关键是五子棋的一些算法，比如判断输赢算法、悔棋实现和人机算法，我觉得人人算法这没什么，就是按顺序轮流下。 判断输赢的话也很简单，假设我们下的棋子分别是黑棋和白棋，可以定义一个静态二维数组，在黑棋下的地方赋标志1，白棋下的地方赋标志-1，当然没下的地方就是0 了。五子棋赢即同色的棋五子连珠，所以只需判断四个方向上有没有连续的1或者-1即可。而且赋标志也有好处，在重绘的时候根据标志就可以把原来下的棋子画出来了。
当然如果要悔棋的话，最后是把棋子的坐标存入自定义队列当中，这样可以实现任意步的悔棋。在安卓做的五子棋的时候，我还用队列存的棋子坐标重绘，感觉没有根据赋标志的二维数组重绘简单明了。
人机算法的话主要还是汪洋学弟教我的，那时还没有讲队列啥的。其主要方法是根据人下的棋子情况给每个没下的位置赋权值，权值越大表示该位置越危险，也是机方需要下的地方，当然这只是对人下棋子的简单防守。在网上，我找到某位大神写的防守权值表，这个应该算比较高级的了！见下图：
当然还可以根据电脑自己下的情况确定是否进攻，比如电脑有有三三连或者活四或者死四情况而人没有时，就可以毫不犹豫的进攻了，我后来给电脑加了进攻，但是电脑依旧很弱，大概人十几步就能搞定电脑！而高级的五子棋人机算法有待以后有时间研究！
下面是我做的效果图：
初始化界面，提示需要选择菜单栏中的对战模式：
人机大战，电脑赢（白棋），可惜没有考虑选择棋子颜色的设置
下面给出了我的五子棋代码：
首先是一些常数和静态变量的定义接口：
[color=red][size=large]紧接着是初始化窗口，对中间面板上的画布重绘：
再就是监听器的对象类，包含人人和人机算法：[/size][/color]
最后是输赢判断：
[/size][/color]
期待下一次能做个高级的五子棋人机算法项目和网络版五子棋！
记得熊哥说过，如果你会画布重绘，那么就能做五子棋项目了。确实如此，五子棋棋盘不就是一条一条的直线吗？而棋子的话也很简单，两种颜色的实心圆，当然高级点可以用图片代替。而这个项目的关键是五子棋的一些算法，比如判断输赢算法、悔棋实现和人机算法，我觉得人人算法这没什么，就是按顺序轮流下。 判断输赢的话也很简单，假设我们下的棋子分别是黑棋和白棋，可以定义一个静态二维数组，在黑棋下的地方赋标志1，白棋下的地方赋标志-1，当然没下的地方就是0 了。五子棋赢即同色的棋五子连珠，所以只需判断四个方向上有没有连续的1或者-1即可。而且赋标志也有好处，在重绘的时候根据标志就可以把原来下的棋子画出来了。
当然如果要悔棋的话，最后是把棋子的坐标存入自定义队列当中，这样可以实现任意步的悔棋。在安卓做的五子棋的时候，我还用队列存的棋子坐标重绘，感觉没有根据赋标志的二维数组重绘简单明了。
人机算法的话主要还是汪洋学弟教我的，那时还没有讲队列啥的。其主要方法是根据人下的棋子情况给每个没下的位置赋权值，权值越大表示该位置越危险，也是机方需要下的地方，当然这只是对人下棋子的简单防守。在网上，我找到某位大神写的防守权值表，这个应该算比较高级的了！见下图：
当然还可以根据电脑自己下的情况确定是否进攻，比如电脑有有三三连或者活四或者死四情况而人没有时，就可以毫不犹豫的进攻了，我后来给电脑加了进攻，但是电脑依旧很弱，大概人十几步就能搞定电脑！而高级的五子棋人机算法有待以后有时间研究！
下面是我做的效果图：
初始化界面，提示需要选择菜单栏中的对战模式：
人机大战，电脑赢（白棋），可惜没有考虑选择棋子颜色的设置
下面给出了我的五子棋代码：
首先是一些常数和静态变量的定义接口：
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;
}
[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];
}
}
最后是输赢判断：
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]
期待下一次能做个高级的五子棋人机算法项目和网络版五子棋！
1
顶
顶
0
踩
踩
分享到：
发表评论
-
分形小结
2014-03-22 16:23 670简单的说就是部分与整体以某种方式相似的形体，具有三个特性 1. ... -
哈夫曼编码小结
2014-03-22 15:50 2127哈夫曼树 哈夫曼树是一最优二叉树，假设有n个字节点Tn{T1 ... -
链表小结
2014-03-22 15:44 670链表 1.链表一种物理存储单元上非连续，非顺序的存储结构，但它 ... -
集合框架小结
2014-03-22 15:18 500集合框架 主要学习了java.util.*包下的三大接口。 ... -
数组小结
2014-02-27 12:20 748数组是一种在内存中连续分布的数据结构，很方便存储和取 ... -
重绘应用
2014-02-27 11:16 468一、重绘的原因即概念： 绘制的东西，只记录在缓存中，没有保存 ... -
参数传递及画板小结
2013-12-08 21:42 526参数传递总结： 一、. ... -
接口和抽象类以及事件机制
2013-12-05 15:20 819一.接口 1.接口的定义 定义接口的关键字：interfa ... -
类的继承
2013-12-01 19:11 509<b>1</b>.继承的格式 pub ... -
基本数据类型及string常用的方法举例
2013-11-25 22:20 644java的数据类型分为基本数据类型和对象数据类型两大类； 基本 ... -
类和对象的总结
2013-11-19 10:55 460类和对象的理解：现实世界并没有类的存在，存在的只有一个个的对象 ... -
类和对象，构造方法的学习总结
2013-11-19 10:50 0类和对象的理解：现 ...
相关推荐
【标题】基于JAVA的升级版五子棋项目总结（PPT版） 在Java编程领域，五子棋项目是一个常见的教学实例，它可以帮助开发者巩固基础知识，理解面向对象编程、图形用户界面设计以及游戏逻辑的实现。这个升级版的五子棋...
这些是编写任何Java程序的基础，对于构建五子棋项目至关重要。 其次，五子棋项目的实现需要使用到面向对象编程思想。我们可以创建一个`ChessBoard`类来表示棋盘，它包含二维数组来存储棋子的状态；创建`Player`类来...
【五子棋项目详解】 五子棋是一种深受人们喜爱的双人对弈策略游戏，它简单易学，但深入研究却能发现丰富的战术变化。在本文中，我们将深入探讨一个基于WinForm平台的五子棋项目，这为编程爱好者提供了一个良好的...
【手机Java五子棋项目详解】 手机Java五子棋项目是一种基于J2ME（Java 2 Micro Edition）技术实现的移动设备游戏应用。J2ME是Java平台的一个子集，专为资源有限的嵌入式设备如手机、PDA等设计，具有跨平台的特性，...
【Java五子棋实习报告】主要探讨了使用Java编程语言设计和实现五子棋游戏的过程，包括人机对战和玩家间的联网对战功能。在报告中，作者详细阐述了五子棋游戏的背景和历史，以及选择Java作为开发语言的原因。Java因其...
在本项目中，我们关注的是一个基于Linux的嵌入式五子棋游戏，它特别针对6818开发板设计。这个项目的核心是利用Linux操作系统的能力，在嵌入式硬件平台上实现一个可玩的五子棋游戏，允许玩家与计算机进行对弈。下面将...
五子棋与其他三大棋类（围棋、中国象棋、国际象棋）的主要区别在于它没有“吃子”的概念，而是强调通过连续放置己方棋子以形成特定的排列来获胜，这种机制使得五子棋更加侧重于发展与限制的策略思想。 #### 算法...
1. Python基础：五子棋项目的实现首先依赖于Python的基础语法，包括变量声明、数据类型（如整型、字符串、列表等）、条件语句（if-else）、循环结构（for、while）、函数定义和调用等。 2. 面向对象编程（OOP）：...
总结来说，这个项目提供了一个用MATLAB实现的五子棋游戏，其中的核心是五子棋的算法，包括棋盘状态的管理、合法落子的判断以及胜负的自动检测。通过GUI，用户可以直观地进行游戏，体验到与计算机或其他玩家的对弈。...
本文档是关于大学本科课程实训的一个项目，是用c语言写的一个关于五子棋的实训报告，并且可视化
总结来说，MFC五子棋程序是一个很好的学习实例，它涵盖了MFC的基本使用、图形绘制、事件处理、对象封装和算法设计等多个方面，对于提升C++和MFC编程能力大有裨益。通过阅读源代码和课设PPT，不仅可以了解MFC的具体...
总结来说，"基于Qt的五子棋代码"项目展示了如何利用Qt库构建一个具有图形界面、游戏逻辑、网络通信等功能的五子棋游戏。开发者可以通过这个项目学习到GUI编程、游戏规则的编程实现、网络编程以及C++和Qt的综合运用。
总结，这个五子棋项目不仅涵盖了游戏规则的编程实现，还涉及到界面设计、算法策略、平台适配、代码结构优化等多个IT领域的知识点。对于想要学习游戏开发或者提高编程技能的同学们来说，这是一个绝佳的学习实践机会。...
总结来说，C#结合GDI+技术为我们提供了一个实现五子棋游戏的高效平台。通过理解并运用这些知识点，不仅可以开发出一个功能完善的五子棋应用，也能提升对图形绘制、游戏逻辑和用户交互的理解。无论你是编程新手还是...
总的来说，这款Java五子棋游戏设计项目旨在通过编程实现一个具有互动性和趣味性的五子棋应用，让玩家在享受游戏乐趣的同时，也能锻炼策略思维。通过这个项目，学生可以深入理解Java编程、MVC模式以及游戏逻辑的设计...
总结来说，这份实验报告详细阐述了一个C语言实现的五子棋游戏，涉及了图形界面开发、人机对战的AI算法实现，以及游戏设计的基本流程。通过这样的课程设计，学生不仅能深入理解C语言，还能接触到游戏编程领域的前沿...
总结起来，"QT实现的五子棋"项目涉及了以下几个主要知识点： 1. QT5框架：理解和使用QT5的类库，如QWidget、QGraphicsView、QGraphicsScene等。 2. 人机对战的AI设计：理解并实现搜索算法，如Minimax和Alpha-beta...
6. **项目总结与反思**：总结项目完成过程中遇到的问题、解决方法，以及对自身编程能力的提升。 7. **未来改进方向**：提出可能的改进点，比如增强AI的智能程度，添加网络对战功能，或者优化用户界面等。 通过这个...