Develop Reference

LibGDX touchDown touchUp on different Actors

In my LibGDX game, I have a raster of clickable Actors. I want the player to be able to swipe across them and get the Actor where the swipe stops.
I don't want a GestureListener, the only thing I need is a touchUp event on the touchDown generated on another Actor. For example: think about Androids login screen where you swipe a pattern to unlock, but I only need an event for the last dot/Actor.
I have tried using touchDown / touchUp, but the event always fires on the Actor where the touchDown occurred.
A fine solution would be to get events for every Actor hit by the swipe, and then get a global touchUp event. Is this possible in a relatively accessible way - eg. without writing a whole new InputListener?

In touchUp() of your listener, call hit on the parent WidgetGroup of all your clickable Actors to see which one the finger is over when it is released. Note that since you're adding the actors to the group, the group needs to be added to the stage instead of adding the widgets to the stage directly. And remember that an Actor's X and Y are relative to its parent.
final WidgetGroup parent = new WidgetGroup();
InputListener inputListener = new InputListener(){
private final Vector2 tmp = new Vector2();
public boolean touchDown (InputEvent event, float x, float y, int pointer, int button) {
return true;
}
public void touchUp (InputEvent event, float x, float y, int pointer, int button) {
event.getTargetActor().localToParentCoordinates(tmp.set(x, y));
Actor releaseOverActor = parent.hit(tmp.x, tmp.y, true);
if (releaseOverActor != null){
//doSomethingTo(releaseOverActor);
}
}
}
for (Actor clickable : clickableActors){
parent.add(clickable);
clickable.addListener(inputListener);
}
The above is a little bit simplified. You might want to return true one touchDown only if pointer 0 is used, for example.

libGDX touch in effect after touch

I use the following code to match the user touch to a ball object's position, so when the user touches the ball it bounce back up. Code:
int x1 = Gdx.input.getX();
int y1 = Gdx.input.getY();
Vector3 input = new Vector3(x1, y1, 0);
cam.unproject(input);
if(ball.getBoundingCircle().contains(input.x, input.y)) {
ballBounce();
}
But I have a problem with the touch. If the user touches a certain position on screen for a moment and a ball (after a while more appear) about to reach the position the user touched, the ball will recognize itself as been touched and the ballBounce(); method will start and continue with other balls that reach to the same position until the user touch another position on the screen but then that position will be fixed till the new one... Do someone know how I can bypass that problem so if the user stop touching the screen then where he\she touched won't affect the ball objects?

It seems that you are not using any input processor.
Make your class implement InputProcessor and make your touchDown method look like this.
#Override
touchDown(InputEvent event, float x, float y, int pointer, int button) {
Vector3 input = new Vector3(x, y, 0);
cam.unproject(input);
if (ball.getBoundingCircle().contains(input.x, input.y)) {
ballBounce();
}
}
ClickListener (LibGDX API)

Achieve parallax effect in libGDX game

I'm working in a game with some friends in which we have a large horizontal world and a OrthographicCamera that shows only 1/3 of it. This camera it's moved when the horizontal position of the player change so the camera only move to the left and to the right.
Some of the objects showed in the game are near the player point-of-view but others are far away (for example, islands). With this in consideration, we cannot set fixed positions for elements and move only the camera. We need to achieve a parallax effect taking in consideration the distance of the elements.
Here is a simple image to explain it better:
The viewport to the left shows 3 objects of the game. The green one is near the player, the red ellipse is far and the yellow one is in the middle. In the viewport to the right the camera has been moved to the right so all the objects disappear to the left. The thing is that the relative movement of the green rectangle is greater than the movement of the yellow. In the same way, movement of yellow object is greater than red object movement.
I created all my assets scaled taking in consideration how far they are but now, how can I simulate this perspective using libGDX? Is there any class to do it? If I have to set elements position in each iteration, how could I calculate the right position?

Note that the example below is not tested as I am just recalling how I did it. The idea is simple - create layers with an extra layer for each with initial positions and velocity and move them. If a layer goes off the edge, put another one (that is why we create an extra layer) at the opposite edge.
Say you have a parallax object that takes initial positions, size, and velocity-
public class Parallax extends DynamicGameObject {
public float width, height; // Use setter/getter if you prefer
public Parallax(float x, float y, float width, float height, float velocityX, float velocityY) {
super(x, y, width, height);
velocity.set(velocityX, velocityY);
this.width = width;
this.height = height;
}
public void update(float deltaTime) {
position.add(velocity.x * deltaTime, velocity.y * deltaTime);
}
public void setPosition(float x, float y) {
position.set(x, y);
}
}
DynamicGameObject is taken from SuperJumper demo-
public class DynamicGameObject extends GameObject {
public final Vector2 velocity;
public final Vector2 accel;
public DynamicGameObject(float x, float y, float width, float height) {
super(x, y, width, height);
velocity = new Vector2();
accel = new Vector2();
}
}
GameObject as well-
public class GameObject {
public final Vector2 position;
public final Rectangle bounds;
public GameObject(float x, float y, float width, float height) {
this.position = new Vector2(x,y);
this.bounds = new Rectangle(x - width/2f, y - height/2f, width, height);
}
}
Say we have two layers - one in front and the other goes at back. We have one texture for each. Each texture fills the entire screen. We create two instances for each layer so that when one texture starts going off the screen, the other shows up at the edge to fill the gap. If you have smaller textures, you need to determine first how many textures you need to fill the screen and then create layers with one extra to fill the gap in between.
We can create an array of parallax layers during world creation-
Array<Parallax> parallaxList = new Array<Parallax>(4);
We can create the layers like this-
// Back
/* First parallax for back layer is at 0 x-axis. If you want to move the texture from right to left, the value of BACK_VELOCITY_X should be negative. You can experiment with velocity value for desire pace of movement. We do not want our layer to move on y-axis. Hence, it is set to 0. */
parallaxList.add(new Parallax(0, BACK_TEXTURE_HEIGHT, BACK_TEXTURE_WIDTH, BACK_TEXTURE_HEIGHT, BACK_VELOCITY_X, 0));
/* This one is also for back layer but it is positioned at the right edge of the layer above*/
parallaxList.add(new Parallax(BACK_TEXTURE_WIDTH, BACK_TEXTURE_HEIGHT, BACK_TEXTURE_WIDTH, BACK_TEXTURE_HEIGHT, SOME_VELOCITY_X, 0));
// Front
parallaxList.add(new Parallax(0, 0, FRONT_TEXTURE_WIDTH, FRONT_TEXTURE_HEIGHT, FRONT_VELOCITY_X, 0));
parallaxList.add(new Parallax(FRONT_TEXTURE_WIDTH, 0, FRONT_TEXTURE_WIDTH, FRONT_TEXTURE_HEIGHT, FRONT_VELOCITY_X, 0));
We update the layers on an update call in each frame-
// In our example, TOTAL_LAYERS is 4
for (int i = 0; i < TOTAL_LAYERS; i++) {
int tmpInt;
Parallax parallax = parallaxList.get(i);
parallax.update(deltaTime);
// If one layer is off the edge, put it at the right of the next one
// In this example, layers are moving from right to left
if (parallax.position.x <= -parallax.width) {
// We know that parallaxList's indexes 0 and 1 hold the back layers
// and indexes 2 and 3 have the front layers. You can add additional
// parameters in Parallax class to indicate a group so that you do not
// have to determine the group in dirty way like this
if(i == 0){
tmpInt = 1;
} else if(i == 1) {
tmpInt = 0;
} else if(i == 2) {
tmpInt = 3;
} else {
tmpInt = 2;
}
parallax.setPosition(parallaxList.get(tmpInt).position.x + parallax.width, parallax.position.y);
}
}
You can use an OrthographicCamera and a SpriteBatch to draw the parallax layers. You can actually use the game camera you have but I think using a separate camera is much cleaner. Anyways, parallax textures are usually big enough to be batched in a separate call so using the game camera most probably will not save you a draw call.

How to drag and drop a LibGDX Image actor

I have a LibGDX scene with a couple of Images (the Actor subclass). I want to drag one Image and drop it on another. I started with the source code located at DragDropTest.java. Since I basically want the source to be the payload I've tried modifying payload.setDragActor to use the source Image. It kind of works, I need to add the code to place the payload actor back in the stage but that isn't my issue.
My problem that that the payload (when it's the source actor or a separate actor) doesn't really get dragged. Instead what happens is the payload actor positions itself slightly down and to the right of the mouse cursor. I want to place the payload, not point to where I want the payload placed. It doesn't feel like dragging at all, it feels like something is following the cursor. I see the same behavior on the Android emulator as I do on the desktop version of the app.

I went digging through the LibGDX source for com.badlogic.gdx.scenes.scene2d.utils.DragAndDrop and found the answer. The code places the payload +14 in the X direction from the cursor and (-20 - payLoadActor.getHeight()) in the Y direction which is why I'm not able to visually drag the payload. There is a setDragActorPosition method that can be used to correct the position. If you always want the dragged payload to be centered under the cursor you can do:
final DragAndDrop dragAndDrop = new DragAndDrop();
dragAndDrop.setDragActorPosition(-(sourceImage.getWidth()/2), sourceImage.getHeight()/2);
If you want the dragged payload to maintain its placement under the cursor/finger than you have to use the cursor position when calling setDragActorPosition in the dragStart method.
final DragAndDrop dragAndDrop = new DragAndDrop();
dragAndDrop.addSource(new DragAndDrop.Source(sourceImage) {
public DragAndDrop.Payload dragStart (InputEvent event, float x, float y, int pointer) {
DragAndDrop.Payload payload = new DragAndDrop.Payload();
payload.setDragActor(sourceImage);
dragAndDrop.setDragActorPosition(-x, -y + sourceImage.getHeight());
return payload;
}
public void dragStop (InputEvent event, float x, float y, int pointer, Target target) {
sourceImage.setBounds(50, 125, sourceImage.getWidth(), sourceImage.getHeight());
if(target != null) {
sourceImage.setPosition(target.getActor().getX(), target.getActor().getY());
}
virtualStage.addActor(sourceImage);
}
});

You're not showing any code, so it's hard to know what you are actually doing. Based on your description, it sounds like you are placing the payload at where the cursor is rather than moving it the same offset as the cursor moved since you started dragging.
Assuming you're using an ActorGestureListener, this is what I do in my app.
float touchX, touchY;
public void touchDown(InputEvent ev, float x, float y, int pointer, int button) {
touchX = x;
touchY = y;
...
}
public void pan(InputEvent ev, float x, float y, float dx, float dy) {
moveBy(x - touchX, y - touchY);
...
}
This way you are moving your actor by the same amount as the mouse cursor moved, so it's like the pointer "glued" itself to whereever you touched your actor. Also, I believe the events in libgdx makes it so that you will not receive the pan events until the cursor has moved a bit inside your actor, so be aware of that when testing (moving the cursor a few pixels only will not trigger the pan events).

Drag And Drop LibGDX

I want to make a game where you can build stuff by dragging and dropping objects into place. I think LibGDX only supports DragNDrop on Actors, but I need physics on bricks in order to make them fall down if the construction is not stable.
So far, my approach to drag and drop is:
for(Brick b : map.getList()){
final Image im = new Image(b.ar);
stage.addActor(im);
im.setPosition(b.posX, b.posY);
im.setOrigin(b.posX, b.posY);
im.addListener((new DragListener() {
public void touchDragged (InputEvent event, float x, float y, int pointer) {
im.setOrigin(x, y);
im.setPosition(x, y);
//System.out.println("touchdragged ---> X=" + x + " , Y=" + y);
}
}));
}
where the map.getLists contains all bricks to be painted. b.ar is the texture to be painted.
With this aproach [this] is what happens. I don't know what may be causing it.
#Override
public void render(float delta) {
spritebatch.begin();
map.getWorld().step(1/60f, 6, 2);
renderer.render(map.getWorld(), camera.combined);
if(Gdx.input.justTouched()){
Vector3 touchPoint = new Vector3(Gdx.input.getX(), Gdx.input.getY(),0);
camera.unproject(touchPoint.set(Gdx.input.getX(), Gdx.input.getY(), 0));
System.out.println(touchPoint);
}
stage.draw();
spritebatch.end();
}
Of course i'd like to make the body fell (with the box 2d engine from libgdx) if you drop the object and it has nothing under it.
Thanks in advance

You're setting the origin in your listener callback to a screen coordinate. That is not going to work.
The origin is used to define the "center" of your object, so when you reposition it, Libgdx knows which part of the actor to put where. Generally the origin is either the bottom left corner of the object (I think this is the default) or its the center of the object.
I guess you may want to reset the origin so if someone taps on the left edge of a brick and then you reposition the object you'll reposition that point on the brick (and not reposition the bottom left corner of the brick). To do that you'll need to convert the screen coordinates into coordinates in the actor's space.
That's all somewhat icky though. I think you'd be better off just doing relative repositioning. Instead of trying to position the brick absolutely with setPosition just reposition it relatively:
im.setPosition(im.getX() + dx, im.getY() + dy);
Then it doesn't matter where the "origin" is.
You'll have to compute dx and dy in your listener based on the previous touch point.

It appears that the drag listener gives coordinates relative to the origin of the actor that is raising the event. That is a bit strange when you are moving that actor in response to the drag events, because the origin keeps changing. Essentially, I found that if I just move the actor by the x and y values of the event, it will follow the mouse or finger.
One improvement is to record the position that the drag started at and use it as an offset, so the pointer stays the same distance from the actor's origin.
Another option might be to add the listener to the stage instead of the button. I expect the coordinates would then be relative to the stage's origin, which is not changing. I haven't tried that technique.
Here's the code I used to drag a button horizontally:
DragListener dragListener = new DragListener() {
private float startDragX;
#Override
public void dragStart(
InputEvent event,
float x,
float y,
int pointer) {
startDragX = x;
}
#Override
public void drag(InputEvent event, float x, float y, int pointer) {
insertButton.translate(x - startDragX, 0);
}
};
dragListener.setTapSquareSize(2);
insertButton.addListener(dragListener);
If you want to drag something in two dimensions, just copy the x code for the y position.