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:

Aplikacja LibGDX Project Setup
Aplikacja LibGDX Project Setup

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:

Wskazanie projektu do zaimportowania przez IntelliJ IDEA
Wskazanie projektu do zaimportowania przez IntelliJ IDEA

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:

Ustawienia importu do IntelliJ IDEA projektu LibGDX używającego Gradle
Ustawienia importu do IntelliJ IDEA projektu LibGDX używającego Gradle

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:

rozdzial-02/pierwszy-projekt-libgdx/desktop/src/com/kursjava/gamedev/desktop/DesktopLauncher.java
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.

LWJGL to Lightweight Java Game Library. Jest to biblioteka do tworzenia gier w języku Java, na którą nakładką w aplikacjach desktopowych jest właśnie LibGDX. LWJGL jest przeznaczone dla bardziej zaawansowanych twórców gier w języku Java. LibGDX powstał, aby ułatwić proces tworzenia gier. Pod spodem, LibGDX korzysta z LWJGL.

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:

Otwieranie konfiguracji uruchomienia w IntelliJ IDEA
Otwieranie konfiguracji uruchomienia w IntelliJ IDEA

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

Dodawanie uruchomienia zadania Gradle w IntelliJ IDEA
Dodawanie uruchomienia zadania Gradle w IntelliJ IDEA

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.
Konfiguracja uruchomienia zadania Gradle w IntelliJ IDEA
Konfiguracja uruchomienia zadania Gradle w IntelliJ IDEA

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:

Pierwsza, automatycznie wygenerowana, aplikacja LibGDX
Pierwsza, automatycznie wygenerowana, aplikacja LibGDX

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:

D:\tworzenie-gier\rozdzial-02\pierwszy-projekt-libgdx>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.

Jak już wspominałem we wstępie do kursu, przykłady znajdziesz na GitHubie.

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:

D:\tworzenie-gier\rozdzial-02\pierwszy-projekt-libgdx>gradlew desktop:dist > Task :core:compileJava (...) > Task :desktop:compileJava (...) BUILD SUCCESSFUL in 2s 5 actionable tasks: 5 executed

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:

Sprawdzanie ustawień wersji Java dla modułów Gradle
Sprawdzanie ustawień wersji Java dla modułów Gradle

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:

Aktualizacja ustawień projektów Gradle
Aktualizacja ustawień projektów Gradle

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.

Dodaj komentarz

Twój adres email nie zostanie opublikowany. Nie musisz podawać swojego imienia, e-mailu, ani strony www, aby opublikować komentarz. Komentarze muszą zostać zatwierdzone, aby były widoczne na stronie.