How to manage screens

Question

i'm making a game in libgdx but i'm new and i don´t know if my code is the correct form or the best way to do it.

i'm trying to make the basis of the game:

• a screen manager to implement a Menu,
• an option screen
• a loading screen
• a game screen
• a pause Screem
• a game over screen

In the loading screen I like to do something like Dragon Ball when the loading screen allow us to make goku eat rice, the pause screen needs to draw some statistics and options something like Megaman or Castlevania, the menu do something when the player touch a button something like move the camera or open a door, or move to another "scenario" showing another options, and the game over screen needs to previously gives the player the opportunity to win some life to not lose the game.

I try to make this in this form:

I have the main class of the game with the constructor, and the overriden metods create(), render(), resize() and dispose(), the variables for a camera, a viewport, a Spritebatch, a int to store the current screen, and a manager for the screens.

public class BOS_Project extends Game {
    OrthographicCamera camera;
    Viewport viewport;
    SpriteBatch batch;
    AssetManager manager = new AssetManager();
    int actualScreen = 0;

    public BOS_Project(){
        camera = new OrthographicCamera();
        camera.setToOrtho(false, screenWidth, screenHeight);
        viewport = new FitViewport(screenWidth, screenHeight);
    }

    @Override
    public void create(){
        batch = new SpriteBatch();
    }

    @Override
    public void render(){
        actualScreen = 1;
        ScreenManager.getInstance().showScreen(1, this);
        super.render();
    }

    @Override
    public void resize(int width, int height){
        viewport.update(width, height);
    }

    @Override
    public void dispose(){
        batch.dispose();
    }
}

Also the class ScreenManager is singleton, and

public class ScreenManager{
   private static ScreenManager instance;
   private Game game;
   Screen screen;

private ScreenManager(){
    super();
}

public static ScreenManager getInstance(){
    if(instance == null){
        instance = new ScreenManager();
    }
    return instance;
}

public void initialize(Game game){
    this.game = game;
}

public void showScreen(int currentscreen, BOS_Project game){
    if(currentscreen == 1){
        if(screen!=null)
            screen.dispose();
        screen = new LoadingScreen(game, game.actualScreen);
        game.setScreen(screen);
    }else if(currentscreen == 2){
        if(screen!=null)
            screen.dispose();
        screen = new GameScreen(game);
        game.setScreen(screen);
    }else{
        if(screen!=null)
            screen.dispose();
        screen = new MenuScreen(game);
        game.setScreen(screen);
    }
}

The other classes are the MenuScreen, GameScreen and Loading Screen.

Loading Screen:

public LoadingScreen(BOS_Project game2, int screen2){
    game = game2;
    screen = screen2;
    game.manager.load("button.png", Texture.class);
    game.manager.finishLoadingAsset("button.png");
    sprite1 = new Sprite(game.manager.get("button.png", Texture.class));
    sprite1.setPosition(0, 0);
    //This is a method to load the assets for the especific screen
    game.load(screen);
}

@Override
public void render(float delta){
    if(game.manager.getProgress()==1) {
        if (time < 3) {
            Gdx.app.log("Loading: ", "90.0");
        }
    }else {
        Gdx.app.log("Loading: ", String.valueOf(game.manager.getProgress() * 100));
    }
    game.manager.update();
    batch = game.batch;
    Gdx.gl.glClearColor(0, 0, 0, 0);
    Gdx.gl.glClear(GL20.GL_COLOR_BUFFER_BIT);
    batch.begin();
    sprite1.draw(batch);
    if(game.manager.getProgress()==1 && time > 3){
        if(screen==1) {
            ScreenManager.getInstance().showScreen(2, game);
        }else{
            ScreenManager.getInstance().showScreen(3, game);
        }
    }else{
        time += delta;
    }
    batch.end();
    super.render(delta);
}

The Menu and Game classes are similar to loading, only call the assets and draw some sprite on the render method.

This code function well to change screens but I don't know if is the correct form, and another big question is how to manage the pause screen, because I manage this only storing a variable if the variable is pause the render method draw something, if not draw the normal game, but if I want to change the options and images of the pause I need to check variables to know what the pause needs to draw.

 if(pause){
        Gdx.gl.glClearColor(0, 0, 0, 0);
        Gdx.gl.glClear(GL20.GL_COLOR_BUFFER_BIT);
        batch.begin();
        spritePause.draw(batch);
        batch.end();
    }else if(game){
        batch.begin();
        spriteGame.draw(batch);
        batch.end();
    }

So, am i doing it right? or what would you recommend me? Some examples or maybe specific tutorials to achieve this would be great.

Answer 1

There is not only one correct way of managing screens. Libido gives you the freedom to do it exactly how you please. You can extend the Screen class to make screens for the different needs of your project. You can manage your screens as states and manage them with a state manager.

Regarding the Pause and Game Over screen, you can do that in different ways too.

You can have a dedicated screen to switch to or you can have a Pause and GameOver state in your Game state/screen and show the Pause/GameOver elements on top of your gamescreen while the game is still in the background.

So there is not a single correct way of doing it. The correct way is what works for your game.

For some inspiration:

pixnbgames.com : How to manage screens

Brent Aureli : Game State Manager

Answer 2

As @IronMonkey has answered, there is no "correct" way.

I do it with one GameScreen class only, and have a lot of different states inside the GameScreen class. The GameScreen class is very simple and short (100-200 LOC), and is responsible for switching between states. States are similar to the GameScreen class, but they can be entered and exited without the need to instantiate new objecs.

class GameScreen extends ScreenAdapter implements Disposable {
   GameState menuState;
   GameState playState;

   GameState currentState;

   public GameScreen(final MyGame game) {
      menuState = new MenuState(this);
      playState = new PlayState(this);
   }

   public void setState(GameState state) {
      if(currentState == state) return;

      // states have a method 'exit' where you can pause them or finalize something
      if(currentState != null) 
         currentState.exit();

      currentState = state;

      // also states have 'enter' where you can unpause or init something when entering
      currentState.enter();
   }

   public void render(float delta) {
      currentState.render(delta);
   }
}

First, this is very resource efficient, because the needed states are created only once when the game is started. Second, because you never destroy the states, but just change them and call enter/exit, they always retain perfectly their current state, i.e. variables, objects and everything and when you go back to a state, it is exactly as it was before you left it.

GameState is interface and you are free to implement it as you wish.

public interface GameState 
{
    public void enter();
    public void exit();
    public void update(float delta);
    public void render(SpriteBatch batch, float delta);
    public String toString();
    public void dispose();
}