Tworzenie gier w Javie – Tworzenie szkieletu aplikacji LibGDX

W tym rozdziale wygenerujesz szkielet aplikacji korzystającej z LibGDX, zaimportujesz go do IntelliJ IDEA i uruchomisz.

Generowanie aplikacji używającej LibGDX¶

Twórcy LibGDX przygotowali aplikację napisane w języku Java, której możemy użyć do wygenerowaniu "szkieletu" gry korzystającej z tej właśnie biblioteki. Generuje ona prosty projekt z odpowiednią strukturą, konfiguracją Gradle, oraz klasami tworzącymi okno gry, w którym wyświetlany jest przykładowy obrazek. Będzie to nasz punkt wyjścia do tworzenia gier z LibGDX.

Aplikacja ta nazywa się LibGDX Project Setup i możemy pobrać ją z oficjalnej strony – wystarczy kliknąć na przycisk Download Setup App:

https://libgdx.badlogicgames.com/download.html

Po pobraniu aplikacji, uruchamiamy ją dwukrotnym kliknięciem. Po chwili powinno pojawić się okno podobne do poniższego:

Do wypełnienia mamy kilka pól:

• Name – nazwa naszego projektu – możemy wpisać pierwszy-projekt-libgdx,
• Package – główny pakiet naszego projektu – możesz wpisać dowolną nazwę – ja wpisałem com.kursjava.gamedev,
• Game class: nazwa głównej klasy naszego projektu, która będzie punktem startowym działania gry – ja podałem nazwę FirstGdxApp,
• Destination: folder na naszym dysku, gdzie projekt ma zostać wygenerowany.

Dodatkowo, odznacz pola Android, Ios, Html, oraz Box2d. LibGDX pozwala na tworzenie gier nie tylko dla Windows, ale także na np. telefony z Androidem. My skupimy się na tworzeniu gier dla Windows. Box2d to rozszerzenie pozwalające tworzyć elementy z realistyczną fizyką – nie będziemy na razie z tej funkcjonalności korzystać.

Po uzupełnieniu pól, kliknij na przycisk Generate. Pierwsze użycie może chwilę potrwać – aplikacja musi pobrać wymagane zależności. Po zakończeniu, we wskazanym w polu Destination katalogu pojawi się katalog z wygenerowanym projektem. Jest w nim sporo plików i katalogów, jednak większości z nich nie będziemy modyfikować, ponieważ związane są z użyciem Gradle i konfiguracją projektu.

Poniżej znajdziesz krótki opis struktury wygenerowanego projektu:

• settings.gradle oraz gradle.properties to konfiguracja Gradle.
• gradlew.bat – to "opakowanie" do korzystania Gradle'a, dzięki któremu nie musisz pobierać Gradle na swój komputer – zostanie to zrobione za Ciebie automatycznie. Będziemy korzystać z tego skryptu do budowania projektu za pomocą Gradle.
• build.gradle – to konfiguracja projektu korzystającego z Gradle – są w nim m. in. informacje o zależności do biblioteki LibGDX, którą Gradle pobierze dla nas automatycznie.
• katalogi .gradle i gradle zawierają pliki związane z użyciem Gradle.
• .gitignore to przydatny plik konfiguracyjny dla systemu kontroli wersji Git, który wskazuje, których plików Git ma nie brać pod uwagę podczas wersjonowania projektu, ponieważ są one generowane automatycznie i nie powinny być częścią historii zmian repozytorium.
• katalog desktop zawiera tylko jedną klasę, która znajduje się w pliku DesktopLauncher.java – klasa ta służy do uruchamiania naszej aplikacji i konfigurowania rozmiaru okna gry, jego tytułu itp. Wskazuje ona także klasę, która stanowi klasę główną naszej gry, która znajduje się w katalogu core.
• i wreszcie katalog core – to główny katalog naszej aplikacji – będziemy w nim umieszczać klasy Java i różne zasoby, jak np. obrazki i dźwięki. Na razie jest tam tylko jedna klasa w pliku o nazwie FirstGdxApp.java (chyba, że podałeś inną nazwę w polu Game class), która ładuje obrazek z pliku z katalogu core/assets i wyświetla go w oknie.

Możemy teraz zaimportować i uruchomić nasz projekt w IntelliJ IDEA.

Import i uruchomienie projektu w IntelliJ IDEA¶

Aby zaimportować wygenerowany projekt do IntelliJ IDEA, kliknij w menu na File i wybierz Open... Następnie wskaż katalog z wygenerowanym w poprzednim rozdziale projektem i kliknij OK:

Jeżeli korzystasz z wcześniejszej wersji IntelliJ IDEA niż 2020.1.1, to IntelliJ wyświetli okno importu projektu – zaznacz pole Use auto-import oraz odznacz pole Create separate module per source set, a następnie kliknij OK:

Jeżeli jednak korzystasz co najmniej z wersji 2020.1.1, to powyższe okno będzie pominięte i od razu rozpocznie się import projektu.

Daj IntelliJ chwilę na zaimportowanie projektu. Po lewej stronie zobaczysz strukturę plików i katalogów projektu – znajdziesz w nim m. in. dwie klasy:

• DesktopLauncher w katalogu destkop/src/com/kursjava/gamedev/desktop,
• FirstGdxApp w katalogu destkop/src/com/kursjava/gamedev.

Zauważ, że pierwsza klasa została umieszczona w podpakiecie o nazwie desktop. Klasa ta służy do uruchamiania aplikacji korzystających z LibGDX i wygląda następująco:

package com.kursjava.gamedev.desktop;

import com.badlogic.gdx.backends.lwjgl.LwjglApplication;
import com.badlogic.gdx.backends.lwjgl.LwjglApplicationConfiguration;
import com.kursjava.gamedev.FirstGdxApp;

public class DesktopLauncher {
  public static void main (String[] arg) {
    LwjglApplicationConfiguration config = new
      LwjglApplicationConfiguration();
    new LwjglApplication(new FirstGdxApp(), config);
  }
}

W metodzie main tworzymy obiekt typu LwjglApplicationConfiguration, w którym możemy ustawić różne aspekty naszej aplikacji związane z np. wyświetlaniem grafiki i odtwarzaniem dźwięków. Następnie, tworzymy obiekt klasy LwjglApplication, który przyjmuje jako argumenty obiekt klasy głównej naszej gry oraz konfigurację.

Możesz także spojrzeć na klasę FirstGdxApp – zawiera ona krótki kod odpowiedzialny za wczytanie obrazka z katalogu core\assets i wyświetlenie go w oknie programu na czerwonym tle. W dalszej części kursu dokładniej omówimy sobie te zagadnienia.

Pozostało nam jeszcze przygotować konfigurację uruchomieniową, której będziemy używali do uruchamiania naszego projektu. W prawym górnym rogu edytora kodu powinien znajdować się przycisk Add Configuration:

Po jego kliknięciu, pokaże się poniższe okno – kliknij na zaznaczony przycisk +, a następnie wybierz Gradle:

Po prawej stronie okna pojawi się konfigurator uruchomienia – podaj:

• nazwę w polu Name,
• projekt, który ma zostać uruchomiony, czyli pierwszy-projekt-libgdx, w polu Gradle project,
• zadanie, które ma zostać wykonane, w polu Tasks – w naszym przypadku jest to zadanie desktop:run.

Po kliknięciu OK możemy uruchomić nasz pierwszy program klikając na zieloną strzałkę w prawym górnym rogu edytora kodu lub za pomocą skrótu Shift + F10. Po chwili powinna się pojawić aplikacja wyświetlająca obrazek na czerwonym tle:

Uruchamianie aplikacji za pomocą Gradle¶

Nie potrzebujemy IntelliJ IDEA, aby uruchomić naszą aplikację – możemy to zrobić z linii poleceń. Wystarczy z linii poleceń z poziomu głównego katalogu projektu wykonać komendę gradlew desktop:run:

gradlew to skrypt "opakowujący" wykorzystanie Gradle – sprawdzi on, czy mamy Gradle w naszym systemie – jeżeli nie, to pobierze go dla nas.

W wyniku działania tej komendy na ekranie ponownie zobaczymy naszą pierwszą aplikację z obrazkiem na czerwonym tle. Dzięki użyciu tej komendy możesz uruchamiać przykłady dołączone do tego kursu bez potrzeby ich importowania do IntelliJ IDEA.

Generowanie uruchamialnego JARa¶

Za pomocą Gradle możemy wygenerować jeden duży plik JAR, który będzie zawierał naszą grę i wszystkie jej zależności. Taki JAR będzie można uruchomić dwukrotnym kliknięciem.

Aby tego dokonać, wystarczy z poziomu linii poleceń w katalogu głównym naszego projektu wykonać komendę gradlew desktop:dist:

Argument desktop:dist to zadanie, które Gradle ma wykonać. Zostało ono dla nas zdefiniowane w pliku desktop\build.gradle podczas generowania szkieletu projektu. Po chwili działania, Gradle stworzy plik o nazwie desktop-1.0.jar w katalogu pierwszy-projekt-libgdx\desktop\build\libs. Zajrzyj do tego katalogu i kliknij dwa razy na plik desktop-1.0.jar. Nasza aplikacja powinna się uruchomić i wyglądać tak, jak widzieliśmy w poprzednim rozdziale, uruchamiając ją z poziomu IntelliJ IDEA.

Docelowa wersja Java¶

Jeżeli dla wygenerowanego projektu zajrzysz do ustawień Gradle w plikach core/build.gradle oraz desktop/build.gradle, zauważysz, że docelowa wersja Javy ustawiona jest na 1.7:

sourceCompatibility = 1.7

Powodem nieużycia nowszej wersji jest to, że nie wszystkie funkcjonalności języka Java od wersji 1.8 są dostępne na systemach Android. Z racji tego, że nasze gry będziemy tworzyć dla systemu Windows i nie mamy potrzeby, by pisany przez nas kod był zgodny z systemami Android, w przykładach do tego kursu powyższą wersję zmieniłem na 1.8 w obu plikach build.gradle, by móc korzystać np. z lambd.

Polecam zmianę sourceCompatibility w obu plikach zanim zaimportujesz swoje następne projekty wygenerowane za pomocą LibGDX Project Setup. W przeciwnym razie, jak wynika z mojego doświadczenia, IntelliJ może nie wziąć pod uwagę zmian tych parametrów już po zaimportowaniu projektu. Jeżeli zmienisz te parametry po zaimportowaniu projektu, to upewnij się, korzystając ze skrótu Ctrl + Alt + Shift + s, że w oknie Project Structure, które się pojawi, w zakładce Modules, oba wylistowane moduły core oraz desktop mają Language level ustawiony na co najmniej: 8 – Lambdas, type annotations etc:

Aktualizacja 13.05.2020: Wygląda na to, że w najnowszej wersji IntelliJ IDEA 2020.1.1 problem z aktualizacją Language level dla zaimportowanych projektów Gradle został rozwiązany. Jeżeli zmienisz sourceCompatibility po zaimportowaniu projektu, to po zapisaniu pliku build.gradle kliknij na przycisk Reimport All Gradle Projects, aby zaktualizować ustawienia projektu:

Wiemy już jak wygenerować, zaimportować, uruchomić oraz stworzyć uruchamialny JAR, prostej aplikacji korzystającej z LibGDX – możemy teraz przejść do omawiania funkcjonalności LibGDX, które pozwolą nam na tworzenie gier.