Java练习之潜艇小游戏的实现
首先是主方法里定义的窗口（这些都是固定的格式，不会的也没什么事，直接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潜艇游戏的资料请关注我们其它相关文章！
相关推荐
-
Java实现经典大富翁游戏的示例详解
目录 前言 主要设计 功能截图 代码实现 总结 前言 大富翁,又名地产大亨.是一种多人策略图版游戏.参与者分得游戏金钱,凭运气(掷骰子)及交易策略,买地.建楼以赚取租金.英文原名monopoly意为“垄断”,因为最后只得一个胜利者,其余均破产收场. <大富翁>游戏是用java语言实现,采用了swing技术进行了界面化处理,设计思路用了面向对象思想. 主要需求 可多人参与的大富翁游戏,玩家有初始资金,通过掷骰子,玩家移动指定骰子点数步骤,根据对应格子上的交易策略,来决定是赚钱还是亏钱,其他玩家破
-
java实现潜艇大战游戏源码
代码如下 package com.util; import java.awt.BorderLayout; import java.awt.Color; import java.awt.Dimension; import java.awt.Graphics; import java.awt.Graphics2D; import java.awt.GridLayout; import java.awt.Image; import java.awt.Toolkit; import java.awt.e
-
Java实现经典游戏黄金矿工的示例代码
目录 前言 主要设计 功能截图 代码实现 游戏核心类 钩子类 总结 前言 <黄金矿工>游戏是一个经典的抓金子小游戏,它可以锻炼人的反应能力..该游戏中,可以通过“挖矿”获得积分,游戏道具:有3瓶药水,在回收绳子抓金子的时候速度稍快点. 主要设计 设计游戏界面,用swing实现 随机创建金块算法 随机创建石块算法 计时系统设计 积分系统设计 设置鼠标事件,鼠标左键出钩子:鼠标右键开始游戏,确认吃药水等功能. 功能截图 游戏开始: 抓金子 代码实现 游戏核心类 public class GameW
-
java实现简单猜拳小游戏
本文实例为大家分享了java实现猜拳小游戏的具体代码,供大家参考,具体内容如下 User.java import java.util.Scanner; public class User { String name; int score; public int showFist(){ System.out.println ("请出拳:1.剪刀\t2.石头\t3.布"); Scanner input=new Scanner ( System.in ); int choice=input.
-
Java实现经典捕鱼达人游戏的示例代码
目录 前言 主要设计 功能截图 代码实现 游戏窗体 鱼 鱼池类继承自Jpanel 总结 前言 <捕鱼达人>是一款以深海狩猎为题材的休闲竞技游戏.这是一场海底世界的远征,享受捕获大鱼的乐趣,但不是所有的鱼都是友善的,它们会用自己的方式保护自己,保卫属于自己的海底世界.当然,这里也是冒险与机遇共存的地方,诸多埋藏于海底的宝藏等待着被探寻. 游戏是用java语言实现,采用了swing技术进行了界面化处理,设计思路用了面向对象思想. 主要需求 在鱼池中有很多鱼,鱼各自游动. 有一张渔网,随鼠标移动,点
-
Java实现英文猜词游戏的示例代码
目录 前言 主要设计 功能截图 代码实现 游戏启动类 处理 单词判断 总结 前言 <英文猜词游戏>代码行数没有超过200行,是之前为了背英语单词,特意研发的小游戏. 主要设计 1.事先准备单词文本. 2.为了让玩家能与程序互动,使用下面这个命令可达效果 Scanner sc = new Scanner(System.in); 3.运行WordleMaster里的main方法 4.在Wordle中输入第一个单词(默认第一个单词是abort,会显示在console中.可在代码中修改) 5.将Wor
-
Java练习之潜艇小游戏的实现
首先是主方法里定义的窗口(这些都是固定的格式,不会的也没什么事,直接Ctrl+c+v就行,基本上看一下数据都能看的懂) 写一个超类,超类里需要有潜艇,深水炸弹,水雷和战舰的宽,高,以及出场时的x,y坐标,和移动速度.所有对象的图片,所有对象的移动方法,以及碰撞 然后再写派生类,根据击败一个水雷潜艇,战舰会获得一条命,击败其他潜艇,战舰会获得分数,所以,需要定义两个接口,一个是用来加命,另一个用来加分 完整代码如下(图片什么的可以自己去找,只需要改一下Image类和各个对象的宽高就可以) 游戏世界
-
Java完美实现2048小游戏
完美地模仿了2048游戏,是根据网友的一个2048改的. Block.java import javax.swing.*; import java.awt.*; public class Block extends JLabel { private int value; public Block() { value = 0;//初始化值为0 setFont(new Font("font", Font.PLAIN, 40));//设定字体 setBackground(Color.gray
-
Java实现打飞机小游戏（附完整源码）
写在前面 技术源于分享,所以今天抽空把自己之前用java做过的小游戏整理贴出来给大家参考学习.java确实不适合写桌面应用,这里只是通过这个游戏让大家理解oop面向对象编程的过程,纯属娱乐.代码写的很简单,也很容易理解,并且注释写的很清楚了,还有问题,自己私下去补课学习. 效果如下 完整代码 敌飞机 import java.util.Random; 敌飞机: 是飞行物,也是敌人 public class Airplane extends FlyingObject implements Enemy
-
java实现数字猜拳小游戏
本文编写一个java数字猜拳的小游戏,具体实现很简单 package guenum; import java.util.ArrayList; import java.util.Scanner; public class Demo { // private static Object list; public static void main(String ad[]) { System.out.println("-------------------------------------小游戏---
-
Java实现的打地鼠小游戏完整示例【附源码下载】
本文实例讲述了Java实现的打地鼠小游戏.分享给大家供大家参考,具体如下: 这里涉及到java线程和GUI的相关知识,一个简单的java小游戏打地鼠,有兴趣的朋友可以优化一下.先来看看运行效果: 具体代码: Mouse.java: import java.awt.Color; import java.awt.Font; import java.awt.Graphics; import java.awt.Image; import java.awt.Toolkit; import java.awt
-
Java实现24点小游戏
本文实例为大家分享了Java实现24点小游戏的具体代码,供大家参考,具体内容如下 程序设计要求: 24点游戏是经典的纸牌益智游戏. 常见游戏规则: 从扑克中每次取出4张牌.使用加减乘除,第一个能得出24者为赢.(其中,J代表11,Q代表12,K代表13,A代表1),按照要求编程解决24点游戏. 基本要求: 随机生成4个代表扑克牌牌面的数字字母,程序自动列出所有可能算出24的表达式,用擅长的语言(C/C++/Java或其他均可)实现程序解决问题. 1.程序风格良好(使用自定义注释模板) 2.列出表
-
Java实现猜字小游戏
猜字游戏是一款益智游戏,喜欢玩具有挑战性单词游戏的你就可以来体验一下了,给你一个字母板.尝试通过想象相邻字母的单词.您将获得一个分数,根据您使用的字母,你已经使用了多少个字母,并以这些字母相关联的任何修饰符都可以的. 具体代码如下所示: package test07; import java.util.Scanner; //猜字符游戏 public class Guessing { //主方法 public static void main(String[] args) { Scanner sc
-
用GUI实现java版贪吃蛇小游戏
本文实例为大家分享了java版贪吃蛇小游戏的具体代码,供大家参考,具体内容如下 项目结构 新建一个JFrame窗口,作为程序入口 public class GameStart{ public static void main(String[] args) { JFrame jFrame = new JFrame(); jFrame.setBounds(100,100,900,720); jFrame.setDefaultCloseOperation(WindowConstants.EXIT_ON
-
java实现打砖块小游戏
本文实例为大家分享了java实现打砖块小游戏的具体代码,供大家参考,具体内容如下 源码共包含两个文件 文件1:play_zhuankuai.java import java.awt.*; import javax.swing.JPanel; @SuppressWarnings("serial") public class play_zhuankuai extends JPanel implements Runnable{ boolean exit=false; boolean end=
-
java实现贪吃蛇小游戏
本文实例为大家分享了java实现贪吃蛇小游戏的具体代码,供大家参考,具体内容如下 这是MVC模式的完整Java项目,编译运行SnakeApp.java即可开始游戏. 可扩展功能: 1.积分功能:可以创建得分规则的类(模型类的一部分), 在GameController的run()方法中计算得分 2.变速功能:比如加速功能,减速功能,可以在GameController的keyPressed()方法中针对特定的按键设置每一次移动之间的时间间隔,将Thread.sleep(Settings.DEFAUL