libGDX 1.4.1无法减慢动画速度

时间:2014-11-11 21:13:34

标签: libgdx

这就是我所拥有的:

...
private Array<Sprite> fireballFadeOutAnim;
private Array<Sprite> bucketFadeOutAnim;
private TextureAtlas fballAnimSheet;
private TextureAtlas bucketAnimSheet;
private Animation catch_animation;
private Animation visual_feedback;
private float elapsedTime = 0f;

...

@Override
public void create () {

    ...
    fballAnimSheet = new TextureAtlas("animations/fireball_fadeout.txt");
    bucketAnimSheet = new TextureAtlas("animations/bucket_fadeout.txt");
    fireballFadeOutAnim = fballAnimSheet.createSprites("fireball_fadeout");
    bucketFadeOutAnim = bucketAnimSheet.createSprites("bucket_fadeout");

    catch_animation = new Animation(1/15f, fballAnimSheet.getRegions(), Animation.PlayMode.NORMAL);
    visual_feedback = new Animation(1/15f, bucketAnimSheet.getRegions(), Animation.PlayMode.LOOP);

    ...
}

@Override
public void render () {    

    ...
    // Set the anim_elipsed_time
    elapsedTime += Gdx.graphics.getDeltaTime();

    ...
    // I try to draw them later on (under the render method) like this:
    // Start and draw animation of fireball catch
    batch.begin();

    batch.draw(catch_animation.getKeyFrame(elapsedTime, true), fireBallRect.getX(), fireBallRect.getY());
    batch.end();
}

我可以看到两个动画发生得非常快(它们看起来像白色闪光灯),即使动画模式设置为&#34; LOOP&#34;它们也不会循环播放。

我做错了什么?我似乎无法放慢速度或让它们循环。非常感谢。

编辑:

根据要求,我上传了所有代码

public class MainActivity extends ApplicationAdapter {

    public enum State {
        PAUSE,
        RUN,
        RESUME,
        STOPPED
    }
    public static State state = State.RUN;

    private SpriteBatch batch;
    private OrthographicCamera camera;
    private Stage stage;
    private Texture backgroundImage;
    private Texture bucketImage;
    private Texture fireballImage;
    private Texture heart;
    private TextureRegion criticalTexture;
    private Sprite backgroundSprit;
    private Sprite bucketSprite;
    private Sprite fireballSprite;
    private Sprite heartSprite;
    private Rectangle bucketRect;
    private Rectangle fireBallRect;
    private Rectangle bucketSpriteRect;
    private ShapeRenderer bucketRenderer;
    private ShapeRenderer fireballRenderer;
    private Button pauseButton;
    private Array<Rectangle> fireballArray;
    private Skin progressBarSkin;
    private long lastFireballTime;
    public static Sound bucket_tap;
    public static Sound bucket_drag;
    private Sound fireball_missed_sound;
    private Sound catchFireball;
    private Sound pauseBtnSound;
    private Music bgMusic;
    private float volume = 0.30f;                // music and sfx volume control
    public static int w;
    public static int h;
    private int barLength = 325;
    private int numberOfFails = 10;               // change numberOfFails to increase or decrese
                                                  // the total num. of missed fireballs the player
    private int deductedBarSegment = barLength / numberOfFails;

    private int numOfBallsLeft = numberOfFails;   // use this var to check how many fballs left

    private long fireballFrequency = 1000000000L; // change fireballFrequency to increase or decrease
                                                  // the number of fireballs on the screen

    private int fireballSpeed = 400;              // change the fireballSpeed to increase or decrease
                                                  // the speed at which the fireballs fall

    private InputProcessor gameInputProcessor;    // this sets the game input controller for the bucket
    private InputMultiplexer multiplexer;         // this sets the input processors from the game and UI

    /************************************ Animation Properties ************************************/

    private TextureAtlas fballAtlas;
    private TextureAtlas bucketAtlas;
    private Animation catch_animation;
    private Animation visual_feedback;
    private float elapsedTime = 0f;
    private Actor feedbackPanel;

    /**********************************************************************************************/


    @Override
    public void create () {

        // Parse Test
        //ParseObject testObject = new ParseObject("TestObject");
        //testObject.put("foo", "bar");
        //testObject.saveInBackground();

        // Catch the dynamic size of the screen based on the device that's ran on
        w = Gdx.graphics.getWidth();
        h = Gdx.graphics.getHeight();

        // Set up the camera
        camera = new OrthographicCamera();
        camera.setToOrtho(false, (float)w, (float)h);

        // Instantiate the batch
        batch = new SpriteBatch();

/***************************** These renders are for debugging only *****************************/

        bucketRenderer = new ShapeRenderer();
        fireballRenderer = new ShapeRenderer();

/**************************************************************************************************/

/******************************************** Stage and HUD ***************************************/

        stage = new Stage();

        pauseButton = new Button(new TextureRegionDrawable(
                new TextureRegion(new Texture(Gdx.files.internal("images/pase_button_red.png")))),
                new TextureRegionDrawable(new TextureRegion(new Texture(Gdx.files.internal("images/pase_button_white.png")))));
        pauseButton.setX(flipCoordinates(w, 150));
        pauseButton.setY(flipCoordinates(h, 170));

        pauseButton.act(Gdx.graphics.getDeltaTime());

        stage.addActor(pauseButton);

        pauseButton.addListener(new ChangeListener() {
            @Override
            public void changed (ChangeEvent event, Actor actor) {

                // Do something when the pauseButton is pressed
                // Control multiple touches on the pauseButton
                if(state == State.RUN) {

                    state = State.PAUSE;
                    pauseBtnSound.play();

                    // Set the pauseButton icon to the white version
                    //pauseButton.setColor(Color.WHITE);
                }
                else {
                    state = State.RUN;
                    pauseBtnSound.play();
                }

            }
        });

        // Add the critical_life indicator to the stage as an actor
        criticalTexture = new TextureRegion(new Texture(Gdx.files.internal("images/critical_life.png")));

        feedbackPanel = new Actor() {

            public void draw(Batch batch, float alpha) {

                batch.draw(criticalTexture, getX(), getY(), getOriginX(), getOriginY(), getWidth(), getHeight(),
                        getScaleX(), getScaleY(), getRotation());

            }

        };

        feedbackPanel.setBounds(w / 2, h / 2,
                criticalTexture.getRegionWidth(), criticalTexture.getRegionHeight());

        // Set up an Action for the critical life actor


        feedbackPanel.addAction(forever(sequence(scaleTo(2, 2, 0.5f), scaleTo(1, 1, 0.5f), delay(0.5f))));

        feedbackPanel.act(Gdx.graphics.getDeltaTime());
        stage.addActor(feedbackPanel);



/**************************************************************************************************/

/*********************************** Set up the Input Controllers *********************************/

        // The multiplexer helps target several input processes (in this case, the stage and the
        // InputProcessor.class)

        multiplexer = new InputMultiplexer();
        multiplexer.addProcessor(stage);
        multiplexer.addProcessor(new GameInputProcessor());

        // InputAdaptor
        Gdx.input.setInputProcessor(multiplexer);

/**************************************************************************************************/
        backgroundImage = new Texture("images/bg.jpg");
        bucketImage = new Texture("images/bucket_small.png");
        fireballImage = new Texture("images/fireball_small.png");
        heart = new Texture("images/heart.png");

/*************************************** Animations Setup *****************************************/

        fballAtlas = new TextureAtlas("animations/fireball_fadeout.txt");
        bucketAtlas = new TextureAtlas("animations/bucket_fadeout.txt");

        catch_animation = new Animation(0.50f, fballAtlas.getRegions());
        visual_feedback = new Animation(0.15f, bucketAtlas.getRegions());


/**************************************************************************************************/

        // Instantiate all sounds
        bucket_tap = Gdx.audio.newSound(Gdx.files.internal("sounds/bucket_tap.ogg"));
        bucket_drag = Gdx.audio.newSound(Gdx.files.internal("sounds/bucket_drag.ogg"));
        fireball_missed_sound = Gdx.audio.newSound(Gdx.files.internal("sounds/fireball_missed.ogg"));
        catchFireball = Gdx.audio.newSound(Gdx.files.internal("sounds/fastSteam.ogg"));
        pauseBtnSound = Gdx.audio.newSound(Gdx.files.internal("sounds/pauseBtn_sound.ogg"));
        bgMusic = Gdx.audio.newMusic(Gdx.files.internal("sounds/music_bg.mp3"));
        bgMusic.setLooping(true);
        bgMusic.play();   //                  <----------- turn bg music on/off

        // Instantiate the progressBarSkin
        progressBarSkin = new Skin();
        progressBarSkin.add("progressBarBg", new Texture("images/progress-bar_bg.png"));
        progressBarSkin.add("progressBar", new Texture("images/progress-bar_dynamic_red.png"));


        // Create bg sprite
        backgroundSprit = new Sprite(backgroundImage);
        //backgroundSprit.setPosition((float)w / 2, (float)h / 2);
        //backgroundSprit.setSize((float)w, (float)h);

        // Bucket sprite
        bucketSprite = new Sprite(bucketImage);

        // Fireball sprite
        fireballSprite = new Sprite(fireballImage);

        // Heart sprite
        heartSprite = new Sprite(heart);

        // Set the bucketRect into the rect from the bucketSprite (THE GREEN ONE)
        bucketSpriteRect = bucketSprite.getBoundingRectangle();
        bucketSpriteRect.x = w / 2 - 100 / 2;
        bucketSpriteRect.y = 20;
        bucketSpriteRect.setSize(200, 200);

        // Set the collision rectangle (THE RED ONE)
        bucketRect = new Rectangle();
        bucketRect.x = bucketSpriteRect.getX() + 70;   // <---- adjust position left/right
        bucketRect.y = bucketSpriteRect.getY() + 150;  // <---- adjust position up/down
        bucketRect.setSize(100, 10);

        // Set a rectangle for each fireball sprite (THE WHITE ONE)
        fireBallRect = new Rectangle();
        fireBallRect.x = fireballSprite.getX();
        fireBallRect.y = fireballSprite.getY();
        fireBallRect.width = 55;
        fireBallRect.height = 55;

        fireballArray = new Array<Rectangle>();

    }

    @Override
    public void render () {

        // Devide the Render method into a few switch cases based on the game's state
        switch (state) {

            case RUN:

                // Do all the batch drawing here
                Gdx.gl.glClearColor(1, 1, 1, 1);
                Gdx.gl.glClear(GL20.GL_COLOR_BUFFER_BIT);
                elipsedTime += Gdx.graphics.getDeltaTime();

                batch.setProjectionMatrix(camera.combined);
                batch.begin();
                batch.draw(backgroundSprit, 0, 0, w, h);
                batch.draw(bucketSprite, bucketSpriteRect.x, bucketSpriteRect.y,
                        bucketSprite.getWidth() - 160, bucketSprite.getHeight() - 140);

                for(Rectangle fireball: fireballArray) {
                    batch.draw(fireballSprite, fireball.x, fireball.y,
                            fireballSprite.getWidth() - 20, fireballSprite.getHeight() - 20);
                }

                batch.draw(progressBarSkin.getSprite("progressBarBg"), 200, flipCoordinates(h, 170));
                batch.draw(progressBarSkin.getSprite("progressBar"),
                        210, flipCoordinates(h, 162), barLength, 6); // <---- modify x, x, <x>, x to adjust the length of the life-bar
                batch.draw(heartSprite, 95, flipCoordinates(h, 200), 90, 76);

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


                batch.end();

/***************************************Debugging Rectangles************************************/
                // Draw rects around sprites

//        bucketRenderer.begin(ShapeRenderer.ShapeType.Line);
//        bucketRenderer.setColor(Color.GREEN);
//        bucketRenderer.rect(bucketSpriteRect.getX(), bucketSpriteRect.getY(),
//                bucketSprite.getWidth() - 160, bucketSprite.getHeight() -140);
//        bucketRenderer.end();
//
//        bucketRenderer.begin(ShapeRenderer.ShapeType.Line);
//        bucketRenderer.setColor(Color.RED);
//        bucketRenderer.rect(bucketRect.getX(), bucketRect.getY(), 100, 10);
//        //bucketRenderer.point(bucketRect.getX(), bucketRect.getY(), 0f);
//        bucketRenderer.end();
//
//        fireballRenderer.begin(ShapeRenderer.ShapeType.Line);
//        fireballRenderer.setColor(Color.WHITE);
//        fireballRenderer.rect(fireBallRect.x, fireBallRect.y,
//                fireballSprite.getWidth() - 20, fireballSprite.getHeight() - 20);
//        fireballRenderer.end();

                // To avoid sprite flickering, surround batch.draw with a game state check
                if (state != State.PAUSE) {

                    Iterator<Rectangle> iter = fireballArray.iterator();
                    while(iter.hasNext()) {
                        fireBallRect = iter.next();
                        fireBallRect.y -= fireballSpeed * Gdx.graphics.getDeltaTime();

                        // Remove the fireBallRect from the array as soon as it leaves the screen
                        if(fireBallRect.y + 106 < 0) {
                            iter.remove();

                            // The player missed the fireball, play a the fireball_missed_sound
                            fireball_missed_sound.play();

                            // Subtract a ball from the total number allowed to be missed
                            numOfBallsLeft --;

                            // Call life deduction
                            deductLifePoints();

                            // Check to see if this is the last fball left to fail
                            if (numOfBallsLeft == 1) {


                            }

                            // Check to see if life points are 0 or < 0
                            if (numOfBallsLeft <= 0) {

                                // Game over logic
                                barLength = 0;

                                // Set the game state to PAUSED
                                //state = State.PAUSE;
                                //bucketSprite.setColor(Color.RED);
                                batch.begin();
                                batch.draw(bucketSprite, bucketSpriteRect.x, bucketSpriteRect.y,
                                        bucketSprite.getWidth() - 160, bucketSprite.getHeight() - 140);
                                batch.end();
                            }
                        }

                        // Collision detector
                        if(bucketRect.overlaps(fireBallRect)) {

                            catchFireball.play(volume);

                            // Start and draw animagion of fireball catch
                            batch.begin();

                            batch.draw(catch_animation.getKeyFrame(elapsedTime, true), fireBallRect.getX(), fireBallRect.getY());
                            batch.end();

                            // Remove the fireball that collides with the bucket
                            iter.remove();
                        }

                    }

                }

                // Touch input controller
                if(Gdx.input.isTouched()) {
                    Vector3 touchPos = new Vector3();
                    touchPos.set(Gdx.input.getX(), Gdx.input.getY(), 0);
                    camera.unproject(touchPos);

                    if(touchPos.y <= 250) {

                        bucketSpriteRect.setX(touchPos.x - 115);
                        bucketRect.setX(touchPos.x - 50);  // <---- adjust position left/right on touch

                    }


                }

                if(TimeUtils.nanoTime() - lastFireballTime > fireballFrequency) {

                    fireBallRect = new Rectangle();
                    fireBallRect.x = MathUtils.random(50, w - 270);
                    fireBallRect.y = h;
                    fireBallRect.width = 75;
                    fireBallRect.height = 75;
                    fireballArray.add(fireBallRect);
                    lastFireballTime = TimeUtils.nanoTime();

                }

/**************************************************************************************************/
                break;
            case PAUSE:

                // Pause the game here
/******************************** Redraw the sprites to avoid flickering **************************/

                batch.begin();
                batch.draw(backgroundSprit, 0, 0, w, h);
                batch.draw(bucketSprite, bucketSpriteRect.x, bucketSpriteRect.y,
                        bucketSprite.getWidth() - 160, bucketSprite.getHeight() - 140);

                for(Rectangle fireball: fireballArray) {
                    batch.draw(fireballSprite, fireball.x, fireball.y,
                            fireballSprite.getWidth() - 20, fireballSprite.getHeight() - 20);
                }

                batch.draw(progressBarSkin.getSprite("progressBarBg"), 200, flipCoordinates(h, 170));
                batch.draw(progressBarSkin.getSprite("progressBar"),
                        210, flipCoordinates(h, 162), barLength, 6); // <---- modify x, x, <x>, x to adjust the length of the life-bar
                batch.draw(heartSprite, 95, flipCoordinates(h, 200), 90, 76);
                //pauseButton.draw(batch, 1);
                stage.act(Gdx.graphics.getDeltaTime());
                stage.draw();

                batch.end();

/**************************************************************************************************/

                break;
            case RESUME:

                break;
            default:

                break;
        }

    }

    /************************************* Implement Dispose **************************************/
    @Override
    public void dispose() {

        batch.dispose();
        bucketRenderer.dispose();
        fireballRenderer.dispose();
        backgroundImage.dispose();
        bucketImage.dispose();
        fireballImage.dispose();
        bucket_tap.dispose();
        bucket_drag.dispose();
        catchFireball.dispose();
        bgMusic.dispose();
        fireball_missed_sound.dispose();
        progressBarSkin.dispose();
        fballAtlas.dispose();
        stage.dispose();


    }

    /************************************* Flip Coordinates Method ********************************/

    public static float flipCoordinates(float height, float xORy) {

        float newPosition = height - xORy;
        return newPosition;
    }

    /************************************** Deduces Life Points ***********************************/
    private void deductLifePoints() {

        barLength -= deductedBarSegment;
    }

    /************************************** Set the Game's state **********************************/
    public void setGameState(State s) {

        this.state = s;
    }

    /******************************** Android's Lyfe-Cycle Overrides ******************************/
    @Override
    public void pause() {

        super.pause();
        this.state = State.PAUSE;

    }

    @Override
    public void resume() {

        super.resume();
        this.state = State.PAUSE;
    }
}

1 个答案:

答案 0 :(得分:0)

Animation构造函数的第一个参数是frameDuration,以秒为单位。你传递的是1/15f,这真的很快。尝试更大的内容,例如0.15f