实验三 基于A*算法的迷宫游戏开发

最新推荐文章于 2022-03-30 11:39:25 发布
最新推荐文章于 2022-03-30 11:39:25 发布
阅读量2k 收藏 4
点赞数
文章标签： 算法 java gui
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/JUST192210713125/article/details/121975512
版权

实验要求：

1、迷宫随机生成

2、玩家走迷宫，留下足迹；

3、系统用A*算法寻路，输出路径

解决问题：

1、如何显示迷宫的图形界面；

2、如何生成随机的迷宫；
3、怎样移动游戏中走迷宫的“玩家”；

4、用A*算法求解迷宫；

生成随机迷宫的方法：

  1. 深度优先遍历：利用深度遍历的思想。访问到一个节点时，搜索这个节点没有被访问过的相邻节点，选择一个继续做同样的操作，直到没有邻节点为止再回溯到上一个访问的节点，并选择另外的邻节点。这种方案生成的迷宫会有一条明显的主路，这条主路特别长，贯穿大部分区域的路线，同时，迷宫的路线一般比较扭曲。这种采用深度优先算法（递归回溯算法）生成的迷宫称之为“主路扭曲型”迷宫。

  2. 普利姆算法：把图中预置的通路节点分成两个集合，已经在通路里的属于U，未添加到通路里的属于V-U，通过这样的添加节点策略，把节点间的蓝色0当成最小生成树的边，依次添加到TE里，直到所有节点都添加到U里，这样，在任意两个节点间就形成了一个通路。prim算法形成的主路相对于深度优先算法，比较自然，但迷宫的分岔比较多，所以迷宫会更复杂，玩家需要做的选择次数可能会比较多。

  • 这里我选择的是普利姆算法， 根据这个算法的思想，大致的过程是：

  • 1.生成一个基础地图。格子先用黄色1和灰色0来表示。

  • 2.随机取一个地图边缘的黄色1，把它标记为红色1.即 变成通路。然后把它旁边的灰色0标记成为蓝色0，表示“待定”。

3.随机选择一个蓝色0，然后看红色1隔着这个蓝色0对面的格子，是否是黄色的1，          

 1）如果是，则把对面的黄色1标记成红色1，即变成通路，然后把蓝色0变成红色的，即也变成通路；

 2）如果不是，就把这个蓝色的0变成灰色的；

4.继续为红色通路集合寻找待定的蓝色0，然后随机选择一个蓝色0，然后看红色1隔着这个蓝色0对面的格子，是否是黄色的1，

1）如果是，则把对面的黄色1标记成红色1，即变成通路，然后把蓝色0变成红色的，即也变成通路；

2）如果不是，就把这个蓝色的0变成灰色的；

 

 

如果随机选的蓝色的0隔着红色1对面的不是黄色1，说明这不是一条通路，就把这个蓝色的0变成灰色0，变成确定的障碍物；接下来就继续随机找另一个蓝色的0；即不停地重复上面的步骤3，直到整个地图都没有蓝色0了，地图就生成完毕。大致就是这么一个思路。

我们就先把迷宫生成吧。

主方法类：

import javax.swing.*;
import java.awt.*;
import java.awt.event.MouseAdapter;
import java.awt.event.MouseEvent;
import java.awt.event.MouseListener;

public class Maze {
    public static JFrame jFrame1 = new JFrame("迷宫");
    public static JFrame jFrame2 = new JFrame("迷宫");
    public static JFrame jFrame3 = new JFrame("迷宫3");
    public static JPanel jPanel1 = new JPanel();

    public static void main(String[] args) {
        jFrame1.setBounds(450, 100, 1000, 1000);
        jFrame1.setResizable(true);
        jFrame1.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
        jFrame2.setBounds(450, 100, 1000, 900);
        jFrame2.setResizable(true);
        jFrame2.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
        jFrame3.setBounds(200, 200, 1100, 1100);
        jFrame3.setResizable(true);
        jFrame3.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
        JLabel jLabel1 = new JLabel("难度选择");
        JButton jButton1 = new JButton("简单");
        JButton jButton2 = new JButton("中等");
        JButton jButton3 = new JButton("困难");
        jPanel1.setLayout(null);
        jPanel1.add(jLabel1);
        jPanel1.add(jButton1);
        jPanel1.add(jButton2);
        jPanel1.add(jButton3);
        jLabel1.setFont(new Font("微软雅黑", Font.BOLD + Font.ITALIC, 40));
        jLabel1.setBounds(420, 200, 700, 50);
        jButton1.setBounds(450, 400, 100, 50);
        jButton2.setBounds(450, 500, 100, 50);
        jButton3.setBounds(450, 600, 100, 50);
        jFrame1.add(jPanel1);
        jButton1.addMouseListener(new MouseListener() {
            @Override
            public void mouseClicked(MouseEvent e) {
                jFrame1.dispose();
                jFrame2.add(new Build1());
                jFrame2.setVisible(true);
            }

            @Override
            public void mousePressed(MouseEvent e) {

            }

            @Override
            public void mouseReleased(MouseEvent e) {

            }

            @Override
            public void mouseEntered(MouseEvent e) {

            }

            @Override
            public void mouseExited(MouseEvent e) {

            }
        });
        jButton2.addMouseListener(new MouseListener() {
            @Override
            public void mouseClicked(MouseEvent e) {

            }

            @Override
            public void mousePressed(MouseEvent e) {

            }

            @Override
            public void mouseReleased(MouseEvent e) {

            }

            @Override
            public void mouseEntered(MouseEvent e) {

            }

            @Override
            public void mouseExited(MouseEvent e) {

            }
        });
        jFrame1.setVisible(true);
    }
}

 这样就有了一个界面的基本框架。

接着做普利姆算法的第一步，

难度一的地图类：（第一步）

import javax.swing.*;
import java.awt.*;
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;
import java.awt.event.KeyEvent;
import java.awt.event.KeyListener;
import java.util.*;
import java.util.List;

public class Build1 extends JPanel implements KeyListener, ActionListener {
    int[] stardustX = new int[600];
    int[] stardustY = new int[500];
    int[] mazeX = new int[600];
    int[] mazeY = new int[500];
    String forward;
    //方格的宽度和长度
    int BLOCK_WIDTH = 70;
    int BLOCK_HEIGHT = 70;
    Random random = new Random();
    HashMap<String, String> hashMap1 = new HashMap<String, String>();
    HashMap<String, String> hashMap2 = new HashMap<String, String>();
    List<String> arraylist =new ArrayList<String>();

    public Build1() {
        for (int i = 0; i < 11; i++) {
            for (int j = 0; j < 11; j++) {
                hashMap1.put(String.valueOf(i) + "," + String.valueOf(j), "灰色0");
            }
        }
        for (int i = 1; i < 11; i = i + 2) {
            for (int j = 1; j < 11; j = j + 2) {
                hashMap1.replace(String.valueOf(i) + "," + String.valueOf(j), "黄色1");
            }
        }
        int x = 2 * random.nextInt(5) + 1;
        int y;
        if (x == 1 || x == 9) {
            y = 2 * random.nextInt(5) + 1;
        } else {
            y = random.nextInt(2);
            if (y == 0) {
                y = 1;
            } else {
                y = 9;
            }
        }
        hashMap1.replace(String.valueOf(x) + "," + String.valueOf(y), "红色1");
        if (x + 1 != 10) {
            hashMap1.replace(String.valueOf(x + 1) + "," + String.valueOf(y), "蓝色0");
            arraylist.add(String.valueOf(x + 1) + "," + String.valueOf(y));
        }
        if (x - 1 != 0) {
            hashMap1.replace(String.valueOf(x - 1) + "," + String.valueOf(y), "蓝色0");
            arraylist.add(String.valueOf(x + 1) + "," + String.valueOf(y));
        }
        if (y + 1 != 10) {
            hashMap1.replace(String.valueOf(x) + "," + String.valueOf(y + 1), "蓝色0");
            arraylist.add(String.valueOf(x + 1) + "," + String.valueOf(y));
        }
        if (y - 1 != 0) {
            hashMap1.replace(String.valueOf(x) + "," + String.valueOf(y - 1), "蓝色0");
            arraylist.add(String.valueOf(x + 1) + "," + String.valueOf(y));
        }
        inti();
        this.setFocusable(true);
        this.addKeyListener(this);
        this.setSize(12 * BLOCK_HEIGHT, 12 * BLOCK_WIDTH);//界面的方格的行数和列数
        this.setLocation(0, 0);
    }

    public void inti() {

    }

    @Override
    protected void paintComponent(Graphics Picture) {
        super.paintComponent(Picture);
        this.setBackground(Color.black);
        Picture.setColor(Color.white);
        for (int i = 0; i < 11; i++) {
            for (int j = 0; j < 11; j++) {
                if (hashMap1.get(String.valueOf(i) + "," + String.valueOf(j)).equals("红色1")) {
                    Picture.setColor(Color.red);
                    Picture.fillRect(i * 70, j * 70, 70, 70);
                }
                if (hashMap1.get(String.valueOf(i) + "," + String.valueOf(j)).equals("黄色1")) {
                    Picture.setColor(Color.yellow);
                    Picture.fillRect(i * 70, j * 70, 70, 70);
                }
                if (hashMap1.get(String.valueOf(i) + "," + String.valueOf(j)).equals("灰色0")) {
                    Picture.setColor(Color.gray);
                    Picture.fillRect(i * 70, j * 70, 70, 70);
                }
                if (hashMap1.get(String.valueOf(i) + "," + String.valueOf(j)).equals("蓝色0")) {
                    Picture.setColor(Color.blue);
                    Picture.fillRect(i * 70, j * 70, 70, 70);
                }
            }
        }
        Picture.setColor(Color.white);
        for (int i = 0; i < 12; i++) {
            Picture.drawLine(0, i * BLOCK_HEIGHT, 12 * BLOCK_WIDTH, i * BLOCK_HEIGHT);
        }
        for (int i = 0; i < 12; i++) {
            Picture.drawLine(i * BLOCK_WIDTH, 0, i * BLOCK_WIDTH, 12 * BLOCK_HEIGHT);
        }
        Picture.setColor(Color.black);
        Picture.fillRect(771, 0, 900, 900);
        Picture.fillRect(0, 771, 900, 900);
    }

    @Override
    public void actionPerformed(ActionEvent e) {

    }

    @Override
    public void keyTyped(KeyEvent e) {

    }

    @Override
    public void keyPressed(KeyEvent e) {

    }

    @Override
    public void keyReleased(KeyEvent e) {

    }
}

 难度一的地图类：（第二步）由第一步做了一些计算的更新

import javax.swing.*;
import java.awt.*;
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;
import java.awt.event.KeyEvent;
import java.awt.event.KeyListener;
import java.util.*;
import java.util.List;

public class Build1 extends JPanel implements KeyListener, ActionListener {
    int[] stardustX = new int[600];
    int[] stardustY = new int[500];
    int[] mazeX = new int[600];
    int[] mazeY = new int[500];
    int fx;
    int fy;
    String forward;
    //方格的宽度和长度
    int BLOCK_WIDTH = 70;
    int BLOCK_HEIGHT = 70;
    Random random = new Random();
    HashMap<String, String> hashMap1 = new HashMap<String, String>();
    HashMap<String, String> hashMap2 = new HashMap<String, String>();
    List<String> arraylist = new ArrayList<String>();

    public Build1() {
        for (int i = 0; i < 11; i++) {
            for (int j = 0; j < 11; j++) {
                hashMap1.put(String.valueOf(i) + "," + String.valueOf(j), "灰色0");
            }
        }
        for (int i = 1; i < 11; i = i + 2) {
            for (int j = 1; j < 11; j = j + 2) {
                hashMap1.replace(String.valueOf(i) + "," + String.valueOf(j), "黄色1");
            }
        }
        fx = 2 * random.nextInt(5) + 1;
        if (fx == 1 || fx == 9) {
            fy = 2 * random.nextInt(5) + 1;
        } else {
            fy = random.nextInt(2);
            if (fy == 0) {
                fy = 1;
            } else {
                fy = 9;
            }
        }
        hashMap1.replace(String.valueOf(fx) + &
最低0.47元/天 解锁文章
JUST192210713125
关注
  • 0
    点赞
  • 踩
  • 4
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
软件实习项目三：基于A*搜索算法迷宫游戏开发
qq_50944418的博客
12-23 429
软件实习项目三：基于A*搜索算法迷宫游戏开发 项目要求 随机生成一个迷宫并且求解迷宫 支持玩家走迷宫和系统走迷宫两种模式：玩家走迷宫，通过键盘方向键控制，并在行走路径上留下痕迹；系统走迷宫要求基于A*算法实现，输出走迷宫的最优路径并显示。 设计交互友好的游戏图形界面。 ...
基于A*算法的迷宫游戏开发
chi_choo的博客
12-22 233
、要求： 1、迷宫随机生成 2、玩家走迷宫，留下足迹； 3、系统用A*算法寻路，输出路径 生成迷宫时采用深度优先算法 整理思路： 在遍历过程中将遍历路径通路（黄色）节点之间的墙“抹掉”—换成空白的格子，即打通为通路，这样就可形成一个完整的迷宫，如上图。这样遍历一次后任意两点之间都可以找到一条路， 所以迷宫的出口和入口只需要从外围的通路节点任选两个即可（如上图中选择的是1旁边的和16旁边的点）。通路以外的格子设为墙。 代码实现（使用M...
基于A*算法的最优路径规划系统
11-28
A*算法是一种求解最短路径的有效方法，也是人工智能算法中一种简单的启发式搜索方法。本文介绍了A* 算法的原理及实现机制， 以及在搜索出的结点解空间集中，用A* 算法如何选择最优结点，最终求解出最短路径的过程。
实验三 基于A*算法的迷宫游戏
OJAC_hzx的博客
11-25 1055
一、实验目的 二、实验器材 三、实验内容 四、实验原理 五、实验步骤 六、实验具体过程 七、实验过程 八、实验结果分析
代码实现项目三：A*迷宫游戏
weixin_45970647的博客
12-28 1413
具体代码 package migong; import java.awt.Color; import java.awt.Font; import java.awt.Graphics; import java.awt.event.KeyEvent; import java.awt.event.KeyListener; import java.awt.event.MouseEvent; import java.awt.event.MouseListener; import java.awt.image.Bu
迷宫问题的A*算法(python实现)
07-05
附件中A_star.py为算法实现，有两个txt文件作为测试样例，mediumMaze是一个封闭的迷宫，openmaze是一个开放的迷宫
A*算法求解迷宫寻路问题（启发式算法）
12-04
入口坐标和出口坐标分别为(startx,starty)和(endx,eny)，每一个坐标点有两种可能：0或1，其中0表示该位置允许通过，1表示该位置不允许通过。以寻路问题为例实现A*算法的求解程序，设计两种不同的估价函数。
基于A*算法的迷宫搜索向心法法则
01-13
针对IEEE标准的电脑鼠走迷宫中向心搜索算法在某些情况下搜索效率不高的问题，采用了一种基于A*算法的改进型向心法法则对传统向心法进行了改进。通过两种算法的对比试验验证，改进型算法转弯46次共74步，传统算法转弯...
基于改进A*算法的机器人路径规划的MATLAB实现
07-07
一种基于环境栅格地图的机器人路径规划方法，包括建模与仿真。基于环境栅格地 图的路径规划及路径优化算法，首先建立...由仿真实验可以看出笔者所述的全覆盖路径规划算法在已知环境信息区域中的遍历是非常有效的。
A*算法求解迷宫寻路问题
11-24
使用A*算法求解迷宫寻路问题，使用python编程，人工智能导论课后实验
A*算法实验报告广工（附源码java）
01-10
对下图所示的迷宫问题，用A*算法为机器人搜索一条路径： 其中(1, 1) 为起始点，(4, 4) 为目标点，启发函数采用曼哈顿距离。
A*算法求解迷宫寻路问题实验
12-16
1.画出用A”算法求解迷宫最短路径的流程图。 2.设置不同的地图,以及不同的初始状态和目标状态,记录A`算法的求解结果,包括最短路径、扩展节点数、生成节点数和算法运行时间。 3.对于相同的初始状态和目标状态,设计...
基于方向约束的A*算法
01-13
实际机器人路径规划问题经常需要考虑路径的转弯约束以及路径起始/目标角要求,为此提出一种基于方向约束的A*算法.新算法区分同一路径点处不同方向的各条路径,通过定向扩展机制来满足路径方向约束,并采用节点合并策略...
基于A*算法的迷宫游戏制作1.0.zip
12-20
可以玩家寻路和系统寻找最优路径，玩家走时会显示走过的路径
基于区域搜索的A*算法在游戏寻径中的应用研究
04-16
寻径是人工智能中的重要组成部分，是游戏开发...本文提出了一种基于区域搜索的A*算法，在提高搜索效能的同时保证了搜索精度，并有效解决了路径曲折问题。实验仿真结果验证了该算法在游戏地图寻径中的有效性和可行性。
基于A* 算法的路径搜索 -《大数据时代的算法》学习笔记
lorna_2011的博客
05-15 649
基于A* 算法的路径搜索 -《大数据时代的算法》学习笔记 1. A* 算法简介 “A* ” 算法擅长解决镜头路径只能够最短路径问题，又不同于Dijkstra算法和Floyd算法。该算法综合了广度优先搜索（BFS）和Dijkstra算法的有点： 在进行启发式搜索提高算法效率的同时，可以保证找到一条最优路径。Floyd算法更多地使用场景在于机器人路径规划、游戏路径、卫星路径探寻等领域。 2....
实验项目三 基于A*搜索算法迷宫游戏开发
qq_45938837的博客
12-15 328
一.实验要求 1.要求随机生成一个迷宫，并求解迷宫。 2.要求游戏支持玩家走迷宫，和系统走迷宫路径两种模式。玩家走迷宫，通过键盘方向键控制,并在行走路径上留下痕迹;系统走迷宫路径要求基于A*算法实现，输出走迷宫的最优路径并显示。 3.设计交互友好的游戏图形界面。 二、迷宫问题大致分析 从起点出发，沿着某一方向前进，如果可以走通，则继续前进，否则原路退回，寻找其他路径。在迷宫中路径的选择方向只有四种，分别是上，下，左，右，我们可以通过键盘进行控制。我们分别用三种颜色对于迷宫中各种对象...
人工智能大作业——A*算法迷宫寻路问题
热门推荐
weixin_46037153的博客
07-05 2万+
项目设计的目的 利用A*算法实现迷宫寻路功能，利用启发式函数的编写以及各类启发式函数效果的比较。 相关原理知识介绍 A*（A-Star)算法是一种静态路网中求解最短路最有效的方法。公式表示为：f(n)=g(n)+h(n)，其中f(n)是节点n从初始点到目标点的估价函数，g(n)是在状态空间中从初始节点到n节点的实际代价，h(n)是从n到目标节点最佳路径的估计代价。保证找到最短路径（最优解的）条件，关键在于估价函数h(n)的选取：估价值h(n)小于等于n到目标节点的距离实际值，这种情况下，搜索的点数多，搜索范
利用A*算法解决迷宫问题(附代码)
汪程序员
03-30 7120
《人工智能》实验报告 实验名称： 利用A*算法解决迷宫问题 班 级： 软件工程191 2022 年 3 月 29 日 先看一下效果： 整体图： 一、问题描述 利用A*算法在迷宫中找到一条最优路径。其中1代表墙，0代表路。出发位置为左上角，终点为右下角。 二、实验目的 学习并实现A*算法，实现使用java语言。 三、实验内容 3.1数据导入 将map.txt中的迷宫地图存入二维数组中。 String filename = in.next();
python给定一个MN的迷宫图，求一条从指定入口到出口的路径使用栈编写代码
最新发布
04-04
假设迷宫图是一个二维数组maze，其中0表示通路，1表示障碍物，起点的坐标是(start_x, start_y)，终点的坐标是(end_x, end_y)，则可以使用深度优先搜索（DFS）和栈来寻找路径。 具体实现步骤如下： 1. 定义一个栈stack，将起点坐标(start_x, start_y)压入栈中。 2. 定义一个二维数组visited，用于记录每个位置是否已经被访问过，初始值为False。 3. 当栈不为空时，取出栈顶元素(x, y)，判断是否为终点，如果是，则返回路径；如果不是，则继续执行下面的步骤。 4. 标记当前位置为已访问，即visited[x][y]=True。 5. 判断当前位置的四个方向是否为通路，如果是，则将该方向的坐标压入栈中。 6. 重复步骤3-5，直到找到终点或栈为空。 7. 如果栈为空仍未找到终点，则返回空列表表示路径不存在。 下面是具体的代码实现： ```python def findPath(maze, start_x, start_y, end_x, end_y): stack = [(start_x, start_y)] # 初始化栈，将起点压入栈中 visited = [[False]*len(maze[0]) for _ in range(len(maze))] # 初始化visited数组 visited[start_x][start_y] = True # 标记起点为已访问 while stack: x, y = stack.pop() # 取出栈顶元素 if x == end_x and y == end_y: # 判断是否为终点 return getPath(start_x, start_y, end_x, end_y, visited) # 返回路径 for dx, dy in [(0, 1), (1, 0), (0, -1), (-1, 0)]: # 遍历四个方向 nx, ny = x+dx, y+dy if 0 <= nx < len(maze) and 0 <= ny < len(maze[0]) and maze[nx][ny] == 0 and not visited[nx][ny]: stack.append((nx, ny)) # 将该方向的坐标压入栈中 visited[nx][ny] = True # 标记该位置为已访问 return [] # 栈为空，表示路径不存在 def getPath(start_x, start_y, end_x, end_y, visited): path = [(end_x, end_y)] while path[-1] != (start_x, start_y): x, y = path[-1] for dx, dy in [(0, 1), (1, 0), (0, -1), (-1, 0)]: nx, ny = x+dx, y+dy if 0 <= nx < len(visited) and 0 <= ny < len(visited[0]) and visited[nx][ny]: path.append((nx, ny)) break return list(reversed(path)) # 返回路径 ``` 使用示例： ```python maze = [[0, 1, 0, 0, 0], [0, 1, 0, 1, 0], [0, 0, 0, 0, 0], [0, 1, 1, 1, 0], [0, 0, 0, 1, 0]] start_x, start_y = 0, 0 end_x, end_y = 4, 4 path = findPath(maze, start_x, start_y, end_x, end_y) print(path) # 输出[(0, 0), (1, 0), (2, 0), (2, 1), (2, 2), (2, 3), (3, 3), (4, 3), (4, 4)] ``` 上述代码中，getPath函数用于从visited数组中获取路径，具体实现是从终点开始，依次向四周扩展，找到第一个已访问的位置，将其加入路径中，并继续向该位置扩展，直到起点为止。最后需要将路径反转，因为是从终点往起点扩展的。

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值