Erste Schritte mit Unity und Google Play Spiele für PC

1. Einführung

Zuletzt aktualisiert: 18.10.2022

Wie bereite ich mein Spiel für Google Play Games auf dem PC vor?

Mit Google Play Games kannst du dein Mobilspiel ganz einfach auf Windows-PCs anbieten. So kannst du das Engagement deiner Spieler und deine Zielgruppe steigern, ohne dein Spiel neu zu konzipieren oder dein Geschäftsmodell zu ändern. Es gibt noch ein paar Änderungen, die du vornehmen musst, um deinen neuen PC-Spielern die bestmögliche Erfahrung zu bieten.

Lerninhalte

In diesem Codelab werden die grundlegenden Teile der Checkliste mit Anforderungen behandelt, damit Sie mit der Entwicklung Ihres Spiels beginnen und Ihr eigenes Unity-Spiel für Google Play Games auf dem PC vorbereiten können. Detailliertere Integrationen wie die Anmeldung bei Play Spiele und die Play Integrity API werden nicht behandelt.

• So erstellen Sie mit Unity Builds für die x86-Architektur.
• Testen und Bereitstellen im Google Play Games-Emulator
• So passen Sie die Benutzeroberfläche an, damit sie auf einem PC gut aussieht.
• Hier erfahren Sie, wie Sie erkennen, ob Ihr Spiel im Google Play Games-Emulator ausgeführt wird, und wie Sie Ihr Spiel entsprechend anpassen.

Voraussetzungen

• Unity 2020 LTS-Installation (dieses Codelab wurde mit Version 2020.3.30f1 erstellt).
• Google Play Games-Emulator

2. Einrichten

Projekt öffnen oder erstellen

1. Erstellen Sie ein neues Projekt mit dem 2D-Plattformer-Microgame oder öffnen Sie ein eigenes Projekt.

2. Wählen Sie im Projekt File > Build Settings aus und prüfen Sie, ob Sie für die Erstellung für Android eingerichtet sind.

3. Google Play Games-Emulator vorbereiten

Laden Sie den Emulator herunter.

Nach der Installation sollte in einem Fenster ein Android-Desktop angezeigt werden:

Hinweis:Der Emulator wird in Ihrer Anwendungsliste als Google Play Games-Emulator für Entwickler angezeigt.

Dies ist eine leistungsstarke Android-Umgebung mit allen Funktionen, die sich für die Spieleentwicklung eignet. Es sollte in der Android Debug Bridge (adb) als Gerät auf localhost angezeigt werden:

❯ adb devices
List of devices attached
localhost:6520  device

Sie benötigen eine aktuelle Version von adb, um den Emulator zu erkennen. Die mit Android Studio gebündelte Version funktioniert, die mit Unity ausgelieferte Version von adb möglicherweise nicht. Eine kompatible Version ist im Emulator enthalten. Sie finden sie unter C:\Program Files\Google\Play Games Developer Emulator\current\emulator. Für eine optimale Entwicklerumgebung sollten Sie Android Studio installieren und damit Ihr Android SDK verwalten.

Wenn die Verbindung des Emulators zu adb getrennt wird, stellen Sie die Verbindung über die Befehlszeile wieder her:

adb connect localhost:6520

4. Unity so konfigurieren, dass direkt auf dem Emulator erstellt und bereitgestellt wird (optional)

Die mit Unity ausgelieferte Version von „adb“ ist möglicherweise nicht mit dem Emulator kompatibel. Wählen Sie zur Sicherheit File -> Build Settings aus und prüfen Sie im Dialogfeld Run Device, ob das Gerät aufgeführt ist.

Achtung:Denken Sie daran, adb connect localhost:6520 mit der Version von adb zu verwenden, die mit Unity ausgeliefert wird, wenn Sie adb vor dem Testen ausgeführt haben. Keine der getesteten Unity-Versionen wird mit einer kompatiblen ADB ausgeliefert.

Je nach Projekt, Build-Prozess und Komfortniveau können Sie Unity so konfigurieren, dass die Bereitstellung direkt im Google Play Games-Emulator erfolgt, oder eine APK erstellen und sie manuell mit adb install bereitstellen. Für die manuelle Bereitstellung sind die wenigsten Änderungen erforderlich, sie kann jedoch den Iterationszyklus verlangsamen.

So stellen Sie die App direkt auf dem Emulator bereit:

1. Konfigurieren Sie Unity so, dass ein anderes Unity SDK verwendet wird, idealerweise das von Android Studio installierte.
2. Aktualisieren Sie die Build Tools-Version, um einen Fehler in Unity zu umgehen.

Da die mit Unity ausgelieferte Version des Android SDK den Emulator wahrscheinlich nicht erkennt, installieren Sie mit Android Studio ein aktuelleres SDK.

1. Öffnen Sie Android Studio und wählen Sie Edit > Preferences > External Tools aus.
2. Deaktivieren Sie Android SDK Tools Installed with Unity und geben Sie den Pfad zur Installation von Android Studio an (normalerweise AppData/Local/Android/sdk). Lassen Sie die Option Android NDK unverändert.

Wenn Sie die verbundenen Geräte aktualisieren, sollte Google HPE device (localhost:6520) im Build-Fenster angezeigt werden:

Hinweis:Wenn der Emulator nicht angezeigt wird, müssen Sie möglicherweise adb connect localhost:6520 ausführen. Das liegt daran, dass das integrierte ADB von Unity Vorrang hat, bis Sie es ändern und manuell eine Verbindung zur neuen ADB-Instanz herstellen.

Je nach Status dieses Fehlers und Ihrer Unity-Version müssen Sie möglicherweise auch die Version Ihrer Build-Tools ändern. Achten Sie darauf, dass Sie eine mainTemplate.gradle und eine launcherTemplate.gradle generieren.

3. Öffnen Sie das Fenster Projekteinstellungen, gehen Sie zu Playereinstellungen und suchen Sie den Abschnitt Publishing Settings.
4. Scrollen Sie nach unten zu den Build-Optionen und aktivieren Sie „Custom Main Gradle Template“ und „Custom Launcher Gradle Template“. Dadurch werden beide Gradle-Dateien unter Assets\Plugins\Android\ generiert.

Hinweis:Bei Projekten, in denen EDM4U- und androidx-Bibliotheken wie Firebase verwendet werden, müssen Sie auch eine Custom Gradle Properties Template generieren, damit die Abhängigkeitsauflösung ordnungsgemäß ausgeführt werden kann. Wenn Sie noch nie eine benutzerdefinierte Gradle-Vorlage verwendet haben, sollten Sie auch diese Einstellung prüfen.

1. Ersetzen Sie alle Instanzen des Strings **BUILDTOOLS** durch 30.0.0. In beiden Dateien sollte der Codeabschnitt jetzt so aussehen:

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

5. Auf einem Chromebook bereitstellen (optional)

Sie können mit der Entwicklung von Spielen für Google Play Spiele beginnen, ohne Zugriff auf den Google Play Spiele-Emulator zu haben, indem Sie ein ChromeOS-Gerät verwenden. Ähnlich wie bei Google Play Games auf dem PC haben Chromebooks Tastaturen und Mäuse, große Displays und sind in x86-Konfigurationen verfügbar. Wir verwenden das Unity-Plug-in Android Logcat mit dem Chromebook.

1. Öffnen Sie den Paketmanager und suchen Sie unter Unity Registry nach Android Logcat.

Außerdem müssen Sie Ihr Chromebook für die Android-Entwicklung konfigurieren. Aktivieren Sie zuerst Linux.

2. Wählen Sie „Einstellungen“ -> „Entwickler“ -> „Linux“ aus.

Aktivieren Sie dann die ADB-Fehlerbehebung.

3. Wählen Sie Einstellungen -> Entwickler -> Linux-Entwicklungsumgebung -> Android-Apps entwickeln -> ADB-Debugging aktivieren aus.

Außerdem sollten Sie die IP-Adresse Ihres Chromebooks ermitteln. Am einfachsten geht das, wenn Sie

4. Klicken Sie auf das Symbol Netzwerkinformationen, um die IP-Adresse Ihres Chromebooks aufzurufen.

5. Wählen Sie Window -> Analysis -> Android Logcat aus, um das Fenster „Android Logcat“ zu öffnen.

6. Öffne die Geräteliste. Wenn derzeit nichts verbunden ist, wird möglicherweise No Device angezeigt.

7. Klicken Sie auf Andere Verbindungsoptionen und geben Sie die IP-Adresse Ihres Chromebooks ein.

8. Klicken Sie auf Verbinden. Das Fenster Erfolgreich sollte angezeigt werden:

Ihr Chromebook wird jetzt in der Liste „Run Device“ (Gerät ausführen) von Unity angezeigt. Möglicherweise müssen Sie den Bildschirm zuerst aktualisieren:

Sie können jetzt Spiele auf Ihrem Chromebook bereitstellen und mit dem Testen und Entwickeln auf PC-ähnlicher Hardware beginnen.

6. Test-Build bereitstellen

Für Google Play Games müssen Sie eine x86-Version Ihres Spiels bereitstellen, damit die Leistungsbenchmarks auf Desktop-PCs erreicht werden können. Mit allen LTS-Varianten von Unity können x86- und x86-64-kompatible Android-Builds (mit dem Label „ChromeOS“) erstellt werden. Mit Unity-Version 2018 und älter können x86-Builds erstellt werden. Um diese Architekturen zu nutzen, müssen Sie zuerst zum IL2CPP-Scripting-Backend wechseln, was Sie in der Produktion wahrscheinlich bereits für die arm64-Unterstützung tun.

1. Wählen Sie File > Build Settings aus, um das Fenster „Build Settings“ zu öffnen, und klicken Sie dann auf Player Settings.

2. Gehen Sie zum Abschnitt Weitere Einstellungen und stellen Sie Scripting Backend auf IL2CPP um.

Sie sollten auch die Unterstützung für x86 oder x86-64 aktivieren. Für die Veröffentlichung auf der Google Play Games-Plattform müssen Sie nur x86 unterstützen. Wir empfehlen jedoch x86-64.

Hinweis:Jede zusätzliche Architektur, die Sie hinzufügen, verlängert die Build-Zeit. Sie können zwar alle ARM- und x86-Ziele in einem Bundle zusammenfassen, aber während der Entwicklung von Funktionen ist es möglicherweise sinnvoll, nur x86 oder x86-64 auszuwählen.

Die Version der Frame Pacing-Bibliothek, die in Unity enthalten ist, ist ebenfalls nicht mit Google Play Games kompatibel und führt dazu, dass Ihr Spiel beim Start abstürzt.

3. Wenn Sie „Frame Pacing“ im Fenster Playereinstellungen deaktivieren möchten, öffnen Sie den Bereich Auflösung und Darstellung und entfernen Sie das Häkchen bei Optimiertes Frame Pacing.

Jetzt können Sie loslegen.

1. Öffnen Sie das Fenster Build Settings noch einmal und klicken Sie auf Build And Run. Das Spiel wird im Emulatorfenster angezeigt.

Wenn Sie Ihr Spiel nicht bereitstellen können, prüfen Sie, ob „Google HPE device (localhost:6520)“ in der Liste „Run Device“ (Gerät ausführen) angezeigt wird. Wenn sie fehlt, prüfen Sie, ob HPE_Dev ausgeführt wird und der Android-Startbildschirm angezeigt wird. Wenn es weiterhin nicht in der Geräteliste angezeigt wird, führen Sie adb connect localhost:6520 mit der genauen adb.exe aus, die Sie verwenden. Wenn Sie das Android Logcat Unity-Plug-in verwenden, wählen Sie Tools -> Open Terminal (Tools -> Terminal öffnen) aus, um ein Terminal für das Verzeichnis zu öffnen, das adb.exe verwendet.

Open 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. Spiel für den PC anpassen

Nehmen Sie Änderungen an Ihrem Spiel nach Möglichkeit auf Grundlage plattformunabhängiger Messwerte oder des Vorhandenseins bestimmter Funktionen vor. Ein Spieler auf Android kann beispielsweise eine Maus und Tastatur anschließen oder einen Monitor einstecken. Wenn Sie Ihr Steuerungsschema oder Ihre HUD-Elemente in Reaktion auf die Gerätekonfiguration ändern, können Sie die Arbeit, die Sie in Google Play Games für PC investiert haben, auf allen unterstützten Plattformen nutzen.

Wenn es sinnvoll ist, die Logik je nachdem zu ändern, ob sich der Spieler in Google Play Spiele oder ChromeOS befindet, können Sie dies mit diesem Skript erkennen, indem Sie nach dem Systemmerkmal HPE_EXPERIENCE suchen:

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
}

PCs haben ein größeres Display als das typische Android-Smartphone. Wir empfehlen, dass das HUD nicht mehr als 20% des Bildschirms einnimmt. Da in vielen mobilen Spielen „Mit Bildschirmgröße skalieren“ verwendet wird, kann es ein guter erster Schritt sein, diese Einstellung in „Konstante physische Größe“ oder „Konstante Pixelgröße“ zu ändern.

Sie können die Qualitätseinstellungen auch dynamisch mit dem Befehl QualitySettings.SetQualityLevel zur Laufzeit festlegen, wenn Sie erkennen, dass Sie in Google Play Games ausgeführt werden. Der Google Play Spiele-Emulator verwendet ANGLE, um native DirectX- oder Vulkan-Befehle aus den von OpenGL Unity ausgegebenen Befehlen zu senden. So können Sie wahrscheinlich eine höhere Grafikqualität als bei Ihren mobilen Spiel-Builds erzielen.

8. Eingabebehandlung

Spiele, die auf Google Play Games angeboten werden, sollten für die Eingabe über Maus und Tastatur optimiert sein. Sie müssen planen, wie Sie mit Ihrem Spiel über Maus und Tastatur interagieren. Nehmen Sie sich jetzt die Zeit, das Input SDK-Unity-Paket herunterzuladen. Wenn Sie auf dieser Seite keinen Download sehen, prüfen Sie, ob Sie mit einem Konto angemeldet sind, das zur Gruppe „play-mp-libs“ gehört.

Für Testzwecke haben viele Spiele grundlegende Maus- und Tastatursteuerungen für die Entwicklung im Editor. Wenn möglich, sollten Sie diese aktivieren, wenn Sie ein ChromeOS-Gerät oder den Google Play Games-Emulator verwenden.

Hinweis:Wenn Sie derzeit #if UNITY_EDITOR verwenden, um zu erkennen, ob Sie den Editor verwenden, ändern Sie dies in den Laufzeitcheck if (Application.isEditor), damit Sie auch GoogleDeviceUtilities.IsGooglePlayGames oder GoogleDeviceUtilities.HasKeyboard prüfen.

Standardmäßig werden Mauseingaben in Google Play Spiele und ChromeOS in simulierte Berührungen umgewandelt. Wenn Sie Input.GetTouch und Input.touchCount verwenden, funktioniert Ihr Spiel weiterhin wie erwartet. Wenn Sie auf Multi-Touch-Eingabe angewiesen sind, z. B. auf die Steuerung mit zwei Daumen oder das Auseinander- und Zusammenziehen zum Heran- und Herauszoomen, müssen Sie die Aktion Tastendrücken zuordnen. Außerdem sollten Sie In-Game-Aktionen Tastendrücken zuordnen, z. B. i zum Öffnen des Inventars, Esc zum Schließen von Dialogfeldern und Eingabetaste zum Senden von In-Game-Nachrichten.

Im 2D-Plattformer-Microgame werden die Pfeiltasten zum Bewegen und die Leertaste zum Springen verwendet. Wenn Sie Ihr eigenes Spiel verwenden, sollten Sie die gewünschten Tastenzuweisungen für den nächsten Schritt bereithalten.

9. Integration des Input SDK

Nachdem Sie die Maus- und Tastatursteuerung eingerichtet haben, müssen Sie die Unterstützung für das Input SDK hinzufügen. So können Spieler Ihre PC-Eingaben über ein praktisches Pop-over entdecken:

1. Nachdem Sie das SDK in Ihr Projekt importiert haben, erstellen Sie eine Datei mit dem Namen InputMappingProviderBehaviour.cs und fügen Sie die folgenden Inhalte hinzu:

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. Füllen Sie nun ActionIds mit der Liste der Aktionen aus, die Sie in Ihrem Spiel verwenden. Im 2D-Plattformer-Microgame sind die Aktionen „Links“, „Rechts“ und „Springen“ verfügbar:

private enum ActionIds
{
    Left,
    Right,
    Jump
}

3. Erstellen Sie in OnProvideInputMap für jede Aktion eine InputAction. Dazu benötigen Sie den Namen der Aktion, die Eingabe und dann die Maustasten oder Tastencodes, die daran gebunden werden sollen. Für das Beispiel-Game:

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. Als Nächstes gruppieren Sie diese Eingabeaktionen.

Für das Microgame haben wir nur eine Gruppe, aber Sie können so viele erstellen, wie Sie benötigen, damit Ihre Spieler die benötigten Aktionen finden. Fügen Sie Folgendes zu OnProvideInputMap hinzu:

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

5. Fügen Sie der Eingabezuordnung alle Eingabegruppen hinzu, die Sie erstellt haben. Ändern Sie die Rückgabeanweisung in OnProvideInputMap in:

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

6. Fügen Sie das erstellte Skript in Ihr Spiel ein:

7. Wenn Sie Ihr Spiel noch einmal bereitstellen, drücken Sie Shift+Tab, um das In-Game-Overlay zu öffnen.

8. Klicken Sie auf Steuerelemente, um die konfigurierten Steuerelemente aufzurufen.

10. Eingebettete Webansichten entfernen

Damit deine Spieler ein positives Nutzererlebnis haben, solltest du eingebettete Webviews entfernen. Eingebettete WebViews werden häufig verwendet, um Elemente wie Ihre Datenschutzerklärung oder Nutzungsbedingungen anzuzeigen. Obwohl diese Links in Google Play Games funktionieren, werden sie in einem eingebetteten „mobilen“ Browser und nicht im bevorzugten Desktopbrowser des Spielers angezeigt. Das kann bei PC-Spielern zu Verwirrung führen. Wenn Sie in Unity also Erweiterungen verwenden, um einen eingebetteten Browser anzuzeigen, sollten Sie auf Application.OpenURL(url) zurückgreifen.

11. Berechtigungen und Funktionen

Es gibt eine Reihe von Android-Funktionen und ‑Berechtigungen, die in Google Play Games nicht unterstützt werden. Als Faustregel gilt, dass bei Ihrem PC-Build niemals ein Berechtigungsdialogfeld angezeigt werden sollte. Nachdem Sie Ihren Build fertiggestellt haben, sollten Sie eine typische Neuinstallation durchführen und alle Dialogfelder notieren, die angezeigt werden. Diese müssen Sie dann Ihrer Aufgabenliste für die Einreichung Ihres Spiels hinzufügen.

Einige Unity-Spiele fordern Berechtigungen über die Android.Permission API an. Sie sollten diese in if (GoogleDeviceUtilities.IsGooglePlayGames)-Prüfungen einfügen und gegebenenfalls direkt zur Fehlerlogik wechseln.

12. Optimierungen für Desktop

Google Play Games unterscheidet sich in einigen Punkten von einem typischen Android-Smartphone. Möglicherweise müssen Sie Ihr Spiel entsprechend konfigurieren.

Wechseln Sie zur DXT-Texturkomprimierung. Gängige Android-Texturformate wie ETC werden im Arbeitsspeicher zur Laufzeit decodiert, wenn sie nicht direkt an die GPU eines Players übergeben werden können. ASTC bietet die beste Desktop-Kompatibilität. Sie müssen jedoch ein Desktop-GPU-Profiling-Tool verwenden, um das erwartete Verhalten für Ihr Spiel zu überprüfen.

Da Sie jetzt eine Desktop-GPU verwenden, können Sie auch die Grafikqualität erhöhen. Sie können die Qualität direkt in den Projekteinstellungen unter Qualität anpassen.

13. Glückwunsch

Sie haben alles, was Sie brauchen, um mit der Entwicklung Ihres Spiels für Google Play Games zu beginnen. Sie können mit dem Testen und Optimieren Ihres Spiels beginnen. Auch wenn Sie Ihre Codebasis beibehalten können, sollten Sie Ihr Spiel so anpassen, dass es sich wie ein natives PC-Spiel anfühlt.

Nächste Schritte

Es gibt noch mehr zu tun, um ein Spiel bei Google Play Games zu veröffentlichen:

• Aktuelle Informationen finden Sie in der Kurzanleitung.
• Führen Sie ein Upgrade auf Play Games-Dienste-Anmeldung v2 durch, um einen Spieler beim Start automatisch anzumelden und die Kontinuitätsanforderungen zu erfüllen.
• Implementieren Sie die Play Integrity API, um dafür zu sorgen, dass die PC-Version Ihrer Spiele genauso sicher ist wie die mobile Version.

Vieles, was Sie bisher für die Unterstützung von Google Play Games getan haben, hilft Ihnen auch dabei, Ihr Spiel auf ChromeOS zu veröffentlichen. Sie sollten diese Plattform also neben dem PC in Betracht ziehen.