Java+Swing实现五子棋游戏

最新推荐文章于 2023-12-02 19:16:56 发布
最新推荐文章于 2023-12-02 19:16:56 发布
阅读量3.5k 收藏 36
点赞数 9
分类专栏： JavaSwing实战 文章标签： java 游戏 eclipse swing
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/helongqiang/article/details/122849465
版权

目录

一、系统介绍

1.开发环境

2.技术选型

3.系统功能

二、系统展示

1.首页

2.黑棋走

3.白棋走

三、部分代码

AI.java

Chess.java

Gobang.java

GobangListener.java

四、其他

1.更多系统

JavaSwing系统系列实现

Java+JSP系统系列实现

Java+Servlet系统系列实现

Java+SSM系统系列实现

Java+SSH系统系列实现

Java+Springboot系统系列实现

2.源码下载

3.运行项目

4.备注

5.支持博主

一、系统介绍

1.开发环境

开发工具：Eclipse2021

JDK版本：jdk1.8

Mysql版本：8.0.13

2.技术选型

Java+Swing

3.系统功能

实现五子棋游戏，开始游戏，悔棋，认输，退出功能。

二、系统展示

1.首页

2.黑棋走

3.白棋走

三、部分代码

AI.java

package com.sjsq;
 
import java.util.HashMap;
 
public class AI implements Gobang {
	static HashMap<String, Integer> map = new HashMap<String, Integer>();
	static {
 
		/**
		 * 权值
		 */
		// 防守权值
		// 活1连
		map.put("010", 20);  //map.put(key,value) key=键 value=值
		map.put("0-10", 10);
		// 眠1连
		map.put("-110", 1);
		map.put("1-10", 1);
		// 活2连
		map.put("0110", 200);
		map.put("0-1-10", 100);
		// 眠2连
		map.put("-1110", 20);
		map.put("1-1-10", 10);
		// 活3连
		map.put("01110", 7000);
		map.put("0-1-1-10", 5000);
		// 眠3连
		map.put("-11110", 50);
		map.put("1-1-1-10", 30);
		// 活4连
		map.put("011110", 10000);
		map.put("0-1-1-1-10", 10000);
		// 眠4连
		map.put("-111110", 10000);
		map.put("1-1-1-1-10", 10000);
		// 碰壁眠4连
		map.put("11110", 10000);
		map.put("-1-1-1-10", 10000);
 
		 //进攻权值
		 //活1连
		 map.put("010",10);
		 map.put("0-10",20);
		 //眠1连
		 map.put("-110",1);
		 map.put("1-10",1);
		 //活2连
		 map.put("0110", 100);
		 map.put("0-1-10",200);
		 //眠2连
		 map.put("-1110",10);
		 map.put("1-1-10",20);
		 //活3连
		 map.put("01110", 5000);
		 map.put("0-1-1-10",7000);
		 //眠3连
		 map.put("-11110",30);
		 map.put("1-1-1-10",50);
		 //活4连
		 map.put("011110", 10000);
		 map.put("0-1-1-1-10",10000);
		 //眠4连
		 map.put("-111110",10000);
		 map.put("1-1-1-1-10",10000);
		 //碰壁眠4连
		 map.put("11110", 10000);
		 map.put("-1-1-1-10", 15000);
	}
 
	static String code;
	static Integer weight;
 
	public static void Quan() {
		for (int r = 0; r < array1.length; r++) {
			for (int c = 0; c < array1[r].length; c++) {
				if (array1[r][c] == 0) {// 如果该位置没有棋子则开始统计
					code = countHL(r, c);// 调用水平向左统计的方法
					weight = map.get(code);// 根据棋子相连情况获取对应的权值
					if (weight != null) {// 判断是否有该种棋子相连的情况
						weightArray[r][c] += weight;// 累加权值
					}
					// 把另外七个方向统计完毕后，就完成权值统计
					code = countHR(r, c);// 调用水平向右统计的方法
					weight = map.get(code);// 根据棋子相连情况获取对应的权值
					if (weight != null) {// 判断是否有该种棋子相连的情况
						weightArray[r][c] += weight;// 累加权值
					}
 
					code = countHT(r, c);// 调用水平向左统计的方法
					weight = map.get(code);// 根据棋子相连情况获取对应的权值
					if (weight != null) {// 判断是否有该种棋子相连的情况
						weightArray[r][c] += weight;// 累加权值
					}
 
					code = countHB(r, c);// 调用水平向左统计的方法
					weight = map.get(code);// 根据棋子相连情况获取对应的权值
					if (weight != null) {// 判断是否有该种棋子相连的情况
						weightArray[r][c] += weight;// 累加权值
					}
 
					code = countHZXS(r, c);// 调用水平向左统计的方法
					weight = map.get(code);// 根据棋子相连情况获取对应的权值
					if (weight != null) {// 判断是否有该种棋子相连的情况
						weightArray[r][c] += weight;// 累加权值
					}
 
					code = countHYXS(r, c);// 调用水平向左统计的方法
					weight = map.get(code);// 根据棋子相连情况获取对应的权值
					if (weight != null) {// 判断是否有该种棋子相连的情况
						weightArray[r][c] += weight;// 累加权值
					}
 
					code = countHZXX(r, c);// 调用水平向左统计的方法
					weight = map.get(code);// 根据棋子相连情况获取对应的权值
					if (weight != null) {// 判断是否有该种棋子相连的情况
						weightArray[r][c] += weight;// 累加权值
					}
 
					code = countHYXX(r, c);// 调用水平向左统计的方法
					weight = map.get(code);// 根据棋子相连情况获取对应的权值
					if (weight != null) {// 判断是否有该种棋子相连的情况
						weightArray[r][c] += weight;// 累加权值
					}
// 针对每种情况都进行权值分析，保证五子棋规则的完善
					// 判断两个2连在一条直线但中间有一个空位的情况
					if ((countHL(r, c) + countHR(r, c) == "01100110")
							|| (countHL(r, c) + countHR(r, c) == "0-1-100-1-10")
							|| (countHL(r, c) + countHR(r, c) == "-11100110")
							|| (countHL(r, c) + countHR(r, c) == "1-1-100-1-10")
							|| (countHL(r, c) + countHR(r, c) == "0110-1110")
							|| (countHL(r, c) + countHR(r, c) == "0-1-101-1-10")
							|| (countHL(r, c) + countHR(r, c) == "-1110-1110")
							|| (countHL(r, c) + countHR(r, c) == "1-1-101-1-10")) {
						weightArray[r][c] = weightArray[r][c] + 5000;  
					}
 
					if ((countHT(r, c) + countHB(r, c) == "01100110")
							|| (countHT(r, c) + countHB(r, c) == "0-1-100-1-10")
							|| (countHT(r, c) + countHB(r, c) == "-11100110")
							|| (countHT(r, c) + countHB(r, c) == "1-1-100-1-10")
							|| (countHT(r, c) + countHB(r, c) == "0110-1110")
							|| (countHT(r, c) + countHB(r, c) == "0-1-101-1-10")
							|| (countHT(r, c) + countHB(r, c) == "-1110-1110")
							|| (countHT(r, c) + countHB(r, c) == "1-1-101-1-10")) {
						weightArray[r][c] = weightArray[r][c] + 5000;
					}
 
					if ((countHZXS(r, c) + countHYXX(r, c) == "01100110")
							|| (countHZXS(r, c) + countHYXX(r, c) == "0-1-100-1-10")
							|| (countHZXS(r, c) + countHYXX(r, c) == "-11100110")
							|| (countHZXS(r, c) + countHYXX(r, c) == "1-1-100-1-10")
							|| (countHZXS(r, c) + countHYXX(r, c) == "0110-1110")
							|| (countHZXS(r, c) + countHYXX(r, c) == "0-1-101-1-10")
							|| (countHZXS(r, c) + countHYXX(r, c) == "-1110-1110")
							|| (countHZXS(r, c) + countHYXX(r, c) == "1-1-101-1-10")) {
						weightArray[r][c] = weightArray[r][c] + 5000;
					}
 
					if ((countHYXS(r, c) + countHZXX(r, c) == "01100110")
							|| (countHYXS(r, c) + countHZXX(r, c) == "0-1-100-1-10")
							|| (countHYXS(r, c) + countHZXX(r, c) == "-11100110")
							|| (countHYXS(r, c) + countHZXX(r, c) == "1-1-100-1-10")
							|| (countHYXS(r, c) + countHZXX(r, c) == "0110-1110")
							|| (countHYXS(r, c) + countHZXX(r, c) == "0-1-101-1-10")
							|| (countHYXS(r, c) + countHZXX(r, c) == "-1110-1110")
							|| (countHYXS(r, c) + countHZXX(r, c) == "1-1-101-1-10")) {
						weightArray[r][c] = weightArray[r][c] + 5000;
					}
 
					// 判断一个活2连和一个活1连在一条直线上但中间有一个空位的情况
					if ((countHL(r, c) + countHR(r, c) == "0100110") || (countHL(r, c) + countHR(r, c) == "0-100-1-10")
							|| (countHL(r, c) + countHR(r, c) == "0110010")
							|| (countHL(r, c) + countHR(r, c) == "0-1-100-10")) {
						weightArray[r][c] = weightArray[r][c] + 3000;
					}
 
					if ((countHT(r, c) + countHB(r, c) == "0100110") || (countHT(r, c) + countHB(r, c) == "0-100-1-10")
							|| (countHT(r, c) + countHB(r, c) == "0110010")
							|| (countHT(r, c) + countHB(r, c) == "0-1-100-10")) {
						weightArray[r][c] = weightArray[r][c] + 3000;
					}
 
					if ((countHZXS(r, c) + countHYXX(r, c) == "0100110")
							|| (countHZXS(r, c) + countHYXX(r, c) == "0-100-1-10")
							|| (countHZXS(r, c) + countHYXX(r, c) == "0110010")
							|| (countHZXS(r, c) + countHYXX(r, c) == "0-1-100-10")) {
						weightArray[r][c] = weightArray[r][c] + 3000;
					}
 
					if ((countHYXS(r, c) + countHZXX(r, c) == "0100110")
							|| (countHYXS(r, c) + countHZXX(r, c) == "0-100-1-10")
							|| (countHYXS(r, c) + countHZXX(r, c) == "0110010")
							|| (countHYXS(r, c) + countHZXX(r, c) == "0-1-100-10")) {
						weightArray[r][c] = weightArray[r][c] + 3000;
					}
 
					// 眠3连的一端被堵了
					// "1-1-1-10"&"010" "0-1-1-10"&"010"
					if ((countHL(r, c) + countHR(r, c) == "1-1-1-10010")
							|| (countHL(r, c) + countHR(r, c) == "0101-1-1-10")
							|| (countHL(r, c) + countHR(r, c) == "1-1-1-100")
							|| (countHL(r, c) + countHR(r, c) == "01-1-1-10")
							|| (countHL(r, c) + countHR(r, c) == "1-1-1-100110")
							|| (countHL(r, c) + countHR(r, c) == "01101-1-1-10")) {
						weightArray[r][c] = 1;
					}
 
					if ((countHT(r, c) + countHB(r, c) == "1-1-1-10010")
							|| (countHT(r, c) + countHB(r, c) == "0101-1-1-10")
							|| (countHT(r, c) + countHB(r, c) == "1-1-1-100")
							|| (countHT(r, c) + countHB(r, c) == "01-1-1-10")
							|| (countHT(r, c) + countHB(r, c) == "1-1-1-100110")
							|| (countHT(r, c) + countHB(r, c) == "01101-1-1-10")) {
						weightArray[r][c] = 1;
						;
					}
 
					if ((countHZXS(r, c) + countHYXX(r, c) == "1-1-1-10010")
							|| (countHZXS(r, c) + countHYXX(r, c) == "0101-1-1-10")
							|| (countHZXS(r, c) + countHYXX(r, c) == "1-1-1-100")
							|| (countHZXS(r, c) + countHYXX(r, c) == "01-1-1-10")
							|| (countHZXS(r, c) + countHYXX(r, c) == "1-1-1-100110")
							|| (countHZXS(r, c) + countHYXX(r, c) == "01101-1-1-10")) {
						weightArray[r][c] = 1;
					}
 
					if ((countHYXS(r, c) + countHZXX(r, c) == "1-1-1-10010")
							|| (countHYXS(r, c) + countHZXX(r, c) == "0101-1-1-10")
							|| (countHYXS(r, c) + countHZXX(r, c) == "1-1-1-100")
							|| (countHYXS(r, c) + countHZXX(r, c) == "01-1-1-10")
							|| (countHYXS(r, c) + countHZXX(r, c) == "1-1-1-100110")
							|| (countHYXS(r, c) + countHZXX(r, c) == "01101-1-1-10")) {
						weightArray[r][c] = 1;
					}
 
					// 3连和1连在一条线上差一个棋位
					if ((countHL(r, c) + countHR(r, c) == "0-1-1-100-10")
							|| (countHL(r, c) + countHR(r, c) == "0-101-1-1-10")
							|| (countHL(r, c) + countHR(r, c) == "01110010")
							|| (countHL(r, c) + countHR(r, c) == "010-11110")
							|| (countHL(r, c) + countHR(r, c) == "0-100-1-1-10")
							|| (countHL(r, c) + countHR(r, c) == "1-1-1-100-10")
							|| (countHL(r, c) + countHR(r, c) == "01001110")
							|| (countHL(r, c) + countHR(r, c) == "-11110010")) {
						weightArray[r][c] = weightArray[r][c] + 4000;
					}
 
					if ((countHT(r, c) + countHB(r, c) == "0-1-1-100-10")
							|| (countHT(r, c) + countHB(r, c) == "0-101-1-1-10")
							|| (countHT(r, c) + countHB(r, c) == "01110010")
							|| (countHT(r, c) + countHB(r, c) == "010-11110")
							|| (countHT(r, c) + countHB(r, c) == "0-100-1-1-10")
							|| (countHT(r, c) + countHB(r, c) == "1-1-1-100-10")
							|| (countHT(r, c) + countHB(r, c) == "01001110")
							|| (countHT(r, c) + countHB(r, c) == "-11110010")) {
						weightArray[r][c] = weightArray[r][c] + 4000;
					}
 
					if ((countHZXS(r, c) + countHYXX(r, c) == "0-1-1-100-10")
							|| (countHZXS(r, c) + countHYXX(r, c) == "0-101-1-1-10")
							|| (countHZXS(r, c) + countHYXX(r, c) == "01110010")
							|| (countHZXS(r, c) + countHYXX(r, c) == "010-11110")
							|| (countHZXS(r, c) + countHYXX(r, c) == "0-100-1-1-10")
							|| (countHZXS(r, c) + countHYXX(r, c) == "1-1-1-100-10")
							|| (countHZXS(r, c) + countHYXX(r, c) == "01001110")
							|| (countHZXS(r, c) + countHYXX(r, c) == "-11110010")) {
						weightArray[r][c] = weightArray[r][c] + 4000;
					}
 
					if ((countHYXS(r, c) + countHZXX(r, c) == "0-1-1-100-10")
							|| (countHYXS(r, c) + countHZXX(r, c) == "0-101-1-1-10")
							|| (countHYXS(r, c) + countHZXX(r, c) == "01110010")
							|| (countHYXS(r, c) + countHZXX(r, c) == "010-11110")
							|| (countHYXS(r, c) + countHZXX(r, c) == "0-100-1-1-10")
							|| (countHYXS(r, c) + countHZXX(r, c) == "1-1-1-100-10")
							|| (countHYXS(r, c) + countHZXX(r, c) == "01001110")
							|| (countHYXS(r, c) + countHZXX(r, c) == "-11110010")) {
						weightArray[r][c] = weightArray[r][c] + 4000;
					}
				}
			}
		}
	}
 
	// 水平向左统计的方法
	public static String countHL(int r, int c) {
		String code = "0";
		int chess = 0;// 存储第一颗出现的棋子
		// 循环遍历
		for (int r1 = r - 1; r1 >= 0; r1--) {
			if (array1[r1][c] == 0) {// 表示空位沒有棋子
				if (r1 + 1 == r) {// 相邻
					break;
				} else {
					code = array1[r1][c] + code;// 记录棋子相连情况
					break;
				}
			} else {// 表示该位置有棋子
				if (chess == 0) {// 第一次出现棋子
					chess = array1[r1][c];// 记录棋子
					code = array1[r1][c] + code;// 记录棋子相连情况
				} else if (chess == array1[r1][c]) {
					code = array1[r1][c] + code;// 记录棋子相连情况
				} else {
					code = array1[r1][c] + code;// 记录棋子相连情况
					break;
				}
			}
		}
		return code;
	}
 
	// 水平向右统计的方法
	public static String countHR(int r, int c) {
		String code = "0";
		int chess = 0;// 存储第一颗出现的棋子
		// 循环遍历
		for (int r1 = r + 1; r1 < coloum; r1++) {
			if (array1[r1][c] == 0) {// 表示空位沒有棋子
				if (r1 - 1 == r) {// 相邻
					break;
				} else {
					code = array1[r1][c] + code;// 记录棋子相连情况
					break;
				}
			} else {// 表示该位置有棋子
				if (chess == 0) {// 第一次出现棋子
					chess = array1[r1][c];// 记录棋子
					code = array1[r1][c] + code;// 记录棋子相连情况
				} else if (chess == array1[r1][c]) {
					code = array1[r1][c] + code;// 记录棋子相连情况
				} else {
					code = array1[r1][c] + code;// 记录棋子相连情况
					break;
				}
			}
		}
		return code;
	}
 
	// 竖直向上统计的方法
	public static String countHT(int r, int c) {
		String code = "0";
		int chess = 0;// 存储第一颗出现的棋子
		// 循环遍历
		for (int c1 = c - 1; c1 >= 0; c1--) {
			if (array1[r][c1] == 0) {// 表示空位沒有棋子
				if (c1 + 1 == r) {// 相邻
					break;
				} else {
					code = array1[r][c1] + code;// 记录棋子相连情况
					break;
				}
			} else {// 表示该位置有棋子
				if (chess == 0) {// 第一次出现棋子
					chess = array1[r][c1];// 记录棋子
					code = array1[r][c1] + code;// 记录棋子相连情况
				} else if (chess == array1[r][c1]) {
					code = array1[r][c1] + code;// 记录棋子相连情况
				} else {
					code = array1[r][c1] + code;// 记录棋子相连情况
					break;
				}
			}
		}
		return code;
	}
 
	// 竖直向下统计的方法
	public static String countHB(int r, int c) {
		String code = "0";
		int chess = 0;// 存储第一颗出现的棋子
		// 循环遍历
		for (int c1 = c + 1; c1 < row; c1++) {
			if (array1[r][c1] == 0) {// 表示空位沒没有棋子
				if (c1 - 1 == c) {// 相邻
					break;
				} else {
					code = array1[r][c1] + code;// 记录棋子相连情况
					break;
				}
			} else {// 表示该位置有棋子
				if (chess == 0) {// 第一次出现棋子
					chess = array1[r][c1];// 记录棋子
					code = array1[r][c1] + code;// 记录棋子相连情况
				} else if (chess == array1[r][c1]) {
					code = array1[r][c1] + code;// 记录棋子相连情况
				} else {
					code = array1[r][c1] + code;// 记录棋子相连情况
					break;
				}
			}
		}
		return code;
	}
 
	// 左斜向上统计的方法
	public static String countHZXS(int r, int c) {
		String code = "0";
		int chess = 0;// 存储第一颗出现的棋子
		// 循环遍历
		for (int r1 = r - 1, c1 = c - 1; r1 >= 0 && c1 >= 0; r1--, c1--) {
			if (array1[r1][c1] == 0) {// 表示空位沒有棋子
				if (c1 + 1 == c && r1 + 1 == r) {// 相邻
					break;
				} else {
					code = array1[r1][c1] + code;// 记录棋子相连情况
					break;
				}
			} else {// 表示该位置有棋子
				if (chess == 0) {// 第一次出现棋子
					chess = array1[r1][c1];// 记录棋子
					code = array1[r1][c1] + code;// 记录棋子相连情况
				} else if (chess == array1[r1][c1]) {
					code = array1[r1][c1] + code;// 记录棋子相连情况
				} else {
					code = array1[r1][c1] + code;// 记录棋子相连情况
					break;
				}
			}
		}
		return code;
	}
 
	// 右斜向上统计的方法
	public static String countHYXS(int r, int c) {
		String code = "0";
		int chess = 0;// 存储第一颗出现的棋子
		// 循环遍历
		for (int r1 = r + 1, c1 = c - 1; c1 >= 0 && r1 < coloum; r1++, c1--) {
			if (array1[r1][c1] == 0) {// 表示空位沒有棋子
				if (r1 - 1 == r && c1 + 1 == c) {// 相邻
					break;
				} else {
					code = array1[r1][c1] + code;// 记录棋子相连情况
					break;
				}
			} else {// 表示该位置有棋子
				if (chess == 0) {// 第一次出现棋子
					chess = array1[r1][c1];// 记录棋子
					code = array1[r1][c1] + code;// 记录棋子相连情况
				} else if (chess == array1[r1][c1]) {
					code = array1[r1][c1] + code;// 记录棋子相连情况
				} else {
					code = array1[r1][c1] + code;// 记录棋子相连情况
					break;
				}
			}
		}
		return code;
	}
 
	// 左斜向下统计的方法
	public static String countHZXX(int r, int c) {
		String code = "0";
		int chess = 0;// 存储第一颗出现的棋子
		// 循环遍历
		for (int r1 = r - 1, c1 = c + 1; c1 < row && r1 >= 0; c1++, r1--) {
			if (array1[r1][c1] == 0) {// 表示空位沒有棋子
				if (c1 - 1 == c && r1 + 1 == r) {// 相邻
					break;
				} else {
					code = array1[r1][c1] + code;// 记录棋子相连情况
					break;
				}
			} else {// 表示该位置有棋子
				if (chess == 0) {// 第一次出现棋子
					chess = array1[r1][c1];// 记录棋子
					code = array1[r1][c1] + code;// 记录棋子相连情况
				} else if (chess == array1[r1][c1]) {
					code = array1[r1][c1] + code;// 记录棋子相连情况
				} else {
					code = array1[r1][c1] + code;// 记录棋子相连情况
					break;
				}
			}
		}
		return code;
	}
 
	// 右斜向下统计的方法
	public static String countHYXX(int r, int c) {
		String code = "0";
		int chess = 0;// 存储第一颗出现的棋子
		// 循环遍历
		for (int r1 = r + 1, c1 = c + 1; r1 < coloum && c1 < row; r1++, c1++) {
			if (array1[r1][c1] == 0) {// 表示空位沒有棋子
				if (c1 - 1 == c && r1 - 1 == r) {// 相邻
					break;
				} else {
					code = array1[r1][c1] + code;// 记录棋子相连情况
					break;
				}
			} else {// 表示该位置有棋子
				if (chess == 0) {// 第一次出现棋子
					chess = array1[r1][c1];// 记录棋子
					code = array1[r1][c1] + code;// 记录棋子相连情况
				} else if (chess == array1[r1][c1]) {
					code = array1[r1][c1] + code;// 记录棋子相连情况
				} else {
					code = array1[r1][c1] + code;// 记录棋子相连情况
					break;
				}
			}
		}
		return code;
	}
}


Chess.java

package com.sjsq;

import java.awt.Color;//设置棋子颜色和棋子的落子位置

public class Chess extends Object implements Gobang{
	int coloum,row; //输入列数，行数
	Color color; //棋盘颜色的设置
	
	public Chess(int coloum,int row,Color color) {
		this.coloum=coloum;
		this.row=row;
		this.color=color;
	}
}


Gobang.java

package com.sjsq;

public interface Gobang {  //接口  申明全局变量
	public static final int size = 40; // 设置格子大小为40
	public static final int X = 20, Y = 20; // 设置棋盘右上角的位置
	public static final int coloum = 15;    //设置行数
	public static final int row = 15;       //设置列数
	public static final int[][] array1 = new int[coloum][row];   //记录棋子位置的数组
	public static final int[][] weightArray = new int[coloum][row];    //记录棋盘每个位置的权值
	public static final boolean flag[] = new boolean[2];    //记录选择的模式
	public static final boolean co[] = new boolean[2];    //记录选择的棋色
}


GobangListener.java

package com.sjsq;
 
import java.awt.Color;
import java.awt.Graphics;
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;
import java.awt.event.MouseAdapter;
import java.awt.event.MouseEvent;
import java.util.Arrays;

import javax.swing.JOptionPane;
 
public class GobangListener extends MouseAdapter implements ActionListener,Gobang{
 
	private GobangMain gm;   	// 棋盘面板对象
	private Graphics g;     	// 画笔对象
	boolean cco=true;      	//记录玩家下棋还是电脑下棋
	boolean fff=true;     		//记录是否能悔棋
	boolean	 ggg=true;    		//记录是否能认输
	private MyArrayList<Chess> array;
	int coloum1,row1;
	int xx,yy,max;
	
	public GobangListener(GobangMain gm,MyArrayList<Chess> array) {  //从GobangMain传窗体对象和记录棋子的数组
		this.gm = gm;
		this.array=array;
	}
	
    public void actionPerformed(ActionEvent e) {
    	if (e.getActionCommand().equals("悔棋")) {
    		if(flag[0]) {           //人人对战悔棋
    			if(fff) {
    				if(array.getSize()>1) {
    					array1[coloum1][row1]=0;
    					Chess aaa=array.get(array.getSize()-2);
    					coloum1=aaa.coloum;
    					row1=aaa.row;
    					array.Delete();
    					cco=!cco;
    					gm.repaint();
    				}
    			}
    		}
    		
    		if(flag[1]) {      //人机对战悔棋
    			if(fff) {
    				if(cco) {
    					if(array.getSize()>2) {
    						array1[xx][yy]=0;
    						Chess aaa=array.get(array.getSize()-2);
    						coloum1=aaa.coloum;
        					row1=aaa.row;
    						array.Delete();
    						array1[coloum1][row1]=0;
    						Chess bbb=array.get(array.getSize()-2);
    						xx=bbb.coloum;
        					yy=bbb.row;
        					array.Delete();
    						gm.repaint();
    					}
    				}
    			}
    		}
    	}
    	if (e.getActionCommand().equals("认输")) {
    		if(ggg) {
    			if(flag[0]){
    			if(cco) {
    				JOptionPane.showMessageDialog(gm, "白棋获胜");
    			}else {
    				JOptionPane.showMessageDialog(gm, "黑棋获胜");
    			}
    			gm.removeMouseListener(this);
    			fff=false;
    			ggg=false;
    			}
    			if(flag[1]) {
    				if(co[0]) {
    	    			if(cco) {
    	    				JOptionPane.showMessageDialog(gm, "黑棋获胜");
    	    			}else {
    	    				JOptionPane.showMessageDialog(gm, "白棋获胜");
    	    			}
    	    			gm.removeMouseListener(this);
    	    			fff=false;
    	    			ggg=false;
    				}
    				if(co[1]) {
    	    			if(cco) {
    	    				JOptionPane.showMessageDialog(gm, "白棋获胜");
    	    			}else {
    	    				JOptionPane.showMessageDialog(gm, "黑棋获胜");
    	    			}
    	    			gm.removeMouseListener(this);
    	    			fff=false;
    	    			ggg=false;
    	        		array.Reset();
    				}
    			}
    			}
    		}
    	if (e.getActionCommand().equals("退出")) {   //退出游戏
    		System.exit(0);
		}
    	if (e.getActionCommand().equals("人人对战")) {  //选择人人对战模式 flag[0]为true,flag[1]为false
    		flag[0]=true;
    		flag[1]=false;
    		for(int i=0;i<array1.length;i++) {
    			Arrays.fill(array1[i], 0);
    		}
    		cco=true;
    		fff=true;
    		ggg=true;
    		array.Reset();
    		gm.repaint();
    	}
    	if (e.getActionCommand().equals("人机对战")) {  //选择人机对战模式 flag[0]为false,flag[1]为true
    		flag[0]=false;
    		flag[1]=true;
    		for(int i=0;i<array1.length;i++) {
    			Arrays.fill(array1[i], 0);
    		}
    		cco=true;
    		fff=true;
    		ggg=true;
    		array.Reset();
    		gm.repaint();
    	}
    	if (e.getActionCommand().equals("黑子(先手)")) {  
    		co[0]=false;
    		co[1]=true;
    		for(int i=0;i<array1.length;i++) {
    			Arrays.fill(array1[i], 0);
    		}
    		cco=true;
    		fff=true;
    		ggg=true;
    		array.Reset();
    		gm.repaint();
    	}
    	if (e.getActionCommand().equals("白子(后手)")) {  
    		co[0]=true;
    		co[1]=false;
    		for(int i=0;i<array1.length;i++) {
    			Arrays.fill(array1[i], 0);
    		}
    		cco=false;
    		fff=true;
    		ggg=true;
    		array.Reset();
    		gm.repaint();
    	}
    	if (e.getActionCommand().equals("开始新游戏")) {
    		if(flag[1]) {
    		if (co[1]){
    		for(int i=0;i<array1.length;i++) {
    			Arrays.fill(array1[i], 0);
    		}
    		gm.addMouseListener(this);
    		array.Reset();
    		gm.repaint();
    	}
    	if(co[0]) {

			for(int i=0;i<array1.length;i++) {
    			Arrays.fill(array1[i], 0);
    		}
//			cco=false;
    		gm.addMouseListener(this);
    		array.Reset();
    		gm.repaint();
    		
//    		g.setColor(Color.BLACK);
//			g.fillOval(X+8*size-size/2, Y+8*size-size/2, size, size);
			array1[7][7]=-1;   //AI先手第一个子落点
			Chess sh=new Chess(7,7,Color.BLACK);
			array.add(sh);
			cco=true;
			fff=true;
			ggg=true;
    	}
		}
    		if(flag[0]) {
    			for(int i=0;i<array1.length;i++) {
        			Arrays.fill(array1[i], 0);
        		}
    			cco=true;
    			fff=true;
        		ggg=true;
        		gm.addMouseListener(this);
        		array.Reset();
        		gm.repaint();
    		}
    		}
    	}
 
	public void mouseReleased(MouseEvent e) {     //鼠标松开的时候进行的操作
		if(flag[0]) {  //选择人人对战模式进行的操作
			if (g == null)
				g = gm.getGraphics();
			int x = e.getX();
			int y = e.getY();
			coloum1 = (x-X+size/2)/size; 
			row1 = (y-Y+size/2)/size;
			if(coloum1<coloum&&row1<row) {
				if(array1[coloum1][row1]==0) {
					if(cco) {
						g.setColor(Color.BLACK);
						g.fillOval(X+coloum1*size-size/2, Y+row1*size-size/2, size, size);
						array1[coloum1][row1]=1;
						Chess sh=new Chess(coloum1,row1,Color.BLACK);
						array.add(sh);
					}
					else {
						g.setColor(Color.WHITE);
						g.fillOval(X+coloum1*size-size/2, Y+row1*size-size/2, size, size);
						array1[coloum1][row1]=-1;
						Chess sh=new Chess(coloum1,row1,Color.WHITE);
						array.add(sh);
					}
				
					Judge jd=new Judge(coloum1,row1);
					if(jd.judge()) {
						if(cco) {
							JOptionPane.showMessageDialog(gm, "黑棋获胜");
						}else {
							JOptionPane.showMessageDialog(gm, "白棋获胜");
						}
						gm.removeMouseListener(this);
						fff=false;
						ggg=false;
			    		array.Reset();
					}
					cco=!cco;
				
				}
				
			}
		}
		
		if(flag[1]) { //选择人机对战进行的操作
			if (g == null)
				g = gm.getGraphics();
			if(co[1]) {
			if(cco) { //若cco为true，则人下棋
				int x = e.getX();
				int y = e.getY();
				coloum1 = (x-X+size/2)/size; 
				row1 = (y-Y+size/2)/size;
				if(coloum1<coloum&&row1<row) {
					if(array1[coloum1][row1]==0) {
						g.setColor(Color.BLACK);
						g.fillOval(X+coloum1*size-size/2, Y+row1*size-size/2, size, size);
						array1[coloum1][row1]=1;
						Chess sh=new Chess(coloum1,row1,Color.BLACK);
						array.add(sh);
						
						Judge jd=new Judge(coloum1,row1);
						if(jd.judge()) {
							if(cco) {
								JOptionPane.showMessageDialog(gm, "黑棋获胜");
							}else {
								JOptionPane.showMessageDialog(gm, "白棋获胜");
							}
							gm.removeMouseListener(this);
							fff=false;
							ggg=false;
				    		array.Reset();
							cco=!cco;
						}
						cco=!cco;
					
					}
					
				}
			}
			if(!cco) {  //若cco为false，则机器下棋
				AIX();
			}
		}
			if(co[0]) {
				if(cco) { //若cco为true，则人下棋
					int x = e.getX();
					int y = e.getY();
					coloum1 = (x-X+size/2)/size; 
					row1 = (y-Y+size/2)/size;
					if(coloum1<coloum&&row1<row) {
						if(array1[coloum1][row1]==0) {
							g.setColor(Color.WHITE);
							g.fillOval(X+coloum1*size-size/2, Y+row1*size-size/2, size, size);
							array1[coloum1][row1]=1;
							Chess sh=new Chess(coloum1,row1,Color.WHITE);
							array.add(sh);
							
							Judge jd=new Judge(coloum1,row1);
							if(jd.judge()) {
								if(cco) {
									JOptionPane.showMessageDialog(gm, "白棋获胜");
								}else {
									JOptionPane.showMessageDialog(gm, "黑棋获胜");
								}
								gm.removeMouseListener(this);
								fff=false;
								ggg=false;
					    		array.Reset();
								cco=!cco;
							}
							cco=!cco;
						
						}
						
					}
				}
				if(!cco) {  //若cco为false，则机器下棋
					AIX();
				}
			}
		}
		
		
	}
	
	//调用AI进行下棋
	public void AIX() {
		if(co[1]) {
		for(int i=0;i<weightArray.length;i++) {
			for(int j=0;j<weightArray[i].length;j++) {
				weightArray[i][j]=0;
			}
		}
		max=-1;
		AI.Quan();  
		for(int i=0;i<weightArray.length;i++) {
			for(int j=0;j<weightArray[i].length;j++) {
				if(i<5&&j<5) {
					if(max<=weightArray[i][j]&&array1[i][j]==0) {
						max=weightArray[i][j];
						xx=i;yy=j;
					}
				}else {
					if(max<weightArray[i][j]&&array1[i][j]==0) {
						max=weightArray[i][j];
						xx=i;yy=j;
					}
				}
			}
		}
		if(array1[xx][yy]==0) {
			g.setColor(Color.WHITE);
			g.fillOval(X+xx*size-size/2, Y+yy*size-size/2, size, size);
			array1[xx][yy]=-1;
			Chess sh=new Chess(xx,yy,Color.WHITE);
			array.add(sh);
		
			Judge jd=new Judge(xx,yy);
			if(jd.judge()) {
				if(cco) {
					JOptionPane.showMessageDialog(gm, "黑棋获胜");
				}else {
					JOptionPane.showMessageDialog(gm, "白棋获胜");
				}
				gm.removeMouseListener(this);  //移除监听，这时将不能对棋盘进行操作
				fff=false;         //设置不能进行悔棋
				ggg=false;         //设置不能进行认输
	    		array.Reset();
			}
			cco=!cco;
		}
	}
		if(co[0]) {
			for(int i=0;i<weightArray.length;i++) {
				for(int j=0;j<weightArray[i].length;j++) {
					weightArray[i][j]=0;
				}
			}
			max=-1;
			AI.Quan();
			for(int i=0;i<weightArray.length;i++) {
				for(int j=0;j<weightArray[i].length;j++) {
					if(i<5&&j<5) {
						if(max<=weightArray[i][j]&&array1[i][j]==0) {
							max=weightArray[i][j];
							xx=i;yy=j;
						}
					}else {
						if(max<weightArray[i][j]&&array1[i][j]==0) {
							max=weightArray[i][j];
							xx=i;yy=j;
						}
					}
				}
			}
			
			if(array1[xx][yy]==0) {
				g.setColor(Color.BLACK);
				g.fillOval(X+xx*size-size/2, Y+yy*size-size/2, size, size);
				array1[xx][yy]=-1;
				Chess sh=new Chess(xx,yy,Color.BLACK);
				array.add(sh);
				Judge jd=new Judge(xx,yy);
				if(jd.judge()) {
					if(cco) {
						JOptionPane.showMessageDialog(gm, "白棋获胜");
					}else {
						JOptionPane.showMessageDialog(gm, "黑棋获胜");
					}
					gm.removeMouseListener(this);  //移除监听，这时将不能对棋盘进行操作
					fff=false;         //设置不能进行悔棋
					ggg=false;         //设置不能进行认输
		    		array.Reset();
				}
				cco=!cco;
			}
		}
}
	



	}

四、其他

1.更多系统

JavaSwing系统系列实现

Java+Swing实现斗地主游戏

Java+Swing实现图书管理系统

Java+Swing实现医院管理系统

Java+Swing实现考试管理系统

Java+Swing实现酒店管理系统

Java+Swing实现超市管理系统

Java+Swing实现电影购票系统

Java+Swing实现仓库管理系统-1

Java+Swing实现仓库管理系统-2

Java+Swing实现进销存管理系统

Java+Swing实现自助取款机系统

Java+Swing实现通讯录管理系统

Java+Swing实现停车场管理系统

Java+Swing实现学生信息管理系统

Java+Swing实现学生宿舍管理系统

Java+Swing实现学生选课管理系统

Java+Swing实现学生成绩管理系统

Java+Swing实现学校教材管理系统

Java+Swing实现学校教务管理系统

Java+Swing实现企业人事管理系统

Java+Swing实现电子相册管理系统

Java+Swing实现超市管理系统-TXT存储数据

Java+Swing实现自助取款机系统-TXT存储数据

Java+Swing实现宠物商店管理系统-TXT存储数据

Java+JSP系统系列实现

Java+JSP实现学生图书管理系统

Java+JSP实现学生信息管理系统

Java+JSP实现用户信息管理系统

Java+Servlet系统系列实现

Java+Servlet+JSP实现航空订票系统

Java+Servlet+JSP实现新闻发布系统

Java+Servlet+JSP学生宿舍管理系统

Java+Servlet+JSP实现图书管理系统

Java+Servlet+JSP实现停车场管理系统

Java+Servlet+JSP实现房屋租赁管理系统

Java+Servlet+JSP实现学生信息管理系统

Java+Servlet+JSP实现学生选课管理系统

Java+Servlet+JSP实现宠物诊所管理系统

Java+Servlet+JSP实现学生成绩管理系统-1

Java+Servlet+JSP实现学生成绩管理系统-2

Java+SSM系统系列实现

Java+SSM+JSP实现图书管理系统

Java+SSM+JSP实现超市订单系统

J​​​ava+SSM+JSP实现网上考试系统

Java+SSM+JSP实现宠物商城系统

Java+SSM+Layui实现学生成绩管理系统

Java+SSM+Bootstrap实现学生信息管理系统

Java+SSH系统系列实现

Java+SSH+JSP实现在线考试系统

Java+SSH+JSP实现医院在线挂号系统

Java+Springboot系统系列实现

Java+Springboot+H-ui+Maven实现营销管理系统

Java+Springboot+Bootstrap+Maven实现网上商城系统

Java+Springboot+Bootstrap+Maven实现景区旅游管理系统

1.更多JavaWeb系统请关注专栏。

https://blog.csdn.net/helongqiang/category_10020130.htmlhttps://blog.csdn.net/helongqiang/category_10020130.html

2.更多JavaSwing系统请关注专栏。

https://blog.csdn.net/helongqiang/category_6229101.htmlhttps://blog.csdn.net/helongqiang/category_6229101.html

2.源码下载

Java+Swing实现五子棋游戏

3.运行项目

 请点击以下链接，部署你的项目。

Eclipse如何导入JavaSwing项目超详细图文教程

Eclipse如何导入JavaSwing项目超详细视频教程

4.备注

如有侵权请联系我删除。

5.支持博主

如果您觉得此文对您有帮助，请点赞加关注加收藏。祝您生活愉快！

水坚石青
关注
  • 9
    点赞
  • 踩
  • 36
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 4
    评论
专栏目录
Java Swing版本五子棋
12-15
Java Swing版本的五子棋，有简易版，有复杂版，有AI对弈版本，有悔棋，重新开始，计时，暂停，播放音乐等丰富功能，代码注释详细，新手可看懂！
Java Swing实现五子棋程序
老徐的博客只有干货
03-24 3039
首先感谢08年MLDN出的这个培训视频，我把代码和文档整理了一下，发布出来给需要学习Swing的朋友。 源码地址： https://gitee.com/indexman/gobang 一、知识点准备： JFrame：窗体 JOptionPane：对话框 MouseListener：鼠标事件 Graphics：绘制二维图像 Thread：线程类 二、五子棋游戏的功...
基于java+swing+mysql五子棋小游戏（含实训报告）
Timi2019的博客
12-02 683
一、实验目的1、熟练掌握基本网络编程技术。2、掌握Swing图形用户界面编程。3、掌握多线程编程的基本原理，能使用多线程设计服务器端程序。4、培养独立查找资料，并解决问题的能力二、实验任务网络五子棋游戏必做部分：（1）服务器端为多线程，当判断有偶数个用户连接时，方可开始游戏。（2）先连接的客户执黑棋，先下。另一客户执白棋。（3）双方交替下棋，由服务器端程序判断客户本次下棋步骤是否有效，仅将有效的下棋步骤传递给双方。
java swing写五子棋小游戏（完整代码）
qq_49639550的博客
09-16 1808
五子棋游戏开发 结构 代码： Test: package gobang2; public class Test { public static void main(String[] args) { // TODO Auto-generated method stub FiveChessFrame f=new FiveChessFrame(); } } FiveChessFrame: package gobang2; import java.awt.Color; import java.aw
J2se(11)--------五子棋游戏
疯狂编程路上的藏羚羊
03-20 540
J2se(11)阶段小练习 ----五子棋游戏gobang----五子连珠第一阶段:  画棋盘 A、首先把图片转换成程序中可以使用对象，把作为一个面板背景 1、创建一个窗体,宽度610px,高630px 2、在窗体中放置一个面板Jpanel,填充满整个屏幕 3、编写Jpanel面板的单击事件  --MouseListener----MouseClicked 4、编写内部类MyPanel继...
Java Swing五子棋
Listening_Rift的博客
02-24 1771
项目地址：https://github.com/ListeningRift/gobang 之前用python的pygame这样一个专门用于游戏制作的游戏框架写了一个扫雷，这回事用Java Swing库这个用于创建GUI的库实现了一个五子棋，我持有的观点不变，在初学时写个益智类小游戏，对算法接触基本语法等各方面都有好处。 还是一样的没有把太多精力放在界面美化上，界面的美化我个人认为大体归功于哭的...
Java小游戏——五子棋
weixin_51937688的博客
04-29 2545
文章目录内容简介一、规则二、具体代码实现1.调试环境2.代码实现3.运行演示小结彩蛋 内容简介 本文介绍了一个修改自某位大佬的五子棋小游戏qwq 目前可以实现简单的双人对战~ 原文传送门 GitHub传送门 以下是本篇文章正文内容 一、规则 本程序作为基础的五子棋，连成五个即可获胜，没有设置禁手。 注：五子棋RIF规则中黑棋只能以“四、三”取胜 二、具体代码实现 1.调试环境 开发环境为Eclipse。 2.代码实现 大致结构 具体代码如下： 1.GoBangframe类 package GoBang
Java+Swing实现的五子棋小游戏
07-20
Java+Swing实现的五子棋小游戏
基于Java+Swing实现的五子棋游戏(期末大作业)
最新发布
12-28
基于Java+Swing实现的五子棋游戏(期末大作业)已获导师指导并通过的95分的高分期末大作业项目，可作为课程设计和期末大作业，下载即用无需修改，项目完整确保可以运行。 该系统功能完善、界面美观、操作简单、功能...
五子棋源代码（包括自己做的登录界面）
07-08
自己开发五子棋源代码，希望对大家有用，里面包含有我自己做的登录界面，还有自己设计的五子棋界面。
JAVA Swing 编写的一个五子棋游戏
08-22
这是一个我自己为师弟师妹们所做的一个简单学习程序，这个程序中主要只实现了五子棋的绘制，点击鼠标下棋，判断输赢算法功能。因为，是学习用程序，在程序中还存在很多BUG，同时还有诸多功能未开发。学习者可以自己尝试修改BUG与开发遗留功能。同时，希望各位朋友能实现该程序中的AI(机器人)下棋部分，同时与我交流。谢谢各位支持！
java swing人机对战五子棋
04-08
这个小程序是我1年多前自己写着玩的，当时不懂这么多，两个个文件就搞定了，写的也不规范。 ai不是很智能，只是会搜索当前局面的最优解，评分规则是我从网上找的一个。大概介绍一下这个规则： 能成死二（当前位置下子后，可以有两颗子连在一起，但是一端有对方的一颗子或者边界阻挡），20分； 能成活二（当前位置下子后，可以有两颗子连在一起，两端没有对方棋子或者边界），80分； 能成死三，180分； 能成活三，800分； 能成死四，1200分； 能成活四，2000分； 能成五连，10000分； 程序遍历所有空白点，算出4个方向（横、竖、左斜、右斜）的分数和，算每个点的分数，然后选择所有节点中分数最高的一个落子。当时参考了一个别人的程序，他在程序中设定只搜索8x8的空间，怕电脑承受不了，我自己实现后并没有发现这个问题。
基于Java swing+socket写的五子棋网络对战游戏
05-30
基于Java开发的一个c/s结构的应用程序，包含五子棋的对战、悔棋、匹配、聊天等相关功能，代码前后端分离，资源集中管理，注释详细，欢迎大家下载研究！ 关联博客：https://blog.csdn.net/qq_20698983/article/details/80296165
Java五子棋游戏（Swing）
12-18
采用MVC的设计模式写的Java五子棋游戏 适合初学者学习
java+swing 五子棋
02-14
java+swing 五子棋
五子棋游戏图形化实现
qq_41822021的博客
11-25 690
GUI模组实现五子棋游戏的图形化,还未曾添加胜利判读逻辑，后续可以用稀疏数组进行重构，对游戏进行优化。后续更新。。。。。
【Java之五子棋】——java五子棋游戏
热门推荐
qq_50497708的博客
01-09 1万+
基本思路： 1.先有一个界面可以弹出窗口，在界面上重写paint方法，在这个方法里加入棋盘，使得棋盘可以不断重绘，不会因为刷新而消失； 2.创建鼠标监听器，为了让鼠标监听器界面可以下黑白棋子； 3.再创建一个判断输赢的类，可以用数组来存储棋子 接下来完成具体步骤： 1.创建一个Gobang的类，继承了JFrame的功能，因此以前会写jf.setTitle("五子棋")；这里就可以用this代替或者不写，下面这四个就是分别用了这两个方法 2.重写paint方法，绘制棋盘 可以先画两条直线
Java+Swing实现的五子棋游戏
qq_33037637的博客
05-21 1444
Java+Swing实现的五子棋游戏一、系统介绍二、功能展示1.游戏展示三、系统实现1.ChessFrame .java四、其它1.其他系统实现2.获取源码 一、系统介绍 五子棋游戏实现人机对战、人人对战两个模式。 二、功能展示 1.游戏展示 三、系统实现 1.ChessFrame .java package five; import java.awt.*; import java.awt.event.*; import javax.swing.*; import view.UserFrame;
基于JAVA实现的网络五子棋游戏
06-08
客户端可以使用Java Swing或JavaFX实现用户界面，服务器端则需要实现游戏规则和逻辑。 在实现游戏规则和逻辑时，需要考虑以下几个方面： 1. 实现五子棋的落子和判断胜负：定义五子棋的棋盘和棋子，实现棋子的落子...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

水坚石青

你的鼓励是我更新的动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值