gamemain.java

钻头小子

import javax.microedition.lcdui.Graphics;
import javax.microedition.lcdui.Image;
import java.util.Random;

import com.nokia.mid.ui.FullCanvas;

public final class GameMain extends FullCanvas implements Runnable
{
	private final byte STATE_NONE = -1;
	private final byte STATE_LOGO = 0;
	private final byte STATE_MENU = 1;
	private final byte STATE_LOAD = 2;
	private final byte STATE_INIT = 3;
	private final byte STATE_RUN  = 4;
	
	private final int WIDTH  			= 128;
	private final int HEIGHT 			= 128;
	private final byte MAP_WIDTH  		= 10;
	private final byte MAP_HEIGHT 		= 75;
	private final byte SCREEN_HEIGHT  	= 16;
	
	private final byte STARTING_MAKEBREAK 	= 2;
	private final byte STARTING_LIVES 		= 3;
	private final byte MAKEBREAK_DIST 		= 7;
	private final byte NUM_BRICKS 			= 5;
	
	private final byte DIR_UP 		= 0;
  	private final byte DIR_RIGHT	= 1;
  	private final byte DIR_DOWN		= 2;
  	private final byte DIR_LEFT		= 3;
  	
	private Image[] imgBrick = new Image[NUM_BRICKS];
	private Image[] imgZombie = new Image[4];
	private Image[] imgPlayer = new Image[2];
	private Image[] imgMakeBreak = new Image[4];
	private Image imgTitle;
	private Image imgNumbers;
	private boolean[][] map = new boolean[MAP_HEIGHT][MAP_WIDTH];
	private int[] emptySlot = new int[MAP_WIDTH];
	private boolean done;
	private boolean paused;
	private int do_die;
	private int level;
	private int makebreak;
	private int lives;
	private int map_position;
	private int counter;
	private int playerImageindex;
	private int pl_x;
	private int pl_y;
	private int old_pl_x;
	private int old_pl_y;
	private int zombie_x;
	private int zombie_y;
	private int old_zombie_x;
	private int old_zombie_y;
	private boolean zombie_alive;
	private int zombie_dir;
	private int zombie_fadein;
	private boolean zombie_mad;
	private boolean zombie_bump;
	private int potion_x;
	private int potion_y;
	private boolean potion_alive;
	private int potion_xm;
	
	private int keyPressed;
	private int lastKeyPressed;
	private GameMIDlet gameMIDlet;
	private Random rand;
	private int state;
	private int lastState;
	private boolean running = true;
	
	public GameMain(GameMIDlet gm)
	{
		gameMIDlet = gm;
		rand = new Random(System.currentTimeMillis());
		changeState(STATE_MENU);
		new Thread(this).start();
	}
	
	public void paint(Graphics g)
	{
		switch (state)
		{
			case STATE_RUN:
				g.translate(4, 0);
				draw(g);
				g.translate(-4, 0);
				break;
			case STATE_LOGO:
				break;
			case STATE_MENU:
				title(g);
				break;
			case STATE_LOAD:
				break;
			case STATE_INIT:
				break;
		}
	}
	
	public void run()
	{
		long start = 0;
		long end = 0;
		while(running)
		{
			start = System.currentTimeMillis();
			switch (state)
			{
				case STATE_RUN:
					game();
					break;
				case STATE_MENU:
					break;
				case STATE_LOAD:
					break;
			}
			repaint();
			serviceRepaints();
			end = 50 - (System.currentTimeMillis() - start);
			if (end > 0)
			{
				try
				{
					Thread.sleep(end);
				} catch (Exception e){}
			}
		}
	}
	
	public void keyPressed(int keyCode)
	{
		switch (state)
		{
			case STATE_RUN:
				if (paused)
				{
					if (keyCode == FullCanvas.KEY_SOFTKEY1)
					{
						paused = false;
					}
				}
				else
				{
					playerImageindex = (playerImageindex + 1) % 2;
					keyPressed = keyCode;
				}
				break;
			case STATE_MENU:
				if (keyCode == FullCanvas.KEY_SOFTKEY1)
				{
					changeState(STATE_RUN);
				}
				else if (keyCode == FullCanvas.KEY_SOFTKEY2)
				{
					running = false;
					gameMIDlet.quitApp();
				}
				break;
			case STATE_LOAD:
				break;
		}
	}
	
	public void keyReleased(int keyCode)
	{
		keyPressed = 0;
	}
	
	private int rand(int scale)
	{
		return Math.abs(rand.nextInt()) % scale;
	}
	
	public void hideNotify()
	{
		if (state >= 0)
		{
			lastState = state;
			state = STATE_NONE;
		}
	}
	
	public void showNotify()
	{
		if (state < 0)
		{
			state = lastState;
		}
	}
	
	private void changeState(byte s)
	{
		state = STATE_NONE;
		switch (s)
		{
			case STATE_RUN:
				imgTitle = null;
				loadImage();
				level = 1;
  				resetLevel();
    			makebreak = STARTING_MAKEBREAK;
    			lives = STARTING_LIVES;
    			keyPressed = 0;
  				keyPressed = 0;
  				done = false;
  				do_die = 0;
				break;
			case STATE_LOGO:
				break;
			case STATE_MENU:
				releaseImage();
				try{
					imgTitle = Image.createImage("/img/title.png");
				}catch(Exception e){}
				break;
			case STATE_LOAD:
				break;
			case STATE_INIT:
				break;
		}
  		state = s;
  		System.gc();
	}
	
	private void resetLevel()
	{
	  	boolean[] mask = new boolean[MAP_WIDTH - 2];
	  	for (int y = 0; y < MAP_HEIGHT; y++)
	    {
	      	map[y][0] = true;
	      	map[y][1] = true;
	
	      	for (int x = 2; x < MAP_WIDTH; x++)
			{
		  		map[y][x] = false;
			}
	    }
	
	  	/* Start with a random on-off pattern: */
	  	mask[0] = (rand(2) == 0) ? false : true;
	  	for (int x = 3; x < MAP_WIDTH; x++)
	  	{
	    	mask[x - 2] = !mask[x - 3];
	  	}
	
	  	for (int y = SCREEN_HEIGHT; y < MAP_HEIGHT; y++)
	    {
	      	toggle(mask);
			System.arraycopy(mask, 0, map[y], 2, mask.length);
	    }
	  
	  	/* Set scroll position: */
	  
	  	map_position = 0;
	 	resetSprites();
	}
	
	private void resetSprites()
	{
	  	/* Set player positions: */
	  
	  	pl_x = 15;
	    pl_y = (SCREEN_HEIGHT / 2) * 6;
	
	
	  	/* Disable zombies: */
	
	  	zombie_alive = false;
	  	zombie_x = 0;
	  	zombie_y = 0;
	
	
	  	/* Disable potion: */
	
	  	potion_alive = false;
	  	potion_x = 0;
	  	potion_y = 0;
	}
	
	private void toggle(boolean[] mask)
	{
  		for (int i = 0; i < MAP_WIDTH - 2; i++)
  		{
    		if (rand(10) < 3)
    		{
      			mask[i] = !mask[i];
      		}
  		}
	}
	
	private void title(Graphics g)
	{
		g.setClip(0, 0, WIDTH, HEIGHT);
		g.drawImage(imgTitle, 0, 0, 20);
	}

	private void game()
	{
		if (do_die > 0)
		{
			do_die--;
			if (do_die == 0)
			{
				if (done)
				{
					changeState(STATE_MENU);
					return;
				}
				resetLevel();
				/* Clear part of the map: */
				for (int y = (map_position / 6);
		     		y <= (map_position / 6) + SCREEN_HEIGHT;
		     		y++)
				{
		  			for (int x = 2; x < MAP_WIDTH; x++)
		  			{
		    			map[y][x] = false;
		  			}
				}
			}
			return;
		}
		if (done || paused)
		{
			return;
		}
		
		old_pl_x = pl_x;
      	old_pl_y = pl_y;
		switch (keyPressed)
		{
			case FullCanvas.KEY_UP_ARROW:
			case FullCanvas.KEY_NUM2:
				pl_y -= 2;
				lastKeyPressed = keyPressed;
				break;
			case FullCanvas.KEY_LEFT_ARROW:
			case FullCanvas.KEY_NUM4:
				pl_x -= 3;
				lastKeyPressed = keyPressed;
				break;          
			case FullCanvas.KEY_NUM5:
		  		/* Handle make-or-break: */
				keyPressed = 0;
		  		if (makebreak <= 0)
		  		{
		  			break;
		  		}
	    		int y = pl_y;
	    		int x = pl_x;
	        	switch (lastKeyPressed)
	        	{
					case FullCanvas.KEY_UP_ARROW:
	        		case FullCanvas.KEY_NUM2:
	          			y -= MAKEBREAK_DIST;
	          			break;
					case FullCanvas.KEY_LEFT_ARROW:
	          		case FullCanvas.KEY_NUM4:
	          			x -= MAKEBREAK_DIST;
	          			break;
					case FullCanvas.KEY_RIGHT_ARROW:
	          		case FullCanvas.KEY_NUM6:
	          			x += MAKEBREAK_DIST;
	          			break;
					case FullCanvas.KEY_DOWN_ARROW:
	          		case FullCanvas.KEY_NUM8:
	          			y += MAKEBREAK_DIST;
	          			break;
	          	}
	   
	    		x = mirror_x(x);
	    		x = (x + 2) / 6;
	    		y = (y + 2) / 6;

	    		if (x >= MAP_WIDTH)
	    		{
	      			x = MAP_WIDTH - 1;
	 			}

	    		if (x > 1)
	   	 		{
	      			map[y][x] = !map[y][x];
	      			makebreak--;
	    		}
				break;        
			case FullCanvas.KEY_RIGHT_ARROW:  
			case FullCanvas.KEY_NUM6:
				pl_x += 3;
				lastKeyPressed = keyPressed;
				break;          
			case FullCanvas.KEY_DOWN_ARROW:
			case FullCanvas.KEY_NUM8:
				pl_y += 2;
				lastKeyPressed = keyPressed;
				break;         
			case FullCanvas.KEY_SOFTKEY1:
				paused = true;
				break;          
			case FullCanvas.KEY_SOFTKEY2:
				changeState(STATE_MENU);
				break;
		}
		
      	/* Keep players from going below the screen: */
		int y = map_position + SCREEN_HEIGHT * 6 - 5;
	  	if (pl_y > y)
	    {
	      	pl_y = y;
	    }

      	/* Bump into things: */
	  	int x = mirror_x(pl_x);