计算机软件实习

迷宫游戏开发

本次实验要求能随机生成一个迷宫，并且可以通过控制人物上下左右行走来通过迷宫；
实验还要求显示出最短路径。

随机生成迷宫

这里我采用的是深度优先搜索算法（DFS）

首先，将所有的点初始化为墙，然后随机生成蝴蝶的位置，再将相应点修改成蝴蝶，终点的位置修改好；然后，从蝴蝶位置出发，利用深度优先遍历算法，通过随机遍历方向，将所有与蝴蝶位置X、Y坐标差值均为偶数的点遍历出来，并修改成路，最终连接成一条能联通所有这些点的通道。在此过程中，当我们需要由一个点连接到下一个点时，仅需要打通隔开它们的那堵墙（将它修改成路）即可。

代码：

//深度优先遍历创建迷宫
    public static void creatMaze() {
        m = map.m;
        n = map.n;
        //遍历前初始化工作
        isBeVisit = new boolean[m * n];
        for (int i = 0; i < m * n; i++) isBeVisit[i] = false;      //是否已被访问

        //迷宫初始化
        for (int i = 0; i < m; i++) {                  //防止发生两边上全为墙的情况
            map.tp[i][0].change(Math.random() * 3 > 1 ? 0 : 1);
            map.tp[i][n - 1].change(Math.random() * 3 > 1 ? 0 : 1);
        }
        for (int i = 0; i < n; i++) {
            map.tp[0][i].change(Math.random() * 3 > 1 ? 0 : 1);
            map.tp[m - 1][i].change(Math.random() * 3 > 1 ? 0 : 1);
        }
        for (int i = 1; i < m - 1; i++)
            for (int j = 1; j < n - 1; j++)
                map.tp[i][j].change(0);  //内部的位置初始化全为墙

        m_startx = (int) (Math.random() * m / 2);
        m_starty = (int) (Math.random() * n / 2);    //随机生成蝴蝶位置

        //******************从蝴蝶位置开始深度优先遍历与它x 、y坐标相差均为偶数的点构成的图
        DFS(m_startx * n + m_starty);

        //*******************     这一步在 tp[m-2][n-2]与蝴蝶位置x 、y坐标相差均为偶数时非常重要，保证有到达粮仓的路径
        if (Math.random() * 2 > 1)
            map.tp[m - 2][n - 1].change(1);
        else
            map.tp[m - 1][n - 2].change(1);    //两者只要有一个为路即可，故随机取其一

        //蝴蝶和钻石的位置作另作处理
        map.tp[m_startx][m_starty].change(2);  //蝴蝶的位置是随机的
        map.tp[m - 1][n - 1].change(3);            //固定钻石位置为右下角

        changeable_key = false;  //键盘不可控制蝴蝶移动
        m_currex = m_startx;
        m_currey = m_starty;  //开始新游戏前蝴蝶当前位置与开始位置相等
        restart = false;
    }

    //****************从S点开始深度优先遍历与它x 、y坐标相差均为偶数的点构成的图，并打通每一步需要通过的墙
    public static void DFS(int s) {
        map.tp[s / n][s % n].change(1);
        isBeVisit[s] = true;

        int[] direction = new int[4];              //用于以随机顺序存储方向   右0下1左2上3
        boolean[] isStored = new boolean[4];
        for (int i = 0; i < 4; i++) isStored[i] = false;    //方向是否已被存储
        int currex = s / n, currey = s % n;                 //当前点对应的实际坐标

        //按随机顺序存储方向
        int rand, length = 0;      //随机数 用于产生随机顺序 ，length表示已存储方向的个数
        while (length < 4) {
            rand = (int) (Math.random() * 4);    //0~3
            if (!isStored[rand]) {
                direction[length++] = rand;
                isStored[rand] = true;            //修改为true，防止重复存储
            }
        }
        for (int i = 0; i < 4; i++) {
            switch (direction[i]) {
                case 0:
                    if (currey + 2 < n) {                             //右
                        if (!isBeVisit[s + 2]) {
                            map.tp[currex][currey + 1].change(1); //打通[currex][currey]与[currex][currey+2]之间的墙，下同
                            DFS(s + 2);
                        }
                    }
                    break;
                case 1:
                    if (currex + 2 < m) {                              //下
                        if (!isBeVisit[s + 2 * n]) {
                            map.tp[currex + 1][currey].change(1);
                            DFS(s + 2 * n);
                        }
                    }
                    break;
                case 2:                                               //左
                    if (currey - 2 >= 0) {
                        if (!isBeVisit[s - 2]) {
                            map.tp[currex][currey - 1].change(1);
                            DFS(s - 2);
                        }
                    }
                    break;
                case 3:                                            //上
                    if (currex - 2 >= 0) {
                        if (!isBeVisit[s - 2 * n]) {
                            map.tp[currex - 1][currey].change(1);
                            DFS(s - 2 * n);
                        }
                    }
                    break;
            }
        }
    }

显示最短路径

先用深度优先搜索查找路径，然后再用最短路径深度图显示最短路径
有两个概念：
路径深度: 从某位置走到出口的最短路径的长度，设每一方块为单位路径长度。
假定出口处路径深度为0 , 障碍处路径深度为 - 1 。
路径深度图: 与迷宫对应的图, 每一个节点值为与该节点对应的迷宫单元格的路径深度

代码：

    //***************迷宫最短路径深度图算法

    public static void sortestPath() {
        changeable_key = false;   //不可用键盘控制蝴蝶

        m = map.m;
        n = map.n;
        int max = m * n;                 //任意一点到钻石的最短路径长度不会超出m*n。
        int[] depthGraph = new int[m * n];     //路径深度图

        //路径深度图初始化
        depthGraph[m * n - 1] = 0;                //钻石到自己的距离自然是0
        for (int i = 0; i < m * n - 1; i++) {
            if (map.tp[i / n][i % n].isWall())
                depthGraph[i] = -1;           //墙表示为-1，表示无通路
            else
                depthGraph[i] = max;           //未确定距离时已max表示
        }


        boolean flag = true;             //循环过程中是否有某点的路径深度被修改
        int currex, currey;               //记录当前访问点的坐标
        int aroundmin;                   //周围可行方向的 最小路径深度 + 1

        //动态更新路径深度图直至其达到稳态（即最后一次循环过程中不再有路径深度被修改）
        while (flag) {
            flag = false;
            for (int s = m * n - 1; s >= 0; s--) {
                if (depthGraph[s] != -1) {
                    aroundmin = depthGraph[s];
                    currex = s / n;
                    currey = s % n;
                    if (currey + 1 < n && depthGraph[s + 1] != -1 && depthGraph[s + 1] + 1 < aroundmin)
                        aroundmin = depthGraph[s + 1] + 1;
                    if (currex + 1 < m && depthGraph[s + n] != -1 && depthGraph[s + n] + 1 < aroundmin)
                        aroundmin = depthGraph[s + n] + 1;
                    if (currey - 1 >= 0 && depthGraph[s - 1] != -1 && depthGraph[s - 1] + 1 < aroundmin)
                        aroundmin = depthGraph[s - 1] + 1;
                    if (currex - 1 >= 0 && depthGraph[s - n] != -1 && depthGraph[s - n] + 1 < aroundmin)
                        aroundmin = depthGraph[s - n] + 1;
                    if (aroundmin < depthGraph[s]) {
                        depthGraph[s] = aroundmin;
                        flag = true;
                    }

                }
            }
        }

        //利用已生成的路径深度图，找到从蝴蝶到钻石之间的最短路径
        int[] path = new int[m * n];                    //用于存放最短路径的数组
        int currePoint = m_startx * n + m_starty;         //当前访问点,初始值为蝴蝶位置
        int depth = depthGraph[currePoint];         //蝴蝶位置的路径深度值
        int step = depth - 1;                     //当前要查找的路径深度
        while (step > 0) {
            currex = currePoint / n;
            currey = currePoint % n;
            if (currey + 1 < n && depthGraph[currePoint + 1] == step) {
                currePoint += 1;
            } else if (currex + 1 < m && depthGraph[currePoint + n] == step) {
                currePoint += n;
            } else if (currey - 1 >= 0 && depthGraph[currePoint - 1] == step) {
                currePoint -= 1;
            } else if (currex - 1 >= 0 && depthGraph[currePoint - n] == step) {
                currePoint -= n;
            }
            path[step--] = currePoint;
        }
        int s;         //临时存放位置
        for (int i = 1; i < depth; i++) {
            s = path[i];
            map.tp[s / n][s % n].change(2);   //显示最短路径
        }

        restart = true;                //可开始新游戏

    }


    //****************深度优先搜索
    public static void findPath() {

        changeable_key = false;   //不可用键盘控制蝴蝶

        m = map.m;
        n = map.n;
        int currex = m_startx, currey = m_starty;
        int direction = 0;
        int distance;
        int[] point = new int[m * n];
        boolean[] isBeVisit = new boolean[m * n];
        for (int i = 0; i < m * n - 1; i++) isBeVisit[i] = false;
        int step = 0;
        point[step] = currex * n + currey;
        step++;
        for (; ; ) {
            if (currex == m - 1 && currey == n - 1) {      //已找到钻石
                for (int i = 1; i < step - 1; i++)         //step-1对应钻石，不再重画。
                    map.tp[point[i] / n][point[i] % n].change(2);
                restart = true;                //可开始新游戏
                return;
            }
            switch (direction) {       //按右0下1左2上3的优先顺序遍历
                case 0:
                    if (currey + 1 < n && !map.tp[currex][currey + 1].isWall() && !isBeVisit[currex * n + currey + 1]) {
                        point[step] = currex * n + currey + 1;
                        isBeVisit[currex * n + currey + 1] = true;
                        currey++;
                        step++;
                        direction = 0;

                    } else direction++;
                    break;
                case 1:
                    if (currex + 1 < m && !map.tp[currex + 1][currey].isWall() && !isBeVisit[(currex + 1) * n + currey]) {
                        point[step] = (currex + 1) * n + currey;
                        isBeVisit[(currex + 1) * n + currey] = true;
                        currex++;
                        step++;
                        direction = 0;

                    } else direction++;
                    break;
                case 2:
                    if (currey - 1 >= 0 && !map.tp[currex][currey - 1].isWall() && !isBeVisit[currex * n + currey - 1]) {
                        point[step] = currex * n + currey - 1;
                        isBeVisit[currex * n + currey - 1] = true;
                        currey--;
                        step++;
                        direction = 0;
                    } else direction++;
                    break;
                case 3:
                    if (currex - 1 >= 0 && !map.tp[currex - 1][currey].isWall() && !isBeVisit[(currex - 1) * n + currey]) {
                        point[step] = (currex - 1) * n + currey;
                        isBeVisit[(currex - 1) * n + currey] = true;
                        currex--;
                        step++;
                        direction = 0;
                    } else direction++;
                    break;
                default:              //此路不通，后退一步查看下一方向
                    step--;
                    isBeVisit[point[step]] = false;
                    if (step <= 0) {
                        JOptionPane.showMessageDialog(null, "抱歉，该迷宫没有通路，请使用其它迷宫开始新的游戏。", "该迷宫没有通路！", JOptionPane.ERROR_MESSAGE);
                        restart = true;
                        return;
                    }

                    distance = point[step] - point[step - 1];
                    if (distance == 1) {        //在上一步的右方向（0），则返回上一步时 再找下一个方向 direction=1   下同
                        currex = point[step - 1] / n;
                        currey = point[step - 1] % n;
                        direction = 1;
                    } else if (distance == n) {
                        currex = point[step - 1] / n;
                        currey = point[step - 1] % n;
                        direction = 2;
                    } else if (distance == -1) {
                        currex = point[step - 1] / n;
                        currey = point[step - 1] % n;
                        direction = 3;
                    } else {
                        direction = 4;       //继续后退
                    }
            }
        }
    }

这就是两个核心算法啦

开始界面的设计

开始界面我设计了2X2四个方块，分别代表四种不同的迷宫样式：25X25,35X35,45X45，还有“？”代表可以自定义

代码：

package maze4;
//程序开始界面

import java.awt.*;
import java.awt.event.*;

import javax.swing.*;


public class StartUI extends JFrame implements ActionListener {
  private ImageIcon start1 = new ImageIcon("./start1.jpg");
  private ImageIcon start2 = new ImageIcon("./start2.jpg");
  private ImageIcon start3 = new ImageIcon("./start3.jpg");
  private ImageIcon start4 = new ImageIcon("./start4.jpg");
  private JButton button1 = new JButton(start1);
  private JButton button2 = new JButton(start2);
  private JButton button3 = new JButton(start3);
  private JButton button4 = new JButton(start4);


  StartUI() {

      //将选择按钮包含在选择面板上
      JPanel choose = new JPanel();
      choose.setLayout(new GridLayout(2, 2));
      choose.add(button1);
      choose.add(button2);
      choose.add(button3);
      choose.add(button4);

      //注册监听器
      button1.addActionListener(this);
      button2.addActionListener(this);
      button3.addActionListener(this);
      button4.addActionListener(this);

      //提示信息
      JPanel message = new JPanel() {   //匿名内部类
          protected void paintComponent(Graphics g) {
              setSize(200, 300);
              g.drawString("请选择场地大小", 100, 35);
          }
      };

      //主界面布局
      setLayout(new BorderLayout(120, 40));
      add(choose, BorderLayout.CENTER);
      add(message, BorderLayout.NORTH);
      add(new JPanel(), BorderLayout.EAST);
      add(new JPanel(), BorderLayout.WEST);
      add(new JPanel(), BorderLayout.SOUTH);

      //基本设置
      setTitle("迷宫游戏之酒醉的蝴蝶");
      setSize(800, 600);
      setLocationRelativeTo(null);
      setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
      setVisible(true);
      setResizable(false);
  }

  public static void main(String[] args) {
      new StartUI();
  }

  //按钮事件处理
  public void actionPerformed(ActionEvent e) {
      if (e.getSource() == button1) {
          dispose(); // setVisible(false);
          new map(18, 18);
      } else if (e.getSource() == button2) {
          dispose();  //setVisible(false);
          new map(25, 25);
      } else if (e.getSource() == button3) {
          dispose();  //setVisible(false);
          new map(40, 40);
      } else {
          getData();
      }
  }

  public void getData() {
      int m = 0, n = 0;
      String crowString;
      try {
          crowString = JOptionPane.showInputDialog("请输入自定义的行数（>5）");
          m = Integer.parseInt(crowString);
          crowString = JOptionPane.showInputDialog("请输入自定义的列数（>5）");
          n = Integer.parseInt(crowString);
          if (m <= 5 || n <= 5) throw new Exception();
          else {
              dispose();  //setVisible(false);
              new map(m, n);
          }
      } catch (Exception e) {
          JOptionPane.showMessageDialog(null, "由于用户取消或输入不符合要求等原因，未正常创建迷宫。", "未创建迷宫！", JOptionPane.ERROR_MESSAGE);
      }

  }

}

运行后就是这个样子：

迷宫界面

迷宫界面就是点击开始界面后的游戏界面，可以添加一些按钮，及按钮的事件。

代码：

package maze4;

//迷宫界面


import java.awt.*;
import java.awt.event.*;
import java.io.File;
import java.io.RandomAccessFile;

import javax.swing.*;

public class map extends JFrame implements ActionListener, KeyListener {
  static int m, n;
  static wrmPane[] [] tp = null;        //显示动画,同一包内类均可访问

  // 菜单项
  private JMenuItem m_start = new JMenuItem("开始新游戏");
  private JMenuItem m_return = new JMenuItem("返回主界面");
  private JMenuItem m_exit = new JMenuItem("退出游戏");
  private JMenuItem m_sortpath = new JMenuItem("显示最短路径");
  private JMenuItem m_help = new JMenuItem("游戏使用说明");
  map(int x, int y) {
      m = x;
      n = y;
      tp = new wrmPane[m][n];

      //菜单
      JMenu game = new JMenu("游戏");
      JMenu tip = new JMenu("提示");
      JMenu help = new JMenu("帮助");
      game.add(m_start);
      game.add(m_return);
      game.add(m_exit);
      tip.add(m_sortpath);
      help.add(m_help);

      //菜单栏
      JMenuBar menu = new JMenuBar();
      menu.add(game);
      menu.add(tip);
      menu.add(help);

      //初始化迷宫组件,并生成随机路径
      for (int i = 0; i < m; i++)
          for (int j = 0; j < n; j++) {
              tp[i][j] = new wrmPane();
          }
      Operations.creatMaze();  //深度优先遍历生成至少有一条随机通道的迷宫

      //迷宫地图
      JPanel mazePane = new JPanel();
      mazePane.setLayout(new GridLayout(m, n, 0, 0));
      for (int i = 0; i < m; i++) {
          for (int j = 0; j < n; j++) {
              mazePane.add(tp[i][j]);
          }
      }
      JPanel northPanel = new JPanel();
      northPanel.setLayout(new GridLayout(1, 1));
      northPanel.add(menu);
      menu.setBackground(new Color(245, 240, 245));

      //添加到框架
      setLayout(new BorderLayout());
      add(northPanel, BorderLayout.NORTH);
      add(mazePane, BorderLayout.CENTER);
      add(new JPanel(), BorderLayout.SOUTH);

      //注册监听器
      m_start.addActionListener(this);
      m_return.addActionListener(this);
      m_exit.addActionListener(this);
      m_sortpath.addActionListener(this);
      m_help.addActionListener(this);
      addKeyListener(this);

      //基本设置
      setTitle("迷宫游戏之酒醉的蝴蝶");
      setSize(850, 650);
      setLocationRelativeTo(null);
      setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
      setVisible(true);
      setResizable(false);

  }

  map() {
      this(25, 25);
  }


  //菜单事件处理
  public void actionPerformed(ActionEvent e) {
      if (e.getSource() == m_start) {
          Operations.start();
      } else if (e.getSource() == m_return) {
          dispose(); //关闭当前窗口
          new StartUI();
      } else if (e.getSource() == m_exit) {
          System.exit(0);
      } else if (e.getSource() == m_help) {
          Operations.showHelp();
      } else if (e.getSource() == m_sortpath) {
          Operations.sortestPath();
      }

  }

  //键盘事件处理
  public void keyTyped(KeyEvent e) {
  }

  public void keyReleased(KeyEvent e) {
  }

  public void keyPressed(KeyEvent e) {
      switch (e.getKeyCode()) {
          case KeyEvent.VK_DOWN:
              Operations.down();
              break;
          case KeyEvent.VK_UP:
              Operations.up();
              break;
          case KeyEvent.VK_LEFT:
              Operations.left();
              break;
          case KeyEvent.VK_RIGHT:
              Operations.right();
              break;
      }

  }
}

显示面板

显示面板用来显示图片还有鼠标的事件处理

代码：

package maze4;
//显示面板


import java.awt.*;
import java.awt.event.*;
import javax.swing.*;

public class wrmPane extends JPanel implements MouseListener {
  private boolean changeable_click;
  private int flag;  //标志 0：花丛 1：路 2：蝴蝶 3：钻石
  private Image flower = new ImageIcon("./flower1.gif").getImage();        //花丛
  private Image road = new ImageIcon("./road.gif").getImage();        //路
  private Image butterfly = new ImageIcon("./butterfly.gif").getImage();      //蝴蝶
  private Image dimon = new ImageIcon("./dimon.gif").getImage();   //钻石

  wrmPane(int f) {
      flag = f;
      changeable_click = false;    //初始化时不能通过鼠标点击改变 flag 的值
      addMouseListener(this);
  }

  wrmPane() {
      this(0);
  }

  //重写paintComponent方法，画图
  public void paintComponent(Graphics g) {
      super.paintComponent(g);
      if (flag == 0)
          g.drawImage(flower, 0, 0, getWidth(), getHeight(), this);
      else if (flag == 1)
          g.drawImage(road, 0, 0, getWidth(), getHeight(), this);
      else if (flag == 2)
          g.drawImage(butterfly, 0, 0, getWidth(), getHeight(), this);
      else
          g.drawImage(dimon, 0, 0, getWidth(), getHeight(), this);
  }

  //访问器
  public int getFlag() {
      return flag;
  }

  //是否为墙
  public boolean isWall() {
      return flag == 0;
  }
  
//修改标志并重画面板
  public void change(int f) {
      flag = f;
      repaint();
  }

  //鼠标事件处理
  public void mouseEntered(MouseEvent e) {
  }

  public void mouseExited(MouseEvent e) {
  }

  public void mousePressed(MouseEvent e) {
  }

  public void mouseReleased(MouseEvent e) {
  }
  public void mouseClicked(MouseEvent e) {
      if (!changeable_click) return;
      if (flag == 0) {
          flag = 1;
          repaint();
      } else {
          flag = 0;
          repaint();
      }
  }
}

运行界面

可以显示最短路径

实验总结

迷宫设计的关键就是创建迷宫和显示最短路径两个算法，但是好像使用A算法显示最短路径比较简便。
尽量有时间再看看用A算法怎么写。