使用Java写迷宫之迷宫界面的创建（一）

最新推荐文章于 2023-04-26 09:37:04 发布
最新推荐文章于 2023-04-26 09:37:04 发布
阅读量2.2k 收藏 43
点赞数 7
分类专栏： 课程实验java 文章标签： java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_43632370/article/details/111352536
版权

使用Java写迷宫之迷宫界面的创建


在这里插入图片描述这里引用小蝌蚪找妈妈为题材，生成迷宫
（非常恳请大佬能够提出您宝贵的意见，我将感激涕零！）

思想

迷宫的特点

1、通路和障碍物是同宽度的（您也可以通过计算来使宽度不一样）
2、迷宫的起点到终点肯定是存在一条通路的。
在这里插入图片描述
我们把这个迷宫的所有路拉直，就变成为一个无向图。那我们是否可以转换为无向图的两个顶点之间的通路问题， 图的遍历。

遍历

遍历有很多种，这里运用了较简单的深度优先遍历和广度优先遍历。

深度优先遍历（DFS）

什么是深度优先遍历？
在这里插入图片描述在这里插入图片描述
重复上述两步，直至图中所有和v有路径相通的顶点都被访问到。

类比到迷宫的生成，我们可以这样：

先生成迷宫的大致节点（为深度优先做准备）：
在这里插入图片描述
其中灰色的是墙，黄色的是结点

在这里插入图片描述可以说，深度优先遍历就是一条路走到黑，没有路了，就回溯直到找到下一条路，最后实现起始点与终点的连接。

这与递归算法相似。

广度优先遍历（BFS）

什么是广度优先遍历？
在这里插入图片描述
从图的某一结点出发，首先依次访问该结点的所有邻接结点Vi1,vi2,vi3,……Vin再按这些顶点被访问的先后次序依次访问与它们相邻接的所有未被访问的顶点；
重复此过程，直至所有顶点均被访问位置。

比如说：
v1 -> v3 -> v2 -> v6 -> v4 -> v5 -> v8 -> v7
v1 -> v2 -> v4 -> v8 -> v3 -> v7 -> v5 -> v6
…
可以说，广度优先遍历，就是每到一个新的结点，就有许多周围的结点可以选择。
这里我使用的是队列。

迷宫的显示

这里我使用的是JFrame里添加JPanel，通过在JPanel中绘图，添加至JFrame中，来正常显示，所以说，下面的代码仅生成迷宫的界面，如果想要更多内容，请看下一部分内容，将两者代码合并，源代码在下两章，请您如果需要请看下两章。

素材的制作：通过在网上找图片，通过Photoshop裁剪旋转
地面青蛙
墙
蝌蚪
通过生成的map（请见下文），处于不同类型时添加不同类型的图片，长度宽度我都设为了30像素。

正式开始

变量的定义

一般来说，都是边写代码边加变量名。这里为了更好观看下面的代码，先显示变量的定义。

//地图宽度和高度
    private int width;
    private int height;
    private int model;
    private final int DFSMethod = 1;
    private final int BFSMethod = 2;
    //地图种类定义
    private final int WALL = 0;
    private final int EMPTY = 1;
    private final int SELF = 2;
    private final int END = 3;
    private final int TESTFLAG = 4;
    private final int WALKED = 5;
    private final int ANS = 6;
    //地图具体参数定义
    private int side = 30;
    private int[][] map;
    private int mapWidth;//地图的列数
    private int mapHeight;//地图的行数
    private String direction = "R";
    private boolean isSucceed = false;
    //为A*算法准备
    private int[][] mapForComputer;
    //图片定义
    private ImageIcon wall;
    private ImageIcon floor;
    private ImageIcon frog;
    private ImageIcon tadpoleRight;
    private ImageIcon tadpoleLeft;
    private ImageIcon tadpoleUp;
    private ImageIcon tadpoleDown;
    //与前一个框建立连接
    private JFrame Jf;
    //电脑自动开关按钮
    private boolean buttonOpen = false;
    private JButton ansButton;
    //判断是否开始
    private boolean go = false;
    //方向数组，便于后面加减,分别为上下左右
    int[][] dir = {
            {-1,0},
            {1,0},
            {0,-1},
            {0,1}
    };
    //音乐
    Clip bgm;

迷宫初始化

这个也是为了方便解释，先贴上迷宫的初始化，看看迷宫初始化需要做什么。

MyPanel(int widthCount, int heightCount, int model, JFrame newJFrame) {
        //初始化图片
        loadImages();
        //初始化音乐
        loadBGM();
        //初始化长和宽
        this.width = widthCount * side;
        this.height = heightCount * side;
        this.model = model;
        this.map = new CreateMap(widthCount, heightCount, model).getMap();
        this.mapForComputer = map;
        this.mapWidth = map[0].length;
        this.mapHeight = map.length;
        this.Jf = newJFrame;
        //添加键盘事件监听
        this.setFocusable(true);
        this.addKeyListener(this);
        //初始化答案
        initAns();
        //添加按钮
        initButton();
        this.add(ansButton);
        //开启音乐
        playBGM();
    }

图片的初始化

如图所示，图片在src下的images目录下
在这里插入图片描述
定义的每个变量对应着一张图片，如果您想要打包，可以使用java中的getClass方法以及加上相对路径。

private void loadImages() {

        wall = new ImageIcon("src\\images\\wall.jpg");
        frog = new ImageIcon("src\\images\\frog.png");
        tadpoleRight = new ImageIcon("src\\images\\tadpoleRight.jpg");
        tadpoleLeft = new ImageIcon("src\\images\\tadpoleLeft.jpg");
        tadpoleUp = new ImageIcon("src\\images\\tadpoleUp.jpg");
        tadpoleDown = new ImageIcon("src\\images\\tadpoleDown.jpg");
        floor = new ImageIcon("src\\images\\floor.jpg");

    }

初始化音乐同理，暂时就不介绍了。

按键事件的监听

KeyListener

在实现KeyListener接口后，就需要重写方法

@Override
    public void keyPressed(KeyEvent e) {

        int keyCode = e.getKeyCode();//获取键盘背后对应的数字
        if (keyCode == KeyEvent.VK_RIGHT || keyCode == KeyEvent.VK_D) {
            goRight();
        } else if (keyCode == KeyEvent.VK_LEFT || keyCode == KeyEvent.VK_A) {
            goLeft();
        } else if (keyCode == KeyEvent.VK_UP || keyCode == KeyEvent.VK_W) {
            goUp();
        } else if (keyCode == KeyEvent.VK_DOWN || keyCode == KeyEvent.VK_S) {
            goDown();

这里键盘的上下左右以及AWSD，都可以用来控制小蝌蚪的移动，具体请您看goRight方法。

private void goRight() {
        go = true;
        direction = "R";
        if (!isSucceed) {
            moveRight();
        }
        repaint();
    }

moveRight()

这里的go变量请您先不用管，他是用来对按钮进行控制的。
首先先将方向变量进行修改（在之后的paintComponent方法中会用到），以及判断是否成功，如果小蝌蚪以及到达了青蛙的位置，那么他就不能在移动了，最后调用repaint()方法的重绘功能。下面介绍里面的moveRight方法（俄罗斯套娃.-.）

private void moveRight() {
        //这里的x和y，代表的是map中的坐标位置
        int[][] selfPos = getSELFxy();
        int selfX = selfPos[0][0];
        int selfY = selfPos[0][1];
        //System.out.println(inArea(selfX + 1,selfY));
        //判断是否到达了终点
        if (inArea(selfX,selfY+1) && map[selfX][selfY+1] == END) {
            map[selfX][selfY+1] = SELF;
            map[selfX][selfY] = EMPTY;
            isSucceed = true;
            congratulate();
            return;
        }
        if (inArea(selfX ,selfY + 1) &&
                (map[selfX][selfY+1] == EMPTY
                        || map[selfX][selfY+1] == TESTFLAG
                        || map[selfX][selfY+1] == WALKED
                        || map[selfX][selfY+1] == ANS)) {
            map[selfX][selfY+1] = SELF;
            map[selfX][selfY] = WALKED;
        }
        //printMap();
    }

首先先获取SELF的位置坐标，调用getSELFxy方法，取出x坐标和y坐标，
这里要说明的是，x代表的是行坐标，y代表的是纵坐标（如果您不太认可，可以在代码的基础上修改一下，但可能会比较乱），也就是说，如果地图是这样的
0 0 0 0 0 0
0 1 2 1 1 0
0 0 1 0 1 0
那么如果要找到SELF代表的数字2，他的x就为1，y就为2，及map[1][2]，
那么，接下来的就是判断是否为终点，以及如果不是终点，就开始行走。首先是行走，前面我们已经知道x和y的具体意思，所以如果小蝌蚪想要往右走，我们需要判断的是map[1][3]位置的具体情况，不好意思，这里遗留了一些历史问题（原来打算使用TESTFLAG来实现小蝌蚪的自动寻找功能，结果最后添加了一个新的变量ANS，替代了TESTFLAG），这里麻烦您将TESTFLAG看做为EMPTY一样，可以用来小蝌蚪进行行走，我们仅需将右边的一个位置变为SELF，原来的位置变为WALKED变量，表示已经行走过了。

inArea()

其实这个方法在这里不是很需要，但是如果再做更多功能时，可能就需要了。

//是否在地图内
    private boolean inArea(int x,int y)
    {
        if(x > 0 && x < mapHeight-1 && y > 0 && y < mapWidth-1)
            return true;
        return false;
    }

congratulate()

private void congratulate() {

        stopBGM();
        int num = JOptionPane.showConfirmDialog(this,
                "恭喜您，让小蝌蚪找到了妈妈！您还需要再来一局吗？",
                "恭喜",
                JOptionPane.YES_NO_OPTION);
        if (num == JOptionPane.YES_OPTION) {
            MazeFrame frame = new MazeFrame();
            frame.init();
            Jf.setVisible(false);
        } else if (num == JOptionPane.NO_OPTION) {
            System.exit(0);
        }

    }

这个方法是在当判断为下一个结点为END，就会调用，窗口会弹出选择，问您是否要再来一局和退出。

重绘函数的编写

对于map二维数组对应的所有类型，在相应的位置上绘制图片，每按一次键盘，会运行重绘机制。

@Override
    public void paintComponent(Graphics g) {
        super.paintComponent(g);

        for (int i = 0; i < mapHeight; i++) {
            for (int j = 0; j < mapWidth; j++) {
                if (map[i][j] == WALL) {
                    wall.paintIcon(null,g,j * side,i * side);
                } else if (map[i][j] == SELF) {
                    if (direction == "R") {
                        tadpoleRight.paintIcon(null,g,j * side,i * side);
                    } else if (direction == "L") {
                        tadpoleLeft.paintIcon(null,g,j * side,i * side);
                    } else if (direction == "U") {
                        tadpoleUp.paintIcon(null,g,j * side,i * side);
                    } else {
                        tadpoleDown.paintIcon(null,g,j * side,i * side);
                    }
                } else if (map[i][j] == END) {
                    frog.paintIcon(null,g,j * side,i * side);
                } else if (map[i][j] == WALKED) {
                    floor.paintIcon(null, g, j * side, i * side);
                }
            }
        }
    }

源代码

（非常恳请大佬能够提出您宝贵的意见，我将感激涕零！）

package exp3;

import javax.sound.sampled.*;
import javax.swing.*;
import java.awt.*;
import java.awt.event.*;
import java.io.IOException;
import java.io.InputStream;

public class MyPanel extends JPanel implements ActionListener, KeyListener {

    //地图宽度和高度
    private int width;
    private int height;
    private int model;
    private final int DFSMethod = 1;
    private final int BFSMethod = 2;
    //地图种类定义
    private final int WALL = 0;
    private final int EMPTY = 1;
    private final int SELF = 2;
    private final int END = 3;
    private final int TESTFLAG = 4;
    private final int WALKED = 5;
    private final int ANS = 6;
    //地图具体参数定义
    private int side = 30;
    private int[][] map;
    private int mapWidth;//地图的列数
    private int mapHeight;//地图的行数
    private String direction = "R";
    private boolean isSucceed = false;
    //为A*算法准备
    private int[][] mapForComputer;
    //图片定义
    private ImageIcon wall;
    private ImageIcon floor;
    private ImageIcon frog;
    private ImageIcon tadpoleRight;
    private ImageIcon tadpoleLeft;
    private ImageIcon tadpoleUp;
    private ImageIcon tadpoleDown;
    //与前一个框建立连接
    private JFrame Jf;
    //电脑自动开关按钮
    private boolean buttonOpen = false;
    private JButton ansButton;
    //判断是否开始
    private boolean go = false;
    //方向数组，便于后面加减,分别为上下左右
    int[][] dir = {
            {-1,0},
            {1,0},
            {0,-1},
            {0,1}
    };
    //音乐
    Clip bgm;

    class LookWay extends Thread {
        @Override
        public void run() {

            while (!isSucceed && buttonOpen) {
                //todo
                int[][] xy = getSELFxy();
                int selfX = xy[0][0];
                int selfY = xy[0][1];
                moveDirect(selfX, selfY);
                //System.out.println(selfX + " " + selfY);
                //printMap();
                try {
                    Thread.sleep(100);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        }

        private void moveDirect(int x, int y) {
            for (int i = 0; i < 4; i++) {
                if (map[x + dir[i][0]][y + dir[i][1]] == ANS
                        || map[x + dir[i][0]][y + dir[i][1]] == END) {
                    if (i == 0) {
                        goUp();
                        System.out.println(i);
                        return;
                    } else if (i == 1) {
                        goDown();
                        System.out.println(i);
                        return;
                    } else if (i == 2) {
                        goLeft();
                        System.out.println(i);
                        return;
                    } else if (i == 3) {

                        goRight();
                        System.out.println(i);
                        return;
                    }
                }
            }
        }
    }
    MyPanel(int widthCount, int heightCount, int model, JFrame newJFrame) {
        //初始化图片
        loadImages();
        //初始化音乐
        loadBGM();
        //初始化长和宽
        this.width = widthCount * side;
        this.height = heightCount * side;
        this.model = model;
        this.map = new CreateMap(widthCount, heightCount, model).getMap();
        this.mapForComputer = map;
        this.mapWidth = map[0].length;
        this.mapHeight = map.length;
        this.Jf = newJFrame;
        //添加键盘事件监听
        this.setFocusable(true);
        this.addKeyListener(this);
        //初始化答案
        initAns();
        //添加按钮
        initButton();
        this.add(ansButton);
        //开启音乐
        playBGM();
    }

    void initButton() {
        ansButton = new JButton("开启自动寻路");
        ansButton.addMouseListener(new MouseAdapter() {
            @Override
            public void mousePressed(MouseEvent e) {
                if (go && !buttonOpen) {
                    JOptionPane.showMessageDialog(null,
                            "您已经开始，所以无法再帮您寻找通路了",
                            "警告",JOptionPane.WARNING_MESSAGE);
                    return;
                }
                buttonOpen = !buttonOpen;
                if (!buttonOpen) {
                    ansButton.setText("开启自动寻路");
                } else {
                    ansButton.setText("关闭自动寻路");
                    go = true;
                }
                map = mapForComputer;
                Thread thread = new Thread(new LookWay());
                thread.start();
            }
        });
        ansButton.setVisible(true);
        ansButton.setFocusable(false);
    }

    @Override
    public void paintComponent(Graphics g) {
        super.paintComponent(g);

        for (int i = 0; i < mapHeight; i++) {
            for (int j = 0; j < mapWidth; j++) {
                if (map[i][j] == WALL) {
                    wall.paintIcon(null,g,j * side,i * side);
                } else if (map[i][j] == SELF) {
                    if (direction == "R") {
                        tadpoleRight.paintIcon(null,g,j * side,i * side);
                    } else if (direction == "L") {
                        tadpoleLeft.paintIcon(null,g,j * side,i * side);
                    } else if (direction == "U") {
                        tadpoleUp.paintIcon(null,g,j * side,i * side);
                    } else {
                        tadpoleDown.paintIcon(null,g,j * side,i * side);
                    }
                } else if (map[i][j] == END) {
                    frog.paintIcon(null,g,j * side,i * side);
                } else if (map[i][j] == WALKED) {
                    floor.paintIcon(null, g, j * side, i * side);
                }
            }
        }
    }
    //暂时没啥用，将来可以用来补充功能
    @Override
    public void actionPerformed(ActionEvent e) {
        System.out.println("----actionPerformed---");
        repaint();
    }

    @Override
    public void keyTyped(KeyEvent e) {

    }

    @Override
    public void keyPressed(KeyEvent e) {

        int keyCode = e.getKeyCode();//获取键盘背后对应的数字
        if (keyCode == KeyEvent.VK_RIGHT || keyCode == KeyEvent.VK_D) {
            goRight();
        } else if (keyCode == KeyEvent.VK_LEFT || keyCode == KeyEvent.VK_A) {
            goLeft();
        } else if (keyCode == KeyEvent.VK_UP || keyCode == KeyEvent.VK_W) {
            goUp();
        } else if (keyCode == KeyEvent.VK_DOWN || keyCode == KeyEvent.VK_S) {
            goDown();
        }
    }

    private void goDown() {
        go = true;
        direction = "D";
        if (!isSucceed) {
            moveDown();
        }
        repaint();
    }

    private void goUp() {
        go = true;
        direction = "U";
        if (!isSucceed) {
            moveUp();
        }
        repaint();
    }

    private void goLeft() {
        go = true;
        direction = "L";
        if (!isSucceed) {
            moveLeft();
        }
        repaint();
    }

    private void goRight() {
        go = true;
        direction = "R";
        if (!isSucceed) {
            moveRight();
        }
        repaint();
    }

    @Override
    public void keyReleased(KeyEvent e) {

    }

    private void initAns() {
        mapForComputer = new int[mapHeight][mapWidth];
        for (int i = 0; i < mapHeight; i++) {
            for (int j = 0; j < mapWidth; j++) {
                mapForComputer[i][j] = map[i][j];
            }
        }
        SolveMap solveMap = new SolveMap(mapForComputer);
        mapForComputer = solveMap.getMap();
    }

    private void moveRight() {
        //这里的x和y，代表的是map中的坐标位置
        int[][] selfPos = getSELFxy();
        int selfX = selfPos[0][0];
        int selfY = selfPos[0][1];
        //System.out.println(inArea(selfX + 1,selfY));
        //判断是否到达了终点
        if (inArea(selfX,selfY+1) && map[selfX][selfY+1] == END) {
            map[selfX][selfY+1] = SELF;
            map[selfX][selfY] = EMPTY;
            isSucceed = true;
            congratulate();
            return;
        }
        if (inArea(selfX ,selfY + 1) &&
                (map[selfX][selfY+1] == EMPTY
                        || map[selfX][selfY+1] == TESTFLAG
                        || map[selfX][selfY+1] == WALKED
                        || map[selfX][selfY+1] == ANS)) {
            map[selfX][selfY+1] = SELF;
            map[selfX][selfY] = WALKED;
        }
        //printMap();
    }

    private void moveLeft() {
        int[][] selfPos = getSELFxy();
        int selfX = selfPos[0][0];
        int selfY = selfPos[0][1];
        //System.out.println(inArea(selfX - 1,selfY));
        //判断是否到达了终点
        if (inArea(selfX,selfY-1) && map[selfX][selfY-1] == END) {
            map[selfX][selfY-1] = SELF;
            map[selfX][selfY] = EMPTY;
            isSucceed = true;
            congratulate();
            return;
        }
        if (inArea(selfX,selfY-1) &&
                (map[selfX][selfY-1] == EMPTY
                        || map[selfX][selfY-1] == TESTFLAG
                        || map[selfX][selfY-1] == WALKED
                        || map[selfX][selfY-1] == ANS)) {
            map[selfX][selfY-1] = SELF;
            map[selfX][selfY] = WALKED;
        }
        //printMap();
    }
    private void moveUp() {
        int[][] selfPos = getSELFxy();
        int selfX = selfPos[0][0];
        int selfY = selfPos[0][1];
        //System.out.println(inArea(selfX,selfY - 1));
        //判断是否到达了终点
        if (inArea(selfX-1,selfY) && map[selfX-1][selfY] == END) {
            map[selfX-1][selfY] = SELF;
            map[selfX][selfY] = EMPTY;
            isSucceed = true;
            congratulate();
            return;
        }
        if (inArea(selfX-1,selfY) &&
                (map[selfX-1][selfY] == EMPTY
                        || map[selfX-1][selfY] == TESTFLAG
                        || map[selfX-1][selfY] == WALKED
                        || map[selfX-1][selfY] == ANS)) {
            map[selfX-1][selfY] = SELF;
            map[selfX][selfY] = WALKED;
        }
        //printMap();
    }
    private void moveDown() {
        int[][] selfPos = getSELFxy();
        int selfX = selfPos[0][0];
        int selfY = selfPos[0][1];
        //System.out.println(inArea(selfX+1,selfY));
        //判断是否到达了终点
        if (inArea(selfX+1,selfY) && map[selfX+1][selfY] == END) {
            map[selfX+1][selfY] = SELF;
            map[selfX][selfY] = EMPTY;
            isSucceed = true;
            congratulate();
            return;
        }
        if (inArea(selfX+1,selfY) &&
                (map[selfX+1][selfY] == EMPTY
                        || map[selfX+1][selfY] == TESTFLAG
                        || map[selfX+1][selfY] == WALKED
                        || map[selfX+1][selfY] == ANS)) {
            map[selfX+1][selfY] = SELF;
            map[selfX][selfY] = WALKED;
        }
        //printMap();
    }


    private void loadImages() {

        wall = new ImageIcon("src\\images\\wall.jpg");
        frog = new ImageIcon("src\\images\\frog.png");
        tadpoleRight = new ImageIcon("src\\images\\tadpoleRight.jpg");
        tadpoleLeft = new ImageIcon("src\\images\\tadpoleLeft.jpg");
        tadpoleUp = new ImageIcon("src\\images\\tadpoleUp.jpg");
        tadpoleDown = new ImageIcon("src\\images\\tadpoleDown.jpg");
        floor = new ImageIcon("src\\images\\floor.jpg");

    }

    private void congratulate() {

        stopBGM();
        int num = JOptionPane.showConfirmDialog(this,
                "恭喜您，让小蝌蚪找到了妈妈！您还需要再来一局吗？",
                "恭喜",
                JOptionPane.YES_NO_OPTION);
        if (num == JOptionPane.YES_OPTION) {
            MazeFrame frame = new MazeFrame();
            frame.init();
            Jf.setVisible(false);
        } else if (num == JOptionPane.NO_OPTION) {
            System.exit(0);
        }

    }

    private void loadBGM() {
        // 定义字节输入流变量
        InputStream is;
        // 该类为inputstream的直接子类，用于读取音频
        AudioInputStream ais;
        // 该类提供对一系列浮点值的控制，此处定义用来控制音频音量大小
        FloatControl gainControl;

        try {

            bgm = AudioSystem.getClip();
            // 通过类加载器找到字节流
            is = this.getClass().getClassLoader().
                    getResourceAsStream("music\\morning.wav");
            ais = AudioSystem.getAudioInputStream(is);// 转换成音频字节流
            bgm.open(ais);
            gainControl = (FloatControl) bgm.getControl(FloatControl.Type.MASTER_GAIN);
            gainControl.setValue(1.0f);// 控制调整bgm的音量大小

        } catch (LineUnavailableException
                | IOException
                | UnsupportedAudioFileException e) {
            e.printStackTrace();
        }
    }

    private void playBGM() {
        bgm.loop(Clip.LOOP_CONTINUOUSLY);
    }

    private void stopBGM() {
        bgm.stop();
    }

    private int[][] getSELFxy() {
        int[][] temp = new int[1][2];
        for (int i = 0; i < mapHeight; i++) {
            for (int j = 0; j < mapWidth; j++) {
                if (map[i][j] == SELF) {
                    temp[0][0] = i;
                    temp[0][1] = j;
                    return temp;
                }
            }
        }
        return temp;
    }

    //是否在地图内
    private boolean inArea(int x,int y)
    {
        if(x > 0 && x < mapHeight-1 && y > 0 && y < mapWidth-1)
            return true;
        return false;
    }
    //test
    private void printMap() {
        for (int i = 0; i < mapHeight; i++) {
            for (int j = 0; j < mapWidth; j++) {
                System.out.print(map[i][j] + " ");
            }
            System.out.println();
        }
    }
    //test
    private void getENDxy() {
        int[][] temp = new int[1][2];
        for (int i = 0; i < mapHeight; i++) {
            for (int j = 0; j < mapWidth; j++) {
                if (map[i][j] == END) {
                    temp[0][0] = i;
                    temp[0][1] = j;
                    System.out.println("x = " + i + "y = " + j);
                }
            }
        }
    }
}
从0学习1024
关注
  • 7
    点赞
  • 踩
  • 43
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
专栏目录
java迷宫课程设计.zip
06-08
通过java实现的迷宫课程设计。分成算法部分和界面部分，算法部分涉及到迷宫生成算法，深度优先，广度优先，运用了栈和队列等容器。界面部分采用javafx实现。有显示迷宫路线，更改迷宫大小，展示迷宫解谜动画过程。用户还可通过键盘控制史莱姆解谜迷宫，以及一个娱乐模式，也可以联系QQ：2295710610了解
Java随机Prim算法和A*算法生成随机迷宫
qq_63993414的博客
12-22 4614
程序功能: 1,随机Prim算法生成迷宫地图 游戏中需要随机生成迷宫地图，引入java.util.Random类，利用Random类提供的生成随机数方法，随机生成障碍物、通路或者奖励等状态。迷宫地图采用二维数组进行表示与存储。 2，A*算法求解迷宫路径 根据A*算法求解出当前位置迷宫的路径 3,判断玩家闯关是否成功 根据玩家的当前位置是否位于地图的出口点来判断玩家闯关是否成功。 4,游戏主控模块 输入“←↑↓→”则根据是否能进行移动来更新游戏界面和当前位置，已经退出，难度更改，路径显示等功能
利用Java解决走迷宫问题
HSBhuang的博客
12-18 6552
利用Java解决走迷宫问题 概述 假设有一个如下图所示的迷宫，灰色部分是墙壁不可走，白色部分是可以走的路，蓝色位置为迷宫的入口，绿色位置为出口。从入口出发，规定只能通过向上、向下、向左和向右方向进行走动，问如何才能找到一条到达出口的通路。 思路 可以用一个二维矩阵来模拟迷宫地图，0代表灰色部分的墙壁，1代表白色部分可走的路 当每走过一个位置后，把改位置的值标记为-1，如果该位置标记为-1，则不可以重复走 判断当前位置是否有路可走，根据向右、向下、向左、向上的顺序判断该位置的下一步是否有路可走
使用Java创建迷宫游戏 - 一个实战教程
最新发布
10-03
迷宫游戏是一种有趣的小型游戏，玩家需要在迷宫中找到通往终点的路径。在这个实战博客中，我们将创建一个简单的Java迷宫游戏，演示如何构建一个基本的游戏应用。我们将使用Java编程语言和一些基本的图形库来完成这个项目。 以下是本实战博客的主要内容： 项目概述 准备工作 创建游戏窗口 生成迷宫 游戏逻辑 绘制迷宫和角色 用户输入和游戏循环 运行和测试游戏 总结 让我们开始吧！ 1. 项目概述 在本项目中，我们将创建一个简单的Java迷宫游戏，它包括以下主要功能： 随机生成一个迷宫地图。 在地图上绘制一个玩家角色，玩家可以通过键盘控制角色移动。 玩家的目标是找到迷宫的出口。 游戏会提供胜利和失败的反馈。 我们将使用Java编程语言和以下开发库来构建迷宫游戏： Java标准库：用于基本的Java编程。 Swing：用于创建图形用户界面（GUI）的Java库。 AWT（抽象窗口工具集）：用于创建游戏窗口和绘制图形。
基于Java的迷宫程序（带界面）
03-23
用Eclipse开发的迷宫程序，附带界面设计，整个程序可跑起来，可附加设置迷宫难度等级。
用JAVA实现一个走迷宫程序
suo_jia_hao的博客
06-26 1911
用JAVA实现一个走迷宫程序 本Demo使用三个类 一个Test类 一个自定义的Stack类 一个自定义的Queue类 可以实现的功能： 1.对于一个写在文本文件中的迷宫，能够将其转换为二维数组用广度优先搜索实现查找最短路径 2.可以不定义迷宫的入口和出口，能自动查找到出入口 前提是要有一个对应路径的.txt文件 这里举个例子吧,我的是"F:/1号迷宫(0,18).txt"路径下 运行结果 注释写的很详细，这里就不多赘述了 package com; import java.io.BufferedRea
java-迷宫问题
weixin_65584018的博客
10-15 330
本章讲解一个迷宫问题，用来了解方法递归，迷宫和问题如下问题：求小球从开始到结束的路径，小球从坐标(1,1)开始找，到坐标(5,6)时结束。
java课设迷宫游戏_Java编写迷宫小游戏
weixin_35056962的博客
02-01 1277
缘起：去年(大三上学期)比较喜欢写小游戏，于是想试着写个迷宫试一下。程序效果：按下空格显示路径：思考过程：迷宫由一个一个格子组成，要求从入口到出口只有一条路径.想了一下各种数据结构，似乎树是比较合适的，从根节点到每一个子节点都只有一条路径。假设入口是根节点，出口是树中某个子节点，那么，从根节点到该子节点的路径肯定是唯一的。所以如果能构造一棵树把所有的格子都覆盖到，也就能够做出一个迷宫了。另外还要求...
解密迷宫问题：三种高效算法Java实现，让你轻松穿越未知迷宫
xxxzzzqqq_的博客
04-26 4224
我们总结一下，在迷宫问题中，深度优先搜索（DFS）、广度优先搜索（BFS）和 A* 都可以用来寻找最短路径或最优解。空间要求低，不需要保存整个搜索树，只需要保存当前路径；所有解的路径长度差别不大，或者只需要找到其中一个解；迷宫比较大，而且有很多死路，采用 DFS 可以快速探索大面积空间。需要找到最短路径或最优解；迷宫中大部分路径长度差别不大；可以承受较大的空间复杂度，需要保存整个搜索树。需要找到最短路径或最优解；需要考虑迷宫中的障碍物，即寻找一条避开障碍物的路径；
java 迷宫游戏_Java小项目之迷宫游戏的实现方法
weixin_42509803的博客
02-20 1211
项目要求：一个网格迷宫由n行n列的单元格组成，每个大院个要么是空地(用0表示)，要么是障碍物(用1表示)，你的任务是找一条从起点到终点的移动序列，其中只能上下左右移动到相邻单元格。任何时候都不能在有障碍物的单元格中，也不能走到迷宫之外，起点为左上角和终点右下角。项目功能：解决迷宫路径查找问题，寻找一条从左上角迷宫入口到右下角迷宫出口的一条有效路径，0代表可走，1代表能走，找到请输出最终的迷宫和路径...
Java带界面迷宫
11-26
带界面的JAVA迷宫游戏，可以选择迷宫样式，自动生成迷宫，可用键盘进行移动小人。
java迷宫课程设计
11-30
此资源为本人大一java课程设计结果，用java写迷宫，界面使用javafx，包内带文档，代码较为简单基础，有注释。
java实现迷宫重庆理工大学 19级面向对象程序设计 java 课程设计 课程实践 源码+报告+任务书 原创
06-01
个人资源，仅供参考不得传播。 拥有可视化创建迷宫，寻路等功能，几乎全都有注释。 含有源码+报告+任务书，报告有流程图和类图，全自制。 仅有基本功能，仅供参考。 用java面向对象程序设计语言，设计和实现一电脑鼠走迷宫的软件程序，即一个假想的小车能在图示的迷宫中根据设定的起始点和终点自主寻找路径。本综合实践分成两部分：第一部分为算法设计和实现部分，第二部分为界面展现部分。每一部分又分为三个不同层次的要求，学生可以根据自己的能力来完成相应的部分。
Java课程设计走迷宫.zip_Java课程设计走迷宫_java课程设计_paymx9_迷宫 java_迷宫Java设计
09-21
Java课程设计走迷宫 可用 Java课程设计走迷宫小游戏
简易物流管理系统的创建
qq_43632370的博客
12-28 1016
简易物流管理系统的创建说明页面搭建数据访问层增删改查增删改查数据库 说明 这是我们小组一起共同完成的一个简易物流管理系统，我负责的部分是数据访问层中的删除功能，以及数据库的搭建，还有针对不同窗口大小的适应部分。 页面搭建 我们使用的是Java swing框架 ，根据框架中提供的按钮、文本框、多行文本框以及弹出对话框建立联系，在按下确定按钮时会调用相应的数据访问层语言，先检查数据库是否存在以及其他情况，返回相应的状态，从而进行判断。 //注册提交 BtnCo.addActionListene
使用Java写迷宫之迷宫的生成与解决A*（二）
qq_43632370的博客
12-18 539
使用Java写迷宫之迷宫的生成与解决A*迷宫的生成迷宫的初始化深度优先遍历（DFS）广度优先遍历（BFS）迷宫的解决A*算法思路实现A*代码 （非常恳请大佬能够提出您宝贵的意见，我将感激涕零！） 迷宫生成的算法思想在上一篇文章中已经介绍了，下面介绍的是具体的算法实现代码。 2是起点，3是终点，4是通路，0是墙壁 6是生成的路径答案 迷宫的生成 迷宫的初始化 void init(int width, int height, int model){ map = new int[height][
学习使用Java制作简易计算器的第三天
qq_43632370的博客
12-07 540
学习使用Java制作简易计算器的第三天 今天是使用JFormDesigner来搭建简易计算器。 一、搭建计算器页面 使用JTextField和JBottom分别来搭建输入行、输出行和按钮，然后点击红色框框，给按钮添加事件。 当然，前提是要把按钮和文本框的名字都改好，好见名知意。也好调整好他们的宽和高。 二、写代码 public static void main(String[] args) { Calculator calculator = new Calculator();
学习用Java写简单贪吃蛇第二天
qq_43632370的博客
12-10 261
学习用Java写简单贪吃蛇第二天准备开始贪吃蛇结点的构建页面的显示搭建大部分功能的实现贪吃蛇的开始初始化放置普通食物判断蛇是否咬到了自己设置吃到食物后的发生设置方向键的限定时间时钟到了执行的方法绘图完善吃完特殊食物会怎么样当蛇的长度到达一定长度会怎么样游戏音乐的开启游戏上方按钮的绘制按钮的创建按钮的初始化根据难度以及模式判断具体展示总结 准备开始 贪吃蛇结点的构建 结点是使用双向链表来搭建的，里面定义了x和y分别表示结点所处的位置，用next代表下一个结点，用prev代表前一个结点，而之前的方向，定义在主方
用java写一个迷宫小游戏
05-16
好的，我可以为您提供一些关于用Java编写迷宫小游戏的建议。首先，您需要确定迷宫游戏的规则和目标。然后，您可以使用Java的图形用户界面工具包（如Swing）创建游戏界面，并实现游戏逻辑和交互性。您需要设计迷宫的结构和生成算法，并考虑如何使玩家与游戏进行交互，例如如何移动和收集物品。同时，您需要考虑如何处理游戏的胜利和失败条件。最后，您可以添加音效和图像来增强游戏的体验。希望这些提示对您有所帮助！

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值