实验内容
1
）随机生成一个迷宫，并求解迷宫；
2
）查找并理解迷宫生成的算法，并尝试用两种不同的算法来生成随机的迷宫。
3
）要求游戏支持玩家走迷宫，和系统走迷宫路径两种模式。
玩家走迷宫，通过键盘 方向键控制，并在行走路径上留下痕迹；
系统走迷宫路径要求基于 A*
算法实现，输出走迷宫的最优路径并显示。
4）设计交互友好的游戏图形界面。
实验思路
1.由于之前使用 Eclipse 集成开发环境安装了 Window Builder 工具包，包含了 AWT 中的 Graphics 和 Color 等类，以及一些最基本的 Java swing 工具，
所以本次实验直接使用即可，无需再添加其他插件。
2.迷宫是非常经典的游戏，基于无向图，有很多相关的算法：广度优先（BFS），深度优先（DFS）等。
其实所谓的 A*算法，就是在时间和距离上的一个平衡，广度优先算是 A* 的一个特例。
公式表示为： f(n)=g(n)+h(n)。
其中， f(n) 是从初始状态经由状态n到目标状态的代价估计，g(n) 是在状态空间中从初始状态到状态 n 的实际代价，
h(n) 是从状态n到目标状态的最佳路径的估计代价。（对于路径搜索问题，状态就是图中的节点，代价就是距离）
h(n)的选取
保证找到最短路径（最优解的）条件，关键在于估价函数f(n)的选取（或者说h(n)的选取）。
我们以d(n)表达状态n到目标状态的距离，那么h(n)的选取大致有如下三种情况：
①如果h(n)< d(n)到目标状态的实际距离，这种情况下，搜索的点数多，搜索范围大，效率低。但能得到最优解。
②如果h(n)=d(n)，即距离估计h(n)等于最短距离，那么搜索将严格沿着最短路径进行， 此时的搜索效率是最高的。
③如果 h(n)>d(n)，搜索的点数少，搜索范围小，效率高，但不能保证得到最优解。
3.迷宫由一个一个格子组成，要求从入口到出口只有一条路径。
想了一下各种数据结构，树是比较合适的，从根节点到每一个子节点都只有一条路径。
假设入口是根节点，出口是树中某个子节点，那么，从根节点到该子节点的路径就是唯一的。
所以如果能构造一棵树把所有的格子都覆盖到，也就能够做出一个迷宫了。
另外还要求树的父节点和子节点必须是界面上相邻的格子。在界面显示时，父节点和子节点之间共用的边不画，其他的边都画出来，就能画出一个迷宫。
4.可以用二维数组表示迷宫的格子。每个数组元素存储一个指向父节点的引用，这样也可以形成一个虚拟的树。
5.树的构造：为了可以使迷宫的形状能够随机，我选择随机生成一个坐标作为根节点。
综合考量，我决定通过深度优先搜索的方法增加节点(项目量小速度快)：随机选择一个格子作为根节点，从它开始随机地深度搜索前进，开出一条路来，直到无路可走了，退回一步，换另一条路，
再走到无路可走，回退一步，换另一条……如此循环往复，直到完全无路可走。
涉及知识
深度优先搜索的描述与应用，栈 Stack（其实可以用双端队列 Deque，Stack的完美派生物，虽然在大型项目里不太实用）
Java继承类与接口技术，Java swing 框架，Java swing 图形界面布局；
Java事件执行按钮，Java 虚拟键码 KeyEvent 等。
具体步骤
1. 学习了解程序需要调用的包：javax.swing，java.awt，java.util 等。
import java.awt.Color;
import java.awt.Graphics;
import java.awt.event.KeyAdapter;
import java.awt.event.KeyEvent;
import java.util.Random;
import java.util.Stack;
import javax.swing.JFrame;
import javax.swing.JOptionPane;
import javax.swing.JPanel;
2.定义数组元素存储类，将 get() 和 set() 方法放在里面。
class Grid {
static final int INTREE = 1;
static final int NOTINTREE = 0;
private int x = -1;
private int y = -1;
private int flag = NOTINTREE;
private Grid father = null;
public Grid(int xx, int yy) {
x = xx;
y = yy;
}
public int getX() {
return x;
}
public int getY() {
return y;
}
public int getFlag() {
return flag;
}
public Grid getFather() {
return father;
}
public void setFather(Grid f) {
father = f;
}
public void setFlag(int f) {
flag = f;
}
public String toString() {
return new String("(" + x + "," + y + ")\n");
}
}
3.获取键值与参数对应，和贪吃蛇类似，为后面树的相关操作做准备。同时要考虑到边界问题。
synchronized private void move(int c) {
int tx = ballX, ty = ballY;
// System.out.println(c);
switch (c) {
case KeyEvent.VK_LEFT :
ty--;
break;
case KeyEvent.VK_RIGHT :
ty++;
break;
case KeyEvent.VK_UP :
tx--;
break;
case KeyEvent.VK_DOWN :
tx++;
break;
case KeyEvent.VK_SPACE :
if (drawPath == true) {
drawPath = false;
} else {
drawPath = true;
}
break;
default :
}
if (!isOutOfBorder(tx, ty)
&& (maze[tx][ty].getFather() == maze[ballX][ballY]
|| maze[ballX][ballY].getFather() == maze[tx][ty])) {
ballX = tx;
ballY = ty;
}
}
4.迷宫的生成，基于深度优先搜索。
private void createMaze() {
Random random = new Random();
int rx = Math.abs(random.nextInt()) % NUM;
int ry = Math.abs(random.nextInt()) % NUM;
Stack<Grid> s = new Stack<Grid>();
Grid p = maze[rx][ry];
Grid neis[] = null;
s.push(p);
while (!s.isEmpty()) {
p = s.pop();
p.setFlag(Grid.INTREE);
neis = getNeis(p);
int ran = Math.abs(random.nextInt()) % 4;
for (int a = 0; a <= 3; a++) {
ran++;
ran %= 4;
if (neis[ran] == null || neis[ran].getFlag() == Grid.INTREE)
continue;
s.push(neis[ran]);
neis[ran].setFather(p);
}
}
// changeFather(maze[0][0],null);
}
5.完整源码。
import java.awt.Color;
import java.awt.Graphics;
import java.awt.event.KeyAdapter;
import java.awt.event.KeyEvent;
import java.util.Random;
import java.util.Stack;
import javax.swing.JFrame;
import javax.swing.JOptionPane;
import javax.swing.JPanel;
class Grid {
static final int INTREE = 1;
static final int NOTINTREE = 0;
private int x = -1;
private int y = -1;
private int flag = NOTINTREE;
private Grid father = null;
public Grid(int xx, int yy) {
x = xx;
y = yy;
}
//get()和set()方法
public int getX() {
return x;
}
public int getY() {
return y;
}
public int getFlag() {
return flag;
}
public Grid getFather() {
return father;
}
public void setFather(Grid f) {
father = f;
}
public void setFlag(int f) {
flag = f;
}
public String toString() {
return new String("(" + x + "," + y + ")\n"); //返回字符串坐标(x,y)
}
}
public class Labyrinth extends JPanel {
private static final long serialVersionUID = 1L; //定义程序初始化序列
private int NUM, width, padding; //width存储每个格子的宽度和高度
private Grid[][] maze; //迷宫的格子数
private int ballX, ballY; //小球的坐标参数
private boolean drawPath = false;
Labyrinth(int m, int wi, int p) {
NUM = m;
width = wi;
padding = p;
maze = new Grid[NUM][NUM];
for (int i = 0; i <= NUM - 1; i++)
for (int j = 0; j <= NUM - 1; j++)
maze[i][j] = new Grid(i, j); //初始化maze
createMaze(); //调用createMaze()方法
setKeyListener();
this.setFocusable(true);
}
private void init() {
for (int i = 0; i <= NUM - 1; i++)
for (int j = 0; j <= NUM - 1; j++) {
maze[i][j].setFather(null);
//每一个数组元素中有一个指向父节点的引用
maze[i][j].setFlag(Grid.NOTINTREE);
}
ballX = 0;
ballY = 0;
drawPath = false;
createMaze();
// setKeyListener();
this.setFocusable(true);
repaint();
}
//小球从中心到以wi为半径的范围，作为小球的位置
public int getCenterX(int x) {
return padding + x * width + width / 2;
}
public int getCenterY(int y) {
return padding + y * width + width / 2;
}
//重载getCenter()方法，设置网格的位置
public int getCenterX(Grid p) {
return padding + p.getY() * width + width / 2;
}
public int getCenterY(Grid p) {
return padding + p.getX() * width + width / 2;
}
//到达界面最右下角作为通过迷宫的判断条件
private void checkIsWin() {
if (ballX == NUM - 1 && ballY == NUM - 1) {
JOptionPane.showMessageDialog(null, "YOU WIN !", "你走出了迷宫。",
JOptionPane.PLAIN_MESSAGE);
init();
}
}
synchronized private void move(int c) {
int tx = ballX, ty = ballY;
//参数与键值对应
switch (c) {
case KeyEvent.VK_LEFT :
ty--;
break;
case KeyEvent.VK_RIGHT :
ty++;
break;
case KeyEvent.VK_UP :
tx--;
break;
case KeyEvent.VK_DOWN :
tx++;
break;
case KeyEvent.VK_SPACE : //显示/隐藏解谜路径
if (drawPath == true) {
drawPath = false;
} else {
drawPath = true;
}
break;
default :
}
//实现移动操作的同步
if (!isOutOfBorder(tx, ty)
&& (maze[tx][ty].getFather() == maze[ballX][ballY]
|| maze[ballX][ballY].getFather() == maze[tx][ty])) {
ballX = tx;
ballY = ty;
}
}
//获取键盘事件，设置按钮
private void setKeyListener() {
this.addKeyListener(new KeyAdapter() {
public void keyPressed(KeyEvent e) {
int c = e.getKeyCode();
move(c);
repaint();
checkIsWin();
}
});
}
//防止出界
private boolean isOutOfBorder(Grid p) {
return isOutOfBorder(p.getX(), p.getY());
}
private boolean isOutOfBorder(int x, int y) {
return (x > NUM - 1 || y > NUM - 1 || x < 0 || y < 0) ? true : false;
}
private Grid[] getNeis(Grid p) {
final int[] adds = {-1, 0, 1, 0, -1}; //顺序为上右下左
if (isOutOfBorder(p)) {
return null;
}
Grid[] ps = new Grid[4]; //顺序为上右下左
int xt;
int yt;
for (int i = 0; i <= 3; i++) {
xt = p.getX() + adds[i];
yt = p.getY() + adds[i + 1];
if (isOutOfBorder(xt, yt))
continue;
ps[i] = maze[xt][yt];
}
return ps;
}
//通过深度优先搜索算法画出迷宫
private void createMaze() {
Random random = new Random();
int rx = Math.abs(random.nextInt()) % NUM;
int ry = Math.abs(random.nextInt()) % NUM;
Stack<Grid> s = new Stack<Grid>();
Grid p = maze[rx][ry];
Grid neis[] = null;
s.push(p);
while (!s.isEmpty()) {
p = s.pop();
p.setFlag(Grid.INTREE);
neis = getNeis(p);
int ran = Math.abs(random.nextInt()) % 4;
for (int a = 0; a <= 3; a++) {
ran++;
ran %= 4;
if (neis[ran] == null || neis[ran].getFlag() == Grid.INTREE)
continue;
s.push(neis[ran]);
neis[ran].setFather(p);
}
}
}
//父节点向前搜索，没有元素就把当前位置设为新节点，否则将有元素的点变为父节点
@SuppressWarnings("unused")
private void changeFather(Grid p, Grid f) {
if (p.getFather() == null) {
p.setFather(f);
return;
} else {
changeFather(p.getFather(), p);
}
}
//画出非树部分的线，即迷宫障碍物
private void clearFence(int i, int j, int fx, int fy, Graphics g) {
int sx = padding + ((j > fy ? j : fy) * width),
sy = padding + ((i > fx ? i : fx) * width),
dx = (i == fx ? sx : sx + width),
dy = (i == fx ? sy + width : sy);
if (sx != dx) {
sx++;
dx--;
} else {
sy++;
dy--;
}
g.drawLine(sx, sy, dx, dy);
}
//画出节点纵向的小线段
protected void paintComponent(Graphics g) {
super.paintComponent(g); //嵌套调用
for (int i = 0; i <= NUM; i++) {
g.drawLine(padding + i * width, padding, padding + i * width,
padding + NUM * width);
}
for (int j = 0; j <= NUM; j++) {
g.drawLine(padding, padding + j * width, padding + NUM * width,
padding + j * width);
}
//设置背景色
g.setColor(this.getBackground());
for (int i = NUM - 1; i >= 0; i--) {
for (int j = NUM - 1; j >= 0; j--) {
Grid f = maze[i][j].getFather();
if (f != null) {
int fx = f.getX(), fy = f.getY();
clearFence(i, j, fx, fy, g);
}
}
}
g.drawLine(padding, padding + 1, padding, padding + width - 1);
int last = padding + NUM * width;
g.drawLine(last, last - 1, last, last - width + 1);
g.setColor(Color.RED);
g.fillOval(getCenterX(ballY) - width / 3, getCenterY(ballX) - width / 3,
width / 2, width / 2);
if (drawPath == true)
drawPath(g);
}
//画出正确路径
private void drawPath(Graphics g) {
Color PATH_COLOR = Color.ORANGE,BOTH_PATH_COLOR = Color.PINK;
if (drawPath == true)
g.setColor(PATH_COLOR);
else
g.setColor(this.getBackground());
Grid p = maze[NUM - 1][NUM - 1];
while (p.getFather() != null) {
p.setFlag(2);
p = p.getFather();
}
g.fillOval(getCenterX(p) - width / 3, getCenterY(p) - width / 3,
width / 2, width / 2);
p = maze[0][0];
while (p.getFather() != null) {
if (p.getFlag() == 2) {
p.setFlag(3);
g.setColor(BOTH_PATH_COLOR);
}
g.drawLine(getCenterX(p), getCenterY(p), getCenterX(p.getFather()),
getCenterY(p.getFather()));
p = p.getFather();
}
g.setColor(PATH_COLOR);
p = maze[NUM - 1][NUM - 1];
while (p.getFather() != null) {
if (p.getFlag() == 3)
break;
g.drawLine(getCenterX(p), getCenterY(p), getCenterX(p.getFather()),
getCenterY(p.getFather()));
p = p.getFather();
}
}
public static void main(String[] args) {
//初始化参数，基本布局（位置、大小等），其中n为迷宫的阶数
final int n = 20, width = 500, padding = 20, LX = 200, LY = 100;
JPanel p = new Labyrinth(n, (width - padding - padding) / n, padding);
JFrame frame = new JFrame("Labyrinth(按空格键显示或隐藏路径)");
frame.getContentPane().add(p);
//默认的开关事件按钮
frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
frame.setSize(width + padding, width + padding + padding);
frame.setLocation(LX, LY);
frame.setVisible(true);
}
}
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
