En feuilletant un Sprite 2D Animation en Unity 2D

J'ai une petite question concernant Sprite 2D animations que je n'ai pas été en mesure de trouver spécifiquement répondu n'importe où:

J'ai un sprite avec la marche des animations du droit. Cependant, j'ai évidemment envie de retourner à l'animation de la gauche quand il marche à gauche (2D side-scroller).

Je peux facilement flip le sprite lui-même, à l'aide de transform.localscale.x, cependant, que seulement les flips le sprite. Pas le clip d'animation. (Ça ne se fait plus dans l'Unité)

Ainsi, alors que le sprite flips, la minute, le clip d'animation commence à jouer, il bascule en arrière à droite (comme le seul clip d'animation que j'ai est pour la bonne face de sprite).

Est la seule façon de le faire pour inverser les sprites dans Photoshop, ou est-il un moyen de le faire dans l'Unité?

Merci!

Mise à JOUR: Avec l'actuelle version de l'unité si vous mettez à l'échelle de la transformer en la multipliant par -1, les images de l'animation sont également mis à l'échelle.

OriginalL'auteur Jestus | 2014-10-26

2d animation c#sprite unity3d

J'ai enfin compris ce faisant:

void Flip()
{
    //Switch the way the player is labelled as facing
    facingRight = !facingRight;

    //Multiply the player's x local scale by -1
    Vector3 theScale = transform.localScale;
    theScale.x *= -1;
    transform.localScale = theScale;
}

C'est à partir de l'Unité de Plateforme 2D exemple.

De mettre en œuvre une sorte de vérifier ce qui rend l'utilisation de la Flip méthode, vous pouvez faire quelque chose de similaire à l'exemple ci-dessous qui est la base du mouvement du code. facingRight est définie comme une valeur de la classe de sorte que les autres méthodes peuvent l'utiliser, et par défaut, c'est false.

void Update() 
{

    //On X axis: -1f is left, 1f is right

    //Player Movement. Check for horizontal movement
    if (Input.GetAxisRaw ("Horizontal") > 0.5f || Input.GetAxisRaw("Horizontal") < -0.5f) 
    {
        transform.Translate (new Vector3 (Input.GetAxisRaw ("Horizontal") * moveSpeed * Time.deltaTime, 0f, 0f));
        if (Input.GetAxisRaw ("Horizontal") > 0.5f && !facingRight) 
        {
            //If we're moving right but not facing right, flip the sprite and set     facingRight to true.
            Flip ();
            facingRight = true;
        } else if (Input.GetAxisRaw("Horizontal") < 0.5f && facingRight) 
        {
            //If we're moving left but not facing left, flip the sprite and set facingRight to false.
            Flip ();
            facingRight = false;
        }

    //If we're not moving horizontally, check for vertical movement. The "else if" stops diagonal movement. Change to "if" to allow diagonal movement.
    } else if (Input.GetAxisRaw ("Vertical") > 0.5f || Input.GetAxisRaw("Vertical") < -0.5f) 
    {
        transform.Translate (new Vector3 (0f, Input.GetAxisRaw ("Vertical") * moveSpeed * Time.deltaTime, 0f));
    }

    //Variables for the animator to use as params
    anim.SetFloat ("MoveX", Input.GetAxisRaw ("Horizontal"));
    anim.SetFloat ("MoveY", Input.GetAxisRaw ("Vertical"));

}

J'ai édité dans un ajout tardif à cette réponse utile à qui j'ai mis en place, qui est de faire une vérification lorsque la touche est enfoncée pour déterminer si le sprite doit être retourné ou pas.
le changement est si grand, vous devriez probablement faire une autre réponse.
devrais-je? J'étais vraiment seul bâtiment sur Jestus " réponse en fournissant un peu de code de base pour montrer comment la méthode peut être mise en œuvre. Si vous avez encore le dire, puis je vais revenir à l'édition et l'affichage de mon propre réponse.
ainsi, la modification est approuvée, de sorte qu'il est vraiment votre choix ce point.

OriginalL'auteur Jestus

2
```
void FlipHorizontal()
{
    animator.transform.Rotate(0, 180, 0);
}
```
Vous pourriez aussi le faire sur se transformer lui-même (sans animateur). Mais dans ce cas, la rotation de la valeur peut être remplacé par l'animateur

Je pense que la syntaxe est animator.transform.Rotate(new Vector3(0, 180, 0));

OriginalL'auteur Deepscorn

C'est la façon dont je l'ai fait presque le même que l'autre technique par Jestus avec l'unité de script.

var facing : String = "right";

function updateFacing(curr : String){
    if(curr != facing){
        facing = curr;
        var theScale : Vector3 = gameObject.transform.localScale;
        theScale.x *= -1;
        gameObject.transform.localScale = theScale;
    }
}

//put to use
function controls(){
    if(Input.GetKey (KeyCode.LeftArrow)){
        updateFacing("left");
    } else if(Input.GetKey (KeyCode.RightArrow)){
        updateFacing("right");
    }      
}

OriginalL'auteur Nick Taras

0

Si vous êtes l'animation dans l'Unité:
1. Copie de toutes les images (sprites) de l'animation que vous souhaitez inverser.
2. Coller les images dans votre nouvelle animation et tout sélectionner sur la première image.
3. Modifier l'échelle en x de la première frame de 1 à -1.
4. Faire la même chose avec la dernière image de votre animation.
Maintenant, il devrait jouer en face de l'autre sens!

Courtoisie de EduLopez a suggéré de modifier (qui devrait avoir été posté en commentaire ou alt sna): "Vous pouvez aussi avoir une animation de marche à gauche et ont une fonction uniquement pour faire face à votre sprite. Selon si isFscingRight == true, l'échelle en x sera de 1 ou de -1)"
Ses une bonne réponse. Un autre moyen de le faire dans l'animation de la gui de vue. Ne doivent pas être une réponse négative....

OriginalL'auteur Mickey Ugolini

C'est mon C# de mise en œuvre. Il utilise une chaîne de caractères comme la direction face à la rendre un peu plus facile à déboguer.

public string facing = "right";
public string previousFacing;

private void Awake()
{
    previousFacing = facing;
}

void Update()
{
    //store movement from horizontal axis of controller
    Vector2 move = Vector2.zero;
    move.x = Input.GetAxis("Horizontal");
    //call function
    DetermineFacing(move);
}
//determine direction of character
void DetermineFacing(Vector2 move)
{
    if (move.x < -0.01f)
    {
        facing = "left";
    }
    else if (move.x > 0.01f)
    {
        facing = "right";
    }
    //if there is a change in direction
    if (previousFacing != facing)
    {
        //update direction
        previousFacing = facing;
        //change transform
        gameObject.transform.Rotate(0, 180, 0);
    }
}

OriginalL'auteur ow3n

Vous devez vous connecter pour publier un commentaire.