input listener in second stage not working in libgdx - listener

I want to have two stages on the same screen, but the problem is, the input listener of the second stage(static_stage) is not responding but no problem in drawing its actors.The first stage(stage) works and responds fine. Here is the code,and please tell me where am i going wrong?
package com.amal.arrange;
import com.badlogic.gdx.Gdx;
import com.badlogic.gdx.Screen;
import com.badlogic.gdx.graphics.GL20;
import com.badlogic.gdx.graphics.OrthographicCamera;
import com.badlogic.gdx.graphics.Texture;
import com.badlogic.gdx.graphics.g2d.BitmapFont;
import com.badlogic.gdx.graphics.g2d.Sprite;
import com.badlogic.gdx.scenes.scene2d.InputEvent;
import com.badlogic.gdx.scenes.scene2d.InputListener;
import com.badlogic.gdx.scenes.scene2d.Stage;
import com.badlogic.gdx.scenes.scene2d.ui.Label;
import com.badlogic.gdx.scenes.scene2d.ui.Label.LabelStyle;
public class gamescreen implements Screen {
final Mygame game;
OrthographicCamera camera;
Texture background;
Sprite sprite_back;
Stage stage;
Stage static_stage;
Label shuffle;
LabelStyle shuffle_style;
BitmapFont shuffle_font;
public gamescreen(final Mygame Game) {
game = Game;
camera = new OrthographicCamera();
camera.setToOrtho(false, Gdx.graphics.getWidth(),
Gdx.graphics.getHeight());
stage=new Stage();
static_stage=new Stage(stage.getViewport(),stage.getSpriteBatch());
static_stage.clear();
stage.clear();
Gdx.input.setInputProcessor(stage);
Gdx.input.setInputProcessor(static_stage);
Tile_manager.load();
}
#Override
public void render(float delta) {
Gdx.gl.glClearColor(0.85f, 0.85f, 0.85f, 0.85f);
Gdx.gl.glClear(GL20.GL_COLOR_BUFFER_BIT);
camera.update();
game.batch.setProjectionMatrix(camera.combined);
game.batch.begin();
game.batch.draw(sprite_back, 0, 0);
game.batch.end();
stage.draw();
static_stage.draw();
}
#Override
public void resize(int width, int height) {
static_stage.getViewport().update(width, height, true);
stage.getViewport().update(width, height, true);
}
#Override
public void show() {
//System.out.println("in show");
background=new Texture(Gdx.files.internal("background/background.png"));
sprite_back=new Sprite(background);
sprite_back.setBounds(0, 0, background.getWidth(), background.getHeight());
Tile_manager.generate_tile();
Tile_manager.add_listener();
stage=Tile_manager.get_tile_stage();
shuffle_font=new BitmapFont(Gdx.files.internal("fonts/shuffle.fnt"), false);
shuffle_style=new LabelStyle(shuffle_font, null);
shuffle=new Label("SHUFFLE", shuffle_style);
shuffle.setPosition(190, 1330);
shuffle.addListener(new InputListener(){
#Override
public boolean touchDown(InputEvent event, float x, float y,
int pointer, int button) {
System.out.println("in down");
return true;
}
#Override
public void touchUp(InputEvent event, float x, float y,
int pointer, int button) {
System.out.println("in up");
}
});
static_stage.addActor(shuffle);
}
#Override
public void hide() {
}
#Override
public void pause() {
}
#Override
public void resume() {
}
#Override
public void dispose() {
background.dispose();
stage.dispose();
}
}

I am facing the same problem. But to begin, you overright the input listener,
you have to set an inputmultiplexer to manage both the input
InputMultiplexer inputMultiplexer = new InputMultiplexer();
inputMultiplexer.addProcessor(stage);
inputMultiplexer.addProcessor(static_stage);
Gdx.input.setInputProcessor(inputMultiplexer);
But not sure this is enought...

Related

Error symbol variable ShapeType not found

I have just started to learn game develpoment in libgdx
It is showing error in this line
shapeRenderer.begin(ShapeType.Point);
error displayed is:-
Error:(80, 29) error: cannot find symbol variable ShapeType
this is my complete class
import com.badlogic.gdx.ApplicationAdapter;
import com.badlogic.gdx.Gdx;
import com.badlogic.gdx.graphics.GL20;
import com.badlogic.gdx.graphics.glutils.ShapeRenderer;
import com.badlogic.gdx.math.*;
import com.badlogic.gdx.utils.*;
import java.util.*;
public class Starfield extends ApplicationAdapter {
private static final float STAR_DENSITY = 0.01f;
ShapeRenderer shapeRenderer;
Array<Vector2> stars;
#Override
public void create() {
shapeRenderer=new ShapeRenderer();
initStars(0.01f);
}
public void initStars(float density) {
int a = Gdx.graphics.getWidth();
int b=Gdx.graphics.getHeight();
int count=Integer.parseInt(Float.toString(a*b*density));
stars=new Array<Vector2>(count);
Random random=new Random();
for(int i=0;i<count;i++)
{
int x=random.nextInt(a);
int y=random.nextInt(b);
stars.add(new Vector2(a,b));
}
}
#Override
public void resize(int width, int height) {
initStars(STAR_DENSITY);
shapeRenderer = new ShapeRenderer();
}
#Override
public void render() {
Gdx.gl.glClearColor(0, 0, 0, 1);
Gdx.gl.glClear(GL20.GL_COLOR_BUFFER_BIT);
shapeRenderer.begin(ShapeType.Point);
for(Vector2 star : stars)
{
shapeRenderer.point(star.x,star.y,0);
}
shapeRenderer.end();
}
#Override
public void dispose() {
shapeRenderer.dispose();
super.dispose();
}
}
ShapeType is an enum inside ShapeRenderer class.
Use in this way :
shapeRenderer.begin(ShapeRenderer.ShapeType.Point);

Java - Libgdx : Keep actor's position even screen's resolution changes

issue is next one: my game is built for 1080x1920 pixels screen but if I run it in other resolutions my actors' position is switching.
Some pictures if you haven't understood:
~> original resolution
~> other resolution
I looked for an answer for days in Google, Stackoverflow, forums, couldn't find the right answer for my problem, here's my code:
public class PlayScreen implements Screen {
private Main game;
private Stage stage;
Music music;
Sound sound;
private class MenuGame extends Actor {
Texture menu = new Texture(Gdx.files.internal("sprite/menu.png"));
#Override
public void draw(Batch batch, float alpha) {
batch.draw(menu, 0, 0,Gdx.graphics.getWidth(), Gdx.graphics.getHeight());
}
}
private class NewGame extends Actor {
Texture newgame = new Texture(Gdx.files.internal("sprite/new.png"));
#Override
public void draw(Batch batch, float alpha) {
batch.draw(newgame, 350, 1000);
}
}
private class LoadGame extends Actor {
Texture loadgame = new Texture(Gdx.files.internal("sprite/load.png"));
#Override
public void draw(Batch batch, float alpha) {
batch.draw(loadgame, 350, 830);
}
}
private class CreditsGame extends Actor {
Texture creditsgame = new Texture(Gdx.files.internal("sprite/credits.png"));
#Override
public void draw(Batch batch, float alpha) {
batch.draw(creditsgame, 350, 660);
}
}
private class DonsGame extends Actor {
Texture donsgame = new Texture(Gdx.files.internal("sprite/dons.png"));
#Override
public void draw(Batch batch, float alpha) {
batch.draw(donsgame, 350, 490);
}
}
// our create()
public PlayScreen(final Main game) {
this.game = game;
Gdx.input.setInputProcessor(stage);
final Sound sound = Gdx.audio.newSound(Gdx.files.internal("sound/buttonsound.mp3"));
music = Gdx.audio.newMusic(Gdx.files.internal("sound/brun.mp3"));
music.setLooping(true);
music.setVolume(0.2f);
music.play();
// actors
MenuGame menu = new MenuGame(); // BACKGROUND
stage.addActor(menu);
final NewGame newGame = new NewGame(); // BOUTON NEW
stage.addActor(newGame);
newGame.setX(350);
newGame.setY(1000);
newGame.setWidth(410);
newGame.setHeight(100);
LoadGame loadGame = new LoadGame(); // BOUTON LOAD
stage.addActor(loadGame);
loadGame.setX(350);
loadGame.setY(830);
loadGame.setWidth(410);
loadGame.setHeight(100);
CreditsGame creditsGame = new CreditsGame(); // BOUTON CREDITS
stage.addActor(creditsGame);
creditsGame.setX(350);
creditsGame.setY(660);
creditsGame.setWidth(410);
creditsGame.setHeight(100);
DonsGame donsGame = new DonsGame(); // BOUTON DONS
stage.addActor(donsGame);
donsGame.setX(350);
donsGame.setY(490);
donsGame.setWidth(410);
donsGame.setHeight(100);
// actions
newGame.addListener(new ClickListener() {
public boolean touchDown(InputEvent event, float x, float y, int pointer, int button) // NEW BOUTON ACTION
{
sound.play(0.2f);
music.stop();
game.setScreen(new Story(game));
return true;
}
});
loadGame.addListener(new ClickListener() {
public boolean touchDown(InputEvent event, float x, float y, int pointer, int button) // LOAD BOUTON ACTION
{
sound.play(0.2f); //faire un truc ici
return true;
}
});
creditsGame.addListener(new ClickListener() {
public boolean touchDown(InputEvent event, float x, float y, int pointer, int button) // CREDITS BOUTON ACTION
{
sound.play(0.2f);//faire un truc ici
return true;
}
});
donsGame.addListener(new ClickListener() {
public boolean touchDown(InputEvent event, float x, float y, int pointer, int button) // DONS BOUTON ACTION
{
sound.play(0.2f);//faire un truc ici
return true;
}
});
}
#Override
public void show() {
}
#Override
public void render(float delta) {
Gdx.gl.glClearColor(1, 1, 1, 1);
Gdx.gl.glClear(GL20.GL_COLOR_BUFFER_BIT);
stage.draw();
}
#Override
public void resize(int width, int height) {
}
#Override
public void pause() {
}
#Override
public void resume() {
}
#Override
public void hide() {
}
#Override
public void dispose() {
stage.dispose();
music.dispose();
sound.dispose();
}
}
You are positioning everything after hardcoded values. So right now your game is very resolution depended.
What you need to use is Viewports.
Here are some links to get you started:
Brent Aureli - Aspect Ratios & Viewports
libgdx github - viewports
libgdx github - scene2d
this is happening because different devices has different screen size. so it will appear differently . to avoid this you must use the viewPort .for more clarification you must read the libgdx api about the multi resolution and the viewPort . here i will suggest you some sample code to avoid this multi screen issue. please follow this pattern which acan solve your problem.
// in your main class
public class myGame extends ApplicationAdapter {
public OrthographicCamera camera
public Viewport viewPort
private SpriteBatch batch;
private BitMapFont myScoreFont
public myGame() {
}
#Override
public void create() {
myScoreFont = new BitmapFont(Gdx.files.internal(font.txt), true);
batch = new SpriteBatch();
float w = Gdx.graphics.getWidth();
float h = Gdx.graphics.getHeight();
camera = new OrthographicCamera();
camera.position.set(0, 0, 0);
camera.update();
camera.setToOrtho(false, Constants.APP_WIDTH, Constants.APP_HEIGHT);
viewPort = new FillViewport(1280, 800, camera);
}
#Override
public void dispose() {
batch.dispose();
}
#Override
public void render() {
Gdx.gl.glClearColor(1, 1, 1, 1);
Gdx.gl.glClear(GL30.GL_COLOR_BUFFER_BIT);
float deltaTime = Gdx.graphics.getDeltaTime();
batch.setProjectionMatrix(camera.combined);
batch.begin();
myScoreFont.draw(batch,"myText",0,0)
batch.end();
}
#Override
public void resize(int width, int height) {
viewPort.update(width, height);
}
#Override
public void pause() {
}
#Override
public void resume() {
}
}
for more details you must read the below link about the viewport
https://libgdx.badlogicgames.com/nightlies/docs/api/com/badlogic/gdx/utils/viewport/FillViewport.html

"Cannot use offsets when Array Buffer Object is disabled" error when attempting to change screen

I have a blue square, and when the blue square is moved to the finish flag, the screen should change to signify that the level is complete. However, when I move the blue square to such position, I get an error message:
Exception in thread "LWJGL Application" org.lwjgl.opengl.OpenGLException: Cannot use offsets when Array Buffer Object is disabled
at org.lwjgl.opengl.GLChecks.ensureArrayVBOenabled(GLChecks.java:77)
at org.lwjgl.opengl.GL20.glVertexAttribPointer(GL20.java:892)
at com.badlogic.gdx.backends.lwjgl.LwjglGL20.glVertexAttribPointer(LwjglGL20.java:847)
at com.badlogic.gdx.graphics.glutils.ShaderProgram.setVertexAttribute(ShaderProgram.java:662)
at com.badlogic.gdx.graphics.glutils.VertexBufferObject.bind(VertexBufferObject.java:202)
at com.badlogic.gdx.graphics.Mesh.bind(Mesh.java:380)
at com.badlogic.gdx.graphics.Mesh.bind(Mesh.java:371)
at com.badlogic.gdx.graphics.Mesh.render(Mesh.java:479)
at com.badlogic.gdx.graphics.Mesh.render(Mesh.java:422)
at com.badlogic.gdx.graphics.glutils.ImmediateModeRenderer20.flush(ImmediateModeRenderer20.java:151)
at com.badlogic.gdx.graphics.glutils.ImmediateModeRenderer20.end(ImmediateModeRenderer20.java:160)
at com.badlogic.gdx.graphics.glutils.ShapeRenderer.end(ShapeRenderer.java:1104)
at com.badlogic.gdx.graphics.glutils.ShapeRenderer.check(ShapeRenderer.java:1087)
at com.badlogic.gdx.graphics.glutils.ShapeRenderer.polygon(ShapeRenderer.java:1014)
at com.badlogic.gdx.graphics.glutils.ShapeRenderer.polygon(ShapeRenderer.java:1043)
at com.ian.redsquare.Entities.Walls.render(Walls.java:22)
at com.ian.redsquare.Screens.RedSquareScreen.render(RedSquareScreen.java:65)
at com.badlogic.gdx.Game.render(Game.java:46)
at com.badlogic.gdx.backends.lwjgl.LwjglApplication.mainLoop(LwjglApplication.java:215)
at com.badlogic.gdx.backends.lwjgl.LwjglApplication$1.run(LwjglApplication.java:120)
here is the screen class in which the blue square moves:
package com.ian.redsquare.Screens;
import ...
public class RedSquareScreen implements Screen{
RedSquareGame game;
Viewport gameViewport;
ShapeRenderer renderer;
RedSquare redSquare;
BlueSquare blueSquare;
FinishSquare finishSquare;
Walls walls;
public RedSquareScreen(RedSquareGame game){
this.game = game;
}
#Override
public void show() {
gameViewport = new ExtendViewport(C.WORLD_SIZE, C.WORLD_SIZE, C.WORLD_SIZE, C.WORLD_SIZE);
renderer = new ShapeRenderer();
renderer.setAutoShapeType(true);
finishSquare = new FinishSquare(blueSquare);
redSquare = new RedSquare();
blueSquare = new BlueSquare(redSquare);
walls = new Walls();
}
#Override
public void render(float delta) {
redSquare.update(delta);
blueSquare.update(delta);
if(finishSquare.position.dst(blueSquare.position) <= 0){
game.showLevelEndScreen();
}
gameViewport.apply(true);
Gdx.gl.glClearColor(C.BACKGROUND_COLOR.r, C.BACKGROUND_COLOR.g, C.BACKGROUND_COLOR.b, 1);
Gdx.gl.glClear(GL20.GL_COLOR_BUFFER_BIT);
renderer.setProjectionMatrix(gameViewport.getCamera().combined);
renderer.begin();
finishSquare.render(renderer);
redSquare.render(renderer);
blueSquare.render(renderer);
walls.render(renderer);
renderer.end();
}
#Override
public void resize(int width, int height) {
gameViewport.update(width, height, true);
}
#Override
public void pause() {
}
#Override
public void resume() {
}
#Override
public void hide() {
renderer.dispose();
}
#Override
public void dispose() {
}
}
here is screen class which is meant to appear once the blue square reaches the finish square:
package com.ian.redsquare.Screens;
import ...
public class LevelEndScreen extends InputAdapter implements Screen {
RedSquareGame game;
Viewport viewport;
ShapeRenderer renderer;
SpriteBatch batch;
public LevelEndScreen(RedSquareGame game){
this.game = game;
}
#Override
public void show() {
viewport = new ExtendViewport(C.LE_WORLD_SIZE, C.LE_WORLD_SIZE);
renderer = new ShapeRenderer();
renderer.setAutoShapeType(true);
batch = new SpriteBatch();
Gdx.input.setInputProcessor(this);
}
#Override
public void render(float delta) {
viewport.apply();
Gdx.gl.glClearColor(C.LE_BACKGROUND_COLOR.r, C.LE_BACKGROUND_COLOR.g, C.LE_BACKGROUND_COLOR.b, 1);
Gdx.gl.glClear(GL20.GL_COLOR_BUFFER_BIT);
renderer.setProjectionMatrix(viewport.getCamera().combined);
renderer.begin(ShapeRenderer.ShapeType.Filled);
renderer.setColor(C.RESTART_COLOR);
renderer.rect(C.LE_WORLD_SIZE / 4, C.LE_WORLD_SIZE / 2, C.BUTTON_SIZE, C.BUTTON_SIZE);
renderer.setColor(C.NEXT_LEVEL_COLOR);
renderer.rect((C.LE_WORLD_SIZE * (3 / 4)) - C.BUTTON_SIZE, C.LE_WORLD_SIZE / 2, C.BUTTON_SIZE, C.BUTTON_SIZE);
renderer.end();
}
#Override
public void resize(int width, int height) {
viewport.update(width, height, true);
}
#Override
public void pause() {
}
#Override
public void resume() {
}
#Override
public void hide() {
batch.dispose();
renderer.dispose();
}
#Override
public void dispose() {
}
#Override
public boolean touchDown (int screenX, int screenY, int pointer, int button) {
Vector2 worldTouch = viewport.unproject(new Vector2(screenX, screenY));
if(worldTouch.dst2(new Vector2(C.LE_WORLD_SIZE / 4, C.LE_WORLD_SIZE / 2)) == 0){
game.showRedSquareScreen();
}
return true;
}
}

Libgdx Actor Scened2d Draw method does not draw nothing

I've started a very small Libgdx project based in Scene2d. I downloaed last version of LGDX. I have tried to find some imformation but nothing clear.
The problem is that I only get a Black Screen of the Death. Nothing happens
I have followed the code, with logs and I'm sure I arrive to Draw method in my Actor with no results:
Thank you in advance.
public class ActorBall extends Actor implements Disposable {
private Texture ballTexture;
private TextureRegion ballTextureRegion;
public ActorBall() {
bolaTexture = new Texture("redball.png");
ballTextureRegion = new TextureRegion(ballTexture, 300,300);
setSize(300,300);
}
#Override
public void dispose(){
bolaTexture.dispose();
}
#Override
public void draw(Batch batch, float parentAlpha) {
Color col = getColor();
batch.setColor(col.r,col.g, col.b,col.a * parentAlpha);
Gdx.app.log("App","where are you");
batch.draw(ballTextureRegion,getX(),getY(),getOriginX(),
getOriginY(),getWidth(), getHeight(), getScaleX(), getScaleY(),getRotation());
}
#Override
public void act(float delta) {
super.act(delta);
}
}
My screen class extended from Screen:
public class scene extends scenebase {
private final OrthographicCamera camera;
private MyGdxGame game ;
private Stage stage; // los Stages son inputprocessors
private ActorBall ball;
public scene(MyGdxGame game) {
super(game);
this.game = game;
camera = new OrthographicCamera();
camera.setToOrtho(false, 800, 480);
stage = new Stage(new ScreenViewport());
ball = new ActorBall();
ball.setPosition(0,0);
stage.addActor(ball);
}
#Override
public void render(float delta) {
// super.render(delta);
Gdx.gl.glClearColor(0,0,0.0f,1);
Gdx.gl.glClear (GL20.GL_COLOR_BUFFER_BIT);
camera.update();
// game.batch.setProjectionMatrix(camera.combined);
stage.draw();
stage.act();
}
#Override
public void resize(int width, int height) {
stage.getViewport().update (width,height);
}
}
And last my main game:
public class MyGdxGame extends Game {
private AssetManager manager;
private scene screenscene;
#Override
public void create() {
manager = new AssetManager();
manager.load("redball.png", Texture.class);
manager.finishLoading();
// Enter the loading screen to load the assets.
screenscene = new scene(this);
setScreen(screenscene);
}
#Override
public void render () {
super.render(); // This is very important!!!!!!!!
Gdx.gl.glClearColor(0, 0, 0.1f, 1);
Gdx.gl.glClear(GL20.GL_COLOR_BUFFER_BIT);
}
public AssetManager getManager() {
return this.manager;
}
}
#Override
public void render () {
super.render(); // This is very important!!!!!!!!
Gdx.gl.glClearColor(0, 0, 0.1f, 1);
Gdx.gl.glClear(GL20.GL_COLOR_BUFFER_BIT);
}
What this does is first render everything and then clear the screen. You need to first clear it and then render.

Render Image actor on top of TiledMap in Libgdx

I have created 10 object layers using Tile software,and rendering tiled map using OrthogonalTiledMapRenderer object.
renderer.setView(camera);
renderer.render();
I have created backgroundTiledMap class extending Actor class to it.
adding object of the backgroundTiledMap class in stage of mainGame class.
Its rendering perfectly.
but when I am trying to add next actor to the same stage. its not getting rendered.
is there any different way of using tiled map and actors to detect collision in between.
Below the actual code
backgroundTiledMap.java class which is extended as actor and used to draw background from tiled map (created in tile software)
public class BackgroundTiledMap extends Actor {
public MapProperties properties;
public MapLayer layer;
public MapObject mapObject;
public TiledMapTileLayer tiledLayer;
private TiledMap map;
private OrthogonalTiledMapRenderer renderer;
private OrthographicCamera camera;
public Array<Rectangle> tiles = new Array<Rectangle>();
private Pool<Rectangle> rectPool = new Pool<Rectangle>() {
#Override
protected Rectangle newObject () {
return new Rectangle();
}
};
GameStartPoint game;
Stage stage;
Reptile reptile;
public BackgroundTiledMap(GameStartPoint game,Stage stage)
{
this.game = game;
this.stage = stage;
init();
}
public void init()
{
map = new TmxMapLoader().load("Images/GuideCrocodile.tmx");
renderer = new OrthogonalTiledMapRenderer(map, 1 / 16f);
camera = new OrthographicCamera();
camera.setToOrtho(false, 70, 50);
camera.update();
stage.setCamera(camera);
}
#Override
public void draw(SpriteBatch batch, float parentAlpha) {
super.draw(batch, parentAlpha);
render();
}
public void render()
{
camera.update();
renderer.setView(camera);
renderer.render();
}
}
this is mainGame screen used to create stage and all other actors and objects are added here
public class GuideCrocodileScreen implements Screen {
public GameStartPoint game;
private Stage stage;
public BackgroundTiledMap backgroundTiledMap;
public Reptile reptile;
MoveToAction moveAction;
public GuideCrocodileScreen(GameStartPoint game)
{
this.game = game;
stage = new Stage();
}
#Override
public void render(float delta) {
// clear the screen
Gdx.gl.glClearColor(0.7f, 0.7f, 1.0f, 1);
Gdx.gl.glClear(GL10.GL_COLOR_BUFFER_BIT);
Gdx.input.setInputProcessor(stage);
stage.draw();
}
private void addReptile(){
reptile = new Reptile(stage,100,100,50,50);
// backgroundTiledMap.getTiles(100,100,50,50);
reptile.addListener(new InputListener() {
public boolean touchDown (InputEvent event, float x, float y, int pointer, int button) {
System.out.println("down");
return true;
}
public void touchUp (InputEvent event, float x, float y, int pointer, int button) {
System.out.println("up");
}
public void touchDragged (float x, float y, int pointer) {
reptile.updateReptile(x,y);
}
public boolean touchMoved (float x, float y) {
//reptile.updateReptile(x,y);
return false;
}
});
stage.addActor(reptile);
}
#Override
public void resize(int width, int height) {
}
#Override
public void show() {
addBackgroundArea();
addReptile();
}
private void addBackgroundArea(){
backgroundTiledMap = new BackgroundTiledMap(game,stage);
stage.addActor(backgroundTiledMap);
}
}
new actor class , this is actor to move around the screen detecting collision with the objects drawn on backgroundTiledMap reptile.java (this is not getting rendered)
public class Reptile extends Actor {
public GameStartPoint game;
private OrthogonalTiledMapRenderer renderer;
public SpriteBatch batch;
public int screenWidth;
public int screenHeight;
private Texture reptiletexture;
private TextureRegion reptileRegion;
private Stage stage;
public Reptile( Stage stage,int x, int y,int width, int height){
setX((float)x);
setY((float)y);
setWidth((float)width);
setHeight((float)height);
this.setTouchable(Touchable.enabled);
this.stage = stage;
initialize();
}
private void initialize(){
this.screenWidth = GameStartPoint.WIDTH;
this.screenHeight = GameStartPoint.HEIGHT;
reptiletexture = new Texture(Gdx.files.internal("Images/basketball.png"));
reptileRegion = new TextureRegion(reptiletexture);
this.setVisible(true);
}
#Override
public void draw(SpriteBatch batch,float parentAlpha)
{
super.draw(batch,parentAlpha);
batch.draw(reptileRegion, getX(), getY(), getOriginX(),
getOriginY(), getWidth(), getHeight(), getScaleX(),
getScaleY(), getRotation());
}
public void updateReptile(float x,float y)
{
int duration = 5;
if(Gdx.input.isTouched())
{
MoveToAction action = Actions.action(MoveToAction.class);
action.setPosition(x, y);
action.setDuration(duration);
this.addAction(action);
}
}
#Override
public Actor hit(float x, float y, boolean touchable) {
//Gdx.app.log("","reptile is touched.. ") ;
updateReptile(x,y);
return super.hit(x, y, touchable);
}
}
An old question, but this was the first hit when I was googling for the same problem...
If the actor uses some other methods for drawing instead of the batch, the batch should be ended and then restarted again at the end of the method. So in BackgroundTiledMap:
#Override
public void draw(SpriteBatch batch, float parentAlpha) {
batch.end();
render(); // Renders the TiledMap using OrthogonalTiledMapRenderer
batch.begin();
}
See https://github.com/libgdx/libgdx/wiki/Scene2d#drawing for more info.
To draw an actor above the tilemap you must call stage.draw after rendering tilemap like this:
#Override
public void draw(SpriteBatch batch, float parentAlpha) {
render();
super.draw(batch, parentAlpha);
}
For the collision part you can get the objects that you have created in the TiledMap in different classes such as
EllipseMapObject, PolygonMapObject, RectangleMapObject etc. from where you can extract polylines, polygons etc. and use Intersector class to check their bounds.