spacecanvas.java

星空大战,小车发出子弹打空中的飞行物。空中飞行物也 能发出子弹袭击小车。

import java.io.IOException;
import java.util.Enumeration;
import java.util.Random;
import java.util.Vector;

import javax.microedition.lcdui.Font;
import javax.microedition.lcdui.Graphics;
import javax.microedition.lcdui.Image;
import javax.microedition.lcdui.game.GameCanvas;
import javax.microedition.lcdui.game.Layer;
import javax.microedition.lcdui.game.LayerManager;
import javax.microedition.lcdui.game.Sprite;
import javax.microedition.media.MediaException;


public class SpaceCanvas extends GameCanvas implements Runnable
{
	private Graphics bg;
	private Random rand;
	private boolean gameOver;
	private int	score;
	private int	carsRemain;
	private int[] highScores = new int[5];
	private int fireDelay;
	
	private Image imgBack;
	private Image imgCar;
	private Image imgSmallCar;
	private Image imgSplash;
	private Image imgBullets;
	private Image imgExplosion;
	private Image[] imgMonster = new Image[3];
	
	private Vector monsters;
	private Vector bullets;
	private Vector explosions;
	private CarSprite car;
	

	private MyRMS rms;
	
	public static SpaceCanvas sc;
	
	protected SpaceCanvas(boolean arg0)
    {
	    super(arg0);
	    
	    sc = this;
	    
	    rand = new Random();
	    rms = new MyRMS("highScores");
	    highScores = rms.read();
	    
	    try
        {
	    	imgBack = Image.createImage("/StarryNight.png");
	    	imgCar = Image.createImage("/Car.png");
	    	imgSmallCar = Image.createImage("/SmallCar.png");
	    	imgSplash = Image.createImage("/Splash.png");
	    	imgBullets = Image.createImage("/Bullets.png");
	    	imgExplosion = Image.createImage("/Explosion.png");
	    	
	    	imgMonster[0] = Image.createImage("/Blobbo.png");
	    	imgMonster[1] = Image.createImage("/Jelly.png");
	    	imgMonster[2] = Image.createImage("/Timmy.png");
        }
        catch (IOException e)
        {
	        // TODO Auto-generated catch block
	        e.printStackTrace();
        }
        
        monsters = new Vector();
        bullets = new Vector();
        explosions = new Vector();
        
        car = new CarSprite();
        car.setVisible(false);
        
        
        gameOver = true;
        

        new Thread(this).start();
    }
	
	public void stop()
	{
		rms.update(highScores);
	}
	
	public void run()
    {
	    bg = this.getGraphics();
	    
	    while(true)
	    {
	    	input();
	    	tick();
	    	render();
	    	
	    	try
            {
	            Thread.sleep(30);
            }
            catch (InterruptedException e)
            {
	            // TODO Auto-generated catch block
	            e.printStackTrace();
            }
	    }
    }
	
	public void tick()
	{
		// 随机生成一个怪物(频率由得分来决定)
		if (score < 250)
		{
			if (rand.nextInt()%40 == 0)
			{
				bornMonster();
			}
		}
		else if (score < 500)
		{
			if (rand.nextInt()%20 == 0)
			{
				bornMonster();
			}
		}
		else if (score < 1000)
		{
			if (rand.nextInt()%10 == 0)
			{
				bornMonster();
			}
		}
		else
		{
			if (rand.nextInt()%5 == 0)
			{
				bornMonster();
			}
		}
		
		//怪物运动		
		Enumeration e = monsters.elements();
		while(e.hasMoreElements())
		{
			MonsterSprite ms = (MonsterSprite)e.nextElement();
			ms.update();
		}
		
		//爆炸效果
		Enumeration e3 = explosions.elements();
		while(e3.hasMoreElements())
		{
			Sprite s = (Sprite)e3.nextElement();
			if (s.getFrame() < 3)
			{
				s.nextFrame();
			}
			else
			{
				this.delExplosion(s);
			}
		}
		
		//子弹命中
		Enumeration e1 = bullets.elements();
		while(e1.hasMoreElements())
		{
			BulletSprite bs = (BulletSprite)e1.nextElement();
			bs.update();
			
			switch(bs.getType())
			{
			    //汽车子弹和怪物
				case BulletSprite.TYPE_CAR:
				{
					Enumeration e2 = monsters.elements();
					while(e2.hasMoreElements())
					{
						MonsterSprite ms = (MonsterSprite)e2.nextElement();
						//和怪物发生碰撞
						if(bs.collidesWith(ms, false))
						{
							this.delMonster(ms); //怪物消失
							this.delBullet(bs);  //子弹消失
							
							
							this.score+=10*(ms.getType()+1);   //消灭怪物，分数增加
							
							Sprite exp = new Sprite(imgExplosion, 21, 21); //设定爆炸效果
							exp.setPosition(ms.getX(), ms.getY());
							this.explosions.addElement(exp);
							
				
						}
					}
					break;
				}
				//怪物子弹和汽车
				case BulletSprite.TYPE_BLOBBO:
				case BulletSprite.TYPE_JELLY:
				case BulletSprite.TYPE_TIMMY:
				{
					//怪物子弹和汽车发生碰撞
					if(bs.collidesWith(car, false))
					{
						
						this.delBullet(bs);	//子弹消失
								
						//爆炸效果
						Sprite exp = new Sprite(imgExplosion, 21, 21);
						exp.setPosition(car.getX(), car.getY());
						this.explosions.addElement(exp);
						
						car.die();
						this.carsRemain--;
						
						//判断游戏是否结束
						if (carsRemain <= 0)
						{
							// 隐藏玩家精灵
							car.setVisible(false);							
							addToHighScore();
							gameOver = true;
							return;
						}
					}
					
					break;
				}
			}
		}
		
		car.update();
	}
	
	// 更新高分榜
	private void addToHighScore() {

		int i;
		for (i = 0; i < highScores.length; i++)
		{
			if (score > highScores[i])
				break;
		}

		// 将新纪录存入数组
		if (i < highScores.length)
		{
			for (int j = highScores.length-1; j > i; j--)
			{
				highScores[j] = highScores[j - 1];
			}

			highScores[i] = score;
		}
		
		rms.update(highScores);
	}
	
	public void input()
	{
		int keyState = getKeyStates();

		// 移动玩家
		if ((keyState & LEFT_PRESSED) != 0)
		{
			car.setDx(-2);
		}
		else if ((keyState & RIGHT_PRESSED) != 0)
		{
			car.setDx(4);
		}

		// 玩家射击
		if ((keyState & FIRE_PRESSED) != 0)
		{
			if (gameOver)
			{
				newGame();
			}
			else
			{
				fireDelay++;
				if(fireDelay>5)
				{
					BulletSprite bs = new BulletSprite(BulletSprite.TYPE_CAR);
					bs.setPosition(car.getX()+6, car.getY());
					bullets.addElement(bs);			
					fireDelay = 0;
				}
			}
		}
	}

	public void render()
	{
		bg.drawImage(imgBack, 0, 0, Graphics.TOP | Graphics.LEFT);
		
		car.paint(bg);
		//绘制怪物
	    for (int i = 0; i < monsters.size(); i++) {
			MonsterSprite monster=(MonsterSprite)monsters.elementAt(i);
			monster.paint(bg);
		}
	    //绘制子弹
	    for (int i = 0; i < bullets.size(); i++) {
			BulletSprite bullet=(BulletSprite)bullets.elementAt(i);
			bullet.paint(bg);
		}
	    //绘制爆炸效果	 
	    for (int i = 0; i < explosions.size(); i++) {
			Sprite explosion=(Sprite)explosions.elementAt(i);
			explosion.paint(bg);
		}
		
		//如果游戏结束,绘制闪屏图片及高分榜
		if (gameOver)
		{
			bg.drawImage(imgSplash, 120, 30, Graphics.TOP | Graphics.HCENTER);
			bg.setColor(255, 255, 255);
			bg.setFont(Font.getFont(Font.FACE_SYSTEM, Font.STYLE_BOLD,Font.SIZE_LARGE));

			for (int i = 0; i < 5; i++)
			{
				bg.drawString(Integer.toString(highScores[i]), 120,110 + (i * 15), Graphics.TOP | Graphics.HCENTER);
			}
		}
		else
		{
			// 否则，绘制玩家生命图标及得分
			for (int i = 0; i < carsRemain; i++)
			{
				bg.drawImage(imgSmallCar, 2 + (i * 20), 2, Graphics.TOP| Graphics.LEFT);
			}

			bg.setColor(255, 255, 255);
			bg.setFont(Font.getFont(Font.FACE_SYSTEM, Font.STYLE_PLAIN,Font.SIZE_MEDIUM));

			bg.drawString(Integer.toString(score), 175, 2, Graphics.TOP| Graphics.RIGHT);
		}
		
		this.flushGraphics();
	}
	
	private void newGame()
	{
		// 初始化游戏参数
		gameOver = false;
		score = 0;
		carsRemain = 3;

		// 初始化玩家精灵
		car.setPosition(0, getHeight()-car.getHeight()-10);
		car.setVisible(true);
		
		
		this.monsters.removeAllElements();
		this.bullets.removeAllElements();
		this.explosions.removeAllElements();
	}
	
	public Image getImgBullets()
	{
		return this.imgBullets;
	}
	
	public Image getImgCar()
	{
		return this.imgCar;
	}
	
	public Image getImgMonster(int type)
	{
		return this.imgMonster[type];
	}
	
	
	// 随机添加怪物中的一种
	public void bornMonster()
	{
		switch (Math.abs(rand.nextInt()%3))
		{
			// 添加异形
			case MonsterSprite.TYPE_BLOBBO:
			{
				MonsterSprite ms = new MonsterSprite(MonsterSprite.TYPE_BLOBBO);
				monsters.addElement(ms);
				
				break;
			}
			// 添加水母
			case MonsterSprite.TYPE_JELLY:
			{
				MonsterSprite ms = new MonsterSprite(MonsterSprite.TYPE_JELLY);
				monsters.addElement(ms);
				
				break;
			}
			// 添加蝗虫
			case MonsterSprite.TYPE_TIMMY:
			{
				MonsterSprite ms = new MonsterSprite(MonsterSprite.TYPE_TIMMY);
				monsters.addElement(ms);
				
				break;
			}
		}
	}
	
	public void delMonster(MonsterSprite ms)
	{
		this.monsters.removeElement(ms);
		ms = null;
	}
	
	public void delBullet(BulletSprite bs)
	{
		this.bullets.removeElement(bs);
		bs = null;
	}
	
	public void delExplosion(Sprite s)
	{
		this.explosions.removeElement(s);
		s = null;
	}

	public Vector getBullets() {
		return bullets;
	}

	public void setBullets(Vector bullets) {
		this.bullets = bullets;
	}
	
	
}