【java】java swing：五子棋人机对弈

最新推荐文章于 2022-03-29 19:35:10 发布
最新推荐文章于 2022-03-29 19:35:10 发布
阅读量1.1k 收藏 6
点赞数 1
分类专栏： java 文章标签： 五子棋 java swing
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/Li_Jiaqian/article/details/71170359
版权

最近学习java swing，将上次的人机五子棋做了改进，将其界面化，在调试过程中还发现了上次代码中的一些问题。


问题一：无法应对A落在自己左上方的棋子

问题二：计算机不能应对落在边界的棋子，不能应对单个棋子

（即，对于代码中的k值，若该方向上无法再落子，则应该放弃这个k值最大的一串棋子）
1.大体结构：


2.完整的，又臭又长的代码： 
package vaniot.com;
import java.awt.Color;
import java.awt.Dimension;
import java.awt.Graphics;
import java.awt.Toolkit;
import java.awt.event.MouseAdapter;
import java.awt.event.MouseEvent;
import javax.swing.JFrame;
import javax.swing.JOptionPane;
import javax.swing.JPanel;
public class WuZiQi3 extends JPanel{
	public WuZiQi3(){
		
	}
	//窗口
	public void init(JFrame frame,int formWidth,int formHeight){
        //设置当前窗体可见,默认不可见
        frame.setVisible(true);
        //设置当前窗体的宽和高
        frame.setSize(formWidth+14, formHeight+35);
        frame.setTitle("五子棋人机对弈");
        Dimension dim = Toolkit.getDefaultToolkit().getScreenSize();
        //通过Dimension类的对象dim可以获取到屏幕的宽和高
        int screenWidth = dim.width;
        int screenHeight = dim.height;
        System.out.println("当前屏幕的分辨率为:"+screenWidth+"*"+screenHeight); 
        int x = (screenWidth-formWidth)/2;
        int y = (screenHeight-formHeight)/2;;
        //设置当前窗体出现在窗口中坐标位置,即x轴的坐标值和y轴的坐标值
        frame.setLocation(x, y);
        frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
    }
	public static void main(String[] args) {
		// TODO Auto-generated method stub
		JFrame frame=new JFrame();
		WuZiQi3 wzq=new WuZiQi3();		
		wzq.init(frame,800,600);
		WuZiQi3 qp=new WuZiQi3();
		//初始化棋盘
		qp.initQiPan();
		
		qp.positionOfMouse(frame);
		
		//qp.playGame(frame);
		frame.add(qp);
	}
	private static final long serialVersionUID = 1L;
	int flagB=0;
	int ii=0;int jj=0;//鼠标点击的坐标
	int ss=0;int tt=0;//计算机上一步落子位置	
    public int[][] Qipan1=new int[Y_HEIGHT][X_WIDTH];
    public int[][] Qipan2=new int[Y_HEIGHT][X_WIDTH];
    public int[][] Qipan3=new int[Y_HEIGHT][X_WIDTH];
    public int[][] Qipan4=new int[Y_HEIGHT][X_WIDTH];    
	//假定对应的宽度为40列,对应的是横轴的坐标x
	public static final int X_WIDTH = 40;//假定对应的高度为30列,对应的是纵轴的坐标y
	public static final int Y_HEIGHT = 30;
	//定义一个30*40二维数组 ,表示有30行40列,其中行对应的是y轴的坐标值,列对应的是x轴的坐标值
	int[][] QiPan = new int[Y_HEIGHT][X_WIDTH];
	//初始化棋盘
	void initQiPan(){
		for(int i=0;i
     
     
      
      =0)&&(QiPan[I][J-1]==0)){
								//向右被占用，向左没有被占用且没到边边上
								QiPan[I][J-1]=2;
								ss=I;tt=J-1;
							}
							else{//A向左被占用或到边边上，再搜寻自己的‘#’
								computerPlayer();
							}
							//这里与上篇有调整-------------------------
							//纠正了原程序中玩家A落子在A上一步的左方，而计算机不落子的错误
						}
						else if(J-1>=0){//向右到边界了，再向左看是否有位置
							if(QiPan[I][J-1]==0){//向左没有被占用
								QiPan[I][J-1]=2;
								ss=I;tt=J-1;
							}
							else{//A向左被占用，再搜寻自己的‘#’
								computerPlayer();
							}
						}
						else{//向左也到边界或者向左被占用，搜寻自己的‘#’或就近任意落子
							computerPlayer();
						}
					}
					else if(flag[2]==2){// ↓
						if(I+flag[4]<30){//向下没有到边边上
							if(QiPan[I+flag[4]][J]==0){
								QiPan[I+flag[4]][J]=2;
								ss=I+flag[4];tt=J;//记录计算机这一步落在哪里
							}
							else if((I-1>=0)&&(QiPan[I-1][J]==0)){
								//向下已被占用，向上未到边界且未被占用
								QiPan[I-1][J]=2;
								ss=I-1;tt=J;
							}
							else{
								computerPlayer();
							}
						}
						else if(I-1>=0){//向下到边界了，再向上看是否有位置
							if(QiPan[I-1][J]==0){//向左没有被占用
								QiPan[I-1][J]=2;
								ss=I-1;tt=J;		
							}
							else{//A向上被占用，再搜寻自己的‘#’
								computerPlayer();
							}
						}
						else{//向上也到边界或者向上被占用，搜寻自己的‘#’或就近任意落子
							computerPlayer();
						}
					}
					else if(flag[2]==3){// ↙
						if((I+flag[4]<30)&&(J-flag[4]>=0)){//向左下没有到边边上
							if(QiPan[I+flag[4]][J-flag[4]]==0){//左下没有被占用
								QiPan[I+flag[4]][J-flag[4]]=2;
								ss=I+flag[4];tt=J-flag[4];//记录计算机这一步落在哪里
							}
							else if((QiPan[I-1][J+1]==0)&&(I-1>=0)&&(J+1<40)){
								//左下已被占用，右上没到边边上且没有被占用
								QiPan[I-1][J+1]=2;
								ss=I-1;tt=J+1;	
							}
							else{//右上到边边上或被占用
								computerPlayer();
							}
						}
						else if((I-1>=0)&&(J+1<40)){//向左下到边界了，向右上没有到边界
							if(QiPan[I-1][J+1]==0){//向右上没有被占用
								QiPan[I-1][J+1]=2;
								ss=I-1;tt=J+1;	
							}
							else{//A向右上被占用，再搜寻自己的
								computerPlayer();
							}
						}
						else{//向右上也到边界或者向右上被占用，搜寻自己的‘#’或就近任意落子
							computerPlayer();
						}
					}
					else if(flag[2]==4){// ↘
						if((I+flag[4]<30)&&(J+flag[4]<40)){//向右下没有到边边上
							if(QiPan[I+flag[4]][J+flag[4]]==0){//右下没有被占用
								QiPan[I+flag[4]][J+flag[4]]=2;
								ss=I+flag[4];tt=J+flag[4];//记录计算机这一步落在哪里
							}
							else if((QiPan[I-1][J-1]==0)&&(I-1>=0)&&(J-1>=0)){
								//右下已被占用，左下没到边边上且没有被占用
								QiPan[I-1][J-1]=2;
								ss=I-1;tt=J-1;
							}
							//这里与上篇有调整-------------------------
							//纠正了原程序中玩家A落子在A上一步的右上方，而计算机不落子的错误
							else{//右下已被占用，左下到边边上或被占用
								computerPlayer();//搜寻自己的k最大值
							}
						}
						else if((I-1>=0)&&(J-1>=0)){//向右下到边界了，再向左上看是否有位置
							if(QiPan[I-1][J-1]==0){//向左上没有被占用
								QiPan[I-1][J-1]=2;
								ss=I-1;tt=J-1;	
							}
							else{//A向右上被占用，再搜寻自己的‘#’
								computerPlayer();
							}
							//这里与上篇有调整-------------------------
							//纠正了原程序中玩家A落子在A上一步的左上方，而计算机不落子的错误
						}
						else{//向右上也到边界或者向右上被占用，搜寻自己的‘#’或就近任意落子
							computerPlayer();
						}
					}
					repaint();//落子完毕，更新棋盘
					flag=scanner(ss,tt);//重新计算棋盘布局
					if(flag[3]==1){
						repaint();
						String message="计算机胜出！";
	                    JOptionPane.showMessageDialog(qipan, message);
	                    System.exit(0);
					}
					flagB=1;
				}
			}
		});
	}   
    public void computerPlayer(){
    	//A的k值最大处都已经落子，此时，寻找计算机自己的k最大值
    	int[] flag={0,0,0,0,0};	
    	flag=scanner(ss,tt);//计算机上一步落子处
    	int I=flag[0];
    	int J=flag[1];//(I,J)处，k值最大
		if(flag[2]==1){
			if((J+flag[4]<40)&&(QiPan[I][J+flag[4]]==0)){//向右没有到边边上，且没有被占用
				QiPan[I][J+flag[4]]=2;//计算机向右落子
				ss=I;tt=J+flag[4];
			}
			else if(J-1>=0){//向右到边边上或者向右被占用，向左没有到边边上
				if(QiPan[I][J-1]==0){//向左没有被占用
					QiPan[I][J-1]=2;
					ss=I;tt=J-1;
				}
				else{//向左被占用了，就近随机落子
					for(int i=0;i<30-I;i++){
						for(int j=0;j<40-J;j++){
							if(QiPan[I+i][J+j]==0){
								QiPan[I+i][J+j]=2;
								j=40-J;i=30-I;//跳出循环
							}
						}
					}
				}
			}
		}
		else if(flag[2]==2){
			if((I+flag[4]<30)&&(QiPan[I+flag[4]][J]==0)){//向下没有到边边上，且没有被占用
				QiPan[I+flag[4]][J]=2;
				ss=I+flag[4];tt=J;
			}
			else if(I-1>=0){//向下到边界或被占用，向上没有到边界
				if(QiPan[I-1][J]==0){
					QiPan[I-1][J]=2;
					ss=I-1;tt=J;
				}
				else{//向上被占用了，就近随机落子
					for(int i=0;i<30-I;i++){
						for(int j=0;j<40-J;j++){
							if(QiPan[I+i][J+j]==0){
								QiPan[I+i][J+j]=2;
								j=40-J;i=30-I;//跳出循环
							}
						}
					}
				}
			}
		}
		else if(flag[2]==3){
			if((I+flag[4]<30)&&(J-flag[4]>=0)){//向左下没有到边边上
				QiPan[I+flag[4]][J-flag[4]]=2;
				ss=I+flag[4];tt=J-flag[4];
			}
			else if((I-1>=0)&&(J+1<40)){//向右上没有到边边上
				if(QiPan[I-1][J+1]==0){
					QiPan[I-1][J+1]=2;
					ss=I-1;tt=J+1;
				}
				else{//向右上被占用了，就近随机落子
					for(int i=0;i<30-I;i++){
						for(int j=0;j<40-J;j++){
							if(QiPan[I+i][J+j]==0){
								QiPan[I+i][J+j]=2;
								j=40-J;i=30-I;//跳出循环
							}
						}
					}
				}
			}
		}
		else if(flag[2]==4){
			if((I+flag[4]<30)&&(J+flag[4]<40)&&(QiPan[I+flag[4]][J+flag[4]]==0)){
				//向右下没有到边边上且没有被占用
				QiPan[I+flag[4]][J+flag[4]]=2;
				ss=I+flag[4];tt=J+flag[4];
			}
			else if((I-1>=0)&&(J-1>=0)){
				//向右下到边界或者被占用，向左上没有到边界
				if(QiPan[I-1][J-1]==0){
					QiPan[I-1][J-1]=2;
					ss=I-1;tt=J-1;
				}
				else{//向左上被占用了，就近随机落子
					for(int i=0;i<30-I;i++){
						for(int j=0;j<40-J;j++){
							if(QiPan[I+i][J+j]==0){
								QiPan[I+i][J+j]=2;
								j=40-J;i=30-I;//跳出循环
							}
						}
					}
				}
			}
		}
    }
    //scanner较上篇有调整-------------------------
    //在找寻k值最大的点的同时，需要考察该方向上是否还有落子位置
    //若没有，则放弃这个k值最大点
    public int[] scanner(int iii,int jjj){
		//每落一子，扫描全盘，看是否有连成功的
		int[] m=new int[5];//返回k值最大的坐标、方向以及是否连成5子、相应坐标的k值
		//从(0,0)开始，先向右扫描
		int flag0=0;
		for(int i=0;i<30;i++){
			for(int j=0;j<40;j++){//不越界的情况下作比较
				int k=1;
				int k0=0;
				while(k0==0){//k=4时，成功
					if(j+k<40){
						if((QiPan[i][j]==QiPan[i][j+k])&&(QiPan[i][j]!=0)){
							k++;
					    }
						else k0=1;	
					}
					else break;
				}
				if(k==5){
					flag0=1;//成功左右连成5子
				}
				if(j+k<40){//右没有到边界
					if(QiPan[i][j+k]==0){//右有位置，可以
						Qipan1[i][j]=k;
					}
					else if(j-1>=0){//右没有到边界，但是向右被占用，左没有到边界
						if(QiPan[i][j-1]==0){//左有位置，可以
							Qipan1[i][j]=k;
						}
						else Qipan1[i][j]=0;//左也被占用，放弃该位置，改点k值记为0
					}
					else Qipan1[i][j]=0;//左到边界，放弃该位置
				}
				else{//右到边界
					if(j-1>=0){//左没有到边界
						if(QiPan[i][j-1]==0){//左有位置，可以
							Qipan1[i][j]=k;
						}
						else Qipan1[i][j]=0;//左被占用，放弃该位置
					}
					else Qipan1[i][j]=0;//左也到边界，放弃该位置				
				}
			}
		}

		//向下扫描
		for(int j=0;j<40;j++){
			for(int i=0;i<30;i++){
				int k=1;
				int k0=0;
				while(k0==0){//k=4时，成功
					if(i+k<30){
						if((QiPan[i][j]==QiPan[i+k][j])&&(QiPan[i][j]!=0)){
							k++;
					    }
						else k0=1;//跳出循环
					}
					else break;
				}
				if(k==5){
					flag0=1;//成功上下连成5子
				}
				if(i+k<30){//下没有到边界
					if(QiPan[i+k][j]==0){//下有位置，可以
						Qipan2[i][j]=k;
					}
					else if(i-1>=0){//下没有到边界，但是向下被占用，上没有到边界
						if(QiPan[i-1][j]==0){//上有位置，可以
							Qipan2[i][j]=k;
						}
						else Qipan2[i][j]=0;//上也被占用，放弃该位置
					}
					else Qipan2[i][j]=0;//上到边界，放弃该位置
				}
				else{//下到边界
					if(i-1>=0){//上没有到边界
						if(QiPan[i-1][j]==0){//上有位置，可以
							Qipan2[i][j]=k;
						}
						else Qipan2[i][j]=0;//上被占用，放弃该位置
					}
					else Qipan2[i][j]=0;//上也到边界，放弃该位置				
				}
			}
		}

		//右上&左下方向
		for(int i=0;i<30;i++){
			for(int j=0;j<40;j++){//j可以直接从4开始，4之前的这个方向连不成5子
				int k=1;
				int k0=0;
				while(k0==0){//k=4时，成功
					if((i+k<30)&&(j-k>=0)){
						if((QiPan[i][j]==QiPan[i+k][j-k])&&(QiPan[i][j]!=0)){
							k++;
					    }
						else k0=1;
					}
					else break;
				}
				if(k==5){
					flag0=1;//成功右上&左下连成5子
				}
				if((i+k<30)&&(j-k>=0)){//左下没有到边界
					if(QiPan[i+k][j-k]==0){//左下有位置，可以
						Qipan3[i][j]=k;
					}
					else if((i-1>=0)&&(j+1<40)){//左下没有到边界，但是被占用，右上没有到边界
						if(QiPan[i-1][j+1]==0){//右上有位置，可以
							Qipan3[i][j]=k;
						}
						else Qipan3[i][j]=0;//右上也被占用，放弃该位置
					}
					else Qipan3[i][j]=0;//右上到边界，放弃该位置
				}
				else{//左下到边界
					if((i-1>=0)&&(j+1<40)){//右上没有到边界
						if(QiPan[i-1][j+1]==0){//右上有位置，可以
							Qipan3[i][j]=k;
						}
						else Qipan3[i][j]=0;//右上被占用，放弃该位置
					}
					else Qipan3[i][j]=0;//右上也到边界，放弃该位置				
				}
			}
		}

		//左上&右下方向
		for(int i=0;i<30;i++){
			for(int j=0;j<40;j++){//j到a-4，a-4之后的这个方向连不成5子
				int k=1;
				int k0=0;
				while(k0==0){//k=4时，成功
					if((i+k<30)&&(j+k<40)){
						if((QiPan[i][j]==QiPan[i+k][j+k])&&(QiPan[i][j]!=0)){
							k++;
					    }
						else k0=1;
					}
					else break;
				}
				if(k==5){
					flag0=1;//成功左上&右下连成5子
				}
				if((i+k<30)&&(j+k<40)){//右下没有到边界
					if(QiPan[i+k][j+k]==0){//右下有位置，可以
						Qipan4[i][j]=k;
					}
					else if((i-1>=0)&&(j-1>=0)){//右下没有到边界，但是被占用，左上没有到边界
						if(QiPan[i-1][j-1]==0){//左上有位置，可以
							Qipan4[i][j]=k;
						}
						else Qipan4[i][j]=0;//左上也被占用，放弃该位置
					}
					else Qipan4[i][j]=0;//左上到边界，放弃该位置
				}
				else{//右下到边界
					if((i-1>=0)&&(j-1>=0)){//左上没有到边界
						if(QiPan[i-1][j-1]==0){//左上有位置，可以
							Qipan4[i][j]=k;
						}
						else Qipan4[i][j]=0;//左上被占用，放弃该位置
					}
					else Qipan4[i][j]=0;//左上也到边界，放弃该位置				
				}
			}
		}
		int[][] m1=new int[Y_HEIGHT][X_WIDTH];//存储每点的k值
		int[][] m2=new int[Y_HEIGHT][X_WIDTH];//存储每点k值最大的那个方向
		for(int i=0;i<30;i++){
			for(int j=0;j<40;j++){
				//同一个点，四个方向k值最大的那个方向
				//m2记录方向
				m1[i][j]=max(Qipan1[i][j],Qipan2[i][j],Qipan3[i][j],Qipan4[i][j]);
				if(m1[i][j]==Qipan1[i][j]){
					m2[i][j]=1;// →
				}
				else if(m1[i][j]==Qipan2[i][j]){
					m2[i][j]=2;// ↓
				}
				else if(m1[i][j]==Qipan3[i][j]){
					m2[i][j]=3;// ↙
				}
				else{
					m2[i][j]=4;// ↘
				}
			}
		}
		//整个棋盘上哪个点的k值最大
		int m3=0;
		int I=0,J=0;//(I,J)处k值最大
		for(int i=0;i<30;i++){
			for(int j=0;j<40;j++){
				if(m1[i][j]>m3){
					m3=m1[i][j];
					I=i;J=j;
				}
				else if(m1[i][j]==m3){//如果两个k相等，取离落子近的那个点
					int dd1=(I-iii)*(I-iii)+(J-jjj)*(J-jjj);
					int dd2=(i-iii)*(i-iii)+(j-jjj)*(j-jjj);
					if(dd1>dd2){
						m3=m1[i][j];
						I=i;J=j;
					}
				}
			}
		}
		m[0]=I;m[1]=J;//确定哪个点的k值最大
		m[2]=m2[I][J];//方向
		m[3]=flag0;//是否连成5子
		m[4]=m3;//该点的k值
		return m;
	}
    public int max(int x,int y,int z,int w){
    	if(x>y){
    		if(x>z) return x>w?x:w;
    		else return z>w?z:w;
    	}
    	else{
    		if(y>z) return y>w?y:w;
    		else return z>w?z:w;
    	}
    }
}

3.效果截图：


最后，欢迎大家到我的个人主页http://jiaqianli.cn/，有更为详细的介绍，希望一起交流、学习，一起进步~
Li_JiaQian
关注
专栏目录
五子棋 人机对弈 JAVA实现
07-09
在本项目中，"五子棋 人机对弈 JAVA实现" 是一个使用Java编程语言设计的五子棋游戏，特别之处在于它包含了人机对弈的功能，这意味着玩家可以与计算机进行对战。这个项目对于想要了解AI和图形用户界面（GUI）开发的...
五子棋（人人博弈和人机博弈的Java实现）
最新发布
SJYsjydsb的博客
09-09 1410
机器方AI类的定义，该类中使用到的数据结构有两个Map，分别为AttackMap，其中存放的是进攻棋型，以及棋型对应的权值；DefendMap存放的是防守棋型，以及棋型对应的权值。清空权值矩阵，判断是否是Ai的回合，获取一个点的所有棋链(即进攻棋链和防御棋链)。5、棋子下在棋盘的空白点上，棋子下定后，不得向其它点移动，不得从棋盘上拿掉或拿起另落别处。简单来说，如果想两个类共享一个属性，这个属性必须是引用类型，不能是基本数据类型。空白交叉的的权值，然后Ai会下在权值最大的位置。主类FiveChess。
java--五子棋人机大战--课程设计
热门推荐
wsswsswss123的博客
03-29 1万+
南京中医药大学 《Java 程序设计》课程设计 2020-2021 学年 二 学期 日期： 2021 年 5 月 30 日 人工智能与信息技术学院 项目名称： 五子棋 南京中医药大学 2 目录 一、概述 …4 1.1 背景…4 1.2 开发工具…4 1.3 功能图…4 二、需求分析…4 三、 游戏设计思路…6 3.1 总体设计…6 3.2 功能设计…6 3.2.1 人人模式…6 3.2.3 人机模式…7 3.3 游戏包设计 …9 3.4 界面棋盘设计… 10 3.5 算法设计… 10 四、 游戏实现… 1.
五子棋人机对战（Java项目）
by_zed的博客
11-30 3631
用Java的轻量级swing组件写的五子棋小游戏
Java五子棋全代码-增加了人机对战功能
guyu的博客
02-04 8117
用Java编写简单的五子棋——人机对战！ 前言 2022-02-04，农历正月初四   首先在这祝大家新年快乐。   距离上两个版本的更新已经过去了很久，因为年前工作非常忙，经常熬到凌晨，导致我看大家私信和回复的时间有限，但我会用上厕所摸鱼的宝贵时间仔细查看并回应大家的互动。   那天我看到有同学问我人机对战如何实现，说实话这玩意三言两语很难解释清楚，不如直接写一个让大家看来的直接，所以我没有回答他的问题，而是找时间把这个功能做出来，争取让所有想问这个问题的同学找到答案。   终于来到了年假，招待完亲戚朋友
五子棋——人机博弈（Java实现）
weixin_53068616的博客
12-10 6852
1引言 本文档是考试系统项目的内容汇总，其主要内容包括： 项目说明 需求分析 项目设计 编码与实现 测试说明 课程设计体会与总结 2项目说明 2.1项目要求 五子棋是全国智力运动会竞技项目之一，是一种两人对弈的纯策略型棋类游戏。通常双方分别使用黑白两色的棋子，下在棋盘直线与横线的交叉点上，先形成五子连线者获胜。具体要求如下： 功能需求： 1、实现人与人对决。 2、实现人与机器对决，对局双方各执一色棋子，要求其中一方为机器。 3、游戏开始要求为空棋盘。 4、黑先、白后，交替下子，每
wuziqi.rar_五子棋 人机 java
09-14
在本项目中，"wuziqi.rar_五子棋 人机 java" 提供了一个使用 Java 编程语言实现的五子棋游戏，具备人机对战功能。以下是关于这个项目的详细知识点： 1. **五子棋**：五子棋，又称为连珠、朱墨棋，是一种双人对弈的...
java五子棋人机对战项目
11-10
【Java五子棋人机对战项目】是一个利用JavaSwing图形用户界面库开发的桌面游戏应用程序，专注于提供一个互动的五子棋游戏环境。在这个项目中，玩家可以与计算机进行对弈，体验到一定程度的智能挑战。智能的实现主要...
javawuziqi.zip_五子棋 人机 java
09-19
这意味着开发者使用Java技术构建了一个可以让用户与计算机进行对弈的五子棋应用。 【描述】提到的“实现了自动人机对战的功能”，意味着这个程序不仅允许玩家与另一位真实玩家在线或离线对战，还具备了人工智能（AI...
Java五子棋（人机版），昨天买的棋子今天就用不上了
javadada1197的博客
07-22 1760
效果图 由于篇长的原因有需要LeetCode刷题笔记+视频中源码资料+Java全栈开发学习路线图私信回复“java笔记” 实现思路 1.创建运行窗口并添加背景色。 2.绘制棋盘。 3.用二维数组来控制起码落子位置、绘制指示器。 4.鼠标在落子位置处点击可落子。 5.落子后检查是否获得胜利。 6.机器判断下一步，并落子。 7.机器判断是否获得胜利。 代码实现 创建窗口 首先创建一个...
java实现五子棋人机智能对战/人人网络对战
08-26
用Java实现的五子棋的对战小游戏，实现了人人网络对战，人机对战，拥有界面，在使用的时候记得将src下面的所有素材放到bin目录下方可正常运行，导入Eclipse即可运行。
java swing人机对战五子棋
04-08
这个小程序是我1年多前自己写着玩的，当时不懂这么多，两个个文件就搞定了，写的也不规范。 ai不是很智能，只是会搜索当前局面的最优解，评分规则是我从网上找的一个。大概介绍一下这个规则： 能成死二（当前位置下子后，可以有两颗子连在一起，但是一端有对方的一颗子或者边界阻挡），20分； 能成活二（当前位置下子后，可以有两颗子连在一起，两端没有对方棋子或者边界），80分； 能成死三，180分； 能成活三，800分； 能成死四，1200分； 能成活四，2000分； 能成五连，10000分； 程序遍历所有空白点，算出4个方向（横、竖、左斜、右斜）的分数和，算每个点的分数，然后选择所有节点中分数最高的一个落子。当时参考了一个别人的程序，他在程序中设定只搜索8x8的空间，怕电脑承受不了，我自己实现后并没有发现这个问题。
基于java的五子棋游戏（人机对战）
08-24
我毕业设计自己做的基于java的五子棋游戏软件，获得优秀论文，功能在单纯的人机对战上算比较齐全，也比较好玩！希望为毕业设计做游戏的同学提供些查考！ 软件的基本功能 软件的基本功能介绍如下： 1. 程序运行后首先在界面显示一个十五行十五列的围棋棋盘，还有背景图片和菜单条以及相关数据的显示。 2. 在棋盘上面通过在对应位置点击鼠标下子则表示游戏开始，棋盘上将在相应的位置上显示棋子，并且棋子在横纵交点上。 3. 电脑具有较高的人工智能和玩家游戏，可以自动判断游戏是否结束，是否玩家或者是电脑已经胜利，并且跳出文字来提示玩家并统计结果。 4. 在棋盘上方会有一条菜单选项，用来选择相应选项实现相应的功能。人机对战会有三个模式分别是普通模式、墓碑模式和地雷模式。每种模式难度有所不同。 5. 可以重新开始游戏，并且有悔棋的功能。还具有输赢局数显示，积分统计和胜率计算显示的功能。 6. 可以实现背景、棋子、棋盘的更换，可以选择先后手，可以选择背景音乐的播放和关闭，积分板的显示和隐藏以及游戏介绍。 7. 在关闭游戏后当前用户的相关数据可以存储在一个文件内，在下次该用户登录游戏后可以读出这些数据。
Java实现具有界面的人机对战五子棋（很强）
10-20
使用Java开发的人机对战五子棋，具有界面效果，总代码量500多行。界面使用awt，swing简单技术，机器落子算法是评分法，对572个五元组评分，思路简单，效果很好，机器胜率非常高。 笔者不仅打包了jar，而且打包的.exe可以直接点击运行
Java实现五子棋游戏（人机对战）
04-06
本程序适用于java初学者巩固类与对象、事件响应、awt包中各种工具的相关概念以及对逻辑能力的锻炼 需要注意的有： ①要加入java界面的重绘（基本原则） ②由于玩家需要通过鼠标点击，计算机响应出棋子的位置，但却不能保证每次点击都正中棋盘点位，所以要有一定的误差范围 ③要保存更新棋盘上的棋子信息，因为棋盘格数是固定的故本例中采取最简单的数组
java swing实现的人机对战五子棋
LGL的专栏
04-08 6343
这个小程序是我1年多前自己写着玩的，ai
java五子棋的实现，实现人人对战，人机对战
06-03
java五子棋的实现，适合学生的课程设计，希望能够帮到大家，实现人机对战，和人人对战功能模式，有时间统计
GUI版Java五子棋源码，可人机对战，经典
08-15
内容索引:JAVA源码,游戏娱乐,五子棋 　　基于GUI的Java五子棋游戏源码，可人机对战，用java swing做的，运行时需要修改图片的路径。 　　制作思路： 　　用按钮做棋子，用图片填充每个按钮。 　　设置棋盘为24*24的，五子棋FiveChessGame类，继承了JFrame，并且添加了时间监听，五子棋的棋子chess，用JButton表示，五子棋棋子chess对应的棋子标识，用于标记棋子的状态。 1表示黑棋,-1表示白棋,默认0表示无棋子，点击棋子时设置棋子的图标setOnChessIcon。 根据判断该位置的棋子是否有棋子，和棋子颜色设置棋子图标 　　测试棋子的方法showChess。用于将chessInt数组内容打印到控制台，以便观看。
Java五子棋源代码：人机对弈与界面详解
类中定义了字符串数组 `strsize` 和 `strmode`，分别用于存储棋盘大小（如 "20x15"、"30x20"）和游戏模式（"人机对弈"、"人人对弈"）。这表明用户可以选择不同的棋盘尺寸，并可以设置初始的对弈模式。 2. **游戏...
评论 2
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值