飞机大战游戏，下载即可运行

最新推荐文章于 2024-05-31 10:46:10 发布
最新推荐文章于 2024-05-31 10:46:10 发布
阅读量225 收藏 1
点赞数 1
分类专栏： JAVA斗地主游戏 斗地主 文章标签： java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qwer353637/article/details/118069996
版权

JAVA飞机大战游戏
有十款机型，还要声音

package com.eduask.view;
import com.eduask.model.Enemy001;
import com.eduask.model.Enemy002;
import com.eduask.model.Enemy003;
import com.eduask.model.Enemy004;
import com.eduask.model.Enemy005;
import com.eduask.model.Enemy006;
import com.eduask.model.Enemy007;
import com.eduask.model.Enemy008;
import com.eduask.model.Enemy009;
import com.eduask.model.Enemy010;
// 1：创建一个MainFrame 继承 BaseFrame
public class MainFrame extends BaseFrame {
	public MainFrame(){
		// 3：创建玩家
		createPlayer();		
		// 4： 监听玩家手势
		setTouchListener();		
		// 5： 设置玩家火力等级  (1,2,3)
		setPlayerPowerLevel(1);		
		// 6： 添加敌人的类型		
		addEnemyType(Enemy001.class);
		addEnemyType(Enemy002.class);
		addEnemyType(Enemy003.class);
		addEnemyType(Enemy004.class);
		addEnemyType(Enemy005.class);
		addEnemyType(Enemy006.class);
		addEnemyType(Enemy007.class);
		addEnemyType(Enemy008.class);
		addEnemyType(Enemy009.class);
		addEnemyType(Enemy010.class);		
		// 7：设置敌人携带道具
		setEnemyHasItem();		
		// 8：统计得分
		setCount();		
	}
}

package com.eduask.view;
import java.awt.Color;
import java.awt.Font;
import java.awt.Graphics;
import java.awt.Image;
import java.awt.LayoutManager;
import java.awt.Toolkit;
import java.util.ArrayList;
import javax.swing.JPanel;
import com.eduask.model.Bullet;
import com.eduask.model.Enemy;
import com.eduask.model.Enemy001;
import com.eduask.model.Enemy002;
import com.eduask.model.Enemy003;
import com.eduask.model.Enemy004;
import com.eduask.model.Enemy005;
import com.eduask.model.Enemy006;
import com.eduask.model.Enemy007;
import com.eduask.model.Enemy008;
import com.eduask.model.Enemy009;
import com.eduask.model.Enemy010;
import com.eduask.model.Item;
import com.eduask.model.Player;
import com.eduask.thread.BulletThread;
import com.eduask.thread.DrawableThread;
public class MyPanel extends JPanel{
	private static final long serialVersionUID = 1L;	
	public DrawableThread thread;
	public Player player;
	public ArrayList<Bullet> bullets = new ArrayList<Bullet>();
	public ArrayList<Enemy> enemies = new ArrayList<Enemy>();
	public ArrayList<Item> items = new ArrayList<Item>();	
	public MyPanel(){
		this.bg = Toolkit.getDefaultToolkit().getImage("images/bg01.jpg");
		this.player = new Player(this);
		this.thread = new DrawableThread(this);
		this.thread.start();
	}
	```
	```java
	public int timer = 0;
	public Image bg;
	public int top = 0;
	public int enemyFlag;	
	public void paintComponent(Graphics g){
		super.paintComponent(g);
		timer++;
		if( timer >= 10000 ){
			timer = 0;
		}
		// 画背景
		g.drawImage(bg, 0, top-bg.getHeight(this), bg.getWidth(this), bg.getHeight(this), null);
		g.drawImage(bg, 0, top, bg.getWidth(this), bg.getHeight(this), null);
		if( timer % 10 == 0 )
		{
			this.top+= 1;
			if( top > bg.getHeight(this) ){
				top = 0;
			}
		}		
		// 画飞机
		if(BaseFrame.hasPlayer)
		player.drawSelf(g);				
		// 创建新子弹
		if( timer % 100 == 0 ){			
			if( player.attactMode == 1 ){
				// 射出子弹
				Bullet b = new Bullet(this);
				b.x = player.x + player.width / 2 - b.width/2;
				b.y = player.y;
				bullets.add(b);
			}
			else if( player.attactMode == 2 ){
				Bullet b1 = new Bullet(this);
				b1.x = player.x + player.width / 2 - b1.width/2;
				b1.y = player.y - 15;
				bullets.add(b1);				
				Bullet b2 = new Bullet(this);
				b2.x = player.x + player.width / 2 - b2.width/2 -                b2.width - 5;
				b2.y = player.y;
				bullets.add(b2);				
				Bullet b3 = new Bullet(this);
				b3.x = player.x + player.width / 2 - b3.width/2 + b3.width + 5;
				b3.y = player.y;
				bullets.add(b3);				
			}
			else if( player.attactMode == 3 )
			{
				Bullet b1 = new Bullet(this);
				b1.x = player.x + player.width / 2 - b1.width/2;
				b1.y = player.y - 30;
				bullets.add(b1);
				
				Bullet b2 = new Bullet(this);
				b2.x = player.x + player.width / 2 - b2.width/2 - b2.width - 5;
				b2.y = player.y - 15;
				bullets.add(b2);
				
				Bullet b3 = new Bullet(this);
				b3.x = player.x + player.width / 2 - b3.width/2 + b3.width + 5;
				b3.y = player.y - 15;
				bullets.add(b3);
				
				Bullet b4 = new Bullet(this);
				b4.x = player.x + player.width / 2 - b4.width/2 - 2*b4.width - 10;
				b4.y = player.y;
				bullets.add(b4);
				
				Bullet b5 = new Bullet(this);
				b5.x = player.x + player.width / 2 - b5.width/2 + 2*b5.width +10;
				b5.y = player.y;
				bullets.add(b5);
			}
			new BulletThread("video/bullet.wav").start();
		}		
		// 画所有子弹
		
		for( int i = 0 ; i <= bullets.size() - 1; i++ ){
			bullets.get(i).drawSelf(g);
		}		
		// 创建敌人
		if( timer % 200 == 0 ){
			// 创建敌人
			Enemy enemy;
			if( BaseFrame.enemiesType.size() != 0 ){
			enemyFlag = (int)(Math.random() * BaseFrame.enemiesType.size());
			try{
			enemy =(Enemy) BaseFrame.enemiesType.get(enemyFlag).getConstructors()[0].newInstance(new Object[]{this});
			
			enemies.add(enemy);
			}catch(Exception e){
				e.printStackTrace();
			}
			}
		}		
		// 画所有敌人
		for( int i = 0 ; i <= enemies.size() - 1; i++ ){
			enemies.get(i).drawSelf(g);
		}
		
		// 画所有道具
		if( BaseFrame.hasItem )
		for( int i = 0 ; i <= items.size() - 1; i++ ){
			items.get(i).drawSelf(g);
		}		
		// 画分数
		if( BaseFrame.hasCount ){
		g.setColor(Color.WHITE);
		g.drawString(""+player.pointer, BaseFrame.FrameWidth - 140, 15);
		}		
	}	
}

启动类

package com.eduask.view;
import com.eduask.thread.BulletThread;
import com.eduask.thread.MusicThread;
public class Main {
	public static void main(String[] args) {		
		// 2：主函数 实例化 MainFrame对象
		new MainFrame();		
		new MusicThread("video/bjmusic.wav").start();		
	}
}

package com.eduask.view;
import java.awt.Container;
import java.awt.Dimension;
import java.awt.Point;
import java.awt.Toolkit;
import java.util.ArrayList;
import javax.swing.JFrame;
import com.eduask.listener.FrameMouseListener;
import com.eduask.listener.FrameMouseMotionListener;
import com.eduask.thread.MusicThread;
public class BaseFrame extends JFrame{
	public static boolean hasPlayer = false;
	public static boolean hasItem = false;
	public static boolean hasCount = false;
	public static boolean hasListener = false;
	public static ArrayList<Class> enemiesType = new ArrayList<Class>();
	public void setTouchListener(){
		hasListener = true;	
		if( hasListener ){
		mouselistener = new FrameMouseListener();
		mouselistener.mainframe = this;
		this.addMouseListener(mouselistener);	
		mousemotionlistener = new FrameMouseMotionListener();
		mousemotionlistener.mainframe = this;
		this.addMouseMotionListener(mousemotionlistener);
		}
	}
	public  void addEnemyType(Class c){
		enemiesType.add(c);
	}
	public  void createPlayer(){
		hasPlayer = true;
	}
	public  void setCount(){
		hasCount = true;
	}
	public  void setEnemyHasItem(){
		hasItem = true;
	}	
	public void setPlayerPowerLevel(int level){
		this.panel.player.attactMode = level;
	}
	private static final long serialVersionUID = 1L;	
	public static int FrameWidth = 512;
	public static int FrameHeight = 768;	
	public BaseFrame(){
		super("学生作品飞机大战");
		Dimension screenSize =Toolkit.getDefaultToolkit().getScreenSize();
		setBounds( ((int)screenSize.getWidth() - FrameWidth) / 2, 0, FrameWidth, FrameHeight);
		setLayout(null);
		this.panel = new MyPanel();
		this.panel.setBounds(0, 0, this.getWidth(), this.getHeight());
		this.add(this.panel);
		setVisible(true);
		setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
	}	
	public MyPanel panel;
	public FrameMouseListener mouselistener;
	public FrameMouseMotionListener mousemotionlistener;
}

package com.eduask.thread;
import java.io.ByteArrayInputStream;
import java.io.DataInputStream;
import java.io.File;
import java.io.IOException;
import java.io.InputStream;
import javax.sound.sampled.AudioFormat;
import javax.sound.sampled.AudioInputStream;
import javax.sound.sampled.AudioSystem;
import javax.sound.sampled.DataLine;
import javax.sound.sampled.LineUnavailableException;
import javax.sound.sampled.SourceDataLine;
import javax.sound.sampled.UnsupportedAudioFileException;
public class BulletThread extends Thread {	
	private String fileName;
	private AudioFormat format;
	private byte[] samples;
	public BulletThread(String fileName){
		this.fileName = fileName;
		reverseMusic();
	}
	public void reverseMusic(){
		try {
			// open the audio input stream
			AudioInputStream stream =AudioSystem.getAudioInputStream(new File(fileName));
			format = stream.getFormat();
			// get the audio samples
			samples = getSamples(stream);
		}
		catch (UnsupportedAudioFileException ex) {
			ex.printStackTrace();
		}
		catch (IOException ex) {
			ex.printStackTrace();
		}
	}
	public byte[] getSamples(AudioInputStream audioStream) {
		int length = (int)(audioStream.getFrameLength() *    format.getFrameSize());
		byte[] samples = new byte[length];
		DataInputStream is = new DataInputStream(audioStream);
		try {
			is.readFully(samples);
		}catch (IOException ex) {
			ex.printStackTrace();
		}
		return samples;
	}
	public void play(InputStream source) {	
		int bufferSize = format.getFrameSize() *
				Math.round(format.getSampleRate() / 10);
		byte[] buffer = new byte[bufferSize];		
		SourceDataLine line;
		try {
			DataLine.Info info =
					new DataLine.Info(SourceDataLine.class, format);
			line = (SourceDataLine)AudioSystem.getLine(info);
			line.open(format, bufferSize);
		}
		catch (LineUnavailableException ex) {
			ex.printStackTrace();
			return;
		}		
		line.start();		
		try {
			int numBytesRead = 0;
			while (numBytesRead != -1) {			
				numBytesRead =
						source.read(buffer, 0, buffer.length);
				if (numBytesRead != -1) {
					line.write(buffer, 0, numBytesRead);
				}
			}			
		}
		catch (IOException ex) {
			ex.printStackTrace();
		}		
		line.drain();
		line.close();
	}
	public void run(){			
		InputStream stream =new ByteArrayInputStream(samples);				
		play(stream);
}
}

package com.eduask.thread;
import com.eduask.view.MyPanel;
public class DrawableThread extends Thread{
	public MyPanel mypanel;	
	public DrawableThread(MyPanel mypanel){
		this.mypanel = mypanel;
	}	
	public void run(){
		while(true){
			mypanel.repaint();			
			try {
				Thread.currentThread().sleep(1);
			} catch (InterruptedException e) {
				// TODO Auto-generated catch block
				e.printStackTrace();
			}
		}
	}	
}

package com.eduask.thread;
import java.io.ByteArrayInputStream;
import java.io.DataInputStream;
import java.io.File;
import java.io.IOException;
import java.io.InputStream;
import javax.sound.sampled.AudioFormat;
import javax.sound.sampled.AudioInputStream;
import javax.sound.sampled.AudioSystem;
import javax.sound.sampled.DataLine;
import javax.sound.sampled.LineUnavailableException;
import javax.sound.sampled.SourceDataLine;
import javax.sound.sampled.UnsupportedAudioFileException;
public class MusicThread extends Thread {
	private String fileName;
	private AudioFormat format;
	private byte[] samples;	
	private boolean flag;
	public MusicThread(String fileName){
		this.fileName = fileName;
		reverseMusic();
	}
	public void reverseMusic(){
		try {
			// open the audio input stream
			AudioInputStream stream =AudioSystem.getAudioInputStream(new File(fileName));
			format = stream.getFormat();
			// get the audio samples
			samples = getSamples(stream);
		}
		catch (UnsupportedAudioFileException ex) {
			ex.printStackTrace();
		}
		catch (IOException ex) {
			ex.printStackTrace();
		}
	}
	public byte[] getSamples(AudioInputStream audioStream) {
		int length = (int)(audioStream.getFrameLength() *   format.getFrameSize());
		byte[] samples = new byte[length];
		DataInputStream is = new DataInputStream(audioStream);
		try {
			is.readFully(samples);
		}catch (IOException ex) {
			ex.printStackTrace();
		}
		return samples;
	}
	public void play(InputStream source) {
		int bufferSize = format.getFrameSize() *
				Math.round(format.getSampleRate() / 10);
		byte[] buffer = new byte[bufferSize];		
		SourceDataLine line;
		try {
			DataLine.Info info =
					new DataLine.Info(SourceDataLine.class, format);
			line = (SourceDataLine)AudioSystem.getLine(info);
			line.open(format, bufferSize);
		}
		catch (LineUnavailableException ex) {
			ex.printStackTrace();
			return;
		}		
		line.start();		
		try {
			int numBytesRead = 0;
			while (numBytesRead != -1) {				
				flag = false;
				numBytesRead =
						source.read(buffer, 0, buffer.length);
				if (numBytesRead != -1) {
					line.write(buffer, 0, numBytesRead);
				}
			}			
			flag = true;
		}
		catch (IOException ex) {
			ex.printStackTrace();
		}		
		line.drain();
		line.close();
	}
	public void run(){		
		flag = true;	
		while(true){			
			if(flag){				
				InputStream stream =new ByteArrayInputStream(samples);				
				play(stream);
			}			
		}
	}
}

package com.eduask.listener;
import java.awt.event.MouseEvent;
import java.awt.event.MouseListener;
import com.eduask.view.BaseFrame;
public class FrameMouseListener implements MouseListener{
	public BaseFrame mainframe;	
	@Override
	public void mouseClicked(MouseEvent e) {		
		mainframe.panel.player.x = e.getX() - mainframe.panel.player.width/2;
		mainframe.panel.player.y = e.getY() - mainframe.panel.player.height / 2 - 10;		
	}
	@Override
	public void mousePressed(MouseEvent e) {
		// TODO Auto-generated method stub		
	@Override
	public void mouseReleased(MouseEvent e) {
		// TODO Auto-generated method stub		
	}
	@Override
	public void mouseEntered(MouseEvent e) {
		// TODO Auto-generated method stub		
	}
	@Override
	public void mouseExited(MouseEvent e) {
		// TODO Auto-generated method stu		
	}
}

package com.eduask.listener;
import java.awt.event.MouseEvent;
import java.awt.event.MouseMotionListener;
import com.eduask.view.BaseFrame;
public class FrameMouseMotionListener implements MouseMotionListener {
	public BaseFrame mainframe	
	@Override
	public void mouseDragged(MouseEvent e) {
		mainframe.panel.player.x = e.getX() - mainframe.panel.player.width/2;
		mainframe.panel.player.y = e.getY() - mainframe.panel.player.height / 2 - 10;
	}
	@Override
	public void mouseMoved(MouseEvent e) {
		// TODO Auto-generated method stub		
	}
}

package com.eduask.model;
import java.awt.Graphics;
import java.awt.Image;
import java.awt.Toolkit;
import com.eduask.thread.BulletThread;
import com.eduask.view.BaseFrame;
import com.eduask.view.MyPanel;
public class Bullet {
	public int width;
	public int height;
	public int x;
	public int y;
	public Image[] images = new Image[]{
			Toolkit.getDefaultToolkit().getImage("images/bullet01.png"),
			Toolkit.getDefaultToolkit().getImage("images/bullet02.png"),
			Toolkit.getDefaultToolkit().getImage("images/bullet03.png"),
			Toolkit.getDefaultToolkit().getImage("images/bullet04.png"),
			Toolkit.getDefaultToolkit().getImage("images/bullet05.png"),
			Toolkit.getDefaultToolkit().getImage("images/bullet06.png")
	};
	public int imageIndex = 0;
	public MyPanel mypanel;	
	public Bullet(MyPanel mypanel){		
		this.mypanel = mypanel;
		width = 8;
		height = 8;		
	}	
	public void drawSelf(Graphics g){		
		g.drawImage(images[imageIndex], x, y, width, height, null);
		if( mypanel.timer % 1 == 0 )
		{
			imageIndex++;
			y--;
			if( imageIndex >= images.length ){
				imageIndex = 0;
			}
			if(y<0){
				mypanel.bullets.remove(this);				
			}
		}		
		// 判断子弹是否击中敌人
		for( int i = 0 ; i <= mypanel.enemies.size() - 1; i++ )
		{
			Enemy e = mypanel.enemies.get(i);
			if( e.hp <= 0 ){continue;}
			if( x >= e.x - width && x <= e.x + e.width && y >= e.y - height && y <= e.y + e.height ){
				mypanel.bullets.remove(this);
				e.underAttact();				
			}			
		}		
	}	
}

package com.eduask.model;
import java.awt.Graphics;
import java.awt.Image;
import java.awt.Toolkit;
import com.eduask.thread.BulletThread;
import com.eduask.view.BaseFrame;
import com.eduask.view.MyPanel;
public abstract class Enemy {
	public int width;
	public int height;
	public int x;
	public int y;
	public Image image;
	public MyPanel mypanel;
	public int speed;
	public int hp;
	public int pointer = 0;
	public Image[] images = new Image[]{
			Toolkit.getDefaultToolkit().getImage("images/die01.png"),
			Toolkit.getDefaultToolkit().getImage("images/die02.png"),
			Toolkit.getDefaultToolkit().getImage("images/die03.png"),
			Toolkit.getDefaultToolkit().getImage("images/die04.png")
	};
	public int imageIndex = 0;
	public Item[] items = null	
	public Enemy(MyPanel mypanel){
		this.mypanel = mypanel;
	}	
	public void drawSelf(Graphics g){		
		if( hp > 0 )
		{
			g.drawImage(image, x, y, width, height, null);
		}
		else
		{
			x = x + width/2 - 22;
			y = y + height / 2 - 22;
			width = 45;
			height = 45;
			g.drawImage(images[imageIndex], x, y, width, height, null);
			if( mypanel.timer % 10 == 0 )
			{
				imageIndex++;
				if( imageIndex >= images.length ){
					// 被打死了
					killed();
					new BulletThread("video/boom.wav").start();
				}
			}
		}	
		if( mypanel.timer % speed == 0 ){
			y++;
			if( y > BaseFrame.FrameHeight ){
				mypanel.enemies.remove(this);
			}
		}
	}
	public void killed(){
		mypanel.player.pointer += this.pointer;
		if( items != null && items.length > 0 )
		{
			for( int i = 0 ; i <= items.length - 1; i++ )
			{
				Item item = items[i];
				item.y = this.y;
				if( i == 0 ){
					item.x = this.x + this.width / 2 - item.width/2;
				}else if(i == 1){
					item.x = this.x + this.width / 2 - item.width/2 - item.width - 10;
				}else if( i == 3){
					item.x = this.x + this.width / 2 - item.width/2 - item.width * 2 - 20;
				}else if(i == 2){
					item.x = this.x + this.width / 2 - item.width/2 + item.width + 10;
				} else if( i == 4 ){
					item.x = this.x + this.width / 2 - item.width/2+ item.width * 2 + 20;
				}
				mypanel.items.add(item);
			}
		}
		mypanel.enemies.remove(this);		
	}
	public void underAttact(){
		if( hp > 0  ){hp--;
		}		
}

package com.eduask.mode;
import java.awt.Graphics;
import java.awt.Toolkit
import com.eduask.view.BaseFrame;
import com.eduask.view.MyPanel;
public class Enemy001 extends Enemy
	public Enemy001(MyPanel mypanel) {
		super(mypanel);
		width = 60;
		height = 40;
		x = (int)(Math.random() * (BaseFrame.FrameWidth - width) );
		y = 0 - height;
		image = Toolkit.getDefaultToolkit().getImage("images/enemy01.png");
		speed = 3;
		hp = 3;
		pointer = 100;
		this.items = new Item[]{
				new Item001(mypanel),
				new Item001(mypanel),
				new Item001(mypanel)
		};
	}
}

package com.eduask.model;
import java.awt.Graphics;
import java.awt.Image
import com.eduask.view.BaseFrame;
import com.eduask.view.MyPanel
public abstract class Item 
	public int width;
	public int height;
	public int x;
	public int y;
	public Image[] images;
	public int imageIndex = 0;
	public MyPanel mypanel;
	public int pointer;
	public int attactMode = 1;
	public int powerTime = 0;
	public int speed;
	public int imageSpeed	
	public Item(MyPanel mypanel){
		this.mypanel = mypanel;
		imageSpeed = (int)(Math.random() * 20 + 20);
	}	
	public void drawSelf(Graphics g){
		g.drawImage(images[imageIndex], x, y, width, height, null);
		if( mypanel.timer % imageSpeed == 0 )
		{
			imageIndex++;
			if( imageIndex >= images.length ){
				imageIndex = 0;
			}
		}
		if( mypanel.timer % speed == 0 ){
			y++;
			if( y > BaseFrame.FrameHeight ){
				mypanel.enemies.remove(this);
			}
		}
	}	
	public void eated()		
		mypanel.player.pointer += this.pointer;		
		if( this.attactMode >= mypanel.player.attactMode ){
			mypanel.player.attactMode = this.attactMode;
			mypanel.player.powerTime = this.powerTime;
		}		
		mypanel.items.remove(this);
		System.gc();
	}	
}

package com.eduask.model;
import java.awt.Graphics;
import java.awt.Image;
import java.awt.Toolkit;
import com.eduask.view.MyPanel;
public class Item001 extends Item
	public Item001(MyPanel mypanel) {
		super(mypanel);
		// TODO Auto-generated constructor stub
		width = 15;
		height = 15;
		images = new Image[]{
				Toolkit.getDefaultToolkit().getImage("images/star01.png"),
				Toolkit.getDefaultToolkit().getImage("images/star02.png"),
				Toolkit.getDefaultToolkit().getImage("images/star03.png"),
				Toolkit.getDefaultToolkit().getImage("images/star04.png"),
				Toolkit.getDefaultToolkit().getImage("images/star05.png"),
				Toolkit.getDefaultToolkit().getImage("images/star06.png"),
				Toolkit.getDefaultToolkit().getImage("images/star07.png"),
				Toolkit.getDefaultToolkit().getImage("images/star08.png"),
				Toolkit.getDefaultToolkit().getImage("images/star09.png")
		};
		pointer = 100;
		attactMode = 1;
		powerTime = 0;
		speed =(int)( Math.random() * 3 + 3);
	}
}

package com.eduask.model;
import java.awt.Graphics;
import java.awt.Image;
import java.awt.Toolkit;
import com.eduask.view.BaseFrame;
import com.eduask.view.MyPanel
public class Player {
	public int width;
	public int height;
	public int x;
	public int y;
	public Image[] images = new Image[]{
			Toolkit.getDefaultToolkit().getImage("images/player01.png"),
			Toolkit.getDefaultToolkit().getImage("images/player02.png"),
			Toolkit.getDefaultToolkit().getImage("images/player04.png"),
			Toolkit.getDefaultToolkit().getImage("images/player05.png"),
			Toolkit.getDefaultToolkit().getImage("images/player06.png"),
			Toolkit.getDefaultToolkit().getImage("images/player08.png"),
			Toolkit.getDefaultToolkit().getImage("images/player09.png")
	};
	public int imageIndex = 0;
	public MyPanel mypanel;
	public int pointer = 0;
	public int attactMode = 0;
	public int powerTime = 0;
	
	public Player(MyPanel mypanel){
		this.mypanel = mypanel;
		width = 100;
		height = 100;
		x = ( BaseFrame.FrameWidth - width ) / 2;
		y = BaseFrame.FrameHeight - height * 2;
	}	
	public void drawSelf(Graphics g){
		g.drawImage(images[imageIndex], x, y, width, height, null)		
		if( mypanel.timer % 50 == 0 )
		{
			imageIndex++;
			if( imageIndex >= images.length ){
				imageIndex = 0;
			}
		}		
		// 攻击时间
		if( this.attactMode > 1 ){
			if( this.powerTime > 0 ){
				this.powerTime--;
				if( this.powerTime <= 0 ){
					this.attactMode = 1;
				}
			}
		}		
		// 判断是否吃到道具
		for( int i = 0 ; i <= mypanel.items.size() - 1; i++ )
		{
			Item item = mypanel.items.get(i);
			if( this.x >= item.x - this.width && this.x <= item.x + item.width && this.y >= item.y - this.height && this.y <= item.y + item.height )
			{
				item.eated();
			}
		}
		
	}
	
}
篮色梦想
关注
  • 1
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
Python项目开发实战：飞机大战游戏（案例教程）
一个好知识的传播者
05-06 481
飞机大战游戏是一款经典的射击类游戏，玩家需要驾驶飞机在空中与敌人进行战斗，躲避敌人的攻击，同时发射子弹消灭敌人。本文将详细介绍如何使用Python及其相关库来开发一款简单的飞机大战游戏，包括游戏的设计思路、开发过程、实现细节以及最后的测试与优化。
花一天时间做一个高质量飞机大战游戏，过万字Unity完整教程！漂亮学妹看了直呼666！
热门推荐
努力前行，总会成为自己心中的那道光
06-07 26万+
Unity制作飞机大战。本篇文章完整的介绍了使用Unity引擎制作一个飞机大战的小游戏，附带游戏过程，截图和讲解，最后附带工程源码，请品尝！
C语言飞机大战
罅隙的博客
02-02 4万+
300行代码实现最简易的飞机小游戏，简单有趣，快来试试
Android Studio 实现飞机大战游戏App
qq_29823791的博客
01-11 2016
Android Studio 实现飞机大战游戏通过自定义View实现Android飞机大战小游戏，游戏玩法很简单，可以锻炼玩家的反应能力。开启背景音乐进行新的游戏，控制飞机移动来消灭敌机获取更多的分数，在移动过程中避免与敌机发生碰撞。1. 飞机一直发射子弹，用手指滑动可以改变飞机的位置2. 不同的敌机抗击打能力不同，当敌机被击中一定子弹数量时会爆炸，爆炸有动画效果3. 每隔一段时间都会有双发子弹或炸弹等道具奖励4. 获得双发子弹之后，子弹变为双发5. 获得炸弹道具之后，可以通过双击将屏幕内的所有敌机炸毁。
Python飞机大战游戏 附素材及源码
Xylon的博客
06-30 1万+
效果图： 代码： # coding:UTF-8 import pygame from pygame import locals from sys import exit from pygame.sprite import Sprite,Group import random , time , math class BGSprite(Sprite): ...
Python笔记14-实战小游戏飞机大战（上）
zhangxm_qz的博客
01-28 1818
下面来编写一个名为settings 的模块，在其中包含一个名为Settings 的类，用于将所有设置都存储在一个地方，以免在代码中到处添加设置。另外，在项目增大时，这使得修改游戏的外观和行为更容易：要修改游戏，只需修改（接下来将创建的）settings.py中的一些值，而无须查找散布在项目中的各种设置。在AlienInvasion 中，需要修改_check_keydown_events() ，以便在玩家按空格键时发射一颗子弹，此编写一个新方法_fire_bullet() 来完成这项任务。
JAVA小游戏之飞机大战（超详细）
qq_43425914的博客
03-31 9049
在具备了一定的java基础（如类、监听、线程等）后，就可以开始飞机大战小游戏的编写了。
【Python】游戏：飞机大战
qq_35284513的博客
09-28 423
本文主要内容： 复现：Eric Matthes所著的《python编程从入门到实践》一书中，第12章到第十四章的《外星人入侵》项目的代码，并成功运行。 将项目的主要文件和代码做一个分享 分享此项目完整代码的链接 第一部分：项目的效果图和目录树 项目的初始运行的效果： 项目的文件目录： 项目的依赖包： 第二部分：主要代码 alien_invasion.py （主程序代码） import pygame from settings import Settings from ship import Shi
Python快速实现简易飞机大战小游戏(完整源码+图片素材)
ASS-ASH的博客
10-11 8275
在今天的数字时代，计算机游戏一直是人们娱乐和放松的一种重要方式。而作为程序员或编程爱好者，将自己的创意融入游戏开发中，不仅可以带来乐趣，还可以提高编程技能。本文将带您走进游戏开发的精彩世界，通过使用 Python 编程语言，快速创建一个简单的飞机大战小游戏，仅供娱乐。app.ico图片为游戏运行界面左上角图标，随便用那张图片都行，例如直接使用我方飞机图片重命名即可。运行方式：运行main.py即可。
android飞机大战源码，直接运行即可
06-26
JAVA飞机大战源码，自己初学Android时候写的，直接在eclipse运行就能跑起来
java飞机大战，经典小游戏
07-30
这是一个Idea项目，下载压缩包后直接用 Idea 打开，运行 src/shoot/Game.java 即可开始游戏。 如果使用 eclipse，新建项目，新建 shoot 包，将下载的压缩包的 src/shoot 内的所有文件复制到 eclipse 项目的 shoot 包...
PYTHON 游戏：双人飞机大战游戏（基于python实现的可视化游戏）
03-13
PYTHON 游戏：双人飞机大战游戏（基于python实现的可视化游戏） 解压后直接运行 game 即可，游戏需要安装pygame，可以参考requirements文件 运行 game.py 脚本即可开始游戏 操作方式：玩家一，方向键控制上下左右，...
python3 实现飞机大战小游戏代码
09-10
python3 实现飞机大战小游戏的代码， 新手编程入门课程， 使用pip install 安装相应的库,启动飞机大战.py即可运行。
java swing飞机大战小游戏
02-06
用java swing写的飞机大战窗体小游戏，代码较为简单，界面良好，有详细的代码注释，点击即可运行，适合初学者学习使用
operator ＜=＞ (spaceship operator)
janeqi1987的专栏
05-28 855
= 与!= 操作符为了检查是否相等，现在定义== 操作符就够了。当编译器找不到表达式的匹配声明a!=b 时，编译器会重写表达式并查找!(a==b)。若这不起作用，编译器也会尝试改变操作数的顺序，所以也会尝试!(b==a):a!=b,!(b==a)因此，对于TypeA 的a 和TypeB 的b，编译器将能够识别并编译a!= b若需要的话，可以这样做• 一个独立函数operator!• 一个独立函数operator==(TypeA, TypeB)
Spring6基础笔记
质胜文则野，文胜质则史。文质彬彬，然后君子。
05-21 1189
Spring 是一款主流的 Java EE 轻量级开源框架 ，Spring 由“Spring 之父”Rod Johnson 提出并创立，其目的是用于简化 Java 企业级应用的开发难度和开发周期。Spring的用途不仅限于服务器端的开发。从简单性、可测试性和松耦合的角度而言，任何Java应用都可以从Spring中受益。Spring 框架除了自己提供功能外，还提供整合其他技术和框架的能力。Spring 自诞生以来备受青睐，一直被广大开发人员作为 Java 企业级应用程序开发的首选。时至今日，Spring 俨然
Java 异常处理中try-catch块、finally子句以及自定义异常的使用
最新发布
Itmastergo的博客
05-31 480
异常是程序运行过程中出现的非正常情况。Java 使用异常类（Exception 类及其子类）来表示这些异常情况。异常处理的核心思想是将正常的程序流程与异常处理流程分离开来，使代码更加清晰和可维护。Throwable 类：所有异常和错误的基类。Error 类：表示系统级的错误，程序通常无法处理，比如内存不足（OutOfMemoryError）。Exception 类：表示程序中可以处理的异常情况。RuntimeException 类。
java多线程创建方式
weixin_57763462的博客
05-28 1034
这种方式是通过创建一个实现了Runnable接口的类，并实现run()方法来创建线程。然后将这个类的对象作为参数传递给Thread类的构造器，并调用Thread对象的start()方法来启动线程。这种方式是通过创建一个实现了Callable接口的类，实现call()方法，并使用FutureTask或者ExecutorService来创建线程。这种方式的优点在于，由于Java不支持多重继承，如果你的类需要继承其他类，那么实现Runnable接口将是唯一的选择。// 在这里定义线程的执行逻辑。
python课设飞机大战游戏
05-24
Python课设飞机大战游戏是一种基于Python语言开发的游戏，玩家需要控制飞机避开敌机的攻击，同时进行反击。这个游戏具有简单易懂的操作方式和良好的用户体验。下面是这个游戏的一些特点： 1. 游戏画面简洁、美观，...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值