gdx-studio

package scene2d;

import com.badlogic.gdx.Gdx;

import com.badlogic.gdx.graphics.g2d.Animation;

import com.badlogic.gdx.graphics.g2d.Batch;

import com.badlogic.gdx.graphics.g2d.ParticleEffect;

import com.badlogic.gdx.graphics.g2d.TextureRegion;

import com.badlogic.gdx.scenes.scene2d.Actor;

/** The MapActor Class

 * <p>

 * The MapActor is a SceneActor that can be used as a static tile, animated tile, animated actor or as a plain

 * actor.<br>

 * 1.For using it as a Static Tile use:<br>

 *  	MapActor(TextureRegion region, int row, int col, int id, int tileSize)<br>

 * 2.For using it as a Animated Tile/Actor use:<br>

 * 	 	MapActor(Animation a, int row, int col, int id, int tileSize)<br>

 * 3.For using it as a plain Actor use:<br>

 * 	 	MapActor(int row, int col, int tileSize)<br>

 * 

 * It has many important methods like moveTo, moveBy, collides, intersects, getCenterX, getCenterY

 * 

 * <b>Note:</b> Only Use setPositionXY and SetPositionRC on this actor do not use the Actor's setPosition method

 * as it causes problems

 * @author pyros2097 */

public class MapActor extends Actor {

	private int row;

	private int col;

	private int tileSize;

	public TextureRegion tileImage;

	public int index;

  	protected Animation animation;

  	protected boolean isAnimationActive = false;

  	protected boolean isAnimationLooping = true;

	protected TextureRegion keyFrame;

	// Particle

	public ParticleEffect particleEffect;

	public float particlePosX = 0.0f;

	public float particlePosY = 0.0f;

	public boolean isParticleEffectActive;

	// When tiles coords row and column are directly specified

	public MapActor(int row, int col, int tileSize){

		setTileSize(tileSize);

		setPositionRC(row, col);

		setSize(tileSize, tileSize); // All map units are 24x24

	}

	public MapActor(TextureRegion region, int row, int col, int id, int tileSize){

		this(row, col, tileSize);

		index = id;

		if(region != null)

			tileImage = region;

	}

	public MapActor(Animation a, int row, int col, int id, int tileSize) {

		this(row, col, tileSize);

		index = id;

		if(a != null){

			animation = a;

			isAnimationActive = true;

		}

	}

	@Override

	public void draw(Batch batch, float parentAlpha) {

		super.draw(batch, parentAlpha);

		batch.setColor(getColor());

		if(tileImage != null)

			batch.draw(tileImage, getX(), getY(), tileSize, tileSize);

		//font("normal").draw(batch, ""+index, getX(), getY()+tileSize);

		if (isAnimationActive && animation != null) {

			keyFrame = animation.getKeyFrame(Scene.stateTime, isAnimationLooping);

			batch.draw(keyFrame, getX(), getY(), tileSize, tileSize);

		}

		drawParticleEffect(batch);

	}

	public void drawParticleEffect(Batch batch){

		if (isParticleEffectActive) {

			particleEffect.draw(batch, Gdx.graphics.getDeltaTime());

			particleEffect.setPosition(getX() + particlePosX, getY()+ particlePosY);

		}

	}

	/**

	 * Set particle for this actor, centerPosition is used to center the

	 * particle on this actor sizes

	 * */

	public void setParticleEffect(ParticleEffect particleEffect,

			boolean isParticleEffectActive, boolean isStart,

			boolean centerPosition) {

		this.particleEffect = particleEffect;

		this.isParticleEffectActive = isParticleEffectActive;

		if (!centerPosition) {

			this.particleEffect.setPosition(getX(), getY());

		} else {

			particlePosX = getWidth() / 2.0f;

			particlePosY = getHeight() / 2.0f;

			this.particleEffect.setPosition(getX() + particlePosX, getY()

					+ particlePosY);

		}

		if (isStart) {

			this.particleEffect.start();

		}

	}

	/**

	 * Set particle position

	 * */

	public void setParticlePositionXY(float x, float y) {

		particlePosX = x;

		particlePosY = y;

	}

	public void setTileSize(int tsize){

		tileSize = tsize;

	}

	public int getTileSize(){

		return tileSize;

	}

	public int getCol(){

		return col;

	}

	public int getRow(){

		return row;

	}

	/*

	 * Col is always x-axis and Row is y-axis

	 */

	public void setPositionRC(int row, int col){

		setPosition(col*tileSize, row*tileSize);

	}

	/*

	 * The setPosition calls the super Actor's setPosition method and also updates the row and col

	 * position of the tile

	 */

	@Override

	public void setPosition(float x, float y){

		super.setPosition(x, y);

		this.row =(int)this.getY()/tileSize;

		this.col = (int)this.getX()/tileSize;

	}

	/**

	 * Translate actor in a direction of speed without stopping. Actor moves in

	 * constants speed set without acceleration

	 * 

	 * @param speedX

	 *            axis-X speed

	 * @param speedY

	 *            axis-Y speed

	 * @param delta

	 *            the delta time for accurate speed

	 * */

	public void translateWithoutAcc(float speedX, float speedY, float delta) {

		setPosition(getX() + (speedX * delta), getY() + (speedY * delta));

	}

	/**

	 * Get center x point of an object

	 * <p>

	 * EXAMPLE<br>

	 * Object's width 200, and we touched the screen in 400 in position X, and

	 * we want to center the object according to our touch position. (200 / 2 =

	 * 100 then 400 - 100), so 300 our center position

	 * 

	 * */

	public static float getCenterX(float eventX, float objectWidth) {

		return eventX - (objectWidth / 2);

	}

	/**

	 * @see getCenterX()

	 * */

	public static float getCenterY(float eventY, float objectHeight) {

		return eventY - (objectHeight / 2);

	}

	public boolean intersects(MapActor other){

		//Sink.log(""+row+" : "+other.getRow());

		if(col == other.getCol() && row == other.getRow())

			return true;

		return false;

	}

	public Animation getAnimation(){

		return animation;

	}

}