Optymalizacja gier Unity na duże ekrany i urządzenia składane

1. Wprowadzenie

W tym ćwiczeniu dowiesz się, jak zoptymalizować grę na Androida w Unity pod kątem urządzeń z dużym ekranem i urządzeń składanych. Aby wdrożyć obsługę formatu obrazu, rozszerzyć wykorzystanie pełnego ekranu i reagować na stany urządzenia składanego, użyjesz przykładowego projektu Lost Crypt.

Wymagania wstępne

• Podstawowa znajomość Unity i programowania na Androida.
• urządzenia z Androidem z dużym ekranem, takie jak tablety lub telefony składane;

Czego się dowiesz

• Jak wdrożyć obsługę różnych formatów obrazu.
• Jak używać punktów zakotwiczenia w interfejsie gry i ustawieniach kamery, aby automatycznie dostosowywać się do rozmiaru ekranu.
• Jak używać Menedżera okien Jetpack na Androidzie do wykrywania pozycji złożenia urządzenia i dostosowywania układu.

Wymagania

• Unity Hub i edytor: zainstalowana wersja Unity 2020 LTS lub Unity 2022 z obsługą kompilacji na Androida.
• Sprzęt: urządzenia z Androidem z dużym ekranem, takie jak tablety lub telefony składane.
• Oparta na agentach platforma dla programistów, np. Google Antigravity, jeśli planujesz korzystać z umiejętności.

2. Umiejętności agenta

Opcjonalnie dostępna jest umiejętność agenta, która umożliwia ocenę projektu gry w Unity. Ta umiejętność pomaga dodać obsługę zmiany rozmiaru oraz obsługę urządzeń z dużym ekranem i urządzeń składanych. Więcej informacji znajdziesz w witrynie GitHub.

Aby skorzystać z tej umiejętności:

1. Skopiuj plik SKILL.md do katalogu agenta. Więcej informacji o dodawaniu umiejętności znajdziesz w artykule Pierwsze kroki z Google Antigravity.
2. Zadaj agentowi w środowisku IDE agenta, np. Antigravity, pytania dotyczące dużych ekranów, urządzeń składanych lub zmiany rozmiaru.
3. Poproś agenta o dodanie obsługi dużych ekranów i urządzeń składanych.

3. Obsługa formatu obrazu

Aby mieć pewność, że gra wyświetla się prawidłowo na ekranach o różnych rozmiarach, zacznij od wdrożenia obsługi różnych formatów obrazu. Możesz dostosować format obrazu z kamery lub obszaru roboczego, aby lepiej pasował do różnych ekranów.

1. Sprawdź, czy aplikacja korzysta z ustawienia pełnego ekranu z możliwością zmiany rozmiaru.
2. W AndroidManifest.xml (znajdującym się pod adresem Assets/Plugins/Android/AndroidManifest.xml):
   1. Ustaw android:resizeableActivity="true".
   2. Ustaw android:screenOrientation="fullSensor".

Na przykład:

<?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. Sprawdź ustawienia kompilacji w Unity pod kątem konfiguracji platformy Android.

Uwaga: obsługa różnych formatów obrazu to pierwszy krok do zapewnienia świetnego wyglądu gry na tabletach i urządzeniach składanych.

4. Wykorzystanie pełnego ekranu

Po dostosowaniu się do różnych formatów obrazu upewnij się, że gra wykorzystuje cały ekran, aby rozgrywka była bardziej wciągająca.

Aby korzystać z całego ekranu:

1. Używaj punktów zakotwiczenia w interfejsie gry i ustawieniach kamery. Dzięki temu elementy interfejsu automatycznie dostosowują swoje położenie do rozmiaru ekranu.
2. Otwórz scenę Anchoring w projekcie przykładowym, aby zobaczyć, jak skonfigurowane jest kotwiczenie obszaru roboczego interfejsu.
3. W scenie Anchoring obszar roboczy jest aktualizowany, aby uwzględniać bezpieczną ramkę, a elementy sterujące ruchem są zakotwiczone w rogach ekranu.

Aby zachować format obrazu głównego aparatu, dynamicznie dostosuj pixelRect. Skrypt CameraAspectLock.cs pokazuje, jak reagować na zmiany orientacji i przycinać widok z kamery:

[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. Obsługa urządzeń składanych

W przypadku urządzeń składanych należy na bieżąco dostosowywać układ gry do pozycji złożenia urządzenia (np. HALF_OPENED, FLAT) i rozmiaru ekranu.

1. Użyj Jetpack Window Manager na Androidzie, aby wykryć stan urządzenia.
2. W przykładowym projekcie otwórz scenę HingeAware.
3. Ta scena zawiera ConfigurationManager MonoBehaviour, który łączy zdarzenia Jetpack WindowManager na Androidzie z Unity i reaguje na stany składania za pomocą wywołań zwrotnych UnityEvent.
4. HingeSensor.cs odczytuje kąt zawiasu za pomocą com.unity.lostcryptlargescreenexample.HingeAngleSensor wtyczki Java.

Korzystanie z klasy ConfigurationManager

ConfigurationManager.cs komunikuje się z niestandardową aktywnością na Androidzie i analizuje ciągi JSON reprezentujące stan. Nasłuchuje wywołań zwrotnych onConfigurationChanged i onFoldChanged z aktywności Androida.

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

Możesz też synchronicznie wysyłać zapytania o stan za pomocą właściwości 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. Korzystanie z  HingeSensor

Niektóre urządzenia składane mają fizyczny czujnik zawiasu, który podaje dokładny kąt zgięcia (od 0 do 360 stopni). Możesz go używać do sterowania mechaniką rozgrywki lub dostosowywania kamery.

W HingeSensor.cs inicjowana jest wtyczka Androida, która odczytuje dane z czujnika sprzętowego. Możesz też sprawdzić, czy zawias jest włączony:

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

Uwaga: gdy aplikacja zostanie wstrzymana lub zamknięta, wywołaj funkcję Dispose() lub StopSensing() w instancji HingeSensor, aby zapobiec rozładowaniu baterii.

7. Tworzenie pliku AAB

Aby utworzyć plik AAB w edytorze Unity, wykonaj te czynności:

1. W edytorze Unity kliknij File > Build settings (Plik > Ustawienia kompilacji).
2. Kliknij Build App Bundle (Google Play) (Utwórz pakiet aplikacji (Google Play)). Więcej informacji znajdziesz w informacjach o ustawieniach kompilacji na Androida.
3. Kliknij Utwórz.
4. Pobierz plik AAB z Edytora Unity.

Tworzenie wersji testu wewnętrznego

Aby utworzyć wersję testu wewnętrznego i dodać testerów w Konsoli Play:

1. W Konsoli Google Play wybierz grę.
2. Otwórz stronę Testuj i publikuj (Testowanie> Test wewnętrzny).
3. Kliknij Prześlij i wybierz plik AAB.
4. W polu Szczegóły wersji wpisz nazwę.
5. Kliknij Dalej i sprawdź szczegóły wydania.
6. Kliknij Zapisz i opublikuj.

8. Kompilowanie i uruchamianie projektu

Możesz teraz skompilować projekt i przetestować go na urządzeniu.

1. Upewnij się, że gra jest otwarta.
2. W Konsoli Play kliknij Plik > Utwórz profil (lub Ustawienia kompilacji).
3. Jeśli chcesz przesłać pakiet aplikacji do Konsoli Play, upewnij się, że pole Build App Bundle (Google Play) jest zaznaczone. Możesz też kliknąć Build and Run (Skompiluj i uruchom), aby wdrożyć aplikację bezpośrednio na podłączonym urządzeniu.
4. W przypadku urządzeń składanych należy dostosowywać układ gry na bieżąco w zależności od pozycji złożenia urządzenia (np. HALF_OPENED, FLAT) i rozmiaru ekranu.

9. Gratulacje

Gratulacje! Poznałeś(-aś) zasady dostosowywania gier na Androida w Unity do dużych i składanych ekranów.

Ankieta

Twoja opinia na temat tego ćwiczenia w Codelabs jest dla nas bardzo cenna. Poświęć kilka minut na wypełnienie naszej ankiety.

WYPEŁNIJ ANKIETĘ