The first thing that we have to do is register our custom accessor in the Tween Engine and here is where the core class, Tween, comes into action:

Tween.registerAccessor(Actor.class, new ActorAccessor());

However, this is not its only mission because, as its name says, you will have to make use of it each time an interpolation is required. There are different types of tweens:

The previous explanation constantly refers to the target values, which can be specified like this:

Tween.from(…).target(x,y);

In addition to the absolute target float numbers, you can also provide values relative to the current ones:

Tween.to(…).targetRelative(x,y);

Besides the end values, you can lead the way that the interpolation should take by supplying waypoints. However, take into account that you must inform in advance about the number of waypoints in order to allocate some extra memory through the following static method:

Tween.setWaypointsLimit(10);

Waypoints usage keeps the same chaining dynamic:

Tween.to(group, ActorAccessor.SCALE_XY, 0.6f).waypoint(1.6f, 0.4f).target(1.2f, 1.2f).ease(Cubic.OUT)

That is not all since you can still customize your Tween a little bit more with the following methods:

The Tween class building works by chaining these methods one after the other. For instance, to fade in a Scene2D Label object during half a second:

Tween.to(label, ActorAccessor.OPACITY, .5f).target(1).ease(Quad.OUT)

We already have the tools to animate our objects through the Tween class but we will need to organize our code a little bit instead of placing delays everywhere. With the aim of achieving this, you can create Timeline instances that are composed of two control structures:

The way to insert tweens to them is by chaining the push () methods, for instance:

Timeline t = Timeline.createSequence()
.push(
Tween.set(label1, ActorAccessor.OPACITY).target(1))
.beginParallel()
   .push(
Tween.to(label1, ActorAccessor.POS_XY, 1.25f).targetRelative(0, -340).ease(Quart.OUT))
   .push(
Tween.to(label2, ActorAccessor.POS_XY, 1.25f).targetRelative(0, 340).ease(Quart.OUT))
.end()
.beginSequence()
   .push(
Tween.to(label1, ActorAccessor.OPACITY, .2f).target(0).ease(Quad.OUT))
   .push(
Tween.to(label2, ActorAccessor.OPACITY, 2f).target(0).ease(Cubic.IN))
.end()

The preceding code will start by immediately setting label1 opaque. Then, label1 and label2 will concurrently move to a relative target. Finally, both labels will fade out.

You can add pause times:

.pushPause(.5f);

Also, you can recycle some of the already explained methods, setCallback(…), delay(), repeat(…), repeatYoyo(…) and some new others to control Timeline such as pause(), resume(), and start().

Managing timelines individually can be a little messy because you will have to update each of them at the right moment. Fortunately, TweenManager comes to your rescue and takes absolute responsibility of Tween and Timeline life cycles. All we have to do is instantiate it, let it know about the existence of new timelines, and update them all as follows:

TweenManager manager = new TweenManager();

Timeline.createSequence()
...
.start(manager);

manager.update(Gdx.graphics.getDeltaTime()); //Must be called every render call

Now you should have a decent understanding about the Universal Tween Engine. However, its API is very extended, so feel free to take a look at the official documentation if you want to dive into some extra methods.