该项目主要采用面向对象编程（封装、继承、多态）、swing桌面编程、数组、集合、while、if、for、foreach循环语句、多线程等技术。适合中级程序员学习。
1.BackGround 类
package com.sy.mario;
//awt:abstract window tools
import java.awt.image.BufferedImage;
import java.util.ArrayList;
import java.util.List;
//场景类 关《TankClient:背景 主人公 敌人 障碍物 etc》
public class BackGround {
//当前的关数
private int sort;
//是不是最后一关的变量
private boolean flag;
//背景图片
private BufferedImage showImage;
//开始下落的变量
public boolean 旗帜下落;
//定义存储每一关障碍物的集合
private List<Obstrcution> allobs=new ArrayList<Obstrcution>();
//定义存储每一关死亡的障碍物集合
private List<Obstrcution> removeobs=new ArrayList<Obstrcution>();
//定义存储每一关敌人集合
private List<Enemy> allenemys=new ArrayList<Enemy>();
//定义存储每一关死亡的敌人集合
private List<Enemy> removeenemys=new ArrayList<Enemy>();
public boolean 降旗完毕;
public boolean 通关;
public List<Enemy> getAllenemys() {
return allenemys;
}
public List<Enemy> getRemoveenemys() {
return removeenemys;
}
public List<Obstrcution> getRemoveobs() {
return removeobs;
}
//alt+shift+s(Source源码)
public BackGround(int sort, boolean flag) {
super();
this.sort = sort;
this.flag = flag;
//根据flag确定showImage
if(flag){//最后一关
showImage=StaticValue.endImage;
}else{ //还在继续
showImage=StaticValue.bgImage;
}
//根据sort的值确定allobs内容
if(1 == sort){
//地面
for(int i=0;i<15;i++){
allobs.add(new Obstrcution(60*i,540,9,this));
}
//第一层
allobs.add(new Obstrcution(120,360,4,this));
allobs.add(new Obstrcution(300,360,0,this));
allobs.add(new Obstrcution(360,360,4,this));
allobs.add(new Obstrcution(420,360,0,this));
allobs.add(new Obstrcution(480,360,4,this));
allobs.add(new Obstrcution(540,360,0,this));
//第二层
allobs.add(new Obstrcution(420,180,4,this));
//花盆
allobs.add(new Obstrcution(660,480,8,this));
allobs.add(new Obstrcution(720,480,7,this));
allobs.add(new Obstrcution(660,540,6,this));
allobs.add(new Obstrcution(720,540,5,this));
//敌人
allenemys.add(new Enemy(600,480,1,true,this));
allenemys.add(new Enemy(690,520,2,540,360,true,this));
}
//处理第二关
if(sort == 2){
//地面
for(int i=0;i<15;i++){
allobs.add(new Obstrcution(60*i,540,9,this));
}
//第一个花盆
allobs.add(new Obstrcution(160,480,8,this));
allobs.add(new Obstrcution(220,480,7,this));
allobs.add(new Obstrcution(160,540,6,this));
allobs.add(new Obstrcution(220,540,5,this));
allenemys.add(new Enemy(190,520,2,540,360,true,this));
//从左到右设计
allenemys.add(new Enemy(280,480,1,false,this));
//从右到左设计
allenemys.add(new Enemy(600,480,1,true,this));
//第二个花盆
allobs.add(new Obstrcution(660,420,8,this));
allobs.add(new Obstrcution(720,420,7,this));
allobs.add(new Obstrcution(660,480,6,this));
allobs.add(new Obstrcution(720,480,5,this));
allobs.add(new Obstrcution(660,540,6,this));
allobs.add(new Obstrcution(720,540,5,this));
allenemys.add(new Enemy(690,480,2,540,360,true,this));
allenemys.add(new Enemy(690,520,2,540,360,true,this));
}
//处理第三关
if(sort == 3){
//地面
for(int i=0;i<15;i++){
allobs.add(new Obstrcution(60*i,540,9,this));
}
//画出地面的砖块
allobs.add(new Obstrcution(520,480,2,this));
//画出旗帜
allobs.add(new Obstrcution(550,180,11,this));
}
}
public BufferedImage getShowImage() {
return showImage;
}
public List<Obstrcution> getAllobs() {
return allobs;
}
public int getSort() {
// TODO Auto-generated method stub
return sort;
}
public boolean isFlag() {
return flag;
}
//解冻方法
public void resume(){
for(Enemy e:allenemys){
e.resume();
}
}
public void reset() {
this.allobs.addAll(removeobs);
this.allenemys.addAll(removeenemys);
//分别取出敌人和障碍物将对应数据回传给他们
for(Obstrcution obs:allobs){
obs.reset();
}
for(Enemy e:allenemys){
e.reset();
}
}
}
2.Enemy 类
package com.sy.mario;
import java.awt.image.BufferedImage;
//敌人类
public class Enemy implements Runnable{
//坐标
private int x,y,startX,startY;
//类型
private int type;
//图片
private BufferedImage showImage;
//食人花的上下限范围
private int downmax,upmax;
//默认朝向
private boolean isUporLeft;
//持有场景对象
private BackGround bg;
//创建有名对象
Thread t=new Thread(this);
//普通敌人
public Enemy(int x, int y, int type,
boolean isUporLeft,BackGround bg) {
super();
this.bg=bg;
this.startX=this.x = x;
this.startY=this.y = y;
this.type = type;
this.isUporLeft = isUporLeft;
//根据type来划分是蘑菇还是乌龟还是其他的
showImage=StaticValue.allTriangleImage.get(0);
t.start();
t.suspend();
}
//食人花
public Enemy(int x, int y, int type, int downmax, int upmax,
boolean isUporLeft,BackGround bg) {
super();
this.bg=bg;
this.startX=this.x = x;
this.startY=this.y = y;
this.type = type;
this.downmax = downmax;
this.upmax = upmax;
this.isUporLeft = isUporLeft;
showImage=StaticValue.allFlowerImage.get(0);
t.start();
t.suspend();
}
public int getX() {
return x;
}
public int getY() {
return y;
}
public BufferedImage getShowImage() {
return showImage;
}
//定义切换步子
private int imagetype=0;
public void run() {
while(true){
boolean canLeft=true;
boolean canRight=true;
//【对集合数组同时进行大批量的增加和删除,建议采用基本for】
for(int i=0;i<bg.getAllobs().size();i++){
Obstrcution obs=bg.getAllobs().get(i);
//不能向右
if(x+60 == obs.getX()&& y>=obs.getY()-40
&& y<=obs.getY()+40){
canRight=false;
}
//不能向左
if(x-60 == obs.getX()&& y>=obs.getY()-40
&& y<=obs.getY()+40){
canLeft=false;
}
}
//根据定义type找出食人花和普通敌人
if(1 == type){
//普通敌人
if(imagetype == 0){
imagetype=1;
}else{
imagetype=0;
}
//正在朝左走但是不能朝左走
if(isUporLeft&&!canLeft || x<=0){
//朝右走
isUporLeft=false;
}
//正在朝右走但是不能朝右走
if(!isUporLeft&&!canRight || x>=840){
//朝左走
isUporLeft=true;
}
if(isUporLeft)
x-=2;//默认朝左
else
x+=2;
showImage=StaticValue.allTriangleImage.get(imagetype);
}
if(type == 2){
//食人花
if(imagetype == 0){
imagetype=1;
}else{
imagetype=0;
}
//正在朝上走但是不能朝上（小于最大值）
if(isUporLeft&&y<=upmax){
isUporLeft=false;
}
//正在朝下走但是不能朝下(大于最小值)
if(!isUporLeft&&y>=downmax){
isUporLeft=true;
}
if(isUporLeft)
y-=2;//默认朝上
else
y+=2;
showImage=StaticValue.allFlowerImage.get(imagetype);
}
try {
Thread.sleep(100);
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
public int getType() {
// TODO Auto-generated method stub
return type;
}
public void dead() {
bg.getAllenemys().remove(this);
bg.getRemoveenemys().add(this);
}
public void reset() {
x=startX;
y=startY;
}
public void resume() {
t.resume();
}
}
3. Mario 类
package com.sy.mario;
import java.awt.image.BufferedImage;
//主人公
public class Mario implements Runnable{
private int x,y;//坐标
private BufferedImage showImage;//图片
//横向移动的偏移量
private int xmove;
//纵向移动的偏移量
private int ymove;
//表示图片的字符串变量
private String status;
//持有场景
private BackGround bg;
//定义Mario存活的变量(假设只有1条命)
public boolean live;
//定义Mario设置3条命
public int life=3;
public void setBg(BackGround bg){
this.bg=bg;
}
public Mario(int x,int y){
//默认是活的
this.live=true;
this.x=x;
this.y=y;
//指定第一张右站立的图片1.gif
showImage=StaticValue.allMarioImage.get(0);
//指定默认的状态"right-standing"
status="right-standing";
//开启线程完成mario的横向移动
new Thread(this).start();
}
//定义出Mario横向移动的四个基本方法
public void leftstop(){
xmove=0;
//初始化
status="left-standing";
}
public void leftmove(){
xmove=-5;
status="left-moving";
}
public void rightstop(){
xmove=0;
status="right-standing";
}
public void rightmove(){
xmove=5;
status="right-moving";
}
//Mario纵向移动的方法
//上升
//定义上升的时间
int uptime=0;//默认没有上升
public void jump(){
if(status.indexOf("left")!=-1){
//Mario打算从左边起跳
status="left-jumping";
}else{
//Mario打算从右边起跳
status="right-jumping";
}
ymove=-5;//ymove认为是速度0.1s(1上升50)
//求出上升的时间t=s/v(Math.abs())
//uptime从起始点给定上升的时间
//但是随着线程的刷新我们程序员人为减少uptime
//时间,直到uptime=0说明上升结束
uptime=180/5;
}
//下降的方法(不需要给定下降的时间)
public void down(){
if(status.indexOf("left")!=-1){
//PS:上升和下降对应的图片是一致的
status="left-jumping";
}else{
status="right-jumping";
}
ymove=5;
}
//独立线程Thread-A
//定义：朝一个方向走的步子(0-1逐个逐个走)
private int moving=0;
public void run() {
//不断监听玩家操作键盘-->xmove
while(true){
//处理Mario游戏通过过程
if(x>520 && bg.isFlag()){
//游戏正在通关
//1.改变状态
status="right-jumping";
//2.mario下落到砖块上面
if(y<420){
y+=5;
}
if(y==420){
y=420;
status="right-standing";
//3.通知旗帜开始下落
bg.旗帜下落=true;
}
//4.当降旗完毕后，再来通关
if(bg.降旗完毕){
if(x<580){
x+=5;
status="right-moving";
}
if(x == 580){
if(y<480){
y+=5;
status="right-jumping";
}
if(y == 480){
//落到地面
status="right-standing";
}
}
if(y == 480){
//朝右走
if(x<800){
x+=10;
status="right-moving";
}
if(x == 750){
//游戏通关结束
bg.通关=true;
}
}
}
}else{
//游戏还在继续
//处理Mario遇到敌人
for(int i=0;i<bg.getAllenemys().size();i++){
Enemy e=bg.getAllenemys().get(i);
/*
* 1.通过类型在区分横向和纵向
* 2.通过横向和纵向再来类型
*/
//横向
if(x>e.getX()-60&&x<e.getX()+60
&& y>e.getY()-60&& y<e.getY()+60){
//Mario死亡
this.dead();
}
//纵向
if(y+60==e.getY() && x<=e.getX()+60
&& x>=e.getX()-60){
//根据敌人类型做出死亡判断
if(e.getType() == 1){
//普通敌人
e.dead();
}
if(e.getType() == 2){
//食人花
this.dead();
}
}
}
//分析：Mario纵向行为
//1.找出是否在障碍物上面
boolean οnlοad=false;
//2.找出Mario上升的高度 180
//3.整理上升和下降的方法
//分析:Mario横向遇到障碍物逻辑
boolean canLeft=true;
boolean canRight=true;
//【对集合数组同时进行大批量的增加和删除,建议采用基本for】
for(int i=0;i<bg.getAllobs().size();i++){
Obstrcution obs=bg.getAllobs().get(i);
//不能向右
if(x+60 == obs.getX()&& y>=obs.getY()-40
&& y<=obs.getY()+40){
canRight=false;
}
//不能向左
if(x-60 == obs.getX()&& y>=obs.getY()-40
&& y<=obs.getY()+40){
canLeft=false;
}
//在障碍物上面
if(y+60==obs.getY() && x<=obs.getX()+60
&& x>=obs.getX()-60){
οnlοad=true;
}
//顶到障碍物
if(y-60==obs.getY() && x<=obs.getX()+60
&& x>=obs.getX()-60){
//根据障碍物的类型处理对应的结果
//普通的砖块
if(obs.getType() == 0){
//干掉障碍物
bg.getAllobs().remove(obs);
//为游戏的重置做准备
bg.getRemoveobs().add(obs);
}
//问号砖块
if(obs.getType() == 4){
//直接置换类型
obs.setType(2);
//uptime=5;
}
uptime=0;
}
}
//通过onload操作ymove进一步控制Y
if(onload && uptime == 0){
//我在障碍物上面(1.定在障碍物上面 2.打算去跳)
//分析:standing下来|moving下来的
if(status.indexOf("left")!=-1){
if(status.indexOf("moving")!=-1){
status="left-moving";
}else{
status="left-standing";
}
}else{
if(status.indexOf("moving")!=-1){
status="right-moving";
}else{
status="right-standing";
}
}
MyFrame.跳跃=true;
}else{
//我不在障碍物上面(空中:上升或者下降)
if(uptime!=0){
//说明还在上升
uptime--;
}else{
//说明上升最高点,只能是下降
this.down();
}
y+=ymove;
MyFrame.跳跃=false;
}
//根据canLeft和canRight进行x的控制
if(xmove<0&&canLeft || xmove>0&&canRight){
x+=xmove;
//处理最左边
if(x<=0) x=0;
}
}//else结束符号
//分析：Mario横向移动图片逻辑
//1:朝一个方向走图片切换最多是3个
//2.朝左=朝右+5
//定义：allMarioImges集合图片的索引
//右: 0 1 2 3
//左: 5 6 7 8
int index=0;//默认是第0张
if(status.indexOf("left")!=-1){
index+=5;
}
//走和停止
//standing
//1.standing--->standing(ERROR)
//2.standing--->moving(移动)
//3.moving--->moving(移动)
//4.moving--->standing(移动|停止)
if(status.indexOf("moving")!=-1){
index+=moving;//2
moving++;
//切换完毕之后的判断结果
if(moving == 4){
moving=0;
}
}
//指定图片的切换利用index
if(status.indexOf("left-jumping")!=-1){
showImage=StaticValue.allMarioImage.get(9);
}else if(status.indexOf("right-jumping")!=-1){
showImage=StaticValue.allMarioImage.get(4);
}else{
showImage=StaticValue.allMarioImage.get(index);
}
try {
Thread.sleep(20);//参数 long(毫秒)
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
//三目童子
private void dead() {
life--;
if(life == 0){
//Mario所有的命都没有了
live=false;
}else{
//让Mario和敌人以及障碍物全部重置
this.reset();
bg.reset();
}
}
public void reset(){
x=0;
y=480;
}
public int getX() {
return x;
}
public int getY() {
return y;
}
public BufferedImage getShowImage() {
return showImage;
}
public void setX(int i) {
// TODO Auto-generated method stub
this.x=i;
}
}
4.MyFrame类 主程序类
package com.sy.mario;
import java.awt.Color;
import java.awt.Graphics;
import java.awt.event.KeyAdapter;
import java.awt.event.KeyEvent;
import java.awt.event.KeyListener;
import java.awt.image.BufferedImage;
import java.util.ArrayList;
import java.util.Iterator;
import java.util.List;
import javax.swing.JFrame;
import javax.swing.JOptionPane;
//1.画出游戏的窗口 2.画出窗口默认的背景 3.画出障碍物
//4.画出主人公Mario 5.处理Mario的横向移动 6.切换图片
//7.处理Mario横向遇到障碍物
//8.完成Mario的基本跳跃 9.处理障碍物死亡问题 10.画出敌人
//11.处理敌人移动 12.完成Mario遇到敌人的情况
//13.处理切换场景 14.完成Mario多条生命
//15.处理开机画面 16.处理线程挂载（冻结起来）
public class MyFrame extends JFrame{
//定义所有的场景的集合
List<BackGround> allbg=new ArrayList<BackGround>();
//定义当前的场景
BackGround nowbg;
//定义当前的主人公
Mario m;
//操作Jump的boolean变量 $￥
public static boolean 跳跃=true;
//定义游戏是否开始
public static boolean 开始=false;
public MyFrame(){
//初始化图片
StaticValue.init();
//初始化场景
for(int i=1;i<=3;i++){
allbg.add(new BackGround(i,i==3?true:false));
}
//初始化当前的场景【默认关数=1】
nowbg=allbg.get(0);
//初始化Mario
m=new Mario(0,480);
//告诉mario在哪一个场景中
m.setBg(nowbg);
//窗口基本的设置
//标题
this.setTitle("超级玛丽");
//大小
this.setSize(900,600);
//固定大小
this.setResizable(false);
//关闭
this.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
//显示
this.setVisible(true);
//完成键盘的监听
this.addKeyListener(new MyListener());
//实现界面的刷新
new Thread(new MyThread()).start();
}
//内部类（成员、静态、局部、匿名）
private class MyListener extends KeyAdapter
implements KeyListener{//F4
//压下
public void keyPressed(KeyEvent e) {
int key=e.getKeyCode();//ASCII
if(开始){
if(key == KeyEvent.VK_LEFT){
//调用mario朝左移动方法
m.leftmove();
}
if(key == KeyEvent.VK_RIGHT){
//调用mario朝右移动方法
m.rightmove();
}
if(key == KeyEvent.VK_SPACE){
//调用mario上升的方法
if(跳跃)
m.jump();
}
}else{
if(key == KeyEvent.VK_SPACE){
//说明游戏开始
开始=true;
//解冻
nowbg.resume();
}
}
}
//松开
public void keyReleased(KeyEvent e) {
int key=e.getKeyCode();
if(开始){
if(key == KeyEvent.VK_LEFT){
//调用mario朝左停止方法
m.leftstop();
}
if(key == KeyEvent.VK_RIGHT){
//调用mario朝右停止方法
m.rightstop();
}
}
}
}
private class MyThread implements Runnable{
public void run() {
while(true){
//处理游戏通关
if(nowbg.通关){
//显示对话框
JOptionPane.showMessageDialog(null, "恭喜你，大内低手");
//关闭JVM
System.exit(-1);
}
//切换场景
if(m.getX()>=840){
//1.获取当前的场景
int n=nowbg.getSort();
//2.设置游戏下一个场景
nowbg=allbg.get(n+1-1);
//3.重置m的横坐标
m.setX(0);
//4.告诉Mario你也需要切换场景
m.setBg(nowbg);
//解冻
nowbg.resume();
}
//根据Mario的live判断游戏是否结束
if(!m.live){
//显示对话框
JOptionPane.showMessageDialog(null, "mario死亡,游戏结束");
//关闭JVM
System.exit(-1);
}
try {
Thread.sleep(100);
} catch (InterruptedException e) {
e.printStackTrace();
}
//repaint/update
repaint();//重绘reset+paint
}
}
}
//绘制方法(main函数系统会刷新调用)
public void paint(Graphics g) {
// super.paint(g);
//定义临时变量(没有内存的 和方法)帮助我们解决闪烁问题(桌布)
BufferedImage image=new BufferedImage(900,600,BufferedImage.TYPE_3BYTE_BGR);
Graphics g2 = image.getGraphics();
if(开始){
//绘制背景(参数：图片 坐标 当前对象)
g2.drawImage(nowbg.getShowImage(),0, 0, this);
//绘制障碍物
Iterator<Obstrcution> its = nowbg.getAllobs().iterator();
while(its.hasNext()){
Obstrcution obs=its.next();
g2.drawImage(obs.getShowImage(),obs.getX(),obs.getY(),this);
}
//绘制Mario
g2.drawImage(m.getShowImage(),m.getX(),m.getY(),this);
//绘制敌人 擦式类型
Iterator<Enemy> it2 = nowbg.getAllenemys().iterator();
while(it2.hasNext()){
Enemy e=it2.next();//返回值是Object
g2.drawImage(e.getShowImage(), e.getX(), e.getY(), this);
}
}else{
//绘制开机的画面
g2.drawImage(StaticValue.startImage,0,0,this);
}
//将image(桌布)整体和g发生关系
g.drawImage(image,0,0,this);
}
public static void main(String[] args) {
new MyFrame();
}
}
5.Obstrcution类
package com.sy.mario;
import java.awt.image.BufferedImage;
//障碍物
public class Obstrcution implements Runnable{
private int x,y;//坐标
private int type;//类型
private BufferedImage showImage;//图片
//定义保存原来障碍物类型的变量
private int startType;
//相互持有
BackGround bg;
public int getType(){
return type;
}
public Obstrcution(int x, int y, int type,BackGround bg) {
super();
this.x = x;
this.y = y;
this.startType=this.type = type;
this.bg=bg;
//根据type确定showImage
setType(type);
//如果是旗帜
if(11 == type)
new Thread(this).start();
}
public int getX() {
return x;
}
public int getY() {
return y;
}
public BufferedImage getShowImage() {
return showImage;
}
public void setType(int i) {
this.type=i;
showImage=StaticValue.allObstructionImage.get(type);
}
public void run() {
// TODO Auto-generated method stub
while(true){
//如果场景通知旗帜下落
if(bg.旗帜下落){
if(y<420){
y+=5;
}
if(y == 420){
y=420;
//降旗完毕
bg.降旗完毕=true;
}
}
try {
Thread.sleep(100);
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
public void reset() {
//setType(startType);
this.type=startType;
setType(type);
}
}
6.StaticValue类
package com.sy.mario;
import java.util.ArrayList;
import java.util.Collection;
import java.util.List;
import java.awt.image.BufferedImage;
import java.io.File;
import java.io.IOException;
import javax.imageio.ImageIO;
//将所有的图片加载到集合或者变量属性中，帮助开发
public class StaticValue {
//程序运行的时候，数据是存放在变量里面，临时存放在内存中 //想做java高级开放，至少配16G的内存
//8种基本数据类型，其他的就是引用类型，重点要掌握java中的集合 Collection 和 map
//list集合存放元素的特点：有序（下标从0开始），可重复
//以下所有变量就是用来存放游戏的图片资源
public static List<BufferedImage> allMarioImage=new ArrayList<BufferedImage>();
public static BufferedImage startImage = null;
public static BufferedImage endImage = null;
public static BufferedImage bgImage = null;
public static List<BufferedImage> allFlowerImage=new ArrayList<BufferedImage>();
public static List<BufferedImage> allTriangleImage=new ArrayList<BufferedImage>();
public static List<BufferedImage> allTurtleImage=new ArrayList<BufferedImage>();
public static List<BufferedImage> allObstructionImage=new ArrayList<BufferedImage>();
public static BufferedImage marioDeadImage = null;
public static String imagePath=System.getProperty("user.dir")+"/bin/";
// C:\Users\Administrator\
// workspace\ssh\j1910_MarioV1.0/bin/
//将全部图片初始化 注解模式（单元测试:public void test()）
public static void init(){
//System.out.println(imagePath);//此方法用来测试是否能够加载到所有图片
//玛丽的10张图片
for(int i=1;i<=10;i++){
try {//read or write mkdirs createNewFile()
// allMarioImage.add(ImageIO.read(new File(System.getProperty("user.dir")+"/bin"+i+".jpg")));
//list用add方法向集合中添加元素，文件必须用IO去读取，此刻用ImageIO去读取图片
//imagePath+i+".gif" 是拼接的图片的路径
allMarioImage.add(ImageIO.read(new File(imagePath+i+".gif")));
} catch (IOException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}
try {
startImage=ImageIO.read(new File(imagePath+"start.gif"));
endImage=ImageIO.read(new File(imagePath+"firststageend.gif"));
bgImage=ImageIO.read(new File(imagePath+"firststage.gif"));
marioDeadImage=ImageIO.read(new File(imagePath+"over.gif"));
} catch (IOException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
for(int i=1;i<=5;i++){
try {
if(i<=2){
allFlowerImage.add(ImageIO.read(new File(imagePath+"flower"+i+".gif")));
}
if(i<=3){
allTriangleImage.add(ImageIO.read(new File(imagePath+"triangle"+i+".gif")));
}
allTurtleImage.add(ImageIO.read(new File(imagePath+"Turtle"+i+".gif")));
} catch (IOException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}
for(int i=1;i<=12;i++){
try {
allObstructionImage.add(ImageIO.read(new File(imagePath+"ob"+i+".gif")));
} catch (IOException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}
}
}
