Einstieg in den Source Code

Dieser Eintrag soll den Einstieg in den Source Code erleichtern, indem eine kleiner Überblick darüber gegeben wird, wie ProjektGG und insb. der Teil, der auf libGDX basiert, funktioniert.

Der Ausgangspunkt des Spiels: DesktopLauncher

In der main(...)-Methode der DesktopLauncher-Klasse beginnt das Spiel. Hier werden die Kommandozeilen-Argumente ausgelesen, das Fenster eingerichtet und – ganz wichtig – eine Instanz des Spiels erstellt:

new LwjglApplication(new ProjektGG(options.has("debug"), !options.has("novid")), config);

Die Hauptklasse: ProjektGG

ProjektGG ist die Klasse, in der der Hauptteil der Arbeit abläuft. Zum weiteren Verständnis ist es wichtig zu wissen, dass libGDX-Anwendungen eine Game-Klasse besitzen, die dafür zuständig ist, einzelne Screens zu rendern. Screens sind dabei eine auf dem Bildschirm dargestellte, "in sich schlüssige Situation", d.h. es gibt z.B. einen Hauptmenu-Screen, einen Settings-Screen und einen Ingame-Map-Screen. ProjektGG erweitert diese Game-Klasse (bzw. weitere Subklassen der Game-Klasse) und übernimmt damit die folgenden Methoden, die im Großen und Ganzen nur dafür zuständig sind, den Screen, der gerade angezeigt wird, auswählbar zu machen:

/** The currently shown screen. */
protected Screen screen;

/** Called when the {@link Application} is first created. */
public void create ();

/** Called when the {@link Application} is resized. This can happen at any point during a non-paused 
 * state but will never happen before a call to {@link #create()}.
 * 
 * @param width the new width in pixels
 * @param height the new height in pixels */
public void resize (int width, int height) {
	if (screen != null) screen.resize(width, height);
}

/** Called when the {@link Application} should render itself. */
public void render () {
	if (screen != null) screen.render(Gdx.graphics.getDeltaTime());
}

/** Called when the {@link Application} is paused, usually when it's not active or visible on screen. 
 * An Application is also paused before it is destroyed. */
public void pause () {
	if (screen != null) screen.pause();
}

/** Called when the {@link Application} is resumed from a paused state, usually when it regains focus. */
public void resume () {
	if (screen != null) screen.resume();
}

/** Called when the {@link Application} is destroyed. Preceded by a call to {@link #pause()}. */
public void dispose () {
	if (screen != null) screen.hide();
}

/** @return the currently active {@link Screen}. */
public Screen getScreen () {
	return screen;
}

/** Sets the current screen. {@link Screen#hide()} is called on any old screen, and {@link Screen#show()}
 * is called on the new screen, if any.
 * @param screen may be {@code null} */
public void setScreen (Screen screen) {
	if (this.screen != null) 
		this.screen.hide();
	
	this.screen = screen;

	if (this.screen != null) {
		this.screen.show();
		this.screen.resize(Gdx.graphics.getWidth(), Gdx.graphics.getHeight());
	}
	
}

Die setScreen (Screen)-Methode, die zuständig ist, den aktuell gerenderten Screen festzulegen, wird in der ProjektGG-Klasse dabei durch eine Kombination aus einer addScreen(String, BaseScreen)-Methode und einer pushScreen(String)-Methode ersetzt:

/**
 * A map with all initialized screens.
 */
private Map<String, BaseScreen> screens = new ConcurrentHashMap<>();

/**
 * Adds a screen to the game.
 * 
 * 
 * @param name The name of the screen.
 * @param screen The screen.
 */
public void addScreen(String name, BaseScreen screen) {
	screen.init(this, this.getAssetManager());

	this.screens.put(name, screen);
}

/**
 * Pushes a screen to be the active screen. The screen has to be added to
 * the game beforehand via {@link #addScreen(String, BaseScreen)}.
 * <p>
 * {@link Screen#hide()} is called on the previously {@linkplain Game#screen
 * active screen} and {@link Screen#show()} is called on the new active
 * screen.
 * 
 * @param name The name of the pushed screen.
 */
public void pushScreen(String name) {
	BaseScreen pushedScreen = this.screens.get(name);

	if (pushedScreen == null) {
		throw new ScreenNotFoundException("Could not find a screen named '" + name
			+ "'. Add the screen via #addScreen(String, BaseScreen) first.");
	}

	if (screen != null) {
		screen.hide();
	}

	if (!pushedScreen.isLoaded()) {
		assetManager.load(pushedScreen);
		assetManager.finishLoading();
		pushedScreen.finishLoading();
	}

	pushedScreen.show();
	this.screen = pushedScreen;
}

Ein BaseScreen (letztlich auch nur ein Screen, aber dazu in diesem Eintrag mehr) muss zunächst über die addScreen(String, BaseScreen)-Methode zum Spiel hinzugefügt werden. Dadurch wird der Screen initialisiert, d.h. mit allen relevanten Variablen "gefüttert", und mit einem Namen in der Anwendung registriert. Um den Screen hinterher zum gerade aktiven Screen zu machen, kann anschließend die pushScreen(String)-Methode mit dem Namen des Screens als Parameter aufgerufen werden. Diese Methode kümmert sich auch darum, die Assets eines Screens zu laden (über assetManager.load(pushedScreen);), sofern diese nicht bereits anderweitig geladen wurden (bspw. durch einen Loading Screen).

Zum Spiel hinzugefügt werden die Screens in der create()-Methode von ProjektGG, die dafür zuständig ist, das komplette Spiel zu initialisieren. D.h. hier werden alle wichtigen Variablen (spriteBatch, AssetManager, gameCamera, eventBus, etc.) gesetzt.

Wie geht's weiter?

Als nächste Station bietet sich der Artikel zu den Screens an, der einen Überblick über die einzelnen Screens und ihre Funktionen liefert.