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

　プログラムの学習において、最初のうちは１つのクラス内に色々な処理を書いていくケースがほとんどです。
教材やネットのサイトでも多くそういった書式が紹介されています。

　ソースコードを書くことに慣れてきたら、クラス内の処理を役割単位で分割して、複数のクラスに分けて役割ごとに制御する方法を学習し、実践しましょう。

＜新しい学習内容＞

　・abstract(アブストラクト) 修飾子による抽象クラスと抽象メソッドの宣言
　・クラスの継承とメソッドのオーバーライド処理

ケーススタディ

　よくあるケースとして、PlayerController クラスや GameManager クラスの肥大化があります。
特に初心者の場合や、プログラムに慣れていない場合、複数のクラスに処理を書くことによって処理を読み解くことが難しくなるため、
最初のうちは１つのクラスに集約していくことが多いです。

　実際に１つのクラスに色々な処理がまとまっているソースコードを利用し、クラスの分割を行っていきます。

分割前のクラス

　今回は PlayerController を例に、役割ごとに処理を分割して考えてみます。

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

}

処理を役割に沿って考えてみる

　PlayerController クラス内には、多くの処理があります。
それらの処理を、どういった役割を果たしているのか、という観点で分割してみてください。
その分割したものが役割の１つとなり、同時に、１つのクラスとして作成していく、という方向性になります。

　また処理の内部には、複数の処理内で共通で利用している処理も見受けられます。
例えば十字キー入力値は移動の処理と、アニメの向きの処理の両方で同じ値が利用されています。
こういった部分は共通している部分として、別の役割(共通処理をまとめたクラス)として考えます。

　つまり、移動とアニメの処理からは「十字キー入力値」の処理は含まないようにします。
では、必要な値はどうするのか、ということですが、「共通で利用する処理」をまとめた役割(クラス)を作り、
そこから「十字キー入力値を受け取って」利用するようにします。
それぞれのクラス内で同じ処理を書くのでなくて、共通している情報を管理しているクラスから受け取って利用する、という考え方です。
このようにすることで、十字キー入力の処理は、個々のクラスに書くのでははなく、共通して利用するクラス内のみ(１つのクラス)に集約出来ます。　

参考サイト

MicroSoft
継承
https://docs.microsoft.com/ja-jp/dotnet/csharp/fun...

リファクタリングの方向性

　クラスを分割するにあたっては、クラスの継承機能を利用して、役割(責務)の分割を行っていきます。

　最も最上段にあるクラスは PlayerBase クラスです。一番のスタート地点になるクラスを親クラス、あるいは基幹クラス(スーパークラス)と呼びます。
このクラスは MonoBehaviour クラスを継承しています。

　PlayerBase クラスは abstract 修飾子を用いた抽象クラスとして作成をしています。
抽象クラスは、それ単体ではインスタンスが作成できないクラスです。つまり、いずれかのクラスに継承させる前提で設計を行うクラスになります。

　PlayerBase クラスでは、各クラスに共通して利用する変数やメソッドを作成します。
そのため、個々のクラスに別途備えたい機能(変数やメソッド)については、この PlayerBase クラスには定義しません。
例えば、移動の処理、アニメの処理、という風に、現在の PlayerController クラスに書かれている処理を役割ごとに分けます。

　共通する処理が記述された PlayerBase クラスを親クラスとして継承することで、個々のプレイヤーの役割用のクラスを子クラスとして作成します。

　設計と実装にあたり、全体の設計が完了したら、まずは継承元(親)となる PlayerBase クラスから順番に作成していくことになります。

　PlayerBase クラスを作成したら、それを継承させた Player ～クラスを子クラスとして作成します。
実際にはこの Player ～クラスが、障害物のゲームオブジェクトにアタッチするためのクラスになります。

設計　ー役割の考え方ー

　現在の PlayerController クラスの内容から、機能別に役割を分類してみましょう。

・移動させる機能
・アニメーションを移動方向に同期させる機能
・オブジェクトを判定する機能

　このうち、移動させる機能とアニメーションを移動方向に同期させる機能については、キー入力の値を同じ情報として利用しています。
そのため共通する処理をまとめたクラスを１つ作成し、また、このクラスで、それ以外のクラスを管理します。
つまり、管理者(マネージャー)となるクラスを新しく用意し、他の機能をまとめ上げるようにします。

・マネージャークラス

親クラスを作成する

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

using UnityEngine;

/// <summary>
/// プレイヤー用の抽象クラス
/// </summary>
public abstract class PlayerBase : MonoBehaviour
{
    /// <summary>
    /// 初期設定用の共通処理
    /// </summary>
    public abstract void SetUpPlayer();
}

＜abstract(アブストラクト) 修飾子による抽象クラスと抽象メソッドの宣言＞

　abstract 修飾子をクラスの宣言に追加することで、抽象クラスを作成することができます。

＜抽象クラス＞

　/// <summary>
　/// プレイヤー用の抽象クラス
　/// </summary>
　public abstract class PlayerBase : MonoBehaviour

　抽象クラスとはインスタンスの作成できない(new できない)クラスです。継承を行う前提で作成されているクラスのことを言います。
クラス内には抽象メソッドを１つ以上宣言しておく必要があります。通常のクラスと同じように、private 修飾子や public 修飾子を使って変数やメソッドを実装することも出来ます。

　メソッドの宣言に abstract 修飾子を追加することで抽象メソッドを作成することができます。
これは中身のない(処理の実体のない)メソッドであるため、継承した派生(子)クラス内においてオーバーライドして利用することを前提として作成されているメソッドです。

＜抽象メソッド＞

    /// <summary>
    /// 初期設定用の共通処理
    /// </summary>
    public abstract void SetUpPlayer();

　抽象メソッドは抽象クラス内でしか作成できません。
また抽象クラスを継承しているクラスでは必ず、すべての抽象メソッドをオーバーライドして実装する必要があります。

　この機能を用いることによって、実装の仕方(メソッドの強制)を統一することができます。
つまり、PlayerBase クラスを継承したクラスでは、必ず抽象メソッドである SetUpPlayer メソッドを実装する必要がありますので、
この処理を通じて各クラスにおけるプレイヤーの初期設定を制御するという、同じ処理の流れで設計ができます。

　実装した抽象メソッドでは、子クラスがそれぞれの処理を実装することになりますので、プログラムの多態性(ポリモーフィズム)を実現出来るようになっています。

＜参考サイト＞

MicroSoft
abstract
https://docs.microsoft.com/ja-jp/dotnet/csharp/lan...

++C++; // 未確認飛行 C 様
抽象メソッド、抽象クラス
https://ufcpp.net/study/csharp/oo_abstract.html

.NET Column 様
C#のabstract classとは？インターフェイスについても併せて解説！
https://www.fenet.jp/dotnet/column/language/c-shar...

XR-HU3 様
[第14回] 抽象クラス（abstract）の使い方を学ぶ｜Unityで学ぶC#入門
https://xr-hub.com/archives/19842

＜抽象クラスと抽象メソッド＞

　作成した PlayerBase クラスを継承させて、複数の Player ～で始まる子クラスを作成していきます。
今回は PlayerBase クラスを抽象クラスとして作成していますが、継承するクラスは抽象クラスである必要はありません。
現に、PlayerBase クラス自体は、抽象クラスではない MonoBehaivour クラスを継承しています。

　クラスを継承した場合、継承している親クラス(今回であれば PlayerBase クラス)の継承しているクラスも引き続きます。
そのため、PlayerBase クラスを継承した子クラスは MonoBehaivour クラスと PlayerBase クラスの２つのクラスを継承しているクラスになります。

　MonoBehaivour クラスが継承されていますので、Start メソッドや OnTrigger ～メソッドも利用できますし、
ゲームオブジェクトにアタッチして利用することも出来ます。

　PlayerBase クラスは抽象クラスであるため、abstract 修飾子で宣言されている抽象メソッドがある場合、その抽象メソッドの実装が強要されます。
実装する際には override キーワードを用います。抽象メソッドをすべて実装しないとエラーがでるようになっています。

　詳しくは別の記事を参考にしてください。

　クラスの継承

子クラスを作成する

　各クラスごとに明確な役割を設けるとともに、責務のない処理は書き込まないように配慮します。

　また PlayerManager がすべての子クラスの管理者となります。
そのため、各子クラス同士はお互いを知らない状態(メンバ変数で管理していない。疎結合化)を目的にもしています。

　キー入力に関しては、十字キーが移動の方向とアニメーションの方向の両方で利用されているため、
各子クラス内でキー入力の判定は行わず、PlayerManager 内でキー入力の感知を行い、
その情報を必要なクラス(PlayerMove と PlayerAnimation)に、メソッドの引数を通じて送り届ける形で実装しています。

１．PlayerMove.cs

　移動に関する処理のみを記述します。
そのため、Rigidbody コンポーネントはこちらのクラスでのみ管理します。

　親クラスである PlayerBase クラスに定義されている抽象メソッドである SetUpPlayer メソッドをオーバーライドして実装し、
このクラス独自の振る舞いを行っています。

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

using UnityEngine;

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

    /// <summary>
    /// 親クラスの抽象メソッドである SetUpPlayer をオーバーライドして実装
    /// このクラス用の初期設定の処理を実行する
    /// </summary>
    public override void SetUpPlayer() {
        TryGetComponent(out rb);
    }

    /// <summary>
    /// 移動
    /// 移動方向は引数を通じて PlayerManager よりもらう
    /// </summary>
    /// <param name="direction"></param>
    public void Move(Vector2 direction) {
        rb.velocity = direction * moveSpeed;
    }
    
    /// <summary>
    /// 移動停止
    /// </summary>
    public void StopPlayer()
    {
        rb.velocity = Vector3.zero;
        Debug.Log("移動停止");
    }
}

２．PlayerAnimation.cs

　このクラスでは移動方向に合わせたアニメーションの同期処理を実装しています。
先ほどの PlayerMove クラスと同様に、継承している親クラス(PlayerBase)の抽象メソッドを実装し、このクラスでは Animator クラスの取得を行っています。

　先ほどの PlayerMove クラスの SetUpPlayer メソッドでは Rigidbody クラスの取得を行っていました。
同じメソッドであっても、実装されている内容が異なっていることが分かります。

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

using UnityEngine;

///プレイヤーの向きの種類
public enum FacePlayer
{
    Front,
    Back,
    Left,
    Right
}

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


    /// <summary>
    /// 親クラスの抽象メソッドである SetUpPlayer をオーバーライドして実装
    /// このクラス用の初期設定の処理を実行する
    /// </summary>
    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;
    }

    /// <summary>
    /// 正面を向く
    /// </summary>
    public void LookBack() {
        anim.SetFloat("Look X", 0);
        anim.SetFloat("Look Y", 1);
        Debug.Log("正面をむく");
    }
}

３．PlayerAction.cs

　アクションボタンの判定に成功し、対象となるオブジェクトにイベントが設定されていた場合、
そのイベントを実行する処理を記述しています。

　また NPC に限り、アニメの向きをキャラ側に向けさせるようにしています。

　この処理内では、GameEventHandler クラスの ExecuteGameEvents メソッドを実行することにより、
命令を受けた GameEventHandler が、アサインされている GameEvent を順番に実行していく処理につなげています。

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

using System.Collections;
using UnityEngine;

public class PlayerAction : PlayerBase
{
    private FacePlayer facePlayer;

    /// <summary>
    /// プロパティ
    /// </summary>
    public FacePlayer FacePlayer {
        get => facePlayer;
        set => facePlayer = value;
    }

    /// <summary>
    /// 親クラスの抽象メソッドである SetUpPlayer をオーバーライドして実装
    /// このクラス用の初期設定の処理を実行する
    /// </summary>
    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)) {

　　　　　　// 登録されている GameEvent を１つずつ順番に実行する
            IEnumerator eventCoroutine = gameEventHandler.ExecuteGameEventsCoroutine();
            yield return StartCoroutine(eventCoroutine);
            
　　　　　　// イベント後、イベントの内容からセーブが必要かどうかを戻り値を利用して確認する
            bool isSaveOn = (bool)eventCoroutine.Current;
            CheckSave(isSaveOn);

            // 上記2行を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
        };
    }
}

４．EventChecker.cs

　アクション用のボタンを押下した際の処理です。
プレイヤーの向いている方向に Ray を投射し、指定されたレイヤーを持ち、かつ、コライダーを持つオブジェクトがあるかを判定しています。

　該当するゲームオブジェクトがある場合のみ、true と Ray の接触したゲームオブジェクトの情報を戻すメソッドを実装しています。
Ray が接触しない場合には false と null(ゲームオブジェクトなし)を戻しています。

　この時点ではまだ GameEvent があるかどうかまでは判定していません。

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

using UnityEngine;

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


    /// <summary>
    /// 親クラスの抽象メソッドである SetUpPlayer をオーバーライドして実装
    /// このクラス用の初期設定の処理を実行する
    /// </summary>
    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

　上記の４つのクラスをまとめて管理するクラスです。
このクラスには RequireComponent 属性を付与し、該当する４つのクラスを指定していますので、
このクラスをアタッチすると、４つのクラスも自動的に追加でアタッチされます。

　このクラスのみが４つのクラスをメンバ変数として管理し、それぞれの処理に対して命令を出しています。
トップダウン型のような命令系統の仕組みをイメージしてもらえれば分かりやすいでしょう。

　またイベントの開始と終了も管理していますので、イベント中は移動できないようにしたり、画面の不要なタップを阻害するようにしています。

　共通の処理としてキー入力を判定し、その情報を移動のクラスとアニメーションのクラスにメソッドを通じて渡しています。
こうすることにより、各クラス内で判定をさせる必要なく、共通の値をそれぞれのクラスに利用してもらう設計です。

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

using System.Collections;
using UnityEngine;

[RequireComponent(typeof(PlayerMove))]
[RequireComponent(typeof(PlayerAction))]
[RequireComponent(typeof(PlayerAnimation))]
[RequireComponent(typeof(EventChecker))]

// 上記を１行で書くこともできます
//[RequireComponent((typeof(PlayerMove), typeof(PlayerAction), typeof(PlayerAnimation), 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;


    void Start() {

        // 各 PlayerBase を継承している子クラスごとに SetUpPlayer メソッドを実行
        foreach (var player in playerBases) {

　　　　　　// 各クラスで PlayerBase の抽象メソッドをオーバーライドしているので、各クラスの SetUpPlayer メソッド内の処理を実行
            player.SetUpPlayer();

　　　　　　// 今回のクラスが下記のいずれかに該当するか確認し、該当する場合には変数に代入
            player.TryGetComponent(out playerMove);
            player.TryGetComponent(out playerAction);
            player.TryGetComponent(out playerAnimation);
            player.TryGetComponent(out eventChecker);
        }
    }

    void Update() {
 
        // UTAGE の会話イベント実行中の場合
        if (AdvEngineController.instance.IsPlaying)
        {
            return;
        }
        
　　　　// 画面に UI 用のオブジェクトが表示されている場合
        if(UnityEngine.EventSystems.EventSystem.current.currentSelectedGameObject != null)
        {
            return;
        }

　　　　// イベントが実行されている場合
        if (isPlayingEvent) {
            return;
        }
        
        // 移動用のキー入力(if 文など以外でもコードブロック { } を利用できるので、処理のまとまっている範囲の目印に利用できる)
        {
            // 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();
        }
    }

    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>
    /// プレイヤーから投射した Ray が、指定した Layer 設定のあるコライダーに接触したか判定
    /// 接触しており、かつ、該当するオブジェクトの場合にはアクション成功となり、イベント制御開始
    /// </summary>
    private void PrepareJedgeAction() {
        (bool isReadyAction, GameObject hitObj) item = eventChecker.JedgeAction(lookDirection);
        
        if (!item.isReadyAction) {
            return;
        }
        
        // 判定に成功した場合、イベント実行
        StartCoroutine(StartEventCoroutine(item.hitObj));
    }

    /// <summary>
    /// コルーチンによる非同期処理によるイベント処理の制御
    /// </summary>
    /// <returns></returns>
    private IEnumerator StartEventCoroutine(GameObject hitObj) {
        
        // イベント開始。移動とアクション停止。
        EnterGameEvent();

        // イベント発生
        // コルーチン内で他のコルーチンメソッドを実行する際には StartCoroutine の記述を省略可能
        yield return playerAction.PlayActionCoroutine(hitObj);

　　　　// 従来の書き方。こちらでも動きます
        //yield return StartCoroutine(playerAction.PlayActionCoroutine(hitObj));
        
        // イベント終了。再度移動とアクションを可能にする
        ExitGameEvent();
    }
}

クラス図

　ここまでに制作したクラス間の関係性を可視化することで、分割されたクラスがどのような状況か、イメージしやすくなります。

　クラス図を用意しましたので、各クラスの関連性を見てみましょう。

＜親クラスと子クラスの関係性＞

＜管理クラスと子クラスの関係性＞

　クラス図を書くことにより、自分のイメージを整理する際にも役立ちますし、第三者にクラスの状態を説明する場合にも情報を正確に伝えることが出来ます。

プレイヤー役のゲームオブジェクトに PlayerManager クラスをアタッチし、PlayerManager にアサインする

　まずプレイヤー役のゲームオブジェクトを複製します。複製後、１つは非表示にします。
カメラなどで追従対象になっている場合には、カメラの設定先も見直してアサインし直してください。

　以前の状態のゲームオブジェクトを残しておくことで、インスペクターでの設定値の確認なども出来るためです。

　複製された方の PlayerController のスクリプトを Remove し、代わりに PlayerManager クラスをアタッチしてください。
一緒に４つのクラスもアタッチされます。

　それらのクラスを PlayerBases 変数にアサインして登録してください。
これでこのクラスが４つのクラスのマネージャーとして機能するようになります。

　移動速度のみ設定がありますので、PlayerMove クラスで設定を行ってください。

インスペクター画像

　以上で設定は完了です。

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

　クラスを分割する前と同じように動作するかを検証してください。

　インスペクタータブの上でメニュー表示し、Debug を選択すると、private 修飾子の変数がインスペクターから確認出来るようになります。

メニュー表示

ゲーム実行前の Debug のインスペクター画像

　ゲームを実行した際には、これらの変数に必要な情報がアサインされているかも確認しておいてください。
Debug.Log メソッドを活用していただいても大丈夫です。

ゲーム実行後のインスペクター画像

設計の重要性とクラスの分割

　１つのクラスが肥大化してしまうことは多々あります。
学習中のうちは問題ありませんが、自分でプログラムを考えながら書いてみると、こういった設計部分での問題にぶつかります。
そのため基本的には、クラスを作成する前から肥大化する可能性が見えることがほとんどです。

　かといって最初から分割して作成していければよいのですが、それも中々難しいです。

　ソースコードを書く前に、設計を考えることから始めてみてください。
以前よりもたくさんの時間をクラスの設計に費やしてみることをお勧めします。
どのような処理を、どのクラスに書くのかを明確にしておくことで、肥大化しやすいクラスを前もって認知しておくこともできます。

　ソースコードを書いている間も、常に、設計を頭に考えて進めていくようにしてみてください。
設計は書き出しておくことで考えていることを言語化・可視化できるので、よりイメージしやすくなります。

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

印刷する

コメント（0）

肥大化したクラス内の処理を、役割に応じたクラスを複数作成して分割する実装例 - i-school 先頭へ

コメントをかく

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

i-school