import android.content.res.Resources;
import android.graphics.Bitmap;
import android.graphics.BitmapFactory;
import android.graphics.Canvas;
import android.graphics.Color;
import android.graphics.Matrix;
import android.graphics.Point;
import android.graphics.Rect;
import android.view.MotionEvent;

/**
 * Класс для создания спрайтов с кадрами с возможностью детектирования 
 * столкновения ограничивающих прямоугольников и возможностью вращения на любой угол.
 * @autor samodelkin
 * @version 1.0
 */

public class LayerSprite {
	private int mX, mY; // координаты слоя
	private boolean mVisible; // видимость слоя

	/** Изображения спрайта */
	private Bitmap[] mFrames;

	/** Текущий индекс отрисовываемого спрайта (для анимаций) */
	private int mFrameIndex;

	/** Последовательность кадров */
	private int[] mFrameSequence;

	/** Ограничивающий прямоугольник (для отслеживания столкновений) */
	private Rect mBounds;

	/** Матрица для вращения */
	private Matrix matrix;

	/** Угол вращения и координаты опорного пикселя */
	private int degress, refPixelX, refPixelY;

	/** Создать спрайт с несколькими изображениями. */
	public LayerSprite(int[] ids,Resources res) {
		super();
		Bitmap[] bitmaps;
		bitmaps=new Bitmap[ids.length];
		for(int i=0;i<ids.length;i++){
			bitmaps[i]=BitmapFactory.decodeResource(res, ids[i]);
		}
		mX = mY = 0;
		mVisible = true;
		mFrames = new Bitmap[bitmaps.length];
		System.arraycopy(bitmaps, 0, mFrames, 0, bitmaps.length);
		mFrameIndex = 0;
		mFrameSequence = new int[bitmaps.length];
		for (int n = 0; n < bitmaps.length; n++)
			mFrameSequence[n] = n; // заполнение последовательности кадров по
									// умолчанию
		mBounds = new Rect(0, 0, bitmaps[0].getWidth(), bitmaps[0].getHeight());
		matrix = new Matrix();
		degress = 0;
		refPixelX = this.getWidth() / 2;
		refPixelY = this.getHeight() / 2;
	}

	/** Создать спрайт с одним изображением. */
	public LayerSprite(int id,Resources res) {
		super();
		Bitmap bitmap=BitmapFactory.decodeResource(res, id);
		mX = mY = 0;
		mVisible = true;
		Bitmap[] bitmaps = new Bitmap[] { bitmap };
		mFrames = new Bitmap[bitmaps.length];
		System.arraycopy(bitmaps, 0, mFrames, 0, bitmaps.length);
		mFrameIndex = 0;
		mFrameSequence = new int[bitmaps.length];
		for (int n = 0; n < bitmaps.length; n++)
			mFrameSequence[n] = n; // заполнение последовательности кадров по
									// умолчанию
		mBounds = new Rect(0, 0, bitmaps[0].getWidth(), bitmaps[0].getHeight());
		matrix = new Matrix();
		degress = 0;
		refPixelX = this.getWidth() / 2;
		refPixelY = this.getHeight() / 2;
	}

	/** Узнать координату икс. */
	public int getX() {
		return mX;
	}

	/** Узнать координату игрек. */
	public int getY() {
		return mY;
	}

	/** Узнать виден ли слой. */
	public boolean isVisible() {
		return mVisible;
	}

	/** Установить видимость слоя. */
	public void setVisible(boolean visible) {
		mVisible = visible;
	}

	/** Возвратить ширину спрайта. */
	public int getWidth() {
		return mFrames[0].getWidth();
	}

	/** Возвратить высоту спрайта. */
	public int getHeight() {
		return mFrames[0].getHeight();
	}

	/** Возвратить номер текущего кадра в последовательности кадров. */
	public int getFrameIndex() {
		return mFrameIndex;
	}

	/** Перейти на следующий кадр. */
	public void nextFrame() {
		mFrameIndex++;
		if (mFrameIndex == mFrameSequence.length) {
			mFrameIndex = 0;
		}
	}

	/** Перейти на предыдущий кадр. */
	public void prevFrame() {
		mFrameIndex--;
		if (mFrameIndex < 0) {
			mFrameIndex = mFrameSequence.length - 1;
		}
	}

	/** Установить номер кадра. */
	public void setFrame(int frame) {
		this.mFrameIndex = frame;
	}

	/** Установить числовую последовательность кадров. */
	public void setFrameSequence(int[] frameSequence) {
		mFrameSequence = new int[frameSequence.length];
		System.arraycopy(frameSequence, 0, mFrameSequence, 0,
				frameSequence.length);
	}

	/** Возвратить длину числовой последовательности кадров. */
	public int getFrameSequenceLength() {
		return mFrameSequence.length;
	}

	/**
	 * Проверить столкновение ограничивающих прямоугольников
	 */
	public boolean collidesWith(LayerSprite s){
			return Rect.intersects(getBoundsRect(), s.getBoundsRect());
	}

	/** Проверить столкновение с прямоугольником. */
	public boolean collidesWith(Rect rect) {
		return Rect.intersects(getBoundsRect(), rect);
	}

	/** Проверить столкновение с точкой. */
	public boolean collidesWith(Point point) {
		return Rect.intersects(getBoundsRect(), new Rect(point.x, point.y,
				point.x, point.y));
	}

	/** Проверить столкновение с нажатым на экране пальцем. */
	public boolean collidesWith(MotionEvent me) {
		boolean b = false;
		Point p = new Point();
		p.set((int) me.getX(), (int) me.getY());
		if (this.collidesWith(p))
			b = true;
		return b;
	}

	/** Задать ограничивающий прямоугольник. */
	public void defineCollisionRectangle(Rect rect) {
		mBounds.set(rect);
	}

	/** Установка координат опорного пикселя */
	public void setRefPixel(int refX, int refY) {
		this.refPixelX = refX;
		this.refPixelY = refY;
	}

	/** Получить координату икс опорного пикселя */
	public int getRefX() {
		return this.refPixelX;
	}

	/** Получить координату игрек опорного пикселя */
	public int getRefY() {
		return this.refPixelY;
	}

	/**
	 * Получаем ограничивающий прямоугольник с учётом позиции спрайта.
	 */
	private Rect getBoundsRect() {
		Rect bounds = new Rect(mBounds);
		bounds.offset(this.getX(), this.getY());
		return bounds;
	}

	/** Прорисовка спрайта. */
	public void paint(Canvas canvas) {
		if (this.isVisible())
			canvas.drawBitmap(mFrames[mFrameSequence[mFrameIndex]], matrix,
					null);
	}

	/** Повернуть спрайт на определенный угол. */
	public void rotate(int degress) {
		this.degress += degress;
		matrix.postRotate(this.degress, this.getX() + refPixelX, this.getY()
				+ refPixelY);
	}

	/** Возвратить угол поворота в градусах. */
	public int getRotate() {
		return this.degress;
	}

	/** Сбросить угол поворота. */
	public void resetRotate() {
		degress = 0;
		matrix.reset();
	}

	/** Сместить спрайт. */
	public void move(int dx, int dy) {
		this.mX += dx;
		this.mY += dy;
		matrix.setTranslate(this.getX(), this.getY());
		matrix.postRotate(degress, this.getX() + refPixelX, this.getY()
				+ refPixelY);
	}

	/** Задать позицию спрайта. */
	public void setPosition(int x, int y) {
		this.mX = x;
		this.mY = y;
		matrix.setTranslate(this.getX(), this.getY());
		matrix.postRotate(degress, this.getX() + refPixelX, this.getY()
				+ refPixelY);
	}

}