精华内容
下载资源
问答
  • 网络五子棋只需要包含客户端和服务器端两个窗口,规模比较小,而本模块设计的是独立运行的客户端,不需要服务器。从功能上看,网络五子棋涉及两台主机间的通信,相互需要传递棋子信息、控制指令和文本信息,这需要...
  • 基于JAVA五子棋游戏设计 算法设计简单但功能强大。界面漂亮,值得看看哟。
  • java课程设计五子棋游戏.doc 五子棋小游戏1.课程设计的目的 2.设计方案论证 文本文档格式的
  • 南开大学滨海学院计算机科学系课程设计报告 - PAGE 27 - PAGE PAGE 27 南开大学滨海学院 计算机科学系 课 程 设 计 报 告 课题名称基于Java五子棋游戏 专 业数字媒体 班 级2班 学号姓名 指导教师 完成日期2011年6...
  • 一. 项目简介: 五子棋是全国智力运动会竞技项目之一,是一种两... 以下是我们用Java语言写出的单机版五子棋游戏的简单介绍。本次课程设计是以JAVA语言作为开发环境,使用Eclipse设计并开发简单的单机版五子棋游...

    一. 项目简介:   

        五子棋是全国智力运动会竞技项目之一,是一种两人对弈的纯策略型棋类游戏。五子棋的玩法是:双方分别使用黑白两色的棋子,下在棋盘直线与横线的交叉点上,先形成五子连线者获胜。五子棋的棋具与围棋通用,是一种传统的棋种。五子棋容易上手,老少皆宜,而且趣味横生,引人入胜:它不仅能增强思维能力,提高智力,而且富含哲理,有助于修身养性。

       以下是我们用Java语言写出的单机版五子棋游戏的简单介绍。本次课程设计是

    二.功能需求分析

     1. 游戏的简单流程:

          

     

    三.思路分析

        四个类:
           Chess-棋子类

           DrawPanel-画棋盘类

           FiveFrame-窗口类

           TestMain-测试类(主类)

    六个模块:

          主窗口模块 画棋子模块 棋盘构造模块 按钮模块 鼠标按下模块 判断胜负模块 

          其中我负责的是 主窗口模块 画棋子模块 和 按钮模块

          接下来给大家展示

    1.主窗口模块:      

    public class FiveFrame extends JFrame{
    	
    	private JPanel toolBar;//工具栏里有三个按钮
    	private JButton startButton,backButton,exitButton;
    	private DrawTest drawTest;//棋盒的面板
    	private JMenuBar menuBar;
    	private JMenu sysMenu;
    	private JMenuItem startMenuItem,backMenuItem,exitMenuItem;
    	private MyListener listener;

     首先,创建一个类FiveFrame为窗口类。

     再创建一个Jpanel类的toolbar,即面板容器类的工具栏,再创建按钮类的开始,悔棋和退出,即startbutton,backbutton,exitbutton。

      再创建一个面板drawtest,再创建jmenubar即菜单栏,创建菜单,创建开始,悔棋,退出键,创建一个监听器。

    this.setJMenuBar(menuBar);	//设置窗口菜单栏
    		menuBar.add(sysMenu);
    		sysMenu.add(startMenuItem);
    		sysMenu.add(backMenuItem);
    		sysMenu.add(exitMenuItem);
    		
    		toolBar.add(startButton);
    		toolBar.add(backButton);
    		toolBar.add(exitButton);
    		
    		this.setLayout(new BorderLayout());
    		this.add(toolBar,BorderLayout.NORTH);
    		this.add(drawTest,BorderLayout.CENTER);
    		
    		this.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
    		this.setResizable(false);

    设置一个菜单栏,将sysmenu添加进去,后将三个按钮添加至sysmenu;

    同理将三个按钮添加到工具栏;

    用setlayout()布局管理器自动调整组件的摆放位置,注意将drawtest置于中间,将toolbar置于上方。

    设置关闭窗口时,程序运行自动停止,以及不可自由改变窗口大小。

    2.画棋子模块

    public class Chess {
    	private int x;//棋盘中x的索引值
    	private int y;
    	private Color color;
    	
    	public static final int DIANETER=30;
    
    	public Chess(int x, int y, Color color) {
    		super();
    		this.x = x;
    		this.y = y;
    		this.color = color;
    	}
    
    	public int getX() {
    		return x;
    	}
    
    	public void setX(int x) {
    		this.x = x;
    	}
    
    	public int getY() {
    		return y;
    	}
    
    	public void setY(int y) {
    		this.y = y;
    	}
    
    	public Color getColor() {
    		return color;
    	}
    
    	public void setColor(Color color) {
    		this.color = color;
    	}
    	

    创建一个chess类,设置变量x,y为棋子位置的索引值,设置颜色变量,设置常量直径为30。

    添加一个get方法,再加一个构造方法。

    for(int i=0;i<chessCount;i++) {
    			int xPos=chessList[i].getX()*GRID_SPAN+MARGIN;
    			int yPos=chessList[i].getY()*GRID_SPAN+MARGIN;
    			g.setColor(chessList[i].getColor());
    			g.fillOval(xPos-Chess.DIANETER/2, yPos-Chess.DIANETER/2, Chess.DIANETER, Chess.DIANETER);
    		//最后一颗棋子上画红色框
    			if(i==chessCount-1) {
    				g.setColor(Color.red);
                    g.drawRect(xPos-Chess.DIANETER/2, yPos-Chess.DIANETER/2, Chess.DIANETER, Chess.DIANETER);
    			}	
    		}
    		

    得到x的下标,y的下标,得到颜色,画出。

    如果棋子是最后一颗,即刚画出的那一颗,则画上红色框。

     

    3.按钮模块

    public void init() {
    		listener=new MyListener();
    		
    		this.setTitle("单机版五子棋游戏");
    		
    		toolBar=new JPanel();
    		startButton=new JButton("开始");
    		startButton.addActionListener(listener);
    		
    		backButton=new JButton("悔棋");
    		backButton.addActionListener(listener);
    		
    		exitButton=new JButton("退出");
    		exitButton.addActionListener(listener);
    		
    		drawTest=new DrawTest();
    		
    		menuBar=new JMenuBar();
    		sysMenu=new JMenu("系统");
    		startMenuItem=new JMenuItem("开始");
    		startMenuItem.addActionListener(listener);
    		
    		backMenuItem=new JMenuItem("悔棋");
    		backMenuItem.addActionListener(listener);
    		
    		exitMenuItem=new JMenuItem("退出");
    		exitMenuItem.addActionListener(listener);

    设置按钮,并且给他们加上监听。

    按钮的功能中,悔棋:

    public void goback() {
    		//棋盘中没有棋子不能悔棋
    		if(chessCount==0) {
    			return;
    		}
    		
    		chessList[chessCount-1]=null;
    		chessCount--;
    		
    		if(chessCount>0) {
    			x_index=chessList[chessCount-1].getX();
    			y_index=chessList[chessCount-1].getY();
    		}
    		isBlack=!isBlack;
    		
    		this.repaint();
    	}
    	

    若棋盘中没有棋子,则不能悔棋,return;

    若棋盘中有棋子,则让最后下的棋子等于null,且让当前棋子的x,y的索引值等于上一个棋子的索引值,将颜色相反,重画。

    重新开始:

    //重新开始游戏的方法
    	public void restartGame() {
    		//清除棋子
    		for(int i=0;i<chessList.length;i++) {
    			chessList[i]=null;
    		}
    		
    		//恢复游戏相关的变量
    		isBlack=true;
    		gameOver=false;
    		chessCount=0;
    		
    		this.repaint();
    	}

    将已有的棋子都等于null,将游戏相关变量恢复,重画。

     

     

     

     

     

     

     

     

     

       

     

     

     

     

     

     

    展开全文
  • 基于java五子棋游戏设计与实现

    千次阅读 2019-01-04 22:45:43
    获取项目源文件,联系Q:1225467431,指导其它毕设,课设 摘要:五子棋作为中国古代的传统黑白...本文是采用JAVA语言写的五子棋游戏JAVA语言无论体现在跨平台还是在面向对象,可移植性,安全性,并发机制和可视化...

    欢迎添加微信互相交流学习哦!

    二维码

    项目源码:https://gitee.com/oklongmm/biye2



    摘要:五子棋作为中国古代的传统黑白棋种之一,有着广泛的群众基础,是一种老少皆宜的棋类休闲游戏。开发一款五子棋游戏可以使广大棋牌游戏爱好者在闲暇时间切磋棋艺,对互联网技术的推广和个人棋艺的提高都有好处。的提高都有好处。
    本文是采用JAVA语言写的五子棋游戏,JAVA语言无论体现在跨平台还是在面向对象,可移植性,安全性,并发机制和可视化图形界面的支持都是很好的。选用它作为开发语言,对程序开发来说,很具有高效性。
    关 键 词: JAVA语言 棋牌游戏 跨平台性
    Abstract:Backgammon in ancient China, one of the traditional Othello species has a broad mass base, is a casual chess games for all ages. Development of a backgammon board games game can make the general demonstrate their chess enthusiasts in their spare time on Internet technology to promote and improve individual chess is good.
    This article is written by JAVA language Gobang games, JAVA language or both reflected in the cross-platform object-oriented, portability, security, concurrency mechanisms and visualization support for graphical interfaces are good. Use it as a development language for the program development, it is very efficient.
    Key words:JAVA language Card Games Cross-platform
    1. 第一章 系统概述
    1.1五子棋简介
    1.1.1五子棋
    五子棋是起源于中国古代的传统黑白棋种之一。亦连五子”、五子连”、串珠”、五目”、五目碰”、五格”等多种称谓。
    玩家根据自身等级和习惯,可以自由选择不同的游戏房间。其游戏规则也有所不同。详细分为三种棋室:普通棋室、国标棋室、职业棋室。其中普通棋室不受任何规则限制;国标棋室有禁手规则限制;而职业棋室则在国标棋室的基础上增加三手交换”和五手两打”两项规则。(三手交换:是指黑棋下盘面第3着棋后,白方在应白④之前,如感觉黑方棋形不利于己方,可提出交换,即执白棋一方变为执黑棋一方,而黑方不可以不换。五手两打:是指黑棋在下盘面上关键的第5手棋时,必须下两步棋,让白棋在这两步棋中任选一步,然后再继续对弈。)
    国际比赛规则规定:对局中如黑方出现禁手,白方应立即指出禁手点,黑方即负。如白方在黑方出现禁手后,又落一步白子,黑棋禁手则不成立了。所以 在有禁手的房间里,如果黑方出现禁手,白方应立即按下禁手按钮。程序会判黑方负。如果这时白方又在棋盘上落一子,黑棋禁手则不成立了。为了简化用户对禁手按钮的使用,也有走禁手就输和禁手不能落子规则的房间,顾名思义不多介绍。虽然采取了禁手的限制,黑棋先行仍有优势,黑棋仍可以必胜。所以如果用户是高段位的棋手,或者想成为高手一定要选择国际上比赛选用的比赛标准,即三手交换,五手两打”。
    1.1.2五子棋棋盘
    棋盘正中一点为天元”。棋盘两端的横线称端线。棋盘左右最外边的两条纵线称边线。从两条端线和两条边线向正中发展而纵横交叉在第四条线形成的四个点称为星”。天元和星应在棋盘上用直径约为0.5厘米的实心小圆点标出。
    以持黑方为准,棋盘上的纵轴线从左到右用英文字母A~O标记。横行线从近到远用阿拉伯数字1~15标记。纵横轴上的横纵线交叉点分别用横纵线标记的名称合写成。如天元”H8,四个星”分别为D4、D12、L12、L4等。
    图 1.1.2 五子棋棋盘
    1.1.3五子棋棋盘
     行棋顺序
    黑先、白后,从天元开始相互顺序落子。
     判断胜负
    1、最先在棋盘横向、竖向、斜向形成连续的相同色五个棋子的一方为胜。
    2、黑棋禁手判负(Lose),白棋无禁手。黑棋禁手包括三、三”(Double Three)(包括四、三、三”)、四、四”(Double Four)(包括四、四、三”)、长连”(Overline)。黑棋只能以四、三”取胜。
    3、如分不出胜负,则定为平局(Draw)。
    4、对局中中途退场判为负。
    5、五连与禁手同时形成,先五为胜。
    6、黑方禁手形成时,白方应立即指出。若白方未发现或发现后未指明而继续应子,则不能判黑方负。
    1.2课题背景及意义
    1.2.1开发背景
    随着社会经济的发展,青少年的生活环境日益改善,再加上他们基本上都是独生子女,父母家庭对他们的关爱也就特别强烈。由于家庭给了孩子们太多的关爱,致使许多孩子养成了以自我为中心”的陋习。围绕自我”片面地分析问题,解决问题是很难把事情办好的。而五子棋是双人对弈的项目,行棋过程中就必须同时考虑双方的意图和利益,只顾自己的利益,得到的往往是速败”。再次,五子棋棋手必须从全局入手,正确分析全盘形势,尽最大限度调用自己的有利因素才能达到取胜的目的。由此看来,五子棋可以改善青少年的思维方式,让他们培学会知己知彼” 大局入手”的思考方法,这对他们今后走上竞争日益激烈的社会是大有好处的。
    一个没有经历过失败的人,一定是个什么也不懂的人。许多青少年碰到一点挫折就退缩,不敢面对,这是他们脆弱的心理所造成的。五子棋有助于修身养性,对下棋的孩子来说,胜败是常事,关键是要学会善于自我反思,善于吸取教训, 善于积累经验,使他们有面对失败的勇气,有自我调整心态的能力,这也是他们今后走向社会所必须具备的。
    1.2.2开发的意义
    毕业设计是大学学习的总结,同时也是自己综合运用所学知识解决实际问题的一次锻炼。鉴于以上这些,我感觉有必要普及五子棋,发扬这种思维方式与方法。而互联网作为现今最大的青少年平台。能很好的推广青少年去学习五子棋,发展智力。开发五子棋程序,并放置在互联网平台上,这样会很好的让青少年去关注,以至于爱好它,学习五子棋,培养青少年的智力发育,提高国民整体素质。
    1.3 JAVA简介
    Java是一种简单的,面向对象的,分布式的,解释型的,健壮安全的,结构中立的,可移植的,性能优异、多线程的动态语言。它不只是一门编程语言,也是一个平台,它基于Java虚拟机技术,借助这个东西建立了跨平台的优势。Java技术的重要性就不讲了,从最近流行的一个统计数据上来说,目前世界上编程语言Java 、C 、VB、C++依次排名前4位,这排名本身不说明什么,至少也是工业界对编程语言使用上一个侧面的反映吧。
    Java平台:
    平台是程序运行的硬件或软件环境。Java平台与大多数其它平台不同之处在于它是运行于其它基于硬件平台的纯软件平台。大多数其它平台是硬件和操作系统的结合。Java平台由两部分组成:
    * Java虚拟机(Java VM)
    * Java应用程序界面(Java API)
    Java平台是一种纯软件平台,它有三个版本JavaSE(Java2 Platform Standard Edition,java平台标准版),JavaEE(Java 2 Platform,Enterprise Edition,java平台企业版),JavaME(Java 2 Platform Micro Edition,java平台微型版)。
    Java SE(Java Platform,Standard Edition)这个版本以前叫做J2SE,后来版本号从1.4直接跳到5.0,其实也就是1.5,所以就叫成Java SE 5.0。目前Java开发人员使用较多的版本是5.0,当然还有Java SE 6.0这个更新的版本。它允许开发和部署在桌面、服务器、嵌入式环境和实时环境中使用的Java 应用程序。Java SE还包含了支持Java Web服务开发的类,并为Java EE这个版本提供基础。
    虽说桌面应用程序,Java一直不被看好,但也稍微提一下,负责桌面GUI开发的类库我知道的有:JDK自带的主要是AWT/SWING这个Java原生类库;也可以使用IBM的SWT/JFace这个第三方类库。开发工具我了解的有:NetBeans(最近已经是6.0final版了,做GUI有使用VB的感觉),Eclipse(SWT/JFace这个项目其实就是做Eclipse项目时扩展出来的,所以对SWT/JFace支持的也不错)。Java EE(Java Platform,Enterprise Edition)这个版本以前叫做J2EE,也就是大家可能听得比较多的,也是Java比较流行的领域,Java的企业级版本。Java EE下有很多流行的开发框架,像Struts、Spring、Hibernate这种流行的所谓SSH组合等。
    Java平台由Java虚拟机(Java Virtual Machine)和Java 应用编程接口(Application Programming Interface、简称API)构成。Java 应用编程接口为Java应用提供了一个独立于操作系统的标准接口,可分为基本部分和扩展部分。在硬件或操作系统平台上安装一个Java平台之后,Java应用程序就可运行。现在Java平台已经嵌入了几乎所有的操作系统。这样Java程序可以只编译一次,就可以在各种系统中运行。Java应用编程接口已经从1.1x版发展到1.2版。目前常用的Java平台基于Java1.4,最近版本为Java1.7。
    2. 第二章 系统分析
    2.1系统需求
    我们在设计游戏的时候有以下一些要求:
    一 软件的界面简洁明了,操作简单容易。我们设计的软件界面必须是简洁的,游戏需要设计得易操作。
    二 软件具有人工智能算法原理要简单,并且运行快速。游戏是需要快速反应的。我们需要使用简单实用的智能算法。
    三 游戏要设置几个难度,便于不同玩家选择.玩家的游戏水平不一样,我们设置不同难度供各个水平的玩家选择。
    游戏玩法及规则
    现代五子棋专用棋盘为十五路(15X15),共225个交叉点。棋盘正中一点为天元。对局开始时,先由执黑棋一方将一枚棋子落在天元点上,然后由执白棋一方在黑棋周围的交叉点上落子。但是,为了尊重对方和礼貌起见,持白棋的一方通常将盘面的第二着棋布在自己河界的一侧,即直止或斜止。此后黑白双方轮流落子,直到某一方首先在棋盘的横线、纵线或斜线上形成连续五子或五子以上〔仅对白棋而言〕,则该方就算获胜 。连珠五子棋的一个特点是先行的一方优势很大,因此在职业比赛中对黑方做了种种限制,以利公平竞争。五子棋的比赛规则如下:
    1、黑先、白后,从天元开始相互顺序落子;
    2、最先在棋盘横向、纵向或斜向形成连续的同色五个棋子的一方为胜;
    3、 黑棋禁手判负、白棋无禁手。黑棋禁手有三、三”、四、四”和长连”, 包括四、三、三”和四、四、三”。黑棋只能以四、三”取胜;
    4、如分不出胜负,则到为平局;
    5、五连与禁手同时形成,判胜;
    6、黑方禁手形成时,白方应立即指出。若白方未发现或发现后不立即指出,反而继续落子,则禁手失效,不再判黑方负。
    2.2系统的功能简介
    人机对弈的程序,至少应具备如下几个部分:
    1、某种在机器中表示棋局的方法,能够让程序知道博弈的状态。
    2、产生合法走法的规则,以使博弈公正地进行,并可以判断人类对手是否乱走。
    3、从所有合法走法中选择最佳走法的技术。
    4、一种评估局面优劣的方法,用以同上面的技术配合做出智能的选择。
    5、一个界面,有了它,这个程序才能用。
    2.2.1 棋盘表示
    棋盘表示就是使用一种数据结构来描述棋盘及棋盘上的棋子,通常使用一个二维数组。棋盘的数据表示直接影响到程序的时间及空间复杂度。为了追求更高的效率,研究人员针对不同棋类提出了多种不同的表示方法。有些方法具有更高的效率如比特棋盘表示法。
    2.2.2 走法产生
    博弈的规则决定了哪些走法是合法的。对有的游戏来说,这很简单,比如五子棋,任何空白的位置都是合法的落子点。但是对于象棋来说,就有马走日,象走田等一系列复杂的规则。走法产生是博弈程序中一个相当复杂而且耗费运算时间的过程。不过,通过良好的数据结构可以显著的提高走法生成的速度。
    2.2.3搜索技术
    对于计算机来说,直接通过棋盘信息判断走法的好坏并不精确。除了输赢这样的局面可以准确判断外,其它的判断都只能做到大致估计。判断两种走法孰优孰劣的一个好方法就是观看棋局走下去的结果。也就是向下搜索若干步,然后比较发展下去的结果。为了避免差错,我们假定对手的思考也和我们一样,也就是,我们想到的内容,对手也想到了。这就是极大极小搜索算法的基本原则。极大极小搜索算法的时间复杂度是O(bn)。这里b是分枝因子,指棋局在各种情况下的合法走步的平均值;n是搜索的最大深度,也就是向下搜索的博弈双方的走步之和。例如向下搜索甲乙双方各走一步的情形,n就是2。显然对于五子棋这种分枝因子在200左右的棋类游戏,时间开销随着n的增大会急剧的增长,不出几层就会超出计算机的处理能力,这将导致在有限时间内得不到令人满意的结果。
    人们在开发高效的搜索算法上投入了大量的研究。在过去的几十年中,一些相当成功的改进大大提高了极大极小搜索的效率。Alpha-Beta剪枝、迭代深化、置换表、历史启发等手段的综合运用将搜索效率提高了几个数量级。
    2.2.4用户功能
    用户可以直接使用的游戏功能,通过按键进行操作。每个用例的简要说明如下:
    1、新游戏:初始化相关变量,清空棋盘。
    2、步数计算:计算当前是第几步
    4、棋子坐标:显示当前所下棋子坐标。
    6、下棋提示:提示该哪方下棋子。
    7、重新开局:初始化相关变量,清空棋盘。
    2.3系统的可行性分析
    2.3.1经济可行性
    本游戏使用模块化设计方案,易于编写和维护,核心代码易于移植,总体开发成本低。游戏短小精悍,对目标设备要求低,产品面向受众广,可以带来可观的经济效益。
    2.3.2技术可行性
    JAVA提供了丰富的接口和类服务,本游戏的开发只需要用到基本的绘图接口和系统的文件服务,实现起来非常简单。使用JAVA封装好的数据类可以简化编码实现,避免不必要的错误。对于以处理数据为主的棋类游戏,编码实现没有困难。
    2.3.3系统安全性分析
    本游戏的开发只使用很少的系统接口和系统服务,数据处理都是在程序内部解决,不涉及与其它程序的数据交互。使用JAVA定义好的构造法分配内存空间,这样不会在构造出现异常时产生内存泄露。系统会根据已经入栈的对象指针,通过析构函数收回内存。所以即使程序因为内存不足无法运行,也不会因此而影响系统本身的稳定性和安全性。另外,使用模块化方法进行设计编码,可以很方便的调整算法的搜索深度,减小内存的使用量,提高程序的兼容性
    3. 第三章 系统设计
    3.1系统关键类介绍
    1、Chess类是游戏的主类,负责初始化游戏棋盘,其实Chess类就是游戏的入口,只有启动了此类,才有游戏菜单,才可以进行选择游戏。代码如下
    setVisible(true);
    setLayout(null);
    Label label = new Label(Gobang v1.0, Label.CENTER);
    add(label);
    label.setBounds(10, 50, 440, 26);
    label.setBackground(Color.orange);
    add(chesspad);
    chesspad.setBounds(10, 90, 440, 440);
    addWindowListener(new WindowAdapter() {
    public void windowClosing(WindowEvent e) {
    System.exit(0);
    }
    });
    pack();
    setSize(460, 540);
    2、Evaluate类是用来估算估值点的坐标,返回的是这个点的价值。代码如下:
    int max_x, max_y, max; //定义坐标 x,y及最大值
    public void evaluate(int shape[][][]) {
    int i = 0, j = 0;
    for (i = 0; i < 19; i++)
    for (j = 0; j < 19; j++) {
    switch (shape[i][j][0]) {
    case 5:
    shape[i][j][4] = 200;
    break;
    case 4:
    switch (shape[i][j][1]) {
    case 4:
    shape[i][j][4] = 150 + shape[i][j][2] + shape[i][j][3];
    break;
    case 3:
    shape[i][j][4] = 100 + shape[i][j][2] + shape[i][j][3];
    break;
    default:
    shape[i][j][4] = 50 + shape[i][j][2] + shape[i][j][3];
    }
    break;
    case 3:
    switch (shape[i][j][1]) {
    case 3:
    shape[i][j][4] = 75 + shape[i][j][2] + shape[i][j][3];
    break;
    default:
    shape[i][j][4] = 20 + shape[i][j][2] + shape[i][j][3];
    }
    break;
    case 2:
    shape[i][j][4] = 10 + shape[i][j][1] + shape[i][j][2]
    + shape[i][j][3];
    break;
    case 1:
    shape[i][j][4] = shape[i][j][0] + shape[i][j][1]
    + shape[i][j][2] + shape[i][j][3];
    default:
    shape[i][j][4] = 0;
    }
    }
    int x = 0, y = 0;
    max = 0;
    for (x = 0; x < 19; x++)
    for (y = 0; y < 19; y++)
    if (max < shape[x][y][4]) {
    max = shape[x][y][4];
    max_x = x;
    max_y = y;
    }
    }
    3.2胜负判断
    Judge类中的judge方法是通过扫描当前点周围的同色棋子数进行判断,如果胜利则返回True,否则返回False。这个方法需要配合使用,电脑会在下子之后调用这个方法。这个方法实现的伪代码如下:
    static boolean judge(int a[][], int color) {
    int i, j, flag;
    for (i = 0; i < 19; i++) {
    flag = 0;
    for (j = 0; j < 19; j++)
    if (a[i][j] == color) {
    flag++;
    if (flag == 5)
    return true;
    } else
    flag = 0;
    }
    for (j = 0; j < 19; j++) {
    flag = 0;
    for (i = 0; i < 19; i++)
    if (a[i][j] == color) {
    flag++;
    if (flag == 5)
    return true;
    } else
    flag = 0;
    }
    for (j = 4; j < 19; j++) {
    flag = 0;
    int m = j;
    for (i = 0; i <= j; i++) {
    if (a[i][m--] == color) {
    flag++;
    if (flag == 5)
    return true;
    } else
    flag = 0;
    }
    }
    for (j = 14; j >= 0; j--) {
    flag = 0;
    int m = j;
    for (i = 0; i <= 18 - j; i++) {
    if (a[i][m++] == color) {
    flag++;
    if (flag == 5)
    return true;
    } else
    flag = 0;
    }
    }
    for (i = 14; i >= 0; i--) {
    flag = 0;
    int n = i;
    for (j = 0; j < 19 - i; j++) {
    if (a[n++][j] == color) {
    flag++;
    if (flag == 5)
    return true;
    } else
    flag = 0;
    }
    }
    for (j = 14; j >= 0; j--) {
    flag = 0;
    int m = j;
    for (i = 18; i >= j; i--) {
    if (a[i][m++] == color) {
    flag++;
    if (flag == 5)
    return true;
    } else
     

    展开全文
  • 包里有两套代码,一套是人机对战的,有开始,重开,悔棋等功能,可以设置游戏难度;一套是联网对战的,登录后选对手
  • java游戏设计五子棋

    热门讨论 2011-10-16 00:16:26
    用Eclipse编写的五子棋游戏,动画界面,可人人对战,人机对战,倒计时时间设置,背景音乐,不同等级的电脑AI,分为低,中,高,三个等级的电脑AI。可悔棋,可让电脑自行模拟下棋。本资源具有完整的论文,代码,选题...
  • Java课程设计网络五子棋游戏源程序,能运行。 /** * 登录面板 * * @author Li Zhong Wei */ public class LoginPanel extends javax.swing.JPanel { private Socket socket; private UserBean user; ...
  • 一份包含程序、开题报告、论文的java游戏毕业设计,基于java五子棋游戏设计,亲测代码可执行,没有问题!供大家参考学习。
  • JAVA五子棋游戏

    2012-06-06 21:26:54
    JAVA设计五子棋游戏,包括完整的代码,课程设计报告。
  • 利用java编写五子棋游戏,详细教程,简单明了。
  • Java设计五子棋游戏

    2020-06-20 15:04:28
    1.用java编写五子棋游戏 2.该程序拥有简洁美观的图形化界面,且界面主要由棋盘、标题和游戏操作的按钮三部分组成。另外,该游戏界面的大小是不可变的,程序会自动获取电脑屏幕的大小信息,并且计算出合适的位置...

    要求:

    1.用java编写五子棋的游戏
    2.该程序拥有简洁美观的图形化界面,且界面主要由棋盘、标题和游戏操作的按钮三部分组成。另外,该游戏界面的大小是不可变的,程序会自动获取电脑屏幕的大小信息,并且计算出合适的位置居中显示。因为考虑到棋盘和背景图片的显示问题,为防止出现排列错乱,故采用这样的设计方式。
    3.标题位于界面的最上方;棋盘为19*19的围棋棋盘,位于左下方;按钮包括:“开始游戏” “退出游戏” “游戏说明”,共3个,位于棋盘的右侧
    4. 在单击鼠标时,在相应的位置显示棋子 ,还能够显示轮到哪一方下棋(规定黑子先下)
    5. 可以保存棋局,即保存之前下过的棋子
    6.能够判断游戏胜负,并且弹出窗口提示。一局结束后可以通过“开始游戏”按钮清空棋盘界面,进行下一局。

    设计思想:
    本程序主要用到以下3种技术: ⑴ Swing编程 ⑵ ImageIO类的使用 ⑶ Graphics图片的绘制
    对于这样一个五子棋游戏程序。1.首先我们要用java.Swing和java.awt工具包来设计游戏的用户界面并且绘制图像图形,如制作棋盘。2.此外还要用到ImageIO类来导入和显示图片用作游戏界面的背景,背景图片可以自己设计。
    3.主体界面制作好了以后,我们就可以添加事件监听,用与监听鼠标相关的类—— MouseListener来在指定区域和位置内利用鼠标点击产生棋子进行游戏。4. 接下来就可以开始设计判定胜负的算法了。5.然后就是按钮功能的实现。6.最后就是调试和测验,看程序有没有什么bug。
    具体会用到的类和方法会在下面的主程序中一一给予介绍
    编程过程
    导入java.awt、java.io和javax.swing工具包,它们包含用于创建用户界面、绘制图形图像、图像导入,鼠标监听的所有分类。

    import java.awt.Color;       //color类用于对游戏界面进行配色
    import java.awt.Font;       //font类提供与字体相关的类和接口。
    import java.awt.Graphics;   //Graphics类提供执行实际的绘制、着色及文本输出的操作功能的基类
    import java.awt.Toolkit;
    import java.awt.event.MouseEvent;
    import java.awt.event.MouseListener;   //与监听鼠标相关的类
    import java.awt.image.BufferedImage;   //导入图片的处理类
    import java.io.File;       // 文件和目录路径名的抽象表示形式。
    import java.io.IOException;     //异常类
    import javax.imageio.ImageIO;    //显示图片的类
    import javax.swing.JFrame;         //创建窗体,并且设置其大小,位置等属性
    import javax.swing.JOptionPane;      //与对话框相关的类
    
    

    先把游戏主窗体设计出来

    public class FiveChessFrame extends JFrame implements MouseListener, Runnable {
    
    	// 获取屏幕的宽度和高度,用以计算出合适的位置将游戏界面居中显示
    	int width = Toolkit.getDefaultToolkit().getScreenSize().width;
    	int height = Toolkit.getDefaultToolkit().getScreenSize().height;
    	// 先将背景图片定义为空
    	BufferedImage bgImage = null;
    	//这里定义的x,y用来保存棋子的坐标
    	int x = 0;
    	int y = 0;
    	
       /** 定义一个19*19的二维数组来表示棋盘,其中数据内容 0: 表示这个点并没有棋子, 1: 表示这个点是黑子, 2:表示这个点是白子*/
    	int[][] allChess = new int[19][19];
    	// 标识当前应该黑棋还是白棋下下一步
    	boolean isBlack = true;
    	// 标识当前游戏是否可以继续
    	boolean canPlay = true;
    	// 保存显示的提示信息,这个信息是用来在界面的棋盘上方显示的
    	String message = "黑方先行";
    	
    	//设置五子棋游戏界面的主窗体(位置、大小、居中显示等属性)
           public FiveChessFrame() {
    	   this.setTitle("五子棋--曾磊");
    		this.setSize(500, 500);
    		this.setLocation((width - 500) / 2, (height - 500) / 2);
    		this.setResizable(false);
    		// 将窗体的关闭方式设置为默认关闭后程序结束
    		this.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
    		// 为窗体加入鼠标监听器
    		this.addMouseListener(this);
    		// 将窗体显示出来
    		this.setVisible(true);
    
    	/**下面是导入事先设计好的图片作为游戏界面的背景,运用到io流操作,通过ImageIo类来实现背景图片由磁盘向程序中的导入,并且用到try IOException来捕获异常。*/
    		try {
    			bgImage = ImageIO.read(new File("E:\\image\\128.jpg"));
    		} catch (IOException e) {
    				e.printStackTrace();
    		}
    		// 刷新屏幕,防止开始游戏时出现无法显示的情况.
    		this.repaint();
    	}
    
    
    

    绘制棋盘

    public void paint(Graphics g) {
    		// 绘制背景
    		g.drawImage(bgImage, 1, 20, this);
    		// 输出标题信息
    		g.setFont(new Font("黑体", Font.BOLD, 20));
    		g.drawString("  :" + message, 130, 60);
    		
           /**绘制棋盘,在背景图片流出的棋盘区域绘制棋盘的线,利用一个for循环实现棋盘线的绘制,横扫都18等分,很容易可以计算出来*/
    		for (int i = 0; i < 19; i++) {
    			g2.drawLine(10, 70 + 20 * i, 370, 70 + 20 * i);
    			g2.drawLine(10 + 20 * i, 70, 10 + 20 * i, 430);
    		}
       /** 使用Graphics类的fillOver方法来标注围棋棋盘上的九个点位(只演示一个,其余类似)可以先用鼠标监听的方法获取点位的坐标,然后再进行绘制*/
    		g2.fillOval(68, 128, 4, 4);
    	/**下面提供绘制棋子的程序代码,即通过鼠标监听器判断在什么位置产生什么颜色的棋子。参数传递1表示黑子,2表示白子。*/
    		for (int i = 0; i < 19; i++) {
    			for (int j = 0; j < 19; j++) {
    				if (allChess[i][j] == 1) {
    					int tempX = i * 20 + 10;
    					int tempY = j * 20 + 70;
    					g2.fillOval(tempX - 7, tempY - 7, 14, 14);
    				}
    				if (allChess[i][j] == 2) {
    					int tempX = i * 20 + 10;
    					int tempY = j * 20 + 70;
    					g2.setColor(Color.WHITE);
    					g2.fillOval(tempX - 7, tempY - 7, 14, 14);
    					g2.setColor(Color.BLACK);
    					g2.drawOval(tempX - 7, tempY - 7, 14, 14);
    				}
    			}
    		}
    		g.drawImage(bi, 0, 0, this);
    	}
    
    

    添加鼠标监听

    public void mousePressed(MouseEvent e) {
    		if (canPlay == true) {
    			x = e.getX();
    			y = e.getY();
    			if (x >= 10 && x <= 370 && y >= 70 && y <= 430) {
    				x = (x - 10) / 20;
    				y = (y - 70) / 20;
    				if (allChess[x][y] == 0) {
    				if (isBlack == true) {
    						allChess[x][y] = 1;
    						isBlack = false;
    						message = "轮到白方";
    					} else {
    						allChess[x][y] = 2;
    						isBlack = true;
    						message = "轮到黑方";
    					}
    					// 判断这个棋子是否和其他的棋子连成5连,即判断游戏是否结束
    					boolean winFlag = this.checkWin();
    					if (winFlag == true) {
    						JOptionPane.showMessageDialog(this, "游戏结束,"
    								+ (allChess[x][y] == 1 ? "黑方" : "白方") + "获胜!");
    						canPlay = false;
    					}
    				} else {
    					JOptionPane.showMessageDialog(this, "当前位置已经有棋子,请重新落子!");
    				}
    				this.repaint();
    			}
    		}
    
    

    赋予各个按钮以相应功能

    赋予 “开始游戏” 按钮相应功能。点击“开始游戏”,如果要重新开始游戏的话,要把棋盘清空,且把allchess中的数据归零,将“游戏信息”显示改回到初始状态,将下一步下棋的改为黑方

    if (e.getX() >= 400 && e.getX() <= 470 && e.getY() >= 70
    				&& e.getY() <= 100) {
    		int result = JOptionPane.showConfirmDialog(this, "是否重新开始游戏?");
    		if (result == 0) 
    		   allChess = new int[19][19];
    		message = "黑方先行";
    			isBlack = true;
    				this.repaint();
    
    			}
    		}
    
    

    赋予“ 退出游戏 ”按钮相应功能

    if (e.getX() >= 400 && e.getX() <= 470 && e.getY() >= 370
    				&& e.getY() <= 400) {
    			JOptionPane.showMessageDialog(this, "游戏结束");
    			System.exit(0);
    		}
    	}
    
    

    赋予“游戏设置”按钮功能

    if (e.getX() >= 387 && e.getX() <= 496 && e.getY() >= 228
    				&& e.getY() <= 261) {
    			String input = JOptionPane
    					.showInputDialog("请输入游戏的最大时间(单位:分钟),如果输入0,表示没有时间限制:");
    			try {
    				maxTime = Integer.parseInt(input) * 60;
    				if (maxTime < 0) {
    					JOptionPane.showMessageDialog(this, "请输入正确信息,不允许输入负数!");
    				}
    				if (maxTime == 0) {
    					int result = JOptionPane.showConfirmDialog(this,
    							"设置完成,是否重新开始游戏?");
    					if (result == 0) {
    						for (int i = 0; i < 19; i++) {
    							for (int j = 0; j < 19; j++) {
    								allChess[i][j] = 0;
    							}
    						}
    						// 另一种方式 allChess = new int[19][19];
    						message = "黑方先行";
    						isBlack = true;
    						blackTime = maxTime;
    						whiteTime = maxTime;
    						blackMessage = "无限制";
    						whiteMessage = "无限制";
    						this.canPlay = true; 
    						this.repaint();
    					}
    				}
    				if (maxTime > 0) {
    					int result = JOptionPane.showConfirmDialog(this,
    							"设置完成,是否重新开始游戏?");
    					if (result == 0) {
    						for (int i = 0; i < 19; i++) {
    							for (int j = 0; j < 19; j++) {
    								allChess[i][j] = 0;
    							}
    						}
    						// 另一种方式 allChess = new int[19][19];
    						message = "黑方先行";
    						isBlack = true;
    						blackTime = maxTime;
    						whiteTime = maxTime;
    						blackMessage = maxTime / 3600 + ":"
    								+ (maxTime / 60 - maxTime / 3600 * 60) + ":"
    								+ (maxTime - maxTime / 60 * 60);
    						whiteMessage = maxTime / 3600 + ":"
    								+ (maxTime / 60 - maxTime / 3600 * 60) + ":"
    								+ (maxTime - maxTime / 60 * 60);
    						t.resume();
    						this.canPlay = true; 
    						this.repaint();
    					}
    				}
    			} catch (NumberFormatException e1) {
    				// TODO Auto-generated catch block
    				JOptionPane.showMessageDialog(this, "请正确输入信息!");
    			}
    		}
    

    赋予“认输”按钮功能

    if (e.getX() >= 386 && e.getX() <= 496 && e.getY() >= 284
    				&& e.getY() <= 316) {
    			int result = JOptionPane.showConfirmDialog(this, "是否确认认输?");
    			if (result == 0) {
    				if (isBlack) {
    					JOptionPane.showMessageDialog(this, "黑方已经认输,游戏结束!");
    					canPlay=false;
    				} else {
    					JOptionPane.showMessageDialog(this, "白方已经认输,游戏结束!");
    					canPlay=false;
    				}
    				canPlay = false;
    			}
    		}
    

    赋予“游戏说明”按钮功能

    if (e.getX() >= 392 && e.getX() <= 493 && e.getY() >= 388
    				&& e.getY() <= 427) {
    			JOptionPane.showMessageDialog(this,
    					"这个一个五子棋游戏程序,黑白双方轮流下棋,当某一方连到五子时,游戏结束。作者为曾磊");
    		}
    

    判断输赢

    private boolean checkWin() {
    		boolean flag = false;
    		// 保存共有相同颜色多少棋子相连
    		int count = 1;
    		// 判断横向是否有5个棋子相连,特点 纵坐标 是相同, 即allChess[x][y]中y值是相同
    		int color = allChess[x][y];
    		// 判断横向
    		count = this.checkCount(1, 0, color);
    		if (count >= 5) {
    			flag = true;
    		} else {
    			// 判断纵向
    			count = this.checkCount(0, 1, color);
    			if (count >= 5) {
    				flag = true;
    			} else {
    				// 判断右上、左下
    				count = this.checkCount(1, -1, color);
    				if (count >= 5) {
    					flag = true;
    				} else {
    					// 判断右下、左上
    					count = this.checkCount(1, 1, color);
    					if (count >= 5) {
    						flag = true;
    					}
    				}
    			}
    		}
    
    		return flag;
    	}
    
    	// 判断棋子连接的数量
    	private int checkCount(int xChange, int yChange, int color) {
    		int count = 1;
    		int tempX = xChange;
    		int tempY = yChange;
    		while (x + xChange >= 0 && x + xChange <= 18 && y + yChange >= 0
    				&& y + yChange <= 18
    				&& color == allChess[x + xChange][y + yChange]) {
    			count++;
    			if (xChange != 0)
    				xChange++;
    			if (yChange != 0) {
    				if (yChange > 0)
    					yChange++;
    				else {
    					yChange--;
    				}
    			}
    		}
    		xChange = tempX;
    		yChange = tempY;
    		while (x - xChange >= 0 && x - xChange <= 18 && y - yChange >= 0
    				&& y - yChange <= 18
    				&& color == allChess[x - xChange][y - yChange]) {
    			count++;
    			if (xChange != 0)
    				xChange++;
    			if (yChange != 0) {
    				if (yChange > 0)
    					yChange++;
    				else {
    					yChange--;
    				}
    			}
    		}
    		return count;
    	}
    

    检测时间限制

    public void run() {
    		// TODO Auto-generated method stub
    		// 判断是否有时间限制
    		if (maxTime > 0) {
    			while (true) {
    				if (isBlack&&canPlay) {
    					blackTime--;
    					if (blackTime == 0) {
    						JOptionPane.showMessageDialog(this, "黑方超时,游戏结束!");
    					}
    				} else if(!isBlack&&canPlay) {
    					whiteTime--;
    					if (whiteTime == 0) {
    						JOptionPane.showMessageDialog(this, "白方超时,游戏结束!");
    					}
    				}
    				blackMessage = blackTime / 3600 + ":"
    						+ (blackTime / 60 - blackTime / 3600 * 60) + ":"
    						+ (blackTime - blackTime / 60 * 60);
    				whiteMessage = whiteTime / 3600 + ":"
    						+ (whiteTime / 60 - whiteTime / 3600 * 60) + ":"
    						+ (whiteTime - whiteTime / 60 * 60);
    				this.repaint();
    				try {
    					Thread.sleep(1000);
    				} catch (InterruptedException e) {
    					// TODO Auto-generated catch block
    					e.printStackTrace();
    				}
    				System.out.println(blackTime + " -- " + whiteTime);
    			}
    		}
    	}
    

    在这里插入图片描述
    在这里插入图片描述
    游戏背景底图
    在这里插入图片描述

    展开全文
  • 文件为我在java课程设计时写的五子棋游戏,主要包括开始游戏、悔棋、认输、设置时间限制、弃权、重新开始等功能,共享给大家,需要的带走。
  • 基于Java Swing五子棋游戏设计和实现

    千次阅读 多人点赞 2021-08-24 21:52:00
    五子棋相传起源于四千多年前的尧帝时期,比围棋的历史还要悠久,可能早在“尧造围棋”之前,民间就已有五子棋游戏。有关早期五子棋的文史资料与围棋有相似之处,因为古代五子棋的棋具与围棋是完全相同的。 在上古的...

     订阅专栏获取源码

    前言:

                 五子棋相传起源于四千多年前的尧帝时期,比围棋的历史还要悠久,可能早在“尧造围棋”之前,民间就已有五子棋游戏。有关早期五子棋的文史资料与围棋有相似之处,因为古代五子棋的棋具与围棋是完全相同的。 在上古的神话传说中有“女娲造人, 伏羲做棋”一说,《增山海经》中记载: “休舆之山有石焉, 名曰帝台之棋, 五色而文状鹑卵。 ”善注引三国淳《艺经》 中曰: “棋局,纵横各十七道,合二百八十九道,白黑棋子,各一百五十枚”。这段虽没明讲是何种棋类,但至少知道远古就以漂亮的石头为棋子。因而规则简单的五子棋也可能出自当时,并是用石子作棋子。亦有传说,五子棋最初流行于少数民族地区,以后渐渐演变成围棋并在炎黄子后代中遍及开来。

     

    项目结构:

     

    功能截图:

     

     

     

    关键代码:

     初始化参数:

    	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;							//棋盘边长

    电脑下棋逻辑处理:

    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;
      }

    总结:

         通过此次课程设计,将我本学期所学的JAVA知识得到巩固和应用,在设计的过程中我遇到了很到问题,不过在老师和同学们的帮助和自己的思考下还是很好的完成了。这此课程设计还让我懂得了写程序不能闭门造车,要努力拓宽知识面,开阔视野,拓展思维。它还让我学会了在网上查阅那些无限的资料。由于自己的分析设计和程序经验不足,该系统设计和实现过程中,还有许多没有完善的地方,比如用户界面设计不够美观等多方面问题,这些都有待进一步完善和提高。对于文中出现的不足和系统中出现的问题敬请老师指导。

    订阅专栏获取源码

    JavaSwing系列项目推荐:

    JavaSwing ATM取款机系统的设计和实现

    JavaSwing的经典坦克大战游戏设计实现

    JavaSwing+mysql的图书管理系统设计实现

    JavaSwing+Mysql的酒店管理系统设计实现

    JavaSwing+Mysql的餐厅点餐系统设计实现

    JavaSwing+Mysql的仓库管理系统设计实现

    JavaSwing+Mysql超市商品管理系统设计实现

    javaSwing+TXT学生信息管理系统设计实现

    JavaSwing+mysql学生社团管理系统设计实现

    JavaSwing+mysql的酒店管理系统设计和实现

    打卡Java文章更新 19 / 100 天

    大家可以点赞、收藏、关注、评论我啦 

    展开全文
  • java五子棋游戏设计与实现毕业设计开题报告.pdf
  • 基于Java五子棋游戏设计与实现.pdf
  • 五子棋游戏Java代码简单实现(含活动图和类图设计) @TOPIC 游戏活动图 类图 代码实现 import java.lang.Math; import java.io.*; import java.util.Scanner; class Gobang { // 定义棋盘和棋盘大小 private ...
  • java课程设计五子棋游戏设计含有可运行源代码
  • java五子棋课程设计.doc》由会员分享,可在线阅读,更多相关《java五子棋课程设计.doc(20页珍藏版)》请在人人文库网上搜索。1、Java程序设计大作业20112012学年第一学期Java程序设计课程大作业题目: 五子棋 专业:...
  • Swing是一个用于开发Java应用程序用户界面的开发工具包。 ImageIo类 read(); JOptionPane消息提示框 //只有一个确定按钮 JOptionPane.showMessageDialog(); //有两个选择按钮,返回值int:0(是),1(否) ...
  • 五子棋游戏java开发

    2021-07-29 20:31:57
    五子棋游戏开发 此游戏具有双人对战功能和人机对战功能 一、游戏界面的实现 一个游戏首先从设计界面开始 1、首先创建一个类,作用是通过对窗体组件的一些设置来实现简单游戏界面 public void gameUI(){ //窗体组件...
  • PAGE 25 沈 阳 大 学 五子棋游戏 1.课程设计的目的 计算机技术的不断发展给人们的日常工作和生活都带来了许多益处 从Windows系统的推出使电脑从高雅的学术殿堂走入了寻常百姓家开始各行各业的人们无须经过特别的...
  • 基于Java五子棋游戏设计(源代码+论文) 摘 要 五子棋作为一个棋类竞技运动,在民间十分流行,为了熟悉五子棋规则及技巧,以及研究简单的人工智能,决定用Java开发五子棋游戏。主要完成了人机对战和玩家之间联网...
  • Java的广泛流行是与它所编写的程序可以在网络上运行且可以跨平台。事实上,支持Java的浏览器内置Java虚拟机,使得Java的小程序能够在网络上完全地传送和运行。...“网上五子棋游戏”便是其最好的例子。
  • JAVA课程设计五子棋游戏完整版.pdf
  • JAVA实战3——五子棋游戏设计

    千次阅读 2015-06-09 22:09:58
    一、实践目标:  1.掌握JavaGUI界面设计  2.掌握鼠标事件的监听... 设计一个简单的五子棋程序,能够实现五子棋下棋过程。如下图所示   五子棋运行界面  1.五子棋棋盘类 [java] view plaincopyprint? pa
  • 基于Java五子棋游戏设计毕业论文.pdf
  • 基于的五子棋游戏设计 摘要 五子棋作为一个棋类竞技运动在民间十分流行为了熟悉五子棋规则及技巧以及研究简单的人工智能决定用开发五子棋游戏主要完成了人机对战和玩家之间联网对战2个功能网络连接部分为编程应用...
  • java毕业设计

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 1,891
精华内容 756
关键字:

五子棋游戏设计java

java 订阅