Optimiser les jeux Unity pour les grands écrans et les appareils pliables

1. Introduction

Dans cet atelier de programmation, vous allez apprendre à optimiser un jeu Unity Android pour les appareils à grand écran et pliables. Vous utiliserez l'exemple de projet Lost Crypt pour implémenter la prise en charge du format, étendre l'utilisation du plein écran et répondre aux états pliables.

Prérequis

  • Connaissances de base en développement Unity et Android.
  • Appareils Android à grand écran, comme les tablettes ou les téléphones pliables.

Objectifs

  • Implémenter la prise en charge de différents formats
  • Découvrez comment utiliser les ancres dans l'UI et les paramètres de caméra de votre jeu pour vous adapter automatiquement à la taille de l'écran.
  • Utiliser Jetpack WindowManager d'Android pour détecter la position pliée de l'appareil et ajuster la mise en page.

Ce dont vous avez besoin

  • Unity Hub et Editor : Unity 2020 LTS ou Unity 2022 installé, avec prise en charge de la compilation Android.
  • Matériel : appareils Android à grand écran, comme les tablettes ou les téléphones pliables.
  • Une plate-forme de développement agentique telle que Google Antigravity si vous prévoyez d'utiliser la compétence.

2. Compétence de l'agent

Une compétence d'agent est disponible pour évaluer votre projet de jeu Unity. Cette compétence vous aide à ajouter la compatibilité avec le redimensionnement, les grands écrans et les appareils pliables. Pour en savoir plus, consultez GitHub.

Pour utiliser cette skill :

  1. Copiez le fichier SKILL.md dans le répertoire de votre agent. Pour savoir comment ajouter une compétence, consultez Premiers pas avec Google Antigravity.
  2. Posez des questions à votre agent dans votre IDE agentique, comme Antigravity, sur les grands écrans, les appareils pliables ou la redimensionnabilité.
  3. Demandez à l'agent d'ajouter la compatibilité avec les grands écrans et les appareils pliables.

3. Formats compatibles

Pour vous assurer que votre jeu s'affiche correctement sur différentes tailles d'écran, commencez par implémenter la prise en charge de différents formats. Vous pouvez ajuster le format de la caméra ou du canevas pour mieux l'adapter à différents écrans.

  1. Assurez-vous que votre application utilise le paramètre de redimensionnement en plein écran.
  2. Dans votre AndroidManifest.xml (situé à Assets/Plugins/Android/AndroidManifest.xml) :
    1. Définissez android:resizeableActivity="true".
    2. Définissez android:screenOrientation="fullSensor".

Exemple :

<?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. Consultez vos paramètres de compilation dans Unity pour les configurations de la plate-forme Android.

Remarque : La prise en charge de différents formats est la première étape pour que votre jeu s'affiche correctement sur les tablettes et les appareils pliables.

4. Utilisation du plein écran

Après l'adaptation aux différents formats, assurez-vous que votre jeu utilise l'intégralité de l'écran pour rendre le gameplay plus immersif.

Pour utiliser l'intégralité de l'écran :

  1. Utilisez des ancres dans l'UI et les paramètres de caméra de votre jeu. Cela permet aux éléments d'interface utilisateur d'ajuster automatiquement leur position par rapport à la taille de l'écran.
  2. Ouvrez la scène Anchoring (Ancrage) dans l'exemple de projet pour voir comment l'ancrage du canevas d'UI est configuré.
  3. Dans la scène Ancrage, le canevas est mis à jour pour tenir compte du cadre de sécurité, et les commandes de déplacement sont ancrées aux coins de l'écran.

Pour conserver le format de votre caméra principale, ajustez dynamiquement le pixelRect de la caméra. Le script CameraAspectLock.cs montre comment réagir aux changements d'orientation et comment mettre en letterbox la vue de la caméra :

[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. Prise en charge des appareils pliables

Avec les appareils pliables, vous devez ajuster la mise en page de votre jeu en fonction de la position de pliage de l'appareil (par exemple, HALF_OPENED, FLAT) et de la taille de l'écran à la volée.

  1. Utilisez Jetpack WindowManager d'Android pour détecter l'état de l'appareil.
  2. Dans l'exemple de projet, ouvrez la scène HingeAware.
  3. Cette scène contient un MonoBehaviour ConfigurationManager qui relie les événements Jetpack WindowManager d'Android à Unity et répond aux états de pliage via des rappels UnityEvent.
  4. HingeSensor.cs lit l'angle de la charnière à l'aide du plug-in Java com.unity.lostcryptlargescreenexample.HingeAngleSensor.

Utiliser ConfigurationManager

ConfigurationManager.cs communique avec une activité Android personnalisée et analyse les chaînes JSON représentant l'état. Il écoute les rappels onConfigurationChanged et onFoldChanged de l'activité Android.

[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));
}

Vous pouvez également interroger l'état de manière synchrone à l'aide de la propriété getFoldableState :

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. Utiliser le HingeSensor

Certains appareils pliables sont équipés d'un capteur de charnière physique qui fournit l'angle exact du pli (de 0 à 360 degrés). Vous pouvez l'utiliser pour contrôler les mécanismes de jeu ou ajuster la caméra.

Dans HingeSensor.cs, un plug-in Android est initialisé pour lire le capteur matériel. Vous pouvez également vérifier si la charnière est activée :

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;
	}
}

Remarque : Veillez à appeler Dispose() ou StopSensing() sur votre instance HingeSensor lorsque votre application est mise en pause ou détruite pour éviter de décharger la batterie.

7. Créer un fichier AAB

Pour créer un fichier AAB dans l'éditeur Unity :

  1. Dans l'éditeur Unity, cliquez sur File > Build settings (Fichier > Paramètres de compilation).
  2. Sélectionnez Build App Bundle (Google Play) (Créer un app bundle (Google Play)). Pour en savoir plus, consultez la documentation de référence sur les paramètres de compilation Android.
  3. Cliquez sur Compiler.
  4. Téléchargez le fichier AAB depuis l'éditeur Unity.

Créer une version de test interne

Pour créer une version de test interne et ajouter des testeurs dans la Play Console, procédez comme suit :

  1. Dans la Google Play Console, sélectionnez un jeu.
  2. Accédez à la page Tester et publier (Tests> Tests internes).
  3. Cliquez sur Importer, puis sélectionnez le fichier AAB.
  4. Dans le champ Informations sur la version, saisissez un nom.
  5. Cliquez sur Suivant et vérifiez les détails de la version.
  6. Cliquez sur Enregistrer et publier.

8. Créer et exécuter le projet

Vous êtes maintenant prêt à compiler le projet et à le tester sur votre appareil.

  1. Assurez-vous que le jeu est ouvert.
  2. Dans la Play Console, accédez à Fichier > Profil de compilation (ou Paramètres de compilation).
  3. Assurez-vous que l'option Build App Bundle (Google Play) (Créer un app bundle [Google Play]) est cochée si vous souhaitez importer le fichier dans la Play Console, ou cliquez sur Build and Run (Créer et exécuter) pour le déployer directement sur votre appareil connecté.
  4. Pour les appareils pliables, vous devez ajuster la mise en page de votre jeu en fonction de la position de pliage de l'appareil (par exemple, HALF_OPENED, FLAT) et de la taille de l'écran à la volée.

9. Félicitations

Vous avez appris les principes de l'adaptation d'un jeu Unity Android pour les grands écrans et les appareils pliables.

Enquête

Vos commentaires sur cet atelier de programmation sont très importants. Prenez quelques minutes pour répondre à notre enquête.