sheepdog.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.


// unnamed package

import javax.microedition.lcdui.*;
import javax.microedition.lcdui.game.*;


class Sheepdog
    extends Sprite
{
    static final int WIDTH = 15;
    static final int HEIGHT = 15;
    static final int VIBRATION_MILLIS = 200;

    private final SheepdogCanvas canvas;
    private boolean barking = false;
    private int[][][] animations = {{{0},                // stand up
                                     {1, 2, 3, 4}},      // run up
                                    {{5},                // stand left
                                     {6, 7, 8, 9}},      // run left
                                    {{10},               // stand down
                                     {11, 12, 13, 14}}}; // run down
    private int animationTick = 0;
    private static final int STAND = 0;
    private static final int RUN = 1;
    private int currentDirection = SheepdogCanvas.LEFT;

    Sheepdog(SheepdogCanvas canvas)
    {
        super(SheepdogMIDlet.createImage("/dog.png"), WIDTH, HEIGHT);
        defineCollisionRectangle(2, 2, WIDTH-4, WIDTH-4);
        defineReferencePixel(WIDTH/2, HEIGHT/2);

        this.canvas = canvas;
    }


    void tick(int direction, boolean bark)
    {
        animationTick++;

        Field field = canvas.getField();
        boolean moving = false;;
        switch (direction)
        {
        case SheepdogCanvas.UP:
            currentDirection = direction;
            if ((getY() > 0) &&
                !field.containsImpassableArea(getX(),
                                              getY() - 1,
                                              getWidth(),
                                              1) &&
                moveSuccessfully(0, -1))
            {
                moving = true;
            }
            else
            {
                canvas.vibrate(VIBRATION_MILLIS);
            }
            break;
        case SheepdogCanvas.LEFT:
            currentDirection = direction;
            if ((getX() > 0) &&
                !field.containsImpassableArea(getX() - 1,
                                              getY(),
                                              1,
                                              getHeight()) &&
                moveSuccessfully(-1, 0))
            {
                moving = true;
            }
            else
            {
                canvas.vibrate(VIBRATION_MILLIS);
            }
            break;
        case SheepdogCanvas.DOWN:
            currentDirection = direction;
            if ((getY() + getHeight() < field.getWidth()) &&
                !field.containsImpassableArea(getX(),
                                              getY() + getHeight(),
                                              getWidth(),
                                              1) &&
                moveSuccessfully(0, 1))
            {
                moving = true;
            }
            else
            {
                canvas.vibrate(VIBRATION_MILLIS);
            }
            break;
        case SheepdogCanvas.RIGHT:
            currentDirection = direction;
            if ((getX() + getWidth() < field.getWidth()) &&
                !field.containsImpassableArea(getX() + getWidth(),
                                              getY(),
                                              1,
                                              getHeight()) &&
                moveSuccessfully(1, 0))
            {
                moving = true;
            }
            else
            {
                canvas.vibrate(VIBRATION_MILLIS);
            }
            break;
        default:  // must be NONE
            break;
        }

        if (moving)
        {
            advanceRunningAnimation();
        }
        else
        {
            setStandingAnimation();
        }

        // implement a toggle, so bark only happens once per click
        // (will therefore not register very rapid multiple-clicks)
        if (bark)
        {
            if (!barking)
            {
                SoundEffects.getInstance().startDogSound();
                barking = true;
                canvas.handleDogBark();
            }
        }
        else
        {
            barking = false;
        }
    }


    private boolean moveSuccessfully(int dx, int dy)
    {
        move(dx, dy);
        if (canvas.overlapsSheep(this))
        {
            move(-dx, -dy);
            return false;
        }
        else
        {
            return true;
        }
    }


    private void advanceRunningAnimation()
    {
        int[] sequence;
        if (currentDirection == SheepdogCanvas.RIGHT)
        {
            sequence = animations[SheepdogCanvas.LEFT][RUN];
            setTransform(TRANS_MIRROR);
        }
        else
        {
            sequence = animations[currentDirection][RUN];
            setTransform(TRANS_NONE);
        }
        setFrame(sequence[(animationTick >> 1) % sequence.length]);
    }


    private void setStandingAnimation()
    {
        if (currentDirection == SheepdogCanvas.RIGHT)
        {
            setFrame(animations[SheepdogCanvas.LEFT][STAND][0]);
            setTransform(TRANS_MIRROR);
        }
        else
        {
            setFrame(animations[currentDirection][STAND][0]);
            setTransform(TRANS_NONE);
        }
    }
}