Java编写迷宫小游戏

缘起:

  去年(大三上学期)比较喜欢写小游戏,于是想试着写个迷宫试一下。

程序效果:

按下空格显示路径:

思考过程:

  迷宫由一个一个格子组成,要求从入口到出口只有一条路径.

  想了一下各种数据结构,似乎树是比较合适的,从根节点到每一个子节点都只有一条路径。假设入口是根节点,出口是树中某个子节点,那么,从根节点到该子节点的路径肯定是唯一的。

  所以如果能构造一棵树把所有的格子都覆盖到,也就能够做出一个迷宫了。

  另外还要求树的父节点和子节点必须是界面上相邻的格子。

  在界面显示时,父节点和子节点之间共用的边不画,其他的边都画出来,就能画出一个迷宫。

  之后就是想一下该怎么实现这样一棵树。

  首要的两个问题:

    1、树怎么表示?

    2、怎么构造这棵树?

1.树怎么表示?

  假设像写二叉树一样实现这棵树,那么每个树节点里就要存储一个坐标(X,Y)表示一个格子,另外还要存储四个指针。指针中有的为空,有的不为空,不为空的指针指向子节点,子节点保存邻居格子的坐标。这样做最大的问题是无法判定是否所有的格子都在树中。也许还要用一个二维数组作标志数组。

  假如用二维数组表示迷宫的格子。每个数组元素存储一个指向父节点的引用,这样也可以形成一个虚拟的树。于是就用一个N*N的二维数组,表示N*N个格子,每个数组元素(Lattice)中有一个指向父节点的引用(father)。另外,为了能方便的获取格子的坐标,还要保存坐标信息。

  2.怎么构造这棵树?

  首先选定一个格子作为根节点。为了让迷宫的形状够随机,我选择随机生成一个坐标作为根节点。其实,选择确定的一个坐标也可以。

  然后,怎样往这棵树上增加节点呢?

  在这里我走了不少弯路,一开始想的是一种现在看来类似回溯的算法(当时还不知道回溯算法。。),但是时间复杂度很高,大概当迷宫为64*64的时候,算法就不出结果了。

  然后,又使用了一种扫深度搜索也是回溯描的方法,每次扫描在当前树中找一个节点,看它的邻居格子是否在树中,如果还没在树中,就将该邻居格子加入树中,如果已在树中,就看下一个邻居格子,如果该节点所有邻居格子都在树中了,就找下一个节点,继续同样的操作。另外为了让迷宫生成的随机,扫描的起始位置是随机的就可以了。但是,该方法生成的迷宫中的路径总是不够深,没有我想要的曲折深入的效果。毕竟是类似广度搜索的方法。而且,这样做总还像是靠蛮力,算法不够聪明简洁。

  最后,我终于想到使用深度搜索。。大概是因为数据结构已经学过了一年,又没太练,忘了不少,所以一直没想到这个应该第一想到的方法。。

  随机选择一个格子作为根节点,从它开始随机地深度搜索前进,开出一条路来,直到无路可走了,退回一步,换另一条路,再走到无路可走,回退一步,换另一条……如此循环往复,直到完全无路可走。。。其实也还是回溯。

  在程序里就是以下过程(详见代码中的createMaze()函数):

    随机选择一个格子作为根节点,将它压进栈里。

    然后在栈不为空的时候执行以下循环:

      取出一个格子,将它的INTREE标志设置为1,然后将它的所有不在树中的邻居格子压进栈里(顺序随机),并且让这些邻居格子的father指向该格子。

  解决了这两个问题,其余的画迷宫、显示路径、小球移动也就比较简单了。

代码

package maze;

import java.awt.Color;
import java.awt.Graphics;
import java.awt.event.KeyAdapter;
import java.awt.event.KeyEvent;
import java.util.Random;
import java.util.Stack;
import javax.swing.JFrame;
import javax.swing.JOptionPane;
import javax.swing.JPanel;
class Lattice {
  static final int INTREE = 1;
  static final int NOTINTREE = 0;
  private int x = -1;
  private int y = -1;
  private int flag = NOTINTREE;
  private Lattice father = null;
  public Lattice(int xx, int yy) {
    x = xx;
    y = yy;
  }
  public int getX() {
    return x;
  }
  public int getY() {
    return y;
  }
  public int getFlag() {
    return flag;
  }
  public Lattice getFather() {
    return father;
  }
  public void setFather(Lattice f) {
    father = f;
  }
  public void setFlag(int f) {
    flag = f;
  }
  public String toString() {
    return new String("(" + x + "," + y + ")\n");
  }
}
public class Maze extends JPanel {
  private static final long serialVersionUID = -8300339045454852626L;
  private int NUM, width, padding;// width 每个格子的宽度和高度
  private Lattice[][] maze;
  private int ballX, ballY;
  private boolean drawPath = false;
  Maze(int m, int wi, int p) {
    NUM = m;
    width = wi;
    padding = p;
    maze = new Lattice[NUM][NUM];
    for (int i = 0; i <= NUM - 1; i++)
      for (int j = 0; j <= NUM - 1; j++)
        maze[i][j] = new Lattice(i, j);
    createMaze();
    setKeyListener();
    this.setFocusable(true);
  }
  private void init() {
    for (int i = 0; i <= NUM - 1; i++)
      for (int j = 0; j <= NUM - 1; j++) {
        maze[i][j].setFather(null);
        maze[i][j].setFlag(Lattice.NOTINTREE);
      }
    ballX = 0;
    ballY = 0;
    drawPath = false;
    createMaze();
    // setKeyListener();
    this.setFocusable(true);
    repaint();
  }
  public int getCenterX(int x) {
    return padding + x * width + width / 2;
  }
  public int getCenterY(int y) {
    return padding + y * width + width / 2;
  }

  public int getCenterX(Lattice p) {
    return padding + p.getY() * width + width / 2;
  }
  public int getCenterY(Lattice p) {
    return padding + p.getX() * width + width / 2;
  }
  private void checkIsWin() {
    if (ballX == NUM - 1 && ballY == NUM - 1) {
      JOptionPane.showMessageDialog(null, "YOU WIN !", "你走出了迷宫。",
          JOptionPane.PLAIN_MESSAGE);
      init();
    }
  }
  synchronized private void move(int c) {
    int tx = ballX, ty = ballY;
    // System.out.println(c);
    switch (c) {
      case KeyEvent.VK_LEFT :
        ty--;
        break;
      case KeyEvent.VK_RIGHT :
        ty++;
        break;
      case KeyEvent.VK_UP :
        tx--;
        break;
      case KeyEvent.VK_DOWN :
        tx++;
        break;
      case KeyEvent.VK_SPACE :
        if (drawPath == true) {
          drawPath = false;
        } else {
          drawPath = true;
        }
        break;
      default :
    }
    if (!isOutOfBorder(tx, ty)
        && (maze[tx][ty].getFather() == maze[ballX][ballY]
            || maze[ballX][ballY].getFather() == maze[tx][ty])) {
      ballX = tx;
      ballY = ty;
    }
  }
  private void setKeyListener() {
    this.addKeyListener(new KeyAdapter() {
      public void keyPressed(KeyEvent e) {
        int c = e.getKeyCode();
        move(c);
        repaint();
        checkIsWin();

      }
    });
  }
  private boolean isOutOfBorder(Lattice p) {
    return isOutOfBorder(p.getX(), p.getY());
  }
  private boolean isOutOfBorder(int x, int y) {
    return (x > NUM - 1 || y > NUM - 1 || x < 0 || y < 0) ? true : false;
  }
  private Lattice[] getNeis(Lattice p) {
    final int[] adds = {-1, 0, 1, 0, -1};// 顺序为上右下左
    if (isOutOfBorder(p)) {
      return null;
    }
    Lattice[] ps = new Lattice[4];// 顺序为上右下左
    int xt;
    int yt;
    for (int i = 0; i <= 3; i++) {
      xt = p.getX() + adds[i];
      yt = p.getY() + adds[i + 1];
      if (isOutOfBorder(xt, yt))
        continue;
      ps[i] = maze[xt][yt];
    }
    return ps;
  }
  private void createMaze() {
    Random random = new Random();
    int rx = Math.abs(random.nextInt()) % NUM;
    int ry = Math.abs(random.nextInt()) % NUM;
    Stack<Lattice> s = new Stack<Lattice>();
    Lattice p = maze[rx][ry];
    Lattice neis[] = null;
    s.push(p);
    while (!s.isEmpty()) {
      p = s.pop();
      p.setFlag(Lattice.INTREE);
      neis = getNeis(p);
      int ran = Math.abs(random.nextInt()) % 4;
      for (int a = 0; a <= 3; a++) {
        ran++;
        ran %= 4;
        if (neis[ran] == null || neis[ran].getFlag() == Lattice.INTREE)
          continue;
        s.push(neis[ran]);
        neis[ran].setFather(p);
      }
    }
    // changeFather(maze[0][0],null);
  }
  private void changeFather(Lattice p, Lattice f) {
    if (p.getFather() == null) {
      p.setFather(f);
      return;
    } else {
      changeFather(p.getFather(), p);
    }
  }
  private void clearFence(int i, int j, int fx, int fy, Graphics g) {
    int sx = padding + ((j > fy ? j : fy) * width),
        sy = padding + ((i > fx ? i : fx) * width),
        dx = (i == fx ? sx : sx + width),
        dy = (i == fx ? sy + width : sy);
    if (sx != dx) {
      sx++;
      dx--;
    } else {
      sy++;
      dy--;
    }
    g.drawLine(sx, sy, dx, dy);
  }
  protected void paintComponent(Graphics g) {
    super.paintComponent(g);
    for (int i = 0; i <= NUM; i++) {
      g.drawLine(padding + i * width, padding, padding + i * width,
          padding + NUM * width);
    }
    for (int j = 0; j <= NUM; j++) {
      g.drawLine(padding, padding + j * width, padding + NUM * width,
          padding + j * width);
    }
    g.setColor(this.getBackground());
    for (int i = NUM - 1; i >= 0; i--) {
      for (int j = NUM - 1; j >= 0; j--) {
        Lattice f = maze[i][j].getFather();
        if (f != null) {
          int fx = f.getX(), fy = f.getY();
          clearFence(i, j, fx, fy, g);
        }
      }
    }
    g.drawLine(padding, padding + 1, padding, padding + width - 1);
    int last = padding + NUM * width;
    g.drawLine(last, last - 1, last, last - width + 1);
    g.setColor(Color.RED);
    g.fillOval(getCenterX(ballY) - width / 3, getCenterY(ballX) - width / 3,
        width / 2, width / 2);
    if (drawPath == true)
      drawPath(g);
  }
  private void drawPath(Graphics g) {
    Color PATH_COLOR = Color.ORANGE, BOTH_PATH_COLOR = Color.PINK;
    if (drawPath == true)
      g.setColor(PATH_COLOR);
    else
      g.setColor(this.getBackground());
    Lattice p = maze[NUM - 1][NUM - 1];
    while (p.getFather() != null) {
      p.setFlag(2);
      p = p.getFather();
    }
    g.fillOval(getCenterX(p) - width / 3, getCenterY(p) - width / 3,
        width / 2, width / 2);
    p = maze[0][0];
    while (p.getFather() != null) {
      if (p.getFlag() == 2) {
        p.setFlag(3);
        g.setColor(BOTH_PATH_COLOR);
      }
      g.drawLine(getCenterX(p), getCenterY(p), getCenterX(p.getFather()),
          getCenterY(p.getFather()));
      p = p.getFather();
    }
    g.setColor(PATH_COLOR);
    p = maze[NUM - 1][NUM - 1];
    while (p.getFather() != null) {
      if (p.getFlag() == 3)
        break;
      g.drawLine(getCenterX(p), getCenterY(p), getCenterX(p.getFather()),
          getCenterY(p.getFather()));
      p = p.getFather();
    }
  }
  public static void main(String[] args) {
    final int n = 30, width = 600, padding = 20, LX = 200, LY = 100;
    JPanel p = new Maze(n, (width - padding - padding) / n, padding);
    JFrame frame = new JFrame("MAZE(按空格键显示或隐藏路径)");
    frame.getContentPane().add(p);
    frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
    frame.setSize(width + padding, width + padding + padding);
    frame.setLocation(LX, LY);
    frame.setVisible(true);
  }
}
时间: 2016-05-06

Java版坦克大战游戏源码示例

整理文档,搜刮出一个Java版坦克大战游戏的代码,稍微整理精简一下做下分享. package tankwar; import java.awt.Color; import java.awt.Font; import java.awt.Graphics; import java.awt.event.KeyEvent; import java.awt.event.KeyListener; import java.io.File; import java.io.FileInputStream; imp

java 简单的计算器程序实例代码

java 简单的计算器程序 实现实例: import java.awt.*; import java.awt.event.*; import javax.swing.*; public class Calculator { public static void main(String[] args) { EventQueue.invokeLater(new Runnable() { public void run() { CalculatorFrame frame = new Calculato

Java计算一个数加上100是完全平方数,加上168还是完全平方数

题目:一个整数,它加上100后是一个完全平方数,加上168又是一个完全平方数,请问该数是多少? 程序分析:在10万以内判断,先将该数加上100后再开方,再将该数加上268后再开方,如果开方后的结果满足如下条件,即是结果.请看具体分析: 程序设计: public class test { public static void main (String[]args){ long k=0; for(k=1;k<=100000l;k++) if(Math.floor(Math.sqrt(k+100))=

Java使用Math.random()结合蒙特卡洛方法计算pi值示例

本文实例讲述了Java使用Math.random()结合蒙特卡洛方法计算pi值.分享给大家供大家参考,具体如下: 一.概述 蒙特·卡罗方法(Monte Carlo method),也称统计模拟方法,是二十世纪四十年代中期由于科学技术的发展和电子计算机的发明,而被提出的一种以概率统计理论为指导的一类非常重要的数值计算方法.是指使用随机数(或更常见的伪随机数)来解决很多计算问题的方法.与它对应的是确定性算法. 详细可参考百度百科:https://baike.baidu.com/item/%E8%92

利用java、js或mysql计算高德地图中两坐标之间的距离

前言 因为工作的原因,最近在做与地图相关的应用,使用了高德地图,研究了下高德地图计算两坐标距离的方法,官网上提供的开发包中有相关的方法,但是我的产品中比较特殊,无法直接使用提供的方法,所以就自己封装了相关计算方法,供大家参考,下面话不多说了,来一起看看详细的介绍吧. Java实现 首先定义一个用于存储经纬度的类,这里起个名字叫:LngLat package amap; import java.text.DecimalFormat; import java.text.DecimalFormatSy

Java编程实现游戏中的简单碰撞检测功能示例

本文实例讲述了Java编程中的简单碰撞检测功能.分享给大家供大家参考,具体如下: 今天在家正在写一个坦克大战的小游戏来玩,遇到了一个简单的圆和圆的碰撞检测的小问题, 碰撞检测的过程处理主要有以下三步: 1.碰撞检测(Collision Detection):返回两个或多个物体是否发生碰撞的布尔判断. 2.碰撞确定(Collision Determination):找到物体之间实际相交位置. 3.碰撞响应(Collision Response):针对两个物体之间的碰撞决定采取何种操作. 下面是关于

java中的数学计算函数的总结

java中的数学计算函数 Math类: java.lang.Math类中包含基本的数字操作,如指数.对数.平方根和三角函数. java.math是一个包,提供用于执行任意精度整数(BigInteger)算法和任意精度小数(BigDecimal)算法的类. java.lang.Math类中包含E和PI两个静态常量,以及进行科学计算的类(static)方法,可以直接通过类名调用. public static final Double E = 2.7182818284590452354 public

java贪吃蛇游戏编写代码

本文实例为大家分享了java贪吃蛇游戏展示的具体代码,供大家参考,具体内容如下 1.采用MVC(model.view.control)框架模式 2.包和类的关系树形图为: 3.源码: package com.huai; import Java.awt.Color; import java.awt.Graphics; import java.awt.Point; import java.util.HashSet; import java.util.LinkedList; import java.u

用Java实现小球碰壁反弹的简单实例(算法十分简单)

核心代码如下: if(addX){ x+=3; }else{ x-=3; } if(addY){ y+=6; }else{ y-=6; } if(x<=0||x>=(width-50)){ addX=!addX; } if(y<=0||y>=(height-50)){ addY=!addY; } 根据x和y递增的值,来决定角度. 以上这篇用Java实现小球碰壁反弹的简单实例(算法十分简单)就是小编分享给大家的全部内容了,希望能给大家一个参考,也希望大家多多支持我们.

java计算两个日期之前的天数实例(排除节假日和周末)

如题所说,计算两个日期之前的天数,排除节假日和周末.这里天数的类型为double,因为该功能实现的是请假天数的计算,有请一上午假的为0.5天. 不够很坑的是每个日期都要查询数据库,感觉很浪费时间. 原则: 1.节假日存放在数据库中 实现步骤: 1.循环每个日期 2.判断每个日期是否为节假日或者为周末 3.若不是节假日和周末,天数+1 代码: public double calLeaveDays(Date startTime,Date endTime){ double leaveDays = 0;

java计算两个日期中间的时间

java计算两个日期中间的时间 其中在数据库中有一个字段为datetime类型,想要计算两个日期之间过了多少天 多少小时 多少分钟. 思路为把时间换算为毫秒(与协调世界时 1970 年 1 月 1 日午夜之间的时间差(以毫秒为单位测量).然后利用毫秒的加减计算. 计算如下: public static String getDays(Date date){ Calendar cal=Calendar.getInstance(); cal.setTime(date); long oldTime=ca

用javascript实现计算两个日期的间隔天数

ASP 里面计算两个时间的差距可以 DateDiff,但 javascript 里面没有,需要手写函数. js 里面居然可以直接 Date1-Date2,而且还是转换为毫秒计算时间差的. 复制代码 代码如下: // 计算两个日期的间隔天数  function DateDiff(sDate1, sDate2){ //sDate1和sDate2是2002-12-18格式   var aDate, oDate1, oDate2, iDays   aDate = sDate1.split("-"

Java编程实现计算两个日期的月份差实例代码

本文实例主要实现计算两个日期的月份差,具体如下: package com.forezp.util; import org.joda.time.DateTime; import org.joda.time.Months; import org.joda.time.format.DateTimeFormat; import org.joda.time.format.DateTimeFormatter; /** * 在JAVA中,如何计算两个日期的月份差?<br> * * * @author Adm

MySQL计算两个日期相差的天数、月数、年数

MySQL自带的日期函数TIMESTAMPDIFF计算两个日期相差的秒数.分钟数.小时数.天数.周数.季度数.月数.年数,当前日期增加或者减少一天.一周等等. SELECT TIMESTAMPDIFF(类型,开始时间,结束时间) 相差的秒数: SELECT TIMESTAMPDIFF(SECOND,'1993-03-23 00:00:00',DATE_FORMAT(NOW(), '%Y-%m-%d %H:%i:%S')) 相差的分钟数: SELECT TIMESTAMPDIFF(MINUTE,'

利用Java中Calendar计算两个日期之间的天数和周数

前言 究竟什么是一个 Calendar 呢?中文的翻译就是日历,那我们立刻可以想到我们生活中有阳(公)历.阴(农)历之分.它们的区别在哪呢? 比如有: 月份的定义 - 阳`(公)历 一年12 个月,每个月的天数各不同:阴(农)历,每个月固定28天 每周的第一天 - 阳(公)历星期日是第一天:阴(农)历,星期一是第一天 实际上,在历史上有着许多种纪元的方法.它们的差异实在太大了,比如说一个人的生日是"八月八日" 那么一种可能是阳(公)历的八月八日,但也可以是阴(农)历的日期.所以为了计时

JAVA计算两个日期相差的实例

在Java开发物流或是其他功能的时候会用到两个日期 相差多天的数据,所以整理了一下备用.调用方式: 复制代码 代码如下: long date1 = getDateTime("20121201");//可改成自己的日期类型,但以 "20121212"这种格式 long date2 = getDateTime("20121212");   int day = dateInterval(date1, date2);   System.out.print

Java计算两个日期时间之间的天数最简方法

有一种low的方式,就是你把两个时间都换成秒,然后除以一天的秒数,然后向上取整,就是算的天数.但是这么实现太low啦. jdk有高级的API,我们为啥还要自己去实现呢,问题就是我们不知道. 所以,我在这写个笔记,记录下,jdk 1.8 是怎么做的. /** * 计算两个时间点之间的天数 */ private static void getBetweenDay() { LocalDate start = LocalDate.of(2018, 2, 12); LocalDate now = Loca

javaScript 计算两个日期的天数相差(示例代码)

一:计算两个日期相差的天数 比如:   str1  =  "2002-01-20"   str2  =  "2002-10-11"  怎样用javaScript计算出str1与str2之间相差的天数?  复制代码 代码如下: <html>  <head>  <meta  http-equiv="Content-Type"  content="text/html;  charset=gb2312"&

Android编程实现计算两个日期之间天数并打印所有日期的方法

本文实例讲述了Android编程实现计算两个日期之间天数并打印所有日期的方法.分享给大家供大家参考,具体如下: 以下代码是计算两个日期之间的天数,并打印所有日期 注:开始时,增加天数时,一天的毫秒数直接用24*60*60*1000来逐步增加天数,再测试时发现,当两个日期之间的天数超过24天时,打印的日期反而在开始日期之前了,(如打印2016/12/18-2017/1/23,打印的日期反而有2016/12/1),后来发现原因在于24*60*60*1000是一个int值,int值的取值范围在2的31