javaSwing推箱子游戏

一、简介

策略性游戏可以锻炼人的思维能力还能缓解人的压力，使人们暂时忘却生活当中的烦恼，增强人们的逻辑思维能力，游戏的艺术美也吸引着越来越多的玩家和厂商，寓教于乐，在放松人们心情的同时还可以活跃双手。在人类的社会生活当中，游戏占有很大的比重，并且随着社会的发展而不断发展。而且游戏本身具有激发人类潜在行为的特质，是一种能够吸引人们参与其中的活动，其本身具有强烈的吸引力使游戏者卷入其中；再者适当的游戏、合理的时间安排，能够让玩家在娱乐的同时还可以锻炼其反应速度及灵敏程度，亦可让玩家从压力中释放出来。因此游戏逐渐成为人们生活中不可缺少的一部分，游戏产业也正逐步发展成熟。
经典的推箱子游戏是一个来自日本的古老游戏，目的是在训练你的逻辑思考能力。它的玩法也非常简单，在一个狭小的仓库中，要求把木箱放到指定的位置，稍不小心就会出现箱子无法移动或者通道被堵住的情况，所以需要巧妙的利用有限的空间和通道，合理安排移动的次序和位置，控制人物不停的移动将箱子推到目的位置才能顺利的完成任务。难点在于移动的位置，以及箱子到达指定位置的顺序，只有多加思考才能获得游戏的胜利。反复推敲，锻炼了人们的耐性。本次的开发尽量多的设置了关卡数目，增强游戏的耐玩性，同时在画面上有所提高，借鉴了许多达人的经验和技术，引发了我对游戏的热爱，丰富了个人生活，相信推箱子游戏在今后的社会总会越来越引人注目。

二、系统分析

1.1 技术可行性分析

1.1.1 可行性目的

通过推箱子游戏中使用的Java技术，让我能够更加熟练的使用Eclipse。同时了解相关运行环境的配置。将理论知识和实际操作结合起来。达到学以致用的目的。网上资料的查询极大的提高了我的自学能力。希望经过此次设计，锻炼自己的思考，解决问题的能力。对系统开发的流程有更深层次的理解，检验学习成果和实际动手能力，对底层知识有更深的了解。为今后的工作打好基础。

1.1.2 可行性研究前提

基本需求:通过规范的开发流程，采用面向对象的分析设计方法实现游戏美观，易玩，及时等特性。操作性方面主要通过键盘的借口实现，操作键位是上下左右。
主要开发目标:通过此次研究熟练Java的相关知识和技术的应用，界面美化的工作需要同学的帮助，了解团队和合作的重要，熟悉不同领域相关技术的交叉，完成Java推箱子游戏的基本功能。
条件假定和限制：Java相关技术的使用不是很熟练，如果有些游戏bug没有及时发现，相关升级版本需要之后弥补，更正。
可行性研究所采用的方法和步骤,通过研究分析推箱子小游戏所需要的功能以及实现的方法、确定主体结构。利用所学到的知识，以最简洁、最容易的办法，边开发边测试边修改，实现一个初级游戏软件。
评价尺度,实现基础的推箱子功能，如输赢判定，人物的移动位置，箱子的移动位置，同时加强画面的优化，音乐的选定等基础功能。更强的优化需要以后的升级和修改，实现相关功能就达到目标。

1.1.3 算法可行性分析

管理可行性:
此次设计基于Java，有面向对象，可移植性，安全性，并发机制，支持可视化图形界面等特点。易于管理。
经济可行性:
经济可行性是指可以使用的资源的可能性（资源包括人力资源、自然资源和资金条件）。
经济可行性的内容
经济可行性包括两个方面的内容：一是某一备选方案占有和使用经济资源的可能性，进而实现政策目标的可能性；二是实施某一政策方案所需花费的成本和取得的收益。政府的财政资源是有限的，任何政策方案占有和使用的经济资源也是有限的。因此，任何一项公共政策都存在一个争取公共经济资源的问题。一般说来，“公共政策的经济资源的占有量与其政策目标的期望值成正比例关系。”当然，这还涉及到一个成本效益问题。如果某一方案的成本大于收益，显然这项政策是不可行的。

经济可行性的方法

评估经济可行性有两个基本方法：成本－效益分析或损益分析，成本－效能分析（或称成本－有效性分析）。
经济可行性的标准
经济可行性的具体标准有投入产出比（O/I）、效率（efficiency）、效力（effectiveness）、利润率（profitability）等。这里主要特别说明效率和效力这两个概念。效率是以最小的投入取得最大的产出；效力则是以最小的成本实现即定的目标。二者虽然相关，但却不能混淆，最高效率和最高效力不一定出现在同一个点上。举一个简单的例子，你购买一本书的最小成本是20元，但当你同时买10本同样的书时，只需180元。这后一种显然更有效力（一本书的成本只要18元），但问题是同样的书你只要一本就够了，显然这后一种就不能满足你最基本的目标了。
本次设计注重游戏功能的实现，达到设计目的，不用于其他的商业用途。通过此次设计增强Java技术和实践的结合。同时了解可视化界面，设计操作界面和页面的跳转更换。操作环境需要Eclipse。相关资料可以上网查询。硬件方面可以普通笔记本可以达到要求。

技术可行性:

对于本游戏，可以使用如VB，Java，Delphi等相关的编程语言，但是考虑到编写程序的难易程度以及对编译语言的了解程度，本游戏选择Java程序语言作为编程语言。需要对变量定义、变量初始化、界面初始化、游戏初始化等，然后就可以进入游戏，处理游戏过程中的各种操作。同时进行技术可行性分析时，要注意以下一些问题。
1．全面考虑系统开发过程所涉及的所有技术问题
软件开发涉及多方面的技术，包括开发方法、软硬件平台、网络结构、系统布局和结构、输入输出技术、系统相关技术等。应该全面和客观地分析软件开发所涉及的技术，以及这些技术的成熟度和现实性。
2．尽可能采用成熟技术
成熟技术是被多人采用并被反复证明行之有效的技术，因此采用成熟技术一般具有较高的成功率。另外，成熟技术经过长时间、大范围使用、补充和优化，其精细程度、优化程度、可操作性、经济性等方面要比新技术好。鉴于以上原因，软件项目开发过程中，在可以满足系统开发需要、能够适应系统发展、保证开发成本的条件下，应该尽量采用成熟技术。
3．慎重引入先进技术
在软件项目开发过程中，有时为了解决系统的特定问题，为了使所开发系统具有更好的适应性，需要采用某些先进或前沿技术。在选用先进技术时，需要全面分析所选技术的成熟程度。有许多报道的先进技术或科研成果实际上仍处在实验室阶段，其实用性和适应性并没有得到完全解决，也没有经过大量实践验证，在选择这种技术时必须慎重。例如，许多文章中已经报道了指纹识别技术，而且市场上也有实验性产品，但指纹识别技术至今仍有许多重大技术难题没有突破，离具体应用仍有一定距离。因此，在项目开发中要谨慎选用这种技术。如果不加分析，在项目中盲目采用指纹识别技术，应用时肯定会出现许多难以解决的具体问题。
4．着眼于具体的开发环境和开发人员
许多技术总的来说可能是成熟和可行的，但是在开发队伍中如果没有人掌握这种技术，而且在项目组中又没有引进掌握这种技术的人员，那么这种技术对本系统的开发仍然是不可行的。例如，分布对象技术是分布式系统的一种通用技术，但是如果在开发队伍中没有人掌握这种技术，那么从技术可行性来看就是不可行的。
5．技术可行性评价
技术可行性评价是通过原有系统和欲开发系统的系统流程图和数据流图，对系统进行比较，分析新系统具有的优越性，以及对设备、现有软件、用户、系统运行、开发环境、运行环境和经费支出的影响，然后评价新系统的技术可行性。

社会可行性:

社会可行性是在特定环境下对项目的开发与实施。
　　社会就是由许多个体汇集而成的有组织有规则或纪律的相互合作的生存关系的群体。没有分工与合作关系的个体所聚集成的群体不成为社会。本次设计基于学习的需要，所做毕业设计的内容不会在社会上进行商业运作。网上所查的资料以及相关的知识的引用，属于学术交流，不涉及版权，以及法律责任。同时不会对社会产生负面的影响，不存在不可行性。
算法实现：以人为中心，出现两种可能：①人在空位 ②人在目标位置上
① 有六种可能：（注：x1，y1, x2, y2为坐标的偏移量,i ,为人所在的坐标 )


仍然使用问题1的广度优先扩展，容易找出所有和主角所在空间相邻的箱子，判断箱子是否可以从主角所在空间推动也不难，先看是哪一面相邻，再看箱子另一面是否为空。程序设计思路：
对于工人的操作很简单：4个方向的移动，工人移动箱子也随之移动。
地图数据最为关键：第一关的地图都要更换，这些位置也要变，首先我们设计一个二维数组map.我们所地图想象成一个网格，每个格子就是图片的大小30像素，工人和箱子每步移动的距离也是30像素
假设工人移动方式向右，其它方向原理是一致的，P1、P2分别代表工人移动趋势方向前的两个方格
（1）前方P1是围墙：
如果工人前方是围墙 {
退出规则判断，布局不做任何改变
}
（2）前方P1是通道或目的地
如果工人前方是通道或目的地 {
工人可以进入到P1方格，修改相关位置的格子状态值
}
（3）前方P1是箱子
在这种情况，需要判断箱子(P1)前方P2处的物体，来判断工人是否可以移动，此时有以下可能：
一、P1处为箱子（BOX）或者放到目的地的箱子,P2处为通道：工人可以进到P1方格，P2方格的状态可以修改为箱子，修改相关格子的状态值
二、P1处为箱子或者放到目的地的箱子,P2处为目的地：工人可以进到P1方格，P2处为放到目的地的箱子,修改相关格子的状态值
三、P1处为箱子，P2处为墙：退出判断规则布局不做任何改变

三、游戏需求

玩家是通过对小人的移动操作来控制推动箱子的，并且玩家需要避过障碍物以及死角，才能将其推放到指定位置从而达到过关的目的。如果玩家将箱子推入死角导致箱子无法移动或不能移动到指定位置则闯关失败，可以通过悔步或重新开始等操作来重新挑战本关。

1、能够显示主菜单和功能

游戏需要提供主菜单让玩家进行游戏设置，同时能能够把地图文件中的信息转换成为图像显示到主游戏界面上。

2、能够实现键盘操作功能

能够接收到键盘输入的方向键信息，并根据不同的方向键把游戏任务移动到相应的位置，例如，当玩家单击方向键“上”时，如果向上的位置是可移动的，那么就当把游戏人物向上移动一个方格。

3、能够把放置到位置上的箱子进行变色显示

当玩家把箱子推到指定位置的格子时，需要把这个箱子进行变色。这样就能明确地显示出该箱子是否已经放置到指定位置上。

4、支持游戏扩展功能

玩家可以自己扩展原游戏地图文件，从而生成新的游戏地图。

5、游戏胜负判断功能

在游戏中，当玩家把全部的箱子都推到箱子放置点时，玩家胜利通过当前游戏关口，进行下一关口的游戏，如果玩家无法将指定的箱子全部推到放置点时，玩家失败。玩家可以选择重新进行当前关口的游戏，还是退出游戏。

6、支持关口选择功能

玩家在游戏中可自行选择需要挑战的关口。

7、游戏提供支持背景音乐功能

通过主菜单，在游戏开始后，可以选择播放或者禁止播放背景音乐。

四、程序截图

五、联系与交流

q:969060742 完整代码 、 报告、ppt 、程序资源

六、代码

import javax.swing.*;
import java.awt.event.*;
import java.awt.*;
import java.io.*;
import javax.sound.midi.*;
import java.util.Stack;
public class Tuixiangzi
{
	public static void main(String[] args)
	{
		new mainFrame();
	}
}

class mainFrame extends JFrame implements ActionListener,ItemListener
{
	JLabel lb;
	JLabel lb2;
	JButton btnrenew,btnlast,btnnext,btnchoose,btnfirst,btnover,btnmuc,btnback;
	mainpanel panel;
	Sound sound;
	JComboBox jc=new JComboBox();
	MenuItem renew=new MenuItem("    重新开始");
	MenuItem back=new MenuItem("    悔一步");
	MenuItem last=new MenuItem("    上一关");
	MenuItem next=new MenuItem("    下一关");
	MenuItem choose=new MenuItem("    选关");
	MenuItem exit=new MenuItem("    退出");
	MenuItem qin=new MenuItem("    琴萧合奏");
	MenuItem po=new MenuItem("    泡泡堂");
	MenuItem guang=new MenuItem("    灌篮高手");
	MenuItem nor=new MenuItem("    默认");
	MenuItem eye=new MenuItem("    eyes on me");
	MenuItem about=new MenuItem("    关于推箱子...");
	mainFrame()
	{
		super("推箱子v2.0");
		setSize(720,720);
		setVisible(true);
		setResizable(false);
		setLocation(300,20);
		setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
		Container cont=getContentPane();
		cont.setLayout(null);
		cont.setBackground(Color.black);
		Menu choice=new Menu("    选项");
		choice.add(renew);
		choice.add(last);
		choice.add(next);
		choice.add(choose);
		choice.add(back);
		choice.addSeparator();
		choice.add(exit);
		renew.addActionListener(this);
		last.addActionListener(this);
		next.addActionListener(this);
		choose.addActionListener(this);
		exit.addActionListener(this);
		back.addActionListener(this);
		Menu setmuc=new Menu("    设置音乐");
		setmuc.add(nor);
		setmuc.add(qin);
		setmuc.add(po);
		setmuc.add(guang);
		setmuc.add(eye);
		nor.addActionListener(this);
		qin.addActionListener(this);
		po.addActionListener(this);
		guang.addActionListener(this);
		eye.addActionListener(this);
		Menu help=new Menu("    帮助");
		help.add(about);
		about.addActionListener(this);
		MenuBar bar=new MenuBar();
		bar.add(choice);bar.add(setmuc);bar.add(help);
		setMenuBar(bar);                                        

		nor.setEnabled(false);
		lb=new JLabel("灰太狼古堡推箱子！",SwingConstants.CENTER);
		lb2=new JLabel("更换音乐",SwingConstants.CENTER);
		add(lb);add(lb2);
		lb.setBounds(100,20,400,20);
		lb.setForeground(Color.white);
		lb2.setBounds(625,500,55,20);
		lb2.setForeground(Color.white);
		btnrenew=new JButton("重玩");
		btnback=new JButton("悔一步");
		btnlast=new JButton("上一关");
		btnnext=new JButton("下一关");
		btnchoose=new JButton("选关");
		btnfirst=new JButton("第１关");
		btnover=new JButton("最终关");
		btnmuc=new JButton("音乐关");
		add(btnrenew);
		add(btnlast);
		add(btnnext);
		add(btnchoose);
		add(btnfirst);
		add(btnover);
		add(btnmuc);
		add(btnback);
		btnrenew.setBounds(625,100,80,30);
		btnrenew.addActionListener(this);
		btnback.setBounds(625,150,80,30);
		btnback.addActionListener(this);
		btnfirst.setBounds(625,200,80,30);
		btnfirst.addActionListener(this);
		btnlast.setBounds(625,250,80,30);
		btnlast.addActionListener(this);
		btnnext.setBounds(625,300,80,30);
		btnnext.addActionListener(this);
		btnover.setBounds(625,350,80,30);
		btnover.addActionListener(this);
		btnchoose.setBounds(625,400,80,30);
		btnchoose.addActionListener(this);
		btnmuc.setBounds(625,450,80,30);
		btnmuc.addActionListener(this);
		jc.setBounds(625,530,80,20);
		jc.addItem("默认");
		jc.addItem("琴萧合奏");
		jc.addItem("泡泡堂");
		jc.addItem("灌篮高手");
		jc.addItem("eyes on me");
		jc.addItemListener(this);
		cont.add(jc);
		sound=new Sound();
		sound.loadSound();
		panel=new mainpanel();
		add(panel);
		panel.Tuixiangzi(panel.level);
		panel.requestFocus();
		validate();
	}
	
	public void actionPerformed(ActionEvent e)
	{
		if(e.getSource()==btnrenew||e.getSource()==renew)
		{
			panel.Tuixiangzi(panel.level);
			panel.requestFocus();
			panel.remove();
		}
		else if(e.getSource()==btnlast||e.getSource()==last)
		{
			panel.level--;
			if(panel.level<1)
			{panel.level++;
			JOptionPane.showMessageDialog(this,"本关是第一关");
			panel.requestFocus();}
			else 
			{
				panel.Tuixiangzi(panel.level);
				panel.requestFocus();
			}
			panel.remove();
		}
		else if(e.getSource()==btnnext||e.getSource()==next)
		{
			panel.level++;
			if(panel.level>panel.maxlevel())
			{panel.level--;
			JOptionPane.showMessageDialog(this,"本关已是最后一关");
			panel.requestFocus();}
			else 
			{
				panel.Tuixiangzi(panel.level);
				panel.requestFocus();
			}
			panel.remove();
		}
		else if(e.getSource()==exit)System.exit(0);
		else if(e.getSource()==about)
		{
			JOptionPane.showMessageDialog(this, "JAVA推箱子游戏！(version 3.0)");
		}
		else if(e.getSource()==btnchoose||e.getSource()==choose)
		{
			String lel=JOptionPane.showInputDialog(this,"请输入您要转到的关卡号：(1~50)");
			panel.level=Integer.parseInt(lel);
			panel.remove();
			if(panel.level>panel.maxlevel()||panel.level<1)
			{JOptionPane.showMessageDialog(this, "没有这一关！！！");panel.requestFocus();}
			else
				{
				panel.Tuixiangzi(panel.level);
				panel.requestFocus();
				}
		}
		
		else if(e.getSource()==btnfirst)
		{
			panel.level=1;
			panel.Tuixiangzi(panel.level);
			panel.requestFocus();
			panel.remove();
		}
		else if(e.getSource()==btnover)
		{
			panel.level=panel.maxlevel();
			panel.Tuixiangzi(panel.level);
			panel.requestFocus();
			panel.remove();
		}
		else if(e.getSource()==btnmuc)
		{
			if(sound.isplay())
			{
				sound.mystop();
				btnmuc.setLabel("音乐开");
			}
			else 
			{
				sound.loadSound();
				btnmuc.setLabel("音乐关");
			}
			panel.requestFocus();
		}
		else if(e.getSource()==btnback||e.getSource()==back)
		{
			if(panel.isMystackEmpty())JOptionPane.showMessageDialog(this, "您还未移动！！！");
			else
			{
				switch(panel.back())
				{
					case 10:panel.backup(10);break;
					case 11:panel.backup(11);break;
					case 20:panel.backdown(20);break;
					case 21:panel.backdown(21);break;
					case 30:panel.backleft(30);break;
					case 31:panel.backleft(31);break;
					case 40:panel.backright(40);break;
					case 41:panel.backright(41);break;
				}
			}
			panel.requestFocus();
		}
		else if(e.getSource()==nor)
		{
			jc.setSelectedIndex(0);
		}
		
		else if(e.getSource()==qin)
		{
			jc.setSelectedIndex(1);
		}
		else if(e.getSource()==guang)
		{
			
			jc.setSelectedIndex(3);
			
		}
		else if(e.getSource()==eye)
		{
			jc.setSelectedIndex(4);
		}
		else if(e.getSource()==po)
		{
			jc.setSelectedIndex(2);
		}
	}
	public void itemStateChanged(ItemEvent ie)
	{
		int no=jc.getSelectedIndex();
		switch(no)
		{
			case 0:sound.setMusic("nor.mid");
					 if(sound.isplay())
					 sound.mystop();
					 sound.loadSound();
					 btnmuc.setLabel("音乐关");
					 nor.setEnabled(false);
					 qin.setEnabled(true);
					 guang.setEnabled(true);
					 eye.setEnabled(true);
					 po.setEnabled(true);panel.requestFocus();break;
			case 1:sound.setMusic("qin.mid");
					 if(sound.isplay())
					 sound.mystop();
					 sound.loadSound();
					 btnmuc.setLabel("音乐关");
					 nor.setEnabled(true);
					 qin.setEnabled(false);
					 guang.setEnabled(true);
					 eye.setEnabled(true);
					 po.setEnabled(true);panel.requestFocus();break;
			case 2:sound.setMusic("popo.mid");
					if(sound.isplay())
					sound.mystop();
					sound.loadSound();
					btnmuc.setLabel("音乐关");
					nor.setEnabled(true);
					qin.setEnabled(true);
					guang.setEnabled(true);
					eye.setEnabled(true);
					po.setEnabled(false);panel.requestFocus();break;
			case 3:sound.setMusic("guang.mid");
					if(sound.isplay())
					sound.mystop();
					sound.loadSound();
					btnmuc.setLabel("音乐关");
					nor.setEnabled(true);
					qin.setEnabled(true);
					guang.setEnabled(false);
					eye.setEnabled(true);
					po.setEnabled(true);panel.requestFocus();break;
			case 4:sound.setMusic("eyes on me.mid");
					if(sound.isplay())
					sound.mystop();
					sound.loadSound();
					btnmuc.setLabel("音乐关");
					nor.setEnabled(true);
					qin.setEnabled(true);
					guang.setEnabled(true);
					eye.setEnabled(false);
					po.setEnabled(true);panel.requestFocus();break;
		}
	}
}

class mainpanel extends JPanel implements KeyListener
{
	int max=50;
	int[][] map,maptmp;
	int manX,manY,boxnum;
	Image[] myImage;
	Readmap Levelmap;
	Readmap Levelmaptmp;
	int len=30;
	public int level=1;
	Stack mystack=new Stack();
	mainpanel()
	{	
		setBounds(15,50,600,600);
		setBackground(Color.white);
		addKeyListener(this);
		myImage=new Image[10];
		for(int i=0; i<10; i++)
		{
		    myImage[i] = Toolkit.getDefaultToolkit().getImage("pic\\"+i+".gif");
		}
		
		setVisible(true);
	}

	void Tuixiangzi(int i)
	{
		Levelmap=new Readmap(i);
		Levelmaptmp=new Readmap(i);
		map=Levelmap.getmap();
		manX=Levelmap.getmanX();
		manY=Levelmap.getmanY();
		maptmp=Levelmaptmp.getmap();
		repaint();
	}
	int maxlevel(){return max;}

	public void paint(Graphics g)
	{
		for(int i=0; i<20; i++)
			for(int j=0; j<20; j++)
		    {
			    g.drawImage(myImage[map[j][i]],i*len,j*len,this);
			}		
		g.setColor(new Color(0,0,0));
		g.setFont(new Font("楷体_2312",Font.BOLD,30));
		g.drawString("第",240,40);
		g.drawString(String.valueOf(level),310,40);
		g.drawString("层",360,40);
	}

	public void keyPressed(KeyEvent e)
	{
		if(e.getKeyCode()==KeyEvent.VK_UP){moveup();}
		if(e.getKeyCode()==KeyEvent.VK_DOWN){movedown();}
		if(e.getKeyCode()==KeyEvent.VK_LEFT){moveleft();}
		if(e.getKeyCode()==KeyEvent.VK_RIGHT){moveright();}
		if(iswin())
		{
			if(level==max){JOptionPane.showMessageDialog(this, "恭喜您通过最后一关！！！");}
			else
			{
				String msg="恭喜您通过第"+level+"关!!!\n是否要进入下一关？";
				int type=JOptionPane.YES_NO_OPTION;
				String title="恭喜过关！";
				int choice=0;
				choice=JOptionPane.showConfirmDialog(null,msg,title,type);
				if(choice==1)System.exit(0);
				else if(choice==0)
				{
					level++;
					Tuixiangzi(level);
				}
			}
			mystack.removeAllElements();
		}
	}
	public void keyTyped(KeyEvent e){}
	public void keyReleased(KeyEvent e){}

	boolean isMystackEmpty(){return mystack.isEmpty();}
	
	int  back(){return (Integer)mystack.pop();}

	void remove(){mystack.removeAllElements();}
	
	void moveup()
	{
		if(map[manY-1][manX]==2||map[manY-1][manX]==4)
		{
			if(maptmp[manY][manX]==4||maptmp[manY][manX]==9)
				map[manY][manX]=4;
			else map[manY][manX]=2;
			map[manY-1][manX]=8;
			repaint();manY--;mystack.push(10);
		}
		else if(map[manY-1][manX]==3)
		{
			if(map[manY-2][manX]==4)
			{
				if(maptmp[manY][manX]==4||maptmp[manY][manX]==9)
					map[manY][manX]=4;
				else map[manY][manX]=2;
				map[manY-1][manX]=8;
				map[manY-2][manX]=9;
				repaint();manY--;mystack.push(11);
			}
			else if(map[manY-2][manX]==2)
			{
				if(maptmp[manY][manX]==4||maptmp[manY][manX]==9)
					map[manY][manX]=4;
				else map[manY][manX]=2;
				map[manY-1][manX]=8;
				map[manY-2][manX]=3;
				repaint();manY--;mystack.push(11);
			}
			else {map[manY][manX]=8;repaint();}
		}
		else if(map[manY-1][manX]==9)
		{
			if(map[manY-2][manX]==4)
			{
				if(maptmp[manY][manX]==4||maptmp[manY][manX]==9)
					map[manY][manX]=4;
				else map[manY][manX]=2;
				map[manY-1][manX]=8;
				map[manY-2][manX]=9;
				repaint();manY--;mystack.push(11);
			}
			else if(map[manY-2][manX]==2)
			{
				if(maptmp[manY][manX]==4||maptmp[manY][manX]==9)
					map[manY][manX]=4;
				else map[manY][manX]=2;
				map[manY-1][manX]=8;
				map[manY-2][manX]=3;
				repaint();manY--;mystack.push(11);
			}
			else {map[manY][manX]=8;repaint();}
		}
		if(map[manY-1][manX]==1)
		{
			map[manY][manX]=8;repaint();
		}
	}
	
	void backup(int t)
	{
		int n=t;
		if(n==10)
		{
			if(maptmp[manY][manX]==4||maptmp[manY][manX]==9)
			{
				map[manY][manX]=4;
			}
			else map[manY][manX]=2;
		}
		else if(n==11)
		{
			if(maptmp[manY][manX]==4||maptmp[manY][manX]==9)
			{
				map[manY][manX]=9;
			}
			else map[manY][manX]=3;
			if(maptmp[manY-1][manX]==4||maptmp[manY-1][manX]==9)
			{
				map[manY-1][manX]=4;
			}
			else map[manY-1][manX]=2;
		}
		map[manY+1][manX]=8;
		repaint();manY++;
	}

	void movedown()
	{
		if(map[manY+1][manX]==2||map[manY+1][manX]==4)
		{
			if(maptmp[manY][manX]==4||maptmp[manY][manX]==9)
				map[manY][manX]=4;
			else map[manY][manX]=2;
			map[manY+1][manX]=5;
			repaint();manY++;mystack.push(20);
		}
		else if(map[manY+1][manX]==3)
		{
			if(map[manY+2][manX]==4)
			{
				if(maptmp[manY][manX]==4||maptmp[manY][manX]==9)
					map[manY][manX]=4;
				else map[manY][manX]=2;
				map[manY+1][manX]=5;
				map[manY+2][manX]=9;
				repaint();manY++;mystack.push(21);
			}
			else if(map[manY+2][manX]==2)
			{
				if(maptmp[manY][manX]==4||maptmp[manY][manX]==9)
					map[manY][manX]=4;
				else map[manY][manX]=2;
				map[manY+1][manX]=5;
				map[manY+2][manX]=3;
				repaint();manY++;mystack.push(21);
			}
			else {map[manY][manX]=5;repaint();}
		}
		else if(map[manY+1][manX]==9)
		{
			if(map[manY+2][manX]==4)
			{
				if(maptmp[manY][manX]==4||maptmp[manY][manX]==9)
					map[manY][manX]=4;
				else map[manY][manX]=2;
				map[manY+1][manX]=5;
				map[manY+2][manX]=9;
				repaint();manY++;mystack.push(21);
			}
			else if(map[manY+2][manX]==2)
			{
				if(maptmp[manY][manX]==4||maptmp[manY][manX]==9)
					map[manY][manX]=4;
				else map[manY][manX]=2;
				map[manY+1][manX]=5;
				map[manY+2][manX]=3;
				repaint();manY++;mystack.push(21);
			}
			else {map[manY][manX]=5;repaint();}
		}
		else if(map[manY+1][manX]==1)
		{
			map[manY][manX]=5;repaint();
		}
	}

	void backdown(int t)
	{
		int n=t;
		if(n==20)
		{
			if(maptmp[manY][manX]==4||maptmp[manY][manX]==9)
			{
				map[manY][manX]=4;
			}
			else map[manY][manX]=2;
		}
		else if(n==21)
		{
			if(maptmp[manY][manX]==4||maptmp[manY][manX]==9)
			{
				map[manY][manX]=9;
			}
			else map[manY][manX]=3;
			if(maptmp[manY+1][manX]==4||maptmp[manY+1][manX]==9)
			{
				map[manY+1][manX]=4;
			}
			else map[manY+1][manX]=2;
		}
		map[manY-1][manX]=5;
		repaint();manY--;
	}

	void moveleft()
	{
		if(map[manY][manX-1]==2||map[manY][manX-1]==4)
		{
			if(maptmp[manY][manX]==4||maptmp[manY][manX]==9)
				map[manY][manX]=4;
			else map[manY][manX]=2;
			map[manY][manX-1]=6;			
			repaint();manX--;mystack.push(30);
		}
		else if(map[manY][manX-1]==3)
		{
			if(map[manY][manX-2]==4)
			{
				if(maptmp[manY][manX]==4||maptmp[manY][manX]==9)
					map[manY][manX]=4;
				else map[manY][manX]=2;
				map[manY][manX-1]=6;
				map[manY][manX-2]=9;
				repaint();manX--;mystack.push(31);
			}
			else if(map[manY][manX-2]==2)
			{
				if(maptmp[manY][manX]==4||maptmp[manY][manX]==9)
					map[manY][manX]=4;
				else map[manY][manX]=2;
				map[manY][manX-1]=6;
				map[manY][manX-2]=3;
				repaint();manX--;mystack.push(31);
			}
			else {map[manY][manX]=6;repaint();}
		}
		else if(map[manY][manX-1]==9)
		{
			if(map[manY][manX-2]==4)
			{
				if(maptmp[manY][manX]==4||maptmp[manY][manX]==9)
					map[manY][manX]=4;
				else map[manY][manX]=2;
				map[manY][manX-1]=6;
				map[manY][manX-2]=9;
				repaint();manX--;mystack.push(31);
			}
			else if(map[manY][manX-2]==2)
			{
				if(maptmp[manY][manX]==4||maptmp[manY][manX]==9)
					map[manY][manX]=4;
				else map[manY][manX]=2;
				map[manY][manX-1]=6;
				map[manY][manX-2]=3;
				repaint();manX--;mystack.push(31);
			}
			else {map[manY][manX]=6;repaint();}
		}
		else if(map[manY][manX-1]==1)
		{
			map[manY][manX]=6;repaint();
		}
	}

	void backleft(int t)
	{
		int n=t;
		if(n==30)
		{
			if(maptmp[manY][manX]==4||maptmp[manY][manX]==9)
			{
				map[manY][manX]=4;
			}
			else map[manY][manX]=2;
		}
		else if(n==31)
		{
			if(maptmp[manY][manX]==4||maptmp[manY][manX]==9)
			{
				map[manY][manX]=9;
			}
			else map[manY][manX]=3;
			if(maptmp[manY][manX-1]==4||maptmp[manY][manX-1]==9)
			{
				map[manY][manX-1]=4;
			}
			else map[manY][manX-1]=2;
		}
		map[manY][manX+1]=6;
		repaint();manX++;
	}

	void moveright()
	{
		if(map[manY][manX+1]==2||map[manY][manX+1]==4)
		{			
			if(maptmp[manY][manX]==4||maptmp[manY][manX]==9)
				map[manY][manX]=4;
			else map[manY][manX]=2;
			map[manY][manX+1]=7;			
			repaint();manX++;mystack.push(40);
		}
		else if(map[manY][manX+1]==3)
		{
			if(map[manY][manX+2]==4)
			{
				if(maptmp[manY][manX]==4)
					map[manY][manX]=4;
				else map[manY][manX]=2;
				map[manY][manX+1]=7;
				map[manY][manX+2]=9;
				repaint();manX++;mystack.push(41);
			}
			else if(map[manY][manX+2]==2)
			{
				if(maptmp[manY][manX]==4)
					map[manY][manX]=4;
				else map[manY][manX]=2;
				map[manY][manX+1]=7;
				map[manY][manX+2]=3;
				repaint();manX++;mystack.push(41);
			}
			else {map[manY][manX]=7;repaint();}
		}
		else if(map[manY][manX+1]==9)
		{
			if(map[manY][manX+2]==4)
			{
				if(maptmp[manY][manX]==4||maptmp[manY][manX]==9)
					map[manY][manX]=4;
				else map[manY][manX]=2;
				map[manY][manX+1]=7;
				map[manY][manX+2]=9;
				repaint();manX++;mystack.push(41);
			}
			else if(map[manY][manX+2]==2)
			{
				if(maptmp[manY][manX]==4||maptmp[manY][manX]==9)
					map[manY][manX]=4;
				else map[manY][manX]=2;
				map[manY][manX+1]=7;
				map[manY][manX+2]=3;
				repaint();manX++;mystack.push(41);
			}
			else {map[manY][manX]=7;repaint();}
		}
		else if(map[manY][manX+1]==1)
		{
			map[manY][manX]=7;repaint();
		}
	}

	void backright(int t)
	{
		int n=t;
		if(n==40)
		{
			if(maptmp[manY][manX]==4||maptmp[manY][manX]==9)
			{
				map[manY][manX]=4;
			}
			else map[manY][manX]=2;
		}
		else if(n==41)
		{
			if(maptmp[manY][manX]==4||maptmp[manY][manX]==9)
			{
				map[manY][manX]=9;
			}
			else map[manY][manX]=3;
			if(maptmp[manY][manX+1]==4||maptmp[manY][manX+1]==9)
			{
				map[manY][manX+1]=4;
			}
			else map[manY][manX+1]=2;
		}
		map[manY][manX-1]=7;
		repaint();manX--;
	}

	boolean iswin()
	{
		boolean num=false;
		out:for(int i=0; i<20; i++)
			for(int j=0; j<20; j++)
		{
			if(maptmp[i][j]==4||maptmp[i][j]==9)
				if(map[i][j]==9)num=true;
			    else {num=false;break out;}
		}
		return num;
	}
}

class Sound
{
	String path=new String("musics\\");
	String  file=new String("nor.mid");
	Sequence seq;
    Sequencer midi;
	boolean sign;
	void loadSound()
	{
		try {
            seq=MidiSystem.getSequence(new File(path+file));
            midi=MidiSystem.getSequencer();
            midi.open();
            midi.setSequence(seq);
			midi.start();
			midi.setLoopCount(Sequencer.LOOP_CONTINUOUSLY);
        }
        catch (Exception ex) {ex.printStackTrace();}
		sign=true;
	}
	void mystop(){midi.stop();midi.close();sign=false;}
	boolean isplay(){return sign;}
	void setMusic(String e){file=e;}
}

class Readmap
{
	private int level,mx,my;
	private int[][] mymap=new int[20][20];
	FileReader r;
	BufferedReader br;
	String bb="";
	int[] x;int c=0;
	Readmap(int k)
	{
		level=k;
		String s;
		try
		{
			File f=new File("maps\\"+level+".map");
			r=new FileReader(f);
			br=new BufferedReader(r);
		}
		catch (IOException e)
		{
			System.out.println(e);
		}
		try
		{
			while ((s=br.readLine())!=null)
			{
				bb=bb+s;
				
			}
		}
		catch (IOException g)
		{
			System.out.println(g);
		}
		byte[] d=bb.getBytes();
		int len=bb.length();
		int[] x=new int[len];
		for(int i=0;i<bb.length();i++)x[i]=d[i]-48;
		for(int i=0;i<20;i++)
		{
			for(int j=0;j<20;j++)
		    {
				mymap[i][j]=x[c];
		        if(mymap[i][j]==5)
		        {
					mx=j;my=i;
		        }
		        c++;
		    }
	    }
	}
	int[][] getmap(){return mymap;}
	int getmanX(){return mx;}
	int getmanY(){return my;}
}