【Unity】3Dシューティングゲームをリリース！工夫点や反省点をざっと振り返る

                var ownerTransform = Owner.transform;
                
                // 中心(0, 0, 0)に近づいたら喜びステートへ遷移
                if (Vector3.Distance(ownerTransform.position, Vector3.zero) <= ChangeHappyDistance)
                {
                    StateMachine.ChangeState((int) StateType.Happy);
                    return;
                }
                
                // 出現時の距離分進む
                var speed = Owner._speed;
                if (_totalMove < AppearDistance)
                {
                    _totalMove += (speed * ownerTransform.forward * Time.deltaTime).magnitude;
                }
            
                // 揺れの量を求める
                var shakeWidth = Owner._shakeWidth;
                var shakeVec = shakeWidth.x * ownerTransform.right + shakeWidth.y * Vector3.up;
                shakeVec = Mathf.Sin(Time.frameCount / 10.0f) * shakeVec;
            
                // 位置の更新
                var initPosition = Owner._initPosition;
                ownerTransform.position = initPosition + (_totalMove * ownerTransform.forward) + shakeVec;

using UnityEngine;
using Utils;

namespace Scenes.Common.Model
{
    /// <summary>
    /// 移動スティックModel
    /// </summary>
    public class StickMoveModel
    {
        private const float StickMoveRadiusMax = 80.0f; // 最大移動半径
        private const float StickMoveRadiusMin = 40.0f; // 最小移動半径
        
        private Touch _stickTouch;                // タッチ情報
        private Vector3 _stickBeganTouchPosition; // タッチ開始時の位置

        public bool IsPushStick { get; private set; } // 押下されているか？
        public Vector3 StickDragDiffPosition { get; private set; } // スティック移動量

        public StickMoveModel()
        {
            // タッチ情報を初期化
            IsPushStick = false;
            _stickTouch = TouchUtil.NotTouch;
            StickDragDiffPosition = Vector3.zero;
            _stickBeganTouchPosition = Vector3.zero;
        }

        /// <summary>
        /// スティック情報更新処理
        /// </summary>
        /// <param name="canvasRectTransform">キャンバスRectTransform</param>
        public void OnUpdateStick(RectTransform canvasRectTransform = null)
        {
            if (!IsPushStick) return;
            
            // タップ座標、ドラッグ座標を設定
            var screenTapPosition = _stickBeganTouchPosition;
            var screenDragPosition = TouchUtil.GetCurrentTouchPosition(_stickTouch);

            // ドラッグ差分を算出
            var canvasDiffPosition = TouchUtil.CalculateDragDiffPosition(
                screenTapPosition, screenDragPosition, 
                canvasRectTransform); // 解像度考慮のためキャンバス座標で取得
            var canvasDiffMagnitude = canvasDiffPosition.magnitude;

            // 最大半径より大きいなら丸める
            if (StickMoveRadiusMax < canvasDiffMagnitude)
            {
                canvasDiffPosition.Normalize();
                canvasDiffPosition *= StickMoveRadiusMax;
            }

            // 最小半径より大きいなら移動量を設定
            StickDragDiffPosition = Vector3.zero;
            if (StickMoveRadiusMin < canvasDiffMagnitude)
            {
                StickDragDiffPosition = canvasDiffPosition;
            }
        }

        /// <summary>
        /// スティックを押下した時
        /// </summary>
        public void PushDownStick()
        {
            // タッチ情報を設定
            IsPushStick = true;
            _stickTouch = TouchUtil.GetBeganTouch();
            _stickBeganTouchPosition = _stickTouch.position;
        }

        /// <summary>
        /// スティックを離した時
        /// </summary>
        public void PushUpStick()
        {
            // タッチ情報を初期化
            IsPushStick = false;
            _stickTouch = TouchUtil.NotTouch;
            StickDragDiffPosition = Vector3.zero;
            _stickBeganTouchPosition = Vector3.zero;
        }
    }
}

            if (_moveStickMoveModel.StickDragDiffPosition.x > MoveStickMoveMin)
            {
                var dragDiffPosition = Mathf.Abs(_moveStickMoveModel.StickDragDiffPosition.x);
                _player.SetMoveRightVelocity((dragDiffPosition - MoveStickMoveMin) / MoveStickMoveMax);
            }
            if (_moveStickMoveModel.StickDragDiffPosition.x < -MoveStickMoveMin)
            {
                var dragDiffPosition = Mathf.Abs(_moveStickMoveModel.StickDragDiffPosition.x);
                _player.SetMoveLeftVelocity((dragDiffPosition - MoveStickMoveMin) / MoveStickMoveMax);
            }

            // スローモーション処理
            private bool _isSlowMotion;
            private const float SlowMotionTimeScale = 0.2f;
            private const float SlowMotionAudioPitch = 0.45f;
            private const float SlowMotionTime = 0.6f;
            private IEnumerator ChangeSlowMotion()
            {
                // スローモーションフラグをON
                _isSlowMotion = true;
                
                // カメラをクリア状態に切り替える
                Owner.cameraCtrl.StartClearState(Owner._lastDestroyEnemyPosition);
                
                // BGM停止
                ServiceLocator.Resolve<IAudioService>().StopBGM();
                
                // 指定時間分スローモーションにする
                Time.timeScale = SlowMotionTimeScale;
                ServiceLocator.Resolve<IAudioService>().ChangeSePitch(SlowMotionAudioPitch);
                yield return new WaitForSeconds(SlowMotionTime);
                // 元に戻す
                Time.timeScale = 1.0f;
                ServiceLocator.Resolve<IAudioService>().ChangeSePitch(1.0f);

                // カメラを元に戻す
                Owner.cameraCtrl.EndClearState();
                
                // スローモーションフラグをOFF
                _isSlowMotion = false;
                
                // クリア状態に遷移する
                StateMachine.ChangeState((int) StateType.GameClear);
            }

        // ----- clear animation ------
        private class StateClear : StateMachine<CameraCtrl>.StateBase
        {
            // 位置情報
            private static readonly Vector3 OffsetPos = new Vector3(5.0f, 5.0f, 10.0f);
            private Vector3 _smoothTargetPos;
            private const float SmoothSpeed = 5.0f;
            private const float InitPosDistance = 5.0f;
            
            // 揺れ情報
            private const float ShakeStrength = 1.0f;
            private const float ShakeDuration = 0.5f;
            
            private float _totalTime = 0.0f;

            public override void OnStart()
            {
                _totalTime = 0.0f;
                // ターゲット位置を設定
                var forwardVec = Owner._clearTargetEnemyPos.normalized;
                var rightVec = Quaternion.Euler(0.0f, -90.0f, 0.0f) * forwardVec;
                var targetPos = Owner._clearTargetEnemyPos;
                targetPos += forwardVec * OffsetPos.z;
                targetPos += rightVec * OffsetPos.x;
                targetPos += Vector3.up * OffsetPos.y;
                _smoothTargetPos = targetPos;
                // 初期位置を設定
                Owner.transform.position = targetPos.normalized * InitPosDistance;
                Owner.transform.LookAt(Vector3.zero);
            }

            public override void OnUpdate()
            {
                // 終了通知を受け取ったら通常に戻る
                if (!Owner.IsClearState)
                {
                    StateMachine.ChangeState((int) StateType.Normal);
                }
                
                // ターゲット位置に着いたら何もしない
                if (Vector3.Distance(Owner.transform.position, _smoothTargetPos) < 0.5f)
                {
                    return;
                }
                
                // 臨場感出すため少し揺らす
                var ratio = Mathf.Clamp(1.0f - _totalTime / ShakeDuration, 0.0f, 1.0f);
                var randomOffsetX = Random.Range(-ShakeStrength, ShakeStrength);
                var randomOffsetY = Random.Range(-ShakeStrength, ShakeStrength);
                Owner.transform.position += randomOffsetX * ratio * Owner.transform.right;
                Owner.transform.position += randomOffsetY * ratio * Owner.transform.up;
                
                // ターゲット位置に向かって移動
                Owner.transform.position = Vector3.MoveTowards(Owner.transform.position, _smoothTargetPos, SmoothSpeed);
                Owner.transform.LookAt(Vector3.zero);
            }

            public override void OnEnd() { }
        }

using JsonSchema.Response;
using Services;

namespace Scenes.Game
{
    /// <summary>
    /// GameScene管理クラス
    /// GameState ノーマルモード用
    /// </summary>
    public partial class GameSceneCtrl
    {
        private class StateGameNormalMode : StateGameTemplate
        {
            /// <summary>
            /// ゲーム開始時の敵生成情報取得
            /// </summary>
            protected override EnemyGenerateInfo GetInitEnemyGenerateInfo()
            {
                return ServiceLocator.Resolve<IDataAccessService>().GetEnemyGenerateInfo(Owner._gameMode, Owner._gameLevel);
            }
            
            /// <summary>
            /// プレイヤーが破壊された時の処理
            /// </summary>
            protected override void PlayerDestroyAction()
            {
                // ゲームオーバー
                Owner.cameraCtrl.ShakeCamera(); // カメラを揺らす
                Owner._player.StartStateStop(); // プレイヤーを停止状態にする
                StateMachine.ChangeState((int) StateType.GameOver);
            }

            /// <summary>
            /// 敵が全て破壊された時の処理
            /// </summary>
            protected override void AllEnemyDestroyAction()
            {
                // ゲームクリア
                Owner._player.StartStateStop(); // プレイヤーを停止状態にする
                StateMachine.ChangeState((int) StateType.SlowMotion); // クリア前にスローモーション状態に遷移
            }
        }
    }
}

using JsonSchema.Response;
using Services;
using UnityEngine;
using Utils;

namespace Scenes.Game
{
    /// <summary>
    /// GameScene管理クラス
    /// GameState エンドレスモード用
    /// </summary>
    public partial class GameSceneCtrl
    {
        private class StateGameEndlessMode : StateGameTemplate
        {
            private EnemyGenerateInfo _lastGenerateInfo; // 最後に生成した情報
            private int _generateLevel; // 敵生成レベル
            
            /// <summary>
            /// MAXレベルを超えた場合の追加速度
            /// </summary>
            private const float OverLevelAddSpeed = 10.0f;

            /// <summary>
            /// ゲーム開始時の敵生成情報取得
            /// </summary>
            protected override EnemyGenerateInfo GetInitEnemyGenerateInfo()
            {
                // 敵生成レベルに1を指定して開始する
                _generateLevel = 1;
                _lastGenerateInfo = ServiceLocator.Resolve<IDataAccessService>().GetEnemyGenerateInfo(Owner._gameMode, _generateLevel);
                return _lastGenerateInfo;
            }
            
            /// <summary>
            /// プレイヤーが破壊された時の処理
            /// </summary>
            protected override void PlayerDestroyAction()
            {
                // ゲーム終了
                Owner.cameraCtrl.ShakeCamera(); // カメラを揺らす
                Owner._player.StartStateStop(); // プレイヤーを停止状態にする
                StateMachine.ChangeState((int) StateType.GameClear);
            }

            /// <summary>
            /// 敵が全て破壊された時の処理
            /// </summary>
            protected override void AllEnemyDestroyAction()
            {
                // 敵生成レベルアップ
                _generateLevel++;
                Debug.Log("generate level: " + _generateLevel);
                
                // レベルアップメッセージを表示
                ServiceLocator.Resolve<IAudioService>().PlayOneShot(GameConst.AudioNameSeLucky);
                Owner._gameInfoPresenter.ShowLevelUpMsg();
                
                // 敵の生成情報を取得
                var generateInfo = ServiceLocator.Resolve<IDataAccessService>().GetEnemyGenerateInfo(Owner._gameMode, _generateLevel);
                if (generateInfo != null)
                {
                    // 取得できた場合、生成情報を保持
                    _lastGenerateInfo = generateInfo;
                }
                else
                {
                    // 取得できなくなった場合(MAXレベルを超えた場合)、
                    // 最後の生成情報に速度を加えていく
                    _lastGenerateInfo.minSpeed += OverLevelAddSpeed;
                    _lastGenerateInfo.maxSpeed += OverLevelAddSpeed;
                    generateInfo = _lastGenerateInfo;
                }
                
                // 追加で敵を生成する
                GenerateEnemy(generateInfo, Owner._enemyPrefab, 3.0f); // 3秒待機する
            }
        }
    }
}

    /// <summary>
    /// DOTween共通クラス
    /// </summary>
    public class DOTweenUtil : MonoBehaviour
    {
        /// <summary>
        /// テキストを加算する
        /// </summary>
        public static Tween IncrementText(Text text, float current, float target, float duration = 1.0f, UnityAction<float> setAction = null)
        {
            return DOTween.To( (val) =>
            {
                current = val;
                if (setAction != null)
                {
                    setAction(val);
                }
                else
                {
                    text.text = Mathf.RoundToInt(val).ToString();
                }
            }, current, target, duration);
        }

        /// <summary>
        /// Scaleを変更する
        /// </summary>
        public static Tween DoScaleTransform(Transform transform, Vector3 current, Vector3 target, float duration = 1.0f, Ease ease = Ease.Linear)
        {
            transform.localScale = current;
            return transform.DOScale(target, duration).SetEase(ease);
        }

        /// <summary>
        /// localPositionを変更する
        /// </summary>
        public static Tween DoLocalMoveTransform(Transform transform, Vector3 current, Vector3 target, float duration = 1.0f, Ease ease = Ease.Linear)
        {
            transform.localPosition = current;
            return transform.DOLocalMove(target, duration).SetEase(ease);
        }
        
        /// <summary>
        /// Alpha値をフェードする
        /// </summary>
        public static Tween FeedImageAlpha(Image image, float current, float target, float duration = 1.0f)
        {
            var tmp = image.color;
            tmp.a = current;
            image.color = tmp;
            return DOTween.ToAlpha(
                () => image.color,
                color => image.color = color,
                target,
                duration);
        }
    }

            // リザルト画面表示
            var sequence = DOTween.Sequence();
            sequence.AppendCallback(() =>
            {
                InitializeScoreInfo();
                SetActiveResultWindow(true);
                SetActiveResultNextButton(false);
            });
            
            // 敵の倒した数を表示
            var duration = 0.5f;
            sequence.Append(DOTweenUtil.IncrementText(resultPerfectCountText, 0, perfectCount, duration));
            sequence.Join(DOTweenUtil.IncrementText(resultPerfectScoreText, 0, perfectScore, duration));
            sequence.Join(DOTweenUtil.IncrementText(resultGreatCountText, 0, greatCount, duration));
            sequence.Join(DOTweenUtil.IncrementText(resultGreatScoreText, 0, greatScore, duration));
            sequence.Join(DOTweenUtil.IncrementText(resultGoodCountText, 0, goodCount, duration));
            sequence.Join(DOTweenUtil.IncrementText(resultGoodScoreText, 0, goodScore, duration));
            sequence.Join(DOTweenUtil.IncrementText(null, 0, 1.0f, duration, (val) =>
            {
                ServiceLocator.Resolve<IAudioService>().PlayOneShot(GameConst.AudioNameSeCount);
            }));
            
            // タイムを表示
            sequence.AppendInterval(0.5f);
            sequence.Append(DOTweenUtil.IncrementText(resultTimeText, 0.0f, time, duration, (val) =>
            {
                resultTimeText.text = DateUtil.ConvTimeToMmSs(val);
            }));
            sequence.Join(
                DOTweenUtil.IncrementText(resultTimeScaleText, 0.0f, timeScale, duration, (val) =>
                {
                    resultTimeScaleText.text = "x" + val.ToString("f2");
                }));
            sequence.Join(DOTweenUtil.IncrementText(null, 0, 1.0f, duration, (val) =>
            {
                ServiceLocator.Resolve<IAudioService>().PlayOneShot(GameConst.AudioNameSeCount);
            }));
            
            // トータルスコアを表示
            var totalDuration = 0.5f;
            var totalEase = Ease.InExpo;
            sequence.AppendInterval(0.5f);
            sequence.AppendCallback(() => resultTotalScoreText.text = Mathf.RoundToInt(totalScore).ToString());
            sequence.Join(DOTweenUtil.DoLocalMoveTransform(resultTotalScoreText.rectTransform, new Vector3(-200.0f, 200.0f, 1.0f), resultTotalScoreText.rectTransform.localPosition, totalDuration, totalEase));
            sequence.Join(DOTweenUtil.DoScaleTransform(resultTotalScoreText.rectTransform, 10.0f * resultTotalScoreText.rectTransform.localScale, resultTotalScoreText.rectTransform.localScale, totalDuration, totalEase));
            sequence.AppendCallback(() => ServiceLocator.Resolve<IAudioService>().PlayOneShot(GameConst.AudioNameSeBomb));

            // トータルスコアの稲妻を表示
            sequence.AppendCallback(() =>
            {
                resultTotalScoreThunderImage01.gameObject.SetActive(true);
                resultTotalScoreThunderImage02.gameObject.SetActive(true);
            });
            sequence.Join(DOTweenUtil.FeedImageAlpha(resultTotalScoreThunderImage01, 0.0f, 1.0f, 0.5f));
            sequence.Join(DOTweenUtil.FeedImageAlpha(resultTotalScoreThunderImage02, 0.0f, 1.0f, 0.5f));
            
            // カニを表示
            sequence.AppendInterval(0.3f);
            sequence.AppendCallback(() =>
            {
                resultKaniImage.gameObject.SetActive(true);
                resultKaniSpeechImage.gameObject.SetActive(true);
                resultKaniSpeechText.text = isHighScore ? "ハイスコアぞ" : "オソレイッタ";
            });
            sequence.Join(DOTweenUtil.FeedImageAlpha(resultKaniImage, 0.0f, 1.0f, 0.5f));
            sequence.Join(DOTweenUtil.FeedImageAlpha(resultKaniSpeechImage, 0.0f, 1.0f, 0.5f));

            // コールバック実行
            sequence.AppendInterval(0.5f);
            sequence.AppendCallback(() =>
            {
                callback();
            });

using UnityEngine;

namespace Services
{
    /// <summary>
    /// Admob関連Service(Dummy)
    /// </summary>
    public class AdmobDummyService : MonoBehaviour, IAdmobService
    {
        public void ShowBanner()
        {
            // 処理なし
        }

        public void HideBanner()
        {
            // 処理なし
        }
    }
}

        // サービス登録
        var serviceLocator = new GameObject("ServiceLocator");
        serviceLocator.AddComponent<DontDestroyObject>();
        ServiceLocator.Register<IAudioService>(serviceLocator.AddComponent<AudioService>());
        ServiceLocator.Register<IAssetsService>(serviceLocator.AddComponent<AssetsService>());
        ServiceLocator.Register<IMonoBehaviorService>(serviceLocator.AddComponent<MonoBehaviorService>());
        ServiceLocator.Register<IDataAccessService>(new DataAccessJsonService());
        ServiceLocator.Register<IPlayerPrefsService>(new PlayerPrefsService());
        // モバイルの場合、Admobを適用し入力検知を無効にする
        if (ShootingGameState.IsMobilePlatform)
        {
            ServiceLocator.Register<IAdmobService>(serviceLocator.AddComponent<AdmobService>());
            ServiceLocator.Register<IInputKeyService>(serviceLocator.AddComponent<InputKeyDummyService>());
        }
        else
        {
            ServiceLocator.Register<IAdmobService>(serviceLocator.AddComponent<AdmobDummyService>());
            ServiceLocator.Register<IInputKeyService>(serviceLocator.AddComponent<InputKeyService>());
        }
        // 下記は内部でServiceを呼んでいるため最後に呼ぶ
        ServiceLocator.Register<IRankingService>(new RankingNCMBService());
        ServiceLocator.Register<ILoadingService>(new LoadingService());
        ServiceLocator.Register<IDialogService>(new DialogService());

{
  "generate_infos": [
    {
      "mode": 1,
      "level": 1,
      "generateCount": 5,
      "minAppearDegree": -45.0,
      "maxAppearDegree": 45.0,
      "minScale": 1.5,
      "maxScale": 3.0,
      "minSpeed": 15.0,
      "maxSpeed": 30.0,
      "addSpeed": 0.02,
      "minShakeWidthX": -5.0,
      "maxShakeWidthX": 5.0,
      "minShakeWidthY": -6.5,
      "maxShakeWidthY": 6.5,
      "shakeWidthYCount": 3,
      "minWaitTime": 6.0,
      "maxWaitTime": 8.5,
      "appearEachCount": 2
    },
    {
      "mode": 1,
      "level": 2,
      "generateCount": 15,
      "minAppearDegree": -60.0,
      "maxAppearDegree": 60.0,
      "minScale": 1.0,
      "maxScale": 3.0,
      "minSpeed": 25.0,
      "maxSpeed": 45.0,
      "addSpeed": 0.02,
      "minShakeWidthX": -7.0,
      "maxShakeWidthX": 7.0,
      "minShakeWidthY": -8.5,
      "maxShakeWidthY": 8.5,
      "shakeWidthYCount": 3,
      "minWaitTime": 4.0,
      "maxWaitTime": 5.5,
      "appearEachCount": 3
    },
    {
      "mode": 1,
      "level": 3,
      "generateCount": 30,
      "minAppearDegree": -75.0,
      "maxAppearDegree": 75.0,
      "minScale": 0.8,
      "maxScale": 3.0,
      "minSpeed": 25.0,
      "maxSpeed": 45.0,
      "addSpeed": 0.03,
      "minShakeWidthX": -8.0,
      "maxShakeWidthX": 8.0,
      "minShakeWidthY": -9.0,
      "maxShakeWidthY": 9.0,
      "shakeWidthYCount": 3,
      "minWaitTime": 4.5,
      "maxWaitTime": 6.0,
      "appearEachCount": 5
    },
    {
      "mode": 2,
      "level": 1,
      "generateCount": 10,
      "minAppearDegree": -60.0,
      "maxAppearDegree": 60.0,
      "minScale": 1.5,
      "maxScale": 3.0,
      "minSpeed": 25.0,
      "maxSpeed": 45.0,
      "addSpeed": 0.02,
      "minShakeWidthX": -7.0,
      "maxShakeWidthX": 7.0,
      "minShakeWidthY": -8.0,
      "maxShakeWidthY": 8.0,
      "shakeWidthYCount": 3,
      "minWaitTime": 4.0,
      "maxWaitTime": 5.5,
      "appearEachCount": 3
    },
    {
      "mode": 2,
      "level": 2,
      "generateCount": 10,
      "minAppearDegree": -60.0,
      "maxAppearDegree": 60.0,
      "minScale": 1.2,
      "maxScale": 3.0,
      "minSpeed": 25.0,
      "maxSpeed": 45.0,
      "addSpeed": 0.02,
      "minShakeWidthX": -7.0,
      "maxShakeWidthX": 7.0,
      "minShakeWidthY": -8.0,
      "maxShakeWidthY": 8.0,
      "shakeWidthYCount": 3,
      "minWaitTime": 4.0,
      "maxWaitTime": 5.5,
      "appearEachCount": 4
    },

・・・略・・・

  ]
}

        [Test]
        public void MaxScoreInfoTest()
        {
            // 倒した数が99999999を超えないこと
            var enemyScore = new JsonSchema.Response.EnemyScore();
            enemyScore.perfectScore = 500;
            enemyScore.greatScore = 300;
            enemyScore.goodScore = 100;
            
            for (var i = 0; i < 1000; i++)
            {
                _gameInfoModel.UpdateScoreInfoByHitType(GameConst.EnemyHitTypePerfect, enemyScore);
                _gameInfoModel.UpdateScoreInfoByHitType(GameConst.EnemyHitTypeGreat, enemyScore);
                _gameInfoModel.UpdateScoreInfoByHitType(GameConst.EnemyHitTypeGood, enemyScore);
            }

            var scoreInfo = _gameInfoModel.GetResultScoreInfo();
            Assert.AreEqual(999, scoreInfo.PerfectCount);
            Assert.AreEqual(999, scoreInfo.GreatCount);
            Assert.AreEqual(999, scoreInfo.GoodCount);
            Assert.AreEqual(999, scoreInfo.GameTotalCount);
            Assert.AreEqual(999, scoreInfo.ResultTotalCount);
            Assert.AreEqual(500000, scoreInfo.PerfectTotalScore);
            Assert.AreEqual(300000, scoreInfo.GreatTotalScore);
            Assert.AreEqual(100000, scoreInfo.GoodTotalScore);
            Assert.AreEqual(900000, scoreInfo.GameTotalScore);
            Assert.AreEqual(900000, scoreInfo.ResultTotalScore);
            
            // スコアが99999999を超えないこと
            enemyScore = new JsonSchema.Response.EnemyScore();
            enemyScore.perfectScore = 5000000;
            enemyScore.greatScore = 3000000;
            enemyScore.goodScore = 1000000;
            
            for (var i = 0; i < 1000; i++)
            {
                _gameInfoModel.UpdateScoreInfoByHitType(GameConst.EnemyHitTypePerfect, enemyScore);
                _gameInfoModel.UpdateScoreInfoByHitType(GameConst.EnemyHitTypeGreat, enemyScore);
                _gameInfoModel.UpdateScoreInfoByHitType(GameConst.EnemyHitTypeGood, enemyScore);
            }
            
            scoreInfo = _gameInfoModel.GetResultScoreInfo();
            Assert.AreEqual(999, scoreInfo.PerfectCount);
            Assert.AreEqual(999, scoreInfo.GreatCount);
            Assert.AreEqual(999, scoreInfo.GoodCount);
            Assert.AreEqual(999, scoreInfo.GameTotalCount);
            Assert.AreEqual(999, scoreInfo.ResultTotalCount);
            Assert.AreEqual(999999, scoreInfo.PerfectTotalScore);
            Assert.AreEqual(999999, scoreInfo.GreatTotalScore);
            Assert.AreEqual(999999, scoreInfo.GoodTotalScore);
            Assert.AreEqual(999999, scoreInfo.GameTotalScore);
            Assert.AreEqual(999999, scoreInfo.ResultTotalScore);
        }