wormpit.java

j2me Games for example

/*
 *
 * Copyright (c) 2007, Sun Microsystems, Inc.
 *
 * All rights reserved.
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions
 * are met:
 *
 *  * Redistributions of source code must retain the above copyright
 *    notice, this list of conditions and the following disclaimer.
 *  * Redistributions in binary form must reproduce the above copyright
 *    notice, this list of conditions and the following disclaimer in the
 *    documentation and/or other materials provided with the distribution.
 *  * Neither the name of Sun Microsystems nor the names of its contributors
 *    may be used to endorse or promote products derived from this software
 *    without specific prior written permission.
 *
 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
 * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
 * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
 * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR
 * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
 * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
 * LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
 * NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
 * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 */
/*
 * WormPit.java
 *
 * Created on March 30, 2001, 16:15
 * @version
 */
package example.wormgame;

import java.io.ByteArrayInputStream;
import java.io.ByteArrayOutputStream;
import java.io.DataInputStream;
import java.io.DataOutputStream;
import java.io.IOException;

import java.lang.InterruptedException;
import java.lang.Runnable;
import java.lang.System;

import javax.microedition.lcdui.Canvas;
import javax.microedition.lcdui.Font;
import javax.microedition.lcdui.Graphics;
import javax.microedition.media.Manager;
import javax.microedition.media.MediaException;
import javax.microedition.media.Player;
import javax.microedition.media.control.ToneControl;
import javax.microedition.rms.RecordStore;
import javax.microedition.rms.RecordStoreException;


/**
 * The WormPit contains a Worm and some WormFood. The Worm will
 * slither around the pit in search of WormFood. If the Worm eats
 * it will grow in length. The Worm will be killed if it attempts
 * to slither past the edge of the pit or if it eats itself.
 */
public class WormPit extends Canvas implements Runnable {
    /** Current screen size in cells. */
    static int CellWidth;

    /** Current screen height in cells. */
    static int CellHeight;

    /** Initial offset for screen rendering. */
    private static final int START_POS = 3;

    /** Font height for rendering the score message. */
    private static final int SCORE_CHAR_HEIGHT;

    /** Font width for rendering the score message. */
    private static final int SCORE_CHAR_WIDTH;

    /** Height for two lines of score message text. */
    private static final int SCORE_HEIGHT;

    /** Default delay between worm repaints. (400 milliseconds) */
    private static final int DEFAULT_WAIT = 400;

    /** Maximum number of difficulty levels. (10) */
    static final byte MAX_LEVELS = 10;

    /** Color for target food object. (0x00ff00) */
    static final int FOOD_COLOUR = 0x0000ff00;

    /** Color for text objects. (0xff0000) */
    static final int TEXT_COLOUR = 0x00ff0000;

    /** Color for erasing worm cells. (0xffffff) */
    static final int ERASE_COLOUR = 0x00ffffff;

    /** Color for drawing worm cells. (0x000000) */
    static final int DRAW_COLOUR = 0x00000000;

    /** Size of a cell for worm rendering. */
    public static final int CELL_SIZE = 5;

    static {
        Font defaultFont = Font.getDefaultFont();
        SCORE_CHAR_WIDTH = defaultFont.charWidth('S');
        SCORE_CHAR_HEIGHT = defaultFont.getHeight();
        SCORE_HEIGHT = SCORE_CHAR_HEIGHT * 2;
    }

    /** Handle to target food. */
    private WormFood myFood;

    /** Handle to current worm object. */
    private Worm myWorm;

    /** Flag to indicate when the game is finished. */
    private boolean gameOver = false;

    /** Flag to indicate if current game is paused. */
    private boolean gamePaused = false;

    /** Flag to indicate game is restarted. */
    private boolean gameRestart = false;

    /** Flag to indicate forced repaint is needed. */
    private boolean forceRedraw = true;

    /** Flag to indicate the game is to be completely destroyed. */
    private boolean gameDestroyed = false;

    /** Current game score. */
    private int score = 0;

    /** Current game level. */
    private int level = 5;

    /** Number of pieces of food eaten since the last level change. */
    private int foodEaten = 0;

    /** Current screen width in pixels. */
    private int width;

    /** Current screen height in pixels. */
    private int height;

    /** Audio player for background tune. */
    private Player audioPlayer;

    /** Tone player. */
    private Player tonePlayer;

    /**
     * Default constructor for worm pit.
     * Initialized the food and worm objects.
     */
    public WormPit() {
        width = round(getWidth());
        height = round(getHeight() - SCORE_HEIGHT);
        WormPit.CellWidth = (width - (START_POS * 2)) / WormPit.CELL_SIZE;
        WormPit.CellHeight = (height - (START_POS * 2)) / WormPit.CELL_SIZE;
        myWorm = new Worm(this);

        /* Generate food for worm to eat */
        myFood = new WormFood(this);

        int x = myFood.getX();
        int y = myFood.getY();

        while (myWorm.contains(x, y)) {
            myFood.regenerate(); // regenerate if food placed under worm
            x = myFood.getX();
            y = myFood.getY();
        }
    }

    /**
     * Round the given value to next lowest number divisible by the
     * cell size.
     * @param val number to be rounded down
     * @return rounded down value
     */
    private int round(int val) {
        int delta = (val - (START_POS * 2)) % CELL_SIZE;

        return (val - delta);
    }

    /**
     * Set the difficulty level. If the new level is different from the
     * current level, any game currently in progress is terminated and
     * the score is lost.
     * @param level value of new level requested
     * @see #getLevel
     */
    public void setLevel(int level) {
        if (this.level != level) {
            this.level = level;
            gameOver = true;
            gamePaused = false;
            foodEaten = 0;
            score = 0;
        }
    }

    /**
     * Get the difficulty level.
     * @return current game level
     * @see #setLevel
     */
    public int getLevel() {
        return level;
    }

    /**
     * Get the score of this game.
     * @return current score
     */
    public int getScore() {
        return score;
    }

    /**
     * Returns true if the given point is within the bounds of the
     * worm pit.
     * @param x x coordinate of point to check (0 - CellWidth)
     * @param y y coordinate of point to check (0 - CellHeight)
     * @return true, if coordinate is in the worm pit
     */
    static boolean isInBounds(int x, int y) {
        if ((x < 0) || (x >= WormPit.CellWidth)) {
            return false;
        }

        if ((y < 0) || (y >= WormPit.CellHeight)) {
            return false;
        }

        return true;
    }

    /**
     * Restart the game.
     */
    void restart() {
        if (gamePaused) {
            gamePaused = false;
        } else {
            myWorm.regenerate();
            myFood.regenerate();

            int x = myFood.getX();
            int y = myFood.getY();

            while (myWorm.contains(x, y)) {
                myFood.regenerate(); // regenerate if food placed under worm
                x = myFood.getX();
                y = myFood.getY();
            }

            foodEaten = 0;
            score = 0;
            gameOver = false;

            if ((audioPlayer != null) && (audioPlayer.getState() == Player.PREFETCHED)) {
                try {
                    audioPlayer.setMediaTime(0);
                    audioPlayer.start();
                } catch (MediaException me) {
                }
            }
        }

        forceRedraw = true;

        synchronized (myWorm) {
            myWorm.notifyAll();
        }
    }

    /**
     * Handle keyboard input. This is used for worm movement.
     * @param keyCode pressed key is either Canvas arrow key (UP,
     *  DOWN, LEFT, RIGHT) or simulated with KEY_NUM (2, 8, 4,6).
     */
    public void keyPressed(int keyCode) {
        switch (getGameAction(keyCode)) {
        case Canvas.UP:
            myWorm.setDirection(Worm.UP);

            break;

        case Canvas.DOWN:
            myWorm.setDirection(Worm.DOWN);

            break;

        case Canvas.LEFT:
            myWorm.setDirection(Worm.LEFT);

            break;

        case Canvas.RIGHT:
            myWorm.setDirection(Worm.RIGHT);

            break;

        case 0:

            // There is no game action.. Use keypad constants instead
            switch (keyCode) {
            case Canvas.KEY_NUM2:
                myWorm.setDirection(Worm.UP);

                break;