base.java

J2ME MIDP_Example_Applications

// Copyright 2003 Nokia Corporation.
//
// THIS SOURCE CODE IS PROVIDED 'AS IS', WITH NO WARRANTIES WHATSOEVER,
// EXPRESS OR IMPLIED, INCLUDING ANY WARRANTY OF MERCHANTABILITY, FITNESS
// FOR ANY PARTICULAR PURPOSE, OR ARISING FROM A COURSE OF DEALING, USAGE
// OR TRADE PRACTICE, RELATING TO THE SOURCE CODE OR ANY WARRANTY OTHERWISE
// ARISING OUT OF ANY PROPOSAL, SPECIFICATION, OR SAMPLE AND WITH NO
// OBLIGATION OF NOKIA TO PROVIDE THE LICENSEE WITH ANY MAINTENANCE OR
// SUPPORT. FURTHERMORE, NOKIA MAKES NO WARRANTY THAT EXERCISE OF THE
// RIGHTS GRANTED HEREUNDER DOES NOT INFRINGE OR MAY NOT CAUSE INFRINGEMENT
// OF ANY PATENT OR OTHER INTELLECTUAL PROPERTY RIGHTS OWNED OR CONTROLLED
// BY THIRD PARTIES
//
// Furthermore, information provided in this source code is preliminary,
// and may be changed substantially prior to final release. Nokia Corporation
// retains the right to make changes to this source code at
// any time, without notice. This source code is provided for informational
// purposes only.
//
// Nokia and Nokia Connecting People are registered trademarks of Nokia
// Corporation.
// Java and all Java-based marks are trademarks or registered trademarks of
// Sun Microsystems, Inc.
// Other product and company names mentioned herein may be trademarks or
// trade names of their respective owners.
//
// A non-exclusive, non-transferable, worldwide, limited license is hereby
// granted to the Licensee to download, print, reproduce and modify the
// source code. The licensee has the right to market, sell, distribute and
// make available the source code in original or modified form only when
// incorporated into the programs developed by the Licensee. No other
// license, express or implied, by estoppel or otherwise, to any other
// intellectual property rights is granted herein.


import javax.microedition.lcdui.*;


// The player uses the base (or ship) to fly up, down, left and right.
// It can fire bullets at blocks. Base is also used to draw itself.

class Base
{
    final static int COLOR = 0xFFFF00; // YELLOW
    final static int MAX_CANNON_COOLDOWN_TICKS =
        (12000 / GameManager.MILLIS_PER_TICK); // 12 seconds
    final static int MAX_CANNON_HEAT = 2;
    final static int MAX_CANNON_FIRE_RATE = 2; // 2 bullets per second

    private final GameManager gameManager;
    private final int xMin;
    private final int yMin;
    private final int xMax;
    private final int yMax;
    private final int dx;
    private final int dy;
    private final int dCannon;
    private final boolean useLimitedFiringRate;

    private int x;
    private int y;
    private int w;
    private int h;
    private int xCannon;
    private int yCannon;
    private int collideTicks = 0;
    private int lives;
    private boolean gameActionLeft = false;
    private boolean gameActionRight = false;
    private boolean gameActionUp = false;
    private boolean gameActionDown = false;
    private boolean gameActionFire = false;

    private int clockTickMillis = 0;
    private int clockTickSeconds = 0;
    private int cannonHeat = 0;
    private int cannonCoolDownTicks = 0;
    private int cannonFireCount = 0; // bullets
    private int cannonFireRate = 0;  // bullets/sec


    Base(GameManager gameManager, boolean useLimitedFiringRate,
         int lives, int xMin, int yMin, int xMax, int yMax)
    {
        this.gameManager = gameManager;
        this.lives = lives;
        this.xMin = xMin;
        this.yMin = yMin;
        this.xMax = xMax;
        this.yMax = yMax;
        this.useLimitedFiringRate = useLimitedFiringRate;

        // In general, the height and width of the base only need to depend
        // on the game screen's size (xMin, xMax, yMin, yMax).
        // I've chosen to make the base about the same size as the blocks,
        // which is why the Block size dimensions are used below.

        h = (9 * Block.getDimension()) / 10; // base height is 90% of block's
        if (h > (yMax / 8))
        {
            h = yMax / 8;
        }
        w = h / 2;
        y = (yMax - h) / 2;
        x = xMin;
        dCannon = h / 3;
        xCannon = w;
        yCannon = y + ((h - dCannon) / 2);
        dy = h / 2;
        dx = w;
    }


    public void tick()
    {
        if (collideTicks > 0)
        {
            collideTicks--;
        }

        if (cannonCoolDownTicks > 0)
        {
            cannonCoolDownTicks--;
        }

        if (gameActionUp)
        {
            // move up

            if ((y - dy) >= yMin)
            {
                y -= dy;
            }
            else if ((y - (dy / 4)) >= yMin)
            {
                // use a smaller step near a boundary
                y -= (dy / 4);
            }
        }
        else if (gameActionDown)
        {
            // move down

            if ((y + dy) <= (yMax - h))
            {
                y += dy;
            }
            else if ((y + (dy / 4)) <= (yMin - h))
            {
                // use a smaller step near a boundary
                y += (dy / 4);
            }
        }
        if (gameActionLeft)
        {
            // move left

            if ((x - dx) >= xMin)
            {
                x -= dx;
            }
        }
        if (gameActionRight)
        {
            // move right

            if ((x + dx) <= (xMax - w - dCannon))
            {
                x += dx;
            }
        }

        yCannon = y + ((h - dCannon) / 2);
        xCannon = x + w;

        // ticking of virtual millisecond clock
        clockTickMillis++;

        int millis = (clockTickMillis * GameManager.MILLIS_PER_TICK);
        int seconds = millis / 1000;
        boolean isNewSecondTick = false;

        if (seconds > clockTickSeconds)
        {
            clockTickSeconds = seconds;
            cannonFireRate = cannonFireCount / seconds;
            isNewSecondTick = true;
        }

        if (gameActionFire)
        {
            if (!useLimitedFiringRate)
            {
                // There are no limits on firing the cannon. We may fire it.

                int d = dCannon; // Bullet is d x d pixels
                Bullet b = new Bullet(xCannon, xMax, yCannon, d, d, (2 * d));

                gameManager.addBullet(b);
            }
            else
            {
                if (cannonCoolDownTicks == 0)
                {
                    // compute the cannon's firing rate and heat every second
                    if (isNewSecondTick)
                    {

                        if (cannonFireRate >= MAX_CANNON_FIRE_RATE)
                        {
                            cannonHeat++;
                        }
                        else
                        {
                            if (cannonHeat > 0)
                            {
                                cannonHeat--;
                            }
                        }
                    }

                    if (cannonHeat > MAX_CANNON_HEAT)
                    {
                        // The cannon is overheating due to excessive
                        // continuous firing, and will be cooled down
                        // by setting cannonCoolDownTicks. It is not fired.

                        cannonCoolDownTicks = MAX_CANNON_COOLDOWN_TICKS;
                        cannonFireCount = 0;
                        cannonHeat = 0;
                        clockTickMillis = 0;
                        clockTickSeconds = 0;
                    }
                    else
                    {
                        // We may fire the cannon.

                        int d = dCannon; // Bullet is d x d pixels
                        Bullet b = new Bullet(xCannon, xMax, yCannon,
                                              d, d, (2 * d));

                        gameManager.addBullet(b);
                        cannonFireCount++;
                    }
                }
                else
                {
                    // The cannon is cooling down, and can not be fired
                    // until it has cooled down.

                    if (isNewSecondTick)
                    {
                        reduceCannonHeat();
                    }
                }
            }
        }
        else
        {
            // The player is not pressing the game fire action,
            // we can cool down the cannon if needed.

            if (useLimitedFiringRate && isNewSecondTick && (cannonHeat > 0))
            {
                reduceCannonHeat();
            }
        }
    }


    private void reduceCannonHeat()
    {
        if (cannonHeat > 0)
        {
            cannonHeat--;
        }

        if (cannonHeat == 0)
        {
            cannonFireCount = 0;
            cannonFireRate = 0;
            clockTickMillis = 0;
            clockTickSeconds = 0;
        }
    }


    int getCannonHeat()
    {
        return cannonHeat;
    }


    int getCannonCoolDownTicks()
    {
        return cannonCoolDownTicks;
    }


    void gameActionPressed(int action, boolean isPressed)
    {
        switch (action)
        {
            case Canvas.UP:
                gameActionUp = isPressed;
                break;
            case Canvas.DOWN:
                gameActionDown = isPressed;
                break;
            case Canvas.LEFT:
                gameActionLeft = isPressed;
                break;
            case Canvas.RIGHT:
                gameActionRight = isPressed;
                break;
            case Canvas.FIRE:
                gameActionFire = isPressed;
                break;
        }
    }


    void draw(Graphics g)
    {
        g.setColor(COLOR);

        // draw the body of the base
        if (collideTicks > 0)
        {
            // 'Just collided'

            // during the 'isColliding' state, we draw base's body
            // as 'flashing' to indicate this state to the player
            if ((collideTicks % 2) == 0)
            {
                // even tick: un-filled rectangle
                g.drawRect(x, y, (w - 1), (h - 1));
            }
            else
            {
                // odd tick: filled rectangle
                g.fillRect(x, y, w, h);
            }
        }
        else
        {
            // 'Not colliding'

            // use a filled rectangle with the default base color
            g.fillRect(x, y, w, h);
        }

        // draw the cannon of the base
        if (cannonCoolDownTicks > 0)
        {
            g.drawRect(xCannon, yCannon, dCannon - 1, dCannon - 1);
        }
        else
        {
            g.fillRect(xCannon, yCannon, dCannon, dCannon);
        }
    }


    int getX()
    {
        return x;
    }


    int getY()
    {
        return y;
    }


    int getWidth()
    {
        return w;
    }


    int getCannonDimension()
    {
        return dCannon;
    }


    int getHeight()
    {
        return h;
    }


    int getLives()
    {
        if (lives < 0)
        {
            lives = 0;
        }

        return lives;
    }


    void doCollision()
    {
        lives--;

        // For two seconds, the base is in a state of 'isColliding'.
        // This is indicated by collideTicks > 0. collideTicks is decremented
        // by method tick. During this state, new block collisions do not
        // affect the base.
        //
        // This was done so that if the base is hit simultaneously by two
        // blocks, that its life count is only decremented by one rather
        // than by two.
        //
        // The base's draw method draws a 'flashing base' during the
        // 'isColliding' state.
        collideTicks = (2000 / GameManager.MILLIS_PER_TICK);
    }


    boolean isColliding()
    {
        return collideTicks > 0;
    }
}