devbox
我家小花儿
这个屌丝很懒，什么也没留下！
关注作者
热门标签
热门文章
当前位置:   article > 正文

单机版五子棋【JAVA】_java五子棋内容

作者：我家小花儿 | 2024-03-27 18:58:50

赞

踩

java五子棋内容
单机版五子棋

这个小游戏是我和我姐们儿的JAVA课程设计，也是我做的第一个JAVA项目，适合初学者，希望能帮到那些被JAVA课设所困扰的孩纸们~~~

一、该游戏需要的实现的：

1、设计主框架，界面。

2、利用ActionListener接口实现按钮事件的监听。

3、重新开始功能的实现。

4、悔棋功能的实现。

5、退出功能的实现。

6、棋盘中棋子点类的定义。

7，利用MouseListener接口实现事件监听，并实现接口里的所有方法。

8，当鼠标移动到棋盘上的交点上，且该点上无棋子时能够变成小手形状。

9，点击棋盘时，利用if语句判断该点是否点在交点上，并利用foreach语句和棋子类中的getX（），getY（）方法遍历每一个棋子的位置判断该点是否有棋子。

10，当判断到可以在所点击的点上下子时，画棋子时利用for循环遍历已有的每一个点并利用Graphics类的setColor设置颜色，利用Graphics类的fillOval方法设置形状大小。

11，当画完棋子时要及时判断输赢，用棋子所在索引和for循环遍历最后一个棋子的各个方向，如果有在同一条直线上的棋子个数大于等于五的即当前棋子所代表的那方赢。

12，胜负已定的时候，能够弹出相应的信息。

二、功能代码实现

2.1进入游戏

  1. public static void main(String[] args) {
  2. 		StartChessJFrame f=new StartChessJFrame();//创建主框架
  3. 		f.setVisible(true);//显示主框架
  4. 	}

2.2初始化，定义一些要用到的量。

  1. private ChessBoard chessBoard;//对战面板
  2. 	private Panel toolbar;//工具条面板
  3. 	private Button startButton;//设置开始按钮
  4. 	private Button backButton;//设置悔棋按钮
  5. 	private Button exitButton;//设置退出按钮

2.3界面的构造方法（游戏的框架）

  1. public StartChessJFrame(){
  2. 		setTitle("单机版五子棋");//设置标题
  3. 		chessBoard=new ChessBoard();//初始化面板对象，创建和添加菜单
  4. 		MyItemListener lis=new MyItemListener();//初始化按钮事件监听器内部类
  5. 		toolbar=new Panel();//工具面板栏实例化
  6. 		startButton=new Button("重新开始");
  7. 		backButton=new Button("悔棋");
  8. 		exitButton=new Button("退出");//三个按钮初始化
  9. 		toolbar.setLayout(new FlowLayout(FlowLayout.LEFT));//将工具面板按钮用FlowLayout布局
  10. 		toolbar.add(backButton);
  11. 		toolbar.add(startButton);
  12. 		toolbar.add(exitButton);//将三个按钮添加到工具面板上
  13. 		startButton.addActionListener(lis);
  14. 		backButton.addActionListener(lis);
  15. 		exitButton.addActionListener(lis);//将三个按钮事件注册监听事件
  16. 		add(toolbar,BorderLayout.SOUTH);//将工具面板布局到界面南方也就是下面
  17. 		add(chessBoard);//将面板对象添加到窗体上
  18. 		setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);//设置界面关闭事件
  19. 		pack();//自适应大小
  20. 	}

2.4按钮的实现与监听（构造方法内部）

  1. MyItemListener lis=new MyItemListener();//初始化按钮事件监听器内部类
  2. 		toolbar=new Panel();//工具面板栏实例化
  3. 		startButton=new Button("重新开始");
  4. 		backButton=new Button("悔棋");
  5. 		exitButton=new Button("退出");//三个按钮初始化
  6. 		toolbar.setLayout(new FlowLayout(FlowLayout.LEFT));//将工具面板按钮用FlowLayout布局
  7. 		toolbar.add(backButton);
  8. 		toolbar.add(startButton);
  9. 		toolbar.add(exitButton);//将三个按钮添加到工具面板上
  10. 		startButton.addActionListener(lis);
  11. 		backButton.addActionListener(lis);
  12. 		exitButton.addActionListener(lis);//将三个按钮事件注册监听事件

2.5按钮事件的监听

  1. private class MyItemListener implements ActionListener{
  2. 		public void actionPerformed(ActionEvent e) {
  3. 			Object obj=e.getSource();//获取事件源
  4. 			if(obj==startButton){
  5. 				System.out.println("重新开始...");//重新开始
  6. 				//JFiveFrame.this内部类引用外部类
  7. 				chessBoard.restartGame();
  8. 			}else if(obj==exitButton){
  9. 				System.exit(0);//结束应用程序
  10. 			}else if(obj==backButton){
  11. 				System.out.println("悔棋...");//悔棋
  12. 				chessBoard.goback();
  13. 			}			
  14. 		}		
  15. 	}

2.6重新开始按钮的功能实现

  1. public void restartGame(){//清除棋子
  2. 		for(int i=0;i<chessList.length;i++)
  3. 			chessList[i]=null;
  4. 		/*恢复游戏相关的变量值*/
  5. 		isBack=true;
  6. 		gameOver=false;//游戏是否结束
  7. 		chessCount=0;//当前棋盘的棋子个数
  8. 		repaint();		
  9. 	}

2.7悔棋按钮的功能实现

  1. public void goback(){
  2. 		if(chessCount==0)
  3. 			return ;
  4. 		chessList[chessCount-1]=null;
  5. 		chessCount--;
  6. 		if(chessCount>0){
  7. 			xIndex=chessList[chessCount-1].getX();
  8. 			yIndex=chessList[chessCount-1].getY();
  9. 		}
  10. 		isBack=!isBack;
  11. 		repaint();
  12. 	}

2.8当棋盘根据需要变大或变小时窗口应随之发生改变

  1. //Dimension:矩形ChessBoard类内部
  2. 	public Dimension getPreferredSize(){
  3. 		return new Dimension(MARGIN*2+GRID_SPAN*COLS,MARGIN*2+GRID_SPAN*ROWS);
  4. 	}	
  5. pack();//自适应大小StartChessBoard类内部

2.9定义棋子类

  1. import java.awt.*;
  2. public class Point {
  3. 	private int x;//棋子在棋盘中的x索引值
  4. 	private int y;//棋子在棋盘中的y索引值
  5. 	private Color color;//颜色
  6. 	public static   int DIAMETER=30;//直径
  7. 	public Point(int x,int y,Color color){
  8. 		this.x=x;
  9. 		this.y=y;
  10. 		this.color=color;
  11. 	}
  12. 	//得到棋子在棋盘中的x索引值
  13. 	public int getX(){
  14. 		return x;
  15. 	}
  16. 	//得到棋子在棋盘中的y索引值
  17. 	public int getY(){
  18. 		return y;
  19. 	}
  20. 	//得到棋子颜色
  21. 	public Color getColor(){
  22. 		return color;
  23. 	}
  24. }

三、功能部分代码实现

3.1初始化，定义一些要用到的量。

  1. public static int MARGIN=30;//边距
  2. 	public static int GRID_SPAN=35;//网格间距
  3. 	public static int ROWS=18;//棋盘行数
  4. 	public static int COLS=18;//棋盘列数
  5. 	Point[] chessList=new Point[(ROWS+1)*(COLS+1)];//初始化每个数组元素为null
  6. 	boolean isBack=true;//默认开始是黑棋先下
  7. 	boolean gameOver=false;//游戏是否结束
  8. 	int chessCount;//当前棋盘的棋子个数
  9. 	int xIndex,yIndex;//当前刚下棋子的索引

3.2棋盘对象的构造方法

  1. public ChessBoard(){
  2. 		setBackground(Color.LIGHT_GRAY);//设置背景颜色为灰色
  3. 		addMouseListener(this);//添加事件监听器
  4. 		addMouseMotionListener(new MouseMotionListener() {//匿名内部类
  5. 			
  6. 			@Override
  7. 			public void mouseMoved(MouseEvent e) {
  8. 				int x1=(e.getX()-MARGIN+GRID_SPAN/2)/GRID_SPAN;
  9. 				int y1=(e.getY()-MARGIN+GRID_SPAN/2)/GRID_SPAN;//将鼠标单击的坐标位置转化为网格索引
  10. 				if(x1<0||x1>ROWS||y1<0||y1>COLS||gameOver||findChess(x1,y1)){//游戏已经结束，不能下；落在棋盘外，不能下；x，y位置已经有棋子存在，不能下
  11. 					setCursor(new Cursor(Cursor.DEFAULT_CURSOR));//设置成默认形状
  12. 				}else{
  13. 					setCursor(new Cursor(Cursor.HAND_CURSOR));//设置成手型
  14. 				}
  15. 			}			
  16. 			@Override
  17. 			public void mouseDragged(MouseEvent e) {
  18. 			}
  19. 		});
  20. 	}

3.3设置鼠标监听器，变小手（在构造方法内部）

  1. addMouseMotionListener(new MouseMotionListener() {//匿名内部类
  2. 			
  3. 			@Override
  4. 			public void mouseMoved(MouseEvent e) {
  5. 				int x1=(e.getX()-MARGIN+GRID_SPAN/2)/GRID_SPAN;
  6. 				int y1=(e.getY()-MARGIN+GRID_SPAN/2)/GRID_SPAN;//将鼠标单击的坐标位置转化为网格索引
  7. 				if(x1<0||x1>ROWS||y1<0||y1>COLS||gameOver||findChess(x1,y1)){//游戏已经结束，不能下；落在棋盘外，不能下；x，y位置已经有棋子存在，不能下
  8. 					setCursor(new Cursor(Cursor.DEFAULT_CURSOR));//设置成默认形状
  9. 				}else{
  10. 					setCursor(new Cursor(Cursor.HAND_CURSOR));//设置成手型
  11. 				}
  12. 			}			
  13. 			@Override
  14. 			public void mouseDragged(MouseEvent e) {
  15. 			}
  16. 		});

3.4点击棋盘时的鼠标按压事件

  1. public void mousePressed(MouseEvent e) {//鼠标按键在组件上按下时调用
  2. 		if(gameOver)//游戏已经结束，不能下
  3. 			return ;
  4. 		String colorName=isBack ? "黑棋" : "白棋";
  5. 		xIndex=(e.getX()-MARGIN+GRID_SPAN/2)/GRID_SPAN;
  6. 		yIndex=(e.getY()-MARGIN+GRID_SPAN/2)/GRID_SPAN;//将鼠标单击的坐标位置转化为网格索引
  7. 		if(xIndex<0||xIndex>ROWS||yIndex<0||yIndex>COLS)//棋子落在棋盘外，不能下
  8. 			return ;
  9. 		if(findChess(xIndex,yIndex))//x,y位置已经有棋子存在，不能下
  10. 			return ;		
  11. 		Point ch=new Point(xIndex,yIndex,isBack ? Color.black : Color.white);
  12. 		chessList[chessCount++]=ch;
  13. 		repaint();//通知系统重新绘制
  14. 		if(isWin()){
  15. 			String msg=String.format("恭喜，%s赢啦~", colorName);
  16. 			JOptionPane.showMessageDialog(this, msg);
  17. 			gameOver=true;			
  18. 		}
  19. 		else if(chessCount==(COLS+1)*(ROWS+1))
  20. 		{
  21. 			String msg=String.format("棋鼓相当，棒棒哒~");
  22. 			JOptionPane.showMessageDialog(this,msg);
  23. 			gameOver=true;
  24. 		}
  25. 		isBack=!isBack;
  26. 	}

3.5绘制棋盘，棋子还有红框框

  1. public void paintComponent(Graphics g){
  2. 		super.paintComponent(g);//画棋盘
  3. 		for(int i=0;i<=ROWS;i++){//画横线
  4. 			g.drawLine(MARGIN, MARGIN+i*GRID_SPAN, MARGIN+COLS*GRID_SPAN, MARGIN+i*GRID_SPAN);
  5. 		}
  6. 		for(int i=0;i<=COLS;i++){//画直线
  7. 			g.drawLine(MARGIN+i*GRID_SPAN, MARGIN, MARGIN+i*GRID_SPAN,MARGIN+ROWS*GRID_SPAN);
  8. 		}
  9. 		/*画棋子*/
  10. 		for(int i=0;i<chessCount;i++){
  11. 			int xPos=chessList[i].getX()*GRID_SPAN+MARGIN;//网格交叉的x坐标
  12. 			int yPos=chessList[i].getY()*GRID_SPAN+MARGIN;//网格交叉的y坐标
  13. 			g.setColor(chessList[i].getColor());//设置颜色
  14. 			g.fillOval(xPos-Point.DIAMETER/2, yPos-Point.DIAMETER/2, Point.DIAMETER, Point.DIAMETER);
  15. 			if(i==chessCount-1){
  16. 				g.setColor(Color.red);//标记最后一个棋子为红色
  17. 			    g.drawRect(xPos-Point.DIAMETER/2, yPos-Point.DIAMETER/2, Point.DIAMETER, Point.DIAMETER);
  18. 			}
  19. 		}
  20. 	}

3.6判断输赢

  1. /*判断哪方赢*/
  2. 	private boolean isWin(){
  3. 		int continueCount=1;//连续棋子的个数
  4. 		for(int x=xIndex-1;x>=0;x--){//横向向左寻找
  5. 			Color c=isBack ? Color.black : Color.white;
  6. 			if(getChess(x,yIndex,c)!=null){
  7. 				continueCount++;
  8. 			}else
  9. 				break;
  10. 		}
  11. 		for(int x=xIndex+1;x<=ROWS;x++){//横向向右寻找
  12. 			Color c=isBack ? Color.black : Color.white;
  13. 			if(getChess(x,yIndex,c)!=null){
  14. 				continueCount++;
  15. 			}else
  16. 				break;
  17. 		}
  18. 		if(continueCount>=5){//判断记录数大于等于五，即表示此方获胜
  19. 			return true;
  20. 		}else
  21. 			continueCount=1;
  22. 		//
  23. 		for(int y=yIndex-1;y>=0;y--){//纵向向上寻找
  24. 			Color c=isBack ? Color.black : Color.white;
  25. 			if(getChess(xIndex,y,c)!=null){
  26. 				continueCount++;
  27. 			}else
  28. 				break;
  29. 		}
  30. 		for(int y=yIndex+1;y<=ROWS;y++){//纵向向下寻找
  31. 			Color c=isBack ? Color.black : Color.white;
  32. 			if(getChess(xIndex,y,c)!=null){
  33. 				continueCount++;
  34. 			}else
  35. 				break;
  36. 		}
  37. 		if(continueCount>=5){//判断记录数大于等于五，即表示此方获胜
  38. 			return true;
  39. 		}else
  40. 			continueCount=1;
  41. 		//
  42. 		for(int x=xIndex+1,y=yIndex-1;y>=0&&x<=COLS;x++,y--){//右下寻找
  43. 			Color c=isBack ? Color.black : Color.white;
  44. 			if(getChess(x,y,c)!=null){
  45. 				continueCount++;
  46. 			}else
  47. 				break;
  48. 		}
  49. 		for(int x=xIndex-1,y=yIndex+1;y<=ROWS&&x>=0;x--,y++){//左上寻找
  50. 			Color c=isBack ? Color.black : Color.white;
  51. 			if(getChess(x,y,c)!=null){
  52. 				continueCount++;
  53. 			}else
  54. 				break;
  55. 		}
  56. 		if(continueCount>=5){//判断记录数大于等于五，即表示此方获胜
  57. 			return true;
  58. 		}else
  59. 			continueCount=1;
  60. 		//
  61. 		for(int x=xIndex-1,y=yIndex-1;y>=0&&x>=0;x--,y--){//左下寻找
  62. 			Color c=isBack ? Color.black : Color.white;
  63. 			if(getChess(x,y,c)!=null){
  64. 				continueCount++;
  65. 			}else
  66. 				break;
  67. 		}
  68. 		for(int x=xIndex+1,y=yIndex+1;y<=ROWS&&x<=COLS;x++,y++){//右上寻找
  69. 			Color c=isBack ? Color.black : Color.white;
  70. 			if(getChess(x,y,c)!=null){
  71. 				continueCount++;
  72. 			}else
  73. 				break;
  74. 		}
  75. 		if(continueCount>=5){//判断记录数大于等于五，即表示此方获胜
  76. 			return true;
  77. 		}else
  78. 			continueCount=1;
  79. 		return false;		
  80. 	}

3.7弹出相应消息框（在鼠标按压函数内部）

  1. if(isWin()){
  2. 			String msg=String.format("恭喜，%s赢啦~", colorName);
  3. 			JOptionPane.showMessageDialog(this, msg);
  4. 			gameOver=true;			
  5. 		}
  6. 		else if(chessCount==(COLS+1)*(ROWS+1))//平局
  7. 		{
  8. 			String msg=String.format("棋鼓相当，棒棒哒~");
  9. 			JOptionPane.showMessageDialog(this,msg);
  10. 			gameOver=true;
  11. 		}

3.8上面用到的一个判断某点是否有棋子的函数

  1. private boolean findChess(int x,int y){
  2. 		for(Point c:chessList){
  3. 			if(c!=null&&c.getX()==x&&c.getY()==y)
  4. 				return true;
  5. 		}
  6. 		return false;
  7. 	}

3.9因为该棋盘类实现了鼠标监听接口MonseListener，所以要重写该接口内的所有方法，其它方法如下

  1. @Override
  2. 	public void mouseClicked(MouseEvent e) {//鼠标按键在组件上单击(按下并释放)时调用
  3. 	}
  4. 	@Override
  5. 	public void mouseReleased(MouseEvent e) {鼠标按键在组件上释放时调用
  6. 	}
  7. 	@Override
  8. 	public void mouseEntered(MouseEvent e) {//鼠标进入组件时调用
  9. 	}
  10. 	@Override
  11. 	public void mouseExited(MouseEvent e){//鼠标离开组件时调用	
  12. 	}

四、运行结果





五、代码汇总

该游戏总共建了三个类，一个是界面StartChessJFrame,一个是棋盘类ChessBoard，一个是棋子类Point

5.1StartChessJFrame类

  1. package chess.lcc.com;
  2. import javax.swing.*;
  3.  
  4. import java.awt.event.*;
  5. import java.awt.*;
  6. /*
  7.  * 五子棋的主框架，程序启动类
  8.  */
  9. public class StartChessJFrame extends JFrame {
  10. 	private ChessBoard chessBoard;//对战面板
  11. 	private Panel toolbar;//工具条面板
  12. 	private Button startButton;//设置开始按钮
  13. 	private Button backButton;//设置悔棋按钮
  14. 	private Button exitButton;//设置退出按钮
  15.  
  16. 	
  17. 	public StartChessJFrame(){
  18. 		setTitle("单机版五子棋");//设置标题
  19. 		chessBoard=new ChessBoard();//初始化面板对象，创建和添加菜单
  20. 		MyItemListener lis=new MyItemListener();//初始化按钮事件监听器内部类
  21. 		toolbar=new Panel();//工具面板栏实例化
  22. 		startButton=new Button("重新开始");
  23. 		backButton=new Button("悔棋");
  24. 		exitButton=new Button("退出");//三个按钮初始化
  25. 		toolbar.setLayout(new FlowLayout(FlowLayout.LEFT));//将工具面板按钮用FlowLayout布局
  26. 		toolbar.add(backButton);
  27. 		toolbar.add(startButton);
  28. 		toolbar.add(exitButton);//将三个按钮添加到工具面板上
  29. 		startButton.addActionListener(lis);
  30. 		backButton.addActionListener(lis);
  31. 		exitButton.addActionListener(lis);//将三个按钮事件注册监听事件
  32. 		add(toolbar,BorderLayout.SOUTH);//将工具面板布局到界面南方也就是下面
  33. 		add(chessBoard);//将面板对象添加到窗体上
  34. 		setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);//设置界面关闭事件
  35. 		pack();//自适应大小
  36. 	}
  37. 	private class MyItemListener implements ActionListener{
  38. 		public void actionPerformed(ActionEvent e) {
  39. 			Object obj=e.getSource();//获取事件源
  40. 			if(obj==startButton){
  41. 				System.out.println("重新开始...");//重新开始
  42. 				//JFiveFrame.this内部类引用外部类
  43. 				chessBoard.restartGame();
  44. 			}else if(obj==exitButton){
  45. 				System.exit(0);//结束应用程序
  46. 			}else if(obj==backButton){
  47. 				System.out.println("悔棋...");//悔棋
  48. 				chessBoard.goback();
  49. 			}			
  50. 		}		
  51. 	}
  52. 	public static void main(String[] args) {
  53. 		StartChessJFrame f=new StartChessJFrame();//创建主框架
  54. 		f.setVisible(true);//显示主框架
  55. 	}
  56. }
5.2ChessBoard类 
  1. package chess.lcc.com;
  2.  
  3. import javax.swing.*;
  4.  
  5. import java.awt.*;
  6. import java.awt.event.MouseListener;
  7. import java.awt.event.MouseMotionListener;
  8. import java.awt.event.MouseEvent;
  9. /*五子棋-棋盘类*/
  10. public class ChessBoard extends JPanel implements MouseListener{
  11. 	public static int MARGIN=30;//边距
  12. 	public static int GRID_SPAN=35;//网格间距
  13. 	public static int ROWS=15;//棋盘行数
  14. 	public static int COLS=15;//棋盘列数
  15. 	Point[] chessList=new Point[(ROWS+1)*(COLS+1)];//初始化每个数组元素为null
  16. 	boolean isBack=true;//默认开始是黑棋先下
  17. 	boolean gameOver=false;//游戏是否结束
  18. 	int chessCount;//当前棋盘的棋子个数
  19. 	int xIndex,yIndex;//当前刚下棋子的索引
  20. 	public ChessBoard(){
  21. 		setBackground(Color.LIGHT_GRAY);//设置背景颜色为黄色
  22. 		addMouseListener(this);//添加事件监听器
  23. 		addMouseMotionListener(new MouseMotionListener() {//匿名内部类
  24. 			
  25. 			@Override
  26. 			public void mouseMoved(MouseEvent e) {
  27. 				int x1=(e.getX()-MARGIN+GRID_SPAN/2)/GRID_SPAN;
  28. 				int y1=(e.getY()-MARGIN+GRID_SPAN/2)/GRID_SPAN;//将鼠标单击的坐标位置转化为网格索引
  29. 				if(x1<0||x1>ROWS||y1<0||y1>COLS||gameOver||findChess(x1,y1)){//游戏已经结束，不能下；落在棋盘外，不能下；x，y位置已经有棋子存在，不能下
  30. 					setCursor(new Cursor(Cursor.DEFAULT_CURSOR));//设置成默认形状
  31. 				}else{
  32. 					setCursor(new Cursor(Cursor.HAND_CURSOR));//设置成手型
  33. 				}
  34. 			}
  35. 			
  36. 			@Override
  37. 			public void mouseDragged(MouseEvent e) {
  38. 			}
  39. 		});
  40. 	}
  41. 	/*绘制*/
  42. 	public void paintComponent(Graphics g){
  43. 		super.paintComponent(g);//画棋盘
  44. 		for(int i=0;i<=ROWS;i++){//画横线
  45. 			g.drawLine(MARGIN, MARGIN+i*GRID_SPAN, MARGIN+COLS*GRID_SPAN, MARGIN+i*GRID_SPAN);
  46. 		}
  47. 		for(int i=0;i<=COLS;i++){//画直线
  48. 			g.drawLine(MARGIN+i*GRID_SPAN, MARGIN, MARGIN+i*GRID_SPAN,MARGIN+ROWS*GRID_SPAN);
  49. 		}
  50. 		/*画棋子*/
  51. 		for(int i=0;i<chessCount;i++){
  52. 			int xPos=chessList[i].getX()*GRID_SPAN+MARGIN;//网格交叉的x坐标
  53. 			int yPos=chessList[i].getY()*GRID_SPAN+MARGIN;//网格交叉的y坐标
  54. 			g.setColor(chessList[i].getColor());//设置颜色
  55. 			g.fillOval(xPos-Point.DIAMETER/2, yPos-Point.DIAMETER/2, Point.DIAMETER, Point.DIAMETER);
  56. 			if(i==chessCount-1){
  57. 				g.setColor(Color.red);//标记最后一个棋子为红色
  58. 			    g.drawRect(xPos-Point.DIAMETER/2, yPos-Point.DIAMETER/2, Point.DIAMETER, Point.DIAMETER);
  59. 			}
  60. 		}
  61. 	}
  62. 	
  63.  
  64.  
  65. 	@Override
  66. 	public void mousePressed(MouseEvent e) {//鼠标按键在组件上按下时调用
  67. 		if(gameOver)//游戏已经结束，不能下
  68. 			return ;
  69. 		String colorName=isBack ? "黑棋" : "白棋";
  70. 		xIndex=(e.getX()-MARGIN+GRID_SPAN/2)/GRID_SPAN;
  71. 		yIndex=(e.getY()-MARGIN+GRID_SPAN/2)/GRID_SPAN;//将鼠标单击的坐标位置转化为网格索引
  72. 		if(xIndex<0||xIndex>ROWS||yIndex<0||yIndex>COLS)//棋子落在棋盘外，不能下
  73. 			return ;
  74. 		if(findChess(xIndex,yIndex))//x,y位置已经有棋子存在，不能下
  75. 			return ;
  76. 		
  77. 		Point ch=new Point(xIndex,yIndex,isBack ? Color.black : Color.white);
  78. 		chessList[chessCount++]=ch;
  79. 		repaint();//通知系统重新绘制
  80. 		if(isWin()){
  81. 			String msg=String.format("恭喜，%s赢啦~", colorName);
  82. 			JOptionPane.showMessageDialog(this, msg);
  83. 			gameOver=true;			
  84. 		}
  85. 		else if(chessCount==(COLS+1)*(ROWS+1))
  86. 		{
  87. 			String msg=String.format("棋鼓相当，棒棒哒~");
  88. 			JOptionPane.showMessageDialog(this,msg);
  89. 			gameOver=true;
  90. 		}
  91. 		isBack=!isBack;
  92. 	}
  93. 	
  94. 	@Override
  95. 	public void mouseClicked(MouseEvent e) {//鼠标按键在组件上单击(按下并释放)时调用
  96. 	}
  97.  
  98. 	@Override
  99. 	public void mouseReleased(MouseEvent e) {鼠标按键在组件上释放时调用
  100. 	}
  101.  
  102. 	@Override
  103. 	public void mouseEntered(MouseEvent e) {//鼠标进入组件时调用
  104. 	}
  105.  
  106. 	@Override
  107. 	public void mouseExited(MouseEvent e){//鼠标离开组件时调用		
  108. 	}
  109. 	
  110. 	private boolean findChess(int x,int y){
  111. 		for(Point c:chessList){
  112. 			if(c!=null&&c.getX()==x&&c.getY()==y)
  113. 				return true;
  114. 		}
  115. 		return false;
  116. 	}
  117. 	
  118. 	/*判断那方赢*/
  119. 	private boolean isWin(){
  120. 		int continueCount=1;//连续棋子的个数
  121. 		for(int x=xIndex-1;x>=0;x--){//横向向左寻找
  122. 			Color c=isBack ? Color.black : Color.white;
  123. 			if(getChess(x,yIndex,c)!=null){
  124. 				continueCount++;
  125. 			}else
  126. 				break;
  127. 		}
  128. 		for(int x=xIndex+1;x<=ROWS;x++){//横向向右寻找
  129. 			Color c=isBack ? Color.black : Color.white;
  130. 			if(getChess(x,yIndex,c)!=null){
  131. 				continueCount++;
  132. 			}else
  133. 				break;
  134. 		}
  135. 		if(continueCount>=5){//判断记录数大于等于五，即表示此方获胜
  136. 			return true;
  137. 		}else
  138. 			continueCount=1;
  139. 		//
  140. 		for(int y=yIndex-1;y>=0;y--){//纵向向上寻找
  141. 			Color c=isBack ? Color.black : Color.white;
  142. 			if(getChess(xIndex,y,c)!=null){
  143. 				continueCount++;
  144. 			}else
  145. 				break;
  146. 		}
  147. 		for(int y=yIndex+1;y<=ROWS;y++){//纵向向下寻找
  148. 			Color c=isBack ? Color.black : Color.white;
  149. 			if(getChess(xIndex,y,c)!=null){
  150. 				continueCount++;
  151. 			}else
  152. 				break;
  153. 		}
  154. 		if(continueCount>=5){//判断记录数大于等于五，即表示此方获胜
  155. 			return true;
  156. 		}else
  157. 			continueCount=1;
  158. 		//
  159. 		for(int x=xIndex+1,y=yIndex-1;y>=0&&x<=COLS;x++,y--){//右下寻找
  160. 			Color c=isBack ? Color.black : Color.white;
  161. 			if(getChess(x,y,c)!=null){
  162. 				continueCount++;
  163. 			}else
  164. 				break;
  165. 		}
  166. 		for(int x=xIndex-1,y=yIndex+1;y<=ROWS&&x>=0;x--,y++){//左上寻找
  167. 			Color c=isBack ? Color.black : Color.white;
  168. 			if(getChess(x,y,c)!=null){
  169. 				continueCount++;
  170. 			}else
  171. 				break;
  172. 		}
  173. 		if(continueCount>=5){//判断记录数大于等于五，即表示此方获胜
  174. 			return true;
  175. 		}else
  176. 			continueCount=1;
  177. 		//
  178. 		for(int x=xIndex-1,y=yIndex-1;y>=0&&x>=0;x--,y--){//左下寻找
  179. 			Color c=isBack ? Color.black : Color.white;
  180. 			if(getChess(x,y,c)!=null){
  181. 				continueCount++;
  182. 			}else
  183. 				break;
  184. 		}
  185. 		for(int x=xIndex+1,y=yIndex+1;y<=ROWS&&x<=COLS;x++,y++){//右上寻找
  186. 			Color c=isBack ? Color.black : Color.white;
  187. 			if(getChess(x,y,c)!=null){
  188. 				continueCount++;
  189. 			}else
  190. 				break;
  191. 		}
  192. 		if(continueCount>=5){//判断记录数大于等于五，即表示此方获胜
  193. 			return true;
  194. 		}else
  195. 			continueCount=1;
  196. 		return false;		
  197. 	}
  198. 	private Point getChess(int xIndex,int yIndex,Color color){
  199. 		for(Point c:chessList){
  200. 			if(c!=null&&c.getX()==xIndex&&c.getY()==yIndex&&c.getColor()==color)
  201. 				return c;
  202. 		}
  203. 		return null;
  204. 	}
  205. 	public void restartGame(){//清除棋子
  206. 		for(int i=0;i<chessList.length;i++)
  207. 			chessList[i]=null;
  208. 		/*恢复游戏相关的变量值*/
  209. 		isBack=true;
  210. 		gameOver=false;//游戏是否结束
  211. 		chessCount=0;//当前棋盘的棋子个数
  212. 		repaint();		
  213. 	}
  214. 	public void goback(){
  215. 		if(chessCount==0)
  216. 			return ;
  217. 		chessList[chessCount-1]=null;
  218. 		chessCount--;
  219. 		if(chessCount>0){
  220. 			xIndex=chessList[chessCount-1].getX();
  221. 			yIndex=chessList[chessCount-1].getY();
  222. 		}
  223. 		isBack=!isBack;
  224. 		repaint();
  225. 	}
  226. 	//Dimension:矩形
  227. 	public Dimension getPreferredSize(){
  228. 		return new Dimension(MARGIN*2+GRID_SPAN*COLS,MARGIN*2+GRID_SPAN*ROWS);
  229. 	}
  230. 	
  231. 	
  232.  
  233. }

5.3Point类 

  1. package chess.lcc.com;
  2.  
  3. import java.awt.*;
  4.  
  5. public class Point {
  6. 	private int x;//棋子在棋盘中的x索引值
  7. 	private int y;//棋子在棋盘中的y索引值
  8. 	private Color color;//颜色
  9. 	public static   int DIAMETER=30;//直径
  10. 	public Point(int x,int y,Color color){
  11. 		this.x=x;
  12. 		this.y=y;
  13. 		this.color=color;
  14. 	}
  15. 	//得到棋子在棋盘中的x索引值
  16. 	public int getX(){
  17. 		return x;
  18. 	}
  19. 	//得到棋子在棋盘中的y索引值
  20. 	public int getY(){
  21. 		return y;
  22. 	}
  23. 	//得到棋子颜色
  24. 	public Color getColor(){
  25. 		return color;
  26. 	}
  27. }








声明：本文内容由网友自发贡献，不代表【wpsshop博客】立场，版权归原作者所有，本站不承担相应法律责任。如您发现有侵权的内容，请联系我们。转载请注明出处：https://www.wpsshop.cn/w/我家小花儿/article/detail/326351
推荐阅读
相关标签

Copyright © 2003-2013 www.wpsshop.cn 版权所有，并保留所有权利。

  

闽ICP备14008679号