Example #1
0
  private void onExit(
      final Screen screen, TextButton buttonPlay, TextButton buttonCredits, TextButton buttonExit) {

    Tween.set(buttonPlay, ActorAccessor.ALPHA)
        .target(buttonPlay.getColor().a)
        .start(getTweenManager());
    Tween.to(buttonPlay, ActorAccessor.ALPHA, 0.5f).target(0).delay(0.2f).start(getTweenManager());
    Tween.set(buttonCredits, ActorAccessor.ALPHA)
        .target(buttonCredits.getColor().a)
        .start(getTweenManager());
    Tween.to(buttonCredits, ActorAccessor.ALPHA, 0.5f)
        .target(0)
        .delay(0.1f)
        .start(getTweenManager());
    Tween.set(buttonExit, ActorAccessor.ALPHA)
        .target(buttonExit.getColor().a)
        .start(getTweenManager());
    Tween.to(buttonExit, ActorAccessor.ALPHA, 0.5f)
        .target(0)
        .setCallback(
            new TweenCallback() {

              @Override
              public void onEvent(int type, BaseTween<?> source) {
                getGame().setScreen(screen);
              }
            })
        .start(getTweenManager());
  }
Example #2
0
  @Override
  public void show() {
    super.show();

    table = new Table();
    table.setFillParent(true);

    TextButtonStyle bStyle = new TextButtonStyle();
    bStyle.font = Cache.getFont(48);
    bStyle.fontColor = Color.LIGHT_GRAY;
    final TextButton buttonPlay = new TextButton("PLAY", bStyle);

    buttonPlay.pad(20);
    table.add(buttonPlay);

    table.row();
    final TextButton buttonCredits = new TextButton("CREDITS", bStyle);

    buttonCredits.pad(20);
    table.add(buttonCredits);
    table.row();
    final TextButton buttonExit = new TextButton("EXIT", bStyle);

    buttonExit.pad(20);
    table.add(buttonExit);
    table.pad(150, 0, 0, 0);
    getStage().addActor(table);

    buttonPlay.addListener(
        new ClickListener() {
          @Override
          public void clicked(InputEvent event, float x, float y) {
            onExit(new LevelSelect(getGame()), buttonPlay, buttonCredits, buttonExit);
          }
        });
    buttonCredits.addListener(
        new ClickListener() {
          @Override
          public void clicked(InputEvent event, float x, float y) {
            onExit(new Credits(getGame()), buttonPlay, buttonCredits, buttonExit);
          }
        });
    buttonExit.addListener(
        new ClickListener() {
          @Override
          public void clicked(InputEvent event, float x, float y) {
            Gdx.app.exit();
          }
        });
    Tween.set(buttonPlay, ActorAccessor.ALPHA).target(0).start(getTweenManager());
    Tween.to(buttonPlay, ActorAccessor.ALPHA, 1).target(1).start(getTweenManager());
    Tween.set(buttonCredits, ActorAccessor.ALPHA).target(0).start(getTweenManager());
    Tween.to(buttonCredits, ActorAccessor.ALPHA, 1).target(1).delay(0.1f).start(getTweenManager());
    Tween.set(buttonExit, ActorAccessor.ALPHA).target(0).start(getTweenManager());
    Tween.to(buttonExit, ActorAccessor.ALPHA, 1).target(1).delay(0.2f).start(getTweenManager());

    Gdx.input.setInputProcessor(new InputMultiplexer(getStage(), new TouchDetector(this)));
  }
Example #3
0
 @Override
 public void fadeOut() {
   Tween.to(Launcher.instance().editorScreen.leftPaneBlocker, BlockerTweenAccessor.ALPHA, .3f)
       .target(0)
       .ease(Linear.INOUT)
       .start(tweenManager);
   Tween.to(Launcher.instance().editorScreen.rightPaneBlocker, BlockerTweenAccessor.ALPHA, .3f)
       .target(0)
       .ease(Linear.INOUT)
       .start(tweenManager);
   super.fadeOut();
 }
  private void executeCommand() {
    switch (struct.command) {
      case SET_VISIBLE:
        if (struct.animation != null) struct.animation.setVisible(struct.visible);
        else struct.button.setVisible(struct.visible);
        break;
      case SET_MOVEMENT:
        struct.animation.setMovement(struct.movement, struct.loopFor);
        struct.animation.setCurrentFrame(struct.startFrame);
        break;
      case SET_POSITION:
        struct.animation.setPosition(struct.x, struct.y);
        break;
      case SET_SCALE:
        struct.animation.setScale(struct.scale);
        break;
      case SET_HEALTH:
        target.setHealth(target.getHealth() - struct.damage);
        break;
      case MOVE_TO:
        Tween.to(struct.animation.getGroup(), GroupAccessor.POS_XY, struct.duration)
            .ease(Linear.INOUT)
            .target(struct.x, struct.y)
            .start(manager);
        break;
      case MOVE_TO_TARGET:
        Tween.to(struct.animation.getGroup(), GroupAccessor.POS_XY, struct.duration)
            .ease(Linear.INOUT)
            .target(
                target.getBasePosX()
                    + ((target instanceof EnemyEntity)
                        ? -struct.animation.getWidth()
                        : target.getAnimation().getWidth()),
                target.getBasePosY())
            .start(manager);
        break;
      case MOVE_TO_BASE:
        Tween.to(struct.animation.getGroup(), GroupAccessor.POS_XY, struct.duration)
            .ease(Linear.INOUT)
            .target(caster.getBasePosX(), caster.getBasePosY())
            .start(manager);
        break;
      case POSITION_TO_TARGET:
        struct.animation.setPosition(
            target.getBasePosX() + struct.x, target.getBasePosY() + struct.y);
        break;
      case FLIP:
        struct.animation.flipAnimation(true, false);
        break;
    }

    index++;
  }
Example #5
0
 @Override
 public VisWindow fadeIn() {
   //        Launcher.instance().editorScreen.leftPaneBlocker.alpha = .4f;
   Tween.to(Launcher.instance().editorScreen.leftPaneBlocker, BlockerTweenAccessor.ALPHA, .3f)
       .target(.4f)
       .ease(Linear.INOUT)
       .start(tweenManager);
   Tween.to(Launcher.instance().editorScreen.rightPaneBlocker, BlockerTweenAccessor.ALPHA, .3f)
       .target(.4f)
       .ease(Linear.INOUT)
       .start(tweenManager);
   return super.fadeIn();
 }
 @Override
 public boolean touchUp(int x, int y, int pointer, int button) {
   Tween.to(veil, SpriteAccessor.OPACITY, 0.7f)
       .target(1)
       .setCallback(callback)
       .start(tweenManager);
   return true;
 }
Example #7
0
  @Override
  protected Timeline showAnimation() {
    this.levelStartAnimation = Timeline.createSequence();

    float y = (stage.getHeight() + this.levelImage.getHeight()) / 2f;
    Tween slideinTween =
        Tween.to(this.levelImage, ActorAccessor.POSITION_Y, 1f)
            .ease(TweenEquations.easeInOutQuint)
            .target(y);
    slideinTween.setCallbackTriggers(TweenCallback.COMPLETE);
    slideinTween.setCallback(
        new TweenCallback() {

          @Override
          public void onEvent(int arg0, BaseTween<?> arg1) {
            levelStartAnimation.pause();
            imageStartAnimationFinished = true;
            startScreenCloseAnimation();
          }
        });
    this.levelStartAnimation.push(slideinTween);

    this.levelStartAnimation.push(Tween.to(this.filter, ActorAccessor.ALPHA, 0.5f).target(0f));

    y = stage.getHeight() + levelImage.getHeight();
    Tween slideoutTween =
        Tween.to(this.levelImage, ActorAccessor.POSITION_Y, 0.5f)
            .ease(TweenEquations.easeInQuint)
            .target(y);
    slideoutTween.setCallbackTriggers(TweenCallback.COMPLETE);
    slideoutTween.setCallback(
        new TweenCallback() {

          @Override
          public void onEvent(int arg0, BaseTween<?> arg1) {
            levelImage.remove();
            filter.remove();
            MusicPlayer.getInstance().playNext();
            getGameEngine().startGamePlay();
          }
        });
    levelStartAnimation.push(slideoutTween);

    return this.levelStartAnimation;
  }
Example #8
0
  public static Timeline moveAlongPath(
      Path<GridPoint2> path, float stepDuration, Object target, int tweenType) {
    Timeline timeline = Timeline.createSequence();

    for (GridPoint2 point : path.getPoints()) {
      timeline = timeline.push(Tween.to(target, tweenType, stepDuration).target(point.x, point.y));
    }

    return timeline;
  }
Example #9
0
 private void shrink() {
   selected = false;
   disableClick();
   Tween.to(SetCard.this, Accessor.XYWH, 0.1f)
       // .targetRelative(-(1-scaleXY)*width/2, -(1-scaleXY)*height/2, -(scaleXY-1)*width,
       // -(scaleXY-1)*height)
       .targetRelative(growWidth, growHeight, -growWidth * 2, -growHeight * 2)
       .ease(Quad.OUT)
       .start(tweenManager);
   enableClick();
 }
Example #10
0
 private void grow() {
   selected = true;
   showBorder();
   disableClick();
   Tween.to(SetCard.this, Accessor.XYWH, 0.1f)
       // .targetRelative((1-scaleXY)*width/2, (1-scaleXY)*height/2, (scaleXY-1)*width,
       // (scaleXY-1)*height)
       .targetRelative(-growWidth, -growHeight, growWidth * 2, growHeight * 2)
       .ease(Quad.OUT)
       .start(tweenManager);
   enableClick();
 }
Example #11
0
  /** Launch splashScreen. */
  @Override
  public void show() {
    // Switch to normal stage.
    tappy.setStage(splashNormalStage);

    // Register tweenEngine timeline.
    Timeline.createSequence()
        // Set default values.
        .push(Tween.set(splashHeadphone, SpriteAccessor.ALPHA).target(0))
        .push(Tween.set(splashBackground, SpriteAccessor.ALPHA).target(0))
        .push(
            Tween.set(splashBackground, SpriteAccessor.POSITION)
                .target(0, -(splashBackground.getHeight() - Gdx.graphics.getHeight())))
        // FadeIn & Slide down.
        .push(Tween.to(splashHeadphone, SpriteAccessor.ALPHA, 1.2f).target(1))
        .pushPause(1.4f)
        .push(Tween.to(splashHeadphone, SpriteAccessor.ALPHA, 1.2f).target(0))
        .beginParallel()
        .push(Tween.to(splashBackground, SpriteAccessor.ALPHA, 5.2f).target(1))
        .push(Tween.to(splashBackground, SpriteAccessor.POSITION, 9.8f).target(0, 0).ease(Quad.OUT))
        .end()
        // Waiting.
        .pushPause(1.2f)
        // FadeOut.
        .push(Tween.to(splashBackground, SpriteAccessor.ALPHA, 0.7f).target(0))
        // Register callback.
        .setCallback(
            new TweenCallback() {
              @Override
              public void onEvent(int type, BaseTween<?> source) {
                if (tappy.getPreferences().getBoolean("firstTime", true)) {
                  tappy.setScreen(new TutorialScreen(tappy));
                } else {
                  tappy.setScreen(new HomeScreen(tappy));
                }
              }
            })
        // Launch!
        .start(tweenManager);
  }
Example #12
0
  private void setPlayTippingOver() {
    switch ((int) character.rotation) {
      case 0:
        tipOverSprite = new Sprite(tipOverE.getRegions()[11]);
        break;
      case 45:
        tipOverSprite = new Sprite(tipOverNe.getRegions()[11]);
        break;
      case 90:
        tipOverSprite = new Sprite(tipOverN.getRegions()[11]);
        break;
      case 135:
        tipOverSprite = new Sprite(tipOverNw.getRegions()[11]);
        break;
      case 180:
        tipOverSprite = new Sprite(tipOverW.getRegions()[11]);
        break;
      case 225:
        tipOverSprite = new Sprite(tipOverSw.getRegions()[11]);
        break;
      case 270:
        tipOverSprite = new Sprite(tipOverS.getRegions()[11]);
        break;
      case 315:
        tipOverSprite = new Sprite(tipOverSe.getRegions()[11]);
        break;
    }

    tipOverSprite.setBounds(character.getPosition().x - 1.5f, character.getPosition().y - 1, 4, 4);

    // For fading of killed animation
    Tween.registerAccessor(Sprite.class, new SpriteTween());

    tweenManager = new TweenManager();

    TweenCallback cb =
        new TweenCallback() {

          @Override
          public void onEvent(int type, BaseTween<?> source) {
            tweenCompleted();
          }
        };

    Tween.to(tipOverSprite, SpriteTween.ALPHA, 2.5f)
        .target(0)
        .ease(TweenEquations.easeInQuad)
        .setCallback(cb)
        .setCallbackTriggers(TweenCallback.COMPLETE)
        .start(tweenManager);
  }
Example #13
0
  public void animate() {
    if (placement.equals(Placement.RELATIVE)) {
      CameraHandler cameraHandler = gui.getApp().getCameraHandler();

      Vector2 targetPosition =
          new Vector2(target.x + target.width / 2, target.y + target.height / 2);
      Vector2 cameraPosition =
          new Vector2(cameraHandler.getCamera().position.x, cameraHandler.getCamera().position.y);

      float time = targetPosition.dst(cameraPosition) / (App.WORLD_SCALE * 10);
      Tween.to(cameraHandler, CameraHandlerAccessor.SET, Math.max(2f, time))
          .target(targetPosition.x, targetPosition.y)
          .ease(TweenEquations.easeOutCubic)
          .start(App.getTweenManager());
      /* Tween.to(cameraHandler, CameraHandlerAccessor.ZOOM, 1).target(cameraHandler.getCamera().zoom / 2).start(
      App.getTweenManager());    */
    }
  }
  private void setupTween() {
    Tween.registerAccessor(Sprite.class, new SpriteAccessor());
    manager = new TweenManager();

    TweenCallback cb =
        new TweenCallback() {
          @Override
          public void onEvent(int type, BaseTween<?> source) {
            game.setScreen(new GameScreen());
          }
        };

    Tween.to(sprite, SpriteAccessor.ALPHA, .8f)
        .target(1)
        .ease(TweenEquations.easeInOutQuad)
        .repeatYoyo(1, .4f)
        .setCallback(cb)
        .setCallbackTriggers(TweenCallback.COMPLETE)
        .start(manager);
  }
  private void buildMenuComponents(final TextureAtlas menuButtonAtlas) {
    if (progressPanel != null) {
      progressPanel.remove();
    }

    addActor(makeLibGDXLogo(menuButtonAtlas));
    addActor(makeHappyDroidsLogo(menuButtonAtlas));

    MainMenuButtonPanel menuButtonPanel = new MainMenuButtonPanel();
    menuButtonPanel.pack();
    menuButtonPanel.setY(droidTowersLogo.getY() - menuButtonPanel.getHeight());
    menuButtonPanel.setX(-droidTowersLogo.getImageWidth());
    addActor(menuButtonPanel);

    Tween.to(menuButtonPanel, WidgetAccessor.POSITION, CAMERA_PAN_DOWN_DURATION)
        .target(
            50 + (45 * (droidTowersLogo.getImageWidth() / droidTowersLogo.getWidth())),
            menuButtonPanel.getY())
        .ease(TweenEquations.easeInOutExpo)
        .start(TweenSystem.manager());
  }
Example #16
0
  @Override
  public void render(float delta) {
    Gdx.gl.glClear(GL20.GL_COLOR_BUFFER_BIT | GL20.GL_DEPTH_BUFFER_BIT);
    Gdx.gl.glClearColor(.3f, .3f, .3f, 1);

    simulateEventHandler(delta);

    if (!ready) {
      renderLoading(delta);
      return;
    }
    if (loading) {
      Tween.to(wrapper, PrimitiveTweenAccessor.FLOAT, .4f)
          .target(0)
          .ease(Linear.INOUT)
          .setCallback(
              (type, source) -> {
                if (type == TweenCallback.COMPLETE) {
                  stillLoading = false;
                }
              })
          .start(tweenManager);
      loading = false;
    }

    tweenManager.update(delta);

    preRender(delta);
    try {
      stage2d.act(delta);
      stage2d.draw();
    } catch (Exception ignored) {
    }
    postRender(delta);

    if (stillLoading) {
      renderLoading(delta);
    }
  }
  @Override
  public void update() {
    if (Gdx.input.justTouched()) {
      touch = MainGame.camera.unprojectCoordinates(Gdx.input.getX(), Gdx.input.getY());

      if (showingCard) {

        TweenCallback myCallBack =
            new TweenCallback() {
              @Override
              public void onEvent(int type, BaseTween<?> source) {
                purchasedCard = null;
                showingCard = false;
              }
            };

        Tween.to(cardAnimSprite, SpriteAccessor.SCALE_XY, 10f)
            .target(0.001f, 0.001f)
            .ease(TweenEquations.easeNone)
            .setCallback(myCallBack)
            .setCallbackTriggers(TweenCallback.END)
            .start(tweenManager);
        startTime = TimeUtils.millis();

      } else {

        if (backButton.checkTouch(touch)) {
          SoundManager.play(Assets.CLICK);
          ScreenManager.setScreen(new MainMenuScreen());

        } else if (randomCardButton.checkTouch(touch)) {

          long myGold = MainGame.userStats.getPlayerGold();

          if (myGold >= randomCardCost) {
            MainGame.userStats.addGold(-randomCardCost);

            purchasedCard =
                CardCreator.createCard((int) (Math.random() * MainGame.numberOfCards + 1));
            MainGame.userStats.getPlayerCardList().insert(0, purchasedCard.getID());
            MainGame.saveManager.saveDataValue("PLAYER", MainGame.userStats);

            currGold = "Gold: " + MainGame.userStats.getPlayerGold();
            Tween.to(cardAnimSprite, SpriteAccessor.SCALE_XY, 10f)
                .target(1.5f, 1.5f)
                .ease(TweenEquations.easeNone)
                .start(tweenManager);
            startTime = TimeUtils.millis();
            showingCard = true;
          }
        } else if (rareCardButton.checkTouch(touch)) {

          long myGold = MainGame.userStats.getPlayerGold();

          if (myGold >= rareCardCost) {
            MainGame.userStats.addGold(-rareCardCost);

            purchasedCard =
                CardCreator.createCard((int) (Math.random() * MainGame.numberOfCards + 1));
            MainGame.userStats.getPlayerCardList().insert(0, purchasedCard.getID());
            MainGame.saveManager.saveDataValue("PLAYER", MainGame.userStats);

            currGold = "Gold: " + MainGame.userStats.getPlayerGold();
            Tween.to(cardAnimSprite, SpriteAccessor.SCALE_XY, 10f)
                .target(1.5f, 1.5f)
                .ease(TweenEquations.easeNone)
                .start(tweenManager);
            startTime = TimeUtils.millis();
            showingCard = true;
          }
        }
      }
    }
    bgManager.update();
  }
Example #18
0
 private void hideBorder() {
   tweenManager.killTarget(borderThickness);
   Tween.to(SetCard.this, Accessor.BORDER_THICKNESS, 0.4f).target(2).start(tweenManager);
 }
Example #19
0
  @Override
  public void show() {
    super.show();

    backgroundStage.addActor(new Image(atlas.findRegion("background")));

    Image alien = new Image(atlas.findRegion("alien"));
    alien.setPosition(mainStage.getWidth() + mainStage.getPadLeft(), -365f);
    mainStage.addActor(alien);

    Image energy = new Image(atlas.findRegion("energy")); // 195, 313
    energy.setPosition(83f, 201f);
    energy.setScale(0f);
    energy.setOrigin(energy.getPrefWidth() / 2, energy.getPrefHeight() / 2);
    mainStage.addActor(energy);

    final Table certificateTable = new Table();
    certificateTable.padTop(314f).padBottom(101f).defaults().padBottom(100f);
    certificateTable.setBackground(new TextureRegionDrawable(atlas.findRegion("certificate")));
    certificateTable.setSize(mainStage.getWidth(), mainStage.getHeight());
    certificateTable.setOrigin(195f, 313f);
    certificateTable.setTransform(true);
    certificateTable.setTouchable(Touchable.disabled);
    certificateTable.addListener(
        new ClickListener() {
          @Override
          public void clicked(InputEvent event, float x, float y) {
            Assets.fanfareFX.stop();
            game.loadNextScreen(EndingScreen.this, KonnectingGame.ScreenType.MAIN_MENU);
          }
        });
    certificateTable.setScale(0f);
    mainStage.addActor(certificateTable);

    StatsData tempData = SavedData.getStats();
    int score =
        tempData.kronosScore1
            + tempData.kronosScore2
            + tempData.kronosScore3
            + tempData.kronosScore4
            + tempData.kronosScore5
            + tempData.kronosScore6
            + tempData.kronosScore7
            + tempData.zappingScore1
            + tempData.zappingScore2
            + tempData.zappingScore3
            + tempData.zappingScore4
            + tempData.zappingScore5;

    final Label userLabel =
        new Label(
            SavedData.getUsername() + "\n\n" + score + "pt",
            new Label.LabelStyle(uiSkin.getFont("default-font"), Color.WHITE));
    userLabel.setWrap(true);
    userLabel.setAlignment(Align.center);
    userLabel.getColor().a = 0f;
    certificateTable.add(userLabel).width(407f).row();

    String correctComment = comments[0];
    for (int i = scoreLimits.length - 1; i >= 0; i--) {
      if (score > scoreLimits[i]) {
        correctComment = comments[i];
        break;
      }
    }
    final Label commentLabel =
        new Label(correctComment, new Label.LabelStyle(uiSkin.getFont("arial"), Color.WHITE));
    commentLabel.setWrap(true);
    commentLabel.setFontScale(0.9f);
    commentLabel.setAlignment(Align.center);
    commentLabel.getColor().a = 0f;
    certificateTable.add(commentLabel).width(407f);

    Timeline.createSequence()
        .push(Tween.to(alien, ActorAccessor.MOVE_X, 1f).target(20f))
        .pushPause(0.25f)
        .push(Tween.to(energy, ActorAccessor.SCALEXY, 1f).target(1f))
        .push(Tween.to(energy, ActorAccessor.SCALEXY, 0.5f).target(0.8f))
        .push(Tween.to(energy, ActorAccessor.SCALEXY, 0.5f).target(1f))
        .push(Tween.to(certificateTable, ActorAccessor.SCALEXY, 0.5f).target(1f))
        .beginParallel()
        .push(Tween.to(userLabel, ActorAccessor.ALPHA, 0.5f).target(1f))
        .push(Tween.to(commentLabel, ActorAccessor.ALPHA, 0.5f).target(1f))
        .end()
        .setCallback(
            new TweenCallback() {
              @Override
              public void onEvent(int type, BaseTween<?> source) {
                Assets.fanfareFX.setOnCompletionListener(
                    new Music.OnCompletionListener() {
                      @Override
                      public void onCompletion(Music music) {
                        Assets.fanfareFX.setOnCompletionListener(null);
                        certificateTable.setTouchable(Touchable.enabled);
                      }
                    });
                Assets.fanfareFX.play();
              }
            })
        .start(tweenManager);
  }
  public SplashScreen(TweenCallback callback) {
    this.callback = callback;

    TextureAtlas atlas = Assets.inst().get("data/splash/pack", TextureAtlas.class);
    universal = atlas.createSprite("universal");
    tween = atlas.createSprite("tween");
    engine = atlas.createSprite("engine");
    logo = atlas.createSprite("logo");
    strip = atlas.createSprite("white");
    powered = atlas.createSprite("powered");
    gdx = atlas.createSprite("gdxblur");
    veil = atlas.createSprite("white");
    gdxTex = atlas.findRegion("gdx");

    float wpw = 1f;
    float wph = wpw * Gdx.graphics.getHeight() / Gdx.graphics.getWidth();

    camera.viewportWidth = wpw;
    camera.viewportHeight = wph;
    camera.update();

    Gdx.input.setInputProcessor(inputProcessor);

    Sprite[] sprites = new Sprite[] {universal, tween, engine, logo, powered, gdx};
    for (Sprite sp : sprites) {
      sp.setSize(sp.getWidth() / PX_PER_METER, sp.getHeight() / PX_PER_METER);
      sp.setOrigin(sp.getWidth() / 2, sp.getHeight() / 2);
    }

    universal.setPosition(-0.325f, 0.028f);
    tween.setPosition(-0.320f, -0.066f);
    engine.setPosition(0.020f, -0.087f);
    logo.setPosition(0.238f, 0.022f);

    strip.setSize(wpw, wph);
    strip.setOrigin(wpw / 2, wph / 2);
    strip.setPosition(-wpw / 2, -wph / 2);

    powered.setPosition(-0.278f, -0.025f);
    gdx.setPosition(0.068f, -0.077f);

    veil.setSize(wpw, wph);
    veil.setPosition(-wpw / 2, -wph / 2);
    veil.setColor(1, 1, 1, 0);

    Timeline.createSequence()
        .push(Tween.set(tween, SpriteAccessor.POS_XY).targetRelative(-1, 0))
        .push(Tween.set(engine, SpriteAccessor.POS_XY).targetRelative(1, 0))
        .push(Tween.set(universal, SpriteAccessor.POS_XY).targetRelative(0, 0.5f))
        .push(Tween.set(logo, SpriteAccessor.SCALE_XY).target(7, 7))
        .push(Tween.set(logo, SpriteAccessor.OPACITY).target(0))
        .push(Tween.set(strip, SpriteAccessor.SCALE_XY).target(1, 0))
        .push(Tween.set(powered, SpriteAccessor.OPACITY).target(0))
        .push(Tween.set(gdx, SpriteAccessor.OPACITY).target(0))
        .pushPause(0.5f)
        .push(Tween.to(strip, SpriteAccessor.SCALE_XY, 0.8f).target(1, 0.6f).ease(Back.OUT))
        .push(Tween.to(tween, SpriteAccessor.POS_XY, 0.5f).targetRelative(1, 0).ease(Quart.OUT))
        .push(Tween.to(engine, SpriteAccessor.POS_XY, 0.5f).targetRelative(-1, 0).ease(Quart.OUT))
        .push(
            Tween.to(universal, SpriteAccessor.POS_XY, 0.6f)
                .targetRelative(0, -0.5f)
                .ease(Quint.OUT))
        .pushPause(-0.3f)
        .beginParallel()
        .push(Tween.set(logo, SpriteAccessor.OPACITY).target(1))
        .push(Tween.to(logo, SpriteAccessor.SCALE_XY, 0.5f).target(1, 1).ease(Back.OUT))
        .end()
        .push(Tween.to(strip, SpriteAccessor.SCALE_XY, 0.5f).target(1, 1).ease(Back.IN))
        .pushPause(0.3f)
        .beginParallel()
        .push(Tween.to(tween, SpriteAccessor.POS_XY, 0.5f).targetRelative(1, 0).ease(Back.IN))
        .push(Tween.to(engine, SpriteAccessor.POS_XY, 0.5f).targetRelative(1, 0).ease(Back.IN))
        .push(Tween.to(universal, SpriteAccessor.POS_XY, 0.5f).targetRelative(1, 0).ease(Back.IN))
        .push(Tween.to(logo, SpriteAccessor.POS_XY, 0.5f).targetRelative(1, 0).ease(Back.IN))
        .end()
        .pushPause(-0.3f)
        .push(Tween.to(powered, SpriteAccessor.OPACITY, 0.3f).target(1))
        .beginParallel()
        .push(Tween.to(gdx, SpriteAccessor.OPACITY, 1.5f).target(1).ease(Cubic.IN))
        .push(Tween.to(gdx, SpriteAccessor.ROTATION, 2.0f).target(360 * 15).ease(Quad.OUT))
        .end()
        .pushPause(0.3f)
        .push(
            Tween.to(gdx, SpriteAccessor.SCALE_XY, 0.6f)
                .waypoint(1.6f, 0.4f)
                .target(1.2f, 1.2f)
                .ease(Cubic.OUT))
        .pushPause(0.3f)
        .beginParallel()
        .push(Tween.to(powered, SpriteAccessor.POS_XY, 0.5f).targetRelative(1, 0).ease(Back.IN))
        .push(Tween.to(gdx, SpriteAccessor.POS_XY, 0.5f).targetRelative(1, 0).ease(Back.IN))
        .end()
        .pushPause(0.3f)
        .setCallback(callback)
        .start(tweenManager);
  }