【Unity】Unityで学ぶデザインパターン08: Composite パターン【デザパタ】

# はじめに
様々な言語で「デザインパターン」の本が世の中にありますが、筆者個人の経験では
`いまいちピンとこない例` `いまいちピンとこないコード` で説明されてることが多く、
`結局これっていつ使うの？` という疑問に答えるには仕事仲間等との議論をしないと
辿り着けないことが多々ありました。

そこで特に「ゲーム開発ではどう使うか？」にフォーカスを当てて、実践的な例を交えて
デザインパターンの説明の需要があると思い記事を作りました。

## デザインパターンを学ぶ理由

デザインパターンを学ぶ理由としては
1. 車輪の再発明の防止
1. 長文で読みにくいコード（可読性の低いコード）を減らす
1. コードを疎結合にして変更に強くなる(変更時のコスト・変更箇所を減らす)
1. モジュールとして使いまわせるように、コードの再利用性を高める
といった効果を期待できます。

## 対象読者
Unity 全くの初心者(インストールしただけで触ったことがないような方)はお断りです。
最低限以下のことは理解・経験を積んでおくことが必須になります。

- MonoBehaviour 継承クラスでコードを書いたことがある
- C# のピュアクラスを用いた自作クラスを作ったことがある
- クラスの継承という概念は知っている

そのため、`脱・初心者` `中級者へのステップアップ` として `デザインパターンを学ぶ` のが良いと思います。


# デザパタ記事リンク
## 生成系
1. [AbstractFactory パターン](https://qiita.com/Cova8bitdot/items/e863cecf48c0529ba05a)
1. [Builder パターン](https://qiita.com/Cova8bitdot/items/9dcdfeb0641bc774b1f8)
1. [FactoryMethod パターン](https://qiita.com/Cova8bitdot/items/61a38fd51735f321e564)
1. [Prototype パターン](https://qiita.com/Cova8bitdot/items/0bc251bc36201985c204)
1. [Singleton パターン](https://qiita.com/Cova8bitdot/items/29b7064c7472a6f34972)

## 構造系
1. [Adapter パターン](https://qiita.com/Cova8bitdot/items/f09776957073cf64902b)
1. [Bridge パターン](https://qiita.com/Cova8bitdot/private/5b528216952c74436045)
1. [Composite パターン](https://qiita.com/Cova8bitdot/items/1c57d856027a33e99eb0)（本記事）
1. [Decorator パターン](https://qiita.com/Cova8bitdot/items/e1373a756b3dfd86c920)
1. [Facade パターン](https://qiita.com/Cova8bitdot/items/bdf0976bdfa83e57f121)
1. [Flyweight パターン](https://qiita.com/Cova8bitdot/items/7f1f1f04b46ebaf43c5e)
1. [Proxy パターン](https://qiita.com/Cova8bitdot/items/8a27137812e103ec1ee3)

## 様態・ふるまい系
1. [Chain of Responsibility パターン](https://qiita.com/Cova8bitdot/items/66c62dd96adffda7e72e)
1. [Command パターン](https://qiita.com/Cova8bitdot/items/9a88f7fc0782c729f97c)
1. [Interpreter パターン](https://qiita.com/Cova8bitdot/items/a871c1de813d14049934)
1. [Iterator パターン](https://qiita.com/Cova8bitdot/items/302f19863cc3b2235625)
1. [Mediator パターン](https://qiita.com/Cova8bitdot/items/be33b97f35c84e814df7)
1. [Memento パターン](https://qiita.com/Cova8bitdot/items/ae7e6f5d2da7b07d379b)
1. [Observer パターン](https://qiita.com/Cova8bitdot/items/632782ad5264baf6a366)
1. [State パターン](https://qiita.com/Cova8bitdot/items/ab9fc16ac3a6657fdce0)
1. [Strategy パターン](https://qiita.com/Cova8bitdot/items/28dd773075cf6e9fefee)
1. [TemplateMethod パターン](https://qiita.com/Cova8bitdot/items/f0bed164ef6563b489d0)
1. [Visitor パターン](https://qiita.com/Cova8bitdot/items/15c56d40435adf63891d)


# Composite　パターンについて
Composite パターンとはその名の通り `複合` という意味です。
端的に言うと、Compositeパターンなクラスとは `共通のインターフェース` を実装し、クラス内部で `共通のインターフェースのList` を抱えているようなクラスです。

```mermaid
classDiagram
    IHoge <|-- CompositeHoge
    ICollection <|-- CompositeHoge

    CompositeHoge "1" o-- "N" IHoge

    class IHoge{
        <<interface>>
        + SomeMethod()
    }
    class ICollection{
        <<interface>>
        + int Count
        + Add()
        + Clear()
        + Contains(item)
        + bool Remove(item)
        + CopyTo(array, arrayIndex)
    }

    class CompositeHoge{
        -  List<IHoge> m_internalHogeList
        + SomeMethod()
    }

```

このCompositeクラスのメリットは 外側からは `1つのObjectに見える/1つのObjectとして操作する` ところです。
内部には複数のObjectを保持しているので、CompositeパターンのObjectでAPIがコールされると内部のリストに対して同じAPIをfor文で実行します。
つまり、 `まとめて処理を実行したい`, `複数のObjectをとりまとめた結果を得たい` ような場合には打ってつけのデザインパターンです。

# ゲームでの利用例
## UniRx
Unity でいえば有名なリアクティブプログラミングのライブラリである [UniRx](https://github.com/neuecc/UniRx) では `CompositeDisposable` というクラスで実装・利用されます。

これはIDisposable をとりまとめたクラスです。
最後にIDisposable実装ObjectそれぞれにDispose()をコールする時、コール忘れが起きるとメモリリーク等の原因になるため、このクラスを利用して登録しておくことで、Dispose処理は CompositeDisposable のクラス1個に対して発行するだけで、内部に登録してあるObject全てをDisposeしてくれるため、破棄処理が複雑にならずに済みます。

## スキルの実装
RPGやヒーローシューター等一部のゲームではキャラクターに「スキル」を持たせることがあります。
このスキルですが、下位レベルのものだと単一の効果ですが、上位レベルのスキルだと効果が複数あるものはよくある話です。

この `効果が複数あるスキル` を作るためにCompositeパターンはほぼ必須といっても過言ではありません。

具体例として回復スキルを考えてみましょう。

回復スキルとして `HPを回復するスキル` と `状態異常を治すスキル` に分かれると思います。
ここでHPを全回復スキルと状態異常を完全治癒するスキルがあった時に、新たに `HPも状態異常も完全回復するスキル` を作りたいとプランナーに言われたとします。

このときにスキルを新規で0から実装する場合、 `HPを全回復スキル` と `状態異常を完全治癒するスキル` と同じ処理を書かなければいけません。これでは車輪の再発明で、重複コードも増え、アプリ容量の増加にもつながります（スマホアプリでは容量限界がシビアです）。この時にCompositeパターンで作るとコードの重複を防げます。

実際のコード例を見ていきましょう。


``` HealSkill.cs
public interface ISKill
{
	void Invoke(Character[] targets);
}

public class CompositeSkill : ISkill, ICollection<ISkill>
{

    protected readonly object _gate = new object();
    protected List<ISkill> list = new List<ISkill>();

    #region ===== ISkill =====
    
	void ISkill.Invoke(Character[] targets)
	{
		if(targets == null) return;
        foreach(var skill in list)
        {
            skill.Invoke(targets);
        }
	}

    #endregion //) ===== ISkill =====

    #region ===== ICollection =====

    public int Count => list.Count;

    public bool IsReadOnly => false;

    public void Add(IAudioLoader item){list.Add(item);}

    public void Clear(){list.Clear();}

    public bool Contains(IAudioLoader item)
    {
        return list.Contains(item);
    }

    public void CopyTo(IAudioLoader[] array, int arrayIndex)
    {
        int startIndex = Mathf.Min(arrayIndex, array.Length - 1);
        for (int i =startIndex; i < array.Length; i++)
        {
            Add(array[i]);
        }
    }

    public bool Remove(IAudioLoader item)
    {
        return list.Remove(item);
    }

    IEnumerator IEnumerable.GetEnumerator()
    {
        return GetEnumerator();
    }

    public IEnumerator<IAudioLoader> GetEnumerator()
    {
        var res = new List<IAudioLoader>();

        lock (_gate)
        {
            foreach (var d in list)
            {
                if (d != null) res.Add(d);
            }
        }

        return res.GetEnumerator();
    }

    #endregion //) ===== ICollection =====

}


/// <summary>
/// HP完全回復スキル
/// </summary>
public class FullHealSkill : ISkill
{
	void ISkill.Invoke(Character[] targets)
	{
		if(targets == null) return;
		foreach(var target in targets)
		{
			target.Heal(100.0f);
		}
	}
}

/// <summary>
/// 状態異常回復スキル
/// </summary>
public class FullCure : ISkill
{
	void ISkill.Invoke(Character[] targets)
	{
		if(targets == null) return;
		foreach(var target in targets)
		{
			target.ClearDebuffAll();
		}
	}
}


/// <summary>
/// 完全回復スキル
/// </summary>
public class PerfectHeal : CompositeSkill
{
	public PerfectHeal()
	{
		// 完全回復 = HP全回復 + 全状態異常回復
		list.Add(new FullHealSkill());
		list.Add(new FullCure());
	}
}
```


このようにCompositeパターンを用意すると、組み合わせで表現できるスキルの実装が非常にシンプルになります。
特に、複合スキルについては、複合元のスキルが独立して動くように実装されていれば、実装工数がほとんど0に近い状態まで減らすことができます。

クラス図でいうと以下のようになります。

```mermaid
classDiagram
    ISkill <|-- CompositeSKill
    ICollection <|-- CompositeSKill


    class ISkill{
        <<interface>>
        + Invoke(Character[] targets)
    }
    class ICollection{
        <<interface>>
        + int Count
        + Add()
        + Clear()
        + Contains(item)
        + bool Remove(item)
        + CopyTo(array, arrayIndex)
    }

    class CompositeSKill{
        -  List<IHoge> m_internalHogeList
    }

    class FullHealSkill {
    }
    ISkill <|-- FullHealSkill

    class FullCure {
    }
    ISkill <|-- FullCure
    
    class PerfectHeal{
    }
    CompositeSKill <|-- PerfectHeal
    PerfectHeal o-- FullHealSkill
    PerfectHeal o-- FullCure
```

# まとめ

Compositeパターンはゲーム系でもとても有益なデザインパターンです。
特に複雑なものを作成・管理する時に威力を発揮します。

実際の開発現場では理解がほぼ必須といっても過言でないくらい重要なので、もし知らなかった場合は覚えておくと良いと思います。