/* * @(#)PushPuzzleCanvas.java	1.5 04/05/20 * * Copyright (c) 1999-2004 Sun Microsystems, Inc. All rights reserved.  * PROPRIETARY/CONFIDENTIAL * Use is subject to license terms */package example.pushpuzzle;import java.io.*;import javax.microedition.lcdui.*;import javax.microedition.lcdui.game.*;import javax.microedition.midlet.*;import javax.microedition.media.*;import javax.microedition.media.control.ToneControl;/** * PushPuzzleCanvas displays the game board and handles key events. * The PushPuzzle game logic and algorithms are separated into Board.java. * PushPuzzleCanvas does not setup or use any Commands.  Commands for each * screen and listeners should be setup outside this class. * PushPuzzleCanvas generates a SELECT_COMMAND when the current level  * is solved. Sequencing through screens is done in the PushPuzzle MIDlet. * <p> * PushPuzzleCanvas handles the reading, initialization, and sequencing * of individual puzzle screens. * <p> * PushPuzzleCanvas uses the Score class to restore and save game levels * and scores for each level. To display the scores use getScoreScreen. * It will be initialized with the current scores. * To select a new level use the getLevelScreen and gotoLevel * methods. * <p> * PushPuzzleCanvas handled key events for LEFT, RIGHT, UP, and DOWN to * move the pusher in the game board.  Pointer pressed events * are used to move the pusher to the target location (if possible). * <p> */class PushPuzzleCanvas extends GameCanvas implements Runnable {    /** The current level */    private int level = 1;    /** The current theme index */    private int theme;    /** True if the level has been solved */    private boolean solved;    /** number of pixels per cell (updated by readscreen) */    private int cell = 1;	    /** The width of the canvas */    private int width;    /** The height of the canvas */    private int height;    /** The width of the board */    private int bwidth;    /** The height of the board */    private int bheight;    /** The board containing the location of each packet, ground, walls, etc */    private Board board;    /** The score object */    private Score score;    /** The main MIDlet */    private PushPuzzle pushpuzzle;    /** The Display of this MIDlet */    private Display display;    /** The listener used to report solved events */    private CommandListener listener;    /** The form for score display */    private Form scoreForm;	// form for scores    /** The TextBox to input new level numbers */     private TextBox levelText;	// for input of new level    /** Background color */    private static int groundColor = 0xff8080;    /** The index in the image of the Ground */    public final int TILE_GROUND = 1;    /** The index in the image of the Packet */    public final int TILE_PACKET = 2;    /** The index in the image of the Store */    public final int TILE_STORE = 3;    /** The index in the image of the Wall */    public final int TILE_WALL = 4;    /** The index in the image of the Pusher */    public final int TILE_PUSHER = 5;    /** Background image */    private Image themeImage;    /** Tiles forming the background */    private TiledLayer tiles;    /** The Sprite that is the pusher */    private Sprite sprite;    /** Layer manager */    private LayerManager layers;    /** Thread used for key handling and animation */    private Thread thread;    /** The target cell for runTo */    private int targetx;    /** The target cell for runTo */    private int targety;    /** Pan Rate; number of milliseconds between screen updates */    private static final int PanRate = 50;    /** The Tone player */    private Player tonePlayer;    /** The ToneController */    private ToneControl toneControl;    /** Tune to play when puzzle level is solved. */    private byte[] solvedTune = {	ToneControl.VERSION, 1,	74, 8,	// 1/8 note	75, 8,	73, 8    };    /** Tune to play when a packet enters a store */    private byte[] storedTune = {	ToneControl.VERSION, 1,	50, 8,	// 1/8 note	60, 8,	70, 8    };    /**     * Construct a new canvas     * @param pushpuzzle the main MIDlet     * @param s the score object     */    public PushPuzzleCanvas(PushPuzzle pushpuzzle, Score s) {	super(false);		// Don't suppress key events	this.pushpuzzle = pushpuzzle;	display = Display.getDisplay(pushpuzzle);	score = s;	board = new Board();	layers = new LayerManager();	setupTheme();	targetx = targety = -1;	height = getHeight();	width = getWidth();    }    /**     * Read the previous level number from the score file.     * Read in the level data.     */    public void init() {	// Read the last level; if it can't be found, revert to level 0	theme = score.getTheme();	setupTheme();	level = score.getLevel();	if (!readScreen(level)) {	    level = 0;	    readScreen(level);	}    }	    /**     * Cleanup and destroy.     */    public void destroy() {	hideNotify();    }    /**     * Figure out which set of icons to use based on the colors     */    private void initColors() {	boolean isColor = display.isColor();	int numColors = display.numColors();	if (isColor) {	} else {	    if (numColors > 2) {	    } else {	    }	}    }       /**     * Change themes.     * Cycle to the next index and try it     */    public void changeTheme() {	theme++;	setupTheme();	score.setLevel(level, theme); // save the level and theme	setupTiles();	updateSprite(0);    }    /**     * Undo the last move if possible. Redraw the cell     * the pusher occupies after the undone move and the cells     * in the direction of the original move.     * Here so undo can be triggered by a command.     */    public void undoMove() {	int pos = board.getPusherLocation();	int dir = board.undoMove();	if (dir >= 0) {	    updateTilesNear(pos, dir);	    updateSprite(dir);	}	solved = board.solved();    }    /**     * Restart the current level.     */    public void restartLevel() {	readScreen(level);	solved = false;    }    /**     * Start the next level.     * @param offset of the next level     * @return true if the new level was loaded     */    public boolean nextLevel(int offset) {	updateScores();	// save best scores 	if (level + offset >= 0 && readScreen(level+offset)) {	    level += offset;	    score.setLevel(level, theme);	    solved = false;	    return true;	}	return false;    }    /**     * Get the current level.     * @return the current level.     */    public int getLevel() {	return level;    }    /**     * Get a screen to let the user change the level.     * A simple numeric TextBox will do.     * @return the textbox used to change the level number     */    public Screen getLevelScreen() {	if (levelText == null) {	    levelText = new TextBox("Enter Level",				      Integer.toString(level), // default				      4, TextField.NUMERIC);	} else {	    levelText.setString(Integer.toString(level));	}	return levelText;    }    /**     * Go to the chosen Level.     * @return true if the new level was loaded.     */    public boolean gotoLevel() {	if (levelText != null) {	    String s = levelText.getString();	    int l;           try {               l = Integer.parseInt(s);           } catch (java.lang.NumberFormatException e) {               return false;           }	    updateScores();	    if (l >= 0 && readScreen(l)) {		level = l;		score.setLevel(level, theme);		solved = false;		return true;	    }	}	return false;    }    /**     * Read and setup the next level.     * Opens the resource file with the name "/Screen.<lev>"     * and tells the board to read from the stream.     * <STRONG>Must be called only with the board locked.</STRONG>     * @param lev the level number to read.     * @return true if the reading of the level worked, false otherwise.     */    private boolean readScreen(int lev) {	if (lev <= 0) {	    board.screen0();	// Initialize the default zero screen.	} else {	    InputStream is = null;	    try {		is = getClass().getResourceAsStream(					"/example/pushpuzzle/data/screen."					+ lev);		if (is != null) {		    board.read(is, lev);		    is.close();		} else {		    System.out.println(				   "Could not find the game board for level "				   + lev);		    return false;		}	    } catch (java.io.IOException ex) {		return false;	    }	}	bwidth = board.getWidth();	bheight = board.getHeight();	setupTiles();	updateSprite(0);	return true;    }    /**     * Create the Tiled layer to represent the current board.     */    private void setupTiles() {	if (tiles != null) {	    layers.remove(tiles);	}	// Figure out how many cells are needed to cover canvas.	int w = (width + cell - 1) / cell;	int h = (height + cell - 1) / cell;	tiles = new TiledLayer(w > bwidth ? w : bwidth,			       h > bheight ? h : bheight,			       themeImage, cell, cell);	/** Fill it all with background */	tiles.fillCells(0, 0, w, h, TILE_GROUND);	// Initialize the background tileset	for (int y = 0; y < bheight; y++) {	    for (int x = 0; x < bwidth; x++) {		updateTile(x, y);	    }	}		layers.append(tiles);    }    /**     * Update the tile at the location.     * @param x the offset of the tile to update     * @param y the offset of the tile to update     */    private void updateTile(int x, int y) {	int tile = 0;	byte v = board.get(x, y);	switch (v & ~Board.PUSHER) {	case Board.WALL:	    tile = TILE_WALL;	    break;	case Board.PACKET:	case Board.PACKET | Board.STORE:	    tile = TILE_PACKET;	    break;	case Board.STORE:	    tile = TILE_STORE;	    break;	case Board.GROUND:	default:	    tile = TILE_GROUND;	}	tiles.setCell(x, y, tile);    }    private static final int GroundColor0 = 0xffffff;    private static final int PacketColor0 = 0xff6d00;    private static final int StoreColor0 = 0xb60055;    private static final int WallColor0 = 0x006D55;    private static final int PusherColor0 = 0x6d6dff;    /**     * Setup Theme-0 generated to match screen     * size and board size.     */    private void setupTheme0() {	int bwidth = board.getWidth();