package cn.edu.ahu.RapidSurvial;
import java.awt.Graphics;
import java.awt.Image;
import java.awt.Rectangle;
import java.awt.Toolkit;
import java.util.List;
/**
* 类
* @author Your风之恋(AHU - java - 课程设计)
*
*/
public class Bomb {
public static final int BWIDTH = 20; //宽度
public static final int BHEIGHT = 5; //高度
public static final int BXSPEED = 10; //x方向上的速度
public static final int BYSPEED = 10; //y方向上的速度
int x; //的左上角 x点的位置
int y; //的左上角 y点的位置
int w; //的宽度
int h; //的高度
RapidSurvialManager rsm; //持有RapidSurvialManager的引用
Fighter.Direction dir; //的方向
boolean isLive = true; //是否有效
boolean isEnemy; //区分敌我的量
public static int sid = 0; //记录战果
private static Toolkit tk =
Toolkit.getDefaultToolkit();
private static Image[] bombImage = null;
static {
bombImage = new Image[] {
tk.getImage(Bomb.class.getClassLoader().getResource("images/Bomb_LTR.png")),
tk.getImage(Bomb.class.getClassLoader().getResource("images/Bomb_RTL.png"))
};
}
//构造方法
public Bomb(int x, int y) {
this.x = x;
this.y = y;
this.w = BWIDTH;
this.h = BHEIGHT;
}
//构造方法
public Bomb(int x, int y, RapidSurvialManager rsm) {
this(x, y);
this.rsm = rsm;
}
//构造方法
public Bomb(int x, int y, RapidSurvialManager rsm, Fighter.Direction dir, boolean isEnemy) {
this(x, y, rsm);
this.dir = dir;
this.isEnemy = isEnemy;
}
//画出自己的方法
public void draw(Graphics g) {
if(!isLive) {
rsm.bombs.remove(this);
return;
}
if(!isEnemy) {
g.drawImage(bombImage[0], x, y, null);
} else {
g.drawImage(bombImage[1], x, y, null);
}
setPostion();
}
//根据方向计算下一重画的位置
private void setPostion() {
switch(dir) {
case LTR:
x += BXSPEED;
break;
case RTL:
x -= BXSPEED;
break;
}
//出界处理
if(x < 0 || y < 0 ||
x > RapidSurvialManager.MAINWIDTH ||
y > RapidSurvialManager.MAINHEIGHT) {
isLive = false;
}
}
//返回自己的大小
public Rectangle getRect() {
return new Rectangle(x, y, w, h);
}
//此方法用于与敌机一个子弹的碰撞检测
public boolean hitBomb(Bomb b) {
if(this.isLive
&& this.getRect().intersects(b.getRect())
&& b.isLive
&& b.isEnemy != this.isEnemy) {
Explode e = new Explode(x + BWIDTH, y + BHEIGHT, rsm);
rsm.explodes.add(e);
this.isLive = false;
b.isLive = false;
return true;
}
return false;
}
//此方法用于与敌机一群子弹的碰撞检测
public boolean hitBombs(List<Bomb> bombs) {
for(int i = 0; i < bombs.size(); i++) {
if(hitBomb(bombs.get(i))){
return true;
}
}
return false;
}
public boolean hitFighter(Fighter f) {
if(this.isLive
&& this.getRect().intersects(f.getRect())
&& f.isLive
&& f.isEnemy != this.isEnemy) {
Explode e = new Explode(x + BWIDTH, y + BHEIGHT, rsm);
rsm.explodes.add(e);
if(!f.isEnemy) {
f.setLifeValue(f.getLifeValue() - 1);
if(f.getLifeValue() <= 0) {
f.isLive = false;
}
} else {
f.isLive = false;
sid ++;
}
this.isLive = false;
return true;
}
return false;
}
//此方法用于与一群战机的碰撞检测
public boolean hitFighters(List<Fighter> enemys) {
for(int i = 0; i < enemys.size(); i++) {
if(hitFighter(enemys.get(i))){
return true;
}
}
return false;
}
}
package cn.edu.ahu.RapidSurvial;
import java.awt.Color;
import java.awt.Graphics;
/**
* 爆炸类
* @author Your风之恋(AHU - java - 课程设计)
*
*/
public class Explode {
int x; //产生爆炸的x点坐标
int y; //产生爆炸的y点坐标
RapidSurvialManager rsm; //持有RapidSurvialManager的引用
boolean isLive = true; //是否有效,是:true,否:false
int [] diameter = {4, 7, 12, 23, 34, 12, 6}; //模拟爆炸产生的半径
int step = 0; //爆炸的步数
//构造函数
public Explode(int x, int y, RapidSurvialManager rsm) {
this.x = x;
this.y = y;
this.rsm = rsm;
}
//画出自己的方法
public void draw(Graphics g) {
if(!isLive) {
rsm.explodes.remove(this);
return;
}
Color c = g.getColor();
g.setColor(Color.ORANGE);
if(step == diameter.length) {
isLive = false;
step = 0;
return;
}
g.fillOval(x, y, diameter[step], diameter[step]);
g.setColor(c);
step ++;
}
}
package cn.edu.ahu.RapidSurvial;
import java.awt.Color;
import java.awt.Graphics;
import java.awt.Image;
import java.awt.Rectangle;
import java.awt.Toolkit;
import java.awt.event.KeyEvent;
public class Fighter {
public static final int FWIDTH = 70; //战机宽度
public static final int FHEIGHT = 10; //战机高度
public static final int FXSPEED = 4; //战机在x方向上的速度
public static final int FYSPEED = 4; //战机在y方向上的速度
int x; //战机在x方向上的位置
int y; //战机在y方向上的位置
int w; //战机的宽度
int h; //战机的高度
Direction dir; //方向
RapidSurvialManager rsm; //持有RapidSurvialManager的引用
private boolean isUp = false; //键盘↑ 是否被按下,初始化为false
private boolean isDown = false; //键盘↓ 是否被按下,初始化为false
private boolean isRight = false; //键盘→ 是否被按下,初始化为false
private boolean isLeft = false; //键盘← 是否被按下,初始化为false
enum Direction {LTR, RTL}; //两个方向,LTR:从左向右,RTL:从右向左
boolean isEnemy; //区分敌我的量,是敌人:true,否则为false
boolean isLive = true; //判读是否存活,活着:true,否则为false
private int lifeValue = 10; //我方战机的生命值
int speed; //产生一个速度值
BloodBar bb = new BloodBar(); //可视的血量
static int isRelive = 0; //是否复活
private int superStarCounts = 1; //初始大决数
private static Toolkit tk =
Toolkit.getDefaultToolkit();
private static Image[] fighterImage = null;
static {
fighterImage = new Image[] {
tk.getImage(Fighter.class.getClassLoader().getResource("images/EnemysFighter.png")),
tk.getImage(Fighter.class.getClassLoader().getResource("images/MyFighter_LTR.png"))
};
}
//构造函数
Fighter(int x , int y,boolean isEnemy) {
this.x = x;
this.y = y;
this.w = FWIDTH;
this.h = FHEIGHT;
this.isEnemy = isEnemy;
}
//构造函数
Fighter(int x, int y, boolean isEnemy, RapidSurvialManager rsm) {
this(x, y, isEnemy);
this.rsm = rsm;
this.dir = Direction.LTR;
}
//构造函数
Fighter(int x, int y,boolean isEnemy, RapidSurvialManager rsm, Direction dir, int speed) {
this(x, y, isEnemy, rsm);
this.dir = dir;
this.speed = speed;
}
//设置lifeValue值
public void setLifeValue(int lifeValue) {
this.lifeValue = lifeValue;
}
//得到lifeValue值
public int getLifeValue() {
return lifeValue;
}
//设置superStarCounts值
public void setSuperStarCounts(int superStarCounts) {
this.superStarCounts = superStarCounts;
}
//得到superStarCounts值
public int getSuperStarCounts() {
return superStarCounts;
}
//用此方画出战机
public void draw(Graphics g) {
if(!isLive) {
if(isEnemy) {
rsm.enemys.remove(this);
}
return;
}
if(isEnemy) {
g.drawImage(fighterImage[0], x, y, null);
go();
} else {
g.drawImage(fighterImage[1], x, y, null);
setPostion();
bb.draw(g);
}
}
//让敌军动起来的方法
public void go() {
switch(dir) {
case LTR:
x += speed;
break;
case RTL:
x -= speed;
break;
}
}
//对按键被按下经行处理
public void keyPressed(KeyEvent e) {
int key = e.getKeyCode();
switch(key) {
case KeyEvent.VK_UP:
isUp = true;
break;
case KeyEvent.VK_RIGHT:
isRight = true;
break;
case KeyEvent.VK_DOWN:
isDown = true;
break;
case KeyEvent.VK_LEFT:
isLeft = true;
break;
}
setPostion();
}
//对按键被释放经行处理
public void keyReleased(KeyEvent e) {
int key = e.getKeyCode();
switch(key) {
case KeyEvent.VK_UP:
isUp = false;
break;
case KeyEvent.VK_RIGHT:
isRight = false;
break;
case KeyEvent.VK_DOWN:
isDown = false;
break;
case KeyEvent.VK_LEFT:
isLeft = false;
break;
case KeyEvent.VK_Q:
fire();
break;
case KeyEvent.VK_F2:
if(!isLive) {
isLive = true;
lifeValue = 10;
isRelive ++;
}
break;
case KeyEvent.VK_W:
if(getSuperStarCounts() == 0) {
return;
}
if(!isLive) {
return;
}
setSuperStarCounts(getSuperStarCounts() - 1);
superFire();
break;
}
}
//根据按键的组合确定下一次的位置
private void setPostion() {
if(isUp && !isRight && !isDown && !isLeft) {
y -= FYSPEED;
}
if(!isUp && isRight && !isDown && !isLeft) {
x += FXSPEED;
}
if(!isUp && !isRight && isDown && !isLeft) {
y += FYSPEED;
}
if(!isUp && !isRight && !isDown && isLeft) {
x -= FXSPEED;
}
if(isUp && isRight && !isDown && !isLeft) {
x += FXSPEED;
y -= FYSPEED;
}
if(isUp && !isRight && !isDown && isLeft) {
y -= FYSPEED;
x -= FXSPEED;
}
if(!isUp && isRight && isDown && !isLeft) {
x += FXSPEED;
y += FYSPEED;
}
if(!isUp && !isRight && isDown && isLeft) {
x -= FXSPEED;
y += FYSPEED;
}
//对战机的出界处理
if(x <= 0) {
x = 0;
}
if(y < 45) {
y = 45;
}
if(x + Fighter.FWIDTH > RapidSurvialManager.MAINWIDTH) {
x = RapidSurvialManager.MAINWIDTH - Fighter.FWIDTH;
}
if(y + Fighter.FHEIGHT + 52> RapidSurvialManager.MAINHEIGHT) {
y = RapidSurvialManager.MAINHEIGHT - Fighter.FHEIGHT - 52;
}
}
//战机的开火处理
public Bomb fire() {
if(!isLive) {
return null;
}
int x, y;
if(!isEnemy) {
x = this.x + Fighter.FWIDTH;
y = this.y + Fighter.FHEIGHT / 2 - Bomb.BHEIGHT / 2 + 22;
} else {
x = this.x;
y = this.y + Fighter.FHEIGHT / 2 - Bomb.BHEIGHT / 2 + 22;
}
Bomb b = new Bomb(x, y, rsm, dir, isEnemy);
rsm.bombs.add(b);
return b;
}
//放大决的方法
public SuperLine superFire() {
if(!isLive) {
return null;
}
SuperLine s = new SuperLine(x, rsm, dir);
rsm.superLines.add(s);
return s;
}
//得到自己的大小,用于碰撞检测
public Rectangle getRect() {
return new Rectangle(x, y, w, h*4);
}
//血块类
private class BloodBar {
public void draw(Graphics g) {
Color c = g.getColor();
if(lifeValue <= 5) {
g.setColor(Color.RED);
g.drawRect(x+20, y-20, w * 2 / 3, 4);
int w = FWIDTH * lifeValue / 10;
g.fillRect(x+20, y-20, w * 2 / 3, 4);
g.drawString(""+ lifeValue, x, y-13);
} else {
g.setColor(Color.GREEN);
g.drawRect(x+20, y-20, w * 2 / 3, 4);
int w = FWIDTH * lifeValue / 10;
g.fillRect(x+20, y-20, w * 2 / 3, 4);
g.drawString(""+ lifeValue, x, y-13);
g.setColor(c);
}
}
}
//吃SuperStar的方法
public boolean eat(SuperStar ss) {
if(this.isLive
&& ss.isLive
&& this.getRect().intersects(ss.getRect())) {
ss.isLive = false;
setSuperStarCounts(getSuperStarCounts() + 1);
return true;
}
return false;
}
public int getScore() {
return Bomb.sid - isRelive * 50;
}
}
package cn.edu.ahu.RapidSurvial;
import java.awt.Color;
import java.awt.Graphics;
import java.awt.Rectangle;
import java.util.List;
/**
* 游戏中的大决类
* @author Your风之恋(AHU - java - 课程设计)
*
*/
public class SuperLine {
public static final int SXSPEED = 10; //大决的移动速度
public static final int LWIDTH = 10; //大决的显示宽度
int x; //大决开始x坐标
int y; //大决开始y坐标
Fighter.Direction dir; //方向
RapidSurvialManager rsm; //持有RapidSurvialManager的引用
boolean isLive = true; //是否有效,是:true,否:false
//构造函数
SuperLine(int x, RapidSurvialManager rsm) {
this.x = x;
this.y = LWIDTH;
this.rsm = rsm;
}
//构造函数
SuperLine(int x, RapidSurvialManager rsm, Fighter.Direction dir) {
this(x, rsm);
this.dir = dir;
}
//画方法
public void draw(Graphics g) {
if(!isLive) {
rsm.superLines.remove(this);
return;
}
Color c = g.getColor();
g.setColor(Color.PINK);
g.fillRect(x, 0, LWIDTH, RapidSurvialManager.MAINHEIGHT);
g.setColor(c);
go();
}
//移动自己的方法
public void go() {
switch(dir) {
case LTR:
x += SXSPEED;
break;
case RTL:
x -= SXSPEED;
break;
}
if(x >= RapidSurvialManager.MAINWIDTH) {
isLive = false;
}
}
//拿到自己的大小,为碰撞检测服务
public Rectangle getRect() {
return new Rectangle(x, 0, y,RapidSurvialManager.MAINHEIGHT);
}
//与一个战机经行碰撞检测
public boolean hitFighter(Fighter f) {
if(this.isLive
&& this.getRect().intersects(f.getRect())
&& f.isLive) {
Explode e = new Explode(f.x, f.y,rsm);
rsm.explodes.add(e);
f.isLive = false;
Bomb.sid ++;
return true;
}
return false;
}
//与一群战机经行碰撞检测
public boolean hitFighters(List<Fighter> enemys) {
for(int i = 0; i < enemys.size(); i++) {
if(this.hitFighter(enemys.get(i))) {
return true;
}
}
return false;
}
}
package cn.edu.ahu.RapidSurvial;
import java.awt.Graphics;
import java.awt.Image;
import java.awt.Rectangle;
import java.awt.Toolkit;
/**
* 超星类
* @author Your风之恋(AHU - java - 课程设计)
*
*/
public class SuperStar {
public static final int SSWIDTH = 20; //超星的宽度
public static final int SSHEIGHT = 20; //超星的高度
int x; //超星初始化x点坐标
int y; //超星初始化y点坐标
int w; //超星的宽度
int h; //超星的高度
int speed; //超星的移动速度
boolean isLive = true; //是否有效,是:true,否:false
RapidSurvialManager rsm; //持有RapidSurvialManager的引用
Fighter.Direction dir; //方向
private static Toolkit tk =
Toolkit.getDefaultToolkit();
private static Image[] superStarImage = null;
static {
superStarImage = new Image[] {
tk.getImage(SuperStar.class.getClassLoader().getResource("images/SuperStar_RTL.png")),
};
}
//构造方法
public SuperStar(int x, int y, RapidSurvialManager rsm, Fighter.Direction dir,int speed) {
this.x = x;
this.y = y;
this.speed = speed;
this.w = SSWIDTH;
this.h = SSHEIGHT;
this.rsm = rsm;
this.dir = dir;
}
//画方法
public void draw(Graphics g) {
if(!isLive) {
rsm.superStars.remove(this);
return;
}
g.drawImage(superStarImage[0], x, y, null);
go();
}
//移动自己的方法
public void go() {
switch(dir) {
case LTR:
x += speed;
break;
case RTL:
x -= speed;
break;
}
if(x <= 0) {
isLive = false;
}
}
//得到自己的大小
public Rectangle getRect() {
return new Rectangle(x, y, w, h);
}
}
package cn.edu.ahu.RapidSurvial;
import java.awt.Color;
import java.awt.Font;
import java.awt.Frame;
import java.awt.Graphics;
import java.awt.Image;
import java.awt.event.KeyAdapter;
import java.awt.event.KeyEvent;
import java.awt.event.WindowAdapter;
import java.awt.event.WindowEvent;
import java.util.ArrayList;
import java.util.List;
import java.util.Random;
import cn.edu.ahu.RapidSurvial.Fighter.Direction;
/**
* 游戏的主类,用于管理其他图形元素
* @author Your风之恋(AHU - java - 课程设计)
*
*/
public class RapidSurvialManager extends Frame{
private static final long serialVersionUID = 1L;
public static final int MAINWIDTH = 1200; //主窗口的宽度
public static final int MAINHEIGHT = 600; //主窗口的高度
public static final int MAINXPOINT = 30; //主窗口初始化x点的位置
public static final int MAINYPOINT = 50; //主窗口初始化y点的位置
public static Random r= new Random(); //添加随机数产生器,用于控制敌方的AI
Image bufferImage = null; //双缓冲的缓冲图像,用双缓冲取消屏幕闪烁
public static int time = 0;
Fighter myFighter = new Fighter(50, 300, false, this); //创建主战机
List<Bomb> bombs = new ArrayList<Bomb>(); //炮弹集合
List<Fighter> enemys = new ArrayList<Fighter>(); //敌机集合
List<Explode> explodes = new ArrayList<Explode>(); //爆炸集合
List<SuperLine> superLines = new ArrayList<SuperLine>(); //大决集合
List<SuperStar> superStars = new ArrayList<SuperStar>(); //超星集合
//主线程入口
public static void main(String[] args) {
RapidSurvialManager rsm = new RapidSurvialManager();
rsm.launchGameFrame();
}
//重写paint()方法
public void paint(Graphics g) {
//显示一些基本信息,便于判断集合中的元素是否被删除
Color c = g.getColor();
g.setColor(Color.ORANGE);
Font font = g.getFont();
g.setFont(new Font("SansSerif", Font.ROMAN_BASELINE, 15));
g.drawString("游戏时间: " + showTime(), 25, 50);
g.drawString("消灭敌机: " + Bomb.sid, 25, 70);
g.drawString("剩余绝招: " + myFighter.getSuperStarCounts(), 150, 50);
g.drawString("游戏得分: " + myFighter.getScore(),150, 70);
g.setFont(font);
g.setColor(Color.RED);
g.drawLine(MAINXPOINT + MAINWIDTH * 4 / 5, MAINYPOINT - 25,
MAINXPOINT + MAINWIDTH * 4 / 5, MAINYPOINT + MAINHEIGHT);
g.setColor(c);
//画出主战机
myFighter.draw(g);
for(int i = 0; i < superStars.size(); i++) {
SuperStar ss = superStars.get(i);
myFighter.eat(ss);
ss.draw(g);
}
//判断如果超星数少于0,则添加
if (superStars.size() <= 0) {
for(int i = 0; i < r.nextInt(2); i++) {
boolean flag1 = true;
boolean flag2 = true;
int x = 0, y = 0;
while(flag1 || flag2) {
int t1 = r.nextInt(3000);
int t2 = r.nextInt(1000);
if(t1 <= 1100 && t1 >= 1000) {
x = t1;
flag1 = false;
}
if(t2 <= 550 && t2 >= 30) {
y = t2;
flag2 = false;
}
}
if(r.nextInt(500) > 495) {
superStars.add(new SuperStar(x, y, this, Direction.RTL, r.nextInt(6) + 4));
}
}
}
//画出大决
for(int i = 0; i < superLines.size(); i++) {
SuperLine s = superLines.get(i);
s.hitFighters(enemys);
//s.hitBombs(bombs);
s.draw(g);
}
//如果敌机数量少于3,则继续添加
if(enemys.size() <= 2) {
for(int i = 0; i < r.nextInt(10); i++) {
boolean flag1 = true;
boolean flag2 = true;
int x = 0, y = 0;
while(flag1 || flag2) {
int t1 = r.nextInt(3000);
int t2 = r.nextInt(1000);
if(t1 <= 1100 && t1 >= 1000) {
x = t1;
flag1 = false;
}
if(t2 <= 550 && t2 >= 30) {
y = t2;
flag2 = false;
}
}
enemys.add(new Fighter(x, y, true, this, Direction.RTL,r.nextInt(6) + 4));
}
}
//画出
for(int i = 0; i < bombs.size(); i++) {
Bomb b = bombs.get(i);
b.hitFighters(enemys);
b.hitFighter(myFighter);
b.hitBombs(bombs);
b.draw(g);
}
//画出敌机
for(int i = 0; i < enemys.size(); i++) {
Fighter f = enemys.get(i);
if(f.x <= 0) {
f.isLive = false;
}
if(f.isEnemy) {
if((r.nextInt(50)) > 48) {
f.fire();
}
}
f.draw(g);
}
//画出爆炸
for(int i = 0; i < explodes.size(); i++) {
Explode e = explodes.get(i);
e.draw(g);
}
}
//统一的主界面的调用函数
public void launchGameFrame() {
this.setBounds(MAINXPOINT, MAINYPOINT, MAINWIDTH, MAINHEIGHT);
this.setBackground(Color.BLACK);
this.setLayout(null);
//关闭窗口的处理
this.addWindowListener(new WindowAdapter() {
public void windowClosing(WindowEvent e) {
setVisible(false);
System.exit(0);
}
});
//按键处理
this.addKeyListener(new KeyAdapter() {
public void keyPressed(KeyEvent e) {
myFighter.keyPressed(e);
}
public void keyReleased(KeyEvent e) {
myFighter.keyReleased(e);
}
});
//在窗口显示前开始线程重画
new Thread(new PaintThread()).start();
this.setResizable(false);
this.setVisible(true);
}
//重写update()方法,实现双缓冲取消图像闪烁的情况
public void update(Graphics g) {
if(bufferImage == null) {
bufferImage =
this.createImage(MAINWIDTH, MAINHEIGHT);
}
Graphics gBuffer = bufferImage.getGraphics();
Color c = gBuffer.getColor();
gBuffer.setColor(Color.BLACK);
gBuffer.fillRect(0, 0, MAINWIDTH, MAINHEIGHT);
gBuffer.setColor(c);
paint(gBuffer);
g.drawImage(bufferImage, 0, 0,null);
}
//绘图线程---用于不断的重绘
class PaintThread implements Runnable {
int step = 0;
public void run() {
while(true) {
repaint();
try {
Thread.sleep(20);
} catch (InterruptedException e) {
e.printStackTrace();
}
step ++;
if(step % 50 == 0) {
time ++;
step = 0;
}
}
}
}
public String showTime() {
int hour = time / 3600;
int minite = (time - hour*3600) / 60;
int second = (time - hour*3600) % 60;
return hour + ":" + minite + ":" + second;
}
}
工程源码+ 文档+可执行文件:http://download.csdn.net/detail/haifengzhilian/4494594