Otimização de jogos do Unity para telas grandes e dispositivos dobráveis

1. Introdução

Neste codelab, você vai aprender a otimizar um jogo Unity Android para dispositivos de tela grande e dobráveis. Você vai usar o projeto de amostra Lost Crypt para implementar a compatibilidade com proporções, expandir a utilização em tela cheia e responder a estados dobráveis.

Pré-requisitos

• Noções básicas de desenvolvimento para Unity e Android.
• Dispositivos Android de tela grande, como tablets ou smartphones dobráveis.

Conteúdo do laboratório

• Como implementar suporte a várias proporções.
• Como usar âncoras nas configurações de câmera e interface do jogo para ajustar automaticamente ao tamanho da tela.
• Como usar o Jetpack Window Manager do Android para detectar a posição de dobra do dispositivo e ajustar o layout.

O que é necessário

• Unity Hub e Editor: Unity 2020 LTS ou Unity 2022 instalado, com suporte para build do Android.
• Hardware: dispositivos Android de tela grande, como tablets ou smartphones dobráveis.
• Uma plataforma de desenvolvimento agêntico, como o Google Antigravity, se você planeja usar a habilidade.

2. Habilidade do agente

Como opção, uma habilidade de agente está disponível para avaliar seu projeto de jogo do Unity. Essa habilidade ajuda você a adicionar suporte para redimensionamento e dispositivos de tela grande e dobráveis. Para mais informações, consulte: GitHub

Para usar essa habilidade:

1. Copie o arquivo SKILL.md para o diretório do agente. Para mais informações sobre como adicionar uma habilidade, consulte Como começar a usar o Google Antigravity.
2. Faça perguntas ao agente na sua IDE de agente, como o Antigravity, sobre telas grandes, dobráveis ou redimensionamento.
3. Peça ao agente para adicionar suporte a telas grandes e dispositivos dobráveis.

3. Suporte a proporção

Para garantir que o jogo apareça corretamente em diferentes tamanhos de tela, comece implementando o suporte a várias proporções. Você pode ajustar a proporção da câmera ou da tela para se adequar melhor a diferentes telas.

1. Verifique se o aplicativo usa a configuração de tela cheia redimensionável.
2. No seu AndroidManifest.xml (localizado em Assets/Plugins/Android/AndroidManifest.xml):
   1. Defina android:resizeableActivity="true".
   2. Defina android:screenOrientation="fullSensor".

Exemplo:

<?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. Verifique as Configurações de build no Unity para configurações da plataforma Android.

Observação: oferecer suporte a várias proporções é a primeira etapa para que seu jogo tenha uma ótima aparência em tablets e dispositivos dobráveis.

4. Utilização da tela cheia

Depois de se adaptar a diferentes proporções, verifique se o jogo usa a tela inteira para tornar a jogabilidade mais imersiva.

Para usar a tela inteira:

1. Use âncoras nas configurações de câmera e interface do jogo. Isso permite que os elementos da interface ajustem automaticamente as posições em relação ao tamanho da tela.
2. Abra a cena Ancoragem no projeto de exemplo para ver como a ancoragem da tela da interface é configurada.
3. Na cena Ancoragem, a tela é atualizada para reconhecer o quadro de segurança, e os controles de movimento são ancorados nos cantos da tela.

Para manter a proporção da câmera principal, ajuste dinamicamente o pixelRect dela. O script CameraAspectLock.cs demonstra como responder a mudanças de orientação e usar o efeito letterbox na visualização da câmera:

[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. Suporte para dispositivos dobráveis

Em dispositivos dobráveis, ajuste o layout do jogo com base na postura de dobra do dispositivo (por exemplo, HALF_OPENED, FLAT) e no tamanho da tela.

1. Use o Jetpack Window Manager do Android para detectar o estado do dispositivo.
2. No projeto de exemplo, abra a cena HingeAware.
3. Essa cena contém um MonoBehaviour ConfigurationManager que conecta os eventos do Jetpack WindowManager do Android ao Unity e responde aos estados de dobra por callbacks UnityEvent.
4. O HingeSensor.cs lê o ângulo da dobradiça usando o plug-in Java com.unity.lostcryptlargescreenexample.HingeAngleSensor.

Como usar o ConfigurationManager

O ConfigurationManager.cs se comunica com uma atividade personalizada do Android e analisa strings JSON que representam o estado. Ele detecta callbacks onConfigurationChanged e onFoldChanged da atividade do 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));
}

Também é possível consultar o estado de forma síncrona usando a propriedade 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. Usar o HingeSensor

Alguns dispositivos dobráveis têm um sensor de articulação físico que fornece o ângulo exato da dobra (de 0 a 360 graus). Você pode usar isso para impulsionar a mecânica de jogo ou ajustar a câmera.

Em HingeSensor.cs, um plug-in do Android é inicializado para ler o sensor de hardware. Você também pode verificar se a dobradiça está ativada:

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

Observação: chame Dispose() ou StopSensing() na sua instância HingeSensor quando o aplicativo for pausado ou destruído para evitar o consumo da bateria.

7. Criar um arquivo AAB

Para criar um arquivo AAB no Unity Editor, siga estas etapas:

1. No Unity Editor, clique em File > Build settings.
2. Selecione Criar pacote de app ( Google Play).Para mais informações, consulte Referência das configurações de build do Android.
3. Clique em Build.
4. Faça o download do arquivo AAB no Unity Editor.

Criar uma versão de teste interno

Para criar uma versão de teste interno e adicionar testadores no Play Console, siga estas etapas:

1. No Google Play Console, selecione um jogo.
2. Acesse a página Testar e lançar (Teste > Teste interno).
3. Clique em Fazer upload e selecione o arquivo AAB.
4. No campo Detalhes da versão, insira um nome.
5. Clique em Próxima e revise os detalhes da versão.
6. Clique em Salvar e publicar.

8. Criar e executar o projeto

Agora você já pode criar o projeto e testá-lo no seu dispositivo.

1. Confira se o jogo está aberto.
2. No Play Console, acesse Arquivo > Perfil de build (ou Configurações de build).
3. Verifique se a opção Criar pacote de apps (Google Play) está marcada se você quiser fazer upload para o Play Console ou clique em Criar e executar para implantar diretamente no dispositivo conectado.
4. Verifique os dispositivos dobráveis e ajuste o layout do jogo com base na postura de dobra do dispositivo (por exemplo, HALF_OPENED, FLAT) e no tamanho da tela em tempo real.

9. Parabéns

Você aprendeu os princípios de adaptação de um jogo Unity para Android em telas grandes e dispositivos dobráveis.

Pesquisa

Seu feedback sobre este codelab é muito importante. Reserve alguns minutos para responder à nossa pesquisa.

RESPONDER À PESQUISA