Acciones de Actores en libgdx

Question

He hecho mi Actor, pero no estoy seguro de cómo aprovechar los métodos action y act. Fuera del Javadoc básico, no he encontrado buenos tutoriales sobre estos métodos.

¿Alguien puede dar un ejemplo con comentarios para acciones en actores?

Answer 1

Esta respuesta se está volviendo obsoleta debido a cambios en LibGDX. Para obtener documentación actualizada, consulte scene2d wiki page.

Hay varias acciones disponibles en LibGDX listas para usted. Están en el paquete com.badlogic.gdx.scenes.scene2d.actions. Yo diría que hay 3 tipos de acciones:

1. acciones de animación
2. acciones compuestas
3. Otras acciones

acciones de animación modificar varias propiedades de su agente, tales como la ubicación, rotación, escala y alfa.Ellos son:

• FadeIn - cambia alfa de su agente de alfa actual del actor a 1
• FadeOut - cambia alfa de su agente de alfa actual del actor a 0
• fadeTo - cambia alfa de tu actor del actor de alfa actual al valor específico
• moveBy - mueve tu actor por cantidad específica
• MoveTo - mueve tu actor a ubicación específica
• RotateBy - gira a su actor por ángulo específico
• RotateTo - gira a su actor a ángulo específico
• scaleTo - escalas de su actor factor de escala específica

acciones compuestas combinan múltiples acciones en una acción, hay:

• Paralelo - ejecutar acciones dadas en paralelo - todas las acciones a la vez
• Secuencia - ejecutar acciones dadas en secuencia - uno tras otro

Otras acciones:

• Repeat - repetición de la acción dada n-veces
• siempre - repeticiones dada la acción siempre
• retardo - demora la ejecución de una acción determinada por un período de tiempo específico
• Eliminar - elimina el actor dado de la etapa

Cada acción tiene un método estático $ que crea una instancia de esa Acción. Ejemplo de creación de acciones de animación:

MoveTo move = MoveTo.$(200, 200, 0.5f); //move Actor to location (200,200) in 0.5 s 
RotateTo rotate = RotateTo.$(60, 0.5f); //rotate Actor to angle 60 in 0.5 s 

Ejemplo de creación de secuencia de acción más compleja:

Sequence sequence = Sequence.$(
       MoveTo.$(200, 200, 0.5f), //move actor to 200,200 
       RotateTo.$(90, 0.5f),  //rotate actor to 90° 
       FadeOut.$(0.5f),   //fade out actor (change alpha to 0) 
       Remove.$()    //remove actor from stage 
      ); 

acciones de animación también permiten especificar Interpolator. Hay varias implementaciones:

• AccelerateDecelerateInterpolator
• AccelerateInterpolator
• AnticipateInterpolator
• DecelerateInterpolator
• LinearInterpolator
• OvershootInterpolator

interpolador Javadoc: un interpolador def es la tasa de cambio de una animación. Esto permite que los efectos de animación básicos (alfa, escala, traducir, rotar) se aceleren, desaceleren, etc. Para establecer interpolador a su acción:

action.setInterpolator(AccelerateDecelerateInterpolator.$()); 

Cuando usted tiene su acción con interpolador listo, entonces establecer que la acción de tu actor:

actor.action(yourAction); 

Para ejecutar realmente todas las acciones definidas para los actores en el escenario , usted tiene que llamar stage.act (...) en su método render:

stage.act(Gdx.graphics.getDeltaTime()); 
stage.draw(); 

Answer 2

Aquí hay un enlace útil para los usos de la clase com.badlogic.gdx.math.Interpolation. Así, por ejemplo, para crear una ación moveTo con un efecto que podría simplemente utilizar:

myActor.addAction(Actions.moveTo(100, 200, 0.7f, Interpolation.bounceOut)); 

Si establece la importación clase de acciones como estática (hay que ajustarlo manualmente):

import static com.badlogic.gdx.scenes.scene2d.actions.Actions.*; 

luego, puede usar sus acciones de esta manera:

myActor.addAction(moveTo(100, 200, 0.7f, Interpolation.bounceOut)); 

Answer 3

Debe probar Universal Tween Engine. Es fácil de usar y realmente poderoso ... y hace que la lectura de animaciones complejas sea una caminata en el parque porque todos los comandos se pueden encadenar. Ver ejemplos a continuación.

Pasos:

1. Descargar la biblioteca de here
2. crear una clase accesor. Puede guardar el tiempo y tomar el que estaba usando desde here.
3. En su clase de juego declaran la TweenManager

public static TweenManager tweenManager; 

En el crear método:

tweenManager = new TweenManager(); 

En el rendir método:

tweenManager.update(Gdx.graphics.getDeltaTime()); 

4. Utilícelo como lo desee. Ex.

Mueva el actor a la posición (100, 200) en 1.5 segundos con la interpolación elástica:

Tween.to(actor, ActorAccesor.POSITION_XY, 1.5f) 
    .target(100, 200) 
    .ease(Elastic.INOUT) 
    .start(tweenManager); 

crear una secuencia compleja de animaciones:

Timeline.createSequence() 
    // First, set all objects to their initial positions 
    .push(Tween.set(...)) 
    .push(Tween.set(...)) 
    .push(Tween.set(...)) 

    // Wait 1s 
    .pushPause(1.0f) 

    // Move the objects around, one after the other 
    .push(Tween.to(...)) 
    .push(Tween.to(...)) 
    .push(Tween.to(...)) 

    // Then, move the objects around at the same time 
    .beginParallel() 
     .push(Tween.to(...)) 
     .push(Tween.to(...)) 
     .push(Tween.to(...)) 
    .end() 

    // And repeat the whole sequence 2 times 
    .repeatYoyo(2, 0.5f) 

    // Let's go! 
    .start(tweenManager); 

Más detalles here

ACTUALIZACIÓN: reemplazado vínculo roto