コード例 #1
0
ファイル: GameManager.cs プロジェクト: SaitoYoshiki/MassShift
    //プレイヤーの入力を可能にしたり、不可能にしたりする
    //
    void CanInputPlayer(bool aCan)
    {
        float lTime = 0.0f;

        if (aCan == false)
        {
            lTime = 1.0f * 60.0f * 60.0f * 24.0f;
        }
        VirtualController.SetAxis(VirtualController.CtrlCode.Horizontal, 0.0f, lTime);
        VirtualController.SetAxis(VirtualController.CtrlCode.Jump, 0.0f, lTime);
        VirtualController.SetAxis(VirtualController.CtrlCode.Lift, 0.0f, lTime);
        VirtualController.SetAxis(VirtualController.CtrlCode.Vertical, 0.0f, lTime);
    }
コード例 #2
0
ファイル: GameManager.cs プロジェクト: SaitoYoshiki/MassShift
    IEnumerator GameMain()
    {
        float lTakeTime;

        //ステージ開始時の演出

        //タイトルから来ていないなら、プレイヤーに寄った位置からズームアウトを開始する
        if (cameraMove.fromTitle == false)
        {
            mCameraMove.mStartPosition = GetPlayerZoomCameraPosition();
        }
        //タイトルからなら
        else
        {
            //mCameraMove.mStartPosition = new Vector3(0.0f, 0.0f, 45.0f);
        }

        //カメラをズームされた位置に移動
        mCameraMove.MoveStartPosition();


        //プレイヤーを操作不可に
        CanMovePlayer(false);
        CanJumpPlayer(false);
        OnCanShiftOperation(false);

        if (mPause != null)
        {
            mPause.canPause = false;
        }

        //BGMを再生する
        int lAreaNumber = Area.GetAreaNumber();

        if (lAreaNumber == -1)
        {
        }
        else
        {
            GameObject lBGMPrefab = null;

            if (lAreaNumber <= 3)
            {
                lBGMPrefab = mAreaBGM[lAreaNumber];
            }
            else if (lAreaNumber == 4)
            {
                int lStageNumber = Area.GetStageNumber();
                if (lStageNumber == 1)
                {
                    lBGMPrefab = mAreaBGM[1];
                }
                else if (lStageNumber == 2)
                {
                    lBGMPrefab = mAreaBGM[2];
                }
                else if (lStageNumber == 3)
                {
                    lBGMPrefab = mAreaBGM[3];
                }
                else
                {
                    lBGMPrefab = mAreaBGM[3];
                }
            }

            //BGMを流し始める
            mBGMInstance = SoundManager.SPlay(lBGMPrefab);
            SoundManager.SFade(mBGMInstance, 0.0f, SoundManager.SVolume(lBGMPrefab), 2.0f);
        }

        // タイトルシーンからの遷移なら
        if (cameraMove.fromTitle)
        {
            cameraMove.fromTitle = false;
            Debug.Log("fromTitle" + cameraMove.fromTitle);
            yield return(null);
        }
        else
        {
            // ステージ開始時のドア開き
            if (mTransition != null)
            {
                //ステージ開始時の演出
                mTransition.OpenDoorParent();

                //演出が終了するまで待機
                while (true)
                {
                    if (mTransition.GetOpenEnd())
                    {
                        break;
                    }
                    yield return(null);
                }
            }
        }


        //ゲームメインの開始
        //

        //プレイヤーが操作可能になる
        CanMovePlayer(true);
        CanJumpPlayer(true);

        // エンディングならポーズ不可
        if (mPause != null && SceneManager.GetActiveScene().name != "Ending")
        {
            mPause.canPause = true;
        }
        else
        {
        }

        //カメラのズームアウトを始める
        mCameraMove.MoveStart();


        //ゲームメインのループ
        while (true)
        {
            //カメラのズームアウトが終わってから、移す操作を出来るようになる
            if (mCameraMove.IsMoveEnd)
            {
                OnCanShiftOperation(true);
                mCameraMove.IsMoveEnd = false;
            }

            if (mPause != null)
            {
                //ポーズ中なら
                if (mPause.pauseFlg)
                {
                    //mMassShift.CanShift = false;
                    Cursor.visible = true;
                }
                else
                {
                    //mMassShift.CanShift = true;
                    Cursor.visible = false;
                }
            }

            //ゴール判定
            //
            if (CanGoal(mGoal) || _Debug_ClearFlag)
            {
                break;
            }

            yield return(null);                 //ゲームメインを続ける
        }

        //重さを移せないようにする
        OnCanShiftOperation(false);
        if (mPause != null)
        {
            mPause.canPause = false;
        }

        //プレイヤーを操作不可にする
        CanInputPlayer(false);
        CanJumpPlayer(false);

        //プレイヤーの回転が終わるまで待つ
        while (true)
        {
            if (mPlayer.IsRotation == false)
            {
                break;
            }
            yield return(null);
        }


        //カメラのズームイン
        //

        //ズーム終了後のカメラ位置を変更
        mCameraMove.mEndPosition = GetGoalZoomCameraPosition();

        //カメラの開始地点を現在のカメラ位置にする
        mCameraMove.mStartPosition = mCameraMove.transform.position;

        mCameraMove.MoveStart();

        //カメラのズームイン終了まで待つ
        while (true)
        {
            if (mCameraMove.IsMoveEnd)
            {
                break;
            }
            yield return(null);
        }


        //プレイヤーをゴールの中心まで歩かせる
        //
        mPlayer.GetComponent <MoveManager>().mask = LayerMask.GetMask(new string[] { "Stage", "Player", "Fence" });

        Vector3 lGoalCenter = mGoal.transform.position;

        //左側にいるなら
        if (mPlayer.transform.position.x <= lGoalCenter.x)
        {
            //右に歩かせる
            VirtualController.SetAxis(VirtualController.CtrlCode.Horizontal, 0.5f, 30.0f);

            //ゴールの中心を超えたら、歩かせるのをやめる
            while (true)
            {
                if (mPlayer.transform.position.x >= lGoalCenter.x)
                {
                    Vector3 lPos = mPlayer.transform.position;
                    lPos.x = lGoalCenter.x;
                    mPlayer.transform.position = lPos;                      //補正
                    break;
                }
                yield return(null);
            }
        }
        //左側にいるなら
        else if (mPlayer.transform.position.x > lGoalCenter.x)
        {
            //左に歩かせる
            VirtualController.SetAxis(VirtualController.CtrlCode.Horizontal, -0.5f, 30.0f);

            //ゴールの中心を超えたら、歩かせるのをやめる
            while (true)
            {
                if (mPlayer.transform.position.x <= lGoalCenter.x)
                {
                    Vector3 lPos = mPlayer.transform.position;
                    lPos.x = lGoalCenter.x;
                    mPlayer.transform.position = lPos;                      //補正
                    break;
                }
                yield return(null);
            }
        }

        //左右移動の入力を消す
        mPlayer.GetComponent <MoveManager>().StopMoveHorizontalAll();
        VirtualController.SetAxis(VirtualController.CtrlCode.Horizontal, 0.0f, 30.0f);


        //プレイヤーの回転が終わるまで待つ
        //
        while (true)
        {
            if (mPlayer.IsRotation == false)
            {
                break;
            }
            yield return(null);
        }


        //プレイヤーを移動不可にする
        CanMovePlayer(false);
        CanJumpPlayer(false);

        OnPlayerEffect(true);           //プレイヤーの更新を切る
        mPlayer.GetComponent <PlayerAnimation>().ChangeState(PlayerAnimation.CState.cStandBy);



        //
        //プレイヤーがドアに入っていく演出
        //

        yield return(new WaitForSeconds(mGoalBeforeRotateTime));

        mGoal.mOpenForce = true;                                  //ドアを強制的に開く

        mGoalBlack.transform.position = mGoal.transform.position; //黒い背景をゴールのところに移動させる
        mGoalBlack.transform.rotation = mGoal.transform.rotation;

        //歩きアニメーションの再生
        mPlayer.GetComponent <PlayerAnimation>().SetSpeed(0.3f);
        mPlayer.GetComponent <PlayerAnimation>().ChangeState(PlayerAnimation.CState.cWalk);


        //プレイヤーを回転させていく
        //
        bool lIsRight = mPlayer.RotVec.x > 0.0f;

        //右を向いているなら
        if (lIsRight)
        {
            float lAngle = 0.0f;
            while (true)
            {
                //プレイヤーのモデルの回転を、ゆっくり元に戻す
                mPlayer.CameraLookRatio = Mathf.Clamp01(mPlayer.CameraLookRatio - 1.0f / mGoalRotateTime * Time.deltaTime);
                mPlayer.LookCamera();

                //プレイヤーを回転させる
                lAngle -= 90.0f / mGoalRotateTime * Time.deltaTime;
                mPlayer.transform.rotation = Quaternion.Euler(0.0f, lAngle, 0.0f);
                if (lAngle <= -90.0f)
                {
                    mPlayer.transform.rotation = Quaternion.Euler(0.0f, -90.0f, 0.0f);
                    break;
                }

                yield return(null);
            }
        }
        else
        {
            float lAngle = 0.0f;
            while (true)
            {
                //プレイヤーのモデルの回転を、ゆっくり元に戻す
                mPlayer.CameraLookRatio = Mathf.Clamp01(mPlayer.CameraLookRatio - 1.0f / mGoalRotateTime * Time.deltaTime);
                mPlayer.LookCamera();

                //プレイヤーを回転させる
                lAngle += 90.0f / mGoalRotateTime * Time.deltaTime;
                mPlayer.transform.rotation = Quaternion.Euler(0.0f, lAngle, 0.0f);
                if (lAngle >= 90.0f)
                {
                    mPlayer.transform.rotation = Quaternion.Euler(0.0f, 90.0f, 0.0f);
                    break;
                }

                yield return(null);
            }
        }

        yield return(new WaitForSeconds(mGoalBeforeWalkingTime));

        //プレイヤーを歩かせる
        //

        mPlayer.GetComponent <PlayerAnimation>().SetSpeed(1.0f);

        mGoalBlack.StartFade(0.0f, 1.0f, 0.0f, mGoalWalkingTime);

        while (true)
        {
            mPlayer.transform.position += new Vector3(0.0f, 0.0f, 3.0f / mGoalWalkingTime * Time.deltaTime);
            if (mPlayer.transform.position.z >= 3.0f)
            {
                break;
            }

            yield return(null);
        }

        yield return(new WaitForSeconds(mGoalAfterWalkingTime));

        //歩くのをやめる
        mPlayer.GetComponent <PlayerAnimation>().ChangeState(PlayerAnimation.CState.cStandBy);


        //BGMを止める
        SoundManager.SFade(mBGMInstance, SoundManager.SVolume(mBGMInstance), 0.0f, 0.5f, true);


        //移した回数を保存
        //

        //チュートリアル以外のステージなら
        if (Area.IsInStage() && Area.GetAreaNumber() != 0)
        {
            int lAreaNum  = Area.GetAreaNumber();
            int lStageNum = Area.GetStageNumber();

            int lBeforeTimes = ScoreManager.Instance.ShiftTimes(lAreaNum, lStageNum);
            int lNowTimes    = ScoreManager.Instance.ShiftTimes();

            //今までと今回で、移した回数の最小値を保存する
            bool lIsShortest = false;
            int  lNewTimes   = lBeforeTimes;
            if (lBeforeTimes == ScoreManager.cInvalidScoreTimes)
            {
                lNewTimes = lNowTimes;
            }
            if (lNowTimes < lBeforeTimes)
            {
                lNewTimes   = lNowTimes;
                lIsShortest = true;
            }

            ScoreManager.Instance.ShiftTimes(lAreaNum, lStageNum, lNewTimes);
            ScoreManager.Instance.IsShortestTimes = lIsShortest;
        }

        //データを保存
        SaveData.Instance.Save();


        Cursor.visible  = true;
        mResult.canGoal = true;
    }
コード例 #3
0
    //タイトルとチュートリアルから来た時の、自動で歩く演出のあるもの
    //
    IEnumerator StageSelectMain_FromTitle()
    {
        //重さを移せないようにする
        OnCanShiftOperation(false);
        mPause.canPause = false;

        //プレートの色を変える
        SetEnterColor(-1);

        //プレイヤーとボックスの重さを調整
        mPlayer.GetComponent <WeightManager>().WeightLv                = WeightManager.Weight.light;
        mTopStaticWeightBox.GetComponent <WeightManager>().WeightLv    = WeightManager.Weight.flying;
        mBottomStaticWeightBox.GetComponent <WeightManager>().WeightLv = WeightManager.Weight.heavy;


        //エリアの開放状況によって、重さボックスを消す
        HideBoxByAreaOpen();


        //カメラの開始地点を決める
        mCameraMove.mStartPosition = new Vector3(-19.5f, -3.5f, 45.0f);         //ステージセレクトの左端から始まる


        //カメラをズームされた位置に移動
        mCameraMove.MoveStartPosition();


        //プレイヤーを移動不可にする
        CanMovePlayer(false);
        CanJumpPlayer(false);

        // タイトルシーンからの遷移でなければ
        if (!mFromTitle)
        {
            //ステージ開始時の演出
            mTransition.OpenDoorParent();

            //演出が終了するまで待機
            while (true)
            {
                if (mTransition.GetOpenEnd())
                {
                    break;
                }
                yield return(null);
            }
        }

        //BGMを流し始める
        var t = SoundManager.SPlay(mStageSelectBGMPrefab);

        SoundManager.SFade(t, 0.0f, SoundManager.SVolume(mStageSelectBGMPrefab), 2.0f);


        //カメラのズームアウトを始める
        mCameraMove.MoveStart();


        //カメラのズームアウトが終わるまで待機
        while (true)
        {
            if (mCameraMove.IsMoveEnd)
            {
                break;
            }
            yield return(null);
        }

        mStageSelectScroll.mIsScroll = false;            //スクロールが行えるようになる

        //プレイヤーを自動で歩かせる
        //
        CanMovePlayer(true);            //プレイヤーは動けるようにするが、ユーザーの入力は受け付けない
        var v = mPlayer.GetComponent <VirtualController>();

        float cWalkTime = 10.0f;         //プレイヤーを自動で歩かせる秒数

        VirtualController.SetAxis(VirtualController.CtrlCode.Horizontal, 1.0f, cWalkTime);
        VirtualController.SetAxis(VirtualController.CtrlCode.Jump, 0.0f, cWalkTime);
        VirtualController.SetAxis(VirtualController.CtrlCode.Lift, 0.0f, cWalkTime);
        VirtualController.SetAxis(VirtualController.CtrlCode.Vertical, 0.0f, cWalkTime);


        float lBeforeCameraMoveTime = mCameraMove.mTakeTime;

        mCameraMove.mStartPosition = mCameraMove.transform.position;
        mCameraMove.mEndPosition   = mStageSelectScroll.mAreaCameraPosition[0].transform.position;

        const float cCameraMoveTime = 1.0f;

        mCameraMove.mTakeTime = cCameraMoveTime;

        mCameraMove.MoveStart();

        //歩かせている間待機
        while (true)
        {
            if (mCameraMove.IsMoveEnd == true && mPlayer.transform.position.x >= mPlayerStopPosition.transform.position.x)
            {
                break;
            }
            yield return(null);
        }
        VirtualController.SetAxis(VirtualController.CtrlCode.Horizontal, 0.0f, 0.0f);
        VirtualController.SetAxis(VirtualController.CtrlCode.Jump, 0.0f, 0.0f);
        VirtualController.SetAxis(VirtualController.CtrlCode.Lift, 0.0f, 0.0f);
        VirtualController.SetAxis(VirtualController.CtrlCode.Vertical, 0.0f, 0.0f);


        //カメラの移動にかける時間を戻す
        mCameraMove.mTakeTime = lBeforeCameraMoveTime;


        //プレイヤーを移動不可にする
        CanMovePlayer(false);
        CanJumpPlayer(false);


        //
        //エリア開放イベント
        //

        //エリア2が開放されているが、エリア2の開放イベントが行われていない場合
        if (Area.CanGoArea(2) && SaveData.Instance.mEventDoneFlag.mArea2Open == false)
        {
            yield return(AreaOpenEvent(2));

            SaveData.Instance.mEventDoneFlag.mArea2Open = true; //イベントを行った
            SaveData.Instance.Save();                           //ファイルにセーブ
        }

        //エリア3が開放されているが、エリア3の開放イベントが行われていない場合
        if (Area.CanGoArea(3) && SaveData.Instance.mEventDoneFlag.mArea3Open == false)
        {
            yield return(AreaOpenEvent(3));

            SaveData.Instance.mEventDoneFlag.mArea3Open = true; //イベントを行った
            SaveData.Instance.Save();                           //ファイルにセーブ
        }

        //エリア4が開放されているが、エリア4の開放イベントが行われていない場合
        if (Area.CanGoArea(4) && SaveData.Instance.mEventDoneFlag.mArea4Open == false)
        {
            yield return(AreaOpenEvent(4));

            SaveData.Instance.mEventDoneFlag.mArea4Open = true; //イベントを行った
            SaveData.Instance.Save();                           //ファイルにセーブ
        }


        //メインのコルーチンの開始
        //
        StartCoroutine(StageSelectMain());
    }
コード例 #4
0
    //ステージセレクトのメインの更新
    //
    IEnumerator StageSelectMain()
    {
        OnCanShiftOperation(true);                  //重さを移せるようになる
        mStageSelectScroll.mIsScroll        = true; //スクロールが行えるようになる
        mStageSelectScroll.mCameraMoveSpeed = 50.0f;
        mPause.canPause = true;                     //ポーズが出来るようになる
        CanMovePlayer(true);
        CanJumpPlayer(true);


        int lSelectStageNum       = -1;
        int lBeforeSelectStageNum = -1;
        int lDecideSelectStageNum = -1;


        //メインのループ
        //
        while (true)
        {
            //ポーズ中ならカーソルを出す
            if (mPause.pauseFlg)
            {
                Cursor.visible = true;
            }
            else
            {
                Cursor.visible = false;
            }


            //現在いる場所のドアを開くのと、プレートを光らせるのの更新
            lSelectStageNum = mSelectStageNum;
            if (lSelectStageNum != lBeforeSelectStageNum)
            {
                if (CanEnterStage(lSelectStageNum))
                {
                    SetEnterColor(lSelectStageNum);
                    OpenDoor(lSelectStageNum, true);

                    mSelectInit = false;
                    mSelectTime = 0.0f;
                }
                else
                {
                    SetEnterColor(-1);
                }

                OpenDoor(lBeforeSelectStageNum, false);

                if (lBeforeSelectStageNum != -1)
                {
                    mEnterUI.StopAnimation();
                }
            }
            lBeforeSelectStageNum = lSelectStageNum;


            //入る為のキー操作のUI表示
            //
            mSelectTime += Time.deltaTime;
            if (mSelectTime >= 0.4f && !mSelectInit)
            {
                mSelectInit = true;

                if (lSelectStageNum != -1)
                {
                    Vector3 lUIPosition = mGoal[lSelectStageNum].transform.position;
                    lUIPosition += mGoal[lSelectStageNum].transform.rotation * Vector3.down * 2.0f;
                    mEnterUI.SetPosition(lUIPosition);
                    mEnterUI.SetRotation(mGoal[lSelectStageNum].transform.rotation);
                    mEnterUI.StartAnimation();
                }
            }


            bool lIsEnter = Input.GetKey(KeyCode.W);

            //ゴール判定
            //
            if (mSelectStageNum != -1)
            {
                //もし入る操作が行われているなら
                if (lIsEnter && CanGoal(mGoal[mSelectStageNum]) && CanEnterStage(mSelectStageNum) && Area.IsValidArea((mSelectStageNum / 5) + 1))
                {
                    lDecideSelectStageNum = mSelectStageNum;
                    break;
                }
            }

            bool lEnterDoor = false;

            //Exと行き来するドアを通ったかの判定
            if (mSelectArea1ToEx)
            {
                if (lIsEnter)
                {
                    yield return(MoveArea1ToEx());

                    lEnterDoor = true;
                }
            }

            lIsEnter = Input.GetKey(KeyCode.W);

            if (mSelectExToArea1)
            {
                if (lIsEnter)
                {
                    yield return(MoveExToArea1());

                    lEnterDoor = true;
                }
            }

            yield return(null);             //ゲームメインを続ける


            //Exエリアと行き来するドアを、開きっぱなしにしないようにする
            if (lEnterDoor == true)
            {
                mExToArea1Door.mOpenForce = false;
                mArea1ToExDoor.mOpenForce = false;
            }
        }


        //重さを移せないようにする
        OnCanShiftOperation(false);
        mPause.canPause = false;

        //プレイヤーが入力できないようにする
        CanInputPlayer(false);

        CanJumpPlayer(false);

        //プレイヤーの回転が終わるまで待つ
        while (true)
        {
            if (mPlayer.IsRotation == false)
            {
                break;
            }
            yield return(null);
        }


        //UIを消す
        mEnterUI.gameObject.SetActive(false);

        //ズーム終了後のカメラ位置を変更
        mCameraMove.mEndPosition = GetPlayerZoomCameraPosition(mGoal[lDecideSelectStageNum].transform.up.y <= 0.0f);


        //カメラの開始地点を現在のカメラ位置にする
        mCameraMove.mStartPosition = mCameraMove.transform.position;


        //プレイヤーをゴールの中心まで歩かせる
        Vector3 lGoalCenter = mGoal[lDecideSelectStageNum].transform.position;

        //左側にいるなら
        if (mPlayer.transform.position.x <= lGoalCenter.x)
        {
            //右に歩かせる
            VirtualController.SetAxis(VirtualController.CtrlCode.Horizontal, 1.0f, 30.0f);

            //ゴールの中心を超えたら、歩かせるのをやめる
            while (true)
            {
                if (mPlayer.transform.position.x >= lGoalCenter.x)
                {
                    Vector3 lPos = mPlayer.transform.position;
                    lPos.x = lGoalCenter.x;
                    mPlayer.transform.position = lPos;                      //補正
                    break;
                }
                yield return(null);
            }
        }
        //左側にいるなら
        else if (mPlayer.transform.position.x >= lGoalCenter.x)
        {
            //左に歩かせる
            VirtualController.SetAxis(VirtualController.CtrlCode.Horizontal, -1.0f, 30.0f);

            //ゴールの中心を超えたら、歩かせるのをやめる
            while (true)
            {
                if (mPlayer.transform.position.x <= lGoalCenter.x)
                {
                    Vector3 lPos = mPlayer.transform.position;
                    lPos.x = lGoalCenter.x;
                    mPlayer.transform.position = lPos;                      //補正
                    break;
                }
                yield return(null);
            }
        }

        mPlayer.GetComponent <MoveManager>().StopMoveHorizontalAll();
        VirtualController.SetAxis(VirtualController.CtrlCode.Horizontal, 0.0f, 30.0f);

        //プレイヤーの回転が終わるまで待つ
        while (true)
        {
            if (mPlayer.IsRotation == false)
            {
                break;
            }
            yield return(null);
        }


        //プレイヤーを移動不可にする
        CanMovePlayer(false);
        CanJumpPlayer(false);

        OnPlayerEffect(true);           //プレイヤーの更新を切る

        mPlayer.GetComponent <PlayerAnimation>().ChangeState(PlayerAnimation.CState.cStandBy);


        mStageSelectScroll.mIsScroll = false;


        //ステージセレクトでは、ズームインしない仕様にした

        /*
         * mCameraMove.MoveStart();
         *
         * //カメラのズームイン終了まで待つ
         * while (true) {
         *      if (mCameraMove.IsMoveEnd) {
         *              break;
         *      }
         *      yield return null;
         * }
         */


        Goal g = mGoal[lDecideSelectStageNum];

        //
        //プレイヤーがドアに入っていく演出
        //
        yield return(WalkEnterDoor(g));


        //ステージ終了時の演出
        mTransition.CloseDoorParent();

        //演出が終了するまで待機
        while (true)
        {
            if (mTransition.GetCloseEnd())
            {
                break;
            }
            yield return(null);
        }

        //ステージ遷移
        UnityEngine.SceneManagement.SceneManager.LoadScene(Area.GetStageSceneName((lDecideSelectStageNum / 5) + 1, (lDecideSelectStageNum % 5) + 1));
    }
コード例 #5
0
ファイル: Ending.cs プロジェクト: SaitoYoshiki/MassShift
    IEnumerator EndingCoroutine()
    {
        // プレイヤーから自機操作権限を奪う
        for (int idx = 0; idx < (int)VirtualController.CtrlCode.Max; idx++)
        {
            VirtualController.SetAxis((VirtualController.CtrlCode)idx, 0.0f, float.MaxValue);
        }

        // 重さ移しコンポーネントを取得
        MassShift shift = GameObject.FindObjectOfType <MassShift>();

        // プレイヤーから重さ移し権限を奪う
        shift.mOverrideInputFromScript = true;

        // ムービー帯を表示
        Camera.main.GetComponent <MovieBelt>().IsDisplay = true;

        // カーソル位置をプレイヤー位置に移動
        shift.SetCursorPosition(plTrans.position);

        // 待機
        yield return(new WaitForSeconds(1.6f));

        // BGM再生
        SoundManager.SPlay(musicSoundPrefab);

        // 待機
        yield return(new WaitForSeconds(2.4f));

        // カーソル位置のオブジェクトを生成
        GameObject cursorPoint = new GameObject("CursorPoint");

        cursorPoint.transform.parent = transform;

        // カーソルを移す元に移動
        HermiteCurveMove hermite = cursorPoint.AddComponent <HermiteCurveMove>();

        hermite.SetPoints(plTrans.position, shiftFromTrans.position, ((plTrans.position + shiftFromTrans.position) * 0.5f));
        while (hermite.Ratio <= 1.0f)
        {
            shift.SetCursorPosition(hermite.Point);
            yield return(null);
        }
        shift.SetCursorPosition(shiftFromTrans.position);
        Destroy(hermite);

        // 待機
        yield return(new WaitForSeconds(0.5f));

        // 重さ移し入力を有効化
        shift.mInputClick = true;

        // 待機
        yield return(new WaitForSeconds(0.5f));

        // カーソルを移す先に移動
        hermite = cursorPoint.AddComponent <HermiteCurveMove>();
        hermite.SetPoints(shiftFromTrans.position, shiftToTrans.position, ((shiftFromTrans.position + shiftToTrans.position) * 0.5f));
        while (hermite.Ratio <= 1.0f)
        {
            shift.SetCursorPosition(hermite.Point);
            yield return(null);
        }
        shift.SetCursorPosition(shiftToTrans.position);
        Destroy(hermite);

        // 待機
        yield return(new WaitForSeconds(0.5f));

        // 重さ移し入力を無効化
        shift.mInputClick = false;

        // カーソルを非表示
        shift.mInvisibleCursor = true;

        // カーソルを移動する時間を設定
        float cursorMoveTime = (Time.time + shift.ShiftTimes);

        // 重さ移し演出を強化
        List <GameObject> particleList = new List <GameObject>();
        Vector3           center       = ((shiftFromTrans.position + shiftToTrans.position) * 0.5f);
        Vector3           pointA       = new Vector3(((shiftFromTrans.position.x - center.x) * particleRandomVec + center.x), ((shiftToTrans.position.y - center.y) * particleRandomVec + center.y), center.z);
        Vector3           pointB       = new Vector3(((shiftToTrans.position.x - center.x) * particleRandomVec + center.x), ((shiftFromTrans.position.y - center.y) * particleRandomVec + center.y), center.z);
        float             lastWaitTime = Time.time;
        int endCnt = 1;

        SetSizeUpParticle((float)endCnt / (float)particleNum);
        for (int cnt = 1; cnt < particleNum; cnt++)
        {
            GameObject newParticle = Instantiate(shiftParticle);
            hermite = newParticle.AddComponent <HermiteCurveMove>();

            Vector3 vec      = new Vector3((Random.value * 2.0f - 1.0f), (Random.value * 2.0f - 1.0f), 0.0f).normalized;
            Vector3 midPoint = (shiftFromTrans.position) + vec * shiftHopForce;

            hermite.SetPoints(shiftFromTrans.position, shiftToTrans.position, midPoint);
            hermite.EndDestroy = true;
            particleList.Add(newParticle);

            SoundManager.SPlay(shiftSoundPrefab);

            while (Time.time < (lastWaitTime + particleStandbyTime))
            {
                // カーソル移動判定
                if (cursorMoveTime < Time.time)
                {
                    shift.SetCursorPosition(Vector3.right * 100.0f);
                }

                // 終了したパーティクルをカウント
                while ((particleList.Count > 0) && !particleList[0])
                {
                    particleList.RemoveAt(0);
                    endCnt++;
                    SetSizeUpParticle((float)endCnt / (float)particleNum);
                }
                yield return(null);
            }
            lastWaitTime = Time.time;
            //yield return new WaitForSeconds(particleStandbyTime);
        }

        // 待機
        lastWaitTime = Time.time;
        while (endCnt < (particleNum - 1))
        {
            // 終了したパーティクルをカウント
            while ((particleList.Count > 0) && !particleList[0])
            {
                SoundManager.SPlay(shiftSoundPrefab);
                particleList.RemoveAt(0);
                endCnt++;
                SetSizeUpParticle((float)endCnt / (float)particleNum);
                lastWaitTime = Time.time;
            }
            yield return(null);
        }
        SetSizeUpParticle(1.0f);

        // 待機
        yield return(new WaitForSeconds(0.08f));

        // 落下開始
        boxLockCol.transform.position += (Vector3.down * armCrashDownDis);

        // 待機
        yield return(new WaitForSeconds(0.15f));

        // アームを開く
        armAnim.Play("arm");
        boxLockCol.enabled = false;
        SoundManager.SPlay(impactSoundPrefab);

        // アーム移動
        SoundManager.SPlay(impactSoundPrefab);
        float armMoveBeginTime = Time.time;

        while (true)
        {
            if ((armMoveBeginTime + armMoveTime) <= Time.time)
            {
                break;
            }
            float ratio = ((Time.time - armMoveBeginTime) / armMoveTime);
            armTrans.position = new Vector3(Mathf.Lerp(armBefPoint.position.x, armAftPoint.position.x, ratio), Mathf.Lerp(armBefPoint.position.y, armAftPoint.position.y, ratio), Mathf.Lerp(armBefPoint.position.z, armAftPoint.position.z, ratio));
            armTrans.rotation = Quaternion.Slerp(armBefPoint.rotation, armAftPoint.rotation, ratio);
            yield return(null);
        }

        // 待機
        yield return(new WaitForSeconds(0.5f));

        // 着地演出
        ShakeCamera.ShakeAll(shakeTime, shakeMagnitude);
        GameObject impactEffectObj = Instantiate(impactEffect);

        impactEffectObj.transform.position = impactEffectTrans.position;
        SoundManager.SPlay(impactSoundPrefab);

        // 背景セルの色を全て変更
        foreach (var cell in backgroundCellList)
        {
            cell.PowerfulLighting(backgourndCellMidMat);
        }

        // 背景セルの色を変更する巨大化する球を生成
        GameObject cellChangeSphereObj = Instantiate(cellChangeSpherePrefab, cellChangeSpherePoint);

        cellChangeSphereObj.transform.localPosition = Vector3.zero;

        // 待機
        yield return(new WaitForSeconds(1.0f));

        // カメラを扉にズーム
        float   zoomBeginTime = Time.time;
        Vector3 defCamPos     = Camera.main.transform.position;

        while (true)
        {
            float ratio = ((Time.time - zoomBeginTime) / camZoomTime);

            if (ratio >= 1.0f)
            {
                Camera.main.transform.position = camZoomPoint.position;
                break;
            }

            Camera.main.transform.position = new Vector3(Mathf.Lerp(defCamPos.x, camZoomPoint.position.x, ratio), Mathf.Lerp(defCamPos.y, camZoomPoint.position.y, ratio), Mathf.Lerp(defCamPos.z, camZoomPoint.position.z, ratio));
            yield return(null);
        }

        // 扉を開く
        doorAnim.Play("Open");
        SoundManager.SPlay(doorOpenSoundPrefab);

        // 待機
        yield return(new WaitForSeconds(3.0f));

        // 自機を扉の前に移動
        while (plTrans.position.x < doorFrontTrans.position.x)
        {
            VirtualController.SetAxis(VirtualController.CtrlCode.Horizontal, 0.1f);
            yield return(null);
        }

        // 自機の位置を補正
        plTrans.GetComponent <MoveManager>().StopMoveHorizontalAll();
        VirtualController.SetAxis(VirtualController.CtrlCode.Horizontal, 0.0f, float.MaxValue);
        plTrans.position = new Vector3(doorFrontTrans.position.x, plTrans.position.y, plTrans.position.z);

        // 自機を扉に向ける
        Player pl = plTrans.GetComponent <Player>();

        pl.CamLookDown     = true;
        pl.CameraLookRatio = 0.0f;
        pl.LookCamera();
        pl.enabled = false;
        Quaternion defPlRot    = pl.transform.rotation;
        Quaternion doorLookRot = Quaternion.LookRotation(doorInPointTrans.position - pl.transform.position) * Quaternion.Euler(0.0f, -90.0f, 0.0f);

        float doorLookBeginTime = Time.time;

        while (true)
        {
            float ratio = ((Time.time - doorLookBeginTime) / doorLookTime);
            if (ratio >= 1.0f)
            {
                plTrans.rotation = doorLookRot;
                break;
            }
            plTrans.rotation = Quaternion.Slerp(defPlRot, doorLookRot, ratio);
            yield return(null);
        }

        // 待機
        PlayerAnimation plAnim = pl.GetComponent <PlayerAnimation>();

        plAnim.StartStandBy();
        yield return(new WaitForSeconds(1.0f));

        plAnim.StartWalk();

        // 自機を扉の中に移動
        Camera.main.transform.parent = plTrans;
        Vector3 defPlPos        = plTrans.position;
        float   doorInBeginTime = Time.time;

        while (true)
        {
            float ratio = ((Time.time - doorInBeginTime) / doorInTime);
            if (ratio >= 1.0f)
            {
                plTrans.position = doorInPointTrans.position;
                break;
            }
            plTrans.position = new Vector3(Mathf.Lerp(defPlPos.x, doorInPointTrans.position.x, ratio), Mathf.Lerp(defPlPos.y, doorInPointTrans.position.y, ratio), Mathf.Lerp(defPlPos.z, doorInPointTrans.position.z, ratio));
            yield return(null);
        }

        // 待機
        yield return(new WaitForSeconds(0.75f));

        // 立ち止まる
        plAnim.StartStandBy();

        // ムービー帯解除
        Camera.main.GetComponent <MovieBelt>().IsDisplay = false;
        while (Camera.main.GetComponent <MovieBelt>().Ratio <= 0.0f)
        {
            yield return(null);
        }
        ;

        // 待機
        yield return(new WaitForSeconds(0.5f));

        float creditBeginTime = Time.time;

        while (true)
        {
            float ratio = ((Time.time - creditBeginTime) / creditTime);
            if (ratio >= 1.0f)
            {
                creditTrans.position = creditEndPoint.position;
                break;
            }
            creditTrans.position = new Vector3(Mathf.Lerp(creditBeginPoint.position.x, creditEndPoint.position.x, ratio), Mathf.Lerp(creditBeginPoint.position.y, creditEndPoint.position.y, ratio), Mathf.Lerp(creditBeginPoint.position.z, creditEndPoint.position.z, ratio));
            yield return(null);
        }

        // 待機
        yield return(new WaitForSeconds(4.3f));

        // シーン遷移
        ((ChangeScene)FindObjectOfType(typeof(ChangeScene))).OnTitleButtonDown();               // タイトルへ
    }