scorescreen.java

J2ME超级坦克大战源码

import java.util.*;
import javax.microedition.lcdui.*;
import javax.microedition.lcdui.game.*;


public final class ScoreScreen extends GameCanvas implements Runnable{
    
    /**
     * Score board image.
     */
    private static Image imgScore=null;
    
    /**
     * black number image from 0 to 9
     */
    private static Image imgNumberWhite=null;
    
    /**
     * red number image from 0 to 9
     */
    private static Image imgNumberRed=null;
            
    
    /**
     * reference to player tank
     */
    private static PlayerTank playerTank=null;

    /**
     * picture drawing x offset.
     */
    private int offsetX=0;
    
    /**
     * picture drawing y offset. to make the image center in the screen.
     */
    private int offsetY=0;
    
    /**
     * where to draw high score.
     */
    private int highScoreX=0;
    
    /**
     * where to draw high score.
     */
    private int highScoreY=0;
    
    /**
     * where to draw player score.
     */
    private int playerScoreX=0;
    
    /**
     * where to draw player score.
     */
    private int playerScoreY=0;
    
    /**
     * where to draw total number.
     */
    private int totalNumberX=0;
    
    /**
     * where to draw total number.
     */
    private int totalNumberY=0;
    
    /**
     * where to draw enemy tank count.
     */
    private int[][] tankNumberPos=new int[4][2];
    
    /**
     * is the game over?
     */
    private boolean isGameOver=false;
   
    private int enemyType=0;
    
    /**
     * the index of enemy count.
     */
    private int enemyCount=0;
    
    /**
     * total enemy number killed
     */
    private int totalKilled=0;
    
    
    private int totalKilledIndex=0;
    
    /**
     * the animation thread.
     */
    private Thread animationThread=null;
    
    /**
     * switch screen timer.
     */
    private Timer timer=null;
    
    /**
     * timer task to swith screen.
     */
    private Switch2Screen switchScreen=null;
   
    
    public ScoreScreen() {
        super(false);
        setFullScreenMode(true);
        imgScore=ResourceManager.getInstance()
            .getImage(ResourceManager.SCORE_SCREEN);
        offsetX=(getWidth()-imgScore.getWidth())/2;
        offsetY=(getHeight()-imgScore.getHeight())/2;
        playerTank=Tank.getPlayerTank();  
        imgNumberWhite=ResourceManager.getInstance()
            .getImage(ResourceManager.NUMBER_WHITE);
        imgNumberRed=ResourceManager.getInstance()
            .getImage(ResourceManager.NUMBER_RED);
        highScoreX=getWidth()/2+16;
        highScoreY=offsetY;
        playerScoreX=getWidth()/4;
        playerScoreY=offsetY+35;
        for(int i=0;i<4;i++){
            tankNumberPos[i][0]=playerScoreX;
            tankNumberPos[i][1]=offsetY+50+i*16-1;
        }
        totalNumberX=playerScoreX+40;
        totalNumberY=offsetY+113;
        timer=new Timer();
        switchScreen=new Switch2Screen();
        
    }
    
   
    private void drawNumber(Graphics g, int number,int x,int y,boolean isRed){
        Image imageNumber=null;
        if(isRed){
            imageNumber=imgNumberRed;
        }else{
            imageNumber=imgNumberWhite;
        }
        String strNumber=String.valueOf(number);
        int numberWidth=imageNumber.getHeight();
        for(int i=0;i<strNumber.length();i++){
            char ch=strNumber.charAt(i);
            int index=(ch-'0') % 10;
            Image oneNumber=Image.createImage(imageNumber,index*numberWidth,0,
                    numberWidth,numberWidth,0);
            if(isRed){
                g.drawImage(oneNumber,x+i*numberWidth,y,0);
            }else{
                //right alignment
                g.drawImage(oneNumber,x+(i-strNumber.length()+2)*numberWidth,y,0);
            }
        }
    }
    
    public void show(boolean gameOver){
        if(ResourceManager.isPlayingSound){
            ResourceManager.playSound(ResourceManager.SCORE_SOUND);
        }
        isGameOver=gameOver; 
        enemyType=0;
        enemyCount=0;
        totalKilled=0;
        for(int i=0;i<4;i++){
            int value=GameScene.enemyTanksCount[i]*(i+1)*100;
            playerTank.addScore(value);
            totalKilled+=GameScene.enemyTanksCount[i];
        }
        totalKilledIndex=totalKilled;
        animationThread=new Thread(this);
        animationThread.start();
    }
    
    
    public void paint(Graphics g){
        //clear background to black
        g.setColor(0x000000);
        g.fillRect(0,0,getWidth(),getHeight());
        g.drawImage(imgScore,offsetX,offsetY,0);
        drawNumber(g,ResourceManager.highScore,highScoreX,highScoreY,true);
        drawNumber(g,playerTank.getScore(),playerScoreX,playerScoreY,true);
        if(enemyType>3){
            enemyType=3;
        }
        for(int i=0;i<enemyType;i++){
            drawNumber(g,GameScene.enemyTanksCount[i]*100,tankNumberPos[i][0],
                    tankNumberPos[i][1],false);
            drawNumber(g,GameScene.enemyTanksCount[i],tankNumberPos[i][0]+35,
                    tankNumberPos[i][1],false);
        }
        drawNumber(g,enemyCount*100,tankNumberPos[enemyType][0],
                tankNumberPos[enemyType][1],false);
        drawNumber(g,enemyCount,tankNumberPos[enemyType][0]+35,
                tankNumberPos[enemyType][1],false);

        drawNumber(g,totalKilled,totalNumberX,totalNumberY,false);
       
        
     }
    
    
    public void run(){
        Thread thread=Thread.currentThread();
        if(thread==animationThread){
            while(totalKilledIndex>0 || enemyType<3){
                repaint();
                if(enemyCount>=GameScene.enemyTanksCount[enemyType]){
                    enemyCount=0;
                    enemyType++;
                }
                
                
                try{
                    Thread.sleep(200);
                }catch(Exception e){}
                enemyCount++;
                if(enemyType>3) {
                    enemyType=3;
                    break;
                }
                totalKilledIndex--;
            }
            if(switchScreen!=null){
               switchScreen=null; 
            }
            switchScreen=new Switch2Screen();
            switchScreen.setGameover(isGameOver);
            timer.schedule(switchScreen,2000);
            
        }
        
        
    }
    
}

//
class Switch2Screen extends TimerTask{
       
    private boolean isGameOver=false;
    
     
    void setGameover(boolean gameover){
        isGameOver=gameover;
    }
   
    public void run(){
        
         if(isGameOver){
                ResourceManager.gameoverScreen.show();
                ResourceManager.setCurrentScreen(ResourceManager.gameoverScreen);
        }else{
            ResourceManager.gameScene.newGame();
            ResourceManager.setCurrentScreen(ResourceManager.gameScene);
        }
        
    }
}