mazegame.java

一个迷宫游戏的java源代码,内有随机生成迷宫算法,解答迷宫算法

//在安装了jdk的情况下,有以下两种方式运行:

//1.打开开发软件,新建一个类文件名为MazeGame.java,然后把源程序全部复制过去再编译运行即可

//2.可用命令行直接执行字节码文件MazeGame.class

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

/**
 * 一个2D迷宫游戏.
 * 
 * @author 山
 * 
 */
public class MazeGame {// 主方法
	public static void main(String[] args) {
		JFrame frame = new JFrame("迷宫游戏");
		frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);

		frame.getContentPane().add(new MazeGamePanel());

		frame.pack();
		frame.setVisible(true);
	}
}

class MazeGamePanel extends JPanel {// 主面板:显示迷宫以及定义相关操作.
	private final int DELAY = 10;// 定时器延迟时间
	private final int checkSizeDefault = 40, widthDefault = 20,
			heightDefault = 10, numberOfChasersDefault = 2,
			tearDownAllowedDefault = 0;// 默认值
	private final int panelWidth = 1000, panelHeight = 700;// 主面板宽,高
	private int checkSize, width, height, numberOfChasers, tearDownAllowed;
	// 迷宫的单位方格大小(以像素为单位),迷宫的宽度(方格数),迷宫的高度(方格数),追赶者数目,玩家可拆墙次数限制
	private Maze maze;// 一个迷宫面板
	private JButton tipButton,solve, newMaze, chase, newSure,newCancel;
	// 解答开关按键,生成新迷宫按键,追赶者开关按键,制造新迷宫确定取消按键
	private boolean tipControl,solveControl,chaseControl;//开关按键控制:true为目前开启,false为目前关闭
	private JLabel help, tip, tearDownAllowedTimes;// 帮助标签,提示标签
	private Timer timer;// 定时器:每隔10毫秒就获取当前游戏结果和当前提示.注意:迷宫开始,计时器开始;迷宫停止(指玩家输或赢),计时器停止
	// (由于玩家不动也有可能被追赶成功,因此不推荐在每次移动时作出判断)
	private JLabel checkSizeLabel, widthLabel, heightLabel,
			numberOfChasersLabel, tearDownAllowedLabel;// 滑动条提示
	private JSlider checkSizeSlider, widthSlider, heightSlider,
			numberOfChasersSlider, tearDownAllowedSlider;// 滑动条
	private JPanel mazeMaker;// 迷宫制造者:通过滑动条制造迷宫.仅当玩家点击"制造新迷宫"或输或赢时才可见
	private JScrollPane mazeContainer;//存放迷宫面板的滚动窗格

	public MazeGamePanel() {
		checkSize = checkSizeDefault;// 初始化一个迷宫:方格边长:20像素
		width = widthDefault;// 宽35个方格
		height = heightDefault;// 高25个方格.即迷宫面板大小为500*700
		numberOfChasers = numberOfChasersDefault;// 默认两个追赶者
		tearDownAllowed = tearDownAllowedDefault;// 默认不能拆墙

		maze = new Maze(checkSize, width, height, numberOfChasers,
				tearDownAllowed);// 根据上面的设置来初始化迷宫

		tipButton=new JButton("开启/关闭 提示");
		tipControl=false;
		chase = new JButton("开启/关闭 追赶者");
		chaseControl=true;
		solve = new JButton("开启/关闭 答案");
		solveControl=false;
		
		newMaze = new JButton("制造新迷宫");
		newSure = new JButton("确定");
		newCancel = new JButton("取消");
		help = new JLabel(maze.help()+ "请 按 方 向 建 移 动. 按 W,S,A,D 拆除 上,下,左,右 墙.");
		//按键功能与Maze类无关
		tip = new JLabel(maze.currentTip());
		tearDownAllowedTimes = new JLabel("剩余可拆墙次数:"
				+ maze.tearDownAllowedTimes());

		timer = new Timer(DELAY, new TimerListener());
		timer.start();// 注意:迷宫开始,计时器开始;迷宫停止(指玩家输或赢),计时器停止

		maze.addKeyListener(new KeyBoardListener());// 迷宫面板添加键盘监听器
		maze.setFocusable(true);

		checkSizeSlider = new JSlider(JSlider.HORIZONTAL, 10, 50,
				checkSizeDefault);
		checkSizeSlider.setMajorTickSpacing(10);
		checkSizeSlider.setMinorTickSpacing(2);
		checkSizeSlider.setPaintTicks(true);
		checkSizeSlider.setPaintLabels(true);
		checkSizeSlider.setAlignmentX(Component.LEFT_ALIGNMENT);

		widthSlider = new JSlider(JSlider.HORIZONTAL, 10, 50, widthDefault);
		widthSlider.setMajorTickSpacing(10);
		widthSlider.setMinorTickSpacing(2);
		widthSlider.setPaintTicks(true);
		widthSlider.setPaintLabels(true);
		widthSlider.setAlignmentX(Component.LEFT_ALIGNMENT);

		heightSlider = new JSlider(JSlider.HORIZONTAL, 10, 40, heightDefault);
		heightSlider.setMajorTickSpacing(10);
		heightSlider.setMinorTickSpacing(2);
		heightSlider.setPaintTicks(true);
		heightSlider.setPaintLabels(true);
		heightSlider.setAlignmentX(Component.LEFT_ALIGNMENT);

		numberOfChasersSlider = new JSlider(JSlider.HORIZONTAL, 0, 20,
				numberOfChasersDefault);
		numberOfChasersSlider.setMajorTickSpacing(1);
		numberOfChasersSlider.setPaintTicks(true);
		numberOfChasersSlider.setPaintLabels(true);
		numberOfChasersSlider.setAlignmentX(Component.LEFT_ALIGNMENT);

		tearDownAllowedSlider = new JSlider(JSlider.HORIZONTAL, -1, 50,
				tearDownAllowedDefault);
		tearDownAllowedSlider.setMajorTickSpacing(10);
		tearDownAllowedSlider.setMinorTickSpacing(2);
		tearDownAllowedSlider.setPaintTicks(true);
		tearDownAllowedSlider.setPaintLabels(true);
		tearDownAllowedSlider.setAlignmentX(Component.LEFT_ALIGNMENT);
		
		maze.setPreferredSize(new Dimension(panelWidth,panelHeight));
		//用setPreferredSize设置加入到滚动窗格的面板的大小才可以使滚动窗格有效
		mazeContainer=new JScrollPane(maze);//迷宫面板放到滚动窗格中
		mazeContainer.setEnabled(false);//这样可以使JScrollPane不响应键盘,只响应鼠标.这样走迷宫会好一点

		SliderListener listener = new SliderListener();
		checkSizeSlider.addChangeListener(listener);
		widthSlider.addChangeListener(listener);
		heightSlider.addChangeListener(listener);
		numberOfChasersSlider.addChangeListener(listener);
		tearDownAllowedSlider.addChangeListener(listener);

		checkSizeLabel = new JLabel("小方格边长(以像素为单位):" + checkSizeDefault);
		widthLabel = new JLabel("宽度(方格数):" + widthDefault);
		heightLabel = new JLabel("高度(方格数):" + heightDefault);
		numberOfChasersLabel = new JLabel("追赶者数目(可设为0):"
				+ numberOfChasersDefault);
		tearDownAllowedLabel = new JLabel("可拆墙限制次数(设为-1则不限次数,设为0则不能拆墙):"
				+ tearDownAllowedDefault);

		ButtonListener bListener = new ButtonListener();
		chase.addActionListener(bListener);
		solve.addActionListener(bListener);
		tipButton.addActionListener(bListener);
		newMaze.addActionListener(bListener);
		newSure.addActionListener(bListener);
		newCancel.addActionListener(bListener);// 添加按键监听器

		JLabel title=new JLabel("迷     宫     制     造     者");
		mazeMaker = new JPanel();
		mazeMaker.setLayout(new BoxLayout(mazeMaker, BoxLayout.Y_AXIS));
		mazeMaker.add(title);
		mazeMaker.add(Box.createRigidArea(new Dimension(0, 50)));
		mazeMaker.add(checkSizeLabel);
		mazeMaker.add(checkSizeSlider);
		mazeMaker.add(Box.createRigidArea(new Dimension(0, 30)));
		mazeMaker.add(widthLabel);
		mazeMaker.add(widthSlider);
		mazeMaker.add(Box.createRigidArea(new Dimension(0, 30)));
		mazeMaker.add(heightLabel);
		mazeMaker.add(heightSlider);
		mazeMaker.add(Box.createRigidArea(new Dimension(0, 30)));
		mazeMaker.add(numberOfChasersLabel);
		mazeMaker.add(numberOfChasersSlider);
		mazeMaker.add(Box.createRigidArea(new Dimension(0, 30)));
		mazeMaker.add(tearDownAllowedLabel);
		mazeMaker.add(tearDownAllowedSlider);
		JPanel controls = new JPanel();
		controls.setLayout(new BoxLayout(controls, BoxLayout.X_AXIS));
		controls.add(newSure);
		controls.add(newCancel);
		mazeMaker.add(Box.createRigidArea(new Dimension(0, 50)));
		mazeMaker.add(controls);
		mazeMaker.add(Box.createRigidArea(new Dimension(0, panelHeight)));
		// 加上以上语句,在显示mazeMaker的时候就不会显示到迷宫,比较美观
		mazeMaker.setPreferredSize(new Dimension(panelWidth, panelHeight));
		mazeMaker.setVisible(false);// 仅当玩家点击"制造新迷宫"或输或赢时才可见

		JPanel labels = new JPanel();
		labels.setLayout(new BoxLayout(labels, BoxLayout.Y_AXIS));
		labels.add(tip);
		labels.add(tearDownAllowedTimes);
		labels.add(help);

		JPanel controlPanel = new JPanel();// 控制面板
		controlPanel.setLayout(new BoxLayout(controlPanel, BoxLayout.X_AXIS));
		controlPanel.add(tipButton);
		controlPanel.add(chase);
		controlPanel.add(solve);
		controlPanel.add(newMaze);

		setLayout(new BoxLayout(this, BoxLayout.Y_AXIS));
		add(mazeMaker);//迷宫制造者面板
		add(Box.createRigidArea(new Dimension(0, 20)));
		add(mazeContainer);//存放迷宫的滚动窗格
		add(Box.createRigidArea(new Dimension(0, 20)));
		add(labels);//所有标签存放的面板
		add(Box.createRigidArea(new Dimension(0, 20)));
		add(controlPanel);//控制面板:追赶者开关,答案开关,新迷宫按键
		setPreferredSize(new Dimension(panelWidth, panelHeight));
	}

	private class TimerListener implements ActionListener {
		public void actionPerformed(ActionEvent e) {
			if(tipControl==true)
			tip.setText(maze.currentTip());// 提示和可拆墙剩余次数最好都随时更新
			else
				tip.setText("提示已关闭");
				
			tearDownAllowedTimes.setText("剩余可拆墙次数:"
					+ maze.tearDownAllowedTimes());

			// 以下为判断当前玩家输赢状态
			if (maze.currentResult() == 1) {// 玩家已经到达终点
				timer.stop();
				// 必须要在此停止,否则因为timer仍在计时且两个if其中之一直成立
				int another = JOptionPane.showConfirmDialog(null,
						"恭喜到达终点! 现在要生成一个新迷宫并重新开始?");
				if (another == JOptionPane.YES_OPTION) {
					timer.stop();
					mazeMaker.setVisible(true);// 玩家确认制造新迷宫,则把迷宫制造者设为可见
				}
				maze.requestFocusInWindow();// 迷宫面板必须要重获焦点(不能把这句放在if语句外,因为timer定时执行,会使maze不断获得焦点)
			} else if (maze.currentResult() == -1) {// 玩家输了
				timer.stop();
				// 必须要在此停止,否则因为timer仍在计时且两个if其中之一直成立
				int another = JOptionPane.showConfirmDialog(null,
						"你输啦! 现在要生成一个新迷宫并重新开始?");
				if (another == JOptionPane.YES_OPTION) {
					timer.stop();
					mazeMaker.setVisible(true);// 玩家确认制造新迷宫,则把迷宫制造者设为可见
				}
				maze.requestFocusInWindow();// 迷宫面板必须要重获焦点(不能把这句放在if语句外,因为timer定时执行,会使maze不断获得焦点)
			}
		}
	}

	private class KeyBoardListener extends KeyAdapter {
		public void keyPressed(KeyEvent e) {
			switch (e.getKeyCode()) {
			case KeyEvent.VK_UP:
				maze.move(2);
				break;
			case KeyEvent.VK_DOWN:
				maze.move(4);
				break;
			case KeyEvent.VK_LEFT:
				maze.move(1);
				break;
			case KeyEvent.VK_RIGHT:
				maze.move(3);
				break;
			case KeyEvent.VK_W: {
				maze.tearDown(2);
				tearDownAllowedTimes.setText("剩余可拆墙次数:"
						+ maze.tearDownAllowedTimes());
			}
				break;
			case KeyEvent.VK_S: {
				maze.tearDown(4);
				tearDownAllowedTimes.setText("剩余可拆墙次数:"
						+ maze.tearDownAllowedTimes());
			}
				break;
			case KeyEvent.VK_A: {
				maze.tearDown(1);
				tearDownAllowedTimes.setText("剩余可拆墙次数:"
						+ maze.tearDownAllowedTimes());
			}
				break;
			case KeyEvent.VK_D: {
				maze.tearDown(3);
				tearDownAllowedTimes.setText("剩余可拆墙次数:"
						+ maze.tearDownAllowedTimes());
			}
				break;
			case KeyEvent.VK_I://保护
				maze.protectEnabled(true);
				break;
			case KeyEvent.VK_O://非保护
				maze.protectEnabled(false);
				break;
			case KeyEvent.VK_P://可变范围拆墙
				maze.variableTearDown(3, 3);
				break;
			}
		}
	}

	private class ButtonListener implements ActionListener {
		public void actionPerformed(ActionEvent e) {
			if (e.getSource() == chase){
				if(chaseControl==false){
				maze.chaseOn();chaseControl=true;}
				else 
					{maze.chaseOff();chaseControl=false;}
				}
			else if (e.getSource() == solve){
				if(solveControl==false){
				maze.solveOn();solveControl=true;}
				else {
					maze.solveOff();solveControl=false;}
			}
			else if (e.getSource() == tipButton){
				if(tipControl==true)tipControl=false;
				else
					tipControl=true;//在timer监听器中判断即可
			}
			else if (e.getSource() == newSure) {
				mazeMaker.setVisible(false);// 玩家能点击到这个按键说明已被设为可见,现在要重设为不可见
				maze.newMaze(checkSizeSlider.getValue(),
						widthSlider.getValue(), heightSlider.getValue(),
						numberOfChasersSlider.getValue(), tearDownAllowedSlider
								.getValue());
				timer.start();// 计时器与迷宫一起启动
			} else if (e.getSource() == newCancel)
				mazeMaker.setVisible(false);// 玩家能点击到这个按键说明已被设为可见,现在要重设为不可见
			else {
				timer.stop();
				mazeMaker.setVisible(true);// 玩家点击制造新迷宫,则把迷宫制造者设为可见
			}
			maze.requestFocusInWindow();// 在按了键后迷宫面板必须要重获焦点
		}
	}

	private class SliderListener implements ChangeListener {
		public void stateChanged(ChangeEvent e) {// 注意:此方法若可执行,说明mazeMaker此时必定可见
			checkSizeLabel.setText("小方格边长(以像素为单位):"
					+ checkSizeSlider.getValue());
			widthLabel.setText("宽度(方格数):" + widthSlider.getValue());
			heightLabel.setText("高度(方格数):" + heightSlider.getValue());
			numberOfChasersLabel.setText("追赶者数目(可设为0):"
					+ numberOfChasersSlider.getValue());
			tearDownAllowedLabel.setText("可拆墙限制次数(设为-1则不限次数,设为0则不能拆墙):"
					+ tearDownAllowedSlider.getValue());
		}

	}
}


/**
 * 本类定义了一个迷宫(面板)以及和迷宫相关的一些操作.直接把迷宫加入程序主面板即可.
 * 
 * @author 山
 * 
 */
class Maze extends JPanel {
	private final int DELAY = 1000;// 追赶者走动延迟时间(注意:追赶者很聪明,因此走动延迟时间长一点)
	private int checkSize, width, height;// (迷宫由单位方格构成)单位方格的边长,迷宫的宽度,迷宫的高度
	private Wall[][] horizontal;// 单位水平墙.例如:若迷宫长度为3*5,则horizontal为4*5数组
	private Wall[][] vertical;// 单位竖直墙.例如:若迷宫长度为3*5,则horizontal为3*6数组
	private Check[][] checks;// 单位方格的状态(在遍历迷宫时需要).例如:若迷宫长度为3*5,则checks为3*5数组
	private int playerRow, playerColumn;// 玩家目前所在行,目前所在列
	private boolean[][] notMarked;// 单位方格是否有标记过(在随机生成迷宫时需要)
	private boolean solve;// 控制是否打印结果
	private Timer timer;// 定时器:追赶者每隔一段时间就会在迷宫中走动,玩家碰到追赶者就输.
	private boolean chase;// 追赶者开关器
	private Chaser[] chasers;// 追赶者们
	private int tearDownAllowed;// 玩家可拆墙次数限制
	private int currentResult;// 当前玩家的输赢情况:-1表示玩家输,0表示仍在进行,1表示玩家赢

	private enum Check {// 遍历迷宫时,单位方格的状态:notFoot--未踏足过;notMain--踏足过但不在主路径上;
		// main--踏足过且在主路径上(主路径即从起点到终点的路径)
		notFoot, notMain, main;
	}

	private enum Wall {// 单位墙的存在状态: notExist--不存在;exist--存在
		notExist, exist;
	}

	/**
	 * 一个新的随机生成的迷宫(面板).墙壁为黑色,玩家为蓝色,追赶者为红色. 建议本迷宫面板背景设置为白色. 玩家初始在左上角起点.右下角为终点.
	 * 这是新生成迷宫的提示:这是一个迷宫游戏.玩家是蓝点,走到右下角就赢.若途中碰到两个红点追赶者就输.请按键盘的方向键移动
	 * (建议新生成迷宫时给予玩家提示)
	 * 
	 * @param checkSize
	 *            (迷宫由单位方格构成)单位方格的边长,以像素输入
	 * @param width
	 *            迷宫的宽度.例如:宽度若为3即宽度为3个单位方格
	 * @param height
	 *            迷宫的高度.例如:高度若为3即高度为3个单位方格
	 * @param numberOfChasers
	 *            追赶者的数量(不要追赶者则为0)
	 * @param tearDownAllowed
	 *            玩家可拆墙次数限制(不可拆墙则为0,可拆无数次则为-1)
	 */
	public Maze(int checkSize, int width, int height, int numberOfChasers,
			int tearDownAllowed) {
		this.checkSize = checkSize;
		this.width = width;
		this.height = height;
		this.tearDownAllowed = tearDownAllowed;
		this.playerRow = 0;
		this.playerColumn = 0;// 玩家初始在左上角的方格:起点
		this.solve = false;// 不打印结果
		this.timer = new Timer(DELAY, new TimerListener());// 追赶者移动定时器

		if (numberOfChasers < 1){
			this.chase = false;// 玩家设定追赶者为"关"
			chasers=new Chaser[0];}
		else {
			this.chase=true;
			chasers = new Chaser[numberOfChasers];// 初始化追赶者
			for (int i = 0; i < numberOfChasers; i++) {
				Random gen = new Random();
				int ranRow, ranColumn;
				ranRow = gen.nextInt(this.height);
				ranColumn = gen.nextInt(this.width);
				chasers[i] = new Chaser(ranRow, ranColumn);
			}
			chaseOn();// 开启追赶者,使其移动
		}

		this.currentResult = 0;// 游戏进行中
		this.checks = new Check[this.height][this.width];// 迷宫为height*width个方格
		this.horizontal = new Wall[this.height + 1][this.width];
		// 单位水平墙.horizontalWalls有height*width-1个
		this.vertical = new Wall[this.height][this.width + 1];
		// 单位竖直墙.horizontalWalls有(height-1)*width个
		this.notMarked = new boolean[this.height][this.width];
		// 单位方格是否有标记过(在随机生成迷宫时需要)

		// 以下为迷宫具体初始化:
		// 全部方格状态初始化为"未踏足过"
		for (int i = 0; i < this.height; i++)
			for (int j = 0; j < this.width; j++)
				checks[i][j] = Check.notFoot;

		// 全部方格初始化为"未标记"
		for (int i = 0; i < this.height; i++)
			for (int j = 0; j < this.width; j++)
				notMarked[i][j] = true;