Unity-Spiele für große Displays und faltbare Geräte optimieren

1. Einführung

In diesem Codelab erfahren Sie, wie Sie ein Unity-Android-Spiel für Geräte mit großen Displays und Foldables optimieren. Sie verwenden das Beispielprojekt Lost Crypt, um die Unterstützung von Seitenverhältnissen zu implementieren, die Vollbildnutzung zu erweitern und auf den Zustand von Faltgeräten zu reagieren.

Vorbereitung

  • Grundkenntnisse in Unity und Android-Entwicklung.
  • Android-Geräte mit großen Displays wie Tablets oder faltbare Smartphones.

Lerninhalte

  • So implementieren Sie die Unterstützung für verschiedene Seitenverhältnisse.
  • So verwenden Sie Anker in der Benutzeroberfläche und den Kameraeinstellungen Ihres Spiels, um die Anpassung an die Bildschirmgröße zu automatisieren.
  • So verwenden Sie den Jetpack Window Manager von Android, um die Falthaltung des Geräts zu erkennen und das Layout anzupassen.

Voraussetzungen

  • Unity Hub und Editor: Unity 2020 LTS oder Unity 2022 mit Unterstützung für Android-Builds installiert.
  • Hardware: Android-Geräte mit großen Displays wie Tablets oder faltbare Smartphones.
  • Eine agentische Entwicklungsplattform wie Google Antigravity, wenn Sie den Skill verwenden möchten.

2. KI-Agenten-Skill

Optional ist eine Agent-Skill verfügbar, mit der Sie Ihr Unity-Spielprojekt bewerten können. Mit diesem Skill können Sie Unterstützung für die Größenänderung sowie für Geräte mit großen Displays und faltbare Geräte hinzufügen. Weitere Informationen finden Sie auf GitHub.

So verwenden Sie diesen Skill:

  1. Kopieren Sie die Datei SKILL.md in das Verzeichnis Ihres Agents. Weitere Informationen zum Hinzufügen eines Skills finden Sie unter Erste Schritte mit Google Antigravity.
  2. Stellen Sie Ihrem KI-Agenten in Ihrer Agentic IDE, z. B. Antigravity, Fragen zu großen Displays, Foldables oder zur Größenänderung.
  3. Bitten Sie den Agenten, Unterstützung für große Displays und faltbare Smartphones hinzuzufügen.

3. Unterstützung für das Seitenverhältnis

Damit Ihr Spiel auf verschiedenen Bildschirmgrößen richtig dargestellt wird, sollten Sie zuerst die Unterstützung für verschiedene Seitenverhältnisse implementieren. Möglicherweise sollten Sie das Seitenverhältnis der Kamera oder des Arbeitsbereichs anpassen, damit es besser auf verschiedene Bildschirme passt.

  1. Achte darauf, dass deine Anwendung die Einstellung „Vollbild mit anpassbarer Größe“ verwendet.
  2. In Ihrem AndroidManifest.xml (unter Assets/Plugins/Android/AndroidManifest.xml):
    1. Legen Sie dazu android:resizeableActivity="true" fest.
    2. Legen Sie dazu android:screenOrientation="fullSensor" fest.

Beispiel:

<?xml version="1.0" encoding="utf-8"?>
<manifest
    xmlns:android="http://schemas.android.com/apk/res/android"
    package="com.unity3d.player"
    xmlns:tools="http://schemas.android.com/tools">
    <application>
        <activity android:name="com.unity.lostcryptlargescreenexample.LargeScreenPlayableActivity"
                  android:theme="@style/UnityThemeSelector"
                  android:screenOrientation="fullSensor"
                  android:launchMode="singleTask"
                  android:resizeableActivity="true"
                  android:configChanges="mcc|mnc|locale|touchscreen|keyboard|keyboardHidden|navigation|orientation|screenLayout|uiMode|screenSize|smallestScreenSize|fontScale|layoutDirection|density"
                  android:hardwareAccelerated="false">
            <intent-filter>
                <action android:name="android.intent.action.MAIN" />
                <category android:name="android.intent.category.LAUNCHER" />
            </intent-filter>
            <meta-data android:name="unityplayer.UnityActivity" android:value="true" />
        </activity>
    </application>
</manifest>
  1. Prüfen Sie die Build Settings (Build-Einstellungen) in Unity auf Konfigurationen für die Android-Plattform.

Hinweis: Die Unterstützung verschiedener Seitenverhältnisse ist der erste Schritt, um dafür zu sorgen, dass dein Spiel auf Tablets und Foldables gut aussieht.

4. Vollbildnutzung

Achten Sie nach der Anpassung an verschiedene Seitenverhältnisse darauf, dass Ihr Spiel den gesamten Bildschirm nutzt, um das Gameplay noch intensiver zu gestalten.

So nutzen Sie den gesamten Bildschirm:

  1. Verwende Anker in der Benutzeroberfläche und den Kameraeinstellungen deines Spiels. Dadurch werden die Positionen von UI-Elementen automatisch an die Bildschirmgröße angepasst.
  2. Öffnen Sie die Szene Anchoring im Beispielprojekt, um zu sehen, wie die UI-Canvas-Verankerung eingerichtet ist.
  3. In der Szene Verankern wird der Arbeitsbereich so aktualisiert, dass er den Safe Frame berücksichtigt. Die Bewegungssteuerung wird an den Ecken des Bildschirms verankert.

Um das Seitenverhältnis für Ihre Hauptkamera beizubehalten, passen Sie das pixelRect der Kamera dynamisch an. Das CameraAspectLock.cs-Skript zeigt, wie auf Änderungen der Ausrichtung reagiert und die Kameraansicht mit Letterbox-Bild dargestellt wird:

[SerializeField]
private float minAspectRatio = 4f / 3f;

[SerializeField]
private float maxAspectRatio = 21f / 9f;

public void MaintainAspectRatio() {
    int viewWidth = Display.main.systemWidth;
    int viewHeight = Display.main.systemHeight;

    // 1. Calculate screen aspect ratio
    float scaleScreen = viewWidth / (float)viewHeight;
    Rect rect = _camera.pixelRect;

    // 2. Scale to the fullest of the lower between width or height
    if (scaleScreen > maxAspectRatio) {
        // use height, lock width to max at aspect scale
        rect.width = viewHeight * maxAspectRatio;
        rect.height = viewHeight;
    } else if (scaleScreen < minAspectRatio) {
        // use width, lock height to min at aspect scale
        rect.width = viewWidth;
        rect.height = viewWidth / minAspectRatio;
    } else {
        // within allowed aspect ratio range, use full screen
        rect.width = viewWidth;
        rect.height = viewHeight;
    }

    // make sure to center the rect within the window
    rect.x = Mathf.Floor((viewWidth - rect.width) * 0.5f);
    rect.y = Mathf.Floor((viewHeight - rect.height) * 0.5f);

    Debug.Log("camera view width = " + rect.width +
        " height = " + rect.height +
        " x = " + rect.x +
        " y = " + rect.y);

    // 3. Commit the new size to the camera so that it takes effect
    _camera.pixelRect = rect;
}

5. Unterstützung für faltbare Geräte

Bei faltbaren Geräten sollten Sie das Layout Ihres Spiels spontan an die Faltposition des Geräts (z. B. HALF_OPENED, FLAT) und die Bildschirmgröße anpassen.

  1. Verwenden Sie den Jetpack Window Manager von Android, um den Gerätestatus zu erkennen.
  2. Öffnen Sie im Beispielprojekt die Szene HingeAware.
  3. Diese Szene enthält ein ConfigurationManager-MonoBehaviour, das die Jetpack WindowManager-Ereignisse von Android an Unity weiterleitet und über UnityEvent-Callbacks auf Faltzustände reagiert.
  4. Das HingeSensor.cs liest den Scharnierwinkel mit dem Java-Plug-in com.unity.lostcryptlargescreenexample.HingeAngleSensor.

ConfigurationManager verwenden

ConfigurationManager.cs kommuniziert mit einer benutzerdefinierten Android-Aktivität und parst JSON-Strings, die den Status darstellen. Es wartet auf onConfigurationChanged- und onFoldChanged-Callbacks von der Android-Aktivität.

[System.Serializable]
public class FoldInfo {
	public string orientation;
	public string state;
	public int isSeparating;
	public int boundsLeft;
	public int boundsTop;
	public int boundsRight;
	public int boundsBottom;
}

public void onFoldChanged(string strFoldInfo) {
	FoldInfo info = JsonUtility.FromJson<FoldInfo>(strFoldInfo);

	// Always call the refresh from the main Unity thread
	StartCoroutine(ExecuteOnMainUnityThread(ActionOnFoldChange, info));
}

Sie können den Status auch synchron mit der Property getFoldableState abfragen:

public static string getFoldableState {
	get {
		if (Application.platform == RuntimePlatform.Android) {
			var foldingFeatureObject = foldablePlayerActivity.Call<AndroidJavaObject>("getFoldingFeature");
			if (foldingFeatureObject != null) {
				var state = foldingFeatureObject.Call<AndroidJavaObject>("getState");
				return state.Call<string>("toString");
			}
		}
		return "NONE";
	}
}

6. HingeSensor verwenden

Einige faltbare Geräte haben einen physischen Scharniersensor, der den genauen Winkel der Faltung (0 bis 360 Grad) angibt. Damit können Sie Gameplay-Mechaniken steuern oder die Kamera anpassen.

In HingeSensor.cs wird ein Android-Plug-in initialisiert, um den Hardwaresensor auszulesen. Sie können auch prüfen, ob das Scharnier aktiviert ist:

public class HingeSensor : IDisposable {
	AndroidJavaObject plugin;

	public static HingeSensor Start() {
		if (Application.platform == RuntimePlatform.Android) {
			return OnPlayer.Run(p => {
				var context = p.GetStatic<AndroidJavaObject>("currentActivity");
				var plugin = new AndroidJavaClass("com.unity.lostcryptlargescreenexample.HingeAngleSensor")
						.CallStatic<AndroidJavaObject>("getInstance", context);

				if (plugin != null) {
					plugin.Call("setupSensor");
					return new HingeSensor(plugin);
				}
				return null;
			});
		}
		return null;
	}

	public float GetHingeAngle() {
		return (Application.platform == RuntimePlatform.Android && plugin != null) ? plugin.Call<float>("getHingeAngle") : -1.0f;
	}

	public bool IsHingeEnabled() {
		return Application.platform == RuntimePlatform.Android && plugin != null && plugin.Call<int>("isHingeEnabled") > 0;
	}
}

Hinweis: Rufen Sie Dispose() oder StopSensing() in Ihrer HingeSensor-Instanz auf, wenn Ihre Anwendung pausiert oder beendet wird, um einen übermäßigen Akkuverbrauch zu vermeiden.

7. AAB-Datei erstellen

So erstellen Sie eine AAB-Datei im Unity-Editor:

  1. Klicken Sie im Unity-Editor auf File > Build settings (Datei > Build-Einstellungen).
  2. Wählen Sie Build App Bundle ( Google Play ) aus.Weitere Informationen finden Sie in der Referenz zu Android-Build-Einstellungen.
  3. Klicken Sie auf Erstellen.
  4. Laden Sie die AAB-Datei aus dem Unity-Editor herunter.

Release für interne Tests erstellen

So erstellen Sie in der Play Console einen Release für interne Tests und fügen Tester hinzu:

  1. Wählen Sie in der Google Play Console ein Spiel aus.
  2. Rufen Sie die Seite Testen und veröffentlichen auf (Test> Interner Test).
  3. Klicken Sie auf Hochladen und wählen Sie die AAB-Datei aus.
  4. Geben Sie im Feld Release-Details einen Namen ein.
  5. Klicken Sie auf Weiter und sehen Sie sich die Details der Veröffentlichung an.
  6. Klicken Sie auf Speichern und veröffentlichen.

8. Projekt erstellen und ausführen

Jetzt können Sie das Projekt erstellen und auf Ihrem Gerät testen.

  1. Achte darauf, dass das Spiel geöffnet ist.
  2. Rufen Sie in der Play Console Datei > Build-Profil (oder Build-Einstellungen) auf.
  3. Achten Sie darauf, dass App-Bundle erstellen (Google Play) ausgewählt ist, wenn Sie das Bundle in die Play Console hochladen möchten. Klicken Sie andernfalls auf Erstellen und ausführen, um die App direkt auf Ihrem verbundenen Gerät bereitzustellen.
  4. Bei faltbaren Geräten sollten Sie das Layout Ihres Spiels dynamisch an die Faltposition des Geräts (z. B. HALF_OPENED, FLAT) und die Bildschirmgröße anpassen.

9. Glückwunsch

Sie haben die Grundlagen für die Anpassung eines Unity-Android-Spiels für große Bildschirme und Foldables kennengelernt.

Umfrage

Ihr Feedback zu diesem Codelab ist uns sehr wichtig. Nehmen Sie sich einige Minuten Zeit, um an unserer Umfrage teilzunehmen.