Ottimizzare i giochi Unity per schermi grandi e pieghevoli

1. Introduzione

In questo codelab imparerai a ottimizzare un gioco Unity per Android per dispositivi con schermi di grandi dimensioni e pieghevoli. Utilizzerai il progetto di esempio Lost Crypt per implementare il supporto delle proporzioni, espandere l'utilizzo a schermo intero e rispondere agli stati pieghevoli.

Prerequisiti

• Conoscenza di base dello sviluppo di Unity e Android.
• Dispositivi Android con schermi di grandi dimensioni, come tablet o smartphone pieghevoli.

Cosa imparerai

• Come implementare il supporto per vari formati.
• Come utilizzare gli ancoraggi nelle impostazioni della UI e della videocamera del gioco per adattarsi automaticamente alle dimensioni dello schermo.
• Come utilizzare Jetpack Window Manager di Android per rilevare la postura di chiusura del dispositivo e regolare il layout.

Cosa serve

• Unity Hub ed Editor: Unity 2020 LTS o Unity 2022 installato, con supporto per la build Android.
• Hardware: dispositivi Android con schermi grandi come tablet o smartphone pieghevoli.
• Piattaforma di sviluppo agentico come Google Antigravity se prevedi di utilizzare la skill.

2. Skill dell'agente

Se vuoi, è disponibile una skill dell'agente per valutare il tuo progetto di gioco Unity. Questa competenza ti aiuta ad aggiungere il supporto per il ridimensionamento e per i dispositivi con schermi grandi e pieghevoli. Per maggiori informazioni, consulta: GitHub

Per utilizzare questa skill:

1. Copia il file SKILL.md nella directory dell'agente. Per saperne di più su come aggiungere una skill, consulta l'articolo Inizia a utilizzare Google Antigravity.
2. Chiedi all'agente nel tuo IDE agentico, ad esempio Antigravity, domande su schermi di grandi dimensioni, pieghevoli o ridimensionamento.
3. Chiedi all'agente di aggiungere il supporto per schermi di grandi dimensioni e pieghevoli.

3. Supporto delle proporzioni

Per assicurarti che il tuo gioco venga visualizzato correttamente su schermi di dimensioni diverse, inizia implementando il supporto di vari formati. Potresti prendere in considerazione la possibilità di regolare le proporzioni della videocamera o del canvas per adattarle meglio a schermi diversi.

1. Assicurati che l'applicazione utilizzi l'impostazione ridimensionabile a schermo intero.
2. Nel tuo AndroidManifest.xml (disponibile all'indirizzo Assets/Plugins/Android/AndroidManifest.xml):
   1. Imposta android:resizeableActivity="true".
   2. Imposta android:screenOrientation="fullSensor".

Ad esempio:

<?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. Controlla le impostazioni di build in Unity per le configurazioni della piattaforma Android.

Nota: il supporto di vari formati è il primo passo per rendere il tuo gioco perfetto su tablet e pieghevoli.

4. Utilizzo a schermo intero

Dopo l'adattamento a proporzioni diverse, assicurati che il gioco utilizzi l'intero schermo per rendere il gameplay più coinvolgente.

Per utilizzare l'intero schermo:

1. Utilizza gli ancoraggi nelle impostazioni della videocamera e dell'interfaccia utente del gioco. In questo modo, gli elementi UI regolano automaticamente le loro posizioni in base alle dimensioni dello schermo.
2. Apri la scena Ancoraggio nel progetto di esempio per vedere come è configurato l'ancoraggio del canvas dell'interfaccia utente.
3. Nella scena Ancoraggio, il canvas viene aggiornato in modo da essere compatibile con il safe frame e i controlli di movimento sono ancorati agli angoli dello schermo.

Per mantenere le proporzioni della videocamera principale, regola dinamicamente il pixelRect della videocamera. Lo script CameraAspectLock.cs mostra come rispondere ai cambiamenti di orientamento e come applicare il letterbox alla visualizzazione della videocamera:

[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. Supporto per i dispositivi pieghevoli

Con i dispositivi pieghevoli, devi regolare il layout del gioco in base alla postura di piegatura del dispositivo (ad esempio HALF_OPENED, FLAT) e alle dimensioni dello schermo al volo.

1. Utilizza Jetpack Window Manager di Android per rilevare lo stato del dispositivo.
2. Nel progetto di esempio, apri la scena HingeAware.
3. Questa scena contiene un MonoBehaviour ConfigurationManager che collega gli eventi Jetpack WindowManager di Android a Unity e risponde agli stati di chiusura tramite i callback UnityEvent.
4. HingeSensor.cs legge l'angolo della cerniera utilizzando il plug-in Java com.unity.lostcryptlargescreenexample.HingeAngleSensor.

Utilizzo di ConfigurationManager

ConfigurationManager.cs comunica con un'attività Android personalizzata e analizza le stringhe JSON che rappresentano lo stato. Ascolta i callback onConfigurationChanged e onFoldChanged dall'attività 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));
}

Puoi anche eseguire query sullo stato in modo sincrono utilizzando la proprietà 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. Utilizzare il HingeSensor

Alcuni dispositivi pieghevoli sono dotati di un sensore fisico della cerniera che fornisce l'angolo esatto della piega (da 0 a 360 gradi). Puoi utilizzarlo per guidare le meccaniche di gioco o regolare la videocamera.

In HingeSensor.cs, un plug-in Android viene inizializzato per leggere il sensore hardware. Puoi anche controllare se la cerniera è attiva:

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: assicurati di chiamare Dispose() o StopSensing() nell'istanza HingeSensor quando l'applicazione viene sospesa o eliminata per evitare il consumo della batteria.

7. Crea un file AAB

Per creare un file AAB in Unity Editor:

1. Nell'editor di Unity, fai clic su File > Build settings.
2. Seleziona Crea pacchetto app ( Google Play).Per maggiori informazioni, consulta la Guida di riferimento alle impostazioni di build di Android.
3. Fai clic su Crea.
4. Scarica il file AAB da Unity Editor.

Creare una release di test interno

Per creare una release di test interni e aggiungere tester in Play Console, segui questi passaggi:

1. In Google Play Console, seleziona un gioco.
2. Vai alla pagina Testa e rilascia (Test > Test interni).
3. Fai clic su Carica e seleziona il file AAB.
4. Nel campo Dettagli release, inserisci un nome.
5. Fai clic su Avanti ed esamina i dettagli della release.
6. Fai clic su Salva e pubblica.

8. Crea ed esegui il progetto

Ora puoi creare il progetto e testarlo sul tuo dispositivo.

1. Assicurati che il gioco sia aperto.
2. In Play Console, vai a File > Build Profile (o Build Settings).
3. Assicurati che l'opzione Crea app bundle (Google Play) sia selezionata se vuoi caricare l'app su Play Console oppure fai clic su Crea ed esegui per eseguire il deployment direttamente sul dispositivo connesso.
4. Verifica i dispositivi pieghevoli. Devi regolare il layout del gioco in base alla postura di piegatura del dispositivo (ad esempio HALF_OPENED, FLAT) e alle dimensioni dello schermo al volo.

9. Complimenti

Hai appreso correttamente i principi di adattamento di un gioco Unity per Android a schermi grandi e dispositivi pieghevoli.

Sondaggio

Il tuo feedback su questo codelab è molto importante. Ti invitiamo a dedicare qualche minuto alla compilazione del nostro sondaggio.

PARTECIPA AL SONDAGGIO