Pierwsze kroki z Unity i Grami Google Play na PC

1. Wprowadzenie

Ostatnia aktualizacja: 2022-10-18

Jak przygotować grę do Gier Google Play na PC?

Gry Google Play ułatwiają przenoszenie gier mobilnych na komputery z systemem Windows. Dzięki temu możesz zwiększyć zaangażowanie graczy i rozszerzyć grono odbiorców bez konieczności przebudowywania gry czy zmiany modelu biznesowego. Musisz jeszcze wprowadzić kilka zmian, aby zapewnić nowym graczom na PC jak najlepsze wrażenia.

Czego się nauczysz

Ten samouczek obejmuje podstawowe części listy kontrolnej wymagań, które pomogą Ci rozpocząć pracę nad grą i przygotować ją do Gier Google Play na PC. Bardziej zaawansowane integracje, takie jak logowanie w Grach Play czy interfejs Play Integrity API, nie są objęte tym artykułem.

• Jak tworzyć aplikacje na architekturę x86 w Unity.
• Jak testować i wdrażać w emulatorze Gier Google Play.
• Jak zmodyfikować interfejs, aby dobrze wyglądał na komputerze.
• Jak wykryć, czy gra jest uruchomiona w emulatorze Gier Google Play, i odpowiednio ją dostosować.

Czego potrzebujesz

• Zainstalowana wersja Unity 2020 LTS (te ćwiczenia z programowania zostały utworzone w wersji 2020.3.30f1).
• Emulator Gier Google Play.

2. Konfiguracja

Otwieranie lub tworzenie nowego projektu

1. Utwórz nowy projekt za pomocą mikrogry 2D Platformer lub otwórz własny projekt.

2. W projekcie wybierz File –> Build Settings (Plik –> Ustawienia kompilacji) i sprawdź, czy możesz tworzyć kompilacje na Androida.

3. Przygotowywanie emulatora Gier Google Play

Zacznij od pobrania emulatora.

Po zainstalowaniu powinien Ci się wyświetlić pulpit Androida w oknie:

Uwaga: emulator jest widoczny na liście aplikacji jako Emulator dla deweloperów Gier Google Play.

Jest to w pełni funkcjonalne środowisko Androida o wysokiej wydajności, odpowiednie do tworzenia gier. Powinien pojawić się w Android Debug Bridge (adb) jako urządzenie na hoście lokalnym:

❯ adb devices
List of devices attached
localhost:6520  device

Aby wykryć emulator, musisz mieć najnowszą wersję adb. Wersja dołączona do Androida Studio działa, ale adb dostarczany z Unity może nie działać. Zgodna wersja jest dołączona do emulatora i można ją znaleźć pod adresem C:\Program Files\Google\Play Games Developer Emulator\current\emulator. Aby zapewnić sobie jak najlepsze środowisko programistyczne, możesz zainstalować Android Studio i używać go do zarządzania pakietem Android SDK.

Jeśli emulator odłączy się od adb, połącz go ponownie z wiersza poleceń w ten sposób:

adb connect localhost:6520

4. Konfigurowanie Unity do bezpośredniego kompilowania i wdrażania w emulatorze (opcjonalnie)

Wersja adb dostarczana z Unity może być niezgodna z emulatorem. Aby się upewnić, wybierz File (Plik) –> Build Settings (Ustawienia kompilacji) i sprawdź, czy w oknie Run Device (Uruchom urządzenie) jest wyświetlany Twój telefon.

Uwaga: jeśli przed testowaniem uruchomisz adb, pamiętaj, aby używać adb connect localhost:6520 z wersją adb dostarczaną z Unity. Żadna z testowanych wersji Unity w momencie pisania tego artykułu nie zawiera zgodnego narzędzia adb.

W zależności od projektu, procesu kompilacji i poziomu zaawansowania możesz skonfigurować Unity tak, aby wdrażać aplikację bezpośrednio w emulatorze Gier Google Play, lub skompilować plik APK i wdrożyć go ręcznie za pomocą adb install. Wdrożenie ręczne wymaga najmniejszej liczby zmian, ale może spowolnić cykl iteracji.

Aby wdrożyć aplikację bezpośrednio w emulatorze, wykonaj te 2 czynności:

1. Skonfiguruj Unity tak, aby używać innego pakietu Unity SDK, najlepiej tego zainstalowanego przez Android Studio.
2. Zaktualizuj wersję narzędzi kompilacji, aby obejść błąd w Unity.

Wersja pakietu Android SDK dostarczana z Unity prawdopodobnie nie wykryje emulatora, dlatego do zainstalowania nowszego pakietu SDK użyj Android Studio.

1. Otwórz Android Studio i kliknij Edytuj –> Preferencje –> Narzędzia zewnętrzne.
2. Odznacz Android SDK Tools Installed with Unity i podaj ścieżkę do instalacji Android Studio (zwykle AppData/Local/Android/sdk). Nie zmieniaj opcji Android NDK.

Po odświeżeniu połączonych urządzeń w oknie kompilacji powinna się pojawić ikona Google HPE device (localhost:6520):

Uwaga: jeśli emulator się nie pojawi, może być konieczne uruchomienie polecenia adb connect localhost:6520. Dzieje się tak, ponieważ wbudowany w Unity adb ma pierwszeństwo, dopóki go nie zmienisz i ręcznie nie połączysz się z nową instancją adb.

W zależności od stanu tego błędu i wersji Unity może być też konieczna zmiana wersji narzędzi do kompilacji. Aby to zrobić, sprawdź, czy generujesz mainTemplate.gradle i launcherTemplate.gradle.

3. Otwórz okno Ustawienia projektu, a następnie Ustawienia odtwarzacza i znajdź sekcję Publishing Settings.
4. Przewiń w dół do opcji Build (Kompilacja) i zaznacz „Custom Main Gradle Template” (Niestandardowy główny szablon Gradle) oraz „Custom Launcher Gradle Template” (Niestandardowy szablon Gradle programu uruchamiającego). Spowoduje to wygenerowanie obu plików Gradle w folderze Assets\Plugins\Android\.

Uwaga: projekty korzystające z bibliotek EDM4U i androidx, takie jak Firebase, również wymagają wygenerowania Custom Gradle Properties Template, aby prawidłowo rozwiązywać zależności. Jeśli w przeszłości nie używasz niestandardowego szablonu Gradle, warto też sprawdzić to ustawienie.

1. Zastąp każde wystąpienie ciągu **BUILDTOOLS** ciągiem 30.0.0. W obu plikach sekcja kodu powinna teraz wyglądać tak:

android {
    compileSdkVersion **APIVERSION**
    buildToolsVersion '30.0.0'

5. Wdrażanie na Chromebooku (opcjonalnie)

Możesz zacząć tworzyć gry na Gry Google Play bez dostępu do emulatora Gry Google Play, używając urządzenia z ChromeOS. Podobnie jak w przypadku Gier Google Play na PC, Chromebooki mają klawiatury i myszy, duże ekrany i są dostępne w konfiguracjach x86. Użyjemy wtyczki Unity Android Logcat na Chromebooku.

1. Otwórz Menedżera pakietów i wyszukaj Android Logcat w sekcji Unity Registry.

Musisz też skonfigurować Chromebooka pod kątem tworzenia aplikacji na Androida. Zacznij od włączenia Linuksa.

2. Wybierz Ustawienia –> Deweloper –> Linux.

Następnie włącz debugowanie ADB.

3. Wybierz Ustawienia –> Programiści –> Środowisko programistyczne Linuksa –> Tworzenie aplikacji na Androida –> Włącz debugowanie ADB.

Warto też sprawdzić adres IP Chromebooka. Najłatwiej to zrobić,

4. Kliknij ikonę Informacje o sieci, aby uzyskać adres IP Chromebooka.

5. Kliknij Window –> Analysis –> Android Logcat, aby otworzyć okno Android Logcat.

6. Otwórz listę urządzeń. Jeśli nic nie jest połączone, może być widoczny komunikat No Device.

7. Kliknij Inne opcje połączenia i wpisz adres IP Chromebooka.

8. Kliknij Połącz. Powinno się wyświetlić okno Success (Sukces):

Chromebook pojawi się teraz na liście urządzeń w Unity (może być konieczne odświeżenie ekranu):

Możesz teraz wdrażać gry na Chromebooku i rozpocząć testowanie oraz tworzenie na sprzęcie podobnym do komputera.

6. Wdrażanie kompilacji testowej

Gry Google Play wymagają wdrożenia wersji gry na architekturę x86, co jest jednym z czynników wpływających na osiąganie przez nią wyników na komputerach stacjonarnych. Wszystkie warianty LTS silnika Unity mogą generować kompilacje na Androida zgodne z architekturami x86 i x86-64 (oznaczone jako „ChromeOS”), a Unity w wersji 2018 i starszych może generować kompilacje na architekturę x86. Aby odblokować te architektury, musisz najpierw przełączyć się na backend skryptowy IL2CPP, co prawdopodobnie robisz już w środowisku produkcyjnym w celu obsługi architektury arm64.

1. Wybierz File (Plik) –> Build Settings (Ustawienia kompilacji), aby otworzyć okno Build Settings (Ustawienia kompilacji), a następnie kliknij Player Settings (Ustawienia odtwarzacza).

2. Otwórz sekcję Inne ustawienia i przełącz Scripting Backend na IL2CPP.

Warto też włączyć obsługę x86 lub x86-64. Aby opublikować grę na platformie Gry Google Play, musisz obsługiwać architekturę x86, ale zalecamy x86-64.

Uwaga: każda dodatkowa architektura, którą dodasz, wydłuża czas kompilacji. Chociaż możesz bezpiecznie połączyć wszystkie platformy ARM i x86 w jednym pakiecie, podczas tworzenia funkcji możesz wybrać tylko x86 lub x86-64.

Wersja biblioteki Frame Pacing dołączonej do silnika Unity jest też niezgodna z Grami Google Play i powoduje awarię gry podczas uruchamiania.

3. Aby wyłączyć synchronizację klatek w oknie Ustawienia odtwarzacza, otwórz sekcję Rozdzielczość i prezentacja i odznacz opcję Zoptymalizowana synchronizacja klatek.

Możesz teraz zacząć tworzyć.

1. Ponownie otwórz okno Ustawienia kompilacji i kliknij Skompiluj i uruchom. Gra pojawi się w oknie emulatora.

Jeśli nie możesz wdrożyć gry, sprawdź, czy na liście „Run Device” (Uruchom urządzenie) widnieje pozycja „Google HPE device (localhost:6520)”. Jeśli go nie ma, sprawdź, czy HPE_Dev jest uruchomiony i czy widzisz ekran główny Androida. Jeśli nadal nie widzisz go na liście urządzeń, uruchom adb connect localhost:6520 z dokładnym adb.exe, którego używasz. Jeśli używasz wtyczki Android Logcat Unity, wybierz Tools -> Open Terminal (Narzędzia –> Otwórz terminal), aby otworzyć terminal w katalogu, którego używa Unity.adb.exe

Otwórz terminal" highlighted" style="width: 624.00px" src="img/9101ce3c95fb1aa2.png" srcset="img/9101ce3c95fb1aa2_36.png 36w, img/9101ce3c95fb1aa2_48.png 48w, img/9101ce3c95fb1aa2_72.png 72w, img/9101ce3c95fb1aa2_96.png 96w, img/9101ce3c95fb1aa2_480.png 480w, img/9101ce3c95fb1aa2_720.png 720w, img/9101ce3c95fb1aa2_856.png 856w, img/9101ce3c95fb1aa2_960.png 960w, img/9101ce3c95fb1aa2_1440.png 1440w, img/9101ce3c95fb1aa2_1920.png 1920w, img/9101ce3c95fb1aa2_2880.png 2880w" sizes="(max-width: 840px) 100vw, 856px">

7. Dostosowywanie gry do PC

W miarę możliwości wprowadzaj zmiany w grze na podstawie niezależnych od platformy rodzajów danych lub obecności określonych funkcji. Na przykład gracz na Androidzie może podłączyć mysz i klawiaturę lub monitor. Zmiana schematu sterowania lub elementów HUD w reakcji na konfigurację urządzenia pozwala wykorzystać Gry Google Play na PC na wszystkich obsługiwanych platformach.

Jeśli chcesz zmienić logikę w zależności od tego, czy gracz korzysta z Gier Google Play czy ChromeOS, ten skrypt pomoże Ci to wykryć, sprawdzając funkcję systemową HPE_EXPERIENCE:

using UnityEngine;

public class GoogleDeviceUtilities
{
#if UNITY_ANDROID && !UNITY_EDITOR
    private static AndroidJavaObject PackageManager
    {
        get
        {
            var unityPlayerClass = new AndroidJavaClass("com.unity3d.player.UnityPlayer");
            var currentActivity = unityPlayerClass.GetStatic<AndroidJavaObject>("currentActivity");
            return currentActivity.Call<AndroidJavaObject>("getPackageManager");
        }
    }

    public static bool IsChromeOS => PackageManager.Call<bool>("hasSystemFeature", "org.chromium.arc");

    public static bool IsGooglePlayGames =>
        PackageManager.Call<bool>("hasSystemFeature", "com.google.android.play.feature.HPE_EXPERIENCE");

    public static bool HasKeyboard
    {
        get
        {
            var unityPlayerClass = new AndroidJavaClass("com.unity3d.player.UnityPlayer");
            var currentActivity = unityPlayerClass.GetStatic<AndroidJavaObject>("currentActivity");
            var resources = currentActivity.Call<AndroidJavaObject>("getResources");
            var configuration = resources.Call<AndroidJavaObject>("getConfiguration");
            var keyboard = configuration.Get<int>("keyboard");
            return keyboard == 2; // Configuration.KEYBOARD_QWERTY
        }
    }
#else
    public static bool IsChromeOS => false;
    public static bool IsGooglePlayGames => false;
    public static bool HasKeyboard => true;
#endif
}

Komputery mają większy wyświetlacz niż typowy telefon z Androidem. W miarę możliwości zalecamy, aby wyświetlacz HUD zajmował nie więcej niż 20% ekranu. Wiele gier mobilnych korzysta z opcji „Skaluj do rozmiaru ekranu”, więc zmiana tego ustawienia na „Stały rozmiar fizyczny” lub „Stały rozmiar w pikselach” może być dobrym pierwszym krokiem do osiągnięcia tego celu.

Możesz też dynamicznie ustawiać jakość za pomocą polecenia QualitySettings.SetQualityLevel w czasie działania, jeśli wykryjesz, że gra jest uruchomiona w Grach Google Play. Emulator Gry Google Play używa ANGLE do wydawania natywnych poleceń DirectX lub Vulkan z poleceń OpenGL emitowanych przez Unity, dzięki czemu możesz uzyskać wyższą jakość grafiki niż w przypadku wersji gier mobilnych.

8. Obsługa danych wejściowych

Gry udostępniane w Gry Google Play powinny być dostosowane do sterowania za pomocą myszy i klawiatury. Musisz zaplanować, jak będzie wyglądać interakcja z grą za pomocą myszy i klawiatury, więc poświęć trochę czasu na pobranie pakietu Input SDK w formacie unitypackage. Jeśli nie widzisz pobierania na tej stronie, sprawdź, czy używasz konta należącego do grupy play-mp-libs.

Na potrzeby testów wiele gier ma podstawowe sterowanie myszą i klawiaturą, które jest wykorzystywane podczas tworzenia w edytorze. W miarę możliwości włączaj te funkcje, gdy korzystasz z urządzenia z ChromeOS lub emulatora Gier Google Play.

Uwaga: jeśli obecnie używasz #if UNITY_EDITOR do wykrywania, czy aplikacja jest uruchomiona w edytorze, zmień to na sprawdzanie w czasie działania if (Application.isEditor), aby sprawdzać też GoogleDeviceUtilities.IsGooglePlayGames lub GoogleDeviceUtilities.HasKeyboard.

Domyślnie Gry Google Play i ChromeOS przekształcają sygnał myszy w symulowane dotknięcie. Jeśli używasz Input.GetTouch i Input.touchCount, gra nadal działa zgodnie z oczekiwaniami. Jeśli korzystasz z wejścia wielodotykowego, np. sterowania dwoma kciukami lub powiększania za pomocą gestu uszczypnięcia, musisz przypisać działanie do naciśnięć klawiszy. Powinieneś też przypisać działania w grze do naciśnięć klawiszy, np. naciśnięcie klawisza i otwiera ekwipunek, Escape zamyka okna dialogowe, a Enter wysyła wiadomości w grze.

W mikrogierce 2D Platformer do poruszania się używa się strzałek, a do skakania – spacji. Jeśli używasz własnej gry, upewnij się, że masz preferowane przypisania klawiszy na potrzeby następnego kroku.

9. Integracja pakietu SDK do wprowadzania danych

Po skonfigurowaniu sterowania myszą i klawiaturą musisz dodać obsługę pakietu Input SDK . Dzięki temu gracze mogą odkrywać wejścia na PC za pomocą przydatnego wyskakującego okienka:

1. Po zaimportowaniu pakietu SDK do projektu utwórz plik o nazwie InputMappingProviderBehaviour.cs i dodaj do niego te treści:

using System.Collections.Generic;
using Google.Play.InputMapping;
using UnityEngine;
using Input = Google.Play.InputMapping.Input;

public class InputMappingProviderBehaviour : MonoBehaviour
{
    private void Start()
    {
        Input.GetInputMappingClient().RegisterInputMappingProvider(new MyInputMappingProvider());
    }

    private class MyInputMappingProvider : InputMappingProvider
    {
        public InputMap OnProvideInputMap()
        {
            return new InputMap
            {
                InputGroups = new List<InputGroup> { },
                MouseSettings = new MouseSettings
                {
                    InvertMouseMovement = false,
                    AllowMouseSensitivityAdjustment = false
                }
            };
        }
    }

    private enum ActionIds
    {
    }
}

2. Teraz wypełnij pole ActionIds listą działań, których używasz w swojej grze. W przypadku mikrogry 2D Platformer są to: w lewo, w prawo i skok:

private enum ActionIds
{
    Left,
    Right,
    Jump
}

3. W OnProvideInputMap utwórz InputAction dla każdego działania. W tym celu musisz podać nazwę działania, dane wejściowe, a następnie przyciski myszy lub kody klawiszy, które będą z nim powiązane. W przypadku przykładowej gry:

var leftAction = new InputAction
{
    ActionLabel = "Walk Left",
    UniqueId = (int)ActionIds.Left,
    InputControls = new InputControls
    {
        AndroidKeycodes = new[]
        {
            AndroidKeyCode.KEYCODE_DPAD_LEFT
        }
    }
};

var rightAction = new InputAction
{
    ActionLabel = "Walk Right",
    UniqueId = (int)ActionIds.Right,
    InputControls = new InputControls
    {
        AndroidKeycodes = new[]
        {
            AndroidKeyCode.KEYCODE_DPAD_RIGHT
        }
    }
};

var jumpAction = new InputAction
{
    ActionLabel = "Jump",
    UniqueId = (int)ActionIds.Jump,
    InputControls = new InputControls
    {
        AndroidKeycodes = new[]
        {
            AndroidKeyCode.KEYCODE_SPACE
        }
    }
};

4. Następnie podziel te działania na grupy.

W przypadku mikrogry mamy tylko 1 grupę, ale możesz utworzyć ich tyle, ile potrzebujesz, aby pomóc graczom znaleźć potrzebne działania. Dodaj to do OnProvideInputMap:

var movementInputGroup = new InputGroup
{
    GroupLabel = "Movement",
    InputActions = new List<InputAction>
    {
        leftAction, rightAction, jumpAction
    }
};

5. Dodaj do mapy wejściowej wszystkie utworzone grupy wejściowe. Zmodyfikuj instrukcję powrotu w OnProvideInputMap, aby brzmiała:

return new InputMap
{
    InputGroups = new List<InputGroup> { movementInputGroup },
    MouseSettings = new MouseSettings
    {
        InvertMouseMovement = false,
        AllowMouseSensitivityAdjustment = false
    }
};

6. Na koniec dodaj utworzony skrypt do gry:

7. Gdy ponownie wdrożysz grę, naciśnij Shift+Tab, aby otworzyć nakładkę w grze.

8. Kliknij Elementy sterujące, aby zobaczyć skonfigurowane elementy sterujące.

10. Usuwanie osadzonych widoków stron internetowych

Aby zapewnić graczom jak najlepsze wrażenia, usuń umieszczone widoki internetowe. Osadzone widoki internetowe są często używane do wyświetlania takich elementów jak Polityka prywatności czy Warunki korzystania z usług. Chociaż działają one w Grach Google Play, wyświetlają się w osadzonej przeglądarce „mobilnej”, a nie w preferowanej przeglądarce na komputer, co może wprowadzać graczy na PC w błąd. Dlatego w Unity, jeśli używasz rozszerzeń do wyświetlania osadzonej przeglądarki, wróć do Application.OpenURL(url).

11. Uprawnienia i funkcje

W Grach Google Play nie są obsługiwane niektóre funkcje i uprawnienia Androida. Ogólna zasada jest taka, że aplikacja na PC nigdy nie powinna wyświetlać okna dialogowego z prośbą o uprawnienia. Gdy masz już gotową kompilację, warto przeprowadzić typową nową instalację i zanotować wszystkie wyświetlane okna, aby dodać je do listy „do zrobienia” przed przesłaniem gry.

Niektóre gry na platformie Unity proszą o uprawnienia za pomocą interfejsu Android.Permission API. W takim przypadku należy użyć sprawdzania if (GoogleDeviceUtilities.IsGooglePlayGames) i w razie potrzeby przejść bezpośrednio do logiki błędu.

12. Optymalizacje na komputery

Gry Google Play różnią się od typowego telefonu z Androidem, więc warto odpowiednio skonfigurować grę.

Przełącz na DXT, aby skompresować teksturę. Popularne formaty tekstur Androida, takie jak ETC, są dekodowane w pamięci w czasie działania, jeśli nie można ich bezpośrednio przekazać do procesora graficznego odtwarzacza. ASTC zapewnia najlepszą zgodność z komputerami, ale aby sprawdzić oczekiwane działanie gry, musisz użyć narzędzia do profilowania GPU na komputerze.

Ponieważ korzystasz teraz z karty graficznej na komputerze stacjonarnym, możesz też zwiększyć jakość grafiki. Możesz to zmienić bezpośrednio w Ustawieniach projektu w sekcji Jakość.

13. Gratulacje

Masz już wszystko, co potrzebne, aby rozpocząć pracę nad grą na potrzeby Gier Google Play. Możesz rozpocząć testowanie i ulepszanie gry. Pamiętaj, że chociaż możesz zachować tę samą bazę kodu, warto dostosować grę, aby sprawiała wrażenie natywnej gry na PC.

Co dalej?

Aby opublikować grę w Grach Google Play, musisz wykonać jeszcze kilka czynności:

• Najnowsze informacje znajdziesz w krótkim wprowadzeniu.
• Przejdź na logowanie w usługach gier Play w wersji 2, aby automatycznie logować gracza podczas uruchamiania gry i spełniać wymagania dotyczące ciągłości.
• Wdróż interfejs Play Integrity API, aby zapewnić bezpieczeństwo na PC na takim samym poziomie jak na urządzeniach mobilnych.

Większość pracy wykonanej do tej pory w celu obsługi Gier Google Play pomoże Ci też w publikowaniu gier na ChromeOS. Warto rozważyć obsługę tej platformy wraz z komputerami.