gamescreen.java

坦克大战

/*
 * 创建日期 2005-7-5
 *
 * TODO 要更改此生成的文件的模板，请转至
 * 窗口 － 首选项 － Java － 代码样式 － 代码模板
 */
package game;

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

import javax.microedition.lcdui.Graphics;
import javax.microedition.lcdui.Image;
import javax.microedition.lcdui.game.GameCanvas;
import javax.microedition.lcdui.game.Sprite;
import javax.microedition.lcdui.game.TiledLayer;


/**
 * @author Administrator
 *
 * TODO 要更改此生成的类型注释的模板，请转至
 * 窗口 － 首选项 － Java － 代码样式 － 代码模板
 */
public class GameScreen extends GameCanvas implements Runnable {
	// 坦克移动方向
    private static int INDEX_OF_UP = 0;
    private static int INDEX_OF_DOWN = 1;
    private static int INDEX_OF_LEFT = 3;
    private static int INDEX_OF_RIGHT = 2;

	private final FighterMIDlet midlet;
    private Graphics g; 
	
	// 游戏是否进行
    private boolean isPlay;
    
    // 屏幕尺寸
    private int width; 
    private int height; 
    
    // 坦克位置
    private int currentX, currentY;
    
    // 敌人位置
    private int enemyX, enemyY;    
    
    // 子弹位置
    private int shotX, shotY;
    
    // 敌人子弹位置
    private int shotEX,shotEY;
    
    // 子弹方向
    private int shotDirection = 0;
    
    // 敌人子弹方向
    private int shotEDirection = 0;
    
    // 敌人前进方向
    private int enemyDirection = 0;
    
    // 延迟
    private long delay; 
    
    // 坦克精灵
    private Sprite spriteTank;
    
    // 敌人精灵
    private Sprite spriteEnemy;
    
    // 爆炸精灵
    private Sprite spriteFire;
    
    // 子弹精灵
    private Sprite spriteShot;
    
    // 敌人子弹精灵
    private Sprite spriteEShot;

    // 背景图层
    private TiledLayer tiles;
    
    // 敌人重定向时间间隔
    private int waitTime = 0;

    // 随机数
	private Random rand = new Random();

	/**
	 * @param arg0
	 */
	public GameScreen(FighterMIDlet midlet) {
		super(true);

		// 保存MIDlet类对象
		this.midlet = midlet;
		
		// 初始化
        width = getWidth();
        height = getHeight();
        currentX = width / 2;
        currentY = height / 2;
        shotX = currentX;
        shotY = currentY;        
        enemyX = 20;
        enemyY = 20;
        shotEX = enemyX;
        shotEY = enemyY;
        delay = 20;
       
        // 初始化精灵
        try {
            Image imageTank = Image.createImage("/play.png");
            spriteTank = new Sprite(imageTank, 16, 16);

            Image imageEnemy = Image.createImage("/enemy.png");
            spriteEnemy = new Sprite(imageEnemy, 16, 16);             

            Image imageFire = Image.createImage("/fire.png");
            spriteFire = new Sprite(imageFire, 32, 32);
            
            Image imageShot = Image.createImage("/shot.png");
            spriteShot = new Sprite(imageShot);       
            spriteEShot = new Sprite(imageShot);
        }
        catch(Exception e) { e.printStackTrace(); }

        // 初始化背景
        try {
       		Image imageGround = Image.createImage("/ground.png");
            tiles = new TiledLayer(width / 16 + 1, height / 16 + 1, imageGround, 16, 16);
            for (int i = 0; i < width / 16 + 1 ; i++)
            	for  (int j = 0; j < height / 16 + 1; j++)
            		tiles.setCell(i, j, 1);
       } catch (IOException e) {}
       
 	}

	// 开启线程
    public void start() {
        isPlay = true;
 
        new Thread(this).start();
    }

    // 停止线程
    public void stop() { 
    	isPlay = false; 
    }

    // 主循环
    public void run() {
        g = getGraphics();
        while (isPlay) {
        	// 检测用户输入
            input();
            
            // 绘制场景
            drawScreen(g);
            
            // 延迟
            try {
                Thread.sleep(delay);
            }
            catch (InterruptedException ie) {}
        }
    }

    // 用户输入处理
    private void input() {
    	// 得到按键状态
        int keyStates = getKeyStates();
         
        // 坦克左移
        if ((keyStates & LEFT_PRESSED) != 0){
            currentX = Math.max(0, currentX - 1);
            spriteTank.setFrame(INDEX_OF_LEFT);
            shotDirection = INDEX_OF_LEFT;
        }
        // 坦克右移
        if ((keyStates & RIGHT_PRESSED) !=0 ){
            if ( currentX + 5 < width)
                currentX = Math.min(width, currentX + 1);
            spriteTank.setFrame(INDEX_OF_RIGHT);
            shotDirection = INDEX_OF_RIGHT;
        }
        // 坦克上移
        if ((keyStates & UP_PRESSED) != 0){
            currentY = Math.max(0, currentY - 1);
           spriteTank.setFrame(INDEX_OF_UP);
           shotDirection = INDEX_OF_UP;
        }
        // 坦克下移
        if ((keyStates & DOWN_PRESSED) !=0){
            if ( currentY + 10 < height)
                currentY = Math.min(height, currentY + 1);
           spriteTank.setFrame(INDEX_OF_DOWN);
           shotDirection = INDEX_OF_DOWN;
        }
           
        // 开火
        if ((keyStates & FIRE_PRESSED) !=0){
        	// 子弹当前位置
            shotX = currentX;
            shotY = currentY;
            spriteShot.setPosition(shotX+6, shotY+6);
    
            // 打出子弹
            while (shotX > 0 && shotY > 0 && shotX < width && shotY < height){
	            switch (shotDirection){
	            	case 0:		// 子弹上移
	            		shotY--;
	            		spriteShot.move(0, -1);
	            		break;
	            	case 1:		// 子弹下移
	            		shotY++;
	            		spriteShot.move(0, 1);
	            		break;
	            	case 3:		// 子弹左移
	            		shotX--;
	            		spriteShot.move(-1, 0);
	            		break;
	            	case 2:		// 子弹右移
	            		shotX++;
	            		spriteShot.move(1, 0);
	            		break;
	            }
	            
	            // 绘制场景
	            drawScreen(g);
	            
                // 绘制子弹
                spriteShot.paint(g);
                flushGraphics();
                
                // 延迟
                try {
                    Thread.sleep(1);
                }
                catch (InterruptedException ie) {}
            }
        }        
        
    }

    // Method to Display Graphics
    private void drawScreen(Graphics g) {
    	// 绘制背景
    	tiles.paint(g);

        // 绘制坦克
        spriteTank.setPosition(currentX, currentY);
        spriteTank.paint(g);
        
        // 设置敌人
        waitTime++;
        if (waitTime == 30){
        	waitTime = 0;
        	
        	// 随机更换移动方向
			enemyDirection = ((int)(rand.nextLong())) % 4; 
        }
        
        switch (enemyDirection){
        case 0:		// 上移
        	enemyY--;
        	if (enemyY < 10)
        		enemyDirection = 2;        		
        	spriteEnemy.setFrame(INDEX_OF_UP);
        	break;
        case 1:		// 下移
        	enemyY++;
        	if (enemyY > height - 10)
        		enemyDirection = 3;
        	spriteEnemy.setFrame(INDEX_OF_DOWN);
        	break;
        case 2:		// 右移
        	enemyX++;
        	if (enemyX > width - 10)
        		enemyDirection = 1;
        	spriteEnemy.setFrame(INDEX_OF_RIGHT);
        	break;
        case 3:		// 左移
        	enemyX--;
        	if (enemyX < 10)
        		enemyDirection = 0;
        	spriteEnemy.setFrame(INDEX_OF_LEFT);
        	break;
        }       
       
        // 绘制敌人
        spriteEnemy.setPosition(enemyX, enemyY);
        spriteEnemy.paint(g);
        
       	// 敌人开火
        if (shotEX >= 0 && shotEY >= 0 && shotEX <= width && shotEY <= height){
        	switch (shotEDirection){
	           	case 0:		// 子弹上移
	           		shotEY -= 2;
	           		spriteEShot.move(0, -2);
	           		break;
	           	case 1:		// 子弹下移
	           		shotEY += 2;
	           		spriteEShot.move(0, 2);
	           		break;
	           	case 3:		// 子弹左移
	           		shotEX -= 2;
	           		spriteEShot.move(-2, 0);
	           		break;
	           	case 2:		// 子弹右移
	           		shotEX += 2;
	           		spriteEShot.move(2, 0);
	           		break;
	           	default:
	            	// 子弹当前位置
	                shotEX = enemyX;
	                shotEY = enemyY;
	                spriteEShot.setPosition(shotEX+6, shotEY+6);
	                shotEDirection = enemyDirection;
	           		break;
	        }            
        }else{
        	// 子弹当前位置
            shotEX = enemyX;
            shotEY = enemyY;
            spriteEShot.setPosition(shotEX+6, shotEY+6);
            shotEDirection = enemyDirection;
        }       

        // 绘制敌人子弹
        spriteEShot.paint(g);
        
        // 碰撞检测
        if (spriteEShot.collidesWith(spriteTank, false) == true){
        	// 我方坦克被击中
            for (int i = 0; i<4; i++){
        		spriteFire.setFrame(i);
	             // 画一个Sprite非常简单：
	             spriteFire.setPosition(currentX - 10, currentY);
	             spriteFire.paint(g);
	             flushGraphics();           		
	             try {
	                 Thread.sleep(delay * 4);
	             }
	             catch (InterruptedException ie) {}
            }	     
            
            // 我方坦克和子弹复位
			spriteShot.setPosition(-1, -1);
			spriteTank.setPosition(width / 2, height / 2);
			spriteTank.paint(g);			
			currentX = width / 2;
			currentY = height / 2;
			shotEX = -1;
			shotEY = -1;
			shotX = -1;
			shotY = -1;        
        }

        if (spriteEnemy.collidesWith(spriteShot, false) == true){
        	// 敌方坦克被击中
            for (int i = 0; i<4; i++){
            		spriteFire.setFrame(i);
                 // 画一个Sprite非常简单：
                 spriteFire.setPosition(enemyX - 10, enemyY);
                 spriteFire.paint(g);
                 flushGraphics();           		
                 try {
                     Thread.sleep(delay * 4);
                 }
                 catch (InterruptedException ie) {}
            }
            
            // 敌方坦克和子弹复位
            spriteShot.setPosition(-1, -1);
            spriteEnemy.setPosition(20, 20);
            spriteEnemy.paint(g);
            shotX = -1;
            shotY = -1;        
            shotEX = -1;
            shotEY = -1;
            enemyX = 20;
            enemyY = 20;
        }
 
        // 显示
        flushGraphics();
    }
}