libGDX游戏卡在屏幕上显示（）-hide（）循环

我正在用LibGDX创建我的第一个游戏，在我的初始屏幕上，我正在使用Universal tween引擎。除了我自己的图片，我正在使用的是

aurelian Ribon

。当启动屏幕结束时，会出现问题，它会调用

Launcher

，并从那里调用扩展

Test

类的各种类。我没有找到一种干净的方法将控件提供给我的

LevelSelector

类，它实现了screen并使用stage进行渲染。每当控件转到我的类时，它都会调用它的

show（）

，在不输入render（）的情况下，它会调用

hide（）

。这将一直持续到应用程序停止。一直以来，

App

类（即主类）render（）继续被连续调用。我已经找到了解决办法，但它会导致内存问题，并使游戏速度变慢。谁能告诉我如何停止呈现

App

&将控制权转移到我的班级

我的解决方法如下所示：

当点击Play（扩展

测试
）时，在其初始化静态标志中设置了App:inPlay

在App render（）中，如果设置了isPlay，则将screen设置为LevelSelector

在LevelSelector中，如果单击任何级别，请设置应用程序的静态标志：inLevel

在App render（）中，如果设置了inLevel，则将Screen设置为该级别

这是可行的，但LevelSelector render、App render和level render都会被调用，即使在屏幕设置为导致应用程序延迟和内存问题的级别后

有没有解决这个问题的方法而不使用变通方法

我的代码：

//APP class

import aurelienribon.tweenengine.BaseTween;
import aurelienribon.tweenengine.Tween;
import aurelienribon.tweenengine.TweenCallback;

import com.badlogic.gdx.Game;
import com.badlogic.gdx.Gdx;
import com.badlogic.gdx.Screen;
import com.badlogic.gdx.graphics.g2d.BitmapFont;
import com.badlogic.gdx.graphics.g2d.Sprite;
import com.badlogic.gdx.graphics.g2d.TextureAtlas;

/**
 * @author Aurelien Ribon | http://www.aurelienribon.com/
 */
public class App extends Game {
private SplashScreen splashScreen;
private Launcher launcherScreen;
private boolean isLoaded = false;
static boolean inPlay = false;
static boolean levelStarted = false;
static int levelIndex;
LevelSelector ls;
Screen screen;
Level level;

@Override
public void create() {
    System.out.println("********App create********");
    Tween.setWaypointsLimit(10);
    Tween.setCombinedAttributesLimit(3);
    Tween.registerAccessor(Sprite.class, new SpriteAccessor());

    Assets.inst().load("data/splash/pack", TextureAtlas.class);
    Assets.inst().load("data/launcher/pack", TextureAtlas.class);
    Assets.inst().load("data/test/pack", TextureAtlas.class);
    Assets.inst().load("data/arial-16.fnt", BitmapFont.class);
    Assets.inst().load("data/arial-18.fnt", BitmapFont.class);
    Assets.inst().load("data/arial-20.fnt", BitmapFont.class);
    Assets.inst().load("data/arial-24.fnt", BitmapFont.class);

}

@Override
public void dispose() {
    Assets.inst().dispose();
    if (splashScreen != null) splashScreen.dispose();
    if (launcherScreen != null) launcherScreen.dispose();
    if(screen != null) screen.dispose();
}

@Override
public void render() {

    if (isLoaded) {
        screen = null;
        if (splashScreen != null) splashScreen.render();
       if(inPlay && levelStarted==false){

            splashScreen = null;
            launcherScreen = null;
            Gdx.graphics.setContinuousRendering(false);
            Gdx.input.setInputProcessor(pspt.stage);
            this.setScreen(ls);
        }
        else if(inPlay && levelStarted)
        {
            level.setLevelIndex(levelIndex);
            screen = level.getLevelScreen();
            if(screen != null)
            {
                splashScreen = null;
                launcherScreen = null;
                Gdx.graphics.setContinuousRendering(false);
                this.setScreen(screen);
            }
        }
        if (launcherScreen != null) launcherScreen.render();

    } else {
        if (Assets.inst().getProgress() < 1) {
            Assets.inst().update();  //update returns true when asset manager finishes loading all assets
        } else {
            launch();
            isLoaded = true;
            inPlay = false;
        }
    }
}

@Override public void resize(int width, int height) {}
@Override public void pause() {}
@Override public void resume() {}

private void launch() {
    System.out.println("********App Launch********");
    ls = new LevelSelector(this);
    screen = null;
    level = new Level();
    splashScreen = new SplashScreen(new TweenCallback() {
        @Override public void onEvent(int type, BaseTween source) {
            Test[] tests = new Test[] {
                    new Info(),
                    new Help(),
                    new PlayScreen()
            };

            splashScreen.dispose();
            splashScreen = null;
            launcherScreen = new Launcher(tests);
        }
    });
}
}


//TEST class

public abstract class Test {
private final TweenManager tweenManager = new TweenManager();
private final TextureAtlas atlas;
private final Sprite background;
private final Sprite veil;
private final Sprite infoBack;
private final List<Sprite> dots = new ArrayList<Sprite>(50);
private boolean[] useDots;
private Callback callback;

protected final OrthographicCamera camera = new OrthographicCamera();
protected final SpriteBatch batch = new SpriteBatch();
protected final Random rand = new Random();
protected final BitmapFont font;
protected final float wpw = 10;
protected final float wph = 10 * Gdx.graphics.getHeight() / Gdx.graphics.getWidth();
protected Sprite[] sprites;

public Test() {
    System.out.println("********Test Constructor********");
    atlas = Assets.inst().get("data/test/pack", TextureAtlas.class);
    background = atlas.createSprite("background");
    veil = atlas.createSprite("white");
    infoBack = atlas.createSprite("white");

    int w = Gdx.graphics.getWidth();
    if (w > 600) font = Assets.inst().get("data/arial-24.fnt", BitmapFont.class);
    else font = Assets.inst().get("data/arial-16.fnt", BitmapFont.class);
}

// -------------------------------------------------------------------------
// Abstract API
// -------------------------------------------------------------------------

public abstract String getTitle();
public abstract String getInfo();
public abstract String getImageName();
public abstract InputProcessor getInput();
protected abstract void initializeOverride();
protected abstract void disposeOverride();
protected abstract void renderOverride();

// -------------------------------------------------------------------------
// Public API
// -------------------------------------------------------------------------

public static interface Callback {
    public void closeRequested(Test source);
}

public void setCallback(Callback callback) {
    System.out.println("********Test setCallback********");
    this.callback = callback;
}

public void initialize() {
    System.out.println("********Test initialize********");
    if (isCustomDisplay()) {
        initializeOverride();
        return;
    }

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

    background.setSize(wpw, wpw * background.getHeight() / background.getWidth());
    background.setPosition(-wpw/2, -background.getHeight()/2);

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

    infoBack.setColor(0, 0, 0, 0.3f);
    infoBack.setPosition(0, 0);

    initializeOverride();

    Tween.set(veil, SpriteAccessor.OPACITY).target(1).start(tweenManager);
    Tween.to(veil, SpriteAccessor.OPACITY, 0.5f).target(0).start(tweenManager);
}

public void dispose() {
    System.out.println("###Test dispose###");
    tweenManager.killAll();
    dots.clear();
    sprites = null;
    useDots = null;

    disposeOverride();
}

public void render() {
    System.out.println("********Test render********");
    if(App.inPlay == false)
    {
        if (isCustomDisplay()) {
            System.out.println("CustomDisplay : True");
            renderOverride();
            return;
        }    
        // update

        tweenManager.update(Gdx.graphics.getDeltaTime());

        for (int i=0; i<dots.size(); i++) {
            if (dots.get(i).getScaleX() < 0.1f) {
                dots.remove(i);
            }
        }

        // render
        GLCommon gl = Gdx.gl;
        gl.glClearColor(1, 1, 1, 1);
        gl.glClear(GL10.GL_COLOR_BUFFER_BIT);
        gl.glEnable(GL10.GL_BLEND);
        gl.glBlendFunc(GL10.GL_SRC_ALPHA, GL10.GL_ONE_MINUS_SRC_ALPHA);

        int w = Gdx.graphics.getWidth();
        int h = Gdx.graphics.getHeight();

        batch.setProjectionMatrix(camera.combined);
        batch.begin();
        batch.disableBlending();
        background.draw(batch);
        batch.enableBlending();
        for (int i=0; i<dots.size(); i++) dots.get(i).draw(batch);
        for (int i=0; i<sprites.length; i++) sprites[i].draw(batch);
        batch.end();
        System.out.println("********Test call renderOverride********");
        renderOverride();

        if (getInfo() != null) {
            int padding = 15;
            BitmapFont.TextBounds bs = font.getWrappedBounds(getInfo(), w - padding*2);
            infoBack.setSize(w, bs.height + padding*2);
            font.setColor(Color.WHITE);

            batch.getProjectionMatrix().setToOrtho2D(0, 0, w, h);
            batch.begin();
            infoBack.draw(batch);
            font.drawWrapped(batch, getInfo(), padding, bs.height + padding, w - padding*2);
            batch.end();
        }

        if (veil.getColor().a > 0.1f) {
            batch.setProjectionMatrix(camera.combined);
            batch.begin();
            veil.draw(batch);
            batch.end();
        }
    }
}

// -------------------------------------------------------------------------
// Helpers
// -------------------------------------------------------------------------

protected boolean isCustomDisplay() {
    return false;
}

protected void forceClose() {
    System.out.println("#######Test forceClose########");
    if (callback != null) callback.closeRequested(this);
}

protected void createSprites(int cnt) {
    System.out.println("********Test create Sprites : "+cnt+"********");
    sprites = new Sprite[cnt];
    useDots = new boolean[cnt];

    for (int i=0; i<cnt; i++) {
        int idx = rand.nextInt(400)/100 + 1;
        sprites[i] = atlas.createSprite("sprite" + idx);
        sprites[i].setSize(1f, 1f * sprites[i].getHeight() / sprites[i].getWidth());
        sprites[i].setOrigin(sprites[i].getWidth()/2, sprites[i].getHeight()/2);
        useDots[i] = false;
    }
}

protected void center(Sprite sp, float x, float y) {
    sp.setPosition(x - sp.getWidth()/2, y - sp.getHeight()/2);
}

protected void enableDots(int spriteId) {
    useDots[spriteId] = true;

    Tween.call(dotCallback)
    .delay(0.02f)
    .repeat(-1, 0.02f)
    .setUserData(spriteId)
    .start(tweenManager);
}

protected void disableDots(int spriteId) {
    useDots[spriteId] = false;
}

private final Vector2 v2 = new Vector2();
private final Vector3 v3 = new Vector3();
protected Vector2 touch2world(int x, int y) {
    v3.set(x, y, 0);
    camera.unproject(v3);
    return v2.set(v3.x, v3.y);
}

// -------------------------------------------------------------------------
// Helpers
// -------------------------------------------------------------------------

private final TweenCallback dotCallback = new TweenCallback() {
    @Override
    public void onEvent(int type, BaseTween source) {
        System.out.println("********Test dotCallback : onEvent********");
        int spriteId = (Integer) source.getUserData();

        if (useDots[spriteId] == false) source.kill();
        Sprite sp = sprites[spriteId];

        Sprite dot = atlas.createSprite("dot");
        dot.setSize(0.2f, 0.2f);
        dot.setOrigin(0.1f, 0.1f);
        dot.setPosition(sp.getX(), sp.getY());
        dot.translate(sp.getWidth()/2, sp.getHeight()/2);
        dot.translate(-dot.getWidth()/2, -dot.getHeight()/2);
        dots.add(dot);
        Tween.to(dot, SpriteAccessor.SCALE_XY, 1.0f).target(0, 0).start(tweenManager);
    }
};

// -------------------------------------------------------------------------
// Dummy
// -------------------------------------------------------------------------

public static final Test dummy = new Test() {
    @Override public String getTitle() {
        System.out.println("********Test dummy getTitle********");
        return "Dummy test";}
    @Override public String getInfo() {
        System.out.println("********Test dummy getInfo********");
        return null;}
    @Override public String getImageName() {
        System.out.println("********Test dummy getImageName********");
        return null;}
    @Override public InputProcessor getInput() {
        System.out.println("********Test dummy getInput********");
        return null;}
    @Override protected void initializeOverride() {System.out.println("********Test dummy initOverride********");}
    @Override protected void disposeOverride() {System.out.println("********Test dummy disposeOverride********");}
    @Override protected void renderOverride() {System.out.println("********Test dummy renderOverride********");}
};
}


//LevelSelector

public class LevelSelector implements Screen {

private Skin skin;
Stage stage;
private Table container;
Game game;
//  Level_1_1 level1;
PagedScrollPane scroll ;
int rank=0,leveldone;
Table starTable;
Utils Utils;

public LevelSelector(Game game){
    //      System.out.println("########In pagedScrollPaneTest construct (App)##########");
    Gdx.input.setInputProcessor(stage);
    this.game = game;
    Utils = new Utils();

    stage = new Stage(0, 0, false);
    skin = new Skin(Gdx.files.internal("data/uiskin.json"));
    skin.add("top", skin.newDrawable("default-round", Color.RED), Drawable.class);
    skin.add("star-filled", skin.newDrawable("white", Color.YELLOW), Drawable.class); 
    skin.add("star-unfilled", skin.newDrawable("white", Color.GRAY), Drawable.class);

    Gdx.input.setInputProcessor(stage);

    container = new Table();
    stage.addActor(container);
    container.setFillParent(true);

    scroll= new PagedScrollPane();
    scroll.setFlingTime(0.1f);
    scroll.setPageSpacing(25);
    int c = 1;
    for (int l =0; l < 5; l++) {
        Table levels = new Table().pad(50);
        levels.defaults().pad(20, 40, 20, 40);
        for (int y = 0; y <3; y++) {
            levels.row();
            for (int x = 0; x < 1; x++) {
                levels.add(getLevelButton(c++)).expand().fill();
            }
        }
        scroll.addPage(levels);
    }
    container.add(scroll).expand().fill();

}

public void resize (int width, int height) {
    stage.setViewport(width, height, true);
}

public void dispose () {
    System.out.println("In selector dispose ####");
    Gdx.input.setInputProcessor(null);
    stage.dispose();
    skin.dispose();
}

public boolean needsGL20 () {
    return false;
}

/**
 * Creates a button to represent the level
 * 
 * @param level
 * @return The button to use for the level
 */
public Button getLevelButton(int level) {
    Button button = new Button(skin);
    ButtonStyle style = button.getStyle();
    style.up =  style.down = null;

    // Create the label to show the level number
    Label label = new Label(Integer.toString(level), skin);
    label.setFontScale(2f);
    label.setAlignment(Align.center);       

    // Stack the image and the label at the top of our button
    button.stack(new Image(skin.getDrawable("top")), label).expand().fill();

    // Randomize the number of stars earned for demonstration purposes
    int stars = rank;
    starTable = new Table();
    int j=level;
    starTable.defaults().pad(5);

    if (Utils.prefs.getInteger("rank"+j) >= 0) {
        for (int star = 0; star < 3; star++) {
            if (Utils.prefs.getInteger("rank"+j) > star && level== Utils.prefs.getInteger("level"+j)) {
                System.out.println("\n\nHAd saved option Level:: "+Utils.prefs.getInteger("level"+j));
                System.out.println("HAd saved option Rank :: "+Utils.prefs.getInteger("rank"+j));
                starTable.add(new Image(skin.getDrawable("star-filled"))).width(20).height(20);
            } 
            else {
                starTable.add(new Image(skin.getDrawable("star-unfilled"))).width(20).height(20);
            }
        }           
    }

    button.row();
    button.add(starTable).height(30);

    button.setName("level" + Integer.toString(level));
    button.addListener(levelClickListener);
    return button;
}

/**
 * Handle the click - in real life, we'd go to the level
 */
public ClickListener levelClickListener = new ClickListener() {
    @Override
    public void clicked (InputEvent event, float x, float y) {
        System.out.println("Click: " + event.getListenerActor().getName());
        String levelSelected = event.getListenerActor().getName();
        if(levelSelected.equalsIgnoreCase("level1"))
        {
            App.levelStarted = true;
            game.dispose();
            App.whichLevel = levelSelected;
            App.levelIndex = 1;
        }
        if(levelSelected.equalsIgnoreCase("level2"))
        {
            App.levelStarted = true;
            game.dispose();
            App.whichLevel = levelSelected;
            App.levelIndex = 2;
        }
    }
};


@Override
public void show() {
    System.out.println("########In pagedScrollPaneTest show##########");
    render(Gdx.graphics.getDeltaTime());
}

@Override
public void hide() {
    System.out.println("########In pagedScrollPaneTest hide##########");
}

@Override
public void render(float delta) {
    GLCommon gl = Gdx.gl;
    gl.glClearColor(1, 1, 1, 1);
    gl.glClear(GL10.GL_COLOR_BUFFER_BIT);
    Gdx.input.setInputProcessor(stage);
    //      System.out.println("########In pagedScrollPaneTest renderer(float)##########");
    Gdx.gl.glClear(GL10.GL_COLOR_BUFFER_BIT);

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

    Table.drawDebug(stage);
}

@Override
public void pause() {}
@Override
public void resume() {}

}

//PlayScreen
public class PlayScreen extends Test {
private final TweenManager tweenManager = new TweenManager();

@Override
public String getTitle() {
    return "Play";
}

@Override
public String getInfo() {
    return "Select which level you want to play.";
}

@Override
public String getImageName() {
    return "tile-path";
}

@Override
public InputProcessor getInput() {
    return null;
}

@Override
protected void initializeOverride() {
    System.out.println("#####Play Screen#####");
    App.inPlay = true;
}

@Override
protected void disposeOverride() {
    tweenManager.killAll();
    super.dispose();

}

@Override
protected void renderOverride() {
    Gdx.gl.glClear(GL10.GL_COLOR_BUFFER_BIT);
    tweenManager.update(Gdx.graphics.getDeltaTime());
}
}

//应用程序类
进口奥利安核糖、吐温发动机、碱吐温；
进口奥利安核糖。吐温发动机。吐温；
进口Aurelianribon.tweenengine.TweenCallback；
导入com.badlogic.gdx.Game；
导入com.badlogic.gdx.gdx；
导入com.badlogic.gdx.Screen；
导入com.badlogic.gdx.graphics.g2d.BitmapFont；
导入com.badlogic.gdx.graphics.g2d.Sprite；
导入com.badlogic.gdx.graphics.g2d.TextureAtlas；
/**
*@作者Aurelian Ribon |http://www.aurelienribon.com/
*/
公共类应用程序扩展了游戏{
私人喷溅屏；
专用发射器屏幕；
私有布尔值isLoaded=false；
静态布尔inPlay=false；
静态布尔levelStarted=false；
静态指数；
水平选择器；
屏幕；
水平；
@凌驾
公共void create（）{
System.out.println（“*********应用程序创建*******”）；
设置航路点Slimit（10）之间的距离；
设置的组合属性限值（3）之间；
Tween.registerAccessor（Sprite.class，新的SpriteAccessor（））；
Assets.inst（）.load（“data/splash/pack”，TextureAtlas.class）；
Assets.inst（）.load（“data/launcher/pack”，TextureAtlas.class）；
Assets.inst（）.load（“数据/测试/包”，TextureAtlas.class）；
Assets.inst（）.load（“data/arial-16.fnt”，BitmapFont.class）；
Assets.inst（）.load（“data/arial-18.fnt”，BitmapFont.class）；
Assets.inst（）.load（“data/arial-20.fnt”，BitmapFont.class）；
Assets.inst（）.load（“data/arial-24.fnt”，BitmapFont.class）；
}
@凌驾
公共空间处置（）{
Assets.inst（）.dispose（）；
如果（splashScreen！=null）splashScreen.dispose（）；
如果（LaunchScreen！=null）LaunchScreen.dispose（）；
if（screen！=null）screen.dispose（）；
}
@凌驾
公共无效呈现（）{
如果（已加载）{
screen=null；
如果（splashScreen！=null）splashScreen.render（）；
if（inPlay&&levelStarted==false）{
splashScreen=null；
启动屏幕=空；
Gdx.graphics.setContinuousRendering（false）；
Gdx.input.setInputProcessor（pspt.stage）；
此设置屏幕（ls）；
}
else if（inPlay&&levelStarted）
{
level.setLevelIndex（levelIndex）；
screen=level.getLevelScreen（）；
如果（屏幕！=null）
{
splashScreen=null；
启动屏幕=空；
Gdx.graphics.setContinuousRendering（false）；
这个。设置屏幕（屏幕）；
}
}
如果（LaunchScreen！=null）LaunchScreen.render（）；
}否则{
if（Assets.inst（）.getProgress（）<1）{
Assets.inst（）.update（）；//资产管理器加载完所有资产后，update返回true
}否则{
发射（）；
isLoaded=true；
inPlay=false；
}
}
}
@替代公共空白调整大小（整数宽度，整数高度）{}
@重写公共无效暂停（）{}
@重写公共无效恢复（）{}
私人无效发射（）{
System.out.println（“*********应用程序启动*******”）；
ls=新的液位选择器（此）；
screen=null；
级别=新级别（）；
splashScreen=新splashScreen（新TweenCallback（）{
@重写公共void onEvent（int类型，BaseTween源）{
测试[]测试=新测试[]{
新信息（），
新帮助（），
新的PlayScreen（）
};
splashScreen.dispose（）；
splashScreen=null；
launcherScreen=新发射器（测试）；
}
});
}
}
//测试班
公共抽象类测试{
私人最终TweenManager TweenManager=新TweenManager（）；
图集；
私人最终精灵背景；
私人最后的精灵面纱；
私人最终精灵信息反馈；
私有最终列表点=新阵列列表（50）；
私有布尔点；
私有回调；
受保护的最终正交摄影机=新正交摄影机（）；
受保护的最终SpriteBatch批次=新SpriteBatch（）；
受保护的最终随机兰德=新随机（）；
受保护的最终位图字体；
受保护的最终浮子wpw=10；
受保护的最终浮点wph=10*Gdx.graphics.getHeight（）/Gdx.graphics.getWidth（）；
受保护的精灵[]精灵；
公开考试（）{
System.out.println（“**********测试构造函数*******”）；
atlas=Assets.inst（）.get（“数据/测试/包”，TextureAtlas.class）；
背景=atlas.createSprite（“背景”）；
维
import com.badlogic.gdx.Game;

public class PacketJourney extends Game {

    @Override
    public void create() 
    {
        setScreen(new MainScreen(this));
    }   
}

import aurelienribon.tweenengine.BaseTween;
import aurelienribon.tweenengine.Tween;
import aurelienribon.tweenengine.TweenCallback;


import com.badlogic.gdx.Screen;
import com.badlogic.gdx.graphics.g2d.BitmapFont;
import com.badlogic.gdx.graphics.g2d.Sprite;
import com.badlogic.gdx.graphics.g2d.TextureAtlas;


public class MainScreen implements Screen
{
    private SplashScreen splashScreen;
    private ScreenLauncher launcherScreen;
    Utils utils;


private boolean isLoaded = false;

public MainScreen()
{
    utils = new Utils(null);
}

public MainScreen(PacketJourney game)
{
    utils = new Utils(game);  
}

@Override
public void render(float delta) 
{
    if (isLoaded) {
        if (splashScreen != null) splashScreen.render();
        if (launcherScreen != null) launcherScreen.render();

    } else {
        if (Assets.inst().getProgress() < 1) {
            Assets.inst().update();  //update returns true when asset manager finishes loading all assets
        } else {
            launch();
            isLoaded = true;
        }
    }
}

@Override
public void resize(int width, int height) 
{

}

@Override
public void show() 
{
    Tween.setWaypointsLimit(10);
    Tween.setCombinedAttributesLimit(3);
    Tween.registerAccessor(Sprite.class, new SpriteAccessor());

    Assets.inst().load("data/splash/pack", TextureAtlas.class);
    Assets.inst().load("data/launcher/pack", TextureAtlas.class);
    Assets.inst().load("data/launcher/screenLauncher", TextureAtlas.class);
    Assets.inst().load("data/arial-16.fnt", BitmapFont.class);
    Assets.inst().load("data/arial-18.fnt", BitmapFont.class);
    Assets.inst().load("data/arial-20.fnt", BitmapFont.class);
    Assets.inst().load("data/arial-24.fnt", BitmapFont.class);
}

@Override
public void hide() 
{

}

@Override
public void pause() 
{

}

@Override
public void resume() 
{

}

private void launch() {
    splashScreen = new SplashScreen(new TweenCallback() {
        @Override public void onEvent(int type, BaseTween source) {
            String str= "";
            switch(type)
            {
                case TweenCallback.BEGIN : str = "BEGIN";
                                           break;

                case TweenCallback.COMPLETE : str = "COMPLETE";
                break;

                case TweenCallback.END : str = "END";
                break;

                case TweenCallback.ANY : str = "ANY";
                break;
            }
            splashScreen.dispose();
            splashScreen = null;
            if(utils.game != null) launcherScreen = new ScreenLauncher(utils.screens,utils.spriteNames,utils);
        }
    });
}

@Override
public void dispose() 
{
    Assets.inst().dispose();
    if (splashScreen != null) splashScreen.dispose();
    if (launcherScreen != null) launcherScreen.dispose();
}

}