Pierwsze kroki z Unity i Grami Google Play na PC

1. Wprowadzenie

Ostatnia aktualizacja: 18.10.2022 r.

Jak przygotować swoją grę do korzystania z Gier Google Play na PC?

Gry Google Play ułatwiają przeniesienie gier mobilnych na komputery z systemem Windows. Oznacza to, że możesz zwiększyć zaangażowanie graczy i liczbę odbiorców bez konieczności zmiany architektury gry czy zmiany modelu biznesowego. Musisz wprowadzić jeszcze kilka zmian, aby zapewnić nowym graczom PC najlepsze wrażenia.

Czego się nauczysz

To ćwiczenie w Codelabs obejmuje podstawowe elementy listy kontrolnej wymagań, które pozwolą Ci uruchomić grę i przygotować własną grę Unity do Gier Google Play na PC. Nie omówimy bardziej szczegółowych integracji, takich jak logowanie w Grach Play czy interfejs Play Integrity API.

• Dowiedz się, jak tworzyć na potrzeby architektury x86 Unity.
• Dowiedz się, jak testować i wdrażać emulator Gier Google Play.
• Jak zmodyfikować interfejs, aby wyglądał świetnie na komputerze.
• Jak sprawdzić, czy gra działa w emulatorze Gier Google Play, i odpowiednio ją dostosować.

Czego potrzebujesz

• Instalacja Unity 2020 LTS (to ćwiczenie z programowania zostało utworzone w wersji 2020.3.30f1).
• Emulator Gier Google Play.

2. Konfiguracja

Otwórz lub utwórz projekt

1. Utwórz nowy projekt za pomocą platformówki 2D lub utwórz własny.

2. W projekcie wybierz Plik -> Ustawienia kompilacji i sprawdź, czy masz włączone kompilację pod kątem Androida.

3. Przygotowywanie emulatora Gier Google Play

Zacznij od pobrania emulatora.

Po zainstalowaniu aplikacji powinien wyświetlić się pulpit z Androidem:

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

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

❯ adb devices
List of devices attached
localhost:6520  device

Aby wykryć emulator, musisz mieć najnowszą wersję adb. Wersja dołączana do Android Studio działa, ale plik adb dostarczany z Unity może nie działać. Zgodna wersja jest w pakiecie z emulatorem. Możesz ją znaleźć na stronie C:\Program Files\Google\Play Games Developer Emulator\current\emulator. Aby uzyskać najlepsze rezultaty, zalecamy zainstalowanie pakietu Android Studio i używanie go do zarządzania pakietem SDK do Androida.

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

adb connect localhost:6520

4. Skonfiguruj Unity, aby kompilować i wdrażać bezpośrednio w emulatorze (opcjonalnie)

Wersja adb dostarczana z Unity może nie być zgodna z emulatorem. Aby upewnić się, kliknij menu Plik -> Ustawienia kompilacji i sprawdź, czy znajduje się na liście w oknie Uruchom urządzenie.

Uwaga: jeśli przed testami uruchomiono narzędzie adb, należy użyć polecenia adb connect localhost:6520 z wersją adb dostarczaną z Unity. Żadna z testowanych wersji Unity w momencie pisania tego statku ze zgodnym adb nie była używana.

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

Wdróż bezpośrednio w emulatorze, wykonując te 2 kroki:

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

Wersja pakietu Android SDK dostarczana z Unity prawdopodobnie nie wykryje emulatora, więc musisz zainstalować nowszą wersję pakietu SDK, korzystając z Androida Studio.

1. Otwórz Android Studio i wybierz Edytuj -> Ustawienia -> 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). Opcję Android NDK pozostaw bez zmian.

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

Uwaga: jeśli emulator nie jest widoczny, konieczne może być uruchomienie adb connect localhost:6520. Dzieje się tak, ponieważ wbudowane narzędzie adb w Unity ma pierwszeństwo, dopóki go nie zmienisz i ręcznie 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 kompilacji i zaznacz „Custom Main Gradle Template” (Niestandardowy szablon Gradle). i „Custom Launcher Gradle Template” (Szablon Gradle programu uruchamiającego), który wygeneruje oba pliki Gradle w usłudze Assets\Plugins\Android\.

Uwaga: projekty korzystające z bibliotek EDM4U i androidx, takie jak Firebase, wymagają też wygenerowania pliku Custom Gradle Properties Template, aby prawidłowo rozpoznać zależności. Jeśli jeszcze nie używałeś(-aś) niestandardowego szablonu Gradle, możesz też sprawdzić to ustawienie.

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

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

5. Wdrażanie na Chromebooku (opcjonalnie)

Możesz zacząć tworzyć gry do Gier Google Play na urządzeniu z ChromeOS bez dostępu do emulatora Gier Google Play. Chromebooki, podobnie jak Gry Google Play na PC, mają klawiaturę i myszy, mają duże ekrany i są dostępne w konfiguracjach x86. Do obsługi Chromebooka użyjemy wtyczki Unity Android Logcat dla Unity.

1. Otwórz menedżera pakietów i wyszukaj Android Logcat w polu Unity Registry.

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

2. Wybierz Ustawienia -> Programista -> 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. Aby sprawdzić adres IP Chromebooka, kliknij ikonę Informacje o sieci.

5. Wybierz Okno -> Analiza -> Android Logcat, aby otworzyć okno Android Logcat.

6. Otwieranie listy urządzeń Jeśli obecnie nie ma połączenia z internetem, może on odczytywać stan No Device.

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

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

Twój Chromebook pojawi się na liście Uruchom urządzenie Unity (najpierw konieczne może być odświeżenie ekranu):

Możesz teraz wdrażać gry na Chromebooku oraz rozpocząć testowanie i programowanie na sprzęcie przypominającym komputer.

6. Wdrażanie kompilacji testowej

Gry Google Play wymagają wdrożenia gry w wersji x86, która jest częścią tego, w jaki sposób osiąga ona swoje testy porównawcze na komputerach. Wszystkie warianty LTS Unity mogą generować kompilacje Androida zgodne z architekturą x86 i x86-64 (oznaczone jako „ChromeOS”), a dla Unity w wersji 2018 i starszych można generować kompilacje x86. Aby odblokować te architektury, musisz najpierw przejść na backend obsługi skryptów IL2CPP, który prawdopodobnie jest już używany w środowisku produkcyjnym w celu obsługi arm64.

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

2. Przejdź do sekcji Inne ustawienia i przełącz Scripting Backend na IL2CPP.

Należy również włączyć obsługę procesorów x86 lub x86-64. Platforma Gier Google Play wymaga tylko obsługi procesorów x86, ale zalecamy korzystanie z architektur x86–64.

Uwaga: każda dodatkowa architektura wydłuża czas kompilacji. Chociaż możesz bezpiecznie połączyć wszystkie środowiska docelowe ARM i x86 w jednym pakiecie, przy tworzeniu funkcji warto wybrać tylko x86 lub x86-64.

Wersja pakietów Unity z biblioteki Frame Pacing jest też niezgodna z Grami Google Play i powoduje awarię gry przy uruchamianiu.

3. Aby wyłączyć tempo klatek w oknie Ustawienia odtwarzacza, otwórz sekcję Rozdzielczość i prezentacja i odznacz Zoptymalizowane tempo wyświetlania klatek.

Możesz teraz budować!

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

Jeśli nie możesz wdrożyć gry, sprawdź, czy „Urządzenie Google HPE (localhost:6520)” pojawia się w oknie „Uruchom urządzenie”. z listy. Jeśli go nie ma, upewnij się, że aplikacja HPE_Dev jest uruchomiona i widzisz ekran główny Androida. Jeśli nadal nie ma go na liście urządzeń, uruchom aplikację adb connect localhost:6520 z systemem adb.exe, którego używasz. Jeśli używasz wtyczki Android Logcat Unity, wybierz Narzędzia -> Otwórz Terminal, aby otworzyć terminal połączony z katalogiem, którego używa adb.exe Unity.

Otwórz terminal podświetlone” style="width: 624.00px" src="img/9101ce3c95fb1aa2.png" img 36w. size="(max-width: 840px) 100vw, 856px">

7. Dostosuj grę do potrzeb PC

W miarę możliwości staraj się wprowadzać zmiany w grze na podstawie danych niezależnych od platformy lub obecności określonych funkcji. Na przykład odtwarzacz na Androidzie może podłączyć mysz i klawiaturę lub podłączyć monitor. Dlatego zmiana schematu sterowania lub elementów HUD w odpowiedzi na konfigurację urządzenia umożliwia korzystanie z Gier Google Play na PC na wszystkich obsługiwanych platformach.

Jeśli warto zmienić logikę w zależności od tego, czy odtwarzacz jest w Grach Google Play czy w 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ż typowe telefony z Androidem. Jeśli to możliwe, zalecamy, aby HUD nie zajmował więcej niż 20% ekranu. Wiele gier mobilnych używa opcji „Skaluj z rozmiarem ekranu”, więc trzeba ją zmienić na „Stały rozmiar fizyczny”. lub „Stały rozmiar w pikselach” może być dobrym pierwszym krokiem do osiągnięcia tego celu.

Jeśli wykryjesz działanie w Grach Google Play, możesz też dynamicznie ustawiać ustawienia jakości za pomocą polecenia QualitySettings.SetQualityLevel w czasie działania. Emulator Gier Google Play korzysta z ANGLE do generowania natywnych poleceń dotyczących biblioteki OpenGL lub Vulkan w środowisku OpenGL Unity, więc prawdopodobnie możesz uzyskać lepszą jakość grafiki, niż była dostępna w kompilacjach gier mobilnych.

8. Obsługa danych wejściowych

Dostawa gier w Grach Google Play powinna opierać się na korzystaniu z myszy i klawiatury. Musisz zaplanować sposób wchodzenia w interakcję z grą za pomocą myszy i klawiatury, więc już teraz poświęć czas na nabycie pakietu jednostkowego pakietu SDK do wprowadzania danych. Jeśli nie widzisz na tej stronie pliku do pobrania, upewnij się, że korzystasz z konta w grupie play-mp-libs.

Wiele gier testuje podstawowe funkcje edycji za pomocą myszy i klawiatury, które umożliwiają programowanie w edytorze. Jeśli to możliwe, warto je włączyć na urządzeniu z ChromeOS lub w emulatorze Gier Google Play.

Uwaga: jeśli obecnie używasz #if UNITY_EDITOR do wykrywania, czy korzystasz z edytora, zmień to ustawienie na sprawdzanie środowiska wykonawczego if (Application.isEditor) i sprawdź GoogleDeviceUtilities.IsGooglePlayGames lub GoogleDeviceUtilities.HasKeyboard.

Domyślnie Gry Google Play i ChromeOS konwertują dane wejściowe myszą na symulowany dotyk. Jeśli używasz Input.GetTouch i Input.touchCount, gra będzie nadal działać zgodnie z oczekiwaniami. Jeśli korzystasz z dotyku wielodotykowego, np. sterowania 2 kciukami lub ściąganiem palców, aby powiększyć, musisz przypisać to działanie do naciśnięć klawiszy. Zmapuj też działania w grze na naciśnięcia klawiszy. Na przykład naciśnij i, aby otworzyć ekwipunek, Escape, aby zamknąć okna dialogowe, oraz Enter, aby wysłać wiadomość w grze.

W mikrogrze platformowej 2D poruszają się strzałka, a miejsce do skakania. Jeśli używasz własnej gry, upewnij się, że masz preferowane powiązania klawiszy w następnym kroku.

9. Wejściowa integracja z pakietem SDK

Skoro masz już skonfigurowane sterowanie myszą i klawiaturą, musisz dodać obsługę wejściowego pakietu SDK . Dzięki temu gracze mogą znaleźć elementy wejściowe PC za pomocą wyskakującego okienka:

1. Po zaimportowaniu pakietu SDK do projektu utwórz plik o nazwie InputMappingProviderBehaviour.cs i dodaj do niego tę zawartość:

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 grze. W mikrogrze platformowej 2D działania to lewo, prawo i skok:

private enum ActionIds
{
    Left,
    Right,
    Jump
}

3. W narzędziu OnProvideInputMap utwórz InputAction dla każdego działania. Potrzebujesz do tego nazwy działania, danych wejściowych i powiązanych z nim przycisków myszy lub klawiszy. 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 połącz ze sobą te działania wejściowe.

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

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

5. Dodaj wszystkie utworzone grupy danych wejściowych do mapy wejściowej. Zmodyfikuj instrukcję zwrotu w OnProvideInputMap tak:

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

6. Na koniec dodaj utworzony skrypt do gry:

7. Po ponownym wdrożeniu gry naciśnij Shift+Tab, aby otworzyć nakładkę w grze.

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

10. Usuń umieszczone widoki internetowe

Aby zapewnić użytkownikom lepsze wrażenia, usuń z nich osadzone widoki internetowe. Do wyświetlania elementów takich jak Polityka prywatności czy Warunki korzystania z usługi często używa się osadzonych widoków internetowych. Działają one w Grach Google Play, ale wyświetlają się w umieszczonym przeglądarki zamiast preferowanej przez gracza, co może powodować dezorientację użytkowników odtwarzaczy na PC. Jeśli więc używasz rozszerzeń, aby wyświetlić umieszczoną przeglądarkę, w Unity użyj rozszerzenia Application.OpenURL(url).

11. Uprawnienia i funkcje

Istnieje wiele funkcji i uprawnień Androida, które nie są obsługiwane w Grach Google Play. Ogólną zasadą jest, aby kompilacja komputera nigdy nie pojawiała się okno uprawnień. Teraz, gdy kompilacja będzie gotowa, przeprowadź typową instalację i zapisz wszystkie okna, które zobaczysz, aby dodać je do listy zadań. do przesłania gry.

Niektóre gry na Unity wymagają uprawnień za pomocą interfejsu API Android.Permission. Należy uwzględnić je w testach if (GoogleDeviceUtilities.IsGooglePlayGames) i w razie potrzeby przejść bezpośrednio do logiki błędu.

12. Optymalizacje pod kątem komputerów

Gry Google Play różnią się od typowych telefonów z Androidem w niektórych przypadkach, dlatego warto odpowiednio skonfigurować grę.

Aby uzyskać kompresję tekstury, przełącz się na tryb DXT. Typowe formaty tekstur Androida, takie jak ETC, są dekodowane w pamięci w czasie działania, jeśli nie można ich przekazać bezpośrednio do GPU odtwarzacza. ASTC zapewnia najlepszą zgodność z komputerami, jednak aby sprawdzić oczekiwane działanie gry, musisz użyć narzędzia do profilowania GPU dla komputerów.

Ponieważ obecnie używasz GPU do komputerów, możesz także chcieć poprawić jakość grafiki. Możesz zmienić ją bezpośrednio w Ustawieniach projektu w sekcji Jakość

13. Gratulacje

Masz wszystko gotowe, aby zacząć tworzyć swoją grę w Grach Google Play. Możesz zacząć testować grę i wprowadzać w niej iteracje. Pamiętaj, że chociaż możesz zachować ten sam kod, warto dostosować grę tak, aby wyglądała jak natywna gra na PC.

Co dalej?

Aby móc wysyłać gry do Gier Google Play, musisz wykonać jeszcze więcej pracy:

• Najnowsze informacje znajdziesz w krótkim wprowadzeniu.
• Przejdź na logowanie do usług gier Play w wersji 2, aby automatycznie logować gracza przy uruchamianiu i spełnić wymagania dotyczące ciągłości.
• Zaimplementuj interfejs Play Integrity API, aby mieć pewność, że korzystanie z komputera PC jest tak samo bezpieczne jak na urządzeniu mobilnym.

Duża część pracy wykonanej przez Ciebie do tej pory w zakresie obsługi Gier Google Play pomaga również w dostarczaniu gier na ChromeOS, dlatego warto rozważyć wdrożenie tej platformy tak samo jak PC.