test
代码：
主类：
创建游戏窗口对象，调用启动方法
public class TankWar {
public static void main(String[] args) {
//创建游戏窗口对象,调用运行方法
new GamePanel().lunch();
}
}
游戏对象类：
所有游戏对象的超类
1 import java.awt.*;
2
3 public abstract class GameObject {
4 //图像
5 protected Image image;
6 //坐标
7 protected int x;
8 protected int y;
9 //定义四个bool方向变量，当方向变量为true时进行移动
10 protected boolean left = false;
11 protected boolean right = false;
12 protected boolean down = false;
13 protected boolean up = false;
14 //设置Jframe容器
15 protected GamePanel gamePanel;
16 //构造方法
17 public GameObject(String image, int x, int y, GamePanel gamePanel) {
18 this.image = Toolkit.getDefaultToolkit().getImage(image);
19 this.x = x;
20 this.y = y;
21 this.gamePanel = gamePanel;
22 }
23 //绘制自己
24 public abstract void paintSelf(Graphics g);
25 //返回矩形进行碰撞检测
26 public abstract Rectangle gerRec();
27 }
坦克类：
子类有玩家和地方坦克类
1 import java.awt.*;
2 import java.awt.event.KeyEvent;
3 import java.util.ArrayList;
4 import java.util.Iterator;
5 import java.util.Random;
6 //坦克类
7 public abstract class Tank extends GameObject {
8 //定义移动次数
9 public int movetime= 0;
10 //定义坦克长宽
11 public int width = 40;
12 public int height = 40;
13 //移动速度
14 protected int speed = 5;
15 // 定义初始方向
16 public Direction direction ;
17 // 定义子弹发射冷却变量
18 boolean attackCoolDown = true;
19 //定义四个方向图片
20 private String upImg;
21 private String downImg;
22 private String leftImg;
23 private String rightImg;
24
25
26 public Tank(String image, int x, int y, GamePanel gamePanel, String upImg, String downImg, String leftImg, String rightImg) {
27 super(image, x, y, gamePanel);
28 this.upImg = upImg;
29 this.downImg = downImg;
30 this.leftImg = leftImg;
31 this.rightImg = rightImg;
32 }
33
34 //定义移动方法
35 //向左移动
36 public void leftward() {
37 //判断的时坦克下一步移动的位置是否发生碰撞，如果没有碰撞到墙或者边界或者物体，则进行移动，否则只设置图片和方向;
38 if (hitWall(x-speed,y)&&hitTank(x-speed,y))
39 x -= speed;
40 setImg(leftImg);
41 direction = Direction.LEFT;
42 }
43
44 public void rightward() {
45 if (hitWall(x+speed,y)&&hitTank(x+speed,y))
46 x += speed;
47 setImg(rightImg);
48 direction = Direction.RIGHT;
49 }
50
51 public void upward() {
52 if (hitWall(x,y-speed)&&hitTank(x,y-speed))
53 y -= speed;
54 setImg(upImg);
55 direction = Direction.UP;
56 }
57
58 public void downward() {
59 if (hitWall(x,y+speed)&&hitTank(x,y+speed))
60 y += speed;
61 setImg(downImg);
62 //枚举
63 direction = Direction.DOWN;
64 }
65
66 //设置坦克图片
67 private void setImg(String Img) {
68 this.image = Toolkit.getDefaultToolkit().getImage(Img);
69 }
70
71 //攻击方法，在键盘监听事件中调用攻击方法
72 public void attack() {
73 //如果攻击冷却为true则攻击
74 if (attackCoolDown) {
75 //创建子弹对象
76 //获取坦克头部坐标
77 Point p = getHeadPoint();
78 Bullet bullet = new Bullet("images/bullet.png", p.x, p.y, this.gamePanel, direction);
79 //将子弹添加到子弹集合中
80 gamePanel.bullets.add(bullet);
81 //启动线程，每隔一秒更改攻击冷却变量，实现攻击间隔为一秒
82 new MyThread().start();
83 }
84
85 }
86 //检测是否碰撞到坦克，若碰撞则返回false，否则返回true;
87 public boolean hitTank(int a,int d)
88 {
89 Rectangle newrec = new Rectangle(a, d, width, height);
90 //获得地方坦克集合，遍历
91 ArrayList<Bot> bots = gamePanel.bots;
92 for (Bot b : bots)
93 {
94 if (b==this)
95 break;
96 //利用intersects方法检测是否发生碰撞
97 if (b.gerRec().intersects(newrec))
98 {
99 //即将发生碰撞将该坦克移动次数设置为39，进行下一次移动则改变方向
100 this.movetime = 39;
101 return false;
102 }
103 }
104 return true;
105 }
106 //检测是否与围墙、边界、玩家和基地碰撞
107 public boolean hitWall(int a,int b)
108 {
109 Rectangle newrec = new Rectangle(a, b, width, height);
110 //获取围墙集合
111 ArrayList<Wall> walls = gamePanel.walls;
112 for (Wall w : walls)
113 {
114 if (w.gerRec().intersects(newrec))
115 {
116 this.movetime = 39;
117 return false;
118 }
119 }
120 //检测是否碰撞边界
121 if (a<=5||a+width>=780||b<=25||b+height>=600)
122 return false;
123 //检测是否碰撞基地
124 if (newrec.intersects(gamePanel.base.gerRec()))
125 return false;
126 //检测是否碰撞玩家
127 if (this!=gamePanel.player)
128 {
129 if (this.gerRec().intersects(gamePanel.player.gerRec()))
130 return false;
131 }
132 return true;
133 }
134 //得到坦克炮口坐标
135 public Point getHeadPoint() {
136 switch (direction) {
137 case UP:
138 return new Point(x + width / 2, y);
139 case DOWN:
140 return new Point(x + width / 2, y + height);
141 case LEFT:
142 return new Point(x, y + height / 2);
143 case RIGHT:
144 return new Point(x + width, y + height / 2);
145 }
146 return null;
147 }
148
149
150 @Override
151 public abstract void paintSelf(Graphics g);
152
153 @Override
154 public abstract Rectangle gerRec();
155
156 //自定义线程
157 class MyThread extends Thread {
158 @Override
159 public void run() {
160 attackCoolDown = false;
161 try {
162 MyThread.sleep(1000);
163 } catch (InterruptedException e) {
164 e.printStackTrace();
165 }
166 attackCoolDown = true;
167 this.stop();
168 }
169 }
170 }
玩家类
1 import java.awt.*;
2 import java.awt.event.KeyEvent;
3 import java.util.ArrayList;
4 import java.util.Iterator;
5
6 public class Player extends Tank{
7 public Player(String image, int x, int y, GamePanel gamePanel, String upImg, String downImg, String leftImg, String rightImg) {
8 super(image, x, y, gamePanel, upImg, downImg, leftImg, rightImg);
9 }
10 //添加键盘监听事件，按下则方向键则将坦克该方向设置为true
11 public void keyPressed(KeyEvent k) {
12
13 switch (k.getKeyCode()) {
14 case KeyEvent.VK_UP:
15 up = true;
16 break;
17 case KeyEvent.VK_DOWN:
18 down = true;
19 break;
20 case KeyEvent.VK_LEFT:
21 left = true;
22 break;
23 case KeyEvent.VK_RIGHT:
24 right = true;
25 break;
26 //按下空格调用攻击键
27 case KeyEvent.VK_SPACE:
28 attack();
29 }
30 }
31 //按键松开时，将方向变量设为false，实现键盘按住不放时坦克可以持续移动
32 public void keyReleased(KeyEvent k) {
33 switch (k.getKeyCode()) {
34 case KeyEvent.VK_UP:
35 up = false;
36 break;
37 case KeyEvent.VK_DOWN:
38 down = false;
39 break;
40 case KeyEvent.VK_LEFT:
41 left = false;
42 break;
43 case KeyEvent.VK_RIGHT:
44 right = false;
45 break;
46 }
47 }
48 //方向变量为true则调用对应的移动方法
49 private void move() {
50 if(left)
51 leftward();
52 else if(right)
53 rightward();
54 else if(up)
55 upward();
56 else if(down)
57 downward();
58 }
59 //绘制自己，同时调用移动方法
60 @Override
61 public void paintSelf(Graphics g) {
62 g.drawImage(image,x,y,null);
63 move();
64 }
65 @Override
66 public Rectangle gerRec() {
67 return new Rectangle(x,y,width,height);
68 }
69 }
敌方坦克类
1 import java.awt.*;
2 import java.awt.event.KeyEvent;
3 import java.util.ArrayList;
4 import java.util.Random;
5 //敌方坦克类
6 public class Bot extends Tank{
7
8
9 public Bot(String image, int x, int y, GamePanel gamePanel, String upImg, String downImg, String leftImg, String rightImg) {
10 super(image, x, y, gamePanel, upImg, downImg, leftImg, rightImg);
11 direction = getRanDirect();
12 }
13
14 //自定义随机移动方法，当移动次数为40时随机改变方向
15 public void go()
16 {
17 //调用攻击方法
18 attack();
19 if (movetime == 40)
20 {
21 direction = getRanDirect();
22 movetime = 0;
23 }
24 else
25 movetime++;
26 switch (direction)
27 {
28 case DOWN:downward();break;
29 case LEFT:leftward();break;
30 case RIGHT:rightward();break;
31 case UP:upward();break;
32 }
33 }
34 //随机获取移动方向
35 public Direction getRanDirect()
36 {
37 Random random = new Random();
38 int i = random.nextInt(4);
39 switch (i)
40 {
41 case 0: return Direction.UP;
42 case 1: return Direction.DOWN;
43 case 2: return Direction.LEFT;
44 case 3: return Direction.RIGHT;
45 }
46 return null;
47 }
48
49 //重写攻击方法
50 @Override
51 public void attack()
52 {
53 if(attackCoolDown) {
54 Random random = new Random();
55 int i = random.nextInt(50);
56 if (i == 1) {
57 Point p = getHeadPoint();
58 EnemyBullet bullet = new EnemyBullet("images/bullet.png", p.x, p.y, this.gamePanel, direction);
59 this.gamePanel.bullets.add(bullet);
60 new MyThread().start();
61 }
62 }
63 }
64 //重写绘制方法，使用自定义移动方法
65 @Override
66 public void paintSelf(Graphics g) {
67 g.drawImage(image,x,y,null);
68 go();
69 }
70
71 @Override
72 public Rectangle gerRec() {
73 return new Rectangle(x,y,width,height);
74 }
75 }
子弹类
1 import java.awt.*;
2 import java.util.ArrayList;
3 import java.util.Iterator;
4 import java.util.ListIterator;
5
6 public class Bullet extends GameObject{
7 //尺寸
8 int width = 10;
9 int height = 10;
10 //速度
11 int speed = 20;
12 //方向
13 Direction direction;
14 //定义移动方法
15 public void leftword()
16 {
17 x -= speed;
18 }
19 public void rightword()
20 {
21 x += speed;
22 }
23 public void upword()
24 {
25 y -= speed;
26 }
27 public void downword()
28 {
29 y += speed;
30 }
31
32 public Bullet(String image, int x, int y, GamePanel gamePanel, Direction direction) {
33 super(image, x, y, gamePanel);
34 this.direction = direction;
35 }
36
37 public void go()
38 {
39 switch (direction)
40 {
41 case UP:
42 upword();break;
43 case DOWN:
44 downword();break;
45 case LEFT:
46 leftword();break;
47 case RIGHT:
48 rightword();break;
49 }
50 //检测是否到达边界
51 hitboder();
52 }
53 //检测是否碰撞边界
54 public void hitboder()
55 {
56 //到达边界将该子弹添加进清除子弹集合
57 if (x<=15||y<=45||x>=770||y>=580)
58 gamePanel.removelist.add(this);
59 }
60 //碰撞围墙，子弹和围墙消失
61 public void hitWall() {
62 //获取墙集合
63 ArrayList<Wall> walls = this.gamePanel.walls;
64 //获取围墙集合迭代器
65 ListIterator<Wall> wal = walls.listIterator();
66 while (wal.hasNext())
67 {
68 Wall b = wal.next();
69 if(this.gerRec().intersects(b.gerRec()))
70 {
71 //因为在增强for循环中，删除元素会造成异常，所以采用迭代器的删除方法
72 wal.remove();
73 //将子弹添加入清除子弹集合
74 this.gamePanel.removelist.add(this);
75 }
76 }
77 //如果子弹击中基地，设置为状态2游戏失败
78 if (this.gerRec().intersects(gamePanel.base.gerRec()))
79 {
80 gamePanel.state = 2;
81 }
82 }
83 //同碰撞围墙检测，检测是否碰撞地方坦克
84 public void hitBot() {
85 ArrayList<Bot> bots = this.gamePanel.bots;
86 ListIterator<Bot> bot = bots.listIterator();
87 while (bot.hasNext())
88 {
89 Bot b = bot.next();
90 if(this.gerRec().intersects(b.gerRec()))
91 {
92 bot.remove();
93 this.gamePanel.removelist.add(this);
94 }
95 }
96 }
97 @Override
98 public void paintSelf(Graphics g) {
99 g.drawImage(image,x,y,null);
100 this.go();
101 hitBot();
102 hitWall();
103 }
104
105 @Override
106 public Rectangle gerRec() {
107 return new Rectangle(x,y,width,height);
108 }
109 }
敌方子弹类：
//敌方子弹类，继承子弹类
public class EnemyBullet extends Bullet{
public EnemyBullet(String image, int x, int y, GamePanel gamePanel, Direction direction) {
super(image, x, y, gamePanel, direction);
}
//重写碰撞坦克方法，如果碰撞玩家则游戏结束
@Override
public void hitBot()
{
if(this.gerRec().intersects(this.gamePanel.player.gerRec()))
{
this.gamePanel.state = 2;
}
}
}
围墙类：
1 import java.awt.*;
2 //定义围墙类
3 public class Wall extends GameObject{
4 //定义长度
5 int length = 35;
6
7 public Wall(String image, int x, int y, GamePanel gamePanel) {
8 super(image, x, y, gamePanel);
9 }
10
11 @Override
12 public void paintSelf(Graphics g) {
13 g.drawImage(image,x,y,null);
14 }
15
16 @Override
17 public Rectangle gerRec() {
18 return new Rectangle(x,y,length,length);
19 }
20 }
基地类
1 import java.awt.*;
2 //基地类
3 public class Base extends GameObject{
4 //设置长度
5 int length = 35;
6
7 public Base(String image, int x, int y, GamePanel gamePanel) {
8 super(image, x, y, gamePanel);
9 }
10
11 @Override
12 public void paintSelf(Graphics g) {
13 g.drawImage(image,x,y,null);
14 }
15
16 @Override
17 public Rectangle gerRec() {
18 return new Rectangle(x,y,length,length);
19 }
20 }
GamePanel类
1 import javax.swing.*;
2 import java.applet.AudioClip;
3 import java.awt.*;
4 import java.awt.event.KeyAdapter;
5 import java.awt.event.KeyEvent;
6 import java.awt.event.KeyListener;
7 import java.util.ArrayList;
8 import java.util.Random;
9
10 public class GamePanel extends JFrame {
11 //游戏状态;设置状态为0:开始界面状态
12 int state = 0;
13 //窗口长宽
14 int width =800;
15 int height=610 ;
16 //双缓存图片
17 Image bufferImage = null;
18 //select指针初始坐标
19 int y = 260;
20 //重绘次数
21 int repaintNum = 0;
22 // 开始界面的坦克图标
23 Image select = Toolkit.getDefaultToolkit().getImage("images/right.jpg");
24 //基地
25 Base base = new Base("images/base.gif",340,570,this);
26 //子弹列表
27 ArrayList<Bullet> bullets = new ArrayList<>();
28 //敌方坦克列表
29 ArrayList<Bot> bots = new ArrayList<>();
30 //地方子弹列表
31 ArrayList<EnemyBullet> enemyBullets = new ArrayList<>();
32 //需要删除的地方子弹列表
33 ArrayList<Bullet> removelist = new ArrayList<>();
34 //墙列表
35 ArrayList<Wall> walls = new ArrayList<>();
36 //玩家
37 Player player = new Player("images/up.jpg",125,510,this,"images/up.jpg",
38 "images/down.jpg","images/left.jpg","images/right.jpg");
39
40
41 //窗口启动方法
42 public void lunch()
43 {
44 //添加键盘监听器
45 this.addKeyListener(new KeyMonitor());
46 //标题
47 setTitle("坦克大战");
48 //窗口初始大小
49 setSize(width,height);
50 //使屏幕居中
51 setLocationRelativeTo(null);
52 //添加关闭事件
53 setDefaultCloseOperation(3);
54 //用户不能调整大小
55 setResizable(false);
56 //使窗口可见
57 setVisible(true);
58 //创建敌方坦克和围墙
59 buildBot();
60 buildWall();
61 //每隔20ms重绘一次
62 while(true)
63 {
64 //如果坦克数量小于10并且每重绘三百次重新生成一个地方坦克
65 if(bots.size()<10&&repaintNum%300 == 0)
66 {
67 //获取随机坐标
68 Random random = new Random();
69 int xx = random.nextInt(700);
70 Bot bot = new Bot("images/bot_u.png",xx,110,this,"images/bot_u.png","images/bot_d.png","images/bot_l.png","images/bot_r.png");
71 //添加入敌方坦克列表
72 bots.add(bot);
73 }
74 //重绘
75 repaint();
76 //线程休眠50ms;
77 try {
78 Thread.sleep(50);
79 } catch (InterruptedException e) {
80 e.printStackTrace();
81 }
82 }
83 }
84 //创建坦克对象
85 private void buildBot() {
86 for(int i = 0;i<5;i++)
87 {
88 String img = null;
89 //随机获取坦克坐标
90 Random random = new Random();
91 int xx = random.nextInt(700);
92 int yy = random.nextInt(300);
93 int o = random.nextInt(4);
94 //随机获取坦克朝向
95 switch (o)
96 {
97 case 0 : img = "images/bot_u.png";break;
98 case 1 : img = "images/bot_d.png";break;
99 case 2 : img = "images/bot_l.png";break;
100 case 3 : img = "images/bot_r.png";break;
101 }
102 Bot bot = new Bot(img,xx,yy,this,"images/bot_u.png","images/bot_d.png","images/bot_l.png","images/bot_r.png");
103 bots.add(bot);
104 }
105 }
106 //建造围墙对象
107 private void buildWall() {
108 String wal = "images/wall.gif";
109 walls.add(new Wall(wal,100,200,this));
110 walls.add(new Wall(wal,100,240,this));
111 walls.add(new Wall(wal,100,280,this));
112 walls.add(new Wall(wal,100,320,this));
113 walls.add(new Wall(wal,100,360,this));
114 walls.add(new Wall(wal,360,180,this));
115 walls.add(new Wall(wal,400,180,this));
116 walls.add(new Wall(wal,320,180,this));
117 walls.add(new Wall(wal,280,180,this));
118 walls.add(new Wall(wal,500,250,this));
119 walls.add(new Wall(wal,540,295,this));
120 walls.add(new Wall(wal,580,340,this));
121 walls.add(new Wall(wal,700,100,this));
122 walls.add(new Wall(wal,700,140,this));
123 walls.add(new Wall(wal,700,180,this));
124 walls.add(new Wall(wal,700,220,this));
125 walls.add(new Wall(wal,300,560,this));
126 walls.add(new Wall(wal,300,520,this));
127 walls.add(new Wall(wal,340,520,this));
128 walls.add(new Wall(wal,380,520,this));
129 walls.add(new Wall(wal,380,560,this));
130 }
131 //定义清除列表函数，使用可变参数，可以传入多个集合;
132 public void clear(ArrayList ...al)
133 {
134 //遍历参数数组
135 for (ArrayList a : al)
136 {
137 //如果列表不为空则清空
138 if (a.size()!=0)
139 a.clear();
140 }
141 }
142
143 //paint方法
144 @Override
145 public void paint(Graphics g) {
146 //重绘次数+1
147 repaintNum++;
148 //现将元素绘制到图片，再将图片绘制到界面内，解决屏幕闪动问题;
149 if(bufferImage ==null)
150 {
151 bufferImage = this.createImage(width,height);
152 }
153 //获取图片的画笔
154 Graphics graphics = bufferImage.getGraphics();
155 //设置画笔颜色
156 graphics.setColor(Color.black);
157 //绘制实心矩形
158 graphics.fillRect(0,0,width,height);
159 //状态为0时，绘制游戏开始界面
160 if(state == 0)
161 {
162 //改变画笔颜色
163 graphics.setColor(new Color(158, 51, 51, 218));
164 //改变文字大小和样式
165 graphics.setFont(new Font("楷体",Font.BOLD,100));
166 //添加文字
167 graphics.drawString("BATTILE CITY",80,170);
168 graphics.setFont(new Font("微软雅黑",Font.BOLD,40));
169 graphics.setColor(Color.white);
170 graphics.drawString("开始游戏",320,300);
171 graphics.drawString("游戏说明",320,400);
172 graphics.drawImage(select,240,y,null);
173 }
174 //1: 游戏进行中界面
175 else if(state == 1){
176 //显示敌人数量
177 graphics.setFont(new Font("微软雅黑",Font.BOLD,20));
178 graphics.setColor(Color.white);
179 graphics.drawString("敌人数量:"+bots.size(),40,80);
180 //绘制玩家坦克
181 player.paintSelf(graphics);
182 //移除应该消灭的子弹
183 bullets.removeAll(removelist);
184 //遍历子弹集合，绘制子弹
185 for (Bullet b:bullets) {
186 b.paintSelf(graphics);
187 }
188 //遍历敌方子弹集合，绘制子弹
189 for (EnemyBullet b:enemyBullets) {
190 b.paintSelf(graphics);
191 }
192 //遍历敌方坦克集合，绘制敌方坦克
193 for(Bot b : bots)
194 {
195 b.paintSelf(graphics);
196 }
197 //遍历围墙集合，绘制围墙
198 for(Wall w : walls)
199 {
200 w.paintSelf(graphics);
201 }
202 //绘制基地
203 base.paintSelf(graphics);
204 //如果坦克数量为零，判定胜利，进入状态四
205 if (bots.size()==0)
206 state = 4;
207 }
208 //2: 绘制游戏失败界面
209 else if(state == 2)
210 {
211 //首先清空所有集合元素
212 clear(bullets,bots,walls,enemyBullets);
213 //绘制界面
214 graphics.drawImage(Toolkit.getDefaultToolkit().getImage("images/gameover.png"),50,0,null);
215 graphics.setFont(new Font("微软雅黑",Font.BOLD,40));
216 graphics.setColor(Color.white);
217 graphics.drawString("重新来过",320,300);
218 graphics.drawString("退出游戏",320,400);
219 graphics.drawImage(select,240,y,null);
220 }
221 //4: 绘制游戏胜利界面
222 else if (state == 4)
223 {
224 //改变画笔颜色
225 graphics.setColor(new Color(158, 51, 51, 218));
226 //改变文字大小和样式
227 graphics.setFont(new Font("楷体",Font.BOLD,100));
228 //添加文字
229 graphics.drawString("V I C T O R Y",80,170);
230 graphics.setFont(new Font("微软雅黑",Font.BOLD,40));
231 graphics.setColor(Color.white);
232 graphics.drawString("再来一次",320,300);
233 graphics.drawString("退出游戏",320,400);
234 graphics.drawImage(select,240,y,null);
235 }
236 //5: 绘制游戏说明界面
237 else if (state == 5)
238 {
239 graphics.setColor(Color.white);
240 graphics.setFont(new Font("楷体",Font.BOLD,40));
241 //添加文字
242 graphics.drawString("通过键盘上的方向键控制坦克移动，",80,170);
243 graphics.drawString("空格控制子弹发射，每隔一秒只能",80,230);
244 graphics.drawString("发射一颗子弹，敌方坦克击中我方",80,290);
245 graphics.drawString("坦克或者基地则游戏失败，消灭地",80,350);
246 graphics.drawString("方所有坦克则获得胜利。",80,410);
247 graphics.drawString("按enter键返回开始界面",80,470);
248 }
249 // 将图片绘制到界面中
250 g.drawImage(bufferImage,0,0,null);
251
252 }
253 //键盘监视器
254 class KeyMonitor extends KeyAdapter{
255 //按下键盘
256 @Override
257 public void keyPressed (KeyEvent e)
258 {
259 //监听游戏开始界面
260 if(state ==0)
261 {
262 //改变坦克图标位置
263 if(e.getKeyCode()==KeyEvent.VK_UP||e.getKeyCode()==KeyEvent.VK_DOWN)
264 {
265 if(y == 260)
266 y = 360;
267 else
268 y = 260;
269 }
270 //根据图标位置选择下一步状态
271 if(e.getKeyCode() == KeyEvent.VK_ENTER)
272 if(y==260)
273 //开始游戏
274 state = 1;
275 else
276 //游戏说明
277 state = 5;
278 }
279 //监听游戏运行时界面
280 else if(state == 1){
281 //为玩家添加键盘监听事件
282 player.keyPressed(e);
283 }
284 //监听游戏失败或者胜利界面
285 else if (state == 2||state ==4)
286 {
287 if(e.getKeyCode()==KeyEvent.VK_UP||e.getKeyCode()==KeyEvent.VK_DOWN)
288 {
289 if(y == 260)
290 y = 360;
291 else
292 y = 260;
293 }
294 if(e.getKeyCode() == KeyEvent.VK_ENTER)
295 {
296 //重新游戏，添加围墙，敌人，并设置玩家起始坐标，设置状态1开始游戏
297 if(y == 260)
298 {
299 buildBot();
300 buildWall();
301 state = 1;
302 player.x = 125;
303 player.y = 510;
304 }
305 //退出java虚拟机
306 else
307 System.exit(0);
308 }
309 //监听游戏说明界面
310 }
311 else if (state == 5)
312 {
313 if (e.getKeyCode() == KeyEvent.VK_ENTER)
314 state =0;
315 }
316 }
317 //为玩家添加键盘监听事件
318 @Override
319 public void keyReleased(KeyEvent e)
320 {
321 player.keyReleased(e);
322 }
323 }
324 }
枚举类
1 //枚举类
2 public enum Direction {
3 UP,DOWN,LEFT,RIGHT
4 }
运行截图：
状态0：
状态 5
状态 1
状态2 ：
状态 4：
游戏素材
浙公网安备 33010602011771号