Java练习之潜艇小游戏的实现

2024-04-02 19:04:59 114人浏览安东尼

Python 官方文档：入门教程 => 点击学习

摘要

首先是主方法里定义的窗口（这些都是固定的格式，不会的也没什么事，直接Ctrl+c+v就行，基本上看一下数据都能看的懂）写一个超类，超类里需要有潜艇，深水炸弹，水雷和战舰的宽，高，以

首先是主方法里定义的窗口（这些都是固定的格式，不会的也没什么事，直接Ctrl+c+v就行，基本上看一下数据都能看的懂）

写一个超类，超类里需要有潜艇，深水炸弹，水雷和战舰的宽，高，以及出场时的x，y坐标，和移动速度。所有对象的图片，所有对象的移动方法，以及碰撞

然后再写派生类，根据击败一个水雷潜艇，战舰会获得一条命，击败其他潜艇，战舰会获得分数，所以，需要定义两个接口，一个是用来加命，另一个用来加分

完整代码如下（图片什么的可以自己去找，只需要改一下Image类和各个对象的宽高就可以）

游戏世界World类

package cn.tedu.sunarine;
import javax.swing.JFrame;
import javax.swing.JPanel;
import java.awt.Graphics;
import java.util.Arrays;
import java.util.Random;
import java.util.Timer;
import java.util.TimerTask;
import java.awt.event.KeyAdapter;
import java.awt.event.KeyEvent;
//整个游戏世界
public class World extends JPanel {
    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(30);
        if(type<10){
            return new ObserveSubmarine();
        }else if(type<15){
            return new TorpedoSubmarine();
        }else{
            return new MineSubmarine();
        }
    }
 
    private int subEnterIndex = 0;
    //潜艇入场
    public void submarineEnterAction(){ //每10毫秒走一次
        subEnterIndex++;
        if(subEnterIndex%40==0){ //每40毫秒
            SeaObject obj = nextSubmarine();
            submarines = Arrays.copyOf(submarines,submarines.length+1);
            submarines[submarines.length-1] = obj;
        }
    }
 
    private int mineEnterIndex = 0;
    //鱼雷，水雷入场
    public void MineEnterAction(){
        mineEnterIndex++;
        if(mineEnterIndex%100==0){
            for (int i=0;i<submarines.length;i++){
                if (submarines[i] instanceof  MineSubmarine){
                    if (submarines[i].isLIVE()) {
                        MineSubmarine ms = (MineSubmarine) submarines[i];
                        Mine obj = ms.shootMine();
                        mines = Arrays.copyOf(mines, mines.length + 1);
                        mines[mines.length - 1] = obj;
                    }
                }
            }
        }
    }
 
    public void gameOver(){
        if (ship.getLife()<=0){
            state = GAME_OVER;
        }
    }
 
    //海洋对象移动
    public void moveAction(){
        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(){
        for(int i=0;i<submarines.length;i++){
            if(submarines[i].isOutOfBounds()){
                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] = 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] = bombs[bombs.length-1];
                bombs = Arrays.copyOf(bombs,bombs.length-1);
            }
        }
    }
 
    private  int score = 0;
 
    public void BombsBangAction(){
//深水炸弹炸潜艇
        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)){
                    b.GoDead();
                    s.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(){
        for (int i=0;i<mines.length;i++){
            Mine m= mines[i];
            if (m.isLIVE()&& ship.isLIVE()&&m.isHit(ship)){
                m.goDead();
                ship.subtratLife();
            }
        }
    }
 
 
    
    public void action(){
        KeyAdapter k = new KeyAdapter(){
 
            public void keyPressed(KeyEvent e) {
                if(e.geTKEyCode() == KeyEvent.VK_SPACE){
                    Bomb obj = ship.shoot(); //深水炸弹入场
                    bombs = Arrays.copyOf(bombs,bombs.length+1);
                    bombs[bombs.length-1] = obj;
                }
                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() {
                submarineEnterAction(); //潜艇(侦察、水雷、鱼雷)入场
                MineEnterAction();      //水雷入场
                moveAction();           //海洋对象移动
                BombsBangAction();      //深水炸弹和潜艇碰撞
                mineBangAction();       //水雷和战舰碰撞
                outOfBoundsAction();    //删除越界的对象
                gameOver();
                repaint();
            }
        }, interval, interval);
    }
 
    public void paint (Graphics g ){
        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();
        World world = new World();
        world.setFocusable(true);
        frame.add(world);
        frame.setResizable(false);
        frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
        frame.setSize(WIDTH, HEIGHT+19);
        frame.setLocationRelativeTo(null);
        frame.setVisible(true);
        world.action();
    }
}

定义一个SeaObject的类当作超类（父类），然后再写其他的派生类（子类）

package cn.tedu.sunarine;
 
import javax.swing.ImageIcon;
import java.awt.Graphics;
import java.util.Random;
 
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;
    protected int y;
    protected int speed;
 
    //三个潜艇
    public SeaObject(int width, int height) {
        this.width = width;
        this.height = height;
        x =-width;
        Random rand = new Random();
        y = rand.nextInt(497 - height - 150 + 1) + 150;
        speed = rand.nextInt(3) + 1;
    }
//水雷，战舰，炸弹
    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;
    }
    public void paintImage(Graphics g){
        if (isLIVE()){
            this.getImage().paintIcon(null,g,this.x,this.y);
        }
    }
    public boolean isOutOfBounds(){
        return x>=World.WIDTH;
    }
    public boolean isHit(SeaObject other){
        int x1 = this.x-other.width;
        int x2 = this.x+this.width;
        int y1 = this.y-other.height;
        int y2 = this.y+this.height;
        int x=other.x;
        int y=other.y;
        return x>=x1 && x<=x2 && y>=y1 && y<=y2;
    }
 
    public void goDead(){
        state =DEAD;
    }
}

在派生类的引用超类

鱼雷潜艇类

package cn.tedu.sunarine;
import javax.swing.ImageIcon；
 
//鱼雷潜艇
public class TorpedoSubmarine extends SeaObject implements EnemyScore{
    TorpedoSubmarine(){
        super(64,20);
    }
 
    @Override
    public void move() {
        x+=speed;
    }
    public ImageIcon getImage(){
        return Images.torpedo;
    }
    public boolean isOutOfBounds() {
        return x>=World.WIDTH;
    }
    public int getScore(){
        return 20;
    }
}

水雷潜艇类

package cn.tedu.sunarine;
import javax.swing.ImageIcon;
 
//水雷潜艇
public class MineSubmarine extends SeaObject implements EnemyScore{
    MineSubmarine(){
       super(63,19);
    }
 
    @Override
    public void move() {
        x+=speed;
    }
    public ImageIcon getImage(){
        return Images.minesubm;
    }
    public Mine shootMine(){
        int x = this.x+(this.width/2);
        int y =this.y;
        return new Mine(x,y);
    }
    public boolean isOutOfBounds() {
        return x>=World.WIDTH;
    }
    public int getLife(){
        return 1;
    }
}

侦察潜艇类

package cn.tedu.sunarine;
import javax.swing.ImageIcon;
 
//侦察潜艇
public class ObserveSubmarine extends SeaObject implements EnemyScore{
    ObserveSubmarine(){
        super(63,19);
    }
 
    @Override
    public void move() {
        x+=speed;
    }
    public ImageIcon getImage(){
        return Images.observesubm;
    }
    public boolean isOutOfBounds() {
        return x>=World.WIDTH;
    }
    public int getScore(){
        return 10;
    }
}

鱼雷类

package cn.tedu.sunarine;
//鱼雷
import javax.swing.ImageIcon;
public class Mine extends SeaObject{
        Mine(int x,int y){
            super(11,11,x,y,1);
        }
 
    @Override
    public void move() {
        y-=speed;
    }
 
    public ImageIcon getImage(){
            return Images.mine;
    }
    public boolean isOutOfBounds(){
            return y<=150-(height/2);
    }
}

深水炸弹类

package cn.tedu.sunarine;
//深水炸弹
import javax.swing.ImageIcon;
public class Bomb extends SeaObject{
    Bomb(int x,int y){
        super(9,12,x,y,3);
    }
 
    @Override
    public void move() {
        y+=speed;
    }
    public ImageIcon getImage(){
        return Images.bomb;
    }
    public boolean isOutOfBounds(){
        return y>=World.HEIGHT;
    }
}

战舰类

package cn.tedu.sunarine;
 
import javax.swing.*;
 
//战舰
public class Battleship extends SeaObject{
    int life;
    Battleship(){
       super(66,26,270,124,20);
       life=1;
    }
 
    @Override
    public void move() {
        System.out.println("战舰移动");
    }
    public ImageIcon getImage(){
        return Images.battleship;
    }
    public Bomb shoot(){
        return new Bomb(this.x,this.y+height);
    }
    //限制移动范围
    public void moveLeft(){
        x-=speed;
        x=Math.max(0,x);
    }
    public void moveRight(){
        x+=speed;
        x=Math.min(x,World.WIDTH-this.width);
    }
    public void addLife(int num){
        life+=num;
    }
    public int getLife(){
        return life;
    }
    public void subtratLife(){
        life--;
    }
}

加命接口

package cn.tedu.sunarine;
 
public interface EnemyLife {
    public int getLife();
}

加分接口

package cn.tedu.sunarine;
 
public interface EnemyScore {
    public int getScore();
}

最后，Image类（可根据自己的图片改）

package cn.tedu.sunarine;
import javax.swing.*;
public class Images {
    public static ImageIcon battleship;
    public static ImageIcon observesubm;
    public static ImageIcon mine;
    public static ImageIcon bomb;
    public static ImageIcon sea;
    public static ImageIcon torpedo;
    public static ImageIcon minesubm;
    public static ImageIcon gameover;
    static {
        battleship = new ImageIcon("./img/battleship.png");
        bomb = new ImageIcon("./img/bomb.png");
        gameover = new ImageIcon("./img/gameover.png");
        mine = new ImageIcon("./img/mine.png");
        minesubm = new ImageIcon("./img/minesubm.png");
        observesubm = new ImageIcon("./img/obsersubm.png");
        sea = new ImageIcon("./img/sea.png");
        torpedo = new ImageIcon("./img/torpesubm.png");
    }
 
    public static void main(String[] args) {
        System.out.println(battleship.getImageLoadStatus());
        System.out.println(observesubm.getImageLoadStatus());
        System.out.println(mine.getImageLoadStatus());
        System.out.println(battleship.getImageLoadStatus());
        System.out.println(bomb.getImageLoadStatus());
        System.out.println(gameover.getImageLoadStatus());
        System.out.println(minesubm.getImageLoadStatus());
        System.out.println(sea.getImageLoadStatus());
    }
}

以上就是Java练习之潜艇小游戏的实现的详细内容，更多关于Java潜艇游戏的资料请关注编程网其它相关文章！

您可能感兴趣的文档:

点击免费下载>>软考高级考试备考技巧/历年真题/备考精华资料

--结束END--

本文标题: Java练习之潜艇小游戏的实现

本文链接: https://www.lsjlt.com/news/142600.html(转载时请注明来源链接)

有问题或投稿请发送至: 邮箱/279061341@qq.com QQ/279061341

本篇文章演示代码以及资料文档资料下载

下载Word文档到电脑，方便收藏和打印～

下载Word文档

去做题

猜你喜欢

Java练习之潜艇小游戏的实现

首先是主方法里定义的窗口（这些都是固定的格式，不会的也没什么事，直接Ctrl+c+v就行，基本上看一下数据都能看的懂）写一个超类，超类里需要有潜艇，深水炸弹，水雷和战舰的宽，高，以...

99+

2024-04-02
Java如何实现潜艇小游戏

本篇内容介绍了“Java如何实现潜艇小游戏”的有关知识，在实际案例的操作过程中，不少人都会遇到这样的困境，接下来就让小编带领大家学习一下如何处理这些情况吧！希望大家仔细阅读，能够学有所成！首先是主方法里定义的窗口（这些都是固定的格式，不会的...

99+

2023-06-29
java实现潜艇大战游戏源码

代码如下 package com.util; import java.awt.BorderLayout; import java.awt.Color; import jav...

99+

2024-04-02
使用java怎么实现潜艇大战游戏

使用java怎么实现潜艇大战游戏？针对这个问题，这篇文章详细介绍了相对应的分析和解答，希望可以帮助更多想解决这个问题的小伙伴找到更简单易行的方法。代码如下package com.util;import java.awt....

99+

2023-06-15
C语言练习之扫雷小游戏

本文实例为大家分享了C语言实现扫雷小游戏的具体代码，供大家参考，具体内容如下 *1.设计思路与实现要求 (1)创建两个二维数组 9x9 ,一个表示显示地图数组showMap-未翻开状...

99+

2024-04-02
Java 集合框架之List 的使用(附小游戏练习)

目录1. List1.1 List 的常见方法 1.2 代码示例 2. ArrayList2.1 介绍2.2 ArrayList 的构造方法2.3 ArrayList 底层数组的大小...

99+

2024-04-02
Pygame实战练习之推箱子游戏

导语要说小时候称霸所有翻盖手机的小游戏，除了贪吃蛇，那就是推箱子了。控制小人将所有箱子放到指定位置，就是这样简简单单的操作，陪伴我度过了无数个没有动...

99+

2024-04-02
Pygame实战练习之一百层游戏

导语哈喽哈喽！大家好！我是木木子，又到了每日游戏更新环节！ 8月30日，对暑假还意犹未尽的孩子们收到了一份“开学大礼”：通知要求，严格限制向未成年人提供网络游戏服...

99+

2024-04-02
Pygame实战练习之纸牌21点游戏

导语昨天不是周天嘛？你们在家放松一般都会做什么呢？周末逛逛街，出去走走看电影......这是你们的周末。程序员的周末就是在家躺尸唐诗躺尸，偶尔加班加班加班，或...

99+

2024-04-02
Pygame实战练习之飞机大战游戏

导语承载童年的纸飞机你还会叠嘛？如果你是个80后或者90后，那你应该记得小时候玩的纸飞机。叠好后，哈口仙气，飞出去，感觉棒棒哒。虽然是一个极其简单的玩具，但那...

99+

2024-04-02
Pygame实战练习之保护单身狗游戏

导语各位戏精大家好！我是木木子，这个中秋已经结束了，你们都带着对象回家了码？中秋那几天朋友圈简直是大型秀恩爱现场。又是一年中秋夜，依旧凭实力单身！呼吁大家记得保护下单身狗啊喂！...

99+

2024-04-02
Pygame实战练习之炸弹人学院游戏

导语在现在这个浮躁的年代：小编每次登陆王者荣耀，还有每次登陆刺激战场Z！看着里面的聊天界面，各种代打、各种的找cp。小小编觉得，我们已经失去了玩游戏的初心。接下来，小台将带领你...

99+

2024-04-02
python小练习之爬鱿鱼游戏的评价生成词云

目录前言分析页面重要代码selenium打开豆瓣短评页面根据xpath来获取评论内容实现跳转下一页完整代码成果前言鱿鱼游戏是什么，相信大家都不陌生了，虽然说博主没看过这部剧，但是还...

99+

2024-04-02
C++小游戏教程之猜数游戏的实现

目录0. 引言1. 用户猜数1-1. 设置答案数与猜测数1-2. 系统说明要求与读入数字1-3. 累计猜测次数与判断数字1-4. 输出猜测次数2. 系统猜数，但是是进化史2-1. 代...

99+

2022-11-13

C++猜数游戏 C++猜数
Python游戏开发之魔塔小游戏的实现

前言这一期我们继续完善我们的魔塔小游戏。废话不多说，让我们愉快地开始吧~ 开发工具 Python版本： 3.7.4 相关模块： cpgames模块；以及一些pytho...

99+

2024-04-02
Unity游戏开发之射击小游戏的实现

目录前言游戏画面展示游戏代码解析游戏打包总结前言人们一直都说学习和玩游戏不能兼顾，那我们就来边学习怎样制作游戏，边玩游戏不就兼得了嘛~ 我可真是一个小天才呢~ 所以本篇文章为大家...

99+

2024-04-02
java实战之猜字小游戏

目录一、题目描述二、思路三、代码四、效果图一、题目描述二、思路语法基础：StringBuilder 类似列表，可以更改元素。 package Practice; pub...

99+

2024-04-02
Java实战之飞翔的小鸟小游戏

目录前言一、大体思路二、具体步骤2.1 创建窗体类2.1.1 具体代码2.1.2 效果展示2.1.3 小结三、创建一个获取图片的工具类3.1 具体代码3.2 小结四、创建画布4.1 ...

99+

2024-04-02
3个适合新手练习的python小游戏

目录1.猜拳2.数字炸弹3.赌大小学Python之前我们先来几个简单的小游戏练练手，这三个小游戏一个比一个复杂，建议新手慢慢来： 1.猜拳 import random #导入随机模...

99+

2024-04-02
适合初学者练习的C语言实现三子棋小游戏

目录一、写代码前明确下棋时的步骤与顺序二根据初步的主函数完成想要的代码1.写一个函数来初始化棋盘2.打印棋盘3.玩家落子4.电脑落子5.判断胜负三、三子棋实...

99+

2024-04-02