Comment redémarrer l'écran dans LibGDX en utilisant les méthodes Init()?

Question

J'ai créé un jeu simple dans LibGDX qui a plusieurs écrans. Je veux redémarrer un certain écran après avoir appuyé sur un bouton de redémarrage, mais je ne suis pas sûr de savoir comment le faire. J'ai fait des recherches à ce sujet et toutes les réponses conduisent à ne pas charger mes assets dans show() mais plutôt dans une méthode init() que je ne connais pas vraiment. Je veux savoir comment puis-je redémarrer un écran en utilisant cette méthode init(). A partir de maintenant, j'ai mis la plupart de mon initialisation dans le constructeur et certains ont été initialisés dans des méthodes telles que la méthode restartButton(). Toute autre correction ou amélioration de mon code sera très appréciée. Voici un extrait de mon code:

public class LevelOneScreen implements Screen { 

public MainShooter app; 
private Stage stage; 
private Stage stageCoin; 
private Stage stageScore; 
private Stage stageEnemies; 
private Stage stageFX; 
private Stage stageButton; 

public Image aImage; 
public Image bImage; 
public Image cImage; 
public Image dImage; 

public Array<AntAnimation> AntAnimate; 
public Array<CrumbAnimation> CrumbAnimate; 
public Array<CoinAnimation> CoinAnimate; 

public Texture firstTex; 
public Texture secTex; 
public Texture thirdTex; 
public Texture fourthTex; 


public LevelOneScreen(final MainShooter app){ 

this.app = app; 
this.stage = new Stage(new StretchViewport(app.screenWidth, app.screenHeight, app.camera)); 
this.stageCoin = new Stage(new StretchViewport(app.screenWidth, app.screenHeight, app.camera)); 
this.stageScore = new Stage(new StretchViewport(app.screenWidth, app.screenHeight, app.camera)); 
this.stageEnemies = new Stage(new StretchViewport(app.screenWidth, app.screenHeight, app.camera)); 
this.stageFX = new Stage(new StretchViewport(app.screenWidth, app.screenHeight, app.camera)); 
this.stageButton = new Stage(new StretchViewport(app.screenWidth, app.screenHeight, app.camera)); 

AntAnimate = new Array<AntAnimation>(); 
CrumbAnimate = new Array<CrumbAnimation>(); 
CoinAnimate = new Array<CoinAnimation>(); 

restartButton(); 
levelOneBackground(); 
coinScore(); 


} 


public void show() { 


    inputMultiplexer = new InputMultiplexer(); 
    inputMultiplexer.addProcessor(stageCoin); 
    inputMultiplexer.addProcessor(stageScore); 
    inputMultiplexer.addProcessor(stageEnemies); 
    inputMultiplexer.addProcessor(stageFX); 
    inputMultiplexer.addProcessor(stageButton); 

    Gdx.input.setInputProcessor(inputMultiplexer); 

    } 

    public void levelOneBackGround(){ 
    //code for the background 
    } 


    public void coinScore(){ 
    //code for coinScore 
    } 

    public void restartButton(){ 
    firstTex = MainShooter.manager.get("button.png", Texture.class); 
    aImage = new Image(firstTex); 
    stageButton.addActor(aImage); 
    aImage.addListener(new ActorGestureListener() { 
     public void touchDown(InputEvent event, float x, float y, int pointer, int button) { 

     // Creating new LevelOneScreen somehow affects the fps of my game. 
     app.setScreen(new LevelOneScreen(app)); 


     }}); 
    } 


//some other codes like dispose, hide, etc. 

} 

Cette modification est une réponse à une réponse fournie par IronMonkey qui semble résoudre le problème, mais a besoin d'un code supplémentaire. Le problème ici est que chaque fois que le jeu est redémarré, les acteurs de l'écran redémarré sont au-dessus des acteurs de l'écran précédent (l'écran avant de redémarrer). Voici un nouvel extrait de mon code montrant comment redémarrer le jeu en utilisant mon GameInit():

 public void GameInit(){ 
    levelOneBackground(); 
    scoreInt = 0; 
    coinInt = 0; 
} 


public void levelOneBackground(){ 

     Runnable runAntAct1 = new Runnable(){ 
      public void run(){ 
       antAct1(); 
      } 
     }; 
     Runnable runAntAct2= new Runnable(){ 
      public void run(){ 
       antAct2(); 
      } 
     }; 
     Runnable runAntAct3 = new Runnable(){ 
      public void run(){ 
       antAct3(); 
      } 
     }; 
     Runnable runCoins = new Runnable(){ 
      public void run(){ 
       coinScattered(); 
      } 
     }; 
     levelOneTexture = CoinAssets.manager.get("woodenTable.png",Texture.class); 
     levelOneImage = new Image(levelOneTexture); 
     levelOneImage.setSize(app.screenWidth,app.screenHeight); 
     levelOneImage.setPosition(0,0); 
     stage.addActor(levelOneImage); 
     levelOneImage.addAction(sequence(run(runAct1),delay(2f),run(runAct2),delay(2f),run(runAct3),delay(2f),run(runCoins))); 


} 

public void restartButton(){ 
    //some code for the position, size, texture of the button. 
    restartButton.addListener(new ActorGestureListener() { 
      public void touchDown(InputEvent event, float x, float y, int pointer, int button) { 
       GameInit();}}); 
} 


public void antAct1(){ 
     for(int i = 1; i < 4; i++){AntAnimate.add(new AntAnimation(app));} 

     AntAnimate.get(1).setPosition(x,y); 
     stageEnemies.addActor.(AntAnimate.get(1)); 
     AntAnimate.get(1).addAction(//some actions); 

      AntAnimate.get(2).setPosition(x,y); 
     stageEnemies.addActor.(AntAnimate.get(2)); 
     AntAnimate.get(2).addAction(//some actions); 

      AntAnimate.get(3).setPosition(x,y); 
     stageEnemies.addActor.(AntAnimate.get(3)); 
     AntAnimate.get(3).addAction(//some actions); 

} 

public void antAct2(){ 
    //almost the same with antAct1() 
} 

public void antAct3(){ 
    //almost the same with antAct1() 
} 

public void coinScattered(){ 
    //almost the same with antAct1() 
} 

Answer 1

show() est appelée automatiquement lorsque l'écran est d'abord affichée.

La méthode init() est celle que vous créez vous-même. Vous pouvez l'appeler comme vous voulez. Vous ne devez pas charger tous les actifs dans init() simplement mettre tous les éléments en place, score = 0, player.setPosition (0,0) etc.

Lorsque vous appelez init(), vous définissez toutes les variables. Lorsque vous appelez à nouveau init(), vous les définissez à nouveau. (re set)

modifier efter la question:

Dans les méthodes appelées à partir GameInit() vous chargez des fichiers qui sont déjà chargés et ajouter des acteurs à des étapes où les acteurs sont déjà là et donc maintenant chevauchement Vous ajoutez également des actions et créez des objets déjà créés.

Tout ce que GameInit() doit faire est de définir des valeurs pour les objets déjà créés. Donc, en gros:

private void GameInit(){ 
     AntAnimate.get(1).setPosition(x,y); 
     AntAnimate.get(2).setPosition(x,y); 
     AntAnimate.get(3).setPosition(x,y); 
     levelOneImage.setPosition(0,0); 
     scoreInt = 0; 
     coinInt = 0; 
} 

Chargement et à la création d'objets ne doivent pas faire plus d'une fois. Essayez simplement d'ajouter ma méthode GameInit(), appelez-la GameReset() et appelez-la à partir de votre bouton de réinitialisation.