コルーチンによる非同期処理を UniTask を使った非同期処理に置き換える実装例

　分割したクラス内にあるコルーチンメソッドによる非同期処理についてリファクタリングを行います。

　前段階の学習としまして、下記の記事の学習をお願い致します。

　　　=>　肥大化したクラス内の処理を、役割に応じたクラスを複数作成して分割する実装例

　またこの記事はリファクタリングが目的であるため、UniTask 自体の詳細な説明は含まれていません。
事前に別の記事や他のサイトの記事を参考して事前学習をお願い致します。

設計

　コルーチンの実行命令である StartCoroutine メソッドは MonoBehaviourを継承しているクラスでのみ利用できます。
そのためコルーチンは、ゲームオブジェクトの生存期間に依存する非同期処理になります。
何故ならコルーチンメソッドのあるスクリプトはゲームオブジェクトにアタッチして利用することになりますので、
そのアタッチしているゲームオブジェクトが破棄されたタイミングでコルーチンメソッドの処理も停止します。
　
　Unity では UniTask により、async / await による非同期処理が実装可能です。
こちらはゲームオブジェクトの生存期間には依存しませんが、ゲームオブジェクトが破棄されても自動的に処理は停止しません。
正しい書き方を理解してロジックを組むことが出来れば、コルーチンよりも柔軟な処理が記述できます。

　どちらの処理の書き方も覚えておくことにより、ソースコードの記述の幅が広がります。
今回は前回の肥大化しているクラスの分割をベースに、コルーチンの処理を UniTask を利用した非同期処理に変更します。

分割前のクラス

　下記は今回のリファクタリングで利用するソースコードです。
以前の学習で分割する際に利用したソースコードと同じものを利用します。

PlayerController.cs

<= クリックしたら開きます。

using System.Collections;
using System.Collections.Generic;
using UnityEngine;
using Utage;
using UtageExtensions;
using UnityEngine.UI;

[RequireComponent(typeof(Rigidbody2D))]
public class PlayerController : MonoBehaviour
{
    public float moveSpeed;


    // - - プレイヤーの向きのコントロール - - 
    public enum FacePlayer
    {
        Front,
        Back,
        Left,
        Right
    }

    public FacePlayer facePlayer;

    // - - プレイヤーの操作のコントロール - - 
    [SerializeField, Header("行動の判定")]
    private bool isStop = false;             // 操作状態の判定用。true なら操作できない。


    private Rigidbody2D rb;                      // コンポーネントの取得用

    private float horizontal;                    // x 軸(水平・横)方向の入力の値の代入用
    private float vertical;                      // y 軸(垂直・縦)方向の入力の値の代入用

    private Animator anim;　　　　　　　　　　　 // コンポーネントの取得用

    private Vector2 lookDirection = new Vector2(0, -1.0f);   // キャラの向きの情報の設定用

    [SerializeField, Header("アクション中の判定")]
    private bool isActionCheck = false;      //アクション実行中の判定用。falseなら終わっていない

    // 御朱印獲得用スクリプト
    [SerializeField]
    private GetGenerator getGenerator;

    // // 御朱印データ
    // private GoshuinData goshuinData;

    private string[] actionlayerMasks = new string[4] { "NPC", "GOS", "BOX", "OTH" };


    void Start()
    {

        // このスクリプトがアタッチされているゲームオブジェクトにアタッチされているコンポーネントの中から、<指定>したコンポーネントの情報を取得して、左辺に用意した変数に代入
        rb = GetComponent<Rigidbody2D>();

        anim = GetComponent<Animator>();

    }

    void Update()
    {
        if (AdvEngineController.instance.IsPlaying == true)
        {
            return;
        }

        // 
        if(UnityEngine.EventSystems.EventSystem.current.currentSelectedGameObject!= null)
        {
            return;
        }


        if (Input.GetButtonDown("Action")) {
            StartCoroutine(Action());
        }

        if (isStop == true)
        {
            return;
        }

        // InputManager の Horizontal に登録してあるキーが入力されたら、水平(横)方向の入力値として代入
        horizontal = Input.GetAxis("Horizontal");

        // InputManager の Vertical に登録してあるキーが入力されたら、水平(横)方向の入力値として代入
        vertical = Input.GetAxis("Vertical");


        // キャラの向いている方向と移動アニメの同期
        SyncMoveAnimation();

    }

    void FixedUpdate()
    {

        // 移動
        Move();
    }

    /// <summary>
    /// 移動
    /// </summary>
    private void Move()
    {
        if (isStop == true)
        {
            return;
        }
        // else
        // {
        
        // velocity(速度)に新しい値を代入して、ゲームオブジェクトを移動させる
        rb.velocity = new Vector2(horizontal * moveSpeed, vertical * moveSpeed);
        
        //}
    }

    /// <summary>
    /// キャラの向いている方向と移動アニメの同期
    /// </summary>
    private void SyncMoveAnimation()
    {

        // 移動のキー入力値を代入
        Vector2 move = new Vector2(horizontal, vertical);

        // いずれかのキー入力があるか確認
        if (!Mathf.Approximately(move.x, 0.0f) || !Mathf.Approximately(move.y, 0.0f))
        {

            // 向いている方向を更新
            lookDirection.Set(move.x, move.y);

            // 正規化
            lookDirection.Normalize();

            // キー入力の値と Blend Tree で設定した移動アニメ用の値を確認し、移動アニメを再生
            anim.SetFloat("Look X", lookDirection.x);
            anim.SetFloat("Look Y", lookDirection.y);

            if (lookDirection.y > 0)
            {
                facePlayer = FacePlayer.Back;
            }
            if (lookDirection.y < 0)
            {
                facePlayer = FacePlayer.Front;
            }
            if (lookDirection.x > 0)
            {
                facePlayer = FacePlayer.Right;
            }
            if (lookDirection.x < 0)
            {
                facePlayer = FacePlayer.Left;
            }
        }
    }

    /// <summary>
    /// 行動ボタンを押した際の処理
    /// </summary>
    private IEnumerator Action() {

        // if (Input.GetButtonDown("Action"))
        // {
        
        // Player の位置を起点とし、Player の向いている方向に 1.0f 分だけ Ray を発射し、NPC レイヤーを持つゲームオブジェクトに接触するか判定し、その情報を hit 変数に代入
        RaycastHit2D hit = Physics2D.Raycast(rb.position, lookDirection, 1.0f, LayerMask.GetMask(actionlayerMasks));

        // Scene ビューにて Ray の可視化
        Debug.DrawRay(rb.position, lookDirection, Color.blue, 1.0f);

        // Ray によって hit 変数にコライダーを持つゲームオブジェクトの情報が取得出来ていない場合、処理しない
        if (!hit.collider) {
            yield break;
        }
        
        // アクション中の場合、処理しない
        if (isActionCheck) {
            yield break;
        }
        
        // Ray によって hit 変数にコライダーを持つゲームオブジェクトの情報が取得出来ている場合
        // if (hit.collider != null)
        // {
        //     if (isActionCheck == false)
        //     {
        
        // 移動停止
        StopPlayer();
        isActionCheck = true;
        bool isSaveOn = false;
        
        // 御朱印と接触した場合
        if (hit.collider.TryGetComponent(out Goshuin gos) == true) { 
            yield return StartCoroutine(getGenerator.ActivatePlacementGetStampPopUp2(gos.goshuinData));
            Destroy(gos.gameObject);
            GameData.instance.AddGoshuinInventryData(gos.goshuinData.goshuinName);
            //isActionCheck = true;
            isSaveOn = true;
        }

        // 宝箱と接触した場合
        else if (hit.collider.TryGetComponent(out TreasureBox box) == true) {

            //Boxシナリオの作成
            yield return StartCoroutine(AdvEngineController.instance.JumpScenarioAsync(box.itemData.itemScenario, null));
            GameData.instance.AddItemInventryData(box.itemData.itemName);
            //箱を開ける時の処理
            box.OpenTresureBox();

            //アクションチェックboolをtrue
            //isActionCheck = true;
            isSaveOn = true;
        }

        // NPCと接触した場合
        else if (hit.collider.TryGetComponent(out NonPlayerCharacter npc) == true) {
            // NPCの向きを変更する
            npc.LookDirection(GetFaceNPC(facePlayer));

            //NPCシナリオの作成
            yield return StartCoroutine(AdvEngineController.instance.JumpScenarioAsync(npc.npcData.npcScenario, null));

            //アクションチェックboolをtrue
            //isActionCheck = true;

            // 会話後のアフターイベントがある場合
            bool isAfterEvent = npc.IsAfterEvents();
            if (isAfterEvent == true) { 
                
            //if (npc.IsAfterEvents()) {  // 上記2行を 1行で書く場合

                yield return StartCoroutine(npc.JedgeAfterEventsCoroutine());
            
                // アフターイベント実行
                //npc.JedgeAfterEvents();
                
                // アフターイベント終了まで処理を中断。UTAGE が await 出来ないので、コルーチンで代用
                yield return new WaitUntil(() => !npc.IsPlayingAfterEvents);
            }
            isSaveOn = true;
        }

        if (isSaveOn) {
            GameData.instance.SaveAllUserDatas();
        }
        
        // 再度移動とアクションを可能にする
        NonStopPlayer();
        isActionCheck = false;
        
        
        //UTAGEのフラグがある場合は
        // if(AdvEngineController.instance.AdvEngine.Param.GetParameterBoolean(npc.utageParamBoolName.ToString()) == true)
        // {
        //     if (npc.utageParamBoolName.ToString() == "ep5_Satokibi5")
        //     {
        //         Debug.Log("AAA");
        //         Debug.Log(npc == null);
        //         npc.Suspect();
        //     }

        // アイテムを追加する

        // if (npc.itemName != ItemName.NoItem)
        // {
        //     GameData.instance.AddItemInventryData(npc.itemName);
        //
        // }
        // 看板があれば看板を消す。
        //     Debug.Log("看板を消す1");
        //     npc.KanbanOff();
        // }
        // if(AdvEngineController.instance.AdvEngine.Param.GetParameterBoolean(npc.utageParamBoolName.ToString()) == true)
        // {
        //     // if 御朱印がNoData出なければ、御朱印を追加する
        //     if (npc.npcData.goshuin != GoshuinName.NoData)
        //     {
        //         if (!GameData.instance.goshuinInventryDatasList.Exists(x => x.goshuinName == npc.npcData.goshuin))
        //         {
        //             getGenerator.ActivatePlacementGetStampPopUp(DataBaseManager.instance.GetGoshuinDataFromName(npc.npcData.goshuin));
        //             GameData.instance.AddGoshuinInventryData(DataBaseManager.instance.GetGoshuinDataFromName(npc.npcData.goshuin).goshuinName);
        //             
        //
        //         }
        //     }
        //
        // }


        //     if(npc.moveCheck == true)
        //     {
        //         StopPlayer();
        //
        //         // 移動させる
        //         Debug.Log("移動アニメ開始");
        //         npc.AddMove(this);
        //         yield return new WaitForSeconds(3.0f);
        //         NonStopPlayer();
        //     }
        // }
        //}

        // todo アクションチェックがtrueならば　セーブのアクションを実装する
        //Debug.Log(transform.position);
        // GameData.instance.SaveAllUserDatas();
        // isActionCheck = false;

        //}

        //}

        //yield return null;
    }

    /// <summary>
    /// StopPlayer
    /// </summary>
    public void StopPlayer()
    {
        isStop = true;
        rb.velocity = Vector3.zero;
        Debug.Log("移動停止");
    }

    /// <summary>
    /// StopPlayer
    /// </summary>
    public void NonStopPlayer()
    {
        isStop = false;
        Debug.Log("移動再開");
    }

    /// <summary>
    /// NPCの向きを伝える
    /// </summary>
    /// <param name="facePlayer"></param>
    /// <returns></returns>
    private FaceNPC GetFaceNPC(FacePlayer facePlayer)
    {
        return facePlayer switch {
            FacePlayer.Back => FaceNPC.FrontNPC,
            FacePlayer.Front => FaceNPC.BackNPC,
            FacePlayer.Left => FaceNPC.RightNPC,
            FacePlayer.Right => FaceNPC.LeftNPC,
            _ => FaceNPC.FrontNPC
        };
    }

    // 正面を向くスクリプト
    public void LookBack()
    {
        Debug.Log("正面をむかせるスクリプト");
        anim.SetFloat("Look X", 0);
        anim.SetFloat("Look Y", 1);
    }

}

クラス分割による役割の考え方

　これも前段階と同じ考え方ですので、ここでは割愛します。

　学習としては、分割した各クラス内にあるコルーチンメソッドを UniTask を利用した async / await の処理にリファクタリングを行います。

親クラスを作成する

　このクラスには変更はありません。

<= クリックしたら開きます。

using UnityEngine;

public abstract class PlayerBase : MonoBehaviour
{
    public abstract void SetUpPlayer();
}

子クラスを作成する

１．PlayerMove.cs

　このクラスには変更はありません。

<= クリックしたら開きます。

using UnityEngine;

[RequireComponent(typeof(Rigidbody2D))]
public class PlayerMove : PlayerBase
{
    [SerializeField]
    private float moveSpeed;
    
    private Rigidbody2D rb;

    
    public override void SetUpPlayer() {
        TryGetComponent(out rb);
    }

    public void Move(Vector2 direction) {
        rb.velocity = direction * moveSpeed;
    }
    
    /// <summary>
    /// StopPlayer
    /// </summary>
    public void StopPlayer()
    {
        rb.velocity = Vector3.zero;
        Debug.Log("移動停止");
    }
}

２．PlayerAnimation.cs

　このクラスには変更はありません。

<= クリックしたら開きます。

using UnityEngine;

// - - プレイヤーの向きのコントロール - - 
public enum FacePlayer
{
    Front,
    Back,
    Left,
    Right
}

[RequireComponent(typeof(Animator))]
public class PlayerAnimation : PlayerBase
{
    private Animator anim;


    public override void SetUpPlayer() {
        TryGetComponent(out anim);
    }

    /// <summary>
    /// キャラの向いている方向と移動アニメの同期
    /// </summary>
    public Vector2 SyncMoveAnimation(Vector2 moveDirection) {
        
        // 向いている方向を更新
        Vector2 lookDirection = moveDirection;

        lookDirection.Set(moveDirection.x, moveDirection.y);

        // 正規化
        lookDirection.Normalize();

        // キー入力の値と Blend Tree で設定した移動アニメ用の値を確認し、移動アニメを再生
        anim.SetFloat("Look X", lookDirection.x);
        anim.SetFloat("Look Y", lookDirection.y);

        return lookDirection;
    }


    public void LookBack()
    {
        Debug.Log("正面をむかせるスクリプト");
        anim.SetFloat("Look X", 0);
        anim.SetFloat("Look Y", 1);
    }
}

３．PlayerAction.cs

　このクラスにはコルーチンを利用したメソッドがありますので、
新しいメソッドを作成した上でリファクタリングを行って非同期処理を置き換えます。

<= クリックしたら開きます。

using System.Collections;
using UnityEngine;
using System.Threading;             //　　<=　宣言を追加します。
using Cysharp.Threading.Tasks;　　　//　　<=　宣言を追加します。

public class PlayerAction : PlayerBase
{
    private FacePlayer facePlayer;

    public FacePlayer FacePlayer {
        get => facePlayer;
        set => value = facePlayer;
    }

    public override void SetUpPlayer() {
    }

    /// <summary>
    /// コルーチンによる非同期イベント実行
    /// </summary>
    /// <param name="hitOject"></param>
    /// <param name="facePlayer"></param>
    /// <returns></returns>
    public IEnumerator PlayActionCoroutine(GameObject hitOject) {

        if (hitOject.TryGetComponent(out NonPlayerCharacter npc) == true) {
            // NPCの向きを変更する
            npc.LookDirection(GetFaceNPC(facePlayer));
        }

        if (hitOject.TryGetComponent(out GameEventHandler gameEventHandler)) {
            IEnumerator eventCoroutine = gameEventHandler.ExecuteGameEventsCoroutine();
            yield return StartCoroutine(eventCoroutine);
            
            bool isSaveOn = (bool)eventCoroutine.Current;
            CheckSave(isSaveOn);

            // 上記を1行で書いた場合
            CheckSave((bool)eventCoroutine.Current);
        }
    }

    /// <summary>
    /// セーブ確認
    /// </summary>
    /// <param name="isSaveOn"></param>
    private void CheckSave(bool isSaveOn) {
        if (!isSaveOn) {
            return;
        }
        GameData.instance.SaveAllUserDatas();
    }

    /// <summary>
    /// NPCの向きを伝える
    /// </summary>
    /// <param name="facePlayer"></param>
    /// <returns></returns>
    private FaceNPC GetFaceNPC(FacePlayer facePlayer)
    {
        return facePlayer switch {
            FacePlayer.Back => FaceNPC.FrontNPC,
            FacePlayer.Front => FaceNPC.BackNPC,
            FacePlayer.Left => FaceNPC.RightNPC,
            FacePlayer.Right => FaceNPC.LeftNPC,
            _ => FaceNPC.FrontNPC
        };
    }


////*　ここから追加　*////


    /// <summary>
    /// 非同期処理
    /// </summary>
    /// <param name="hitOject"></param>
    /// <param name="token"></param>
    public async UniTask PlayActionAsync(GameObject hitOject, CancellationToken token) {
        
        if (hitOject.TryGetComponent(out NonPlayerCharacter npc) == true) {
            // NPCの向きを変更する
            npc.LookDirection(GetFaceNPC(facePlayer));
        }

        if (hitOject.TryGetComponent(out GameEventHandler gameEventHandler)) {
            
            // NPC のキャンセル処理は NPC 側でキャンセルトークンを作成させる
            bool isSaveOn = await gameEventHandler.ExecuteGameEventsAsync(token)
            CheckSave(isSaveOn);

　　　　　　　　　↓
                   
            // 上記2行を1行で書いた場合
            CheckSave(await gameEventHandler.ExecuteGameEventsAsync(token));
        }
    }


////*　ここまで　*////


}

　async / await による非同期処理用のメソッドは、戻り値を UniTask 型にします。
コルーチンメソッドと違い、戻り値には任意の情報を持たせることが出来ます。UniTask<int> のように書けます。

　加えて、メソッドの定義には async キーワードを付与します。
メソッド名はわかりやすいように～ Async で終わるようにし、非同期用のメソッドであることがわかるように命名します。
今回であれば PlayActionAsync としています。

　await キーワードを先頭につけることで、非同期処理を実行できます。
これは yield return 付の StartCoroutine と同じ役割になりますので、非同期処理が完了するまで次の処理には移行しません。

　コルーチンメソッドによる非同期処理は実行してすぐに次の処理に移行しましたが、
async / await による非同期処理は待機することが前提になっている非同期処理になります。

４．EventChecker.cs

　このクラスは変更ありません。

<= クリックしたら開きます。

using UnityEngine;

public class EventChecker : PlayerBase
{
    private string[] actionlayerMasks = new string[4] { "NPC", "GOS", "BOX", "OTH" };


    public override void SetUpPlayer() {
        
    }

    /// <summary>
    /// Ray を投射して対象のオブジェクトがアクションの対象物か判定
    /// </summary>
    /// <param name="lookDirection"></param>
    /// <returns></returns>
    public (bool isReacyAction, GameObject hitObj) JedgeAction(Vector2 lookDirection) {
        // Player の位置を起点とし、Player の向いている方向に 1.0f 分だけ Ray を発射し、NPC レイヤーを持つゲームオブジェクトに接触するか判定し、その情報を hit 変数に代入
        RaycastHit2D hit = Physics2D.Raycast(transform.position, lookDirection, 1.0f, LayerMask.GetMask(actionlayerMasks));

        // Scene ビューにて Ray の可視化
        Debug.DrawRay(transform.position, lookDirection, Color.blue, 1.0f);

        // Ray によって hit 変数にコライダーを持つゲームオブジェクトの情報が取得出来ていない場合、処理しない
        if (!hit.collider) {
            return (false, null);
        }

        return (true, hit.collider.gameObject);
    }
}

５．PlayerManager.cs

　このクラスには非同期処理がたくさんありますので、大きな変更があります。

<= クリックしたら開きます。

using System.Collections;
using UnityEngine;
using System.Threading;　　　　　　　//　<=　宣言を追加します。
using Cysharp.Threading.Tasks;　　　 //　<=　宣言を追加します。

[RequireComponent(typeof(PlayerMove))]
[RequireComponent(typeof(PlayerAction))]
[RequireComponent(typeof(PlayerAnimation))]
[RequireComponent(typeof(EventChecker))]
public class PlayerManager : MonoBehaviour
{
    [SerializeField] 
    private PlayerBase[] playerBases;
   
    private PlayerMove playerMove;
    private PlayerAction playerAction;
    private PlayerAnimation playerAnimation;
    private EventChecker eventChecker;
    
    private float horizontal;                    // x 軸(水平・横)方向の入力の値の代入用
    private float vertical;                      // y 軸(垂直・縦)方向の入力の値の代入用
    
    private Vector2 lookDirection = new (0, -1.0f);   // キャラの向きの情報の設定用
    
    private bool isPlayingEvent;


////*　変数の宣言を追加します　*////


    [SerializeField] 
    private bool isAsyncSwitch;

    private CancellationTokenSource cancellationTokenSource;
    private CancellationToken token;


////*　ここまで　*////


    void Start()
    {
        foreach (var player in playerBases) {
            player.SetUpPlayer();

            player.TryGetComponent(out playerMove);
            player.TryGetComponent(out playerAction);
            player.TryGetComponent(out playerAnimation);
            player.TryGetComponent(out eventChecker);
            

////*　処理を追加します　*////


            // Player の MonoBehaviour の破棄と紐づいたキャンセルトークンを作成
            //token = this.GetCancellationTokenOnDestroy();

            cancellationTokenSource = new ();
            token = cancellationTokenSource.Token;


////*　ここまで　*////


        }
    }

    void Update()
    {
        if (AdvEngineController.instance.IsPlaying)
        {
            return;
        }
        
        if(UnityEngine.EventSystems.EventSystem.current.currentSelectedGameObject != null)
        {
            return;
        }

        if (isPlayingEvent) {
            return;
        }
        
        // InputManager の Horizontal に登録してあるキーが入力されたら、水平(横)方向の入力値として代入
        horizontal = Input.GetAxis("Horizontal");

        // InputManager の Vertical に登録してあるキーが入力されたら、水平(横)方向の入力値として代入
        vertical = Input.GetAxis("Vertical");
        
        // いずれかのキー入力があるか確認
        if (!Mathf.Approximately(horizontal, 0.0f) || !Mathf.Approximately(vertical, 0.0f)) {
            // キャラの向いている方向と移動アニメの同期
            lookDirection = playerAnimation.SyncMoveAnimation(new Vector2(horizontal, vertical));
            playerAction.FacePlayer = GetFacePlayerFromDirection();
        }
        
        if (Input.GetButtonDown("Action")) {


////*　非同期処理の実行命令を追加します　*////


            // プレイヤーの向いている方向にあるオブジェクトに対してアクションできるか判定
            PrepareJedgeAction().Forget();　　　//　<=　 Forget() を追加


////*　ここまで　*////


        }
    }

    void FixedUpdate() {
        // 移動
        playerMove.Move(new Vector2(horizontal, vertical));
    }
    
    /// <summary>
    /// 向きの値から FacePlayer を取得
    /// </summary>
    /// <returns></returns>
    public FacePlayer GetFacePlayerFromDirection() {
        return lookDirection switch {
            Vector2 up when up.y > 0 => FacePlayer.Back,
            Vector2 down when down.y < 0 => FacePlayer.Front,
            Vector2 right when right.x > 0 => FacePlayer.Right,
            Vector2 left when left.x < 0 => FacePlayer.Left,
            _ => FacePlayer.Front,
        };
    }

    /// <summary>
    /// イベント開始
    /// </summary>
    private void EnterGameEvent() {
        isPlayingEvent = true;
        playerMove.StopPlayer();
        Debug.Log("イベント開始");
    }

    /// <summary>
    /// イベント終了
    /// </summary>
    private void ExitGameEvent() {
        isPlayingEvent = false;
        Debug.Log("イベント終了");
    }

    /// <summary>
    /// コルーチンによる非同期処理によるイベント処理の制御
    /// フラグによりどちらの非同期を利用するか分岐
    /// </summary>
    /// <returns></returns>
    private IEnumerator StartEventCoroutine(GameObject hitObj) {
        
        // イベント開始。移動とアクション停止。
        EnterGameEvent();

        // イベント発生
        yield return StartCoroutine(playerAction.PlayActionCoroutine(hitObj));
        
        // イベント終了。再度移動とアクションを可能にする
        ExitGameEvent();
    }
    

////*　処理を修正・追加します　*////


    /// <summary>
    /// プレイヤーから投射した Ray が、指定した Layer 設定のあるコライダーに接触したか判定
    /// 接触しており、かつ、該当するオブジェクトの場合にはアクション成功となり、イベント制御開始
    /// </summary>
    private async UniTask PrepareJedgeAction() {   //  <=  ☆①　async キーワードを追加し、戻り値を UniTask にする
        (bool isReadyAction, GameObject hitObj) item = eventChecker.JedgeAction(lookDirection);
        
        if (!item.isReadyAction) {
            return;
        }
        

////*　☆②　処理を修正・追加します。bool 値により、どちらの非同期処理を実行するか切り替えられるようにします　*////


        // 判定に成功した場合、イベント実行
        if (isAsyncSwitch) {
            await StartEventAsync(item.hitObj);
        } else {
            StartCoroutine(StartEventCoroutine(item.hitObj));
        }


////*　ここまで　*////


    }


////*　新しい非同期用のメソッドを追加します　*////


    /// <summary>
    /// UniTask による非同期
    /// </summary>
    private async UniTask StartEventAsync(GameObject hitObj) {
        
        // イベント開始。移動とアクション停止。
        EnterGameEvent();

        // イベント発生
        await playerAction.PlayActionAsync(hitObj, token);

        // イベント終了。再度移動とアクションを可能にする
        ExitGameEvent();
    }


////*　ここまで　*////


}

Forget メソッド

　非同期処理以外のメソッド内で await のない非同期処理を実行すると警告が表示されます。
その場合には、Forget メソッドを追加することで、待機のない非同期処理(従来のコルーチンメソッド)として実行することが可能になります。

Update メソッド内

  if (Input.GetButtonDown("Action")) {

      // プレイヤーの向いている方向にあるオブジェクトに対してアクションできるか判定
      PrepareJedgeAction().Forget();
  }

　Forget メソッドを追加している処理は待機せずに、次の処理が実行されます。

ゲームを実行して動作を確認する

　スクリプトのアタッチ先などは変わりませんので、ソースコードの修正が終了したらリファクタリングは完成です。

　どの部分を修正しているのか、処理の見直しをした上で、いままでと同じように処理が動作するかを確認してください。

このページを編集するこのページを元に新規ページを作成

印刷する

コメント（0）

コルーチンによる非同期処理を UniTask を使った非同期処理に置き換える実装例 - i-school 先頭へ

コメントをかく

名前	ユーザIDを使用しないで書き込む	ユーザーIDを使う	ログインする
画像コード	画像に記載されている文字を下のフォームに入力してください。
備考	「http://」を含む投稿は禁止されています。
本文
利用規約をご確認のうえご記入下さい

i-school