Java編寫迷宮小游戲。本站提示廣大學習愛好者：（Java編寫迷宮小游戲）文章只能為提供參考，不一定能成為您想要的結果。以下是Java編寫迷宮小游戲正文
緣起：
客歲（年夜三上學期）比擬愛好寫小游戲，因而想試著寫個迷宮試一下。
法式後果：
按下空格顯示途徑：
思慮進程：
迷宮由一個一個格子構成，請求從進口到出口只要一條途徑.
想了一下各類數據構造，仿佛樹是比擬適合的，從根節點到每個子節點都只要一條途徑。假定進口是根節點，出口是樹中某個子節點，那末，從根節點到該子節點的途徑確定是獨一的。
所以假如能結構一棵樹把一切的格子都籠罩到，也就可以夠做出一個迷宮了。
別的還請求樹的父節點和子節點必需是界面上相鄰的格子。
在界面顯示時，父節點和子節點之間共用的邊不畫，其他的邊都畫出來，就可以畫出一個迷宮。
以後就是想一下該怎樣完成如許一棵樹。
重要的兩個成績：
1、樹怎樣表現？
2、怎樣結構這棵樹？
1.樹怎樣表現？
假定像寫二叉樹一樣完成這棵樹，那末每一個樹節點裡就要存儲一個坐標（X,Y）表現一個格子，別的還要存儲四個指針。指針中有的為空，有的不為空，不為空的指針指向子節點，子節點保留鄰人格子的坐標。如許做最年夜的成績是沒法剖斷能否一切的格子都在樹中。或許還要用一個二維數組作標記數組。
假設用二維數組表現迷宮的格子。每一個數組元素存儲一個指向父節點的援用，如許也能夠構成一個虛擬的樹。因而就用一個N*N的二維數組，表現N*N個格子，每一個數組元素(Lattice)中有一個指向父節點的援用(father)。別的，為了能便利的獲得格子的坐標，還要保留坐標信息。
2.怎樣結構這棵樹？
起首選定一個格子作為根節點。為了讓迷宮的外形夠隨機，我選擇隨機生成一個坐標作為根節點。其實，選擇肯定的一個坐標也能夠。
然後，如何往這棵樹上增長節點呢？
在這裡我走了很多彎路，一開端想的是一種如今看來相似回溯的算法（其時還不曉得回溯算法。。），然則時光龐雜度很高，年夜概當迷宮為64*64的時刻，算法就不出成果了。
然後，又應用了一種掃深度搜刮也是回溯描的辦法，每次掃描在以後樹中找一個節點，看它的鄰人格子能否在樹中，假如還沒在樹中，就將該鄰人格子參加樹中，假如已在樹中，就看下一個鄰人格子，假如該節點一切鄰人格子都在樹中了，就找下一個節點，持續異樣的操作。別的為了讓迷宮生成的隨機，掃描的肇端地位是隨機的便可以了。然則，該辦法生成的迷宮中的途徑老是不敷深，沒有我想要的彎曲深刻的後果。究竟是相似廣度搜刮的辦法。並且，如許做總還像是靠蠻力，算法不敷聰慧簡練。
最初，我終究想到應用深度搜刮。。年夜概是由於數據構造曾經學過了一年，又沒太練，忘了很多，所以一向沒想到這個應當第一想到的辦法。。
隨機選擇一個格子作為根節點，從它開端隨機地深度搜刮進步，開出一條路來，直到無路可走了，退回一步，換另外一條路，再走到無路可走，回退一步，換另外一條……如斯輪回來去，直到完整無路可走。。。其實也照樣回溯。
在法式裡就是以下進程（詳見代碼中的createMaze()函數）：
隨機選擇一個格子作為根節點，將它壓進棧裡。
然後在棧不為空的時刻履行以下輪回：
掏出一個格子，將它的INTREE標記設置為1，然後將它的一切不在樹中的鄰人格子壓進棧裡（次序隨機），而且讓這些鄰人格子的father指向該格子。
處理了這兩個成績，其他的畫迷宮、顯示途徑、小球挪動也就比擬簡略了。
代碼
package maze;
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 Lattice {
static final int INTREE = 1;
static final int NOTINTREE = 0;
private int x = -1;
private int y = -1;
private int flag = NOTINTREE;
private Lattice father = null;
public Lattice(int xx, int yy) {
x = xx;
y = yy;
}
public int getX() {
return x;
}
public int getY() {
return y;
}
public int getFlag() {
return flag;
}
public Lattice getFather() {
return father;
}
public void setFather(Lattice f) {
father = f;
}
public void setFlag(int f) {
flag = f;
}
public String toString() {
return new String("(" + x + "," + y + ")\n");
}
}
public class Maze extends JPanel {
private static final long serialVersionUID = -8300339045454852626L;
private int NUM, width, padding;// width 每一個格子的寬度和高度
private Lattice[][] maze;
private int ballX, ballY;
private boolean drawPath = false;
Maze(int m, int wi, int p) {
NUM = m;
width = wi;
padding = p;
maze = new Lattice[NUM][NUM];
for (int i = 0; i <= NUM - 1; i++)
for (int j = 0; j <= NUM - 1; j++)
maze[i][j] = new Lattice(i, j);
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(Lattice.NOTINTREE);
}
ballX = 0;
ballY = 0;
drawPath = false;
createMaze();
// setKeyListener();
this.setFocusable(true);
repaint();
}
public int getCenterX(int x) {
return padding + x * width + width / 2;
}
public int getCenterY(int y) {
return padding + y * width + width / 2;
}
public int getCenterX(Lattice p) {
return padding + p.getY() * width + width / 2;
}
public int getCenterY(Lattice 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;
// 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;
}
}
private void setKeyListener() {
this.addKeyListener(new KeyAdapter() {
public void keyPressed(KeyEvent e) {
int c = e.getKeyCode();
move(c);
repaint();
checkIsWin();
}
});
}
private boolean isOutOfBorder(Lattice 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 Lattice[] getNeis(Lattice p) {
final int[] adds = {-1, 0, 1, 0, -1};// 次序為上右下左
if (isOutOfBorder(p)) {
return null;
}
Lattice[] ps = new Lattice[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<Lattice> s = new Stack<Lattice>();
Lattice p = maze[rx][ry];
Lattice neis[] = null;
s.push(p);
while (!s.isEmpty()) {
p = s.pop();
p.setFlag(Lattice.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() == Lattice.INTREE)
continue;
s.push(neis[ran]);
neis[ran].setFather(p);
}
}
// changeFather(maze[0][0],null);
}
private void changeFather(Lattice p, Lattice 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--) {
Lattice 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());
Lattice 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) {
final int n = 30, width = 600, padding = 20, LX = 200, LY = 100;
JPanel p = new Maze(n, (width - padding - padding) / n, padding);
JFrame frame = new JFrame("MAZE(按空格鍵顯示或隱蔽途徑)");
frame.getContentPane().add(p);
frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
frame.setSize(width + padding, width + padding + padding);
frame.setLocation(LX, LY);
frame.setVisible(true);
}
}
