tankcanvas.java

J2ME手机游戏源码 整个游戏有八个类组成： &#61548 主类：TankMIDlet &#61548 敌人坦克：Enemy &#61548 图片池：EnemyPool &#61548

import java.io.*;
import javax.microedition.lcdui.*;
import javax.microedition.midlet.*;
import java.util.Random;
import java.util.Vector;
public class TankCanvas extends Canvas implements Runnable
{
    private final TankMIDlet midlet;
    public static Graphics g = null;
    private int gameStatus=1;

    private int gameSubStatus=1;
    private int gameSelect = 1;
    private int CanvasWidth, CanvasHeight;
    private int fontHeight, fontWidth;
    private int level = 1;
    private static int MAX_LEVEL = 20;
    private int passPos = 1;
    private int title_x, title_y;
    private int title_w, title_h;
    private int SplashCnt;
    private int ResultCnt;
    private int fadeColor;
    private int frameWidth, frameHeight;
    public int mapWidth, mapHeight;
    public int mapOffsetX, mapOffsetY;
    public int dataOffsetX, dataOffsetY;
    public int tileW;
    public int tileWidth, tileHeight;
    private int i,j;
    private boolean isPaused = false;
    private boolean isFirstTime = true;
    private boolean isShowLevel = true;
    private boolean isFadeIn = true;
    private boolean isNotationDown=false;
    private boolean isVictorShowed=false;
    private boolean isCapped=false;
    private Image imgSplash;
    private Image imgTankEnemy;
    private Image imgTankPlayer;
    private Image imgTitle;
    private Image imgMap;
    private Image imgTile1;
    private Image imgTile2;
    private Image imgTile3;
    private Image imgTile4;
    private Image imgVictor;
    private Image imgLogoPlayer;
    private Image imgLogoEnemy;
    private Image imgMedal;
    private Image imgTemp;
    
    private Image again1;
    private Image again2;
    private Image next1;
    private Image next2;
    private Image back1;
    private Image back2;
    private Image exit1;
    private Image exit2;
    private Font font;
    private volatile Thread gameThread = null;
    public int mapInfo[] = new int[(52 * 52)];
    public int mapInfoFormer[] = new int[(52*52)];
    private int liveCount=0;

    boolean pauseStart = false;
    boolean canMove=true;
    boolean ifTimer=false;
    boolean homeWall=false;
    
    private Bullet[] bullet = new Bullet[3];
    public boolean bulletAlive[] = new boolean[3];
    public int maxBullet = 3;
    private EnemyPool pool;
    
    private Vector tempPos = new Vector();
    private Enemy[] enemy;
    private Enemy[] backenemy;
    private Enemy[] enemyNormal;
    private Enemy[] enemyGreen;
   
    private int timeCount=0;
    private int maxShowEnemy = 7;
    private int leftEnemy;
    
    boolean enemyAlive[] = new boolean[maxShowEnemy]; //modified by johnson
    private int currentEnemy =3;
    private final int MAX_NUM = 15;
    private int numPos = 0; 
    private int[] enemyGroup={0,0,0,2,1,3,2,0,2,1,0,3,3,2,1,0,0,0,0,0};
    
    private Image bombImage;
   
    boolean shootFlag = false;
    boolean grassPaint = false;
    public Hero hero;
    public  int life = 3; 
    Bonus bonus = new Bonus();
    private int totalMark;
    private int bonusMark;
    private int normalNum;
    private int redNum;
    private int greenNum;
    private int superNum;
    
    
    public boolean isWin, isLose;
  
    boolean reDraw=false;
    
    public TankCanvas(TankMIDlet midlet)
    {     
        this.midlet = midlet;
        CanvasWidth = getWidth(); //240	
        CanvasHeight = getHeight(); //289

        pool = new EnemyPool();

        isPaused = false;

        font = Font.getFont(Font. FACE_PROPORTIONAL, Font.STYLE_BOLD,
            Font.SIZE_LARGE);
        fontHeight = font.getHeight();
        fontWidth = font.charWidth('坦');
        isNotationDown = (CanvasWidth > CanvasHeight) ? true : false;
        hero = new Hero(this); 
        initLevel();        
        enemy = new Enemy[MAX_NUM];
        backenemy = new Enemy[MAX_NUM];
        enemyNormal = new Enemy[4];
        enemyGreen = new Enemy[4];
  
        for(int i = 0; i < MAX_NUM; i++){
            enemy[i] = new Enemy(this,enemyGroup[i]);
        }
       
        for(int i=0;i<MAX_NUM;i++){
           backenemy[i] = enemy[i];
        }
        for(int i=0;i<4;i++){
           enemyNormal[i] = new Enemy(this,0);
        }
        for(int i=0;i<4;i++){
           enemyGreen[i] = new Enemy(this,2);
        }

            bombImage = createImage("/explode.png");


        for ( int i = 0; i < maxBullet; i ++ ){
            bulletAlive[i] = false;
            bullet[i] = new Bullet(this);
        }


            again1 = createImage("/again1.png");
            again2 = createImage("/again2.png");
            next1 =  createImage("/next1.png");
            next2 =  createImage("/next2.png");
            back1 =  createImage("/back1.png");
            back2 =  createImage("/back2.png");
            exit1 =  createImage("/exit1.png");
            exit2 =  createImage("/exit2.png");
      
    }
    public void run()
    {
        Thread currentThread = Thread.currentThread();
        int gameSpeed = 100;
        try
        {
            while (currentThread == gameThread)
            {
                if (gameStatus == 4)
                    gameSpeed = 70;
                else
                    gameSpeed = 50;
                long startTime = System.currentTimeMillis();
                repaint();
                serviceRepaints();
                long timeTaken = System.currentTimeMillis() - startTime;
                if (timeTaken < gameSpeed)
                {
                    synchronized(this)
                    {
                        wait(gameSpeed - timeTaken);
                    }
                }
            }
        }
        catch (InterruptedException e){}
    }
   void fireBullet(int bulletNo, int direction, int posX, int posY, int offset) {
        if (!bullet[bulletNo].alive){
            bulletAlive[bulletNo] = true;
            bullet[bulletNo].alive = true;
            bullet[bulletNo].direction = direction & 0x0f;
            if (bullet[bulletNo].direction == 0)
                bullet[bulletNo].direction = 3;
            switch(bullet[bulletNo].direction) {
                case 1:		
                    bullet[bulletNo].posY = posY + offset;
                    shootFlag = true;
                    if (posX > (mapOffsetX + 2)){
                        bullet[bulletNo].posX = posX;
                    }else {
                        bullet[bulletNo].posX = mapOffsetX + 2;
                    }
                    break;
                case 2:		
                    bullet[bulletNo].posY = posY + offset;
                    shootFlag = true;
                    if ( posX < (mapOffsetX+mapWidth-18) ){
                        bullet[bulletNo].posX = posX + 4;
                    }else {
                        bullet[bulletNo].posX = mapOffsetX+mapWidth-10;
                    }
                    break;
                case 3:		
                    bullet[bulletNo].posX = posX + offset;
                    shootFlag = true;
                    if ( posY > (mapOffsetY+2) ){
                        bullet[bulletNo].posY = posY;
                    }else {
                        bullet[bulletNo].posY = mapOffsetY+2;
                    }
                    break;
                case 4:		
                    bullet[bulletNo].posX = posX + offset;
                    shootFlag = true;
                    if (posY < (mapOffsetY+mapHeight-18) ){
                        bullet[bulletNo].posY = posY + 4;
                    }else {
                        bullet[bulletNo].posY = mapOffsetY+mapHeight-10;
                    }
                default:
                    break;
            }
        }
    }
    public void start()
    {
        if (isPaused)
        {
            isPaused = false;
            isFirstTime = true;
        }
        else
        {
            isFirstTime = true;
            gameThread = new Thread(this);
            gameThread.start();
        }
    }
    void initLevel()
    {

        imgMap = createImage("/tiles.png");
        tileWidth = imgMap.getWidth() / 4;
        tileHeight = imgMap.getHeight() / 2;
        imgTile1 = Image.createImage(tileWidth, tileHeight);
        g = imgTile1.getGraphics();
        g.drawImage(imgMap, 0, 0, 20); //20:g.topleft
        imgTile2 = Image.createImage(tileWidth, tileHeight);
        g = imgTile2.getGraphics();
        g.drawImage(imgMap,  - tileWidth, 0, 20);
            
        imgTile3 = Image.createImage(tileWidth, tileHeight);
        g = imgTile3.getGraphics(); 
        g.drawImage(imgMap, 0,  - tileHeight, 20);
        imgTile4 = Image.createImage(tileWidth, tileHeight);
        g = imgTile4.getGraphics(); 
        g.drawImage(imgMap,  - tileWidth,  - tileHeight, 20);
        imgVictor = Image.createImage(tileWidth * 2, tileHeight * 2);
        g = imgVictor.getGraphics();
        g.drawImage(imgMap,  - tileWidth * 2, 0, 20);
   
            imgTemp = createImage("/tank_p.png");
            imgLogoPlayer = Image.createImage(imgTemp.getWidth()/4, imgTemp.getHeight());
            g = imgLogoPlayer.getGraphics();
            g.drawImage(imgTemp, -imgTemp.getWidth()/2, 0, 20);
            imgTemp = createImage("/tank_en.png");
            imgLogoEnemy = Image.createImage(imgTemp.getWidth()/4, imgTemp.getHeight());
            g = imgLogoEnemy.getGraphics();
            g.drawImage(imgTemp, -imgTemp.getWidth()/2, 0, 20);
 
        g = null;
        tileW = tileWidth / 2;
        mapWidth = (CanvasWidth < CanvasHeight) ? CanvasWidth : CanvasHeight;
        mapWidth = ((mapWidth - tileWidth * 2) / (tileWidth * 2)) * (tileWidth* 2);
        if (mapWidth > (52 / 2 * tileWidth))
            mapWidth = 52 / 2 * tileWidth;
        //System.out.println("mapWidth = "+mapWidth);
        mapHeight = mapWidth;
        if (CanvasWidth > CanvasHeight)
        {
            mapOffsetX = (CanvasWidth - mapWidth - hero.frameWidth) / 2;
            mapOffsetY = (CanvasHeight - mapHeight) / 2-10;
        }
        else
        {
            mapOffsetX = (CanvasWidth - mapWidth) / 2;
            mapOffsetY = (CanvasHeight - mapHeight - hero.frameHeight) / 2-10;
        }
        dataOffsetX = ((52 * tileW - mapWidth) / 2) / tileW;
        dataOffsetY = (52 * tileW - mapHeight) / tileW;
    }
    private boolean readMap(int lev)
    {
        InputStream is = null;
        int c;
        i = 0;
        j = 0;
        int index;
        int tempInfo[] = new int[(52) * (52)];
        int item, itemNum;
        try
        {
            is = getClass().getResourceAsStream("/" + lev + ".map");
            if (is != null)