グローバルゲームジャムで使ったUnityのテクニックとか開発のコツ 2019

# はじめに

今回はグローバルゲームジャム2019で用いた、開発のコツやUnityのテクニックについてまとめます。

設計についての話はこちらを参照。

* [グローバルゲームジャムでクラス設計をやった話2019](https://qiita.com/toRisouP/items/a868113c99179c585001)

# どんなに手間でもSceneは別けよう

たとえ手間でも、「タイトルシーン」と「ゲーム本編のシーン」は分離して作った方が楽です。
理由としては次のとおり。

* UIがメインとなるタイトルを別シーンに切り出すことで、分業しやすくなる
* **ゲームの初期化が簡単にできる** （最悪、ゲーム本編のシーンのみを再ロードすればScene初期化が完了する）

ゲームジャムのゲームをみていると、「初期化が作れなかったので、1回ゲームを遊ぶたびに再起動しないとだめです」といった作品をたまにみます。
Sceneを分割しておくと、同じSceneをリロードするだけで初期化ができるのでオススメです。

# 簡単なScene遷移機構

Sceneを別けた方がいいと言いましたが、やはりそこを実装するのは結構な手間がかかります。
そこで、シンプルなトランジションエフェクト付きのScene遷移機構の作り方を紹介しておきます。

![transition.gif](https://qiita-image-store.s3.amazonaws.com/0/47146/48517f84-a285-856f-ca16-95f09a601a73.gif)


## 1.TransitionCotrollerコンポーネントを定義する

Scene遷移の実行および、トランジションエフェクトを管理するコンポーネントを定義します。
（UniRxを使っています）

```cs:TransitionCotroller
using System;
using System.Collections;
using UniRx;
using UnityEngine;
using UnityEngine.SceneManagement;
using UnityEngine.UI;

namespace TransitionSample
{
    public class TransitionCotroller : MonoBehaviour
    {
        [SerializeField] private Image coverImage;
        [SerializeField] private float transitonSeconds;

        private readonly BoolReactiveProperty isTransferring = new BoolReactiveProperty(false);

        public IObservable<Unit> OnTransitionFinished
        {
            get
            {
                // シーン遷移をしていないなら、即イベント発行
                if (!isTransferring.Value) return Observable.Return(Unit.Default);

                // シーン遷移中なら終わったときにイベント発行
                return isTransferring.FirstOrDefault(x => !x).AsUnitObservable();
            }
        }

        /// <summary>
        /// シーン遷移を開始する
        /// </summary>
        public void TransitionStart(string nextSceneName)
        {
            if (isTransferring.Value) return; //すでにシーン遷移中なら何もしない
            isTransferring.Value = true;
            StartCoroutine(TransitionCoroutine(nextSceneName));
        }

        private IEnumerator TransitionCoroutine(string nextSceneName)
        {
            var time = transitonSeconds;

            // 画面のクリックイベントをTransitionCanvasでブロックする
            coverImage.raycastTarget = true;

            // 画面を徐々に白くする
            while (time > 0)
            {
                time -= Time.deltaTime;
                coverImage.color = OverrideColorAlpha(coverImage.color, 1.0f - time / transitonSeconds);
                yield return null;
            }

            // 完全に白くする
            coverImage.color = OverrideColorAlpha(coverImage.color, 1.0f);

            // 画面が隠し終わったらシーン遷移する
            yield return SceneManager.LoadSceneAsync(nextSceneName);

            // 画面を徐々に戻す
            time = transitonSeconds;
            while (time > 0)
            {
                time -= Time.deltaTime;
                coverImage.color = OverrideColorAlpha(coverImage.color, time / transitonSeconds);
                yield return null;
            }

            // クリックイベントのブロック解除
            coverImage.raycastTarget = false;
            coverImage.color = OverrideColorAlpha(coverImage.color, 0.0f);

            // シーン遷移完了
            isTransferring.Value = false;
        }

        private Color OverrideColorAlpha(Color c, float a)
        {
            return new Color(c.r, c.g, c.b, a);
        }
    }
}
```

## 2. TransitionCotrollerをつけたPrefabを用意する

つづいて、さきほどの`TransitionCotroller`を貼り付けたPrefabを用意します。  
Prefabはかならず**Resourcesディレクトリ以下**に配置してください。

![tc.png](https://qiita-image-store.s3.amazonaws.com/0/47146/1df74c59-f696-8659-08f0-dd6072522ed9.png)


1. uGUIのCanvasを用意する
2. GameObjectの名前を「TransitionCotroller」にする
3. Canvasの`Sort Order`を **大きめの数値にしておく**
4. Canvasの子に、`Image`を追加する
5. `Image`を画面全体を覆うように配置し、好きな色で塗りつぶしておく（Source Imageは空でよい）
6. Canvas側のGameObjectに`TransitionCotroller`コンポーネントを貼り付ける
7. コンポーネントにさきほどの`Image`を紐づけ、`Transition Seconds`を設定する
8. このGameObjectを **Resourcesディレクトリ以下へ保存してPrefab化する**

## 3. TransitionCotrollerをよびだすstaticクラスを定義する

`TransitionCotroller`を直接さわると扱いにくいので、仲介する`TransitionManager`を定義します。

```cs:TransitionCotroller
using System;
using UniRx;
using UnityEngine;

namespace TransitionSample
{
    public static class TransitionManager
    {
        /// <summary>
        /// TransitionCotrollerが存在しないなら生成する
        /// </summary>
        private static Lazy<TransitionCotroller> controller = new Lazy<TransitionCotroller>(() =>
        {
            var r = Resources.Load("TransitionCotroller");
            var o = UnityEngine.Object.Instantiate(r) as GameObject;
            UnityEngine.Object.DontDestroyOnLoad(o);
            return o.GetComponent<TransitionCotroller>();
        });

        private static TransitionCotroller Controller => controller.Value;

        /// <summary>
        /// 次のシーンへ遷移する
        /// </summary>
        public static void StartTransition(string nextSceneName)
        {
            Controller.TransitionStart(nextSceneName);
        }

        /// <summary>
        /// シーン遷移完了を通知する
        /// </summary>
        public static IObservable<Unit> OnTransitionFinishedAsync()
        {
            return Controller.OnTransitionFinished;
        }
    }
}
```

## 4. 実際に使う

```cs
using UniRx;
using UnityEngine;
using UnityEngine.UI;

namespace TransitionSample
{
    // ボタンが押されたらシーン遷移する
    public class GotoButton : MonoBehaviour
    {
        [SerializeField] private string _nextScene;

        [SerializeField] private Button _button;

        private async void Start()
        {
            // シーン遷移が終わるまで待つ場合はOnTransitionFinishedAsyncをawaitすればよい
            await TransitionManager.OnTransitionFinishedAsync();

            _button.OnClickAsObservable()
                .Subscribe(_ => { TransitionManager.StartTransition(_nextScene); });
        }
    }
}
```

## 面倒くさい人向け

GitHubにサンプルプロジェクトを上げたので、自由に使ってください。

* [SceneTransitionSample](https://github.com/TORISOUP/SceneTransitionSample)


# staticフィールド/DontDestroyOnLoadは理由がない限り使わない

staticフィールドやDontDestroyOnLoadを使うと、Sceneをまたいで状態を保持させることができるようになります。
たしかに便利ではあるのですが、なんでもかんでもこれにしてしまうと**初期化処理が辛いことになる**ので多用は止めましょう。

たとえば「Sceneをまたいでデータをやりとりする」といったときに`DontDestroyOnLoad`を使うことはまったく問題ありません。

# Debugしやすくしておこう

動作確認が簡単にできるような仕組みを整えておくと作業効率をあげることができます。

たとえば、`#if UNITY_EDITOR`と`#endif`で包んだブロックはUnityEditor上でのみ機能させることができるようになります。
この機能を利用して、エディタ実行中のみショートカットコマンドが使える、みたいな状態にしておくと確認作業が楽になるためオススメです。

* 例：[エディタ実行中のみ、コマンド入力で自機にTrapを踏んだときのイベントを与える](https://github.com/TORISOUP/PsychoMothers/blob/master/Assets/PsycthoMothers/Scripts/Battle/Players/PlayerActionEffectAffecter.cs#L20-L36)


# 破壊してもいいSceneで作業しよう

ゲームジャムでは複数人が短時間に一気に作業を行います。
そのため、メインとなるSceneで全員が作業をすると速攻で作業内容がコンフリクトしてしまいます。

これを避けるために、各自が自分専用の作業Sceneを用意するなど、最悪Sceneが壊れて戻せなくなっても構わないように作業するといいでしょう。

# AnimationCurveは便利

Unityの標準機能に[AnimationCurve](https://docs.unity3d.com/ja/current/ScriptReference/AnimationCurve.html)というものがあります。
これを用いるとちょっと複雑な計算を簡略化できる場合があるためオススメです。

## AnimationCurve使用例1：アニメーションの速度を変化させる

たとえば、次のようなオブジェクトを加速させながら回転させるスクリプトがあったとします。

```cs:Rotate
using UnityEngine;

public class Rotate : MonoBehaviour
{
    private float _startTime;

    /// <summary>
    /// 加速する時間
    /// </summary>
    [SerializeField] private float _accelerationDuration;

    /// <summary>
    /// 最大到達速度
    /// </summary>
    [SerializeField] private float _maxSpeed;

    void Start()
    {
        _startTime = Time.time;
    }

    void Update()
    {
        // 加速時間で指定した秒数をかけて最大到達速度まで「線形」に加速していく
        var rate = (Time.time - _startTime) / _accelerationDuration;
        var currentSpeed = Mathf.Lerp(0, _maxSpeed, rate);
        transform.rotation = Quaternion.AngleAxis(currentSpeed * Time.deltaTime, Vector3.forward) * transform.rotation;
    }
}
```

このスクリプトを用いると、「オブジェクトを **等速** に加速させながら回転させる」ことができます。

![rotate1.gif](https://qiita-image-store.s3.amazonaws.com/0/47146/c28e5c0d-406e-4643-fb12-35ec5b368110.gif)


(加速時間3秒、最大速度180度/秒)


ここで`「等速に加速するのはダサいからもっとギュイーン！って加速してほしい！」`となったときに、それをスクリプトで実装するのはなかなか手間です。

そこで`AnimationCurve`を用いてみましょう。

```cs:RotateWithAnimationCurve
using UnityEngine;

public class Rotate : MonoBehaviour
{
    private float _startTime;

    /// <summary>
    /// 加速する時間
    /// </summary>
    [SerializeField] private float _accelerationDuration;

    /// <summary>
    /// 最大到達速度
    /// </summary>
    [SerializeField] private float _maxSpeed;

    /// <summary>
    /// 加速具合
    /// </summary>
    [SerializeField] private AnimationCurve _animationCurve;

    void Start()
    {
        _startTime = Time.time;
    }

    void Update()
    {
        // 加速時間で指定した秒数をかけて最大到達速度まで「線形」に加速していく
        var rate = (Time.time - _startTime) / _accelerationDuration;
        var currentSpeed = _animationCurve.Evaluate(rate) * _maxSpeed; //AnimationCurveを使って速度を算出
        transform.rotation = Quaternion.AngleAxis(currentSpeed * Time.deltaTime, Vector3.forward) * transform.rotation;
    }
}
```

![ac.png](https://qiita-image-store.s3.amazonaws.com/0/47146/3a40e0a3-c028-4395-a421-643a6094ecc5.png)


`AnimationCurve`を`[SerializeField]`で定義すると、インスペクター上でカーブを設定できるようになります。
ここで「回転の加速具合」を設定し、スクリプト上でそのときのパラメータを読み取ることで任意の加速具合を表現することができるようなります。

```cs
// Evaluateの引数にx軸のパラメータを指定すると、そのときのyの値が取得できる
var currentSpeed = _animationCurve.Evaluate(rate) * _maxSpeed;
```

たとえば、このような最初はほとんど加速せず、最後に一気に加速するカーブを描くとこのような挙動にできます。

![curve1.png](https://qiita-image-store.s3.amazonaws.com/0/47146/05625d3d-fa9d-c10f-794e-aabb19a3940a.png)


![rotate2.gif](https://qiita-image-store.s3.amazonaws.com/0/47146/10b18652-0911-4d97-fbf5-62c493f85f35.gif)


(加速時間3秒、最大速度180度/秒、さっきと同じ)

## AnimationCurve使用例2：距離減衰の実装に

たとえば「爆弾の爆風」のような、中心部のもっとも威力が大きく、端にいくほど威力がさがるような攻撃を実装するとします。
こういった実装も`AnimationCurve`を使うと簡単に実装できます。

```cs
using UnityEngine;

class Explosion : MonoBehaviour
{
    [SerializeField] private float _maxPower;

    [SerializeField] private AnimationCurve _powerCurve;

    private float _radius; //自分の最大半径

    private void Start()
    {
        _radius = GetComponent<SphereCollider>().radius;
    }

    /// <summary>
    /// 爆風の範囲内に入ったときの挙動
    /// </summary>
    private void OnTriggerEnter(Collider other)
    {
        var targetRigidbody = other.gameObject.GetComponent<Rigidbody>();

        var vector = (other.gameObject.transform.position - transform.position);
        var distance = vector.magnitude; //中心からの距離
        var direction = vector.normalized; //ふっとぶ方向

        Debug.Log(direction);
        Debug.Log(distance / _radius);

        // 中心からの距離を用いてふっとばし力を算出
        var power = _powerCurve.Evaluate(distance / _radius) * _maxPower;

        // ふっとばす
        targetRigidbody.AddForce(power * direction, ForceMode.VelocityChange);
    }
}
```

![exp_curve.png](https://qiita-image-store.s3.amazonaws.com/0/47146/a4272779-be67-67e9-1358-a75996b3a488.png)


たとえばこのような「一定距離までは減衰しないが、ある点を境に急激に減衰する」といった`AnimationCurve`を設定すれば、次のような挙動が簡単に作ることができます。

![explosion1.gif](https://qiita-image-store.s3.amazonaws.com/0/47146/0e22a2fc-e778-20a8-1943-3d224e856d93.gif)


---

# 時間を管理するManagerを用意すると便利

ゲームにおいて「時間」を管理したいことがあります。
その場合は1つ専用のクラスを定義し、そこに押し付けてしまうと管理が楽になるのでオススメです。

* [TimeManagerの実装例](https://github.com/TORISOUP/PsychoMothers/blob/master/Assets/PsycthoMothers/Scripts/Battle/Manager/TimeManager.cs)

1個のクラスにまとめておくとあとから時間間隔の調整がインスペクター上で簡単に変更できるようになります。

![timemanager.png](https://qiita-image-store.s3.amazonaws.com/0/47146/f646776f-c087-a0cd-aa87-f7b9e9de4f2d.png)




# GameStateをReactivePropertyで管理すると楽

`GameState`とは、たとえば「初期化フェーズ」「バトル中フェーズ」「結果発表フェーズ」といった、ゲームの進行状況を表すものです。
これを`enum`で定義し、`ReactiveProperty`で管理すると全体の制御が非常に楽なのでオススメです。

```cs:こういうStateがあったとして
public enum GameState
{
    Initializing,
    Ready,
    Battle,
    Finished,
    Result
}
```

* [GameStateManager](https://github.com/TORISOUP/PsychoMothers/blob/master/Assets/PsycthoMothers/Scripts/Battle/Manager/GameStateManager.cs)

みたいなのを用意しておくと、たとえば「Battleフェーズのみプレイヤを操作したい」という場合はこんな感じで実装が終わります。

* [Battle中のみ操作可能にする例](https://github.com/TORISOUP/PsychoMothers/blob/master/Assets/PsycthoMothers/Scripts/Battle/Players/PlayerMover.cs#L50)


# ZenjectSceneLoaderが便利

`ZenjectSceneLoader`は[Zenject](https://github.com/svermeulen/Zenject)の機能の1つです。  
かんたんに説明すると、**シーンをまたいで前のシーンのデータを持っていける機能**です。
さきほど説明したシーン遷移機構と合わせて利用すると結構便利です。

## 使い方

`ZenjectSceneLoader`をInjectして、それを使ってシーン遷移すればOKです。
`Action<DiContainer>`のデリゲートに、次のシーンに`Bind`したい処理を記述することができます。

詳しい使い方は[もんりぃ先生のブログ](https://monry.hatenablog.com/entry/2019/01/17/011116)を参照してください。

```cs:使用例
public class TitleMenuManager : MonoBehaviour
{
    [Inject] private ZenjectSceneLoader _zenjectSceneLoader;

    public void MoveToBattleScene(int players)
    {
        var battleMenuInfo = new BattleMenuInfo(playerCount: players);

        _zenjectSceneLoader.LoadScene("Battle", LoadSceneMode.Single, container =>
        {
            // 次のシーンにBattleMenuInfoを持ち越す
            container.Bind<BattleMenuInfo>()
                .FromInstance(battleMenuInfo).AsCached();
        });
    }
}

/// ゲームを開始するために必要な情報
/// </summary>
public struct BattleMenuInfo
{
    /// <summary>
    /// プレイヤの数
    /// </summary>
    public int PlayerCount { get; }

    public BattleMenuInfo(int playerCount)
    {
        PlayerCount = playerCount;
    }
}
```

---

ちなみに移動先のシーンにこういう`Installer`を配置しておくとデバッグもしやすいのでオススメ。

```cs
public class HogeInstaller : MonoInstaller
{
    public override void InstallBindings()
    {
        // BattleMenuInfoがBindされていないなら、
        // シーン初期化のタイミングでデバッグ用のパラメータを埋めておく
        if (!Container.HasBinding<BattleMenuInfo>())
        {
            Container.Bind<BattleMenuInfo>()
                .FromInstance(new BattleMenuInfo(2))
                .AsCached();
        }
    }
}
```

---

ちなみに、さっき紹介した「シーン遷移機構」と併用することもできます。


* [TrasitionComponent](https://github.com/TORISOUP/PsychoMothers/blob/master/Assets/PsycthoMothers/Scripts/Common/TrasitionComponent.cs#L50-L52)
* [SceneLoader](https://github.com/TORISOUP/PsychoMothers/blob/master/Assets/PsycthoMothers/Scripts/Common/SceneManager.cs)
* [TitleMenuManager](https://github.com/TORISOUP/PsychoMothers/blob/master/Assets/PsycthoMothers/Scripts/TitleMenu/TitleMenuManager.cs#L14-L18)

(さっきとクラス名違うけど内容はおなじ)


# ZenAutoInjectorが便利

[Zenject](https://github.com/svermeulen/Zenject)を使っていると、PrefabのInstantiateがやりにくいという欠点があります。

というのも、DIContainerにDIしてもらうためには、**DIContainerにInstantiateを検知してもらう**必要があるからです。
そのため、正攻法でなんとかしようとすると`Factory`を用意して、`Installer`を書く必要があるなどかなり面倒くさいです。

そこで、これらの手間をすべて無視できる`ZenAutoInjector`というコンポーネントを紹介しておきます。

`ZenAutoInjector`はPrefabに貼り付けておくと、**Awakeのタイミングで自分からDIContainerに対してInjectを要求してくれる**というコンポーネントです。  
このコンポーネントをPrefabに貼り付けておけば、`Factory`定義や`Installer`定義が不要になるため、覚えておくとよいでしょう。

**ただし気軽に使うのはゲームジャムだけ**にしておきましょう。業務などでZenjectを用いる場合は、`ZenAutoInjector`の乱用は管理できなくリスクがあるのでオススメしません。

# まとめ

ゲームジャムは「引き出しの数」が重要です。少しでもこの記事が手助けになれば。