锐客网

  1. 首页 > 睿知 > it技术 > >

人机黑白棋java源代码 java课程设计

IT技术int

求例如俄罗斯方块，五子棋，黑白棋等小游戏的JAVA版俄罗斯方块——java源代码提供
import java.awt.*;
import java.awt.event.*;
//俄罗斯方块类
public class ERS_Block extends Frame{
public static boolean isPlay=false;
public static int level=1,score=0;
public static TextField scoreField,levelField;
public static MyTimer timer;
GameCanvas gameScr;
public static void main(String[] argus){
ERS_Block ers = new ERS_Block("俄罗斯方块游戏 V1.0 Author:Vincent");
WindowListener win_listener = new WinListener();
ers.addWindowListener(win_listener);
}
//俄罗斯方块类的构造方法
ERS_Block(String title){
super(title);
setSize(600,480);
setLayout(new GridLayout(1,2));
gameScr = new GameCanvas();
gameScr.addKeyListener(gameScr);
timer = new MyTimer(gameScr);
timer.setDaemon(true);
timer.start();
timer.suspend();
add(gameScr);
Panel rightScr = new Panel();
rightScr.setLayout(new GridLayout(2,1,0,30));
rightScr.setSize(120,500);
add(rightScr);
//右边信息窗体的布局
MyPanel infoScr = new MyPanel();
infoScr.setLayout(new GridLayout(4,1,0,5));
infoScr.setSize(120,300);
rightScr.add(infoScr);
//定义标签和初始值
Label scorep = new Label("分数:",Label.LEFT);
Label levelp = new Label("级数:",Label.LEFT);
scoreField = new TextField(8);
levelField = new TextField(8);
scoreField.setEditable(false);
levelField.setEditable(false);
infoScr.add(scorep);
infoScr.add(scoreField);
infoScr.add(levelp);
infoScr.add(levelField);
scorep.setSize(new Dimension(20,60));
scoreField.setSize(new Dimension(20,60));
levelp.setSize(new Dimension(20,60));
levelField.setSize(new Dimension(20,60));
scoreField.setText("0");
levelField.setText("1");
//右边控制按钮窗体的布局
MyPanel controlScr = new MyPanel();
controlScr.setLayout(new GridLayout(5,1,0,5));
rightScr.add(controlScr);
//定义按钮play
Button play_b = new Button("开始游戏");
play_b.setSize(new Dimension(50,200));
play_b.addActionListener(new Command(Command.button_play,gameScr));
//定义按钮Level UP
Button level_up_b = new Button("提高级数");
level_up_b.setSize(new Dimension(50,200));
level_up_b.addActionListener(new Command(Command.button_levelup,gameScr));
//定义按钮Level Down
Button level_down_b =new Button("降低级数");
level_down_b.setSize(new Dimension(50,200));
level_down_b.addActionListener(new Command(Command.button_leveldown,gameScr));
//定义按钮Level Pause
Button pause_b =new Button("游戏暂停");
pause_b.setSize(new Dimension(50,200));
pause_b.addActionListener(new Command(Command.button_pause,gameScr));
//定义按钮Quit
Button quit_b = new Button("退出游戏");
quit_b.setSize(new Dimension(50,200));
quit_b.addActionListener(new Command(Command.button_quit,gameScr));
controlScr.add(play_b);
controlScr.add(level_up_b);
controlScr.add(level_down_b);
controlScr.add(pause_b);
controlScr.add(quit_b);
setVisible(true);
gameScr.requestFocus();
}
}
//重写MyPanel类，使Panel的四周留空间
class MyPanel extends Panel{
public Insets getInsets(){
return new Insets(30,50,30,50);
}
}
//游戏画布类
class GameCanvas extends Canvas implements KeyListener{
final int unitSize = 30; //小方块边长
int rowNum; //正方格的行数
int columnNum; //正方格的列数
int maxAllowRowNum; //允许有多少行未削
int blockInitRow; //新出现块的起始行坐标
int blockInitCol; //新出现块的起始列坐标
int [][] scrArr; //屏幕数组
Block b; //对方快的引用
//画布类的构造方法
GameCanvas(){
rowNum = 15;
columnNum = 10;
maxAllowRowNum = rowNum - 2;
b = new Block(this);
blockInitRow = rowNum - 1;
blockInitCol = columnNum/2 - 2;
scrArr = new int [32][32];
}
//初始化屏幕，并将屏幕数组清零的方法
void initScr(){
for(int i=0;irowNum;i)
for (int j=0; jcolumnNum;j)
scrArr[j]=0;
b.reset();
repaint();
}
//重新刷新画布方法
public void paint(Graphics g){
for(int i = 0; irowNum; i)
for(int j = 0; jcolumnNum; j)
drawUnit(i,j,scrArr[j]);
}
//画方块的方法
public void drawUnit(int row,int col,int type){
scrArr[row][col] = type;
Graphics g = getGraphics();
tch(type){ //表示画方快的方法
case 0: g.setColor(Color.black);break; //以背景为颜色画
case 1: g.setColor(Color.blue);break; //画正在下落的方块
case 2: g.setColor(Color.magenta);break; //画已经落下的方法
}
g.fill3DRect(col*unitSize,getSize().height-(row 1)*unitSize,unitSize,unitSize,true);
g.dispose();
}
public Block getBlock(){
return b; //返回block实例的引用
}
//返回屏幕数组中(row,col)位置的属性值
public int getScrArrXY(int row,int col){
if (row0 || row = rowNum || col0 || col = columnNum)
return(-1);
else
return(scrArr[row][col]);
}
//返回新块的初始行坐标方法
public int getInitRow(){
return(blockInitRow); //返回新块的初始行坐标
}
//返回新块的初始列坐标方法
public int getInitCol(){
return(blockInitCol); //返回新块的初始列坐标
}
//满行删除方法
void deleteFullLine(){
int full_line_num = 0;
int k = 0;
for (int i=0;irowNum;i){
boolean isfull = true;
L1:for(int j=0;jcolumnNum;j)
if(scrArr[j] == 0){
k;
isfull = false;
break L1;
}
if(isfull) full_line_num;
if(k!=0k-1!=i!isfull)
for(int j = 0; jcolumnNum; j){
if (scrArr[j] == 0)
drawUnit(k-1,j,0);
else
drawUnit(k-1,j,2);
scrArr[k-1][j] = scrArr[j];
}
}
for(int i = k-1 ;irowNum; i){
for(int j = 0; jcolumnNum; j){
drawUnit(i,j,0);
scrArr[j]=0;
}
}
ERS_Block.score= full_line_num;
ERS_Block.scoreField.setText("" ERS_Block.score);
}
//判断游戏是否结束方法
boolean isGameEnd(){
for (int col = 0 ; col columnNum; col){
if(scrArr[maxAllowRowNum][col] !=0)
return true;
}
return false;
}
public void keyTyped(KeyEvent e){
}
public void keyReleased(KeyEvent e){
}
//处理键盘输入的方法
public void keyPressed(KeyEvent e){
if(!ERS_Block.isPlay)
return;
tch(e.getKeyCode()){
case KeyEvent.VK_DOWN:b.fallDown();break;
case KeyEvent.VK_LEFT:b.leftMove();break;
case KeyEvent.VK_RIGHT:b.rightMove();break;
case KeyEvent.VK_SPACE:b.leftTurn();break;
}
}
}
//处理控制类
class Command implements ActionListener{
static final int button_play = 1; //给按钮分配编号
static final int button_levelup = 2;
static final int button_leveldown = 3;
static final int button_quit = 4;
static final int button_pause = 5;
static boolean pause_resume = true;
int curButton; //当前按钮
GameCanvas scr;
//控制按钮类的构造方法
Command(int button,GameCanvas scr){
curButton = button;
this.scr=scr;
}
//按钮执行方法
public void actionPerformed (ActionEvent e){
tch(curButton){
case button_play:if(!ERS_Block.isPlay){
scr.initScr();
ERS_Block.isPlay = true;
ERS_Block.score = 0;
ERS_Block.scoreField.setText("0");
ERS_Block.timer.resume();
}
scr.requestFocus();
break;
case button_levelup:if(ERS_Block.level10){
ERS_Block.level;
ERS_Block.levelField.setText("" ERS_Block.level);
ERS_Block.score = 0;
ERS_Block.scoreField.setText("" ERS_Block.score);
}
scr.requestFocus();
break;
case button_leveldown:if(ERS_Block.level1){
ERS_Block.level--;
ERS_Block.levelField.setText("" ERS_Block.level);
ERS_Block.score = 0;
ERS_Block.scoreField.setText("" ERS_Block.score);
}
scr.requestFocus();
break;
case button_pause:if(pause_resume){
ERS_Block.timer.suspend();
pause_resume = false;
}else{
ERS_Block.timer.resume();
pause_resume = true;
}
scr.requestFocus();
break;
case button_quit:System.exit(0);
}
}
}
//方块类
class Block {
static int[][] pattern = {
{0x0f00,0x4444,0x0f00,0x4444},//用十六进至表示，本行表示长条四种状态
{0x04e0,0x0464,0x00e4,0x04c4},
{0x4620,0x6c00,0x4620,0x6c00},
{0x2640,0xc600,0x2640,0xc600},
{0x6220,0x1700,0x2230,0x0740},
{0x6440,0x0e20,0x44c0,0x8e00},
{0x0660,0x0660,0x0660,0x0660}
};
int blockType; //块的模式号（0-6）
int turnState; //块的翻转状态（0-3）
int blockState; //快的下落状态
int row,col; //块在画布上的坐标
GameCanvas scr;
//块类的构造方法
Block(GameCanvas scr){
this.scr = scr;
blockType = (int)(Math.random() * 1000)%7;
turnState = (int)(Math.random() * 1000)%4;
blockState = 1;
row = scr.getInitRow();
col = scr.getInitCol();
}
//重新初始化块，并显示新块
public void reset(){
blockType = (int)(Math.random() * 1000)%7;
turnState = (int)(Math.random() * 1000)%4;
blockState = 1;
row = scr.getInitRow();
col = scr.getInitCol();
dispBlock(1);
}
//实现“块”翻转的方法
public void leftTurn(){
if(assertValid(blockType,(turnState1)%4,row,col)){
dispBlock(0);
turnState = (turnState1)%4;
dispBlock(1);
}
}
//实现“块”的左移的方法
public void leftMove(){
if(assertValid(blockType,turnState,row,col-1)){
dispBlock(0);
col--;
dispBlock(1);
}
}
//实现块的右移
public void rightMove(){
if(assertValid(blockType,turnState,row,col 1)){
dispBlock(0);
col;
dispBlock(1);
}
}
//实现块落下的操作的方法
public boolean fallDown(){
if(blockState == 2)
return(false);
if(assertValid(blockType,turnState,row-1,col)){
dispBlock(0);
row--;
dispBlock(1);
return(true);
}else{
blockState = 2;
dispBlock(2);
return(false);
}
}
//判断是否正确的方法
boolean assertValid(int t,int s,int row,int col){
int k = 0x8000;
for(int i = 0; i4; i){
for(int j = 0; j4; j){
if((int)(pattern[t][s]k) != 0){
int temp = scr.getScrArrXY(row-i,col j);
if (temp0||temp==2)
return false;
}
k = k1;
}
}
return true;
}
//同步显示的方法
public synchronized void dispBlock(int s){
int k = 0x8000;
for (int i = 0; i4; i){
for(int j = 0; j4; j){
if(((int)pattern[blockType][turnState]k) != 0){
scr.drawUnit(row-i,col j,s);
}
k=k1;
}
}
}
}
//定时线程
class MyTimer extends Thread{
GameCanvas scr;
public MyTimer(GameCanvas scr){
this.scr = scr;
}
public void run(){
while(true){
try{
sleep((10-ERS_Block.level1)*100);
}
catch(InterruptedException e){}
if(!scr.getBlock().fallDown()){
scr.deleteFullLine();
if(scr.isGameEnd()){
ERS_Block.isPlay = false;
suspend();
}else
scr.getBlock().reset();
}
}
}
}
class WinListener extends WindowAdapter{
public void windowClosing (WindowEvent l){
System.exit(0);
}
}
参考;bs=JAVA版俄罗斯方块,五子棋,黑白棋sr=z=cl=3f=8wd=JAVA俄罗斯方块,五子棋,黑白棋ct=0
系统框图如下 java实现五子棋程序 可以实现人人对战 人机对战 简单功能 悔棋 认输一、实验题目
五子棋游戏 。
二、问题分析
五子棋是双人博弈棋类益智游戏，由围棋演变而来 ， 属纯策略型 。棋盘通常15*15，即15行，15列，共225个交叉点，即棋子落点；棋子由黑白两色组成，黑棋123颗，白棋122颗 。游戏规则为黑先白后，谁先五子连成一条直线谁赢 ， 其中直线可以是横的、纵的、45度、135度 。
本次Java编程我的目的是现实人机对战，即游戏者一方是人，另一方计算机 。这就要求程序不仅要具备五子棋的基本界面 ， 还要编程指导计算机与人进行对弈 。为了使程序尽可能智能，我采用了贪心策略、传统搜索算法、极大极小博弈树算法，对应游戏玩家的3个等级：简单、中等、困难 。
三、功能设计
我的程序基本功能是实现人机对弈五子棋 。人和电脑交替下棋 ， 谁先五子连成一条直线谁就赢 。下面是我程序的功能模块：
1.等级设置
核心功能是实现不同策略与算法的对比运用，纯贪心策略实现简单等级对手，直接搜索算法实现中等等级对手，极大极小博弈树算法实现困难等级对手 。对应程序中的3选1单选按钮 。
2.悔棋功能
模拟栈机制实现人悔棋 ， 不限步长的悔棋 。对应程序中的悔棋按钮 。
3.棋面绘制
根据不同机计算机的屏幕分辨率，绘制逼真的棋盘 。
4.图片引入
两张古典的人物图片，生动模拟对弈双方 。人物图片旁的黑白棋钵图片显示黑白棋归属 。
5.背景设置
支持用户选择背景，包括棋盘、棋盘边框、窗口边框，彰显个性 。
6.音乐播放
下棋时有棋子落地的声音 ， 一方胜利时有五子连成一片的声音 。同时在设置背景时相应的改变整个对弈过程中的背景音乐 。
7.时间显示
在棋盘正上方有一模拟文本框显示当前棋局用时 。
8.其他小功能
支持和棋、认输、开启新游戏、退出游戏等操作 。
四、数据结构与算法设计
数据结构部分
1.当前棋局的存储结构
我的五子棋程序选择通常用到的15行*15列棋盘，可以开二维数组PositionFlag = new int[15][15]，PositionFlag[i][j]为0表示(i,j)点尚无棋，为1表示(i,j)点是人的棋子 ， 为2表示(i,j)点是机器的棋子 。之所以选择二维数组，主要原因有两点：
1.本程序需要频繁随机访问15*15的交叉点，对应查询该点状态以及改变该点状态 ， 随机访问是数组的特点 。
2.15*15=225开二维数组的内存需求相对现在内存为2G及以上的计算机完全可以接受，且数组实现简单、操作方便 。
基于以上两点，尽管创建动态的顺序表—链表可能可以节省少量内存（可以只存当前有棋的点，原数组对应位置为0的点可以不存），但选择数组的优势完全在上述两点体现了出来 。
2.实现悔棋操作的数据结构
由于每次悔棋只需回退当前几步 ， 后进先出原则，这正是栈这种典型数据结构的设计思想，于是我选择栈 。我自己先写了用自定义数组模拟的栈，但由于是学Java语言且由于悔棋的存储空间需要随当前步数增大而增大（由于每局最多下225步，即最多要悔225步，所以自己开个225的数组完全可以避免存储空间自增长的问题且内存完全可以接受，之所以不用自定义数组而用ArrayList类主要是为了尝试Java中STL的用法），所有我最终改为用Java类库中的ArrayList类 。
确定用ArrayList类实现栈机制后就必须考虑每个ArrayList单元具体存储什么 。刚开始我存储的是当前的棋局，即整个局面，而每个局面对应一个二维数组，这样是很占用内存的 。试想一下，在最坏情况下，225个ArrayList单元，每个单元存放一个15*15的二维数组 ， 尽管225*15*15在Java的内存管理机制下不会爆栈 ， 但也是极不划算的 。之所以说不划算 ， 是因为有更好的解决方案 。由于每次悔棋只是在回退倒数一步，多步悔棋只需循环回退，所以可以只存储当前棋局最后一步的下法，对应一个二维点，完全可以自定义一个二维坐标类chessOneStep 。
算法设计部分
Java语言是面向对象的语言 。我在进行五子棋游戏编程是总共传创建了11个自定义的类 。在编写程序的过程中，我有一个明显的体验就是面向对象编程就是一项有关对象设计和对象接口技术，很多关键的技术就是如何设计自定义的对象 。
下面我先概括给出我的所有类的作用：
1.mainFrame类：主框架类 ， 我应用程序的入口；
2.chessPositon类：主控类，这个类是我程序的核心类，负责控制双方的下棋 ， 以及调用其他的类完成当前棋局的显示绘制；
3.chessPanel类：面板类 ， 调用其他底层类完成当前棋局的显示绘制；
4.chessBoard类：棋盘绘制类 ， 负责棋盘的绘制；
5.chessImage类：文件类，包含各种资源（背景图片、背景音乐）以及静态全局变量（public static Type）；
6.chessButton类：组件类，定义各种组件，包括按钮、单选按钮、文本框等；
7.chessMusic类：音乐类，负责调用Java库类完成背景音乐、下棋音乐、取胜音乐等的播放；
8.chessPiece类：棋局类，定义棋局二维数组数据结构并完成相关操作；
9.chessList类：栈类，完成悔棋等操作；
10. chessOneStep类：棋子类，定义每步坐标以及下在该处获得的估价值；
11.myCompare类：排序类，完成chessOneStep类的自定义排序
详细设计
1.mainFrame类
作为我的五子棋程序的主类 ， mainFrame类主要实例化相关的对象，如chessbutton,chessborad等，从而完成框架的创建 。更重要的是实例化chessposition，这是本程序的核心类，控制游戏双方行棋过程完成人机互动下棋 ， 然后将MyChessPosition与鼠标响应addMouseListener（）关联起来 。
2.chessMusic类
一个好的游戏必须给人一种身临其境的感觉，而声音是营造这种氛围的重要因素 。参照网上各游戏运行商的音乐配置，我选择相关逼真的声音 。包括背景音乐、下棋棋子落到棋盘发出的声音以及一方胜出的配乐 。所有这些功能的实现 ， 依赖于自定义的chessMusic类，采用AudioInputStream配合Clip的方式完成音乐播放的软硬件工作，然后定义两个接口chessmusic(String Name)和Stop(),前者完成播放功能，后者完成关闭当前音乐功能 。因为音频文件相对较大，而我的程序提供在不同背景乐之间切换的功能，所以在打开另一个音频文件之前必须关闭前一个正在播放的音频文件，防止出现溢出 。
3.chessImage类
适当的动画或图片能给游戏玩家带来美的体验 。所以我的五子棋程序界面在不失和谐的前提下引入了尽可能多的图片，包括对弈双方、棋钵等 。图片引入的具体工作通过语句import javax.imageio.ImageIO完成 。同时，由于图片要在用到它的类中被访问，为了避免频繁调用函数，我直接将图片相关联的对象定义为public static，表明是公用的、静态的 。进一步引申开去，我将程序中用到的静态全局变量都定义在chessImage类中 。具体如下：
public static Date begin;//每局开始时间
public static Date cur;//每局结束时间
public static chessOneStep LineLeft;//结束端点1
public static chessOneStep LineRight;//结束端点2
public static boolean IsGameOver;//是否只有一方获胜
public static int ColorOfBackGround[][]= {{255, 227, 132},{0,255,127},{218,165,32}};//背景颜色
public static int ColorOfWindows[][]= {{ 60,179,113},{245,245,245},{122,122,122}};//背景颜色
public static int WitchMatch;//背景搭配
public static String MusicOfBackGround;//背景音乐
public static int CurrentStep;//记录当前步数
public static int Rank;//设置难度等级
public static boolean IsSurrender;//判断是否认输
public static boolean IsTie;//判断是否认输
public static String Message;//输出提示信息
public static Image IconImage;// 图标
public static Image blackBoard;//白棋盘
public static Image whiteBoard;//黑棋盘
public static Image blackChess;// 白棋棋子图片
public static Image whiteChess;// 白棋棋子图片
public static Image RightPlayer;//白棋棋罐图片
public static Image LeftPlayer;//白棋玩家头像图片
public static String path = "src/";// 图片的保存路径
4.chessButton类
这个是程序的组件类 。定义了各种功能键，完善程序功能，营造逼真的人机对战游戏效果 。分为3类：效果 。。
(1)、按钮组件
本程序有5个按钮，支持和棋、认输、新游戏、退出、悔棋等 。认输和和棋按钮终止当前的棋局，给出相应的提示信息；退出按钮调用系统System.exit(0)的函数正常返回；悔棋按钮调用后面要介绍的chessList类实现悔棋；新游戏按钮则刷新当前棋局准备下一轮，要将记录当前棋局的二维数组全部置0，刷新当前棋局开始时间等 。
(2)、单选按钮组件
游戏界面支持设置个性化界面 ， 包括背景颜色与背景音乐，跟重要的一点是设置难度（简单、中等、困难） 。单选按钮只能多选一 。背景颜色主要是存储相关颜色搭配方案的RGB颜色，开2维数组，即对应RGB3原色数组的一维数组 ， 然后通过改变WitchMatch全局变量的值来有用户自己选择颜色搭配，不同的颜色搭配对应不同的背景音乐表达一致的主题 。难度设置主要是改变计算机的下棋算法，不同难度通过Rank判断进入不同的程序分支 ， 实现不同智能等级的计算机下棋水平 。
(3)、文本框
在不同的单选按钮前添加相应的文本框，提示用户可以实现的功能 。同时我用颜色模拟出显示当前棋局耗用时间的文本框 。
不论按钮还是单选按钮都要关联相应的消息，把相应功能的实现放在消息响应处理函数理 。这些主要是实现Java库提供的消息响应接口里的方法 。
5.chessPiece类
主要完成当前棋面的存储，存储棋面的数据结构为二维数组int[][] PositionFlag；然后定义获取、设置某点以及整个棋面的状态的方法 。
(1)、SetPositionFlag(int x, int y, int flag)//设置（x,y）处的状态为flag
(2)、GetPositionFlag(int x, int y)//获?。▁,y）处的状态
(3)、SetAllFlag(int [][]NewFlag)//设置当前整个棋面的状态为NewFlag
(4)、GetAllFlag()//获取当前整个棋面的状态
(5)、DrawChessPiece(Graphics g)//绘制当前局面的棋子
由于本类比较重要 ， 所以附上了代码，见源代码1 。
6.chessBoard类
功能为绘制棋盘线 。由于围棋的棋盘比较复杂，横线、竖线较多，且为了使棋盘美观，还要自定义窗口边框、棋盘边框、对弈双方边框等，对线宽、线型也有一定要求 。有时要单像素线条，有时要多像素线条 。对于多像素线条，我主要用了2种方法 。
方法一：
在需要绘制多像素线条处首先绘制一条单像素线，然后根据线宽要求上下平移适当像素达到绘制多像素的目的 。这样的方法适合绘制水平线或竖直线，绘制其他斜率的线条容易造成走样 。在没有想到比较好的反走样编程思想后我选择了调用Java库中已经封装好的函数 。
方法二：
为了克服方法一绘制非水平或竖直线时造成的走样，同时也为了更进一步学习Java语言，我猜想肯定会有类似OpenGL中设置线宽的画刷，于是上网百度找到了相应的画刷Stroke类 。通过Java库实现绘制不同线宽的直线，达到了反走样效果 。
7.chessOneStep类
这个类是为了配合chessList类实现悔棋以及在计算机下棋算法实现返回有效状态点而设计的 。主要数据成员为
privateintx,y,weight；//其中x,y表示点坐标 ， weight表示将棋下到该点获得的估价值 。
主要方法如下：
(1)、GetX()//获得当前对象的x坐标
(2)、GetY()//获得当前对象的y坐标
(3)、GetWeight()//获得当前对象的(x,y)处的估价值
8.chessList类
程序支持悔棋功能，为了实现悔棋，自定义了chessList类 。这个类主要通过引入java.util.ArrayList和java.util.List实现集合的数据类型 。然后自定义一些方法 ， 如下：
（1）、AddStep(chessOneStep OneStep)//添加一步棋到List中
（2）、GetSize()//获得当前List的大小
（3）、ClearList()//清空List
（4）、RemoveLast()//删去List中的最后元素
由于每次删除当前List中的最后一个元素，实现后进先出 ， 所以可以模拟栈的功能实现悔棋 。
9.myCompare类
由于在计算机下棋的极大极小博弈树算法中需要对自定义对象chessOneStep按weight进行排序，所以引入了myCompare类 ， 通过实现Comparator接口中的compare方法完成自定义对象排序 。
10.chessPanel类
程序的自定义面板类，主要负责完成当前框架内容的显示 。这是一个重要的与框架和图形显示密切相关的类 。主要数据成员为
private chessboard MyChessBoard;//当前显示棋盘
private chesspiece MyChessPiece;//当前显示整个棋面的状态
主要方法如下：
（1）、chesspanel(chessboard MyChessBoard1, chesspiece MyChessPiece1)//构造函数 ， 分别用MyChessBoard1和MyChessPiece1初始化MyChessBoard和MyChessPiece
（2）display(chessboard MyChessBoard1, chesspiece MyChessPiece1)//自定义显示回调函数，调用repaint()完成重新绘制游戏界面
（3）、paintComponent(Graphics g)//核心方法，调用各种函数完成具体的绘制工作
11.chessPositon类
程序算法核心类，总的功能是控制人和计算机轮流下棋，以及调用chessPanel类中的display(chessboard , chesspiece )方法完成界面的实时刷新 。关于chessPositon类，我在此将重点介绍 。chessPosition类的主要数据成员如下：
private static chessboard MyChessBoard;//当前显示棋盘
public static chesspiece MyChessPiece;//当前显示整个棋面的状态
private static chesspanel Mychesspanel;////当前显示面板
public static chesslist MyChessList=new chesslist();//当前下棋集合，用于悔棋
final private static int INF = (130); // 表示正无穷大的常量，用于极大极小博弈数搜索算法
public static boolean CanGo;//控制当前下棋一方
类的设计集中体现在成员方法的设计上 。实现人机对战，只有语言是远远不够的 ， 还要加入算法，用算法引导计算机下棋 。下面介绍该类的方法成员：
（1）、chessposition(chesspanel , chessboard ,chesspiece ) //带有参数的构造函数
（2）、chessposition()
不带参数的构造函数
（3）、mouseClicked(MouseEvent event)
鼠标响应函数 ， 负责人的下棋，根据鼠标点击的位置转换得到所在棋盘的相对位置 。如果该位置不合法，即超出棋盘有效范围，点击无响应；如果该位置上已有棋，弹出消息框给出提示 。这二者都要求重新给出下棋位置，即当前鼠标响应无效…直到点击到棋盘有效区域 。
（4）、IsOver(int[][] Array,int x,int y)
判断当前int[][]Array对应的棋局是否结束，即一方五子连成一条直线 。此处有两种思路，一种对当前棋面上的所有棋子都进行一次判断 ， 具体为水平方向、竖直方向、与水平线成45度方向、与水平线成135度方向 ， 只要有一个方向五子连成一条直线就说明有一方获胜，游戏结束；另一种思路为只在当前下棋的4个方向进行判断，我的程序采用的是第二种，所以IsOver方法除了int[][]Array参数外 ， 还有x,y参数，（x,y）表示当前下棋的坐标点 。
（5）display()
通过调用自定义面板类的显示回调函数用于重新显示游戏界面，达到每下一步棋及时更新游戏界面的目的 。
（6）、GetValue(int flag, int num)
估值函数，根据经验把棋局分成只有1颗棋相连，2颗棋相连且两端被封死 ， 2颗棋相连且一端封死另一端活的，2颗棋相连且两端都是活的，同理3颗棋、4颗棋也各自可分3种情况 。不同的情况对应不同的估价值 。估价值的设定是决定计算机一方是否智能的一个关键因素 。
（7）、GetPredictValue(int flag, int num)
对未连成一片但通过再下一颗子就能连成一片的局面进行估值 ， 这在双方下棋的有限步骤内是能产生重要影响的 。如果每局棋仅考虑当前一步 ， 是不可取的 。
（8）、Evaluate(int[][] Array, int x, int y)
根据棋面具体情况以及预先设定的估值函数，对某个点对应的局面进行评估 。由于每次双方只能下一颗棋 ， 所以可以每次取当前局面的所有点中对应估值最大值点的估值作为整个局面的估值 。
（9）、GetGreedNext()
计算机下棋方法1 ， 对应难度等级为简单，采用贪心思想 。每次下棋前在求得最有利点下棋，而是否最有利只是通过一步评估 。算法伪码描述为：
Max取负无穷大
for(行i从0到15)
{
For(列j从0到15)
{
If((i ， j)对应的位置无棋)
{
a.假设放上一颗由人控制的棋，求估价值；
b.假设放上一颗由计算机控制的棋，求估价值；
c.取二者中较大值作为(i,j）处的估价值tmp；
d.取tmp与Max较大值赋值给Max.
}
}
}
最终Max对应的点就是当前整个局面中最大的估值点 。至于上述为什么要考虑双方都在该点下棋的情况呢？主要原因为下五子棋是个攻防兼备的过程，不仅要考虑自己对自己最有利，还要考虑对对手最不利，通俗来讲就是在自己赢的时候不能让对手先赢 。
（10）、GetSearchNext(int LookLength)
derectSearch(int [][]Array,boolean who,int deepth)
计算机下棋方法2：直接搜索法,对应难度等级为中等 。
每步棋最多有225个不同下法，若采用直接搜索法则对应的孩子节点有225个（在下棋过程中会逐渐减少），即每层有最多225个节点待扩展 ， 这就决定了直接搜索进行不超过2次—主要原因有两点：
a.采用深度优先搜索需要递归，递归中状态过多可能会爆栈，我们知道递归是用栈机制来实现的；采用宽度优先搜索又需要存储为扩展的节点 ， 这对内存容量要求很高 。
b.不管深搜还是广搜，在时间复杂度为O(N^m)的情况下都是不能接受的 。其中N为当前棋局的待扩展节点，最大225;m为搜索的深度 。
综上所述 ， 在采用直接搜索法时搜索深度不能太深，严格来说是应该控制在2层以内，在计算机运算速度在10^7次每秒的情况下，理论和实验都表明超过2层就会变得很慢且这种趋势成指数级增长 。
直接搜索算法伪代码为
GetSearch(boolean flag，int deep)
{
如果deep等于0，返回当前棋局估值；
for(行i从0到15)
{
For(列j从0到15)
{
If((i，j)对应的位置无棋)
{
如果轮到计算机下棋，置标志位为2
GetSearch(！flag，deep-1)；
如果轮到人下棋，置标志位为1；
GetSearch(！flag ， deep-1)；
}
}
}
}
（11）、GetMinMaxsearchNext(int LookLength)
MinMaxsearch(int [][]Array,boolean who, int deepth)
计算机下棋算法3：极大极小博弈树法,对应难度等级为困难 。五子棋是个博弈游戏 ， 当前在寻找对自己最有利的下棋点时要尽可能保证对对手最不利，这种思想可以用极大极小博弈树
急求Java黑白棋设计源代码importjava.awt.*;
importjava.awt.event.*;
importjavax.swing.*;
importjava.awt.geom.*;
importjavax.swing.JOptionPane.*;
publicclassFiveChess
{
publicstaticvoidmain(String[]args)
{
JFramemyFrame=newJFrame("快乐五子棋");
myFrame.getContentPane().add(newMyPanel());
Toolkitmykit=myFrame.getToolkit();
Dimensionmysize=mykit.getScreenSize();
myFrame.setBounds(0,0,mysize.width,mysize.height-40);
myFrame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
myFrame.show();
}
}
classMyPanelextendsJPanelimplementsMouseListener
{
privatePointstart=newPoint(0,0);
privatePointnext=newPoint(0,0);
boolean[][]chessBo=newboolean[19][19];
booleanchessCo=true; //判断颜色的，true黑
booleanwinchess=true; //true,为胜利
MyPanel(){
addMouseListener(this);
setBackground(Color.blue);
}
publicbooleanwinkill(intx,inty) //win?
{
intcountBlack=0,countWhite=0;
booleanwinchess01=false;
//x,y取到r01,r02的值
for(inti=0;i5;i)//判断纵向下
{
if((xi)20)
break;
if(chessCochessBo[xi][y])
countBlack;
elseif(chessBo[xi][y](chessCo==false))
countWhite;
}
for(inti=0;i5;i)//判断纵向上
{
if((x-i)=0)
break;
if(chessCochessBo[x-i][y])
countBlack;
elseif(chessBo[x-i][y](chessCo==false))
countWhite;
}
if((countBlack==5)||(countWhite==5))
winchess01=true;
returnwinchess01;
}
publicvoidpaint(Graphicsg)//画棋盘
{
Graphics2Dg2D=(Graphics2D)g;
g2D.setPaint(Color.black);
floatpay=60.0f,pbx=60.0f;
floatlett=25.0f;
Point2D.Floatp1=newPoint2D.Float(60.0f,pay);
Point2D.Floatp2=newPoint2D.Float(510.0f,pay);
Point2D.Floatp3=newPoint2D.Float(pbx,60.0f);
Point2D.Floatp4=newPoint2D.Float(pbx,510.0f);
for(inti=0;i19;i){
Line2D.FloatlineH=newLine2D.Float(p1,p2);
Line2D.FloatlineV=newLine2D.Float(p3,p4);
pay=lett;
p1=newPoint2D.Float(60.0f,pay);
p2=newPoint2D.Float(510.0f,pay);
pbx=lett;
p3=newPoint2D.Float(pbx,60.0f);
p4=newPoint2D.Float(pbx,510.0f);
g2D.draw(lineH);
g2D.draw(lineV);
}
}
publicvoidmousePressed(MouseEventevt)
{
}
publicvoidmouseClicked(MouseEventevt)
{
intx=evt.getX();
inty=evt.getY();
intclickCount=evt.getClickCount();
if(clickCount=1){
if((x48x522)(y48y522))
draw(x,y);
}
}
publicvoiddraw(intdx,intdy)
{
intr01=0,r02=0;
Graphicsg=getGraphics();
start.x=dx;
start.y=dy;
r01=(start.x13-60)/25; //r01、r02当前的格子
r02=(start.y13-60)/25;
//System.out.println(r01"-"r02);
next.x=25*r0160-11;
next.y=25*r0260-11;
//System.out.println(next.x"-"next.y);
if(chessCo){
chessCo=false;
g.setColor(Color.black);
g.fillOval(next.x,next.y,20,20);
chessBo[next.x][next.y]=true;//用这个时，黑白子可交替出现，
//chessBo[r01][r02]=true;//用这个代替上面那个时黑白子不可交替了，不知道为什么会这样
//加入判断胜负的方法winkill()
if(winchess==winkill(r01,r02))
showMessage();
}
if(!chessCo){
chessCo=true;
g.setColor(Color.white);
g.fillOval(next.x,next.y,20,20);
chessBo[r01][r02]=true;
}
//g.drawOval(next.x,next.y,20,20);
g.dispose();
}
publicvoidmouseReleased(MouseEventevt)
{
}
publicvoidmouseEntered(MouseEventevt)
{
}
publicvoidmouseExited(MouseEventevt)
{
}
publicvoidshowMessage()
{
JOptionPane.showMessageDialog(null,
"Youarewin.",
"wide288toMessage!",
JOptionPane.INFORMATION_MESSAGE);
}
}
【人机黑白棋java源代码 java课程设计】关于人机黑白棋java源代码和java课程设计的介绍到此就结束了，不知道你从中找到你需要的信息了吗 ？如果你还想了解更多这方面的信息 ， 记得收藏关注本站 。

    推荐阅读


    上一篇：如何获取lite服务器？ lite服务器怎么获得

    下一篇：如何在苹果系统上登录服务器？ 苹果系统怎么登录服务器