matriz com defeito para flipping (reflexão de espelho) um clipe de filme

Question

Atualmente, estou trabalhando em um pouco agradável 2D motor de jogo em AS3. Você pode até carregar em diferentes clipes de filme de flash através de XML para as diferentes animações. Uma das características também permite inverter uma animação quando você executar uma determinada ação. Dessa forma, você pode ter uma animação tanto para esquerda e direita (como sempre). Tenho a transformação de matriz funcionando corretamente; no entanto, eu acho que a minha lógica para virar as coisas e para trás é incorreta. O resultado é que a animação errado vai jogar na hora errada. Eu decidi fazer a animação jogado baseado na velocidade do objeto em movimento, em vez de pressionar a tecla desde que eu tenho elementos de física envolvidos.

Aqui está um link para o jogo em seu estado atual: http://parrisstudios.com/Game_Design/ gameEngineDemo /

A questão é principalmente que as animações jogar em horários incorretos, ou não jogar quando deveriam.

Aqui está o meu código para o flipping (deixe-me saber o que vocês pensam): ps: a variável de direção é o último sentido o personagem está enfrentando (esquerda ou direita, neste caso, é descrito mais tarde no código)

private function drawJumpMode():void {
        var change:Boolean = false;
        //decide whether to swap graphics or continue playing

        if (Math.abs(particleGroup.particles[0].velocity.y) < epsilon && Math.abs(particleGroup.particles[0].velocity.x) < epsilon && direction == "right") {
            if (lastClipAction != "stillRight"){ 
                lastClipAction = "stillRight";
                change = true;
            }
        }
        else if (Math.abs(particleGroup.particles[0].velocity.y) < epsilon && Math.abs(particleGroup.particles[0].velocity.x) < epsilon && direction == "left") {
            if (lastClipAction != "stillLeft"){ 
                lastClipAction = "stillLeft";
                change = true;
            }
        }
        else if (particleGroup.particles[0].velocity.y > 0 && Math.abs(particleGroup.particles[0].velocity.x) < epsilon) {
            if (lastClipAction != "down"){ 
                lastClipAction = "down";
                change = true;
            }
        }
        else if (particleGroup.particles[0].velocity.y < 0 && Math.abs(particleGroup.particles[0].velocity.x) < epsilon) {
            if (lastClipAction != "up"){ 
                lastClipAction = "up";
                change = true;
            }
        }
        else if (particleGroup.particles[0].velocity.x > 0) {
            if (lastClipAction != "right") {
                lastClipAction = "right";
                direction = "right";
                change = true;              
            }
        }
        else if (particleGroup.particles[0].velocity.x < 0) {
            if (lastClipAction != "left"){ 
                lastClipAction = "left";
                direction = "left";
                change = true;
            }
        }

        //If the movie clip has changed, swap the old one back into the all clips library and get the new one.
        if (change) {
            //set flip to false whenever there is a change in movie clip
            flipped = false;
            //if the movie clip was flipped before, this should flip it
                            //back to normal
            flip();
                            //remove movie clip from the scene
            game.removeChild(playingMovieClip);
                            //check it back into the movie clip library
            allClips.addChild(playingMovieClip);
                            //add the movie clip into the scene
            playingMovieClip = MovieClip(allClips.getChildByName(actionToClip[lastClipAction + "Name"]));
            game.addChild(playingMovieClip);
        }

        //Flip if needed
        flip();

        //set it to true so that it won't be constantly flipped.
        flipped = true;

        //set movie clip to be center over the main particle
        playingMovieClip.x = particleGroup.particles[0].center.x;
        playingMovieClip.y = particleGroup.particles[0].center.y;
    }
private function flip():void {
        //If a transformation is required, then do so
        if (actionToClip[lastClipAction + "H"]=="1" && !flipped){
            flipHorizontal(playingMovieClip);
        }
        if (actionToClip[lastClipAction + "V"]=="1" && !flipped){
            flipVertical(playingMovieClip);
        }
    }

Answer 1

Eu acredito que o código em questão está aqui.

            //If the movie clip has changed, swap the old one back into the all clips library and get the new one.
            if (change) {
                    //set flip to false whenever there is a change in movie clip
                    flipped = false;
                    //if the movie clip was flipped before, this should flip it
                        //back to normal
                    flip();
                        //remove movie clip from the scene
                    game.removeChild(playingMovieClip);
                        //check it back into the movie clip library
                    allClips.addChild(playingMovieClip);
                        //add the movie clip into the scene
                    playingMovieClip = MovieClip(allClips.getChildByName(actionToClip[lastClipAction + "Name"]));
                    game.addChild(playingMovieClip);
            }

            //Flip if needed
            flip();

O problema é que você está fazendo um duplo aleta aqui. Isso funciona encontrar se você está de fato mudando clipes a mudança. Por exemplo, se você vai de correr direito para a direita em pé. Ele dá errado quando você vai de correr direito de correndo da esquerda. Uma vez que eles são o mesmo clipe apenas capotou você acaba fazendo dois flips nesta situação. Isso faz com que o comportamento moonwalk: -).

Eu sugeriria limpar essa lógica e fornecer uma maneira de redefinir a inversão. Em vez de virar para a orientação original, volta redefinir a ele para que possa garantir o estado do grampo.