libgdx animation inside of a rectangle - collison detection - rectangles

Question

I am writing a RPG game similar to the style of Pokemon (top down view). I am now working on the issue of collision detection. I am wanting to create the collision detection based on rectangles. The problem is that i am having difficulty drawing the rectangle around the animation that i have previously set. I have searched Google and YouTube for a answer/tutorial of how to handle this problem yet found nothing.

Player.class

public class Player {

public Vector2 position; 
private float moveSpeed;
private SpriteBatch batch;

//animation
public Animation an;
private Texture tex;
public TextureRegion currentFrame;
private TextureRegion[][] frames;
private float frameTime;


public Player(Vector2 position){
    this.position = position;
    moveSpeed = 5f;
    createPlayer();
}

public void createPlayer(){
    tex = new Texture("Sprites/image.png");
    frames = TextureRegion.split(tex, tex.getWidth()/3, tex.getHeight()/4);
    an = new Animation(0.10f, frames[0]);
}

public void render(float delta){
    handleInput();
    frameTime += delta;
    currentFrame = an.getKeyFrame(frameTime, true);
}

public void handleInput(){
    if(Gdx.input.isKeyPressed(Keys.UP)){
        an = new Animation(0.10f, frames[3]);
        position.y += moveSpeed;
    }
    if(Gdx.input.isKeyPressed(Keys.DOWN)){
        an = new Animation(0.10f, frames[0]);
        position.y -= moveSpeed;
    }
    if(Gdx.input.isKeyPressed(Keys.LEFT)){
        an = new Animation(0.10f, frames[1]);
        position.x -= moveSpeed;
    }
    if(Gdx.input.isKeyPressed(Keys.RIGHT)){
        an = new Animation(0.10f, frames[2]);
        position.x += moveSpeed;    
    }
    if(!Gdx.input.isKeyPressed(Keys.ANY_KEY)){
        an = new Animation(0.10f, frames[0]);
    }
}

public void dispose(){
    batch.dispose();
}

public float getX(){
    return position.x;
}

public float getY(){
    return position.y;
}

public int getWidth(){
    return 32;
}

public int getHeight(){
    return 32;
}

}

WorldRenderer.class

public class WorldRenderer {

private OrthogonalTiledMapRenderer renderer;
public OrthographicCamera camera;
private Player player;

//Tilemap
private TiledMapTileLayer collision;
private TiledMap map;


public WorldRenderer() {
    map = new TmxMapLoader().load("maps/testMap.tmx");
    renderer = new OrthogonalTiledMapRenderer(map);

    //Tiled layers
    collision = (TiledMapTileLayer) map.getLayers().get("collision");

    player = new Player(new Vector2(100, 100));
    camera = new OrthographicCamera();
    camera.viewportWidth = Gdx.graphics.getWidth()/2;
    camera.viewportHeight = Gdx.graphics.getHeight()/2;

}
public void render (float delta) {      
    camera.update();
    renderer.setView(camera);
    renderer.render();

    player.render(delta);


    // Calculate tile size in pixels
    MapProperties prop = renderer.getMap().getProperties();
    int mapWidth = prop.get("width", Integer.class); //how many tiles in map
    int mapHeight = prop.get("height", Integer.class);
    int tilePixelWidth = prop.get("tilewidth", Integer.class); //size of each tile
    int tilePixelHeight = prop.get("tileheight", Integer.class);

    // Calculate total map size
    int worldSizeX = mapWidth * tilePixelWidth;
    int worldSizeY = mapHeight * tilePixelHeight;

    // Calculate min/max camera points inside the map
    float minCameraX = camera.zoom * (camera.viewportWidth / 2); 
    float maxCameraX = worldSizeX - minCameraX;
    float minCameraY = camera.zoom * (camera.viewportHeight / 2);
    float maxCameraY = worldSizeY - minCameraY;

    // set the camera to either the player or the min/max of the camera based on player position
    camera.position.set(
            Math.min(maxCameraX, Math.max(player.position.x + 32 / 2, minCameraX)),
            Math.min(maxCameraY, Math.max(player.position.y + 32 / 2, minCameraY)),
            0);
    camera.update();
    renderer.getSpriteBatch().setProjectionMatrix(camera.combined);



    renderer.getSpriteBatch().begin();
    renderer.getSpriteBatch().draw(player.currentFrame, player.position.x, player.position.y);
    renderer.getSpriteBatch().end();
}

}

Answer 1

If you want to detect collision between two rectangles, there is an example I used with sprites.

public class TestSpriteOne extends Sprite{  
    private Rectangle rectangle;

Add in the constructor.

rectangle = new Rectangle(getX(), getY(), getWidth(), getHeight());

In update Method

rectangle.setPosition(getX(), getY());

Is a new nethod

public Rectangle getColliderActor(){
    return this.rectangle;
}

Other classes

public class TestSpriteTwo extends Sprite{
    private Rectangle rectangle;

In the constructor.

rectangle = new Rectangle(getX(), getY(), getWidth(), getHeight());

In update method

rectangle.setPosition(getX(), getY());

In new method

public Rectangle getColliderActor(){
   return this.rectangle;
}

// Call in the TestSpriteOne class

boolean hasCollided = TestSpriteTwo.getColliderActor().overlaps(getColliderActor());

//Call in the GameScreen class

boolean hasCollided = TestSpriteOne.getColliderActor().overlaps(TestSpriteTwo.getColliderActor());

It overlaps whether this rectangle overlaps the other rectangle, so hasCollided variable will become true.

Edit: if the animation changes its width or height, you could resize the rectangle in the update method

rectangle.setSize (width, height);