Optimiza juegos de Unity para pantallas grandes y dispositivos plegables

1. Introducción

En este codelab, aprenderás a optimizar un juego para Android de Unity para dispositivos con pantalla grande y plegables. Usarás el proyecto de muestra Lost Crypt para implementar la compatibilidad con la relación de aspecto, expandir el uso de pantalla completa y responder a los estados de plegado.

Requisitos previos

• Conocimientos básicos sobre el desarrollo en Unity y Android
• Dispositivos Android con pantalla grande, como tablets o teléfonos plegables

Qué aprenderá

• Cómo implementar la compatibilidad con varias relaciones de aspecto
• Cómo usar anclajes en la IU y la configuración de la cámara de tu juego para que se ajusten automáticamente al tamaño de la pantalla
• Cómo usar Jetpack Window Manager de Android para detectar la posición de plegado del dispositivo y ajustar el diseño

Requisitos

• Unity Hub y Editor: Unity 2020 LTS o Unity 2022 instalados, con compatibilidad con la compilación de Android.
• Hardware: Dispositivos Android con pantalla grande, como tablets o teléfonos plegables.
• Plataforma de desarrollo con agentes, como Google Antigravity, si planeas usar la habilidad

2. Habilidad del agente

De manera opcional, hay una habilidad del agente disponible para evaluar tu proyecto de juego de Unity. Esta habilidad te ayuda a agregar compatibilidad con el cambio de tamaño y con dispositivos plegables y de pantalla grande. Para obtener más información, consulta GitHub.

Para usar esta habilidad, haz lo siguiente:

1. Copia el archivo SKILL.md en el directorio de tu agente. Para obtener más información sobre cómo agregar una habilidad, consulta Cómo comenzar a usar Google Antigravity.
2. Hazle preguntas a tu agente en tu IDE agentic, como Antigravity, sobre pantallas grandes, dispositivos plegables o cambio de tamaño.
3. Pídele al agente que agregue compatibilidad con pantallas grandes y dispositivos plegables.

3. Compatibilidad con la relación de aspecto

Para asegurarte de que tu juego se muestre correctamente en diferentes tamaños de pantalla, comienza por implementar la compatibilidad con varias relaciones de aspecto. Puedes ajustar la relación de aspecto de la cámara o el lienzo para que se adapte mejor a diferentes pantallas.

1. Asegúrate de que tu aplicación utilice el parámetro de configuración de pantalla completa redimensionable.
2. En tu AndroidManifest.xml (ubicado en Assets/Plugins/Android/AndroidManifest.xml):
   1. Establece android:resizeableActivity="true".
   2. Establece android:screenOrientation="fullSensor".

Por ejemplo:

<?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>

3. Revisa la configuración de compilación en Unity para ver la configuración de la plataforma de Android.

Nota: Admitir varias relaciones de aspecto es el primer paso para que tu juego se vea bien en tablets y dispositivos plegables.

4. Aprovechamiento de la pantalla completa

Después de adaptarte a diferentes relaciones de aspecto, asegúrate de que tu juego use toda la pantalla para que la experiencia de juego sea más inmersiva.

Para usar toda la pantalla, haz lo siguiente:

1. Usa anclajes en la configuración de la cámara y la IU de tu juego. Esto permite que los elementos de la IU ajusten automáticamente sus posiciones en relación con el tamaño de la pantalla.
2. Abre la escena Anchoring en el proyecto de ejemplo para ver cómo se configura el anclaje del lienzo de la IU.
3. En la escena Anclaje, el lienzo se actualiza para tener en cuenta el marco seguro, y los controles de movimiento se anclan a las esquinas de la pantalla.

Para mantener la relación de aspecto de la cámara principal, ajusta de forma dinámica el pixelRect de la cámara. La secuencia de comandos CameraAspectLock.cs muestra cómo responder a los cambios de orientación y cómo agregar barras negras a la vista de la cámara:

[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. Compatibilidad con dispositivos plegables

En el caso de los dispositivos plegables, debes ajustar el diseño del juego según la postura de plegado del dispositivo (por ejemplo, HALF_OPENED, FLAT) y el tamaño de la pantalla sobre la marcha.

1. Usa el Window Manager de Jetpack de Android para detectar el estado del dispositivo.
2. En el proyecto de ejemplo, abre la escena HingeAware.
3. Esta escena contiene un MonoBehaviour ConfigurationManager que conecta los eventos de Jetpack WindowManager de Android con Unity y responde a los estados de plegado a través de devoluciones de llamada UnityEvent.
4. El HingeSensor.cs lee el ángulo de la bisagra con el complemento de Java com.unity.lostcryptlargescreenexample.HingeAngleSensor.

Cómo usar ConfigurationManager

ConfigurationManager.cs se comunica con una actividad personalizada de Android y analiza cadenas JSON que representan el estado. Espera las devoluciones de llamada onConfigurationChanged y onFoldChanged de la actividad de 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));
}

También puedes consultar el estado de forma síncrona con la propiedad 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. Utiliza el HingeSensor

Algunos dispositivos plegables tienen un sensor de bisagra físico que proporciona el ángulo exacto del pliegue (de 0 a 360 grados). Puedes usarlo para controlar la mecánica de juego o ajustar la cámara.

En HingeSensor.cs, se inicializa un complemento para Android para leer el sensor de hardware. También puedes verificar si la bisagra está habilitada:

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

Nota: Asegúrate de llamar a Dispose() o StopSensing() en tu instancia de HingeSensor cuando tu aplicación se pause o se destruya para evitar el consumo de batería.

7. Crea un archivo AAB

Para crear un archivo AAB en el editor de Unity, sigue estos pasos:

1. En el editor de Unity, haz clic en File > Build settings.
2. Selecciona Build App Bundle ( Google Play).Para obtener más información, consulta la referencia de la configuración de compilación de Android.
3. Haz clic en Build.
4. Descarga el archivo AAB desde el editor de Unity.

Crea una versión de prueba interna

Para crear una versión de prueba interna y agregar verificadores en Play Console, sigue estos pasos:

1. En Google Play Console, selecciona un juego.
2. Navega a la página Prueba y lanza (Pruebas > Pruebas internas).
3. Haz clic en Subir y selecciona el archivo AAB.
4. En el campo Detalles de la versión, ingresa un nombre.
5. Haz clic en Siguiente y revisa los detalles de la versión.
6. Haz clic en Guardar y publicar.

8. Compila y ejecuta el proyecto

Ahora puedes compilar el proyecto y probarlo en tu dispositivo.

1. Asegúrate de tener el juego abierto.
2. En Play Console, ve a File > Build Profile (o Build Settings).
3. Asegúrate de que la opción Build App Bundle (Google Play) esté marcada si quieres subir el paquete a Play Console, o bien haz clic en Build and Run para implementarlo directamente en tu dispositivo conectado.
4. Verifica los dispositivos plegables. Debes ajustar el diseño del juego según la posición de plegado del dispositivo (por ejemplo, HALF_OPENED, FLAT) y el tamaño de la pantalla sobre la marcha.

9. Felicitaciones

Aprendiste correctamente los principios para adaptar un juego de Unity para Android a pantallas grandes y dispositivos plegables.

Encuesta

Valoramos mucho tus comentarios sobre este codelab. Considera dedicar unos minutos a completar nuestra encuesta.

RESPONDER ENCUESTA