Spiele für alle Bildschirme entwickeln

Bei der Entwicklung eines Spiels für Android ist es wichtig, die Vielfalt der möglichen Spielerfahrungen vorauszusehen und sich an die Echtzeit-Interaktionsbedürfnisse der Spieler anzupassen. Durch die Unterstützung unterschiedlicher Spieler ist das Spiel flexibler und kann die Reichweite des Spiels vergrößern.

Es gibt unter anderem folgende Unterschiede:

  • Geräteformfaktoren:Smartphones ermöglichen zwar die Nutzung herkömmlicher Android-Geräte, aber es ist möglich, mit Spielen auf anderen Formfaktoren zu interagieren. Auf ChromeOS-Geräten kann ein Android-Container ausgeführt werden, in dem dein Spiel angezeigt wird. Tablets, auf denen Android ausgeführt werden kann, unterstützen verschiedene Fidelity-Levels. Android TV-Geräte bieten eine detailliertere und immersivere User Experience. Spieler können eine Mehrfensterumgebung simulieren, indem sie ein Displayerweiterungstool verwenden. Bei faltbaren Smartphones können Spieler außerdem die Größe des Bildschirms während einer Spielsitzung ändern.
  • Interaktionsmethoden:Spieler können durch Tippen auf den Bildschirm eines Geräts Eingaben geben, aber auch stattdessen eine Maus, ein Touchpad, eine Tastatur oder einen Controller verwenden. Durch die Verfügbarkeit von Tools zur Displayerweiterung und faltbaren Geräten können Spieler Ihr Spiel auch auf einem größeren Bildschirm spielen. Dadurch sind längere Gameplay-Sitzungen und komplexere Benutzeroberflächen möglich.
  • Hardware-Unterstützung:Einige Android-Geräte haben keine für Handheld-Geräte übliche Hardware, z. B. eine Rückkamera, GPS und Netzwerkkonnektivität. Ihr Spiel sollte sich an die verfügbare Hardware anpassen und auch Situationen unterstützen, in denen bestimmte Funktionen nicht verfügbar sind.

In diesem Leitfaden werden Best Practices für die Entwicklung von Spielen für verschiedene Bildschirmtypen und Nutzerinteraktionen vorgestellt. Dieser Leitfaden enthält auch Vorschläge zum Entwerfen deines Spiels und zum Entwickeln einer effektiven Teststrategie.

Best Practices für das Spieldesign

Halten Sie sich bei der Planung des Designs und der Architektur Ihres Spiels an die Best Practices in den folgenden Abschnitten.

Manuell auf Konfigurationsänderungen reagieren

Wenn das Android-System eine Konfigurationsänderung erkennt, z. B. eine Änderung der Bildschirmgröße, der Bildschirmausrichtung oder der Eingabemethode, startet das System standardmäßig die aktuelle Aktivität neu. Damit der Status innerhalb einer App oder eines Spiels beibehalten wird, ruft die Aktivität standardmäßig onSaveInstanceState() vor dem Neustart und onRestoreInstanceState() nach dem Neustart auf. Für diesen Prozess müssen jedoch alle verknüpften Dienste und Ressourcen neu geladen werden. Weitere Informationen zu diesem Standardverhalten finden Sie in der Anleitung zum Umgang mit Konfigurationsänderungen.

In einer typischen Spielsitzung werden mehrere Konfigurationsänderungen vorgenommen. Wenn Ihr Spiel das System jede Konfigurationsänderung verarbeiten lässt, wird die Szene des Spiels gelöscht und immer wieder neu gestartet, wodurch die Leistung des Spiels verringert wird. Aus diesem Grund empfehlen wir dringend, dass du diese Konfigurationsänderungen in deinem Spiel selbst vornimmst.

Wie Sie Ihrem Spiel diese Konfigurationsänderungslogik hinzufügen, erfahren Sie im Abschnitt zum Erstellen benutzerdefinierter Konfigurationsänderungs-Handler.

Flexible Architektur erstellen

Damit Ihr Spiel auf möglichst vielen Geräten unterstützt wird, befolgen Sie diese Best Practices:

  • Stelle Android App Bundles anstelle einzelner APKs bereit. Mit Android App Bundles können Sie Artefakte unterschiedlicher Auflösungen und verschiedener Architekturmodelle wie x86 oder ARM in einem einzelnen Artefakt verpacken. Außerdem unterstützen Android App Bundles höhere Größenbeschränkungen für Ihr Spiel. Jedes Basis-APK kann bis zu 150 MB groß sein und das Bundle selbst kann viele Gigabyte groß sein.
  • Unterstützung für x86-Architekturen. Dieser Schritt verbessert die Leistung Ihres Spiels auf Geräten, die ARM nicht unterstützen, da diese Geräte jetzt Anweisungen ausführen können, ohne sie vorher übersetzen zu müssen.

Unterstützung für Vulkan hinzufügen

Durch die Unterstützung von Vulkan kann Ihr Spiel eine höhere Grafikleistung erzielen. Die meisten Geräte unterstützen diese Grafik-API.

Benutzerdefinierte Handler für Konfigurationsänderungen erstellen

Wenn du die Arten von Konfigurationsänderungen angeben möchtest, die dein Spiel selbst verarbeitet, füge jedem <activity>-Element in deinem Manifest, das einen Bildschirm oder eine komplexe Schnittstelle repräsentiert, das Attribut android:configChanges hinzu.

Das folgende Code-Snippet zeigt, wie Sie deklarieren, dass Ihr Spiel auf Bildschirmgröße, Bildschirmausrichtung und Eingabemethodenänderungen reagiert:

<activity ...
    android:configChanges="screenSize|orientation|keyboard|keyboardHidden">
</activity>

Wenn die deklarierten Konfigurationsänderungen auftreten, ruft das System jetzt die Methode onConfigurationChanged() auf. Fügen Sie bei dieser Methode Logik zum Aktualisieren der Benutzeroberfläche Ihres Spiels hinzu:

Änderungen an der Bildschirmkonfiguration verarbeiten

Ihr Spiel verarbeitet Änderungen an Bildschirmgröße und Bildschirmausrichtung manuell, wenn Sie die Werte screenSize bzw. orientation in ein android:configChanges-Attribut aufnehmen. Sie können diese neuen Werte verwenden, um den Inhalt Ihrer Szene und die Player-Eingabebereiche zu aktualisieren. Informationen dazu, wie du das Layout deines Spiels so gestalten kannst, dass Updates leichter aktualisiert werden können, findest du in der Anleitung zur Unterstützung verschiedener Bildschirmgrößen.

Verwende in der Implementierung von onConfigurationChanged() in deinem Spiel das übergebene Objekt Configuration und das Objekt Display des Fenstermanagers, um die aktualisierten Werte für Bildschirmgröße bzw. Bildschirmausrichtung zu ermitteln.

Das folgende Code-Snippet zeigt, wie Sie die aktualisierte Bildschirmgröße und -ausrichtung Ihres Spiels abrufen:

Kotlin

override fun onConfigurationChanged(newConfig: Configuration) {
    super.onConfigurationChanged(newConfig)
    val density: Float = resources.displayMetrics.density
    val newScreenWidthPixels = (newConfig.screenWidthDp * density).toInt()
    val newScreenHeightPixels = (newConfig.screenHeightDp * density).toInt()

    // Get general orientation; either Configuration.ORIENTATION_PORTRAIT or
    // Configuration.ORIENTATION_LANDSCAPE.
    val newScreenOrientation: Int = newConfig.orientation

    // Get general rotation; one of: ROTATION_0, ROTATION_90, ROTATION_180,
    // or ROTATION_270.
    val newScreenRotation: Int = windowManager.defaultDisplay.rotation
}

Java

@Override
public void onConfigurationChanged(Configuration newConfig) {
    super.onConfigurationChanged(newConfig);
    float density = getResources().getDisplayMetrics().density;
    int newScreenWidthPixels = (int) (newConfig.screenWidthDp * density);
    int newScreenHeightPixels = (int) (newConfig.screenHeightDp * density);

    // Get general orientation; either Configuration.ORIENTATION_PORTRAIT or
    // Configuration.ORIENTATION_LANDSCAPE.
    int newScreenOrientation = newConfig.orientation;

    // Get general rotation; one of: ROTATION_0, ROTATION_90, ROTATION_180,
    // or ROTATION_270.
    int newScreenRotation = getWindowManager().getDefaultDisplay()
            .getRotation();
}

Wenn Sie die Position eines faltbaren Geräts ändern, ändert sich die Konfiguration, auch wenn Ihre App im Vollbildmodus ausgeführt wird. Ihre App muss daher möglicherweise Änderungen an der Bildschirmgröße oder der Pixeldichte verarbeiten können, wenn der Nutzer das Gerät während des Spiels auf- oder zuklappt.

Spielspezifische Bildschirmqualitäten

In den folgenden Abschnitten wird beschrieben, wie Sie je nach Qualität Ihres Spiels anpassen können, wie Ihr Spiel auf Änderungen der Bildschirmgröße oder der Bildschirmausrichtung reagiert:

Vollbildmodus

Auf einigen Plattformen, wie z. B. ChromeOS, können Android-Apps und -Spiele standardmäßig im Fenstermodus angezeigt und angepasst werden. Wenn Ihr Spiel immer im Vollbildmodus ausgeführt werden soll, können Sie das Attribut android:resizeableActivity in einem Ihrer <activity>-Elemente auf false setzen, wie im folgenden Code-Snippet gezeigt:

<activity ...
    android:resizeableActivity="false">
</activity>

Sie können das android:resizeableActivity-Attribut auch auf false setzen, um zu verhindern, dass größenbasierte Konfigurationsänderungen vorgenommen werden. Wenn Ihr Spiel nicht immer im Vollbildmodus ausgeführt wird, sollten Sie dieses Attribut nur als vorübergehende Lösung zu Testzwecken hinzufügen.

Bildschirmausrichtung

Wenn Ihr Spiel davon abhängt, dass die Sensoren eines Geräts eine bestimmte Ausrichtung haben, geben Sie in der Aktivität Ihres Spiels einen Wert für android:screenOrientation an, wie im folgenden Code-Snippet gezeigt. Mit dieser Einstellung kann verhindert werden, dass eine Szene in Ihrem Spiel unerwartet auf den Kopf gestellt wird.

<activity ...
    android:screenOrientation="landscape">
</activity>

Gerätespezifische Bildschirmqualitäten

In den folgenden Abschnitten wird beschrieben, wie Sie mit bildschirmbasierten Konfigurationsänderungen umgehen, wenn bestimmte Geräte bestimmte Eigenschaften haben.

Seitenverhältnis

Einige Geräte unterstützen unterschiedliche Seitenverhältnisse. Faltbare Geräte unterstützen beispielsweise im zusammengeklappten Zustand ein Seitenverhältnis von 21:9. Führe mindestens einen der folgenden Schritte aus, um diese potenzielle Variation des Seitenverhältnisses zu berücksichtigen:

  • Die App sollte auf Android 8.0 (API-Level 26) oder höher ausgerichtet sein.
  • Passe die Szene und Benutzeroberfläche deines Spiels an. Setze android:resizeableActivity auf Geräten mit Android 7.0 (API-Level 24) und höher auf true.

  • Geben Sie ein maximal unterstütztes Seitenverhältnis an. Legen Sie in einem mit Ihrem Spiel verknüpften <meta-data>-Attribut android.max_aspect auf 2.4 fest, wie im folgenden Code-Snippet gezeigt. Beachten Sie jedoch, dass Seitenverhältnisse, die größer als das angegebene sind, dazu führen, dass das Spiel auf der Anzeige als Letterbox-Bild dargestellt wird.

    <application>
<meta-data android:name="android.max_aspect"
           android:value="2.4" />
</application>

Mehrere Aktivitäten gleichzeitig sichtbar

Viele moderne Geräte unterstützen eine Vielzahl von Bildschirmlayouts, einschließlich Splitscreen, Bild im Bild und großen Anzeigebereichen. Mit einem dieser Layouts lassen sich mehrere Aktivitäten gleichzeitig sichtbar machen.

Auf Geräten mit Android 9 (API-Level 28) oder höher können alle am häufigsten sichtbaren Aktivitäten gleichzeitig fortgesetzt werden. Damit dieses Verhalten funktioniert, müssen jedoch sowohl Ihr Spiel als auch der OEM des Geräts diese Funktion aktivieren. Du kannst Unterstützung innerhalb deines Spiels hinzufügen, indem du android.allow_multiple_resumed_activities im Manifest deines Spiels auf true setzt, wie im folgenden Snippet gezeigt:

<application>
    <meta-data android:name="android.allow_multiple_resumed_activities"
               android:value="true" />
</application>

Anschließend können Sie Ihr Spiel auf verschiedenen Geräten testen, um zu sehen, welche von ihnen den erforderlichen OEM-Support bieten, damit Multi-Resume ordnungsgemäß funktioniert.

Weitere Informationen dazu, wie Sie Ihr Spiel so konfigurieren, dass es im Mehrfenstermodus angezeigt wird, finden Sie in der Anleitung zum Hinzufügen der Unterstützung für den Mehrfenstermodus.

Verschiedene Arten von Interaktionsmodellen behandeln

Ihr Spiel verarbeitet die Tastaturpräsenz und -verfügbarkeit manuell, wenn Sie die Werte keyboard bzw. keyboardHidden in ein android:configChanges-Attribut aufnehmen. Sie können diese neuen Werte verwenden, um die primäre Eingabemethode Ihres Spiels zu aktualisieren.

Wenn Sie Ihr Spiel so konfigurieren, dass mehrere Arten von Nutzereingaben unterstützt werden, beachten Sie Folgendes:

  • Eingabemethoden statt einzelner Geräte erkennen. So lässt sich das Spielerlebnis leichter optimieren, ohne sich zu sehr auf das jeweilige Gerät des Spielers zu konzentrieren.
  • Nehmen Sie das Attribut keyboardHidden in die Liste der manuell verarbeiteten Konfigurationsänderungen auf. Auf diese Weise kann Ihr Spiel feststellen, wann eine Tastatur physisch mit dem Gerät verbunden, aber unbrauchbar ist.

  • Derzeit verfügbare Eingabemethoden bestimmen. Rufen Sie dazu beim Start des Spiels und nach jeder Konfigurationsänderung getInputDeviceIds() auf.

    Häufig lässt sich anhand des bevorzugten Eingabegeräts bestimmen, wie der Spieler mit Ihrem Spiel interagieren möchte:

    • Spieler verwenden in der Regel eine Tastatur oder einen Gamecontroller, um schnelle Tastenfolgen auszuführen.
    • Komplexere Gesten werden in der Regel über einen Touchscreen oder ein Touchpad ausgeführt.
    • Spieler verwenden in der Regel eine Maus, um Eingaben mit höherer Genauigkeit auszuführen.

Die folgenden Abschnitte enthalten Best Practices für bestimmte Arten von Eingabegeräten.

Tastatur

Berücksichtigen Sie beim Erstellen eines Tastaturlayouts für Ihr Spiel, wie der Spieler durch eine bestimmte Szene navigiert und wie er mit den Einstellungen des Spiels interagiert.

WASD-Tasten oder Pfeiltasten sind normalerweise am besten geeignet, um die Bewegung der Figuren zu steuern. Außerdem empfiehlt es sich, jeder wichtigen Aktion oder Fähigkeit, die ein steuerbarer Charakter in Ihrem Spiel ausführen kann, eine bestimmte Taste zuzuweisen. Wir empfehlen, in Ihrem Spiel benutzerdefinierte Schlüsselbindungen zu unterstützen, um das Spielerlebnis zu optimieren.

Die Spieler sollten auch die Menüs Ihres Spiels öffnen und über die Tastatur darin navigieren können. Die Esc-Taste ist eine gängige Zuordnung zum Anhalten einer Szene und zum Aufrufen des Spielmenüs.

Weitere Informationen zur Unterstützung der Tastatureingabe in deinem Spiel findest du in der Anleitung zur Unterstützung der Tastaturnavigation und in der Anleitung zur Steuerung von Tastaturaktionen.

Controller

Weitere Informationen zur Verarbeitung von Controllereingaben in deinem Spiel findest du in der Anleitung zur Unterstützung von Gamecontrollern.

Maus oder Touchpad

Wenn Ihr Spiel die Spielereingabe über eine Maus oder ein Touchpad unterstützt, denken Sie daran, dass die Spieler mit dem Gerät auf andere Weise interagieren als das Spiel. Beachten Sie, dass durch das Anfordern der Zeigererfassung alle Mauseingaben an Ihr Spiel gerichtet werden. Wenn Ihr Spiel also über die benötigten Informationen verfügt, können Sie die Zeigererfassung freigeben, damit die Spieler die standardmäßige Maussteuerung über ihr Gerät zurückerlangen.

Auf Geräten mit Android 8.0 (API-Level 26) und höher kannst du die Mouse Capture API zur Unterstützung der Zeigererfassung verwenden. Bei Spielen, die auf hochpräzise Eingaben reagieren, können Sie die aktuellen Koordinaten des Zeigers durch Aufrufen der Methoden getX() und getY() abrufen.

Weitere Informationen zur Unterstützung von Maus- und Touchpad-Eingaben in Ihrem Spiel finden Sie in der Anleitung zum Erfassen von Touch- und Zeigerbewegungen sowie in der Anleitung zum Umgang mit Multi-Touch-Gesten.

Spiel testen

Bevor Sie Ihr Spiel veröffentlichen, testen Sie, wie es auf Konfigurationsänderungen reagiert. Führen Sie dazu die in den folgenden Abschnitten beschriebenen Schritte aus.

Testplan aktualisieren

Bei der Prüfung der Spielfunktionalität sollten Sie die folgenden Testfälle einbeziehen:

  • Minimieren und maximieren Sie das Fenster, das Ihr Spiel enthält. (Dies gilt nicht, wenn Ihr Spiel immer im Vollbildmodus ist.)
  • Bildschirmgröße ändern.
  • Bildschirmausrichtung ändern (Gilt nicht, wenn Ihr Spiel eine feste Ausrichtung hat.)
  • Eingabegeräte wie Tastaturen und Mäuse anschließen und trennen.
  • Führen Sie mehrere Wiederholungen durch, sofern Ihr Spiel dies unterstützt.

Sie können auch das Qualitätskontrollesystem Ihres Spiels aktualisieren, damit es für eine größere Vielfalt an Spielerlebnissen optimiert werden kann.

Best Practices zum Testen Ihres Spiels finden Sie im Leitfaden zu den Grundlagen des Tests.

Test- und Debugging-Tools verwenden

Sie können Tests mit verschiedenen von der Plattform unterstützten Tools durchführen: