Membuat Transisi Layar

Kebutuhan transisi antara beberapa layar UI(User Interface) Memungkinkan pengguna untuk berinteraksi dengan aplikasi Anda. Unity saat ini mendukung tiga sistem UI. More info
Lihat di Glossary cukup umum. Di halaman ini kita akan menjelajahi cara sederhana untuk membuat dan mengelola transisi tersebut menggunakan animasi dan State MachinesSatu set negara di Animator Controller yang karakter atau animasi GameObject dapat masuk, bersama dengan satu set transisi antara negara-negara tersebut dan variabel untuk mengingat keadaan saat ini. Negara-negara yang tersedia akan tergantung pada jenis gameplay, tetapi keadaan khas termasuk hal-hal seperti idling, berjalan, berjalan dan melompat. More info
Lihat di Glossary untuk mengemudi dan mengontrol setiap layar.

Overview

Ide tingkat tinggi adalah bahwa setiap layar kami akan memiliki Pengontrol AnimatorKontrol animasi melalui Lapisan Animasi dengan Mesin Negara Animasi dan Pohon Animasi Blend, dikendalikan oleh Parameter Animasi. Pengontrol Animator yang sama dapat direferensikan oleh beberapa model dengan komponen Animator. More info
Lihat di Glossary dengan dua states (Open and Closed) dan boolean Parameter (Open). Untuk transisi antara layar Anda hanya perlu menutup Layar terbuka saat ini dan buka yang diinginkan. Untuk membuat proses ini lebih mudah, kami akan membuat Light ScreenManager kelas kecil yang akan melacak dan merawat penutupan setiap layar terbuka untuk kami. Tombol yang memicu transisi hanya harus meminta ScreenManager untuk membuka layar yang diinginkan.

Berpikir tentang Navigasi

Jika Anda berencana untuk mendukung navigasi controller/keyboard elemen UI, maka penting untuk memiliki beberapa hal dalam pikiran. Penting untuk menghindari memiliki elemen yang dapat dipilih di luar layar karena itu akan memungkinkan pemain untuk memilih elemen layar, kita dapat melakukan itu dengan menonaktifkan hierarki layar off. Kami juga perlu memastikan ketika layar baru ditunjukkan kami mengatur elemen dari itu seperti yang dipilih, jika pemain tidak akan dapat menavigasi ke layar baru. Kami akan mengurus semua yang berada di kelas ScreenManager di bawah ini.

Menyiapkan Pengontrol Animator

Mari kita lihat pengaturan yang paling umum dan minimal untuk Pengontrol Animasi untuk melakukan transisi Layar. Pengontrol akan membutuhkan parameter boolean (Open) dan dua negara (Open and Closed), setiap negara harus memiliki animasi hanya dengan satu keyframeBingkai yang menandai titik awal atau akhir transisi dalam animasi. Bingkai di antara bingkai kunci disebut inbetweens.
Lihat di Glossary, cara ini kami membiarkan Mesin Negara melakukan perpaduan transisi untuk kami.

Sekarang kita perlu membuat transitionCampuran dari satu negara ke mesin negara lain, seperti transisi karakter dari berjalan ke animasi jog. Transisi menentukan berapa lama campuran antara negara harus mengambil, dan kondisi yang mengaktifkan campuran. More info
Lihat di Glossary antara kedua negara, mari kita mulai dengan transisi dari Terbuka ke Tertutup dan mari kita mengatur kondisi dengan benar, kita ingin pergi dari Terbuka ke Tertutup ketika parameter Terbuka diatur ke palsu. Sekarang kita membuat transisi dari Tertutup ke Open dan mengatur kondisi untuk pergi dari Tertutup ke Open ketika parameter Open benar.

Mengelola layar

Dengan semua set di atas, satu-satunya hal yang hilang adalah untuk kami untuk mengatur parameter Terbuka untuk benar pada layar Animator kita ingin transisi ke dan Buka palsu pada layar terbuka saat ini Animator. Untuk melakukan itu, kita akan membuat skrip kecil:

using UnityEngine;
using UnityEngine.UI;
using UnityEngine.EventSystems;
using System.Collections;
using System.Collections.Generic;

public class ScreenManager : MonoBehaviour {

    //Screen to open automatically at the start of the Scene
    public Animator initiallyOpen;

    //Currently Open Screen
    private Animator m_Open;

    //Hash of the parameter we use to control the transitions.
    private int m_OpenParameterId;

    //The GameObject Selected before we opened the current Screen.
    //Used when closing a Screen, so we can go back to the button that opened it.
    private GameObject m_PreviouslySelected;

    //Animator State and Transition names we need to check against.
    const string k_OpenTransitionName = "Open";
    const string k_ClosedStateName = "Closed";

    public void OnEnable()
    {
        //We cache the Hash to the "Open" Parameter, so we can feed to Animator.SetBool.
        m_OpenParameterId = Animator.StringToHash (k_OpenTransitionName);

        //If set, open the initial Screen now.
        if (initiallyOpen == null)
            return;
        OpenPanel(initiallyOpen);
    }

    //Closes the currently open panel and opens the provided one.
    //It also takes care of handling the navigation, setting the new Selected element.
    public void OpenPanel (Animator anim)
    {
        if (m_Open == anim)
            return;

        //Activate the new Screen hierarchy so we can animate it.
        anim.gameObject.SetActive(true);
        //Save the currently selected button that was used to open this Screen. (CloseCurrent will modify it)
        var newPreviouslySelected = EventSystem.current.currentSelectedGameObject;
        //Move the Screen to front.
        anim.transform.SetAsLastSibling();

        CloseCurrent();

        m_PreviouslySelected = newPreviouslySelected;

        //Set the new Screen as then open one.
        m_Open = anim;
        //Start the open animation
        m_Open.SetBool(m_OpenParameterId, true);

        //Set an element in the new screen as the new Selected one.
        GameObject go = FindFirstEnabledSelectable(anim.gameObject);
        SetSelected(go);
    }

    //Finds the first Selectable element in the providade hierarchy.
    static GameObject FindFirstEnabledSelectable (GameObject gameObject)
    {
        GameObject go = null;
        var selectables = gameObject.GetComponentsInChildren<Selectable> (true);
        foreach (var selectable in selectables) {
            if (selectable.IsActive () && selectable.IsInteractable ()) {
                go = selectable.gameObject;
                break;
            }
        }
        return go;
    }

    //Closes the currently open Screen
    //It also takes care of navigation.
    //Reverting selection to the Selectable used before opening the current screen.
    public void CloseCurrent()
    {
        if (m_Open == null)
            return;

        //Start the close animation.
        m_Open.SetBool(m_OpenParameterId, false);

        //Reverting selection to the Selectable used before opening the current screen.
        SetSelected(m_PreviouslySelected);
        //Start Coroutine to disable the hierarchy when closing animation finishes.
        StartCoroutine(DisablePanelDeleyed(m_Open));
        //No screen open.
        m_Open = null;
    }

    //Coroutine that will detect when the Closing animation is finished and it will deactivate the
    //hierarchy.
    IEnumerator DisablePanelDeleyed(Animator anim)
    {
        bool closedStateReached = false;
        bool wantToClose = true;
        while (!closedStateReached && wantToClose)
        {
            if (!anim.IsInTransition(0))
                closedStateReached = anim.GetCurrentAnimatorStateInfo(0).IsName(k_ClosedStateName);

            wantToClose = !anim.GetBool(m_OpenParameterId);

            yield return new WaitForEndOfFrame();
        }

        if (wantToClose)
            anim.gameObject.SetActive(false);
    }

    //Make the provided GameObject selected
    //When using the mouse/touch we actually want to set it as the previously selected and 
    //set nothing as selected for now.
    private void SetSelected(GameObject go)
    {
        //Select the GameObject.
        EventSystem.current.SetSelectedGameObject(go);

        //If we are using the keyboard right now, that's all we need to do.
        var standaloneInputModule = EventSystem.current.currentInputModule as StandaloneInputModule;
        if (standaloneInputModule != null)
            return;

        //Since we are using a pointer device, we don't want anything selected. 
        //But if the user switches to the keyboard, we want to start the navigation from the provided game object.
        //So here we set the current Selected to null, so the provided gameObject becomes the Last Selected in the EventSystem.
        EventSystem.current.SetSelectedGameObject(null);
    }
}

Mari kita kaitkan skrip ini, kita melakukan ini dengan membuat GameObjectObjek mendasar dalam adegan Unity, yang dapat mewakili karakter, props, pemandangan, kamera, waypoints, dan banyak lagi. Fungsi GameObject didefinisikan oleh Komponen yang melekat padanya. More info
Lihat di Glossary baru, kita dapat mengubah nama "ScreenManager" misalnya, dan menambahkan komponen di atas ke dalamnya. Anda dapat menetapkan layar awal untuk itu, layar ini akan terbuka pada awal sceneAdegan berisi lingkungan dan menu permainan Anda. Pikirkan setiap file Adegan unik sebagai tingkat yang unik. Di setiap Adegan, Anda menempatkan lingkungan, hambatan, dan dekorasi, pada dasarnya merancang dan membangun permainan Anda dalam potongan-potongan. More info
Lihat di Glossary Anda.

Sekarang untuk bagian akhir, mari kita buat pekerjaan Tombol UI. Pilih tombol yang harus memicu transisi layar dan tambahkan tindakan baru di bawah daftar On Click () di Inspektur. Seret Permainan ScreenManager Objek yang kami buat ke ObjectField, pada dropdown pilih ScreenManager->OpenPanel (Animator) dan drag dan drop panel yang ingin Anda buka ketika pengguna mengklik tombol ke objek lasField.

Notes

Teknik ini hanya membutuhkan setiap layar untuk memiliki AnimatorController dengan parameter Terbuka dan keadaan tertutup untuk bekerja - itu tidak masalah bagaimana layar atau mesin negara Anda dibangun. Teknik ini juga bekerja dengan baik dengan layar bersarang, berarti Anda hanya perlu satu ScreenManager untuk setiap tingkat bersarang.

Mesin Negara kami mengatur di atas memiliki state default Tertutup, sehingga semua layar yang menggunakan pengontrol ini mulai ditutup. The ScreenManager menyediakan properti awalnyaOpen sehingga Anda dapat menentukan layar mana yang ditampilkan terlebih dahulu.