/*

* Copyright (c) 2009 Nokia Corporation and/or its subsidiary(-ies).

* All rights reserved.

* This component and the accompanying materials are made available

* under the terms of "Eclipse Public License v1.0"

* which accompanies this distribution, and is available

* at the URL "http://www.eclipse.org/legal/epl-v10.html".

*

* Initial Contributors:

* Nokia Corporation - initial contribution.

*

* Contributors:

*

* Description:

*

*/

package javax.microedition.lcdui.game;

import javax.microedition.lcdui.Graphics;

import javax.microedition.lcdui.Image;

/**

 * LCDUI Sprite class.

 */

public class Sprite extends Layer

{

    /**

     * Transform constant.

     */

    public static final int TRANS_NONE = 0;

    /**

     * Transform constant.

     */

    public static final int TRANS_MIRROR_ROT180 = 1;

    /**

     * Transform constant.

     */

    public static final int TRANS_MIRROR = 2;

    /**

     * Transform constant.

     */

    public static final int TRANS_ROT180 = 3;

    /**

     * Transform constant.

     */

    public static final int TRANS_MIRROR_ROT270 = 4;

    /**

     * Transform constant.

     */

    public static final int TRANS_ROT90 = 5;

    /**

     * Transform constant.

     */

    public static final int TRANS_ROT270 = 6;

    /**

     * Transform constant.

     */

    public static final int TRANS_MIRROR_ROT90 = 7;

    private static final int TRANSFORM_REFLECT_V = 0x01;

    private static final int TRANSFORM_REFLECT_H = 0x02;

    private static final int TRANSFORM_TRANSPOSE = 0x04;

    private static final int TRANSFORM_MASK = 0x07;

    private int   frameIndex;

    private int   frameCount;

    private int[] frameArray;

    // Transformation bitmask.

    private int transform;

    // Untransformed reference pixel coordinates.

    private int referenceX;

    private int referenceY;

    // Transformed reference pixel coordinates.

    private int transReferenceX;

    private int transReferenceY;

    // Untransformed collision rectangle frame coordinates.

    private int collisionX;

    private int collisionY;

    private int collisionWidth;

    private int collisionHeight;

    // Transformed collision rectangle frame coordinates.

    private int[][] transCollision;

    // If set transformed collision rectangle has been calculated.

    private static final int TRANSFORM_COLLISION = 0x20;

    /**

     * Constructor.

     *

     * @param image Image.

     * @param frameWidth Frame's width.

     * @param frameHeight Frame's height.

     */

    public Sprite(Image image, int frameWidth, int frameHeight)

    {

        super(image, frameWidth, frameHeight);

        this.collisionWidth = frameWidth;

        this.collisionHeight = frameHeight;

        frameCount = tileCount;

    }

    /**

     * Constructor.

     *

     * @param image Image.

     */

    public Sprite(Image image)

    {

        this(image, image.getWidth(), image.getHeight());

    }

    /**

     * Constructor.

     *

     * @param from source Sprite

     */

    public Sprite(Sprite from)

    {

        super(from);

        this.frameIndex = from.frameIndex;

        this.frameCount = from.frameCount;

        this.frameArray = from.frameArray; // shallow copy

        this.referenceX = from.referenceX;

        this.referenceY = from.referenceY;

        this.transform = from.transform;

        this.transReferenceX = from.transReferenceX;

        this.transReferenceY = from.transReferenceY;

        this.collisionX = from.collisionX;

        this.collisionY = from.collisionY;

        this.collisionWidth = from.collisionWidth;

        this.collisionHeight = from.collisionHeight;

    }

    /**

     * Set image.

     *

     * @param image Image to be used.

     * @param frameWidth Frame's width.

     * @param frameHeight Frame's height.

     */

    public void setImage(Image image, int frameWidth, int frameHeight)

    {

        int oldTileCound = tileCount;

        int oldTileWidth = tileWidth;

        int oldTileHeight = tileHeight;

        setTileImage(image, frameWidth, frameHeight);

        this.transform &= TRANSFORM_MASK;

        if(tileCount < oldTileCound)

        {

            frameIndex = 0;

            frameArray = null;

        }

        if(frameArray == null)

        {

            frameCount = tileCount;

        }

        // If image's dimension has changed:

        if((tileWidth != oldTileWidth) || (tileHeight != oldTileHeight))

        {

            updateTransRefPixel(true);

            defineCollisionRectangle(0, 0, tileWidth, tileHeight);

        }

    }

    /**

     * Sets transform.

     *

     * @param transform Transform mask.

     */

    public void setTransform(int transform)

    {

        if((this.transform & TRANSFORM_MASK) != transform)

        {

            // flags have changed

            switch(transform)

            {

            case TRANS_NONE:

            case TRANS_ROT90:

            case TRANS_ROT180:

            case TRANS_ROT270:

            case TRANS_MIRROR:

            case TRANS_MIRROR_ROT90:

            case TRANS_MIRROR_ROT180:

            case TRANS_MIRROR_ROT270:

                // Ok

                break;

            default:

                throw new IllegalArgumentException(

                    MsgRepository.SPRITE_EXCEPTION_INVALID_TRANSFORM);

            }

            this.transform = transform;

            updateTransRefPixel(true);

        }

    }

    /**

     * Sets frame.

     *

     * @param frameIndex Index.

     */

    public void setFrame(int frameIndex)

    {

        if(frameIndex < 0 || frameIndex >= frameCount)

        {

            throw new IndexOutOfBoundsException(

                MsgRepository.SPRITE_EXCEPTION_INVALID_FRAME_INDEX);

        }

        this.frameIndex = frameIndex;

    }

    /**

     * Gets current frame.

     *

     * @return Index of current frame.

     */

    public int getFrame()

    {

        return frameIndex;

    }

    /**

     * Switches to the next frame.

     */

    public void nextFrame()

    {

        frameIndex = (frameIndex + frameCount + 1) % frameCount;

    }

    /**

     * Switches to the previous frame.

     */

    public void prevFrame()

    {

        frameIndex = (frameIndex + frameCount - 1) % frameCount;

    }

    /**

     * Gets frame sequence length.

     *

     * @return Length of frame sequence.

     */

    public int getFrameSequenceLength()

    {

        return frameCount;

    }

    /**

     * Gets the number of raw frames in Sprite.

     *

     * @return Number of raw frames.

     */

    public int getRawFrameCount()

    {

        return tileCount;

    }

    /**

     * Sets the sequence of frames.

     *

     * @param frameArray Array of frame indexes.

     */

    public void setFrameSequence(int[] frameArray)

    {

        int[] tempArray;

        int tempCount;

        if(frameArray == null)

        {

            // no sequence

            tempCount = tileCount;

            tempArray = null;

        }

        else

        {

            tempCount = frameArray.length;

            if(tempCount == 0)

            {

                throw new IllegalArgumentException(

                    MsgRepository.SPRITE_EXCEPTION_INVALID_SEQUENCE_LENGTH);

            }

            tempArray = new int[tempCount];

            // check and copy the sequence

            for(int i = 0; i < tempCount; i++)

            {

                if(frameArray[i] < 0 || frameArray[i] >= tileCount)

                {

                    throw new ArrayIndexOutOfBoundsException(

                        MsgRepository.SPRITE_EXCEPTION_INVALID_FRAME + i);

                }

                tempArray[i] = frameArray[i];

            }

        }

        this.frameArray = tempArray;

        this.frameCount = tempCount;

        this.frameIndex = 0;

    }

    /**

     * Defines reference pixel.

     *

     * @param x X coordinate of reference pixel.

     * @param y Y coordinate of reference pixel.

     */

    public void defineReferencePixel(int x, int y)

    {

        referenceX = x;

        referenceY = y;

        updateTransRefPixel(false);

    }

    /**

     * Gets reference pixel's x-coordinate.

     *

     * @return X coordinate.

     */

    public int getRefPixelX()

    {

        return getX() + transReferenceX;

    }

    /**

     * Gets reference pixel's y-coordinate.

     *

     * @return Y coordinate.

     */

    public int getRefPixelY()

    {

        return getY() + transReferenceY;

    }

    /**

     * Sets reference pixels position.

     *

     * @param x X-coordinate.

     * @param y Y-coordinate.

     */

    public void setRefPixelPosition(int x, int y)

    {

        setPosition(x - transReferenceX, y - transReferenceY);

    }

    /**

     * Defines collision rectangle.

     *

     * @param x X.

     * @param y Y.

     * @param width Width of the rectangle.

     * @param height Height of the rectangle.

     */

    public void defineCollisionRectangle(int x, int y, int width, int height)

    {

        if(width < 0 || height < 0)

        {

            throw new IllegalArgumentException(

                MsgRepository.SPRITE_EXCEPTION_INVALID_WIDTH_HEIGHT);

        }

        collisionX = x;

        collisionY = y;

        collisionWidth = width;

        collisionHeight = height;

        transform &= ~TRANSFORM_COLLISION;

    }

    /**

     * Updates Transform reference pixel.

     *

     * @param moveLayer if the layer movement is needed based on transRef pixel change

     */

    private void updateTransRefPixel(boolean moveLayer)

    {

        int tempX = referenceX;

        int tempY = referenceY;

        if((transform & TRANSFORM_REFLECT_V) != 0)

        {

            tempY = tileHeight - 1 - tempY;

        }

        if((transform & TRANSFORM_REFLECT_H) != 0)

        {

            tempX = tileWidth - 1 - tempX;

        }

        if((transform & TRANSFORM_TRANSPOSE) != 0)

        {

            // xor swap

            tempX ^= tempY;

            tempY ^= tempX;

            tempX ^= tempY;

        }

        if(moveLayer)

        {

            move(transReferenceX - tempX, transReferenceY - tempY);

        }

        transReferenceX = tempX;

        transReferenceY = tempY;

    }

    int getLayerHeight()

    {

        if((transform & TRANSFORM_TRANSPOSE) == 0)

        {

            return tileHeight;

        }

        else

        {

            return tileWidth;

        }

    }

    int getLayerWidth()

    {

        if((transform & TRANSFORM_TRANSPOSE) == 0)

        {

            return tileWidth;

        }

        else

        {

            return tileHeight;

        }

    }

    int getTileIndex()

    {

        if(this.frameArray != null)

        {

            return frameArray[frameIndex];

        }

        return frameIndex;

    }

    /**

     * Paints sprite.

     *

     * @param graphics Graphics.

     */

    public final void paint(Graphics graphics)

    {

        if(visible)

        {

            int index = getTileIndex();

            int row = index / tileColumns;

            int col = index % tileColumns;

            graphics.drawRegion(tileImage,

                                col * tileWidth,

                                row * tileHeight,

                                tileWidth,

                                tileHeight,

                                transform & TRANSFORM_MASK,

                                x, y,

                                0);

        }

    }

    /**

     * Checks collision with Image.

     *

     * @param image Image.

     * @param x Image's x-coordinate.

     * @param y Image's y-coordinate.

     * @param pixelLevel Is collision check done in pixel level.

     *

     * @return true if Image and this Sprite collides.

     */

    public boolean collidesWith(Image image, int x, int y, boolean pixelLevel)

    {

        if(!visible)

        {

            return false;

        }

        // Image rect in painter's coordinates:

        final int x1 = x;

        final int y1 = y;

        final int x2 = x1 + image.getWidth();

        final int y2 = y1 + image.getHeight();

        // Sprite trans collision rect in sprite frame coordinates:

        final int[][] collisionRect = getTransCollisionRect();

        // sprite trans collision rect in painter's coordinates:

        int crX1 = this.x + collisionRect[0][0];

        int crY1 = this.y + collisionRect[0][1];

        int crX2 = this.x + collisionRect[1][0];

        int crY2 = this.y + collisionRect[1][1];

        // Check boundary collision first:

        if(!(x1 < crX2 && x2 > crX1 && y1 < crY2 && y2 > crY1))

        {

            return false;

        }

        // Rectangles intersect, can return a hit if not pixel level:

        if(!pixelLevel)

        {