splashtest.java

在J2ME程序中制作Splash画面效果

import javax.microedition.midlet.*;
import javax.microedition.lcdui.*;
import java.util.*;
import java.io.*;

public class SplashTest extends MIDlet{

	Display display;
	MyCanvas myCanvas;
	SplashCanvas splash;

	public SplashTest(){
		display = Display.getDisplay(this);
		myCanvas = new MyCanvas();
		splash = new SplashCanvas(display, myCanvas);
	}

	public void startApp(){
		display.setCurrent(splash);
	}

	public void pauseApp(){
	}

	public void destroyApp(boolean unconditional){
	}

	class MyCanvas extends Canvas implements CommandListener{

		static final int MY_SPRITE = 49;
		static final int WALL = 50;
		static final int ENEMY = 51;

		Command exitCmd;
		Image offScreen;
		Image mySpriteImage;
		Image enemyImage;
		Image wallImage;
		int x, y;
		int startX, startY;
		int totalWidth = 120*3, totalHeight = 120;
		int cellWidth = 24, cellHeight = 24;
		int XCellNum = 15;
		int YCellNum = 5;
		byte[][] mapData = new byte[YCellNum][XCellNum];

		public MyCanvas(){

			if(!isDoubleBuffered()){
				offScreen = Image.createImage(getWidth(), getHeight());
			}

			try{
				mySpriteImage = Image.createImage("/mySprite.png");
				enemyImage = Image.createImage("/enemy.png");
				wallImage = Image.createImage("/wall.png");
			}
			catch(Exception ex){}

			getMapData();

			exitCmd = new Command("退出", Command.EXIT, 1);
			addCommand(exitCmd);
			setCommandListener(this);
		}

		public void paint(Graphics g){

			Graphics old = g;

			if(offScreen != null){
				g = offScreen.getGraphics();
			}

			g.setColor(0xFFFFFF);
			g.fillRect(0, 0, getWidth(), getHeight());
			g.translate(startX, startY);

			for(int i=0; i < YCellNum; i++){
				for(int j=0; j < XCellNum; j++){
		    		byte data = mapData[i][j];
		    		switch(data){
		    		case WALL:
						g.drawImage(wallImage, j*cellWidth, i*cellHeight, Graphics.LEFT|Graphics.TOP);
					break;
		    		case MY_SPRITE:
		    			g.drawImage(mySpriteImage, x+j*cellWidth, y+i*cellHeight, Graphics.LEFT|Graphics.TOP);
		    		break;
		    		case ENEMY:
						g.drawImage(enemyImage, j*cellWidth, i*cellHeight, Graphics.LEFT|Graphics.TOP);
					break;
					}
				}
			}
			g.translate(-startX, -startY);

			if(g != old){
				old.drawImage(offScreen, 0, 0, Graphics.LEFT|Graphics.TOP);
			}
		}

		public void keyPressed(int keyCode){
			int gameAction = getGameAction(keyCode);
			switch(gameAction){
			case Canvas.UP:
				if(!isWall(x/24, (y-24)/24)){
					y-=24;
					if(y<=0) y = 0;
					startY+=24;
					if(startY>=0) startY = 0;
				}
				repaint();
			break;
			case Canvas.DOWN:
				if(!isWall(x/24, (y+24)/24)){
					y+=24;
					if(y>=totalHeight) y = totalHeight;
					startY-=24;
					if(startY<=getHeight()-totalHeight)
						startY = getHeight()-totalHeight;
				}
				repaint();
			break;
			case Canvas.LEFT:
				if(!isWall((x-24)/24, y/24)){
					x-=24;
					if(x<=0) x = 0;
					startX+=24;
					if(startX>=0) startX = 0;
				}
				repaint();
			break;
			case Canvas.RIGHT:
				if(!isWall((x+24)/24, y/24)){
					x+=24;
					startX-=24;
					if(x>=totalWidth) x = totalWidth;
					if(startX<=getWidth()-totalWidth)
						startX = getWidth()-totalWidth;
				}
				repaint();
			break;
			}
		}

		public void keyReleased(int keyCode){
		}

		public void keyRepeated(int keyCode){
		}

		public void commandAction(Command c, Displayable d){

			if(c == exitCmd){
				destroyApp(true);
				notifyDestroyed();
			}
		}

		private void getMapData() {

	    	InputStream is = null;
	    	try {
				is = getClass().getResourceAsStream("/map.dat");
			}
			catch(Exception ex){}
        	int symbol;
        	int x = 0, y = 0;
        	try {
            	while((symbol = is.read()) != -1){
                	switch(symbol){
                	case '\n':
                    	y++;
                    	x = 0;
                	break;
            		case '1':
                		mapData[y][x] = MY_SPRITE;
                		x++;
                	break;
                	case '2':
                    	mapData[y][x] = WALL;
                    	x++;
                	break;
                	case '3':
                    	mapData[y][x] = ENEMY;
                    	x++;
                	break;
                	default:
                		x++;
                	break;
                	}
            	}
            	is.close();
        	}
        	catch(Exception ex){}
		}

		boolean isWall(int x, int y){
			if(x >= XCellNum || y >=YCellNum) return true;
			if(x < 0 || y < 0) return true;
			if(mapData[y][x] == WALL) return true;
			else return false;
		}
	}

	class SplashCanvas extends Canvas{

		Display display;
		Displayable nextScreen;
		int holdTime;
		Timer splashTimer;
		Image image;

		public SplashCanvas(Display display, Displayable nextScreen){
			this.display = display;
			this.nextScreen = nextScreen;
			try{
				image = Image.createImage("/splash.png");
			}
			catch(Exception ex){}
			splashTimer = new Timer();
			display.setCurrent(this);
			holdTime = 6000;
		}

		public void paint(Graphics g){
			g.setColor(0xFFFFFF);
			g.fillRect(0, 0, getWidth(), getHeight());
			g.drawImage(image, 0, 0, Graphics.LEFT|Graphics.TOP);
			g.setColor(0);
			g.drawString("我的第一个游戏", getWidth()/2,
						 getHeight()/2, Graphics.HCENTER|Graphics.TOP);
			g.drawString("版本："+getAppProperty("MIDlet-Version"), getWidth()/2,
						 getHeight()-20, Graphics.HCENTER|Graphics.TOP);
		}

		public void showNotify(){
			splashTimer.schedule(new SplashTask(this), holdTime);
		}

		public void setHoldTime(int holdTime){
			this.holdTime = holdTime;
		}

		public void nextScreen(){
			display.setCurrent(nextScreen);
		}

	}

	class SplashTask extends TimerTask{

		SplashCanvas scanvas;

		public SplashTask(SplashCanvas scanvas){
			this.scanvas = scanvas;
		}

		public void run(){
			scanvas.nextScreen();
		}
	}
}