achievecanvas.java

类似于推箱子的手机游戏源码

/*
 * AchieveCanvas.java
 *
 * Created on 2007年11月27日, 上午10:48
 */

import java.io.IOException;
import java.io.InputStream;
import java.util.Timer;
import javax.microedition.lcdui.*;
import javax.microedition.lcdui.game.GameCanvas;
import javax.microedition.lcdui.game.Sprite;
import javax.microedition.lcdui.game.TiledLayer;
import javax.microedition.media.Manager;
import javax.microedition.media.MediaException;
import javax.microedition.media.Player;

/**
 *
 * @author  liang
 * @version
 */
public class AchieveCanvas extends GameCanvas implements Runnable {
    private static final int TIMEPERSTAGE = 45;
    private static final int UPMOVE = 1;//向上标志值
    private static final int DOWNMOVE = 2;//向下标志值
    private static final int LEFTMOVE = 3;//向左标志值
    private static final int RIGHTMOVE = 4;//向右标志值
    private static final int STARTING = 5;//游戏开始
    private static final int QUIT = 6;//离开游戏
    private static final int ALLSTATESPASSED = 7;//通关
    private static final int STAGEPASSING = 8;//过关
    private static final int GAMEOVER = 9;//游戏结束

    private int stage;//游戏状态
    private boolean isPaused;//初始化暂停状态
    private Image image;//目标图片
    private int ScreenWid;//屏幕宽度
    private int ScreenHigt;//屏幕高度
    private AchieveMidlet midlet;  
    private NumImgTools TimeFont;        //时间
    private volatile Thread mainThread = null; //游戏运行动画线程
    private Timer timer = null;
    private int LeftTime;
    private int StageNum;
    private MenuList menulist;
 
    private boolean gameover;
    private Stage level;
    private boolean isClose;
    private Player boxPlayer;
    private InputStream is;
    private InputStream passStream;
    private Player passPlayer;
    private InputStream gameoverStream;
    private Player gameoverPlayer;
    private InputStream explosionStream;
    private Player explosionPlayer;
    /**
     * constructor
     */
    public AchieveCanvas(AchieveMidlet midlet) {
        super(true);
        LeftTime = TIMEPERSTAGE;
        stage = STARTING;
        ScreenWid = getWidth();
        ScreenHigt = getHeight();
        this.midlet = midlet;
        init();
    }
    
    /**
     * paint
     */
    public void paint(Graphics g) {
         
        switch(stage){            
            case STARTING:
                DrawBackground(g);
                level.getBox().paint(g);
                if(level.getNumOfBombs() != 0){
                    for(int i=0; i<level.getNumOfBombs(); i++){
                        if(level.getFlag(i)){
                            int[] XY = level.getCoordinate(i);
                            g.setColor(36, 240, 6);
                            g.setFont(Font.getFont(Font.FACE_PROPORTIONAL,Font.STYLE_BOLD,Font.SIZE_MEDIUM));
                            g.drawString(String.valueOf(level.getTime(i)), XY[0]+4, XY[1], Graphics.TOP|Graphics.LEFT);
                        }
                    }
                }
                if(StageNum == 6){
                    level.getPipe(0).paint(g);
                    level.getPipe(1).paint(g);
                }
                    
                break;
            case STAGEPASSING:
                DrawBackground(g);       
                g.setColor(0x00FF00FF);
                g.setFont(Font.getFont(Font.FACE_PROPORTIONAL,Font.STYLE_BOLD,Font.SIZE_LARGE));
                g.drawString("Stage Pass", ScreenWid/2, ScreenHigt/2, Graphics.HCENTER|Graphics.TOP);
                break;
            case GAMEOVER:
                DrawBackground(g);                
                g.setColor(0x00FF00FF);
                g.setFont(Font.getFont(Font.FACE_PROPORTIONAL,Font.STYLE_BOLD,Font.SIZE_LARGE));
                g.drawString("Game Over", ScreenWid/2, ScreenHigt/2, Graphics.HCENTER|Graphics.TOP);
                break;
            case ALLSTATESPASSED:
                DrawBackground(g);                
                g.setColor(0x00FF00FF);
                g.setFont(Font.getFont(Font.FACE_PROPORTIONAL,Font.STYLE_BOLD,Font.SIZE_LARGE));
                g.drawString("All stages passed!", ScreenWid/2, ScreenHigt/2, Graphics.HCENTER|Graphics.TOP);
                break;
        }

    }
    
    /**
     * Called when a key is pressed.
     */
    protected  void keyPressed(int keyCode) {
         if(keyCode < 0){
            stop();
            doTimerStop();
            midlet.GameCanvasMenu();
        }
        
    }
    
    /**
     * Called when a key is released.
     */
    protected  void keyReleased(int keyCode) {
    }
    
    /**
     * Called when a key is repeated (held down).
     */
    protected  void keyRepeated(int keyCode) {
    }
    
    /**
     * Called when the pointer is dragged.
     */
    protected  void pointerDragged(int x, int y) {
    }
    
    /**
     * Called when the pointer is pressed.
     */
    protected  void pointerPressed(int x, int y) {
    }
    
    /**
     * Called when the pointer is released.
     */
    protected  void pointerReleased(int x, int y) {
    }
    
    /**
     * Called when action should be handled
     */
    public void commandAction(Command command, Displayable displayable) {
    }
    
    public synchronized void start() {
        mainThread = new Thread(this);
        mainThread.start();
       
    }
    
     public synchronized void continuegame(){
         if(isPaused)
            isPaused = false;
            doTimerStart();
     }
     
      private void doTimerStart() {
        //计时器不是null的时候就启动计时器
        if(timer == null) {
            GameTimer gameTimer = new GameTimer(this);
            timer = new Timer();
            timer.schedule(gameTimer, 1000, 1000);
        }
    }
      
      public void SubSec() {
         if(LeftTime != 0){
              LeftTime--;
          }
        if(level.getNumOfBombs() != 0){
            for(int i=0; i<level.getNumOfBombs(); i++){
                if(level.getFlag(i)){
                    level.setTime(i);
                    if(level.getTime(i)==0){
                        int[] index = level.getCoordinate(i);
                        player(explosionPlayer);
                        int col = (index[0] - level.getbackgroundLayer().getX())/15;
                        int row = (index[1] - level.getbackgroundLayer().getY())/15;
                        level.getbackgroundLayer().setCell(col,row,0);
                        level.setLeftOfBombs();
                        if(level.getLeftOfBombs() == 0){
                            doStagepassing();
                            break;
                        }
                        level.setFlag(i,false);
                    }
                }
            }
        }
       if ( LeftTime == 0 ){            
                stage = GAMEOVER;
        }
        repaint();
    }

    public void run() {
        while(true){
           if(isPaused){
                try {
                    mainThread.sleep(80);
                } catch (InterruptedException ex) {
                    ex.printStackTrace();
                }
               continue;
            }
           
           
          doTimerStart();
          switch(stage){
              case STARTING:
                 doPoseMove(); 
                  break;
              case GAMEOVER:
                  doGameover();
                  break;
              case ALLSTATESPASSED:
                  doGameover();
                  break;
                    
          }
   }
}    
   
        
    public void doStagepassing(){
        stage = STAGEPASSING;
        if(StageNum == 7){
            stage = ALLSTATESPASSED;
            return;
        }
        player(passPlayer);
        repaint();
        threadSleep();
        StageNum++;
        LeftTime = TIMEPERSTAGE;    
        level = new StageFactory().creatStage(StageNum, this);
        level.init();
        stage = STARTING;
    }
        
  
     
     private void doGameover(){ 
        player(gameoverPlayer);
        repaint();
        try {
            mainThread.sleep(3000);
        } catch (InterruptedException ex) {
            ex.printStackTrace();
        }
        
        midlet.GameCanvasGameOver();
     }
    
    public void init(){ 
           try{
               is = getClass().getResourceAsStream("move.wav");
               boxPlayer = Manager.createPlayer(is,"audio/X-wav");
               passStream = getClass().getResourceAsStream("pass.wav");
               passPlayer = Manager.createPlayer(passStream,"audio/X-wav");
               gameoverStream = getClass().getResourceAsStream("gameover.wav");
               gameoverPlayer = Manager.createPlayer(gameoverStream, "audio/X-wav");
               explosionStream = getClass().getResourceAsStream("explosion.wav");
               explosionPlayer = Manager.createPlayer(explosionStream, "audio/X-wav");
           }
           catch(IOException ioe){
           }
           catch(MediaException e){
           }
           catch(OutOfMemoryError e){
           }
        isClose = false;
        stage = STARTING;
        isPaused = false;
        gameover = false;
        StageNum = 1;
        LeftTime = TIMEPERSTAGE;
        level = new StageFactory().creatStage(StageNum, this);
        level.init();
       
    }
    
       private void doPoseMove(){
  
        int KeyState = getKeyStates();

        if( (KeyState & UP_PRESSED) != 0){           
            player(boxPlayer);
            doMove(UPMOVE);
        }
        else if( (KeyState & DOWN_PRESSED) != 0){
            player(boxPlayer);
            doMove(DOWNMOVE);
            
        }
        else if( (KeyState & LEFT_PRESSED) != 0 ){
           player(boxPlayer);
           doMove(LEFTMOVE);
            
        }
        else if( (KeyState & RIGHT_PRESSED) != 0 ){
             player(boxPlayer);
             doMove(RIGHTMOVE);
           
        }
           
    }
   private void doMove(int keypressed){
        level.checkCollision(keypressed);
        if(gameover){
             stage = GAMEOVER;
             repaint();
        }
        
        
  }
   
   
   public boolean CheckOutOfEdge(){
       if(level.getBox().getX() < 0 || level.getBox().getX() > ScreenWid || 
            level.getBox().getY() < 0 || level.getBox().getY() > ScreenHigt){          
            gameover = true;
            return true;
       }
       else 
           return false;
   
   }
   
 
   private void DrawBackground(Graphics g){
         g.setColor(0x000000);
         g.fillRect(0, 0, ScreenWid, ScreenHigt);        
         level.getbackgroundLayer().paint(g);
         level.getExit().paint(g);
         g.setColor(0x00FF00FF);
         g.setFont(Font.getFont(Font.FACE_PROPORTIONAL,Font.STYLE_BOLD,Font.SIZE_LARGE));
         g.drawString(String.valueOf(LeftTime), ScreenWid/2, 1, Graphics.TOP|Graphics.LEFT);
   }
   
   public synchronized void stop(){ 
         if(!isPaused)
            isPaused = true;
  }
    
   private void doTimerStop() {
        //计时器不是null的时候就停止计时器
        if(timer != null) {
            timer.cancel();
            timer = null;
        }
    }
   public void threadSleep(){
        try {
                mainThread.sleep(80);
                } catch (InterruptedException ex) {
                    ex.printStackTrace();
                }      
   } 
   
   public void player(Player player){
        try {
            player.prefetch();
        } catch (MediaException ex) {
            ex.printStackTrace();
        }
        try {
            player.start();
        } catch (MediaException ex) {
            ex.printStackTrace();
        }
   }
    
   public Player getexplosionPlayer(){
        return explosionPlayer;
   }

}