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());
}
@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)));
}
@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++;
}
@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;
}
@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;
}
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;
}
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();
}
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();
}
/** 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);
}
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);
}
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());
}
@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();
}
private void hideBorder() {
tweenManager.killTarget(borderThickness);
Tween.to(SetCard.this, Accessor.BORDER_THICKNESS, 0.4f).target(2).start(tweenManager);
}
@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);
}