java入门-五子棋游戏的制作

最新推荐文章于 2024-04-24 22:52:03 发布
最新推荐文章于 2024-04-24 22:52:03 发布
阅读量1k 收藏 16
点赞数 3
文章标签： 游戏开发 java 可视化
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_45681711/article/details/117005971
版权

java入门-五子棋游戏的制作

想要开发一个简单的五子棋游戏，需要实现五子棋的棋盘、棋子、输赢判定、重新开始游戏、悔棋、认输、人机大战以及退出游戏等功能。
在这里插入图片描述

1.实现五子棋的棋盘功能

想要实现这个功能，我们需要了解JFrame窗体容器，以及一些相应的可视化组件和元素组件，我们首先需要设置窗口的大小位置以及标题。窗口设置好了，我们需要使用paint(g)函数进行绘图，这里我选择的是20*20的网格，网格大小长宽各为20。在使用paint()函数绘制图形的时候，我们需要加上super.paint(g),这是对父类方法的重写，表示在原来图像的基础上，再画图。如果不加上的话，重绘时，会将原有的绘制清空。

//构造函数初始化
	public youxi() {
		// int w=Toolkit.getDefaultToolkit().getScreenSize().width;
		this.setLayout(null);
		this.setTitle("五子棋");
		this.setBounds(700, 400, 600, 500);
		// this.setBackground(Color.blue);
		this.setResizable(false);
		this.addMouseListener(this);
		JLabel p = new JLabel();
		p.setBounds(100, 435, 100, 30);
		p.setText("剩余时间");
		this.add(p);
		this.setVisible(true);
		this.setDefaultCloseOperation(3);
		putMap();
	}
//重写绘制组件的方法
	public void paint(Graphics g) {
		super.paint(g);
		// 绘制棋盘
		g.setColor(Color.black);
		// 画横线
		for (int i = 0; i < 20; i++) {
			g.drawLine(30, 80 + 20 * i, 410, 80 + 20 * i);
			// 画竖线
			g.drawLine(30 + 20 * i, 80, 30 + 20 * i, 460);
		}

2.棋子的绘制

五子棋一般只有黑白两种棋子`，使用for循环即可，i代表的是横坐标，j代表的是纵坐标，在这里我用的是一个二维数组对棋子的颜色进行存储，来判断（i，j）这个棋盘位置是黑棋还是白棋，由于数组的i，j是坐标值并不是实际的位置，所以我们需要将i,j转换为棋盘的位置，因为棋盘是从窗体的（30,80）开始画的，所以我们计算棋子的位置的时候需要分别加上30和80，g.fillOval(xx, yy, 20, 20)；xx,yy是棋子左上角的位置，所以我们需要提前减去棋子的半径使鼠标点击的位置变成棋子的中心
在这里插入图片描述

// 建立数组缓存已经下好棋子的位置
int arr[][] = new int[20][20];

for (int i = 0; i < 20; i++)
			for (int j = 0; j < 20; j++) {
				xx = 20 * i + 30 - 10;
				yy = 20 * j + 80 - 10;
				if (arr[i][j] == 1) {
					g.setColor(Color.black);
					g.fillOval(xx, yy, 20, 20);
				}
				if (arr[i][j] == 2) {
					g.setColor(Color.white);
					g.fillOval(xx, yy, 20, 20);
				}
			}

3.下棋功能的实现

这里我们需要使用MouseListener鼠标事件监听器，在这里我们将鼠标点击作为事件源，鼠标按下时实现下棋功能，因为鼠标在棋盘上点击的位置并不是棋盘的交点位置，所以我们需要判断一下棋子该下在哪个位置，这里我是根据象限的不同来确定棋子到底下在哪个位置的，根据象限的不同对棋子的坐标值进行相应的调整，如代码所示
在这里插入图片描述
因为总是黑方先下，这里使用了一个布尔变量colorblack作为棋子颜色的标识，每下一步棋标识都发生改变，根据标识的不同来设置二维数组arr[x][y]的值

	public void mouseClicked(MouseEvent e) {
		// 获取鼠标的坐标
		x = e.getX();
		y = e.getY();
		// 判断鼠标在哪一个象限，并将坐标值转换成对应的行和列
		if (play) {
			if (x > 30 && x < 410 && y > 80 && y < 460) {
				if ((x - 30) % 20 > 10 && (y - 80) % 20 > 10) {
					x = (x - 30) / 20 + 1;
					y = (y - 80) / 20 + 1;
				} else if ((x - 30) % 20 < 10 && (y - 80) % 20 > 10) {
					x = (x - 30) / 20;
					y = (y - 80) / 20 + 1;
				} else if ((x - 30) % 20 > 10 && (y - 80) % 20 < 10) {
					x = (x - 30) / 20 + 1;
					y = (y - 80) / 20;
				} else {
					x = (x - 30) / 20;
					y = (y - 80) / 20;
				}
				cx[countx++] = x;
				cy[county++] = y;
				// 记录每一行每一列棋子的颜色，arr[x][y] == 0是为了防止棋子覆盖
				if (arr[x][y] == 0) {
					if (colorblack) {
						arr[x][y] = 1;
						colorblack = false;
						message = "白方下";
					} else {
						arr[x][y] = 2;
						colorblack = true;
						message = "黑方下";
					}
				}
			}

4.判断输赢功能的实现

代码比较长但很简单，需要判断4个方向是否有5子连成，分别是横向、纵向以及两个斜向，这里使用count作为四个方向的计数变量，四个方向的判定方法都一样，只是参数改变了一些，我采用的是遍历整个棋盘的方式来判断是否有五子相连，如图箭头所指的棋子，这里用一个count变量来进行计数，如果遇到相同颜色的棋子count加1，遇到不同的直接跳出该方向的判断，继续进行搜索，直到count变为5，跳出循环，根据当前棋子的颜色判断输赢
在这里插入图片描述

	public void iswin(int x, int y) {
		int count = 1;
		if (arr[x][y] != 0) {
			int a = arr[x][y];
			// 横向
			for (int k = x + 1; k < arr.length; k++) {
				// 棋子的颜色相同时，相应的计数变量增加，否则变为1继续进行判断
				if (arr[k][y] == a) {
					count++;
				} else {
					break;
				}
				// 计数变量大于等于5时即可根据当前棋子的颜色判断黑方赢还是白方赢，判断过后直接跳出循环
				if (count >= 5) {
					if (arr[k][y] == 1) {
						JOptionPane.showMessageDialog(null, "黑方赢");
						play = false;
					} else {
						JOptionPane.showMessageDialog(null, "白方赢");
						play = false;
					}
					break;
				}
			}
			for (int k = x - 1; k >= 0; k--) {
				if (arr[k][y] == a) {
					count++;
				} else {
					break;
				}
				if (count >= 5) {
					if (arr[k][y] == 1) {
						JOptionPane.showMessageDialog(null, "黑方赢");
						play = false;
					} else {
						JOptionPane.showMessageDialog(null, "白方赢");
						play = false;
					}
					break;
				}
			}
			count = 1;
			// 纵向
			for (int k = y - 1; k >= 0; k--) {
				if (arr[x][k] == a) {
					count++;
				} else {
					break;
				}
				if (count >= 5) {
					if (arr[x][k] == 1) {
						JOptionPane.showMessageDialog(null, "黑方赢");
						play = false;
					} else {
						JOptionPane.showMessageDialog(null, "白方赢");
						play = false;
					}
					break;
				}
			}
			for (int k = y + 1; k < arr.length; k++) {
				if (arr[x][k] == a) {
					count++;
				} else {
					break;
				}
				if (count >= 5) {
					if (arr[x][k] == 1) {
						JOptionPane.showMessageDialog(null, "黑方赢");
						play = false;
					} else {
						JOptionPane.showMessageDialog(null, "白方赢");
						play = false;
					}
					break;
				}
			}
			count = 1;
			// 左下、右上
			for (int m = x - 1, k = y + 1; k < arr.length && m >= 0; k++, m--) {
				if (arr[m][k] == a) {
					count++;
				} else {
					break;
				}
				if (count >= 5) {
					if (arr[m][k] == 1) {
						JOptionPane.showMessageDialog(null, "黑方赢");
						play = false;
					} else {
						JOptionPane.showMessageDialog(null, "白方赢");
						play = false;
					}
					break;
				}
			}
			for (int m = x + 1, k = y - 1; m < arr.length && k >= 0; k--, m++) {
				if (arr[m][k] == a) {
					count++;
				} else {
					break;
				}
				if (count >= 5) {
					if (arr[m][k] == 1) {
						JOptionPane.showMessageDialog(null, "黑方赢");
						play = false;
					} else {
						JOptionPane.showMessageDialog(null, "白方赢");
						play = false;
					}
					break;
				}
			}
			count = 1;
			// 左上、右下
			for (int m = x - 1, k = y - 1; m >= 0 && k >= 0; k--, m--) {
				if (arr[m][k] == a) {
					count++;
				} else {
					break;
				}
				if (count >= 5) {
					if (arr[m][k] == 1) {
						JOptionPane.showMessageDialog(null, "黑方赢");
						play = false;
					} else {
						JOptionPane.showMessageDialog(null, "白方赢");
						play = false;
					}
					break;
				}
			}
			for (int m = x + 1, k = y + 1; m < arr.length && k < arr.length; k++, m++) {
				if (arr[m][k] == 0) {
					break;
				}
				if (arr[m][k] == a) {
					count++;
				} else {
					break;
				}
				if (count >= 5) {
					if (arr[m][k] == 1) {
						JOptionPane.showMessageDialog(null, "黑方赢");
						play = false;
					} else {
						JOptionPane.showMessageDialog(null, "白方赢");
						play = false;
					}
					break;
				}
			}
			count = 1;
		}
	}

5.重新开始游戏

这里需要自己直接添加按钮，这里我是自己用画笔画了一个按钮，后面的功能按钮都是这么画的，目的是为了所有的事件源都是窗体，重新开始游戏，那么我们需要将一些变量都赋值为初始值，还需要将棋盘上的棋子清空，即二维数组的清空，比较简单

// 重新开始按钮绘制
		g.drawRect(450, 100, 100, 30);
		g.drawString("重新开始", 480, 118);

// 重新开始
		if (e.getX() > 450 && e.getX() < 550 && e.getY() > 100 && e.getY() < 130) {
			int result = JOptionPane.showConfirmDialog(this, "是否重新开始游戏");
			if (result == 0) {
				for (int i = 0; i < 20; i++)
					for (int j = 0; j < 20; j++) {
						arr[i][j] = 0;
						chessvalue[i][j] = 0;
					}
				for (int i = 0; i < cx.length; i++) {
					cx[i] = 0;
					cy[i] = 0;
				}
				colorblack = true;
				message = "黑方下";
				play = true;
				isrenji = false;
				renji = false;
			}
		}

6.悔棋

悔棋的话需要知道悔棋是黑方还是白方以及返回上一步棋盘上棋子的情况，这里用countx和county两个变量记录当前下了几个棋子，cx[],cy[],两个一维数组分别记下当前棋子的坐标，悔棋的话只需要countx-1和county-1得到上一步棋子的个数再通过数组即可得到坐标值，将该坐标值上的棋子颜色清零即可

// 悔棋按钮绘制
		g.drawRect(450, 200, 100, 30);
		g.drawString("悔棋", 495, 218);

// 悔棋
		//先判断下一步棋子的颜色，如果下一步要下黑棋，则是白方悔棋，反之，黑方悔棋
		if (e.getX() > 450 && e.getX() < 550 && e.getY() > 200 && e.getY() < 230) {
			int result = JOptionPane.showConfirmDialog(this, colorblack == false ? "黑方悔棋，白方是否同意" : "白方悔棋，黑方是否同意");
			message = colorblack == false ? "黑方下" : "白方下";
			//这里用countx和county两个变量记录当前下了几个棋子，cx[],cy[],两个一维数组分别记下当前棋子的坐标，悔棋的话只需要countx-1和county-1得到上一步棋子的个数再通过数组即可得到坐标值，将该坐标值上的棋子颜色清零即可
			if (result == 0) {
				arr[cx[--countx]][cy[--county]] = 0;
				//悔棋之后颜色标识也得改变
				colorblack = !colorblack;
				play = true;
			}
		}

7.认输

按钮的绘制都和前面一样，实现很简单，只需要根据当前棋子颜色标识判断黑方还是白方认输，直接看代码吧

// 认输
		g.drawRect(450, 300, 100, 30);
		g.drawString("认输", 495, 318);


// 认输
		if (e.getX() > 450 && e.getX() < 550 && e.getY() > 300 && e.getY() < 330) {
			int result = JOptionPane.showConfirmDialog(this, "是否认输");
			if (result == 0) {
				JOptionPane.showMessageDialog(null, colorblack == true ? "白方获胜" : "黑方获胜");
				play = false;
			}
		}

8.退出功能

这个就很简单了，直接退出系统即可

// 退出游戏
		g.drawRect(450, 400, 100, 30);
		g.drawString("退出游戏", 480, 418);

// 退出
		if (e.getX() > 450 && e.getX() < 550 && e.getY() > 400 && e.getY() < 430) {
			int result = JOptionPane.showConfirmDialog(this, "是否退出游戏");
			if (result == 0) {
				System.exit(0);
			}
		}

9.人机对战功能

人机功能的实现主要是利用权值算法来实现，首先需要创建权值表，里面具体的权值可以根据你自己来调，这里使用的是来创建权值表，权值表中的键代表的是相连棋子的个数，哈希值代表的是权重，以一个空白位置作为起始点对该点的八个位置进行搜索，碰到空位置直接跳出该方向的循环，遇到棋子的时候将该位置的棋子的颜色和棋局记录下来，继续进行该方向的搜索，重复这样的操作，该方向搜索完之后将权值累加并记录在一个二维数组中，其它七个方向方法都一样，循环结束比较每个位置的权值大小，权值最大的坐标点就是人机要下棋的位置
在这里插入图片描述

HashMap<String, Integer> hm = new HashMap<String, Integer>();

//创建权值表
	public void putMap() {
		hm.put("1", 20);//
		hm.put("11", 200);
		hm.put("111", 2000);
		hm.put("1111", 3000);
		hm.put("12", 10);
		hm.put("112", 100);
		hm.put("1112", 1000);
		hm.put("11112", 2000);
		hm.put("2", 30);
		hm.put("22", 300);
		hm.put("222", 3000);
		hm.put("2222", 4000);
		hm.put("21", 20);
		hm.put("221", 200);
		hm.put("2221", 2000);
		hm.put("22221", 3000);
	}

// 人机对战
			if (isrenji && renji) {
				// System.out.println("1234");
				AI();
				colorblack = !colorblack;
				message = "黑方下";
			}

	public void AI() {
		for (int i = 0; i < arr.length; i++) {
			for (int j = 0; j < arr.length; j++) {
				// 判断当前是否为空
				if (arr[i][j] == 0) {
					// 搜索该空位八个方向上棋局情况
					// 定义两个变量分别保存棋局，以及颜色
					String code = "";
					int color = 0;
					// 向下
					for (int k = i + 1; k < arr.length; k++) {
						if (arr[k][j] == 0) {
							break;
						} else {
							if (color == 0) { // 下边第一颗棋子
								color = arr[k][j]; // 保存颜色
								code += arr[k][j]; // 保存棋局
							} else if (arr[k][j] == color) { // 下边第二，三..同颜色棋子
								code += arr[k][j]; // 保存棋局
							} else { // 下边不同颜色
								code += arr[k][j]; // 保存棋局
								break;
							}

						}
					}
					// 根据code取出hm对应的权值
					Integer value = hm.get(code);
					// System.out.println("value"+value);
					if (value != null) {
						chessvalue[i][j] += value; // 权值累加
					}
					// System.out.println(chessvalue[i][j]);
					// 剩余七个方向
					code = "";
					color = 0;
					// 向上
					for (int k = i - 1; k >= 0; k--) {
						if (arr[k][j] == 0) {
							break;
						} else {
							if (color == 0) { // 上边第一颗棋子
								color = arr[k][j]; // 保存颜色
								code += arr[k][j]; // 保存棋局
							} else if (arr[k][j] == color) { // 上边第二，三..同颜色棋子
								code += arr[k][j]; // 保存棋局
							} else { // 上边不同颜色
								code += arr[k][j]; // 保存棋局
								break;
							}

						}
					}
					Integer value1 = hm.get(code);
					if (value1 != null) {
						chessvalue[i][j] += value1; // 权值累加
					}
					// 剩余六个方向
					code = "";
					color = 0;
					// 向左
					for (int k = j - 1; k >= 0; k--) {
						if (arr[i][k] == 0) {
							break;
						} else {
							if (color == 0) { // 左边第一颗棋子
								color = arr[i][k]; // 保存颜色
								code += arr[i][k]; // 保存棋局
							} else if (arr[i][k] == color) { // 左边第二，三..同颜色棋子
								code += arr[i][k]; // 保存棋局
							} else { // 左边不同颜色
								code += arr[i][k]; // 保存棋局
								break;
							}

						}
					}
					Integer value2 = hm.get(code);
					if (value2 != null) {
						chessvalue[i][j] += value2; // 权值累加
					}
					// 剩余五个方向
					code = "";
					color = 0;
					// 向右
					for (int k = j + 1; k < arr.length; k++) {
						if (arr[i][k] == 0) {
							break;
						} else {
							if (color == 0) { // 右边第一颗棋子
								color = arr[i][k]; // 保存颜色
								code += arr[i][k]; // 保存棋局
							} else if (arr[i][k] == color) { // 右边第二，三..同颜色棋子
								code += arr[i][k]; // 保存棋局
							} else { // 右边不同颜色
								code += arr[i][k]; // 保存棋局
								break;
							}

						}
					}
					Integer value3 = hm.get(code);
					if (value3 != null) {
						chessvalue[i][j] += value3; // 权值累加
					}
					// 剩余四个方向
					code = "";
					color = 0;
					// 左下
					for (int m = i + 1, k = j - 1; m < arr.length && k >= 0; k--, m++) {
						if (arr[m][k] == 0) {
							break;
						} else {
							if (color == 0) { // 左下第一颗棋子
								color = arr[m][k]; // 保存颜色
								code += arr[m][k]; // 保存棋局
							} else if (arr[m][k] == color) { // 左下第二，三..同颜色棋子
								code += arr[m][k]; // 保存棋局
							} else { // 左下不同颜色
								code += arr[m][k]; // 保存棋局
								break;
							}

						}
					}
					Integer value4 = hm.get(code);
					if (value4 != null) {
						chessvalue[i][j] += value4; // 权值累加
					}
					// 剩余四个方向
					code = "";
					color = 0;
					// 右上
					for (int m = i - 1, k = j + 1; m >= 0 && k < arr.length; k++, m--) {
						if (arr[m][k] == 0) {
							break;
						} else {
							if (color == 0) { // 右上第一颗棋子
								color = arr[m][k]; // 保存颜色
								code += arr[m][k]; // 保存棋局
							} else if (arr[m][k] == color) { // 右上第二，三..同颜色棋子
								code += arr[m][k]; // 保存棋局
							} else { // 右上不同颜色
								code += arr[m][k]; // 保存棋局
								break;
							}

						}
					}
					Integer value5 = hm.get(code);
					if (value5 != null) {
						chessvalue[i][j] += value5; // 权值累加
					}
					code = "";
					color = 0;
					// 左上
					for (int m = i - 1, k = j - 1; m >= 0 && k >= 0; k--, m--) {
						if (arr[m][k] == 0) {
							break;
						} else {
							if (color == 0) { // 左上第一颗棋子
								color = arr[m][k]; // 保存颜色
								code += arr[m][k]; // 保存棋局
							} else if (arr[m][k] == color) { // 左上第二，三..同颜色棋子
								code += arr[m][k]; // 保存棋局
							} else { // 左上不同颜色
								code += arr[m][k]; // 保存棋局
								break;
							}

						}
					}
					Integer value6 = hm.get(code);
					if (value6 != null) {
						chessvalue[i][j] += value6; // 权值累加
					}
					code = "";
					color = 0;
					// 右下
					for (int m = i + 1, k = j + 1; m < arr.length && k < arr.length; k++, m++) {
						if (arr[m][k] == 0) {
							break;
						} else {
							if (color == 0) { // 右下第一颗棋子
								color = arr[m][k]; // 保存颜色
								code += arr[m][k]; // 保存棋局
							} else if (arr[m][k] == color) { // 右下第二，三..同颜色棋子
								code += arr[m][k]; // 保存棋局
							} else { // 右下不同颜色
								code += arr[m][k]; // 保存棋局
								break;
							}

						}
					}
					Integer value7 = hm.get(code);
					if (value7 != null) {
						chessvalue[i][j] += value7; // 权值累加
					}
					code = "";
					color = 0;
				}
			}
		}
		int max = 0;
		for (int i = 0; i < chessvalue.length; i++)
			for (int j = 0; j < chessvalue.length; j++) {
				if (chessvalue[i][j] > max) {
					max = chessvalue[i][j];
					rx = i;
					ry = j;
				}
			}
		for (int i = 0; i < 20; i++)
			for (int j = 0; j < 20; j++) {
				chessvalue[i][j] = 0;
			}
		arr[rx][ry] = 2;
	}

10.全部代码

package wuziqi;

//插入图形化界面相应的包1.javax.swing (可视化组件)   2.java.awt (元素组件)
import javax.swing.*;
import java.awt.event.*;
import java.awt.*;
import java.util.*;

public class youxi extends JFrame implements MouseListener {
	// 建立数组缓存已经下好棋子的位置
	int arr[][] = new int[20][20];
	// 记录鼠标当前的位置
	int x, y;
	// 记录当前棋子的坐标，本代码使用颜色来判断棋子在棋盘上的情况，0代表无棋子，1代表黑色棋子，2代表白色棋子
	int cx[] = new int[400];
	int cy[] = new int[400];
	// 记录当前棋子的个数
	int countx, county;
	int xx, yy;
	int a = 1;
	int rx, ry;
	// 建立一些标识
	boolean colorblack = true;// 当前棋子颜色标识，为了方便对arr[][]进行赋值
	boolean play = true;// 判断游戏是否结束，结束则不能玩
	boolean isrenji = false;// 人机对战标识，为true则人机互打
	String message = "黑方下";
	// 用来缓存在棋盘每个位置权值
	int chessvalue[][] = new int[20][20];
	HashMap<String, Integer> hm = new HashMap<String, Integer>();

//创建权值表
	public void putMap() {
		hm.put("1", 20);
		hm.put("11", 200);
		hm.put("111", 2000);
		hm.put("1111", 3000);
		hm.put("12", 10);
		hm.put("112", 100);
		hm.put("1112", 1000);
		hm.put("11112", 2000);
		hm.put("2", 30);
		hm.put("22", 300);
		hm.put("222", 3000);
		hm.put("2222", 4000);
		hm.put("21", 20);
		hm.put("221", 200);
		hm.put("2221", 2000);
		hm.put("22221", 3000);
	}

//构造函数初始化
	public youxi() {
		// int w=Toolkit.getDefaultToolkit().getScreenSize().width;
		this.setLayout(null);// 绝对布局
		this.setTitle("五子棋");// 设置标题
		this.setBounds(700, 400, 600, 500);// 设置大小位置
		this.setResizable(false);// 形状固定
		this.addMouseListener(this);// 添加鼠标监听对象
		JLabel p = new JLabel();
		p.setBounds(100, 435, 100, 30);
		p.setText("剩余时间");
		this.add(p);
		this.setVisible(true);
		this.setDefaultCloseOperation(3);
		putMap();
	}

//重写绘制组件的方法
	public void paint(Graphics g) {
		super.paint(g);
		//添加背景
		ImageIcon icon=new ImageIcon("F:\\2.jpg");
		g.drawImage(icon.getImage(), 30, 80, 380, 380, null);
		// 绘制棋盘
		g.setColor(Color.black);
		// 画横线
		for (int i = 0; i < 20; i++) {
			g.drawLine(30, 80 + 20 * i, 410, 80 + 20 * i);
			// 画竖线
			g.drawLine(30 + 20 * i, 80, 30 + 20 * i, 460);
		}
		// 提示
		g.setColor(Color.black);
		g.drawString("提示:" + message, 50, 55);
		// 重新开始按钮绘制
		g.drawRect(450, 100, 100, 30);
		g.drawString("重新开始", 480, 118);
		// 悔棋按钮绘制
		g.drawRect(450, 200, 100, 30);
		g.drawString("悔棋", 495, 218);
		// 认输
		g.drawRect(450, 300, 100, 30);
		g.drawString("认输", 495, 318);
		// 退出游戏
		g.drawRect(450, 400, 100, 30);
		g.drawString("退出游戏", 480, 418);
		// 人机对战
		g.drawRect(250, 35, 100, 30);
		g.drawString("人机大战", 280, 55);
		// 画棋子
		for (int i = 0; i < 20; i++)
			for (int j = 0; j < 20; j++) {
				xx = 20 * i + 30 - 10;
				yy = 20 * j + 80 - 10;
				if (arr[i][j] == 1) {
					g.setColor(Color.black);
					g.fillOval(xx, yy, 20, 20);
				}
				if (arr[i][j] == 2) {
					g.setColor(Color.white);
					g.fillOval(xx, yy, 20, 20);
				}
			}
	}

	public void mouseClicked(MouseEvent e) {
		// 获取鼠标的坐标
		x = e.getX();
		y = e.getY();
		// 判断鼠标在哪一个象限，并将坐标值转换成对应的行和列
		if (play) {
			if (x > 30 && x < 410 && y > 80 && y < 460) {
				if ((x - 30) % 20 > 10 && (y - 80) % 20 > 10) {
					x = (x - 30) / 20 + 1;
					y = (y - 80) / 20 + 1;
				} else if ((x - 30) % 20 < 10 && (y - 80) % 20 > 10) {
					x = (x - 30) / 20;
					y = (y - 80) / 20 + 1;
				} else if ((x - 30) % 20 > 10 && (y - 80) % 20 < 10) {
					x = (x - 30) / 20 + 1;
					y = (y - 80) / 20;
				} else {
					x = (x - 30) / 20;
					y = (y - 80) / 20;
				}
				cx[countx++] = x;
				cy[county++] = y;
				// 记录每一行每一列棋子的颜色，arr[x][y] == 0是为了防止棋子覆盖
				if (arr[x][y] == 0) {
					if (colorblack) {
						arr[x][y] = 1;
						colorblack = false;
						message = "白方下";
						iswin(x, y);
						// 人机对战
						if (isrenji) {
							AI();
							colorblack = !colorblack;
							message = "黑方下";
							iswin(rx, ry);
						}
					} else {
						arr[x][y] = 2;
						colorblack = true;
						message = "黑方下";
						iswin(x, y);
					}
				}
			}
		}
		// 重新开始
		if (e.getX() > 450 && e.getX() < 550 && e.getY() > 100 && e.getY() < 130) {
			int result = JOptionPane.showConfirmDialog(this, "是否重新开始游戏");
			if (result == 0) {
				for (int i = 0; i < 20; i++)
					for (int j = 0; j < 20; j++) {
						arr[i][j] = 0;
						chessvalue[i][j] = 0;
					}
				for (int i = 0; i < cx.length; i++) {
					cx[i] = 0;
					cy[i] = 0;
				}
				colorblack = true;
				message = "黑方下";
				play = true;
				isrenji = false;

			}
		}
		// 悔棋
		// 先判断下一步棋子的颜色，如果下一步要下黑棋，则是白方悔棋，反之，黑方悔棋
		if (e.getX() > 450 && e.getX() < 550 && e.getY() > 200 && e.getY() < 230) {
			int result = JOptionPane.showConfirmDialog(this, colorblack == false ? "黑方悔棋，白方是否同意" : "白方悔棋，黑方是否同意");
			message = colorblack == false ? "黑方下" : "白方下";
			// 这里用countx和county两个变量记录当前下了几个棋子，cx[],cy[],两个一维数组分别记下当前棋子的坐标，悔棋的话只需要countx-1和county-1得到上一步棋子的个数再通过数组即可得到坐标值，将该坐标值上的棋子颜色清零即可
			if (result == 0) {
				arr[cx[--countx]][cy[--county]] = 0;
				// 悔棋之后颜色标识也得改变
				colorblack = !colorblack;
				play = true;
			}
		}
		// 认输
		if (e.getX() > 450 && e.getX() < 550 && e.getY() > 300 && e.getY() < 330) {
			int result = JOptionPane.showConfirmDialog(this, "是否认输");
			if (result == 0) {
				JOptionPane.showMessageDialog(null, colorblack == true ? "白方获胜" : "黑方获胜");
				play = false;
			}
		}
		// 退出
		if (e.getX() > 450 && e.getX() < 550 && e.getY() > 400 && e.getY() < 430) {
			int result = JOptionPane.showConfirmDialog(this, "是否退出游戏");
			if (result == 0) {
				System.exit(0);
			}
		}
		// 人机对战
		if (e.getX() > 250 && e.getX() < 350 && e.getY() > 35 && e.getY() < 65) {
			int result = JOptionPane.showConfirmDialog(this, "是否人机大战");
			if (result == 0) {
				isrenji = true;
			}
		}
		// 重绘棋盘
		this.repaint();
	}

	public void AI() {
		for (int i = 0; i < arr.length; i++) {
			for (int j = 0; j < arr.length; j++) {
				// 判断当前是否为空
				if (arr[i][j] == 0) {
					// 搜索该空位八个方向上棋局情况
					// 定义两个变量分别保存棋局，以及颜色
					String code = "";
					int color = 0;
					// 向下
					for (int k = i + 1; k < arr.length; k++) {
						if (arr[k][j] == 0) {
							break;
						} else {
							if (color == 0) { // 下边第一颗棋子
								color = arr[k][j]; // 保存颜色
								code += arr[k][j]; // 保存棋局
							} else if (arr[k][j] == color) { // 下边第二，三..同颜色棋子
								code += arr[k][j]; // 保存棋局
							} else { // 下边不同颜色
								code += arr[k][j]; // 保存棋局
								break;
							}

						}
					}
					// 根据code取出hm对应的权值
					Integer value = hm.get(code);
					// System.out.println("value"+value);
					if (value != null) {
						chessvalue[i][j] += value; // 权值累加
					}
					// System.out.println(chessvalue[i][j]);
					// 剩余七个方向
					code = "";
					color = 0;
					// 向上
					for (int k = i - 1; k >= 0; k--) {
						if (arr[k][j] == 0) {
							break;
						} else {
							if (color == 0) { // 上边第一颗棋子
								color = arr[k][j]; // 保存颜色
								code += arr[k][j]; // 保存棋局
							} else if (arr[k][j] == color) { // 上边第二，三..同颜色棋子
								code += arr[k][j]; // 保存棋局
							} else { // 上边不同颜色
								code += arr[k][j]; // 保存棋局
								break;
							}

						}
					}
					Integer value1 = hm.get(code);
					if (value1 != null) {
						chessvalue[i][j] += value1; // 权值累加
					}
					// 剩余六个方向
					code = "";
					color = 0;
					// 向左
					for (int k = j - 1; k >= 0; k--) {
						if (arr[i][k] == 0) {
							break;
						} else {
							if (color == 0) { // 左边第一颗棋子
								color = arr[i][k]; // 保存颜色
								code += arr[i][k]; // 保存棋局
							} else if (arr[i][k] == color) { // 左边第二，三..同颜色棋子
								code += arr[i][k]; // 保存棋局
							} else { // 左边不同颜色
								code += arr[i][k]; // 保存棋局
								break;
							}

						}
					}
					Integer value2 = hm.get(code);
					if (value2 != null) {
						chessvalue[i][j] += value2; // 权值累加
					}
					// 剩余五个方向
					code = "";
					color = 0;
					// 向右
					for (int k = j + 1; k < arr.length; k++) {
						if (arr[i][k] == 0) {
							break;
						} else {
							if (color == 0) { // 右边第一颗棋子
								color = arr[i][k]; // 保存颜色
								code += arr[i][k]; // 保存棋局
							} else if (arr[i][k] == color) { // 右边第二，三..同颜色棋子
								code += arr[i][k]; // 保存棋局
							} else { // 右边不同颜色
								code += arr[i][k]; // 保存棋局
								break;
							}

						}
					}
					Integer value3 = hm.get(code);
					if (value3 != null) {
						chessvalue[i][j] += value3; // 权值累加
					}
					// 剩余四个方向
					code = "";
					color = 0;
					// 左下
					for (int m = i + 1, k = j - 1; m < arr.length && k >= 0; k--, m++) {
						if (arr[m][k] == 0) {
							break;
						} else {
							if (color == 0) { // 左下第一颗棋子
								color = arr[m][k]; // 保存颜色
								code += arr[m][k]; // 保存棋局
							} else if (arr[m][k] == color) { // 左下第二，三..同颜色棋子
								code += arr[m][k]; // 保存棋局
							} else { // 左下不同颜色
								code += arr[m][k]; // 保存棋局
								break;
							}

						}
					}
					Integer value4 = hm.get(code);
					if (value4 != null) {
						chessvalue[i][j] += value4; // 权值累加
					}
					// 剩余四个方向
					code = "";
					color = 0;
					// 右上
					for (int m = i - 1, k = j + 1; m >= 0 && k < arr.length; k++, m--) {
						if (arr[m][k] == 0) {
							break;
						} else {
							if (color == 0) { // 右上第一颗棋子
								color = arr[m][k]; // 保存颜色
								code += arr[m][k]; // 保存棋局
							} else if (arr[m][k] == color) { // 右上第二，三..同颜色棋子
								code += arr[m][k]; // 保存棋局
							} else { // 右上不同颜色
								code += arr[m][k]; // 保存棋局
								break;
							}

						}
					}
					Integer value5 = hm.get(code);
					if (value5 != null) {
						chessvalue[i][j] += value5; // 权值累加
					}
					code = "";
					color = 0;
					// 左上
					for (int m = i - 1, k = j - 1; m >= 0 && k >= 0; k--, m--) {
						if (arr[m][k] == 0) {
							break;
						} else {
							if (color == 0) { // 左上第一颗棋子
								color = arr[m][k]; // 保存颜色
								code += arr[m][k]; // 保存棋局
							} else if (arr[m][k] == color) { // 左上第二，三..同颜色棋子
								code += arr[m][k]; // 保存棋局
							} else { // 左上不同颜色
								code += arr[m][k]; // 保存棋局
								break;
							}

						}
					}
					Integer value6 = hm.get(code);
					if (value6 != null) {
						chessvalue[i][j] += value6; // 权值累加
					}
					code = "";
					color = 0;
					// 右下
					for (int m = i + 1, k = j + 1; m < arr.length && k < arr.length; k++, m++) {
						if (arr[m][k] == 0) {
							break;
						} else {
							if (color == 0) { // 右下第一颗棋子
								color = arr[m][k]; // 保存颜色
								code += arr[m][k]; // 保存棋局
							} else if (arr[m][k] == color) { // 右下第二，三..同颜色棋子
								code += arr[m][k]; // 保存棋局
							} else { // 右下不同颜色
								code += arr[m][k]; // 保存棋局
								break;
							}

						}
					}
					Integer value7 = hm.get(code);
					if (value7 != null) {
						chessvalue[i][j] += value7; // 权值累加
					}
					code = "";
					color = 0;
				}
			}
		}
		int max = 0;
		for (int i = 0; i < chessvalue.length; i++)
			for (int j = 0; j < chessvalue.length; j++) {
				if (chessvalue[i][j] > max) {
					max = chessvalue[i][j];
					rx = i;
					ry = j;
				}
			}
		for (int i = 0; i < 20; i++)
			for (int j = 0; j < 20; j++) {
				chessvalue[i][j] = 0;
			}
		arr[rx][ry] = 2;
	}
	public void iswin(int x, int y) {
		int count = 1;
		if (arr[x][y] != 0) {
			int a = arr[x][y];
			// 横向
			for (int k = x + 1; k < arr.length; k++) {
				// 棋子的颜色相同时，相应的计数变量增加，否则变为1继续进行判断
				if (arr[k][y] == a) {
					count++;
				} else {
					break;
				}
				// 计数变量大于等于5时即可根据当前棋子的颜色判断黑方赢还是白方赢，判断过后直接跳出循环
				if (count >= 5) {
					if (arr[k][y] == 1) {
						JOptionPane.showMessageDialog(null, "黑方赢");
						play = false;
						isrenji=false;
					} else {
						JOptionPane.showMessageDialog(null, "白方赢");
						play = false;
						isrenji=false;
					}
					break;
				}
			}
			for (int k = x - 1; k >= 0; k--) {
				if (arr[k][y] == a) {
					count++;
				} else {
					break;
				}
				if (count >= 5) {
					if (arr[k][y] == 1) {
						JOptionPane.showMessageDialog(null, "黑方赢");
						play = false;
						isrenji=false;
					} else {
						JOptionPane.showMessageDialog(null, "白方赢");
						play = false;
						isrenji=false;
					}
					break;
				}
			}
			count = 1;
			// 纵向
			for (int k = y - 1; k >= 0; k--) {
				if (arr[x][k] == a) {
					count++;
				} else {
					break;
				}
				if (count >= 5) {
					if (arr[x][k] == 1) {
						JOptionPane.showMessageDialog(null, "黑方赢");
						play = false;
						isrenji=false;
					} else {
						JOptionPane.showMessageDialog(null, "白方赢");
						play = false;
						isrenji=false;
					}
					break;
				}
			}
			for (int k = y + 1; k < arr.length; k++) {
				if (arr[x][k] == a) {
					count++;
				} else {
					break;
				}
				if (count >= 5) {
					if (arr[x][k] == 1) {
						JOptionPane.showMessageDialog(null, "黑方赢");
						play = false;
						isrenji=false;
					} else {
						JOptionPane.showMessageDialog(null, "白方赢");
						play = false;
						isrenji=false;
					}
					break;
				}
			}
			count = 1;
			// 左下、右上
			for (int m = x - 1, k = y + 1; k < arr.length && m >= 0; k++, m--) {
				if (arr[m][k] == a) {
					count++;
				} else {
					break;
				}
				if (count >= 5) {
					if (arr[m][k] == 1) {
						JOptionPane.showMessageDialog(null, "黑方赢");
						play = false;
						isrenji=false;
					} else {
						JOptionPane.showMessageDialog(null, "白方赢");
						play = false;
						isrenji=false;
					}
					break;
				}
			}
			for (int m = x + 1, k = y - 1; m < arr.length && k >= 0; k--, m++) {
				if (arr[m][k] == a) {
					count++;
				} else {
					break;
				}
				if (count >= 5) {
					if (arr[m][k] == 1) {
						JOptionPane.showMessageDialog(null, "黑方赢");
						play = false;
						isrenji=false;
					} else {
						JOptionPane.showMessageDialog(null, "白方赢");
						play = false;
						isrenji=false;
					}
					break;
				}
			}
			count = 1;
			// 左上、右下
			for (int m = x - 1, k = y - 1; m >= 0 && k >= 0; k--, m--) {
				if (arr[m][k] == a) {
					count++;
				} else {
					break;
				}
				if (count >= 5) {
					if (arr[m][k] == 1) {
						JOptionPane.showMessageDialog(null, "黑方赢");
						play = false;
						isrenji=false;
					} else {
						JOptionPane.showMessageDialog(null, "白方赢");
						play = false;
						isrenji=false;
					}
					break;
				}
			}
			for (int m = x + 1, k = y + 1; m < arr.length && k < arr.length; k++, m++) {
				if (arr[m][k] == 0) {
					break;
				}
				if (arr[m][k] == a) {
					count++;
				} else {
					break;
				}
				if (count >= 5) {
					if (arr[m][k] == 1) {
						JOptionPane.showMessageDialog(null, "黑方赢");
						play = false;
						isrenji=false;
					} else {
						JOptionPane.showMessageDialog(null, "白方赢");
						play = false;
						isrenji=false;
					}
					break;
				}
			}
			count = 1;
		}
	}

	public void mousePressed(MouseEvent e) {

	}

	public void mouseReleased(MouseEvent e) {

	}

	public void mouseEntered(MouseEvent e) {
	}

	public void mouseExited(MouseEvent e) {

	}

	public static void main(String[] args) {
		// TODO Auto-generated method stub
		youxi yx = new youxi();
	}

}
业精于勤荒于嬉，有志在，勿忧虑
关注
  • 3
    点赞
  • 踩
  • 16
    收藏
    觉得还不错? 一键收藏
  • 2
    评论
java入门五子棋代码
01-06
java编写五子棋的代码，成功运行。整体代码结构是，画棋盘，插背景，添响应事件，加逻辑规则，比较简单。 注意要改背景图片的相对路径！
Java 五子棋棋盘及棋子绘制
TexastheOmertosa的博客
08-08 270
棋子绘制 添加鼠标监听器在鼠标点击位置交替使用Graphic绘制黑白圆。x直线起始横坐标 x1直线结尾横坐标。y直线起始纵坐标 y1直线结尾纵坐标。确定好第一条横线与纵线后可利用循环构建棋盘格。使用直线绘制五子棋棋盘格需要知道位点坐标。可确定绘制直线的起点和终点。Graphics绘制工具。
Java图形界面编程练习——五子棋程序
Ace2NoU的博客
09-05 1984
需要用到的对象和静态常量定义 //定义三个BufferedImage，分别代表棋盘图、黑子图、白子图 private BufferedImage table; private BufferedImage black; private BufferedImage white; //定义一个BufferedImage，代表当鼠标移动时将要下子的选择框 private BufferedImage selected; //定义棋盘的宽高，这里的定义尺寸和给定的board.jpg图片的尺寸一致因为棋盘背景是通
【Java之五子棋】——java五子棋游戏
热门推荐
qq_50497708的博客
01-09 1万+
基本思路： 1.先有一个界面可以弹出窗口，在界面上重写paint方法，在这个方法里加入棋盘，使得棋盘可以不断重绘，不会因为刷新而消失； 2.创建鼠标监听器，为了让鼠标监听器界面可以下黑白棋子； 3.再创建一个判断输赢的类，可以用数组来存储棋子 接下来完成具体步骤： 1.创建一个Gobang的类，继承了JFrame的功能，因此以前会写jf.setTitle("五子棋")；这里就可以用this代替或者不写，下面这四个就是分别用了这两个方法 2.重写paint方法，绘制棋盘 可以先画两条直线
五子棋代码实现（java）
07-23 6038
package jxust.zzb.java; import java.awt.event.*; import java.awt.*; import javax.swing.*; /* 五子棋主框架類，程序啟動類 */ public class StartChessJFrame extends JFrame { private ChessBoard chessBo...
【汇智学堂】-JAVA桌面游戏开发（五子棋之五：重新开始）
weixin_39593940的博客
03-22 934
修改PCChessBoard2类中的mouseClicked事件。 @Override public void mouseClicked(MouseEvent e) { ex=e.getX(); ey=e.getY(); //如果是“重新开始" if(ex>550&&ex<700&&ey>50&&a...
javafx逻辑实现五子棋基本功能（悔棋，重新开始，保存棋谱，复盘，人人对战，单机模式
mysunnygirl的博客
03-16 3786
javafx逻辑实现五子棋基本功能（悔棋，重新开始，保存棋谱，复盘，人人对战，单机模式） 做这个项目，本身目的仅仅是想应用学过的知识做个小项目，想知道它们在实际开发中应该如何应用，顺便帮我对几个月来的学习的知识更深入的了解。等我学完了数据库，再做个更大的项目，应该不成问题。所以，这篇文章适合学完Java基础的人学习，这也是我对自己Java学习第一阶段做的总结。 ...
Java面向对象编程-五子棋v1.0
weixin_63136968的博客
12-20 251
Java面向对象编程-五子棋v1.0
java五子棋代码（控制台输出）
zylyw123的博客
08-19 291
【代码】java五子棋代码（控制台输出）
Java五子棋详细步骤及完整代码
我的博客
07-21 2321
/定义一个变量, 作为当前落子的角色, 1代表黑子, 2代表白子 int role = 1;
java代码-五子棋游戏代码
03-09
五子棋游戏代码，基本功能都都有 ——学习资料: 仅用于个人学习使用
java实现游戏-五子棋1
07-30
这个五子棋小游戏可以让两名游戏玩家之间进行游戏对决，当有一方的棋子有横竖或者斜着相连的五个相同颜色的棋子时，该玩家即获胜。在玩游戏的过程中玩家可以得到放松和娱乐，完成了五子棋游戏的基本操作，可实现两个...
基于java-swing五子棋游戏
03-23
该五子棋采用C/S架构，分为服务器和客户端，开始游戏时服务器先启动，单击侦听按钮启动服务器，侦听是否有客户端连接。如果有连接则进入聊天和下棋功能，同时侦听按钮文字变成正在聊天用户根据提示信息，轮到自己...
Java小游戏-swing-五子棋
01-27
五子棋
java入门之五子棋游戏
07-24
（1） 本软件是五子棋游戏； （2） 可以实现两人PK和人机大战两大游戏功能； （3） 重新开始：在指定的游戏模式下，重新开始游戏； （4） 游戏说明：描述了五子棋游戏的规则。 解压导入项目后需要手动配置jar包...
string模拟实现
m0_73969414的博客
04-23 827
c++中string的模拟实现，面试必会知识点
【1524】java投票管理系统Myeclipse开发mysql数据库web结构java编程计算机网页项目
qq_251836457的博客
04-18 854
2、开发环境为TOMCAT7.0,Myeclipse8.5开发，数据库为Mysql5.0，使用java语言开发。(5)投票选项管理：对投票选项信息进行添加、删除、修改和查看。(6)投票记录管理：对投票记录信息进行添加、删除、修改和查看。(1)管理员管理：对管理员信息进行添加、删除、修改和查看。(2)用户管理：对用户信息进行添加、删除、修改和查看。(3)公告管理：对公告信息进行添加、删除、修改和查看。(4)投票管理：对投票信息进行添加、删除、修改和查看。4）投票浏览查看、查看投票、投票记录。
PageHelper实现分页查询
m0_63849044的博客
04-24 646
这行代码是在使用 MyBatis Generator (MBG) 或类似的 MyBatis 工具生成的代码来构建查询条件。（可能是MyBatis的Mapper接口）来执行基于前面定义的查询条件的查询，并获取结果列表。实例之后会被用来设置各种查询条件，如字段的等于、不等于、大于、小于、模糊查询等。实体类生成的辅助类，它通常包含了一些静态内部类和方法，用于构建查询条件。在MyBatis中，这样的对象通常用于构建查询条件。对象，可能用于作为查询条件）。的一个内部类，用于定义查询的具体条件。
Lambda表达式特点
最新发布
weixin_57763462的博客
04-24 311
**API 设计**：Lambda 表达式鼓励使用函数式接口的设计模式，这改变了 Java 库的设计，例如 `java.util.function` 包下的一系列函数式接口。- **函数式编程**：Lambda 表达式引入了函数式编程的理念，使得 Java 更接近于函数式编程语言，如 Scala 和 Clojure。- **并发编程**：Lambda 表达式与 Java 8 新增的 Stream API 结合使用，可以简化并发编程，特别是与集合的操作相关。
java制作五子棋游戏
06-03
下面是一个简单的 Java 五子棋游戏示例，供参考： ```java import java.util.Scanner; public class Gomoku { private static final int ROWS = 15; private static final int COLS = 15; private static final...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论 2
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值