java swing实现的人机对战五子棋

最新推荐文章于 2024-05-10 10:15:59 发布
最新推荐文章于 2024-05-10 10:15:59 发布
阅读量6.3k 收藏 20
点赞数 5
分类专栏： java 文章标签： java swing 五子棋 人机对战
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/lgl1170860350/article/details/23188715
版权

这个小程序是我1年多前自己写着玩的，当时不懂这么多，两个个文件就搞定了，写的也不规范。图片神马的都是从别人demo弄来的。

ai不是很智能，只是会搜索当前局面的最优解，评分规则是我从网上找的一个。大概介绍一下这个规则：

  • 能成死二（当前位置下子后，可以有两颗子连在一起，但是一端有对方的一颗子或者边界阻挡），20分；
  • 能成活二（当前位置下子后，可以有两颗子连在一起，两端没有对方棋子或者边界），80分；
  • 能成死三，180分；
  • 能成活三，800分；
  • 能成死四，1200分；
  • 能成活四，2000分；
  • 能成五连，10000分；

程序遍历所有空白点，算出4个方向（横、竖、左斜、右斜）的分数和，算每个点的分数，然后选择所有节点中分数最高的一个落子。当时参考了一个别人的程序，他在程序中设定只搜索8x8的空间，怕电脑承受不了，我自己实现后并没有发现这个问题。
开始的时候还想着设置一下ai的难度，搜索几层什么的，实在水平有限，也不懂怎么弄，就成了这样子，搜索当前局面的最优解。



附上程序部分源码： 
package jsj.lgl;

import java.awt.Color;
import java.awt.Graphics;
import java.awt.Point;
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;
import java.awt.event.MouseEvent;
import java.awt.event.MouseListener;
import java.awt.image.BufferedImage;
import java.io.File;
import java.io.IOException;
import java.util.ArrayList;

import javax.imageio.ImageIO;
import javax.swing.ImageIcon;
import javax.swing.JButton;
import javax.swing.JOptionPane;
import javax.swing.JPanel;

public class CBoardPanel extends JPanel implements MouseListener
{
	private static final int START_X=20;
	private static final int START_Y=20;
	private static final int STEP=35;
	private static final int ROW=15;
	private static final int COL=15;
	
	public static final int BLANK=1;
	public static final int WHITE=-1;
	public static final int NONE=0;
	
	public static final int AI_FIRST=1;
	public static final int HUMAN_FIRST=2;
	
	public static final int EASY=2;
	public static final int HARD=4;	
	
	private BufferedImage chessBoardImage=null,whiteImage=null,blankImage=null;//图片
	private int[][] chesses=new int[ROW][COL];//棋盘情况
	private int aiColor,humColor;//电脑和人的棋子颜色
	private int level;//当前难度
	private ChessBoard cb;//主类的引用
	private boolean isHumTurn=false;//是不是轮到人下的布尔值，true代表轮到人下
	private int currRow,currCol;//当前棋子的行和列
	private int winner=NONE;//表示赢家的颜色，初始为空
	private ArrayList<Point> chessProcess=new ArrayList<Point>();//表示每一个棋子下的先后顺序，用于悔棋
	
	private static final int FIVE = 10000;//能成五连
	private static final int L_FOUR =2000;//能成活四
	private static final int D_FOUR = 1200;//能成死四
	private static final int L_THREE = 800;//能成活三
	private static final int D_THREE = 180;//能成死三
	private static final int L_TWO = 80;//能成活二
	private static final int D_TWO = 20;//能成死二
	
	private static final int HENG=1;
	private static final int SHU=2;
	private static final int XIE45=3;
	private static final int XIE135=4;
	
	public CBoardPanel(int whoFirst,int level,ChessBoard cb)//构造器
	{
		this.cb=cb;
		this.level=level;
		chesses=new int[ROW][COL];
		winner=NONE;
		if(whoFirst==HUMAN_FIRST)
		{
			isHumTurn=true;
			humColor=BLANK;
			aiColor=WHITE;
		}
		else
		{
			humColor=WHITE;
			aiColor=BLANK;
			isHumTurn=false;
			//电脑走一步棋
			aiGoOneStep();
		}						
		try
		{
			chessBoardImage=ImageIO.read(new File("image/chessboard.jpg"));
			blankImage = ImageIO.read(new File("image/b.jpg"));
			whiteImage = ImageIO.read(new File("image/w.jpg"));
		} catch (IOException e)
		{
			e.printStackTrace();
		}
		this.addMouseListener(this);
	}
	
	public void restart(int whoFirst,int level,ChessBoard cb)//重新开始的方法
	{
		this.level=level;
		chesses=new int[ROW][COL];
		winner=NONE;
		chessProcess.clear();
		if(whoFirst==HUMAN_FIRST)
		{
			isHumTurn=true;
			humColor=BLANK;
			aiColor=WHITE;
		}
		else
		{
			humColor=WHITE;
			aiColor=BLANK;
			isHumTurn=false;
			//电脑走一步棋
			aiGoOneStep();
		}
		this.repaint();
	}
	
	public void paintComponent(Graphics g)//重写的paintComponent方法
	{
		super.paintComponents(g);
		
		g.drawImage(chessBoardImage,0,0,this);
		for(int i=0;i<ROW;i++)
		{
			for(int j=0;j<COL;j++)
			{
				if(chesses[i][j]==BLANK)
				{
					drawImageInRowCol(i,j,blankImage,g);
				}
				else if(chesses[i][j]==WHITE)
				{
					drawImageInRowCol(i,j,whiteImage,g);
				}
			}
		}
		g.setColor(Color.RED);
		if(chessProcess.size()>0)
		{
			g.drawRect(currCol*STEP+2, currRow*STEP+2, STEP, STEP);
		}
	}
	
	public void back()//退一步棋
	{
		if(!isHumTurn||chessProcess.size()<2)
		{
			return;
		}
		winner=NONE;
		Point p=chessProcess.get(chessProcess.size()-1);
		chesses[p.x][p.y]=NONE;
		chessProcess.remove(chessProcess.size()-1);
		
		p=chessProcess.get(chessProcess.size()-1);
		chesses[p.x][p.y]=NONE;
		chessProcess.remove(chessProcess.size()-1);
		if(chessProcess.size()>0)
		{
			p=chessProcess.get(chessProcess.size()-1);
			currRow=p.x;currCol=p.y;
		}
		
		this.repaint();
	}
	
	public void setLevel(int level)//设置难易程度
	{
		this.level=level;
	}
	
	private void drawImageInRowCol(int row,int col,BufferedImage image,Graphics g)//在指定行和列画棋子
	{
		int x=col*STEP+3;
		int y=row*STEP+3;
		g.drawImage(image,x,y,this);
	}
	
	private Point pressWhere(MouseEvent e)//判断鼠标的点击位置，转换为行和列
	{
		int x=e.getPoint().x;
		int y=e.getPoint().y;
		int row=(y-START_Y+STEP/2)/STEP;
		int col=(x-START_X+STEP/2)/STEP;
		return new Point(row,col);
	}
	
	private void goOneStep(int row,int col,int color)//生成一步棋，并判断是否有玩家胜出
	{
		chesses[row][col]=color;
		chessProcess.add(new Point(row,col));
		currRow=row;currCol=col;
		this.repaint();
		boolean flag=isWin(currRow,currCol,color);		
		if(flag)
		{
			winner=color;
			String msg;
			if(winner==BLANK)
			{
				msg="黑方胜啦！";
			}
			else
			{
				msg="白方胜啦！";
			}
			JOptionPane.showMessageDialog(cb,msg,"游戏结束",JOptionPane.INFORMATION_MESSAGE);
		}
		if(color==humColor&&winner==NONE)
		{
			aiGoOneStep();
		}
	}
	
	private int score(int row,int col,int dir,int color)//判断当前点指定方向的棋形
	{
		if(row<0||row>=ROW||col<0||col>=COL||chesses[row][col]!=NONE)
		{
			return 0;
		}
		int x=0,y=0;
		boolean lflag=false,rflag=false;//左右标志位
		int qx=1;
		int ltemp=0,rtemp=0;
		switch(dir)
		{
		case HENG:x=1;y=0;
			break;
		case SHU:x=0;y=1;
			break;
		case XIE45:x=1;y=1;
			break;
		case XIE135:x=1;y=-1;
			break;
		}
		int currRow=row,currCol=col;
		for(int i=1;i<=5;i++)//往左看
		{
			currRow=row-i*y;
			currCol=col-i*x;
			if(currRow<0||currRow>=ROW||currCol<0||currCol>=COL)
			{
				lflag=true;
				break;
			}
			if(chesses[currRow][currCol]==color)
			{
				qx+=1;
			}
			else if(chesses[currRow][currCol]==-color)
			{
				lflag=true;
				break;
			}
			else if(chesses[currRow][currCol]==NONE)
			{
				for(int j=1;j<5;j++)
				{
					currRow=row-i*y;
					currCol=col-i*x;
					if(chesses[currRow][currCol]==color)
					{
						ltemp++;
					}
					else if(chesses[currRow][currCol]==-color)
					{
						lflag=true;
						break;
					}
					else
					{
						break;
					}
				}
				break;
			}
		}
		for(int i=1;i<=5;i++)//往右看
		{
			currRow=row+i*y;
			currCol=col+i*x;
			if(currRow<0||currRow>=ROW||currCol<0||currCol>=COL)
			{
				rflag=true;
				break;
			}
			if(chesses[currRow][currCol]==color)
			{
				qx+=1;
			}
			else if(chesses[currRow][currCol]==-color)
			{
				rflag=true;
				break;
			}
			else if(chesses[currRow][currCol]==NONE)
			{
				for(int j=1;j<5;j++)
				{
					currRow=row+i*y;
					currCol=col+i*x;
					if(chesses[currRow][currCol]==color)
					{
						rtemp++;
					}
					else if(chesses[currRow][currCol]==-color)
					{
						rflag=true;
						break;
					}
					else
					{
						break;
					}
				}
				break;
			}
		}
		int temp=Math.max(ltemp, rtemp);
//System.out.println("qx="+qx);
		if(qx>=5)
		{
			return FIVE;
		}
		else if(lflag&&rflag)
		{
			return 0;
		}
		else
		{
			qx+=temp;
			if(lflag||rflag)
			{
				switch(qx)
				{
				case 1:return 0;
				case 2:return D_TWO;
				case 3:return D_THREE;
				case 4:return D_FOUR;
				}
			}
			else
			{
				if(temp>0)
				{
					switch(qx)
					{
					case 1:return 0;
					case 2:return D_TWO;
					case 3:return D_THREE;
					case 4:return D_FOUR;
					}
				}
				else
				{
					switch(qx)
					{
					case 1:return 0;
					case 2:return L_TWO;
					case 3:return L_THREE;
					case 4:return L_FOUR;
					}				
				}
			}
		}
		return 0;
	}
	
	private int getScore(int row,int col,int color)
	{
		int result=0;
		int heng=score(row,col,HENG,color);int hengl=score(row,col,HENG,-color);
		int shu=score(row,col,SHU,color);int shul=score(row,col,SHU,-color);
		int xie45=score(row,col,XIE45,color);int xie45l=score(row,col,XIE45,-color);
		int xie135=score(row,col,XIE135,color);int xie135l=score(row,col,XIE135,-color);
		/*int[] temp=new int[8];
		temp[heng]++;
		temp[shu]++;
		temp[xie45]++;
		temp[xie135]++;
		if()*/
		result=heng+shu+xie45+xie135+hengl+shul+xie45l+xie135l;
		
		return result;
	}
	
	private boolean isWin(int row,int col,int color)//判断当前点是否有五连的情况
	{
		int max=0;
		int temp=0;
		//判断横向
		for(int i=0;i<COL;i++)
		{
			if(chesses[row][i]==color)
			{
				temp++;
				if(max<temp)
				{
					max=temp;
				}
			}
			else
			{				
				temp=0;
			}
		}
		if(max>=5)
		{
			return true;
		}
		//判断纵向
		temp=0;max=0;
		for(int i=0;i<ROW;i++)
		{
			if(chesses[i][col]==color)
			{
				temp++;
				if(max<temp)
				{
					max=temp;
				}
			}
			else
			{
				temp=0;
			}
		}
		if(max>=5)
		{
			return true;
		}
		//判断右下方向
		int x=row,y=col;
		max=0;
		while(x>=0&&x<ROW&&y>=0&&y<COL&&chesses[x][y]==color)
		{
			x--;
			y--;
		}
		x++;y++;
		while(x>=0&&x<ROW&&y>=0&&y<COL&&chesses[x][y]==color)
		{
			max++;
			x++;
			y++;
		}
		if(max>=5)
		{
			return true;
		}
		//判断右上方向
		x=row;y=col;
		max=0;
		while(x>=0&&x<ROW&&y>=0&&y<COL&&chesses[x][y]==color)
		{
			x--;
			y++;
		}
		x++;y--;
		while(x>=0&&x<ROW&&y>=0&&y<COL&&chesses[x][y]==color)
		{
			max++;
			x++;
			y--;
		}
		if(max>=5)
		{
			return true;
		}
		return false;
	}
	
	private class AI extends Thread//电脑走棋的线程
	{
		@Override
		public void run()
		{
			isHumTurn=false;
			int row=(int)(Math.random()*ROW);
			int col=(int)(Math.random()*COL);
			while(chesses[row][col]!=0)
			{
				row=(int)(Math.random()*ROW);
				col=(int)(Math.random()*COL);
			}
			
			int score=0;
			for(int i=0;i<ROW;i++)
			{
				for(int j=0;j<COL;j++)
				{
					if(chesses[i][j]!=0)
					{
						//System.out.print(i+","+j+">"+chesses[i][j]+" ");
						continue;
					}
					int temp=getScore(i,j,aiColor);
					//System.out.print(i+","+j+"="+temp+" ");
					if(score<temp)
					{
						row=i;
						col=j;
						score=temp;
					}
				}
				//System.out.println();
			}
			goOneStep(row,col,aiColor);
			isHumTurn=true;
		}
	}
	
	private void aiGoOneStep()//电脑走一步棋的方法
	{
		/*AI ai=new AI();
		ai.start();*/
		
		isHumTurn=false;
		int row=0;
		int col=0;
		if(chessProcess.size()==0)
		{
			row=7;col=7;
			goOneStep(row,col,aiColor);
			isHumTurn=true;
			return;
		}
		
		int score=0;
		//System.out.println(aiColor);
		for(int i=0;i<ROW;i++)
		{
			for(int j=0;j<COL;j++)
			{
				if(chesses[i][j]!=0)
				{
					//System.out.print(i+","+j+">"+chesses[i][j]+" ");
					continue;
				}
				int temp=getScore(i,j,aiColor);
				//System.out.print(i+","+j+"="+temp+" ");
				if(score<temp)
				{
					row=i;
					col=j;
					score=temp;
				}
			}
			//System.out.println();
		}
		goOneStep(row,col,aiColor);
		isHumTurn=true;
	}
	//重写鼠标监听事件
	@Override
	public void mouseClicked(MouseEvent e)
	{
		
	}

	@Override
	public void mouseEntered(MouseEvent e)
	{
		
	}

	@Override
	public void mouseExited(MouseEvent e)
	{
		
	}

	@Override
	public void mousePressed(MouseEvent e)
	{
		
	}

	@Override
	public void mouseReleased(MouseEvent e)//当鼠标抬起时触发，玩家在指定位置走一步棋
	{
		if(!isHumTurn||winner!=NONE)
		{
			return;
		}
		Point p=pressWhere(e);
		if(chesses[p.x][p.y]!=0)
		{
			return;
		}
		isHumTurn=false;
		goOneStep(p.x,p.y,humColor);		
	}
	
	public void dianNaoJianQi()
	{
		if(!isHumTurn||winner!=NONE)
		{
			return;
		}
		int row=(int)(Math.random()*ROW);
		int col=(int)(Math.random()*COL);
		while(chesses[row][col]!=0)
		{
			row=(int)(Math.random()*ROW);
			col=(int)(Math.random()*COL);
		}
		
		int score=0;
		//System.out.println(aiColor);
		for(int i=0;i<ROW;i++)
		{
			for(int j=0;j<COL;j++)
			{
				if(chesses[i][j]!=0)
				{
					//System.out.print(i+","+j+">"+chesses[i][j]+" ");
					continue;
				}
				int temp=getScore(i,j,humColor);
				//System.out.print(i+","+j+"="+temp+" ");
				if(score<temp)
				{
					row=i;
					col=j;
					score=temp;
				}
			}
			//System.out.println();
		}
		goOneStep(row,col,humColor);
	}
}

最后是源码下载链接：http://download.csdn.net/detail/lgl1170860350/7161707，设置了一点下载积分。

liguanliang2013
关注
  • 5
    点赞
  • 踩
  • 20
    收藏
    觉得还不错? 一键收藏
  • 3
    评论
专栏目录
java实现五子棋人机智能对战/人人网络对战
08-26
用Java实现的五子棋的对战小游戏，实现了人人网络对战，人机对战，拥有界面，在使用的时候记得将src下面的所有素材放到bin目录下方可正常运行，导入Eclipse即可运行。
java swing人机对战五子棋
04-08
这个小程序是我1年多前自己写着玩的，当时不懂这么多，两个个文件就搞定了，写的也不规范。 ai不是很智能，只是会搜索当前局面的最优解，评分规则是我从网上找的一个。大概介绍一下这个规则： 能成死二（当前位置下子后，可以有两颗子连在一起，但是一端有对方的一颗子或者边界阻挡），20分； 能成活二（当前位置下子后，可以有两颗子连在一起，两端没有对方棋子或者边界），80分； 能成死三，180分； 能成活三，800分； 能成死四，1200分； 能成活四，2000分； 能成五连，10000分； 程序遍历所有空白点，算出4个方向（横、竖、左斜、右斜）的分数和，算每个点的分数，然后选择所有节点中分数最高的一个落子。当时参考了一个别人的程序，他在程序中设定只搜索8x8的空间，怕电脑承受不了，我自己实现后并没有发现这个问题。
java 五子棋之人机对战思路详解
skltz
07-06 6097
最近做了五子棋，记录下自己完成五子棋的人机对战的思路。     首先，思路是这样的：每当人手动下一颗棋子（黑子）的时候，应当遍历它周围棋子的情况，并赋予周围棋子一定的权值，当在机器要下棋子（白子）守护之前，会遍历整个棋盘的权值情况（棋盘的权值存在一个二维数组中），从中找出权值最大的点坐标，并下子（白子）。     这样的话，问题就集中在两个方面了，一个是：如何遍历黑子周围的棋子
Java最全Java+Swing实现五子棋游戏，基于SpringCloud微服务化开发平台项目
最新发布
2301_82242082的博客
05-10 840
总的来说，面试是有套路的，一面基础，二面架构，三面个人。最后，小编这里收集整理了一些资料，其中包括面试题（含答案）、书籍、视频等。希望也能帮助想进大厂的朋友本文已被CODING开源项目：【一线大厂Java面试题解析+核心总结学习笔记+最新讲解视频+实战项目源码】收录需要这份系统化的资料的朋友，可以点击这里获取if (array1[r][c] == 0) {// 如果该位置没有棋子则开始统计// 调用水平向左统计的方法// 根据棋子相连情况获取对应的权值if (weight!
java五子棋博弈代码_五子棋(人机对弈)——Java权值法五子棋博弈
weixin_42301769的博客
02-13 328
五子棋人机博弈五子棋，人与人之间博弈，我们不用考虑太多，都是玩家自动思考。但是如果我们要玩一个单机的五子棋，实现人机的对战，那么我就得“帮”电脑考虑下走哪步了。实现的方法大概有三种：最大权值法决策树法机器学习训练这里我们主要针对第一种方法讨论下，大致思路如下：我们绘制好一个棋盘后，假定大小为 15*15；下棋之前，对于棋盘中的每个空位，我们每都替电脑人“掂一掂”下在哪里合算；(估权过程)对每个空...
【java】java swing：五子棋人机对弈
Li_Jiaqian的博客
05-04 1185
最近学习java swing，将上次的人机五子棋做了改进，将其界面化，在调试过程中还发现了上次代码中的一些问题。 问题一：无法应对A落在自己左上方的棋子 问题二：计算机不能应对落在边界的棋子，不能应对单个棋子 （即，对于代码中的k值，若该方向上无法再落子，则应该放弃这个k值最大的一串棋子） 1.大体结构： 2.完整的，又臭又长的
java swing人机对战五子棋(含背景音乐)
01-06
本项目是一套基于java swing的人机对战五子棋系统，主要针对计算机相关专业的正在做毕设的学生与需要项目实战练习的Java学习者。 包含：项目源码、数据库脚本等，该项目附带全部源码可作为毕设使用。 项目都经过严格...
java swing 人机对战 五子棋
09-26
主要是一个五子棋游戏，利用java swing技术编写，总共只有一个类，两个内部类。人机对战
java编写的人机对战五子棋
09-19
【标题】"java编写的人机对战五子棋"是一个基于Java编程语言实现的互动游戏项目，它允许玩家与计算机进行对弈。在这款游戏中，玩家可以体验到经典的五子棋玩法，即先连成五子直线（横、竖、斜）的一方获胜。 【描述...
java五子棋人机对战项目
11-10
【Java五子棋人机对战项目】是一个利用JavaSwing图形用户界面库开发的桌面游戏应用程序，专注于提供一个互动的五子棋游戏环境。在这个项目中，玩家可以与计算机进行对弈，体验到一定程度的智能挑战。智能的实现主要...
java swing 五子棋
07-07
人人 人机 PPT 项目毕设 答辩资料整整一套5分带走速度
基于java的五子棋游戏（人机对战）
08-24
我毕业设计自己做的基于java的五子棋游戏软件，获得优秀论文，功能在单纯的人机对战上算比较齐全，也比较好玩！希望为毕业设计做游戏的同学提供些查考！ 软件的基本功能 软件的基本功能介绍如下： 1. 程序运行后首先在界面显示一个十五行十五列的围棋棋盘，还有背景图片和菜单条以及相关数据的显示。 2. 在棋盘上面通过在对应位置点击鼠标下子则表示游戏开始，棋盘上将在相应的位置上显示棋子，并且棋子在横纵交点上。 3. 电脑具有较高的人工智能和玩家游戏，可以自动判断游戏是否结束，是否玩家或者是电脑已经胜利，并且跳出文字来提示玩家并统计结果。 4. 在棋盘上方会有一条菜单选项，用来选择相应选项实现相应的功能。人机对战会有三个模式分别是普通模式、墓碑模式和地雷模式。每种模式难度有所不同。 5. 可以重新开始游戏，并且有悔棋的功能。还具有输赢局数显示，积分统计和胜率计算显示的功能。 6. 可以实现背景、棋子、棋盘的更换，可以选择先后手，可以选择背景音乐的播放和关闭，积分板的显示和隐藏以及游戏介绍。 7. 在关闭游戏后当前用户的相关数据可以存储在一个文件内，在下次该用户登录游戏后可以读出这些数据。
Java实现具有界面的人机对战五子棋（很强）
10-20
使用Java开发的人机对战五子棋，具有界面效果，总代码量500多行。界面使用awt，swing简单技术，机器落子算法是评分法，对572个五元组评分，思路简单，效果很好，机器胜率非常高。 笔者不仅打包了jar，而且打包的.exe可以直接点击运行
java五子棋（人机对战、人人对战）总共三个还有算法！
04-09
java做的五子棋，非常不错！总共三个还有算法！
java五子棋的实现，实现人人对战，人机对战
06-03
java五子棋的实现，适合学生的课程设计，希望能够帮到大家，实现人机对战，和人人对战功能模式，有时间统计
人机对战五子棋游戏算法
10-06
这是一个用VC写的五子棋算法，很好，值得好好学习。适用于正在学习人工智能、VC和算法的朋友。如果你想学好人工智能，或着想学好算法，这是一个很好的材料
Java五子棋人机对战AI算法
qq243920161的博客
12-11 4498
自己写的人机对战，思路是给每个未下的棋子进行评分，活二、活三、冲四等分别代表不同分数，取最高分数进行落子 简单写了个前端页面，大家可以玩玩看 https://www.linzhehao.cn/Gobang/single 下面是Java的核心代码及用法 一、示例用法 public class MyTest { public static void main(String[] args)...
五子棋人机对战（Java项目）
by_zed的博客
11-30 3563
用Java的轻量级swing组件写的五子棋小游戏
JAVA五子棋的实现（三）——人机对战（权值法）
热门推荐
Alexwym的博客
07-01 1万+
完整代码已上传到github上，地址：https://github.com/Alexlingl/GoBang。有需要的可以自取。 五子棋系列博客（总共三篇，从简单功能简单界面到人机对战，以及较美观的登录及对战界面。第三篇博客中有最终实现的界面效果）： JAVA五子棋的实现（一） JAVA五子棋的实现（二） 在JAVA五子棋的实现（二）中我们已经实现了以下几个功能：1.判断输赢；2.实...
Java实现五子棋人机对战源码解析
"这是一个基于Java实现的五子棋游戏，具备人机对战和人人对战模式。包含源代码和相关文档，可以帮助学习者理解Java图形界面编程和游戏逻辑实现。" 在Java编程中，五子棋游戏的实现涉及到多个核心知识点： 1. **...
评论 3
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值