Beispiel #1
0
        public void InputObsavationStart()
        {
            GameManager.Player.CanControl = false;
            _System.DialogResultAsObservable()
            .First()
            .Where(agree => agree)
            .Subscribe(_ =>
            {
                _System.EventDoneAsObservable()
                .Skip(1)
                .First()
                .Subscribe(__ =>
                {
                    SceneChanger.SceneChange(SceneType.StageOne);
                }).AddTo(_System);
                _System.EventDoneAsObservable()
                .DelayFrame(10)
                .First()
                .Subscribe(__ =>
                {
                    _System.TalkStart(TalkMessageReader.GetTalkData(_AfterChoice));
                }).AddTo(_System);
            }).AddTo(_System);

            _System.DialogResultAsObservable()
            .First()
            .Where(agree => !agree)
            .Subscribe(_ =>
            {
                _System.EventDoneAsObservable()
                .First()
                .Subscribe(__ => SceneChanger.SceneChange(SceneType.Title)).AddTo(_System);
            }).AddTo(_System);
            _System.TalkStart(TalkMessageReader.GetTalkData(_BeforeChoice));
        }
Beispiel #2
0
        public void InputObsavationStart()
        {
            _System.EventDoneAsObservable()
            .First()
            .Subscribe(_ =>
            {
                FadeInOut.Instance.OnFadeCompleteAsObservable()
                .First(fade => fade == Fade.Out)
                .Subscribe(__ =>
                {
                    _Player.SetActive(true);
                    _Player.GetComponent <Player> ().CanControl = false;
                    _Player.GetComponent <Player> ().Controller.BombController.ReminingBombCount.Value = 0;
                    _Rendere.sprite = _AirBackGroundImage;
                    _CloudPrefab.SetActive(true);
                    FadeInOut.Instance.OnFadeCompleteAsObservable()
                    .First(fade => fade == Fade.In)
                    .Subscribe(___ =>
                    {
                        _System.TalkStart(TalkMessageReader.GetTalkData(_CSV2));
                    }).AddTo(_System);
                    FadeInOut.Instance.FadeIn(1f);
                }).AddTo(_System);

                FadeInOut.Instance.FadeOut(1f);
            }).AddTo(_System);

            FadeInOut.Instance.OnFadeCompleteAsObservable()
            .First(fade => fade == Fade.Out)
            .Subscribe(__ =>
            {
                FadeInOut.Instance.OnFadeCompleteAsObservable()
                .First(fade => fade == Fade.In)
                .Subscribe(___ =>
                {
                    _System.TalkStart(TalkMessageReader.GetTalkData(_CSV1));
                }).AddTo(_System);
                _Rendere.sprite = _BaseBackGroundImage;
                FadeInOut.Instance.FadeIn(1f);
            }).AddTo(_System);
            Observable.NextFrame()
            .Delay(TimeSpan.FromSeconds(3f))
            .Subscribe(_ =>
            {
                FadeInOut.Instance.FadeOut(1f);
            }).AddTo(_System);
        }
        public void Start()
        {
            this.UpdateAsObservable()
            .First(_ => Input.anyKeyDown)
            .Subscribe(_ => system.TalkStart(TalkMessageReader.GetTalkData(Csv)));

            system.EventStartAsObservable().Subscribe(_ => Debug.Log("Eventstart"));
            system.EventDoneAsObservable().Subscribe(_ => Debug.Log("EventDone"));
        }
        public void InputObsavationStart()
        {
            GameManager.Player.CanControl = false;
            _System.EventDoneAsObservable()
            .First()
            .Subscribe(_ =>
            {
                _GuideRenderer.enabled            = true;
                _GuideRenderer.transform.position = _GuideInfo.Position;
                _GuideRenderer.sprite             = _GuideInfo.Sprite;
                var enemyList = new Enemy[_EnemyData.Length];
                for (int i = 0; i < _EnemyData.Length; i++)
                {
                    enemyList[i] = UnityEngine.Object.Instantiate(_EnemyData[i].Enemy, _EnemyData[i].PopPoint, Quaternion.identity);
                }

                GameManager.Player.CanControl = true;

                var enemiesDestroied                    = false;
                var reloaded                            = false;
                var shooted                             = false;
                Func <bool> reload                      = () => reloaded;
                Func <bool> shot                        = () => shooted;
                Func <bool> eliminateEnemies            = () => enemiesDestroied;
                IObservable <Unit> enemiesDestroyStream = enemyList[0].OnDestroyAsObservable();
                for (int i = 1; i < enemyList.Length; i++)
                {
                    enemiesDestroyStream = enemiesDestroyStream.Zip(enemyList[i].OnDestroyAsObservable(), (l, r) => r);
                }
                enemiesDestroyStream.First()
                .Subscribe(__ => enemiesDestroied = true).AddTo(_System);

                GameManager.Player.Controller.FiringController.ReloadAsObservable()
                .First()
                .Subscribe(__ => reloaded = true).AddTo(_System);
                GameManager.Player.Controller.FiringController.ShotAsObservable()
                .First()
                .Subscribe(__ => shooted = true).AddTo(_System);

                _InputObserver.ObsavationCompleteAsObsavable()
                .First()
                .Subscribe(__ => _GuideRenderer.enabled = false).AddTo(_System);
                _InputObserver.ObsavationStart(reload, shot, eliminateEnemies);
            }).AddTo(_System);
            _System.TalkStart(TalkMessageReader.GetTalkData(_CSV));
        }
Beispiel #5
0
        public void InputObsavationStart()
        {
            GameManager.Player.CanControl = false;
            _System.EventDoneAsObservable()
            .First()
            .Subscribe(_ =>
            {
                GameManager.Player.Controller.BombController.ReminingBombCount.Value = 2;
                _GuideRenderer.enabled            = true;
                _GuideRenderer.transform.position = _GuideInfo.Position;
                _GuideRenderer.sprite             = _GuideInfo.Sprite;
                GameManager.Player.CanControl     = true;
                var bombLaunched        = false;
                var isAllEnemyDestroied = false;
                GameManager.Player.Controller.BombController.LaunchMissileAsObservable()
                .First()
                .Subscribe(__ =>
                {
                    bombLaunched = true;
                }).AddTo(_System);

                var enemies = new Enemy[_EnemyPopData.Length];
                for (int i = 0; i < _EnemyPopData.Length; i++)
                {
                    enemies[i] = UnityEngine.Object.Instantiate(_EnemyPopData[i].Enemy, _EnemyPopData[i].PopPoint, Quaternion.identity);
                }

                var enemiesDestroyStream = enemies[1].OnDestroyAsObservable();
                for (int i = 1; i < enemies.Length; i++)
                {
                    enemiesDestroyStream.Zip(enemies[i].OnDestroyAsObservable(), (l, r) => r);
                }
                enemiesDestroyStream.First()
                .Subscribe(__ => isAllEnemyDestroied = true).AddTo(_System);
                Func <bool> bombLaunch            = () => bombLaunched;
                Func <bool> checkEliminateEnemies = () => isAllEnemyDestroied;

                _InputObserver.ObsavationCompleteAsObsavable()
                .First()
                .Subscribe(__ => _GuideRenderer.enabled = false).AddTo(_System);
                _InputObserver.ObsavationStart(bombLaunch, checkEliminateEnemies);
            }).AddTo(_System);
            _System.TalkStart(TalkMessageReader.GetTalkData(_CSV));
        }
 public void InputObsavationStart()
 {
     GameManager.Player.CanControl = false;
     _System.EventDoneAsObservable()
     .First()
     .Subscribe(_ =>
     {
         GameManager.Player.CanControl = true;
         Func <bool> up    = () => Input.GetAxis(AxisName.VERTICAL) > 0;
         Func <bool> down  = () => Input.GetAxis(AxisName.VERTICAL) < 0;
         Func <bool> left  = () => Input.GetAxis(AxisName.HORIZONTAL) < 0;
         Func <bool> right = () => Input.GetAxis(AxisName.HORIZONTAL) > 0;
         _GuideRenderer.transform.position = _GuideSprite.Position;
         _GuideRenderer.sprite             = _GuideSprite.Sprite;
         _InputObserver.ObsavationCompleteAsObsavable()
         .First()
         .Subscribe(__ => _GuideRenderer.enabled = false).AddTo(_System);
         _InputObserver.ObsavationStart(up, down, left, right);
     }).AddTo(_System);
     _System.TalkStart(TalkMessageReader.GetTalkData(_Csv));
 }
        private void Start()
        {
            _TalkSystem.EventStartAsObservable().Subscribe(_ => _State.Value = StageState.Talk);

            //TODO:ゲームステージの終了検知を入れないとだめかも?
            _TalkSystem.EventDoneAsObservable()
            .Where(data => data.Message != _EscapeTalkAsset.Message.Last().Message &&
                   data.Message != _ClearTalkAsset.Message.Last().Message)
            .Subscribe(_ =>
            {
                EnemySpawnerManager.StartProcess();
                _State.Value = StageState.Play;
                TimeManager.EnemyTimeScale = 1.0f;
                TimeManager.TimeScale      = 1.0f;
            })
            .AddTo(this);

            _TalkSystem.EventDoneAsObservable()
            .First(data => data.Message == _ClearTalkAsset.Message.Last().Message)
            .Subscribe(_ =>
            {
                FadeInOut.Instance.OnFadeCompleteAsObservable()
                .First(fade => fade == Fade.Out)
                .Subscribe(__ =>
                {
                    AudioManager.Instance.ChangeMusic(null);
                    _ClearGraphic.gameObject.SetActive(true);
                    FadeInOut.Instance.OnFadeCompleteAsObservable()
                    .First(fade => fade == Fade.In)
                    .Subscribe(r =>
                    {
                        SceneOverValueHolder.ScoreValue = _Score.ScoreValue.Value;
                        this.UpdateAsObservable()
                        .First(___ => Input.GetButtonDown(Constants.ButtonName.Shot))
                        .Subscribe(rr => SceneChanger.SceneChange(SceneType.Result));
                    });
                    FadeInOut.Instance.FadeIn(1f);
                });
                FadeInOut.Instance.FadeOut(1f);
            }).AddTo(this);

            _TalkSystem.EventDoneAsObservable()
            .Where(data => data.Message == _EscapeTalkAsset.Message.Last().Message)
            .First()
            .Subscribe(_ =>
            {
                SceneOverValueHolder.ScoreValue     = _Score.ScoreValue.Value;
                SceneOverValueHolder.StageClearTime = _StageDeltaTime;
                SceneChanger.SceneChange(SceneType.Result);
            }).AddTo(this);

            //ポーズ処理
            _State.Where(state => state == StageState.Play)
            .Subscribe(_ =>
            {
                GameManager.Player.CanControl = true;

                this.UpdateAsObservable()
                .Where(__ => _State.Value == StageState.Play)
                .Where(__ => Input.GetButtonDown(ButtonName.Pause))
                .First()
                .Subscribe(__ =>
                {
                    TimeManager.Pause();
                    _State.Value = StageState.Pause;
                });
            }).AddTo(this);

            //ポーズ解除処理
            _State.Where(state => state == StageState.Pause)
            .Subscribe(_ =>
            {
                this.UpdateAsObservable()
                .Where(__ => Input.GetButtonDown(ButtonName.Pause))
                .TakeUntil(_State.Where(state => state == StageState.Play))
                .First()
                .Subscribe(__ =>
                {
                    TimeManager.PauseRelease();
                    _State.Value = StageState.Play;
                });
            }).AddTo(this);

            _State.Where(state => state == StageState.Pause)
            .Subscribe(_ => AudioManager.SoundEmitter.PlaySE(_PauseSound)).AddTo(this);
            _State.Where(state => state == StageState.Talk)
            .Subscribe(_ =>
            {
                EnemySpawnerManager.StopProcess();
                GameManager.Player.CanControl = false;
                TimeManager.TimeScale         = 1.0f;
                TimeManager.EnemyTimeScale    = 0.0f;
            }).AddTo(this);

            //ボスポップ時の処理
            var spawnObservable = _EnemySpawner.Select(manager => manager.EnemySpawnAsObservable());

            /*	Observable.Merge (spawnObservable)
             *              .Where (enemy => enemy.tag == "Boss")
             *              .Subscribe (boss =>
             *              {
             *                      boss.OnDestroyAsObservable().Throttle(TimeSpan.FromSeconds(2))
             *                      .Subscribe(_ =>
             *                      {
             *                              SceneOverValueHolder.ScoreValue = _Score.ScoreValue.Value;
             *                              SceneOverValueHolder.StageClearTime = _StageDeltaTime;
             *                              SceneChanger.SceneChange (SceneType.Result);
             *                      });
             *                      UnityEngine.Debug.Log ("bossPop",gameObject);
             *              });*/

            this.UpdateAsObservable()
            .Where(_ => _State.Value == StageState.Play)
            .Subscribe(_ => _StageDeltaTime += TimeManager.DeltaTime);

            this.OnDestroyAsObservable()
            .Subscribe(_ =>
            {
                if (_State.Value == StageState.Pause)
                {
                    TimeManager.PauseRelease();
                }
            });

            GameManager.Player.Controller.LifeController.DeadAsObservable
            .Subscribe(_ =>
            {
                TimeManager.TimeScale      = 1.0f;
                TimeManager.EnemyTimeScale = 0.0f;
                EnemySpawnerManager.StopProcess();
            }).AddTo(this);
        }