package cn.tedu.submarine;
import javax.swing.*;
/** 战舰:是海洋对象 */
public class Battleship extends SeaObject {
private int life; //命数
/** 构造方法 */
public Battleship(){
super(66,26,270,124,20);
life = 5;
}
/** 重写move()移动 */
public void move(){
}
/** 重写getImage()获取对象的图片 */
public ImageIcon getImage(){
return Images.battleship; //返回战舰图片
}
/** 战舰发射深水炸弹---生成深水炸弹对象 */
public Bomb shoot(){
return new Bomb(this.x,this.y); //深水炸弹的坐标就是战舰的坐标
}
/** 战舰左移 */
public void moveLeft(){
x -= speed; //x-(向左)
}
/** 战舰右移 */
public void moveRight(){
x += speed; //x+(向右)
}
/** 战舰增命 */
public void addLife(int num){
life += num;
}
/** 获取命数 */
public int getLife(){
return life; //返回命数
}
/** 战舰减命 */
public void subtractLife(){
life--; //命数减1
}
}
package cn.tedu.submarine;
import javax.swing.*;
/** 深水炸弹:是海洋对象 */
public class Bomb extends SeaObject {
/** 构造方法 */
public Bomb(int x,int y){
super(9,12,x,y,3);
}
/** 重写move()移动 */
public void move(){
y += speed; //y+(向下)
}
/** 重写getImage()获取对象的图片 */
public ImageIcon getImage(){
return Images.bomb; //返回深水炸弹图片
}
/** 重写isOutOfBounds检测深水炸弹越界 */
public boolean isOutOfBounds(){
return y>=World.HEIGHT; //深水炸弹的y>=窗口的高，即为越界了
}
}
package cn.tedu.submarine;
/** 得命接口 */
public interface EnemyLife {
/** 得命 */
public int getLife();
}
package cn.tedu.submarine;
/** 得分接口 */
public interface EnemyScore {
/** 得分 */
public int getScore();
}
package cn.tedu.submarine;
import javax.swing.ImageIcon;
/** 图片类 */
public class Images {
// 公开的 静态的 图片数据类型 变量名
public static ImageIcon battleship; //战舰图片
public static ImageIcon obsersubm; //侦察潜艇图片
public static ImageIcon torpesubm; //鱼雷潜艇图片
public static ImageIcon minesubm; //水雷潜艇图片
public static ImageIcon mine; //水雷图片
public static ImageIcon bomb; //深水炸弹图片
public static ImageIcon sea; //海洋图
public static ImageIcon gameover; //游戏结束图
static{ //给静态图片赋值
battleship = new ImageIcon("img/battleship.png");
obsersubm = new ImageIcon("img/obsersubm.png");
torpesubm = new ImageIcon("img/torpesubm.png");
minesubm = new ImageIcon("img/minesubm.png");
mine = new ImageIcon("img/mine.png");
bomb = new ImageIcon("img/bomb.png");
sea = new ImageIcon("img/sea.png");
gameover = new ImageIcon("img/gameover.png");
}
public static void main(String[] args) {
System.out.println(battleship.getImageLoadStatus()); //返回8表示读取成功
System.out.println(obsersubm.getImageLoadStatus());
System.out.println(torpesubm.getImageLoadStatus());
System.out.println(minesubm.getImageLoadStatus());
System.out.println(mine.getImageLoadStatus());
System.out.println(bomb.getImageLoadStatus());
System.out.println(sea.getImageLoadStatus());
System.out.println(gameover.getImageLoadStatus());
}
}
package cn.tedu.submarine;
import javax.swing.*;
/** 水雷:是海洋对象 */
public class Mine extends SeaObject {
/** 构造方法 */
public Mine(int x,int y){
super(11,11,x,y,1);
}
/** 重写move()移动 */
public void move(){
y -= speed; //y-(向上)
}
/** 重写getImage()获取对象的图片 */
public ImageIcon getImage(){
return Images.mine; //返回水雷图片
}
/** 重写isOutOfBounds检测水雷越界 */
public boolean isOutOfBounds(){
return y<=150-height; //水雷的y<=150减去水雷的高，即为越界了(到水面)
}
}
package cn.tedu.submarine;
import javax.swing.ImageIcon;
/** 水雷潜艇:是海洋对象，也能得命 */
public class MineSubmarine extends SeaObject implements EnemyLife {
/** 构造方法 */
public MineSubmarine(){
super(63,19);
}
/** 重写move()移动 */
public void move(){
x += speed; //x+(向右)
}
/** 重写getImage()获取对象的图片 */
public ImageIcon getImage(){
return Images.minesubm; //返回水雷潜艇图片
}
/** 水雷潜艇发射水雷(生成水雷对象) */
public Mine shootMine(){ //this:水雷潜艇
int x = this.x+this.width; //x:水雷潜艇的x+水雷潜艇的width
int y = this.y-11; //y:水雷潜艇的y-11(水雷的高)
return new Mine(x,y); //返回水雷对象
}
/** 重写getLife()得命 */
public int getLife(){
return 1; //打掉水雷潜艇，战舰得1条命
}
}
package cn.tedu.submarine;
import javax.swing.*;
/** 侦察潜艇:是海洋对象，也能得分 */
public class ObserveSubmarine extends SeaObject implements EnemyScore {
/** 构造方法 */
public ObserveSubmarine(){
super(63,19);
}
/** 重写move()移动 */
public void move(){
x += speed; //x+(向右)
}
/** 重写getImage()获取对象的图片 */
public ImageIcon getImage(){
return Images.obsersubm; //返回侦察潜艇图片
}
/** 重写getScore()得分 */
public int getScore(){
return 10; //打掉侦察潜艇，玩家得10分
}
}
package cn.tedu.submarine;
import java.util.Random;
import javax.swing.ImageIcon;
import java.awt.Graphics;
/** 海洋对象 */
public abstract class SeaObject {
public static final int LIVE = 0; /** 活着的 */
public static final int DEAD = 1; /** 死了的 */
protected int state = LIVE; //当前状态(默认为活着的)
protected int width; //宽
protected int height; //高
protected int x; //x坐标
protected int y; //y坐标
protected int speed; //移动速度
/** 专门给侦察潜艇、鱼雷潜艇、水雷潜艇提供的 */
//因为三种潜艇的宽/高是不同的，所以数据不能写死，需传参写活
//因为三种潜艇的x/y/speed是相同的，所以数据直接写死
public SeaObject(int width,int height){
this.width = width;
this.height = height;
x = -width; //负的潜艇的宽
Random rand = new Random(); //随机数对象
y = rand.nextInt(World.HEIGHT-height-150+1)+150; //150到(窗口高-潜艇高)之内的随机数
speed = rand.nextInt(3)+1; //1到3
}
/** 专门给战舰、水雷、深水炸弹提供的 */
//因为战舰/水雷/深水炸弹的宽/高/x/y/spped都是不同时，所以数据不能写死，需传参写活
public SeaObject(int width,int height,int x,int y,int speed){
this.width = width;
this.height = height;
this.x = x;
this.y = y;
this.speed = speed;
}
/** 对象移动 */
public abstract void move();
/** 获取对象的图片 */
public abstract ImageIcon getImage();
/** 判断对象是否是活着的 */
public boolean isLive(){
return state==LIVE; //若当前状态为LIVE，则表示活着的，返回true，否则返回false
}
/** 判断对象是否是死了的 */
public boolean isDead(){
return state==DEAD; //若当前状态为DEAD，则表示死了的，返回值true，否则返回false
}
/** 画对象 g:画笔 */
public void paintImage(Graphics g){
if(isLive()){ //若活着的
this.getImage().paintIcon(null,g,this.x,this.y);
}
}
/** 检测潜艇越界 */
public boolean isOutOfBounds(){
return x>=World.WIDTH; //潜艇的x>=窗口的宽，即为越界了
}
/** 检测碰撞 this:当前对象 other:另一个对象 */
public boolean isHit(SeaObject other){
//假设:this指代潜艇，other指代炸弹
int x1 = this.x-other.width; //x1:潜艇的x-炸弹的宽
int x2 = this.x+this.width; //x2:潜艇的x+潜艇的宽
int y1 = this.y-other.height; //y1:潜艇的y-炸弹的高
int y2 = this.y+this.height; //y2:潜艇的y+潜艇的高
int x = other.x; //x:炸弹的x
int y = other.y; //y:炸弹的y
return x>=x1 && x<=x2
&&
y>=y1 && y<=y2; //x在x1与x2之间，并且，y在y1与y2之间，即为撞上了
}
/** 海洋对象去死 */
public void goDead(){
state = DEAD; //将对象状态修改为DEAD死了的
}
}
package cn.tedu.submarine;
import javax.swing.*;
import java.util.Random;
/** 鱼雷潜艇:是海洋对象，也能得分 */
public class TorpedoSubmarine extends SeaObject implements EnemyScore {
/** 构造方法 */
public TorpedoSubmarine(){
super(64,20);
}
/** 重写move()移动 */
public void move(){
x += speed; //x+(向右)
}
/** 重写getImage()获取对象的图片 */
public ImageIcon getImage(){
return Images.torpesubm; //返回鱼雷潜艇图片
}
/** 重写getScore()得分 */
public int getScore(){
return 40; //打掉鱼雷潜艇，玩家得40分
}
}
package cn.tedu.submarine;
import javax.swing.JFrame;
import javax.swing.JPanel; //1.
import java.awt.Graphics;
import java.util.Timer;
import java.util.TimerTask;
import java.util.Random;
import java.util.Arrays;
import java.awt.event.KeyAdapter;
import java.awt.event.KeyEvent;
/** 整个游戏世界 */
public class World extends JPanel { //2.
public static final int WIDTH = 641; /** 窗口的宽 */
public static final int HEIGHT = 479; /** 窗口的高 */
public static final int RUNNING = 0; /** 运行状态 */
public static final int GAME_OVER = 1; /** 游戏结束状态 */
private int state = RUNNING; //当前状态(默认为运行状态)
//如下这一堆为窗口中所显示的对象
private Battleship ship = new Battleship(); //战舰
private SeaObject[] submarines = {}; //潜艇(侦察潜艇、鱼雷潜艇、水雷潜艇)数组
private Mine[] mines = {}; //水雷数组
private Bomb[] bombs = {}; //深水炸弹数组
/** 生成潜艇(侦察潜艇、鱼雷潜艇、水雷潜艇)对象 */
public SeaObject nextSubmarine(){
Random rand = new Random(); //随机数对象
int type = rand.nextInt(20); //0到19
if(type<10){ //0到9时，返回侦察潜艇对象
return new ObserveSubmarine();
}else if(type<11){ //10到14，返回鱼雷潜艇对象
return new TorpedoSubmarine();
}else{ //15到19时，返回水雷潜艇对象
return new MineSubmarine();
}
}
private int subEnterIndex = 0; //潜艇入场计数
/** 潜艇(侦察潜艇、鱼雷潜艇、水雷潜艇)入场 */
public void submarineEnterAction(){ //每10毫秒走一次
subEnterIndex++; //每10毫秒增1
if(subEnterIndex%40==0) { //每400(40*10)毫秒走一次
SeaObject obj = nextSubmarine(); //获取潜艇对象
submarines = Arrays.copyOf(submarines,submarines.length+1); //扩容
submarines[submarines.length-1] = obj; //将obj添加到submarines的最后一个元素上
}
}
private int mineEnterIndex = 0; //水雷入场计数
/** 水雷入场 */
public void mineEnterAction(){ //每10毫秒走一次
mineEnterIndex++; //每10毫秒增1
if(mineEnterIndex%100==0){ //每1秒(100*10)走一次
for(int i=0;i<submarines.length;i++){ //遍历所有潜艇
if(submarines[i] instanceof MineSubmarine){ //若潜艇为水雷潜艇
MineSubmarine ms = (MineSubmarine)submarines[i]; //将潜艇强转为水雷潜艇类型
Mine obj = ms.shootMine(); //获取水雷对象
mines = Arrays.copyOf(mines,mines.length+1); //扩容
mines[mines.length-1] = obj; //将obj添加到最后一个元素上
}
}
}
}
/** 海洋对象移动 */
public void moveAction(){ //每10毫秒走一次
for(int i=0;i<submarines.length;i++){ //遍历所有潜艇
submarines[i].move(); //潜艇移动
}
for(int i=0;i<mines.length;i++){ //遍历所有水雷
mines[i].move(); //水雷移动
}
for(int i=0;i<bombs.length;i++){ //遍历所有深水炸弹
bombs[i].move(); //深水炸弹移动
}
}
/** 删除越界的海洋对象---避免内存泄漏 */
public void outOfBoundsAction(){ //每10毫秒走一次
for(int i=0;i<submarines.length;i++){ //遍历所有潜艇
if(submarines[i].isOutOfBounds() || submarines[i].isDead()){ //越界了或者死了的
submarines[i] = submarines[submarines.length-1];
submarines = Arrays.copyOf(submarines,submarines.length-1); //缩容(缩掉最后一个元素)
}
}
for(int i=0;i<mines.length;i++){ //遍历所有水雷
if(mines[i].isOutOfBounds() || mines[i].isDead()){ //越界了或者死了的
mines[i] = mines[mines.length-1]; //将越界水雷替换为最后一个元素
mines = Arrays.copyOf(mines,mines.length-1); //缩容(缩掉最后一个元素)
}
}
for(int i=0;i<bombs.length;i++){ //遍历所有深水炸弹
if(bombs[i].isOutOfBounds() || bombs[i].isDead()){ //越界了或者死了的
bombs[i] = bombs[bombs.length-1]; //将越界炸弹替换为最后一个元素
bombs = Arrays.copyOf(bombs,bombs.length-1); //缩容(缩掉最后一个元素)
}
}
}
private int score = 0; //玩家的得分
/** 深水炸弹与潜艇的碰撞 */
public void bombBangAction(){ //每10毫秒走一次
for(int i=0;i<bombs.length;i++){ //遍历所有深水炸弹
Bomb b = bombs[i]; //获取每个深水炸弹
for(int j=0;j<submarines.length;j++){ //遍历所有潜艇
SeaObject s = submarines[j]; //获取每个潜艇
if(b.isLive() && s.isLive() && s.isHit(b)){ //若都活着并且还撞上了
s.goDead(); //潜艇去死
b.goDead(); //深水炸弹去死
if(s instanceof EnemyScore){ //若被撞对象是分
EnemyScore es = (EnemyScore)s; //将被撞对象强转为得分接口
score += es.getScore(); //玩家得分
}
if(s instanceof EnemyLife){ //若被撞对象是命
EnemyLife ea = (EnemyLife)s; //将被撞对象强转为得命接口
int num = ea.getLife(); //获取命数
ship.addLife(num); //战舰增命
}
}
}
}
}
/** 水雷与战舰的碰撞 */
public void mineBangAction(){ //每10毫秒走一次
for(int i=0;i<mines.length;i++){ //遍历所有水雷
Mine m = mines[i]; //获取每一个水雷
if(m.isLive() && ship.isLive() && m.isHit(ship)){ //若都活着并且撞上了
m.goDead(); //水雷去死
ship.subtractLife(); //战舰减命
}
}
}
/** 检测游戏结束 */
public void checkGameOverAction(){ //每10毫秒走一次
if(ship.getLife()<=0){ //若战舰的命数<=0，表示游戏结束了
state = GAME_OVER; //则将当前状态修改为GAME_OVER游戏结束
}
}
/** 启动程序的执行 */
public void action(){
KeyAdapter k = new KeyAdapter() { //不要求掌握
/** 重写keyReleased()按键抬起事件 */
public void keyReleased(KeyEvent e) { //当按键抬起时会自动触发--不要求掌握
if(e.getKeyCode()==KeyEvent.VK_SPACE){ //若抬起的是空格键--不要求掌握
Bomb obj = ship.shoot(); //获取深水炸弹对象
bombs = Arrays.copyOf(bombs,bombs.length+1); //扩容
bombs[bombs.length-1] = obj; //将obj添加到bombs的最后一个元素上
}
if(e.getKeyCode()==KeyEvent.VK_LEFT){ //若抬起的是左键头--不要求掌握
ship.moveLeft(); //战舰左移
}
if(e.getKeyCode()==KeyEvent.VK_RIGHT){ //若抬起的是右键头--不要求掌握
ship.moveRight(); //战舰右移
}
}
};
this.addKeyListener(k); //不要求掌握
Timer timer = new Timer(); //定时器对象
int interval = 10; //定时间隔(以毫秒为单位)
timer.schedule(new TimerTask() {
public void run() { //定时干的事(每10毫秒自动发生)
submarineEnterAction(); //潜艇(侦察潜艇、鱼雷潜艇、水雷潜艇)入场
mineEnterAction(); //水雷入场
moveAction(); //海洋对象移动
outOfBoundsAction(); //删除越界的海洋对象
bombBangAction(); //深水炸弹与潜艇的碰撞
mineBangAction(); //水雷与战舰的碰撞
checkGameOverAction(); //检测游戏结束
repaint(); //重画(重新调用paint()画)
}
}, interval, interval); //定时计划
}
/** 重写paint()画 g:画笔 */
public void paint(Graphics g){ //每10毫秒走一次
switch(state){ //根据当前状态做不同的处理
case GAME_OVER: //游戏结束状态时，画游戏结束图
Images.gameover.paintIcon(null,g,0,0);
break;
case RUNNING: //运行状态时，画海洋图、对象、分和命
Images.sea.paintIcon(null,g,0,0); //画海洋图
ship.paintImage(g); //画战舰
for(int i=0;i<submarines.length;i++){ //遍历潜艇数组
submarines[i].paintImage(g); //画潜艇
}
for(int i=0;i<mines.length;i++){
mines[i].paintImage(g);
}
for(int i=0;i<bombs.length;i++){
bombs[i].paintImage(g);
}
g.drawString("SCORE: "+score,200,50); //画分------------不要求掌握
g.drawString("LIFE: "+ship.getLife(),400,50); //画命----不要求掌握
}
}
public static void main(String[] args) {
JFrame frame = new JFrame(); //3.
World world = new World();
world.setFocusable(true);
frame.add(world);
frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
frame.setSize(WIDTH+16, HEIGHT+39);
frame.setLocationRelativeTo(null);
frame.setVisible(true); //1)设置窗口可见 2)尽快调用paint()方法
world.action(); //启动程序的执行
}
}
潜艇大战图片链接:
扫一扫
8554
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
