欢迎您访问 最编程 本站为您分享编程语言代码，编程技术文章！

热门搜索/Hot Search

您现在的位置是： 首页

用 java 编写迷宫 java 迷宫游戏设计报告

最编程 2024-06-29 20:39:14
...


目录

 1.系统简介

1.1设计背景

1.2开发工具及环境

2.系统分析与设计

2.1设计目的

2.2功能需求

2.3系统功能代码设计

2.3.1算法说明

3.系统调试

3.1编写源程序界面

4.设计总结

附录：源代码

1.系统简介

1.1设计背景

迷宫是一个经典的游戏，陪伴了几代人的童年，借此机会，在锻炼自身编程水平的同时还原这一经典游戏。

1.2开发工具及环境

（1）开发工具及介绍
IntelliJ IDEA2021是一款专业的JAVA IDE编程工具，最新版本支持git、svn、github等版本控制工具，并整合了智能代码助手、代码自动提示等功能，软件的强大的静态代码分析和人体工程学设计，能够让用户的开发设计变得简单轻松。同时，它也被认为是当前Java开发效率最快的IDE工具。 
（2）开发环境：window10系统、IntelliJ IDEA2021、JDK17。

2.系统分析与设计

2.1设计目的

随机生成迷宫并且尝试用两种方法生成迷宫和解迷宫，支持玩家走迷宫和系统走迷宫，玩家走迷宫需通过键盘方向键控制；系统走迷宫需要输出走到迷宫出口的最优解。

2.2功能需求

（1）迷宫游戏是非常经典的游戏，在该题中要求随机生成一个迷宫，并求解迷宫；

（2）要求查找并理解迷宫生成的算法，并尝试用两种不同的算法来生成随机的迷宫。

（3）要求迷宫游戏支持玩家走迷宫，和系统走迷宫路径两种模式。玩家走迷宫，通过键盘方向键控制，输出玩家当前位置到迷宫出口的最优路径。设计交互友好的游戏图形界面。

2.3系统功能代码设计

2.3.1算法说明

主要思路是从图中一个未访问的顶点 V 开始，沿着一条路一直走到底，然后从这条路尽头的节点回退到上一个节点，再从另一条路开始走到底...，不断递归重复此过程，直到所有的顶点都遍历完成，它的特点是不撞南墙不回头，先走完一条路，再换一条路继续走。

树是图的一种特例(连通无环的图就是树)，接下来我们来看看树用深度优先遍历该怎么遍历。

1、我们从根节点 1 开始遍历，它相邻的节点有 2，3，4，先遍历节点 2，再遍历 2 的子节点 5，然后再遍历 5 的子节点 9。

2、上图中一条路已经走到底了(9是叶子节点，再无可遍历的节点)，此时就从 9 回退到上一个节点 5，看下节点 5 是否还有除 9 以外的节点，没有继续回退到 2，2 也没有除 5 以外的节点，回退到 1，1 有除 2 以外的节点 3，所以从节点 3 开始进行深度优先遍历，如下：

3、同理从 10 开始往上回溯到 6, 6 没有除 10 以外的子节点，再往上回溯，发现 3 有除 6 以外的子点 7，所以此时会遍历 7。

3、从 7 往上回溯到 3， 1，发现 1 还有节点 4 未遍历，所以此时沿着 4， 8 进行遍历,这样就遍历完成了。

完整的节点的遍历顺序如下(节点上的的蓝色数字代表)：

相信大家看到以上的遍历不难发现这就是树的前序遍历,实际上不管是前序遍历，还是中序遍历，亦或是后序遍历，都属于深度优先遍历。

那么深度优先遍历该怎么实现呢，有递归和非递归两种表现形式，接下来我们以二叉树为例来看下如何分别用递归和非递归来实现深度优先遍历。

递归实现

递归实现比较简单，由于是前序遍历，所以我们依次遍历当前节点，左节点，右节点即可，对于左右节点来说，依次遍历它们的左右节点即可，依此不断递归下去，直到叶节点(递归终止条件)。

3.系统调试

3.1编写源程序界面

用java写迷宫 java迷宫游戏的设计报告_java_06

用java写迷宫 java迷宫游戏的设计报告_递归_07

4.设计总结

迷宫这个项目十分有趣，但也特别的难，我虽然看懂了算法，但 还是无法用于自己的程序当中，在这次实习项目的练习过程中，认识到了自己的不足。代码量太少，再加之这个项目的难度较大，所以还是无法独立完成，在于同学的讨论和上网搜寻下才勉强完成这个项目，在这次软件 实习的过程中，认识到了自己的不足和代码水平，在今后的学习生活 中会加强训练，提升自己的代码水平。

附录：源代码

package 迷宫;

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 final int x; // 格子的位置，在第几行
    private final int y; // 第几列
    private int flag = NotInTree; // flag，标识格子是否已加入树中
    private Lattice father = null; // 格子的父亲节点

    public Lattice(int a, int b) {
        x = a;
        y = b;
    }

    public int getX() {
        return x;
    }

    public int getY() {
        return y;
    }

    public int getFlag() {
        return flag;
    }

    public Lattice getFather() {
        return father;
    }

    public void setFather(Lattice dad) {
        father = dad;
    }

    public void setFlag(int f) {
        flag = f;
    }

    public String toString() {
        return "(" + x + "," + y + ")\n";
    }
}

class Labyrinth extends JPanel {
    private final int num;// num：迷宫大小；
    private final int width;//width：每个格子的宽度和高度
    private final int padding;
    private final Lattice[][] maze;
    private int ball_X, ball_Y; // 球的位置，在第几行第几列格子上
    private boolean drawPath = false; // flag，标识是否画出路径

    Labyrinth(int n, int w, int p) {
        num = n;
        width = w;
        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);
            }
        ball_X = 0;
        ball_Y = 0;
        drawPath = false;
        createMaze();
        // setKeyListener();
        this.setFocusable(true);
        repaint();
    }

    // 由格子的行数，得到格子中心点的像素X座标
    public int getCenterX(int x) {
        return padding + x * width + width / 2;
    }

    // 由格子的列数，得到格子中心点的像素Y座标
    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 (ball_X == num - 1 && ball_Y == num - 1) {
            JOptionPane.showMessageDialog(null, "YOU WIN !", "你走出了迷宫。",
                    JOptionPane.PLAIN_MESSAGE);
            init();
        }
    }

    // 移动小球，c为按键码
    private void move(int c) {
        int tx = ball_X, ty = ball_Y;
        // System.out.println(c);
        switch (c) {
            case KeyEvent.VK_A -> ty--;
            case KeyEvent.VK_D -> ty++;
            case KeyEvent.VK_W -> tx--;
            case KeyEvent.VK_S -> tx++;
            case KeyEvent.VK_SPACE -> drawPath = !drawPath;
            default -> {
            }
        }
        // 若移动后未出界且格子之间有路径，则进行移动，更新小球位置，否则移动非法
        if (!isOutOfBorder(tx, ty)
                && (maze[tx][ty].getFather() == maze[ball_X][ball_Y]
                || maze[ball_X][ball_Y].getFather() == maze[tx][ty])) {
            ball_X = tx;
            ball_Y = 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;
    }

    // 获取格子的邻居格子
    private Lattice[] getNeIs(Lattice p) {
        final int[] adds = {-1, 0, 1, 0, -1};
        if (isOutOfBorder(p)) {
            return null;
        }
        Lattice[] ps = new Lattice[4]; // 四个邻居格子，顺序为上右下左，出界的邻居为null
        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(num-1);
        int ry = Math.abs( num-1);
        // 深度优先遍历
        Stack<Lattice> s = new Stack<>();
        Lattice p = maze[rx][ry];
        Lattice[] NeIs;
        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;
                assert NeIs != null;
                if (NeIs[ran] == null || NeIs[ran].getFlag() == Lattice.InTree)
                    continue;
                s.push(NeIs[ran]);
                NeIs[ran].setFather(p);
            }
        }
    }

    // 抹掉两个格子之间的边
    private void clearFence(int i, int j, int fx, int fy, Graphics g) {
        int sx = padding + ((Math.max(j, fy)) * width),
                sy = padding + ((Math.max(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);
        // 画NUM*NUM条黑线
        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);
        // 画右下角出口
        g.drawLine(padding + num * width, padding + num * width - 1, padding + num * width, padding + num * width - width + 1);
        // 画小球
        g.setColor(Color.BLUE);
        g.fillOval(getCenterX(ball_Y) - (width / 3), getCenterY(ball_X) - (width / 3),
                width / 2, width / 2);
        if (drawPath)
            drawPath(g);
    }

    private void drawPath(Graphics g) {
        Color PATH_COLOR = Color.RED;
        if (drawPath)
            g.setColor(PATH_COLOR);
        else
            g.setColor(this.getBackground());
        Lattice p = maze[num - 1][num - 1];
        while (p.getFather() != null) {
            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() == 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 = 50, width = 500, padding = 15, LX = 300, LY = 40;
        JPanel p = new Labyrinth(n, (width - padding - padding) / n, padding);
        JFrame frame = new JFrame("迷宫");
        frame.getContentPane().add(p);
        frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
        frame.setSize(width + padding, width + padding + padding);
        frame.setLocation(LX, LY);
        frame.setVisible(true);
    }
}

上一篇： 蚂蚁走迷宫

下一篇： [迷宫行走（BFS）]

推荐阅读