Actions des acteurs dans libgdx

Question

J'ai fait mon , mais je ne sais pas comment tirer parti des méthodes action et act. En dehors du Javadoc de base, je n'ai pas trouvé de bons tutoriels sur ces méthodes.

Quelqu'un peut-il donner un exemple avec des commentaires pour des actions sur des acteurs?

Answer 1

Cette réponse est rendue obsolète en raison de changements dans LibGDX. Pour une documentation à jour, voir scene2d wiki page.

Il existe différentes actions disponibles dans LibGDX prêt pour vous. Ils sont dans le paquet com.badlogic.gdx.scenes.scene2d.actions. Je dirais qu'il ya 3 types d'actions:

1. actions d'animation
2. actions composites
3. Autres actions

actions d'animation modifier diverses propriétés de votre acteur, tels que l'emplacement, la rotation, échelle et alpha.Ils sont:

• FadeIn - change alpha de votre acteur de courant alpha 1
• FadeOut acteur - change alpha de votre acteur de l'alpha actuelle de l'acteur à 0
• fadeTo - change alpha de votre acteur de son acteur alpha actuelle à la valeur spécifique
• de MoveBy - déplace votre acteur par quantité spécifique
• MoveTo - déplace votre acteur - emplacement spécifique
• RotateBy - tourne votre acteur par angle spécifique
• rotateTo - tourne votre acteur - angle spécifique
• scaleTo - votre acteur à facteur d'échelle spécifique

actions composites combinent plusieurs actions dans un action, il y a:

• Parallèle - exécuter des actions données en parallèle - toutes les actions à la fois
• séquence - d'exécuter des actions données en séquence - un après l'autre

Autres actions:

• Répéter - Répète action donnée n fois
• Forever - répète une action donnée pour toujours
• retard - Retarde l'exécution de l'action donnée pour une durée spécifique
• Supprimer - Enlève l'acteur donné de l'étape

Chaque action a une méthode statique $ qui crée une instance de cette Action. Exemple de création d'actions d'animation:

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 

Exemple de création séquence d'action plus complexe:

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 
      ); 

actions d'animation vous permettent également de spécifier Interpolator. Il existe différentes implémentations:

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

Interpolateur Javadoc: Interpolateur def ines le taux de changement d'une animation. Cela permet d'accélérer, décélérer les effets d'animation de base (alpha, échelle, translation, rotation) etc. Pour définir interpolateur à votre action:

action.setInterpolator(AccelerateDecelerateInterpolator.$()); 

Lorsque vous avez votre action avec interpolateur prêt, alors vous mettre cette action à votre acteur:

actor.action(yourAction); 

Pour exécuter effectivement toutes les actions définies pour les acteurs sur scène , vous devez appeler stage.act (...) dans votre render:

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

Answer 2

Voici un lien utile pour les utilisations de la classe com.badlogic.gdx.math.Interpolation. Ainsi, par exemple, pour créer une ation moveTo avec un effet vous pouvez simplement utiliser:

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

Si vous définissez vos actions d'importation de classe comme statique (vous devez définir manuellement):

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

Ensuite, vous pouvez utiliser vos actions comme ceci:

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

Answer 3

Vous devriez essayer Universal Tween Engine. Il est facile à utiliser et très puissant ... et fait de la lecture d'animations complexes une promenade dans le parc car toutes les commandes peuvent être enchaînées. Voir les exemples ci-dessous.

Étapes:

1. Télécharger la bibliothèque de here
2. Créer une classe accesor. Vous pouvez enregistrer le temps et saisir celui que j'utilisais de here.
3. Dans votre classe de jeu déclare le TweenManager

public static TweenManager tweenManager; 

Dans la méthode de création:

tweenManager = new TweenManager(); 

Dans la méthode rendre:

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

4. Utilisez-le comme vous le souhaitez. Ex.

Déplacez l'acteur à la position (100, 200) dans 1.5 secondes avec interpolation élastique:

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

créer une séquence complexe d'animations:

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); 

Plus de détails here

MISE À JOUR: lien mort remplacé