精华内容
下载资源
问答
  • java随机生成迷宫(图的深度优先遍历)

    千次阅读 多人点赞 2014-05-28 16:03:56
    最近经常在机房看同学在玩一个走迷宫的游戏,比较有趣,自己也用java写一个实现随机生成迷宫的算法,其实就是一个图的深度优先遍历算法.基本思想就是,迷宫中的每个点都有四面墙,然后呢,  从任意一点开始访问...

    最近经常在机房看同学在玩一个走迷宫的游戏,比较有趣,自己也用java写一个实现随机生成迷宫的算法,其实就是一个图的深度优先遍历算法.基本思想就是,迷宫中的每个点都有四面墙,然后呢, 


    1. 从任意一点开始访问(我的算法中固定是从(0,0)点开始),往四个方向中的随机一个访问(每访问到一个可访问的点,就去掉该点的那个方向的墙),被访问点继续以这种方识向下进行访问。
    2. 对每个被访问的点都被标识为已访问,当一个点对某个方向进行访问时我们首先会判断被访问点是否已被访问,或者触到边界.如果该点四个方向皆已访问或已无法访问,就退回上一个点。上一个点继续这个过程。

     

    这样一次遍历下来,可以确定每个点都被访问过,而且由于每次访问的方向都是随机,这就会形成许多不同遍历情况,同时每两个点之间的路径是唯一,也就形成不同的迷宫,且是起点到终点只有唯一路径,这是由于图的深度遍历算法的特点所决定的。算法的实现上,主要是利用栈,第一次,先把第一个点压进栈里,每访问到一个点,就把该点压进栈里,我们再对栈顶的点进行四个方向的随机访问,访问到新点,又把新点压进去,一旦这个点四个方向都无法访问了,就让该点退栈,再对栈顶的点的四个方向进行访问,以此类推,直到栈里的点都全部退出了,我们的遍历就成功了,这是一个递归的过程,这个算法自然可以用递归的方法来实现,不过这里我这样做,而是手工用一个数组作为栈来实现,呵呵~~说了这么多,也不知道自己要表达的有没表达出来。不过我感觉我的具体代码设计还是写的不好,还有很多地方缺乏完善和优化,权当是算法练习,以下是两个关键类的核心代码,至于表示层的代码就不贴出来了,因为那些都很琐碎。有空时把它完善为一个迷宫游戏,发上来赚资源分,呵呵

     

    下面是效果图:

     

    maze截图 

    迷宫的类:

    //作者:zhongZw 
    //邮箱:zhong317@126.com 
    package cn.zhongZw.model;
    import java.util.ArrayList;
    import java.util.Random;
    public class MazeModel {
        private int width = 0;
        private int height = 0;
        private Random rnd = new Random();
    
        public MazeModel() {
            this.width = 50; //迷宫宽度 
            this.height = 50; //迷宫高度 
        }
        public int getWidth() {
            return width;
        }
        public void setWidth(int width) {
            this.width = width;
        }
        public int getHeight() {
            return height;
        }
        public void setHeight(int height) {
            this.height = height;
        }
        public MazeModel(int width, int height) {
            super();
            this.width = width;
            this.height = height;
        }
        public ArrayList < MazePoint > getMaze() {
            ArrayList < MazePoint > maze = new ArrayList < MazePoint > ();
            for (int h = 0; h < height; h++) {
                for (int w = 0; w < width; w++) {
                    MazePoint point = new MazePoint(w, h);
                    maze.add(point);
                }
            }
            return CreateMaze(maze);
        }
        private ArrayList < MazePoint > CreateMaze(ArrayList < MazePoint > maze) {
            int top = 0;
            int x = 0;
            int y = 0;
            ArrayList < MazePoint > team = new ArrayList < MazePoint > ();
            team.add(maze.get(x + y * width));
            while (top >= 0) {
                int[] val = new int[] {
                    -1, -1, -1, -1
                };
                int times = 0;
                boolean flag = false;
                MazePoint pt = (MazePoint) team.get(top);
                x = pt.getX();
                y = pt.getY();
                pt.visted = true;
    
                ro1: while (times < 4) {
                    int dir = rnd.nextInt(4);
                    if (val[dir] == dir)
                        continue;
                    else
                        val[dir] = dir;
    
    
    
    
                    switch (dir) {
                    case 0: // 左边 
                        if ((x - 1) >= 0 && maze.get(x - 1 + y * width).visted == false) {
                            maze.get(x + y * width).setLeft();
                            maze.get(x - 1 + y * width).setRight();
                            team.add(maze.get(x - 1 + y * width));
                            top++;
                            flag = true;
                            break ro1;
    
                        }
                        break;
                    case 1: // 右边 
                        if ((x + 1) < width && maze.get(x + 1 + y * width).visted == false) {
    
                            maze.get(x + y * width).setRight();
                            maze.get(x + 1 + y * width).setLeft();
                            team.add(maze.get(x + 1 + y * width));
                            top++;
                            flag = true;
                            break ro1;
                        }
                        break;
                    case 2: // 上边 
                        if ((y - 1) >= 0 && maze.get(x + (y - 1) * width).visted == false) {
                            maze.get(x + y * width).setUp();
                            maze.get(x + (y - 1) * width).setDown();
                            team.add(maze.get(x + (y - 1) * width));
                            top++;
                            flag = true;
                            break ro1;
                        }
                        break;
                    case 3: // 下边 
                        if ((y + 1) < height && maze.get(x + (y + 1) * width).visted == false) {
                            maze.get(x + y * width).setDown();
                            maze.get(x + (y + 1) * width).setUp();
                            team.add(maze.get(x + (y + 1) * width));
                            top++;
                            flag = true;
                            break ro1;
                        }
                        break;
                    }
                    times += 1;
                }
                if (!flag) {
                    team.remove(top);
                    top -= 1;
                }
    
            }
    
            return maze;
        }
    }
    迷宫

    //作者:zhongZw 
    //邮箱:zhong317@126.com 
    package cn.zhongZw.model;
    import java.util.*;
    import java.lang.*;
    public class MazePoint {
        private int left = 0;
        private int right = 0;
        private int up = 0;
        private int down = 0;
        private int x;
        private int y;
        public boolean visted;
        public MazePoint(int x, int y) {
            this.x = x;
            this.y = y;
        }
        public int getLeft() {
            return left;
        }
    
        public void setLeft() {
            this.left = 1;
        }
        public int getRight() {
            return right;
        }
        public void setRight() {
            this.right = 1;
        }
        public int getUp() {
            return up;
        }
    
        public void setUp() {
            this.up = 1;
        }
        public int getDown() {
            return down;
        }
    
        public void setDown() {
            this.down = 1;
        }
        public int getX() {
            return x;
        }
        public void setX(int x) {
            this.x = x;
        }
        public int getY() {
            return y;
        }
        public void setY(int y) {
            this.y = y;
        }
    
    
    }


    展开全文
  • 使用二维数组随机生成迷宫,里面总共有三份代码,都是迷宫生成的,相信有一份是适合你的。直接运行main方法就可运行,简单方便。
  • 一个Java小游戏,随机生成迷宫地图,可以人机交互
  • 主要为大家详细介绍了java图的深度优先遍历实现随机生成迷宫,具有一定的参考价值,感兴趣的小伙伴们可以参考一下
  • 该资源为迷宫随机生成程序,用Eclipse平台开发的,采用了深度优先遍历算法。迷宫行数列数在界面输入;入口为定点(左上角);有两个出口,在右边界和下边界随机选择。
  • java实现随机迷宫生成、走迷宫小游戏的完整代码,初始化迷宫生成,按下空格为系统提示,上下左右控制移动。本实例需要从 .txt 文件中读取迷宫并绘制。 本程序适用于java程序员巩固类与对象、文件读取、事件响应、...
  • Maze 此项目已打包为 exe 文件,电脑有 gre 即可下载运行 ... // 启动迷宫游戏 new Figure().init(); } } 保存迷宫每一个格子的信息 package MyMaze; /** * 本类保存迷宫中每一个格子的信息 *

    Maze

    此项目已打包为 exe 文件,电脑有 gre 即可下载运行 download
    先看效果图
    在这里插入图片描述
    在这里插入图片描述

    直接上代码啦

    • 启动游戏单独成类
    package MyMaze;
    
    public class Maze {
    
        public static void main(String[] args) {
            // 启动迷宫游戏
            new Figure().init();
        }
    }
    
    • 保存迷宫每一个格子的信息
    package MyMaze;
    
    /**
     * 本类保存迷宫中每一个格子的信息
     */
    
    public class Place {
        //定义当前格子是否可走,若 wall → 0,则表示可走,若 wall → 1,则表示不可走
        private int wall;
        //表示当前格子是否被搜索过
        private boolean search = false;
        //表示当前格子的四个方向分别是哪些格子,搜索时的上一个格子。
        private Place east = null, south = null, west = null, north = null, last = null;
        //保存迷宫格子位置索引
        private int index = 0;
    
        public Place(int wall) {
            this.wall = wall;
        }
    
        public int getWall() {
            return wall;
        }
    
        public void setWall(int wall) {
            this.wall = wall;
        }
    
        public boolean isSearch() {
            return search;
        }
    
        public void setSearch(boolean search) {
            this.search = search;
        }
    
        public Place getEast() {
            return east;
        }
    
        public void setEast(Place east) {
            this.east = east;
        }
    
        public Place getSouth() {
            return south;
        }
    
        public void setSouth(Place south) {
            this.south = south;
        }
    
        public Place getWest() {
            return west;
        }
    
        public void setWest(Place west) {
            this.west = west;
        }
    
        public Place getNorth() {
            return north;
        }
    
        public void setNorth(Place north) {
            this.north = north;
        }
    
        public Place getLast() {
            return last;
        }
    
        public void setLast(Place last) {
            this.last = last;
        }
    
        public int getIndex() {
            return index;
        }
    
        public void setIndex(int index) {
            this.index = index;
        }
    
    }
    
    • 创建迷宫
    package MyMaze;
    
    /**
     * 创建迷宫及提供迷宫的一些参数
     */
    public class CreateMaze {
        // 定义迷宫规模
        private int size;
        // 定义迷宫的入口和出口
        private int entrance, exit;
        // 用一维数组表示迷宫,0 号下标位置空出
        private Place[] maze = null;
    
        // 设置迷宫中每一个格子下一步能移动的方向
        private void setDirections(Place[] maze) {
            for (int i = 1; i <= size * size; i++) {
                if (i % size != 0 && maze[i + 1].getWall() == 0 && maze[i + 1] != null) {
                    maze[i].setEast(maze[i + 1]);
                }
                if (i <= size * (size - 1) && maze[i + size].getWall() == 0 && maze[i + size] != null) {
                    maze[i].setSouth(maze[i + size]);
                }
                if (i % size != 1 && maze[i - 1].getWall() == 0 && maze[i - 1] != null) {
                    maze[i].setWest(maze[i - 1]);
                }
                if (i > size && maze[i - size].getWall() == 0 && maze[i - size] != null) {
                    maze[i].setNorth(maze[i - size]);
                }
            }
        }
        // 设置默认迷宫参数
        public CreateMaze() {
            this.size = 10;
            this.entrance = 1;
            this.exit = this.size * this.size;
        }
        // 调用有参构造函数获取新迷宫大小及入口和出口
        public CreateMaze(int size, int entrance, int exit) {
            this.size = size;
            this.entrance = entrance;
            this.exit = exit;
        }
        // 返回当前迷宫格随机状态
        public Place[] getMaze() {
            maze = new Place[size * size + 1];
            for (int i = 1; i <= size * size; i++) {
                maze[i] = new Place((int) (Math.random() * 2));
                maze[i].setIndex(i);        // 设为 0 或 1
            }
            setDirections(maze);
            return maze;
        }
        // 返回入口索引
        public int getEntrance() {
            return entrance;
        }
        // 设置入口索引
        public void setEntrance(int entrance) {
            this.entrance = entrance;
        }
        // 返回出口索引
        public int getExit() {
            return exit;
        }
        // 设置出口索引
        public void setExit(int exit) {
            this.exit = exit;
        }
        // 返回迷宫大小 size 表示边长
        public int getSize() {
            return size;
        }
        // 设置迷宫边长
        public void setSize(int size) {
            this.size = size;
        }
    
    }
    
    • 对迷宫路径进行搜索
    package MyMaze;
    
    /**
     * 迷宫游戏
     * 本类中对迷宫进行路径搜索,保存合格迷宫的相关信息(合格迷宫只有1条路径)
     */
    public class Path {
        //调用创建迷宫类
        CreateMaze newMaze;
        //保存迷宫路径
        boolean[] path;
        //保存合格迷宫
        Place[] maze = null;
        // 入口位置索引
        int entrance;
        // 出口位置索引
        int exit;
    
        private int searchPathNumber() {
            // 获取当前格状态
            maze = newMaze.getMaze();
            // 定义路径数
            int pathAll = 0;
            // 保存当前路径
            Place[][] path = new Place[maze.length][];
            for (int i = 1; i < path.length; i++) {
                path[i] = new Place[5];
            }
            // 当前格子路径数组下标
            int pathTop = 0;
            // 当前位置的下一位置的可能数下标
            int[] top = new int[maze.length];
            for (int i = 1; i < top.length; i++) {
                top[i] = -1;
            }
            //寻找迷宫路径数
            if (maze[entrance].getWall() == 0) {
                pathTop++;
                top[pathTop]++;
                path[pathTop][top[pathTop]] = maze[entrance];
                while (pathTop > 0) {
                    //判断当前位置是否为结束位置,是,保存迷宫路径,退回上一位置,否,寻找下一不重复位置
                    if (path[pathTop][0] == maze[exit]) {
                        pathAll++;
                        top[pathTop]--;
                        pathTop--;
                    } else if (!path[pathTop][top[0]].isSearch()) {
                        //寻找当前位置的下一位置的可能数
                        if (path[pathTop][0].getEast() != null && path[pathTop][0].getEast() != path[pathTop][0].getLast() && !path[pathTop][0].getEast().isSearch()) {
                            path[pathTop][++top[pathTop]] = path[pathTop][0].getEast();
                        }
                        if (path[pathTop][0].getSouth() != null && path[pathTop][0].getSouth() != path[pathTop][0].getLast() && !path[pathTop][0].getSouth().isSearch()) {
                            path[pathTop][++top[pathTop]] = path[pathTop][0].getSouth();
                        }
                        if (path[pathTop][0].getWest() != null && path[pathTop][0].getWest() != path[pathTop][0].getLast() && !path[pathTop][0].getWest().isSearch()) {
                            path[pathTop][++top[pathTop]] = path[pathTop][0].getWest();
                        }
                        if (path[pathTop][0].getNorth() != null && path[pathTop][0].getNorth() != path[pathTop][0].getLast() && !path[pathTop][0].getNorth().isSearch()) {
                            path[pathTop][++top[pathTop]] = path[pathTop][0].getNorth();
                        }
                        path[pathTop][0].setSearch(true);
                    }
                    //当前位置的下一位置的所有可能依次查询,无下一位置则回退到上一位置
                    if (top[pathTop] == 0) {
                        path[pathTop][0].setLast(null);
                        path[pathTop][0].setSearch(false);
                        top[pathTop]--;
                        pathTop--;
                    }
                    else {
                        pathTop++;
                        top[pathTop]++;
                        path[pathTop][0] = path[pathTop - 1][top[pathTop - 1]--];
                        path[pathTop][0].setLast(path[pathTop - 1][0]);
                    }
                }
            }
            return pathAll;
        }
        // 设置路径
        private void setPath() {
            // 保存当前路径
            Place[][] path = new Place[maze.length][];
            for (int i = 1; i < path.length; i++) {
                path[i] = new Place[5];
            }
            // 当前路径数组下标
            int pathTop = 0;
            // 当前位置的下一位置的可能数下标
            int[] top = new int[maze.length];
            for (int i = 1; i < top.length; i++) {
                top[i] = -1;
            }
            //寻找迷宫路径数
            if (maze[entrance].getWall() == 0) {
                pathTop++;
                top[pathTop]++;
                path[pathTop][top[pathTop]] = maze[entrance];
                while (pathTop > 0) {
                    //判断当前位置是否为结束位置,是,保存迷宫路径,退回上一位置,否,寻找下一不重复位置
                    if (path[pathTop][0] == maze[exit]) {
                        for (int i = 1; i <= pathTop; i++) {
                            this.path[path[i][0].getIndex()] = true;
                        }
                        top[pathTop]--;
                        pathTop--;
                        break;
                    } else if (!path[pathTop][top[0]].isSearch()) {
                        //寻找当前位置的下一位置的可能数
                        if (path[pathTop][0].getEast() != null && path[pathTop][0].getEast() != path[pathTop][0].getLast() && !path[pathTop][0].getEast().isSearch()) {
                            path[pathTop][++top[pathTop]] = path[pathTop][0].getEast();
                        }
                        if (path[pathTop][0].getSouth() != null && path[pathTop][0].getSouth() != path[pathTop][0].getLast() && !path[pathTop][0].getSouth().isSearch()) {
                            path[pathTop][++top[pathTop]] = path[pathTop][0].getSouth();
                        }
                        if (path[pathTop][0].getWest() != null && path[pathTop][0].getWest() != path[pathTop][0].getLast() && !path[pathTop][0].getWest().isSearch()) {
                            path[pathTop][++top[pathTop]] = path[pathTop][0].getWest();
                        }
                        if (path[pathTop][0].getNorth() != null && path[pathTop][0].getNorth() != path[pathTop][0].getLast() && !path[pathTop][0].getNorth().isSearch()) {
                            path[pathTop][++top[pathTop]] = path[pathTop][0].getNorth();
                        }
                        path[pathTop][0].setSearch(true);
                    }
                    //当前位置的下一位置的所有可能依次查询,无下一位置则回退到上一位置
                    if (top[pathTop] == 0) {
                        path[pathTop][0].setLast(null);
                        path[pathTop][0].setSearch(false);
                        top[pathTop]--;
                        pathTop--;
                    } else {
                        pathTop++;
                        top[pathTop]++;
                        path[pathTop][0] = path[pathTop - 1][top[pathTop - 1]--];
                        path[pathTop][0].setLast(path[pathTop - 1][0]);
                    }
                }
            }
        }
        // 当路径唯一时,设置路径
        private void searchPath() {
            while (true) {
                if (searchPathNumber() == 1) {
                    setPath();
                    break;
                }
            }
        }
        // 默认构造函数
        public Path() {
            newMaze = new CreateMaze();
            path = new boolean[newMaze.getSize() * newMaze.getSize() + 1];
            this.entrance = newMaze.getEntrance();
            this.exit = newMaze.getExit();
        }
        // 重载构造函数
        public Path(int size, int entrance, int exit) {
            newMaze = new CreateMaze(size, entrance, exit);
            path = new boolean[newMaze.getSize() * newMaze.getSize() + 1];
            this.entrance = newMaze.getEntrance();
            this.exit = newMaze.getExit();
        }
        // 获取当前格子
        public Place[] getMaze() {
            searchPath();
            return maze;
        }
        // 获取新迷宫大小
        public int getSize() {
            return newMaze.getSize();
        }
        // 获取入口
        public int getEntrance() {
            return entrance;
        }
        // 获取出口
        public int getExit() {
            return exit;
        }
        // 返回当前格子为路还是墙
        public boolean[] getPath() {
            return path;
        }
        // 返回迷宫
        public CreateMaze getNewMaze() {
            return newMaze;
        }
    
    }
    
    
    
    • 构建图形界面
    package MyMaze;
    
    import javax.swing.*;
    import java.awt.*;
    import java.awt.event.*;
    
    /*
     * 本类为迷宫游戏提供图形化界面
     */
    public class Figure {
        // 定义路径
        Path path;
        // 定义当前迷宫周围状态
        Place[] maze = null;
        // 用按钮实现迷宫格
        JButton[] button = null;
        boolean[] isPath = null;
    
        // A* 寻路界面  比较遗憾的是只实现了图形化界面,A* 自动寻路并未实现,有机会有能力再更吧
        class FindMaze extends JFrame implements ActionListener {
            public FindMaze() {
                super("A* Maze");
                // 界面大小
                this.setSize(500, 500);
                // 返回默认工具箱
                Toolkit kit = Toolkit.getDefaultToolkit();
                // 获取屏幕尺寸
                Dimension screenSize = kit.getScreenSize();
                // 获取屏幕宽度
                int screenWidth = screenSize.width;
                // 获取屏幕高度
                int screenHeight = screenSize.height;
                // 获取界面窗口宽度
                int windowWidth = this.getWidth();
                // 获取界面窗口高度
                int windowHeight = this.getHeight();
                // 界面居中
                this.setLocation((screenWidth - windowWidth) / 2, (screenHeight - windowHeight) / 2);
                // 四行一列布局
                this.setLayout(new GridLayout(path.getSize(), path.getSize()));
                maze = path.getMaze();
                int entrance = path.getEntrance();
                int exit = path.getExit();
                button = new JButton[maze.length];
                for (int i = 1; i < maze.length; ++i) {
                    // 当前格子是路则设置活动指令为 1,背景颜色为绿色
                    if (maze[i].getWall() == 0) {
                        button[i] = new JButton();
                        button[i].setActionCommand("1");
                        button[i].setBackground(Color.GREEN);
                    }
                    // 当前格子为墙则设置活动指令为 0,标记为灰色
                    if (maze[i].getWall() == 1) {
                        button[i] = new JButton();
                        button[i].setActionCommand("0");
                        button[i].setBackground(Color.LIGHT_GRAY);
                    }
                }
                for (int i = 1; i < button.length; i++) {
                    button[i].addActionListener(this);
                    add(button[i]);
                }
                button[path.getSize() * path.getSize()].setActionCommand("退出");
                button[path.getSize() * path.getSize()].setText("退出");
                button[path.getSize() * path.getSize()].setFont(new Font("宋体", 0, 7));
                addWindowListener(new closeWin());
                this.setVisible(true);
            }
    		// 自动寻路
            public void innit() {
                isPath = path.getPath();
                for (int i = 1; i < isPath.length; i++) {
                    if (isPath[i]) {
                        button[i].setBackground(Color.YELLOW);
                    }
                }
            }
            @Override
            public void actionPerformed(ActionEvent e) {
                if (e.getActionCommand().equals("退出")) {
                    dispose();
                    Figure figure = new Figure();
                    figure.init();
                }
            }
        }
    
        // 启动游戏界面
        class MazeGameFigure extends JFrame implements ActionListener {
            public MazeGameFigure() {
                super("迷宫游戏");
            }
    
            public void init() {
                // 界面大小
                this.setSize(500, 500);
                // 返回默认工具箱
                Toolkit kit = Toolkit.getDefaultToolkit();
                // 获取屏幕尺寸
                Dimension screenSize = kit.getScreenSize();
                // 获取屏幕宽度
                int screenWidth = screenSize.width;
                // 获取屏幕高度
                int screenHeight = screenSize.height;
                // 获取界面窗口宽度
                int windowWidth = this.getWidth();
                // 获取界面窗口高度
                int windowHeight = this.getHeight();
                // 界面居中
                this.setLocation((screenWidth - windowWidth) / 2, (screenHeight - windowHeight) / 2);
                // 四行一列布局
                this.setLayout(new GridLayout(5, 1));
                JLabel welcom = new JLabel("欢迎进入迷宫游戏!");
                welcom.setBackground(Color.CYAN);
                welcom.setFont(new Font("宋体", 1, 25));
                JButton find = new JButton("A* 寻路");
                find.setFont(new Font("宋体", 1, 25));
                JButton start = new JButton("开始游戏");
                start.setFont(new Font("宋体", 1, 25));
                JButton set = new JButton("游戏设置");
                set.setFont(new Font("宋体", 1, 25));
                JButton end = new JButton("退出游戏");
                end.setFont(new Font("宋体", 1, 25));
                find.setBackground(Color.PINK);
                start.setBackground(Color.PINK);
                set.setBackground(Color.PINK);
                end.setBackground(Color.PINK);
                add(welcom);
                add(find);
                add(start);
                add(set);
                add(end);
                find.addActionListener(this);
                start.addActionListener(this);
                set.addActionListener(this);
                end.addActionListener(this);
                addWindowListener(new closeWin());
                this.setVisible(true);
            }
    
            public void actionPerformed(ActionEvent e) {
                if (e.getActionCommand().equals("A* 寻路")) {
                    dispose();
                    new FindMaze().innit();
                }
                // 点击开始游戏生成迷宫
                if (e.getActionCommand().equals("开始游戏")) {
                    MazeFigure mazeFigure = new MazeFigure();
                    mazeFigure.init();
                    dispose();
                }
                // 点击游戏设置进入设置模式
                if (e.getActionCommand().equals("游戏设置")) {
                    MazeSetFigure mazeSetFigure = new MazeSetFigure();
                    mazeSetFigure.init();
                    dispose();
                }
                if (e.getActionCommand().equals("退出游戏")) {
                    dispose();
                }
            }
        }
    
        // 开始游戏界面
        class MazeFigure extends JFrame implements ActionListener {
            public MazeFigure() {
                super("Maze");
            }
    
            public void init() {
                this.setSize(500, 500);
                this.setBackground(Color.BLACK);
                Toolkit kit = Toolkit.getDefaultToolkit();
                Dimension screenSize = kit.getScreenSize();
                int screenWidth = screenSize.width;
                int screenHeight = screenSize.height;
                int windowWidth = this.getWidth();
                int windowHeight = this.getHeight();
                this.setLocation((screenWidth - windowWidth) / 2, (screenHeight - windowHeight) / 2);
                // 获取迷宫尺寸设计按钮布局
                this.setLayout(new GridLayout(path.getSize(), path.getSize()));
                maze = path.getMaze();
                int entrance = path.getEntrance();
                int exit = path.getExit();
                button = new JButton[maze.length];
                for (int i = 1; i < maze.length; i++) {
                    // 当前格子是路则设置活动指令为 1,背景颜色为绿色
                    if (maze[i].getWall() == 0) {
                        button[i] = new JButton();
                        button[i].setActionCommand("1");
                        button[i].setBackground(Color.GREEN);
                    }
                    // 当前格子为墙则设置活动指令为 0,标记为灰色
                    if (maze[i].getWall() == 1) {
                        button[i] = new JButton();
                        button[i].setActionCommand("0");
                        button[i].setBackground(Color.LIGHT_GRAY);
                    }
                }
                button[entrance].setText("入口");
                button[entrance].setFont(new Font("宋体", 1, 7));
                button[exit].setText("出口");
                button[exit].setFont(new Font("宋体", 1, 7));
                // 为每个按钮添加监听器
                for (int i = 1; i < button.length; i++) {
                    button[i].addActionListener(this);
                    add(button[i]);
                }
                addWindowListener(new closeWin());
                this.setVisible(true);
            }
    
            // 判断是否完成通路
            private boolean isComplete() {
                isPath = path.getPath();
                for (int i = 1; i < isPath.length; i++) {
                    if (isPath[i] && button[i].getBackground() != Color.YELLOW) {
                        return false;
                    }
                }
                return true;
            }
    
            public void actionPerformed(ActionEvent e) {
                JButton button = (JButton) e.getSource();
                if (button.getActionCommand().equals("1")) {
                    if (button.getBackground() == Color.GREEN) {
                        button.setBackground(Color.YELLOW);
                    } else if (button.getBackground() == Color.YELLOW) {
                        button.setBackground(Color.GREEN);
                    }
                }
                if (isComplete()) {
                    CongratulationFigure congratulationFigure = new CongratulationFigure();
                    congratulationFigure.init();
                    this.dispose();
                }
            }
        }
    
        // 迷宫设置界面
        class MazeSetFigure extends Frame implements ActionListener, TextListener {
            String newSize, newEntrance, newExit;
            JTextField setMaze, setEntrance, setExit;
            int size, entrance, exit;
    
            public MazeSetFigure() {
                super("迷宫设置");
            }
    
            public void init() {
                this.setSize(500, 400);
                this.setBackground(Color.WHITE);
                Toolkit kit = Toolkit.getDefaultToolkit();
                Dimension screenSize = kit.getScreenSize();
                int screenWidth = screenSize.width;
                int screenHeight = screenSize.height;
                int windowWidth = this.getWidth();
                int windowHeight = this.getHeight();
                this.setLocation((screenWidth - windowWidth) / 2, (screenHeight - windowHeight) / 2);
                GridLayout layout = new GridLayout(5, 2);
                this.setLayout(layout);
                JLabel size = new JLabel("迷宫规模");
                size.setFont(new Font("宋体", 1, 20));
                JLabel entrance = new JLabel("迷宫入口");
                entrance.setFont(new Font("宋体", 1, 20));
                JLabel exit = new JLabel("迷宫出口");
                exit.setFont(new Font("宋体", 1, 20));
                JButton menu = new JButton("返回菜单");
                menu.setFont(new Font("宋体", 1, 20));
                JButton set = new JButton("设置完成");
                set.setFont(new Font("宋体", 1, 20));
                setMaze = new JTextField("10");
                setEntrance = new JTextField("左上角");
                setEntrance.setFont(new Font("宋体", 1, 18));
                setExit = new JTextField("右下角");
                setExit.setFont(new Font("宋体", 1, 18));
                JLabel tip = new JLabel("tips:出入口只能设置为四个角");
                JLabel tips = new JLabel("即左上角,右上角,左下角,右下角");
                add(tip);
                add(tips);
                add(size);
                add(setMaze);
                add(entrance);
                add(setEntrance);
                add(exit);
                add(setExit);
                add(menu);
                add(set);
                menu.addActionListener(this);
                set.addActionListener(this);
                setMaze.addActionListener(this);
                setEntrance.addActionListener(this);
                setExit.addActionListener(this);
                addWindowListener(new closeWin());
                this.setVisible(true);
            }
    
            public void actionPerformed(ActionEvent e) {
                if (e.getActionCommand().equals("返回菜单")) {
                    dispose();
                    Figure figure = new Figure();
                    figure.init();
                }
                if (e.getActionCommand().equals("设置完成")) {
                    boolean isSizeReasonable = true;
                    boolean isEntranceReasonable = true;
                    boolean isExitReasonable = true;
                    newSize = setMaze.getText();
                    newEntrance = setEntrance.getText();
                    newExit = setExit.getText();
                    try {
                        size = Integer.parseInt(newSize);
                    } catch (Exception ex) {
                        isSizeReasonable = false;
                    }
                    if (isSizeReasonable == true) {
                        if (newEntrance.equals("左上角")) {
                            entrance = 1;
                        } else if (newEntrance.equals("右上角")) {
                            entrance = size;
                        } else if (newEntrance.equals("左下角")) {
                            entrance = size * (size - 1) + 1;
                        } else if (newEntrance.equals("右下角")) {
                            entrance = size * size;
                        } else {
                            isEntranceReasonable = false;
                        }
    
                        if (newExit.equals("左上角")) {
                            exit = 1;
                        } else if (newExit.equals("右上角")) {
                            exit = size;
                        } else if (newExit.equals("左下角")) {
                            exit = size * (size - 1) + 1;
                        } else if (newExit.equals("右下角")) {
                            exit = size * size;
                        } else {
                            isExitReasonable = false;
                        }
    
                        if (isEntranceReasonable == true && isExitReasonable == true) {
                            if (entrance == exit) {
                                isEntranceReasonable = false;
                                isExitReasonable = false;
                            }
                        }
                    }
                    if (isSizeReasonable == true && isEntranceReasonable == true && isExitReasonable == true) {
                        dispose();
                        Figure figure = new Figure(size, entrance, exit);
                        figure.init();
                    } else {
                        SetErrorFigure setErrorFigure = new SetErrorFigure();
                        setErrorFigure.init();
                        dispose();
                    }
                }
            }
    
            public void textValueChanged(TextEvent e) {
    
            }
        }
    
        // 通过迷宫游戏界面
        class CongratulationFigure extends Frame implements ActionListener {
            public CongratulationFigure() {
                super("恭喜");
            }
    
            public void init() {
                this.setSize(220, 200);
                this.setBackground(Color.WHITE);
                Toolkit kit = Toolkit.getDefaultToolkit();
                Dimension screenSize = kit.getScreenSize();
                int screenWidth = screenSize.width;
                int screenHeight = screenSize.height;
                int windowWidth = this.getWidth();
                int windowHeight = this.getHeight();
                this.setLocation((screenWidth - windowWidth) / 2, (screenHeight - windowHeight) / 2);
                this.setLayout(new GridLayout(2, 1));
                JLabel text = new JLabel("恭喜您成功走出迷宫!");
                JButton button = new JButton("确认");
                button.setBackground(Color.WHITE);
                add(text);
                add(button);
                button.addActionListener(this);
                addWindowListener(new closeWin());
                this.setVisible(true);
            }
    
            public void actionPerformed(ActionEvent e) {
                if (e.getActionCommand().equals("确认")) {
                    dispose();
                    Figure figure = new Figure();
                    figure.init();
                }
            }
        }
    
        // 游戏设置数据错误界面
        class SetErrorFigure extends Frame implements ActionListener {
            public SetErrorFigure() {
                super("错误");
            }
    
            public void init() {
                this.setSize(230, 100);
                this.setBackground(Color.WHITE);
                Toolkit kit = Toolkit.getDefaultToolkit();
                Dimension screenSize = kit.getScreenSize();
                int screenWidth = screenSize.width;
                int screenHeight = screenSize.height;
                int windowWidth = this.getWidth();
                int windowHeight = this.getHeight();
                this.setLocation((screenWidth - windowWidth) / 2, (screenHeight - windowHeight) / 2);
                this.setLayout(new GridLayout(2, 1));
                JLabel text = new JLabel("您输入的数据不合理,设置失败!");
                JButton button = new JButton("确认");
                button.setBackground(Color.WHITE);
                add(text);
                add(button);
                button.addActionListener(this);
                addWindowListener(new closeWin());
                this.setVisible(true);
            }
    
            public void actionPerformed(ActionEvent e) {
                if (e.getActionCommand().equals("确认")) {
                    dispose();
                    Figure figure = new Figure();
                    figure.init();
                }
            }
        }
    
        class closeWin extends WindowAdapter {
            public void windowClosing(WindowEvent e) {
                Window w = e.getWindow();
                w.dispose();
            }
        }
    
        public Figure() {
            path = new Path();
        }
    
        public Figure(int size, int entrance, int exit) {
            path = new Path(size, entrance, exit);
        }
    
        public void init() {
            MazeGameFigure mazeGameFigure = new MazeGameFigure();
            mazeGameFigure.init();
        }
    
    }
    
    

    核心源码摘自 链接

    展开全文
  • NULL 博文链接:https://stupid.iteye.com/blog/224414
  • 迷宫Java 为 CS112 生成随机迷宫
  • 学校面试考官问的问题我汗呀 本人真心对算法不不是...看我在简历在写的一个老鼠走迷宫游戏 这游戏迷宫地图是事先编辑好的存在txt文件里 他问我怎么随见生成迷宫地图 回答不上来 郁闷死我了。。。。。。求解惑。。。。
  • java 迷宫 随机生成 自动寻找路径 用到树的深度遍历 课程作业 仅供交流
  • 最近学到A星寻路算法,觉得颇有意思,于是百度Google,花了2天时间捣鼓出一个基于Swing的可视化迷宫生成和寻路demo。在此做个记录~ 小demo使用的迷宫生成算法是DFS,寻路用的A星。这样以来,生成迷宫任意2个格子...
  • Java用递归分割算法实现迷宫

    递归分割生成迷宫

    运行效果

    在这里插入图片描述

    实现代码

    package cn.edu.Maze;
    
    import java.util.Random;
    import java.util.Scanner;
    
    /**
     * 输入迷宫的大小和高度打印出迷宫
     * @author SongErrors
     *
     */
    public class Text {
    
    	public static void main(String[] args) {
    		Scanner in = new Scanner(System.in);
    		System.out.println("Enter the width and height :");
    		int width = in.nextInt(), height = in.nextInt();
    		RecursiveDivision maze = new RecursiveDivision(width, height);
    		maze.printMaze(maze.createMazeData());
    		in.close();
    	}
    
    }
    
    /**
     * 递归分割生成迷宫
     * @author SongErrors
     *
     */
    class RecursiveDivision {
    
    	private int[][] mazeData;//迷宫数据
    
    	private final int WALL = 0;// 墙
    
    	private final int ROUND = 1;// 路
    
    	private int width;// 迷宫的宽度
    
    	private int height;// 迷宫的高度
    
    	/**
    	 * 生成自定义大小的迷宫
    	 * 
    	 * @param width
    	 * @param height
    	 */
    	public RecursiveDivision(int width, int height) {
    		this.width = width % 2 + 1 == 0 ? width : width + 1;
    		this.height = height % 2 + 1 == 0 ? height : height + 1;
    	}
    
    	/**
    	 * 自动生成迷宫
    	 * 
    	 * @return
    	 */
    	public int[][] createMazeData() {
    
    		mazeData = new int[height][width];
    		// 初始化迷宫,给迷宫添加一圈外墙
    		for (int y = 0; y < height; y++) {
    			for (int x = 0; x < width; x++) {
    				if (x == 0 || x == width - 1 || y == 0 || y == height - 1)
    					mazeData[y][x] = WALL;
    				else
    					mazeData[y][x] = ROUND;
    			}
    		}
    		division(1, 1, width - 2, height - 2);
    		// 设置起点和终点
    		mazeData[1][0] = ROUND;
    		mazeData[height - 2][width - 1] = ROUND;
    		return mazeData;
    	}
    
    	/**
    	 * 递归分割画迷宫
    	 *
    	 * @param startX:迷宫的起点横坐标
    	 * @param startY:迷宫的起点纵坐标
    	 * @param endX:迷宫的终点横坐标
    	 * @param endY:迷宫的终点纵坐标
    	 */
    	private void division(int startX, int startY, int endX, int endY) {
    
    		Random random = new Random();
    
    		// 如果迷宫的宽度或者高度小于2了就不能再分割了
    		if (endX - startX < 2 || endY - startY < 2)
    			return;
    
    		// x,y只能是偶数
    		int posX = startX + 1 + random.nextInt((endX - startX) / 2) * 2;// 纵向分割分割线的横坐标
    		int posY = startY + 1 + random.nextInt((endY - startY) / 2) * 2;// 横向分割线的纵坐标
    		for (int i = startX; i <= endX; i++) // 横向分割
    			mazeData[posY][i] = WALL;
    		for (int i = startY; i <= endY; i++) // 纵向分割
    			mazeData[i][posX] = WALL;
    
    		division(startX, startY, posX - 1, posY - 1);// 左下区域
    		division(startX, posY + 1, posX - 1, endY);// 左上区域
    		division(posX + 1, posY + 1, endX, endY);// 右上区域
    		division(posX + 1, startY, endX, posY - 1);// 右下区域
    
    		// 随机打开三扇门
    		switch (random.nextInt(4)) {
    		case 0:
    			openDoor(startX, posY, posX - 1, posY); // 开左边的墙
    			openDoor(posX, posY + 1, posX, endY); // 开上方的墙
    			openDoor(posX + 1, posY, endX, posY); // 开右边的墙
    			break;
    		case 1:
    			openDoor(posX, posY + 1, posX, endY); // 开上方的墙
    			openDoor(posX + 1, posY, endX, posY); // 开右边的墙
    			openDoor(posX, startY, posX, posY - 1);// 开下面的墙
    			break;
    		case 2:
    			openDoor(posX + 1, posY, endX, posY); // 开右边的墙
    			openDoor(posX, startY, posX, posY - 1);// 开下面的墙
    			openDoor(startX, posY, posX - 1, posY); // 开左边的墙
    			break;
    		case 3:
    			openDoor(posX, startY, posX, posY - 1);// 开下面的墙
    			openDoor(startX, posY, posX - 1, posY); // 开左边的墙
    			openDoor(posX, posY + 1, posX, endY); // 开上方的墙
    			break;
    		}
    	}
    
    	/**
    	 * 在指定的一面墙上开一个随机的门
    	 *
    	 * @param startX:迷宫开始的横坐标
    	 * @param startY:迷宫开始的纵坐标
    	 * @param endX:迷宫结束的横坐标
    	 * @param endY:迷宫结束的纵坐标
    	 */
    	private void openDoor(int startX, int startY, int endX, int endY) {
    		Random random = new Random();
    		int x;// 开门的横坐标
    		int y;// 开门的纵坐标
    
    		// 墙是横着的
    		if (startY == endY) {
    			x = startX + random.nextInt((endX - startX) / 2 + 1) * 2;
    			mazeData[startY][x] = ROUND;
    		}
    		// 墙是竖着的
    		if (startX == endX) {
    			y = startY + random.nextInt((endY - startY) / 2 + 1) * 2;// 在奇数墙上开门
    			mazeData[y][startX] = ROUND;
    		}
    	}
    
    	public void setWidth(int width) {
    		this.width = width % 2 + 1 == 0 ? width : width + 1;
    	}
    
    	public void setHeight(int height) {
    		this.height = height % 2 + 1 == 0 ? height : height + 1;
    	}
    
    	/**
    	 * 打印迷宫
    	 * 
    	 * @param data
    	 */
    	public static void printMaze(int[][] data) {
    		for (int i = 0; i < data.length; i++) {
    			for (int j = 0; j < data[0].length; j++) {
    				if (data[i][j] == 0)
    					System.out.print("[]");
    				else
    					System.out.print("  ");
    			}
    			System.out.println();
    		}
    	}
    }
    
    
    
    展开全文
  • 今天小编就为大家分享一篇关于Java基于深度优先遍历的随机迷宫生成算法,小编觉得内容挺不错的,现在分享给大家,具有很好的参考价值,需要的朋友一起跟随小编来看看吧
  • JAVA迷宫生成路径查找源码 ... Java做的迷宫游戏,可以制动随机生成迷宫,也可以制动寻找最短路径 二、主要功能 ,可以制动随机生成迷宫,也可以制动寻找最短路径. 三、注意事项 开发环境为eclipse,数据库为无
  • java迷宫 java迷宫 java迷宫

    热门讨论 2008-05-05 10:52:27
    自己java写的迷宫游戏,提供两种随机生成地图的方式:随机布点法和图的深度优先遍历法两种. 可自动查找路劲并显示...
  • 用prim算法创造一个随机生成迷宫,墙和道路分别用0和1来表示,只有一个入口但可以有一个或者两个出口,请用二维数组构建迷宫迷宫的长和宽由使用者来输入(如果需要,可以假设长和...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 825
精华内容 330
关键字:

java随机生成迷宫

java 订阅