using System.Collections;
using UnityEngine;
using DG.Tweening;
using System.Collections.Generic;
using System.Linq;

/// <summary>
/// 音源管理クラス
/// </summary>
public class SoundManager : MonoBehaviour {

    public static SoundManager instance;

    public SoundDataSO soundDataSO;

    public const float CROSS_FADE_TIME = 1.0f;  // クロスフェード時間

    // ボリューム関連
    public float bgmVolume = 0.1f;
    public float seVolume = 0.2f;
    public float voiceVolume = 0.2f;
    public bool isMute = false;

    // 各オーディオファイル再生用の AudioSource
    private AudioSource[] bgmSources = new AudioSource[2];

    private bool isCrossFading;　　　　　　　// クロスフェード処理中かどうか判定用


    void Awake() {
        // シングルトンかつ、シーン遷移しても破棄されないようにする
        if (instance == null) {
            instance = this;
            DontDestroyOnLoad(gameObject);
        } else {
            Destroy(gameObject);
        }

        // BGM用 AudioSource追加
        bgmSources[0] = gameObject.AddComponent<AudioSource>();
        bgmSources[1] = gameObject.AddComponent<AudioSource>();
        bgmSources[1].volume = 0;
    }

    /// <summary>
    /// BGM再生
    /// </summary>
    /// <param name="bgmType"></param>
    /// <param name="loopFlg"></param>
    public void PlayBGM(SoundDataSO.BgmType newBgmType, bool loopFlg = true) {

        // BGMを Silence の状態にする場合            
        if ((int)newBgmType == 999) {
            StopBGM();
            return;
        }

        // 再生する BGM 用の BgmData を取得
        SoundDataSO.BgmData newBgmData = null;
        foreach (SoundDataSO.BgmData bgmData in soundDataSO.bgmDataList.Where(x => x.bgmType == newBgmType)) {
            newBgmData = bgmData;
            break;
        }

        // 対象となるデータがなければ処理しない
        if (newBgmData == null) {
            return;
        }

        // 同じBGMの場合は何もしない
        if (bgmSources[0].clip != null && bgmSources[0].clip == newBgmData.bgmAudioClip) {
            return;
        } else if (bgmSources[1].clip != null && bgmSources[1].clip == newBgmData.bgmAudioClip) {
            return;
        }

        // フェードでBGM開始
        if (bgmSources[0].clip == null && bgmSources[1].clip == null) {
            bgmSources[0].loop = loopFlg;
            bgmSources[0].clip = newBgmData.bgmAudioClip;
            bgmSources[0].volume = newBgmData.volume;
            bgmSources[0].Play();
        } else {
            // クロスフェード処理を利用して BGM を切り替え
            StartCoroutine(CrossFadeChangeBMG(newBgmData, loopFlg));
        }
    }

    /// <summary>
    /// BGMのクロスフェード処理
    /// </summary>
    /// <param name="bgmData"></param>
    /// <param name="loopFlg">ループ設定。ループしない場合だけfalse指定</param>
    /// <returns></returns>
    private IEnumerator CrossFadeChangeBMG(SoundDataSO.BgmData bgmData, bool loopFlg) {
        isCrossFading = true;

        if (bgmSources[0].clip != null) {
            // [0]が再生されている場合、[0]の音量を徐々に下げて、[1]を新しい曲として再生
            bgmSources[1].DOFade(bgmData.volume, CROSS_FADE_TIME).SetEase(Ease.Linear);
            bgmSources[1].clip = bgmData.bgmAudioClip;
            bgmSources[1].loop = loopFlg;
            bgmSources[1].Play();
            bgmSources[0].DOFade(0, CROSS_FADE_TIME).SetEase(Ease.Linear);

            yield return new WaitForSeconds(CROSS_FADE_TIME);
            bgmSources[0].Stop();
            bgmSources[0].clip = null;
        } else {
            // [1]が再生されている場合、[1]の音量を徐々に下げて、[0]を新しい曲として再生
            bgmSources[0].DOFade(bgmData.volume, CROSS_FADE_TIME).SetEase(Ease.Linear);
            bgmSources[0].clip = bgmData.bgmAudioClip;
            bgmSources[0].loop = loopFlg;
            bgmSources[0].Play();
            bgmSources[1].DOFade(0, CROSS_FADE_TIME).SetEase(Ease.Linear);

            yield return new WaitForSeconds(CROSS_FADE_TIME);
            bgmSources[1].Stop();
            bgmSources[1].clip = null;
        }
        isCrossFading = false;
    }

    /// <summary>
    /// BGM完全停止
    /// </summary>
    public void StopBGM() {
        bgmSources[0].Stop();
        bgmSources[1].Stop();
        bgmSources[0].clip = null;
        bgmSources[1].clip = null;
    }

    /// <summary>
    /// BGM一時停止
    /// </summary>
    public void MuteBGM() {
        bgmSources[0].Stop();
        bgmSources[1].Stop();
    }

    /// <summary>
    /// 一時停止した同じBGMを再生(再開)
    /// </summary>
    public void ResumeBGM() {
        bgmSources[0].Play();
        bgmSources[1].Play();
    }
}

using System.Collections;
using System.Collections.Generic;
using UnityEngine;

public class GameManager : MonoBehaviour {

    [SerializeField]
    private RailMoveController railMoveController;

    [SerializeField, Header("経路用のパス群の元データ")]
    private RailPathData originRailPathData;                      // 後程 List 化して複数のルートを管理できるようにします

    [SerializeField, Header("パスにおけるミッションの発生有無")]  // Debug 用
    private bool[] isMissionTriggers;

    [SerializeField]
    private PlayerController playerController;

    [SerializeField]
    private EventGenerator eventGenerator;

    [SerializeField, Header("ミッションで発生している敵のリスト")]
    private List<EnemyController> enemiesList = new List<EnemyController>();

    private int currentMissionDuration;

    [Header("現在のゲームの進行状態")]
    public GameState currentGameState;

    [SerializeField]
    private WeaponEventInfo weaponEventInfo;

    [SerializeField]
    private UIManager uiManager;

    [SerializeField]
    private WeaponChanger weaponChanger;

    [SerializeField]
    private CameraController cameraController;

    [SerializeField]   　　//　Debug 用に SerializeField属性を付与しています。確認が済んだら SerializeField属性 は削除してください。
    private bool[] isMoviePlays;


    private IEnumerator Start() {


        ////*  処理を追加します  *////


        SoundManager.instance.PlayBGM(SoundDataSO.BgmType.Main);


        ////*  ここまで  *////


        // ゲームの状態を準備中にする
        currentGameState = GameState.Wait;

        // ルート用の経路情報を設定
        originRailPathData = DataBaseManager.instance.GetRailPathDatasFromBranchNo(0, BranchDirectionType.NoBranch);

        // イベント生成機能の準備
        eventGenerator.SetUpEventGenerator(this, playerController);

        // 初期武器登録
        GameData.instance.AddWeaponData(DataBaseManager.instance.GetWeaponData(0));

        // 武器取得イベント用の設定
        weaponEventInfo.InitializeWeaponEventInfo();

        // 初期武器設定
        playerController.ChangeBulletData(GameData.instance.weaponDatasList[0]);

        // 初期武器のモデル表示
        weaponChanger.InitWeaponModel();

        // RailMoveController の初期設定
        railMoveController.SetUpRailMoveController(this);

        // パスデータよりミッションの発生有無情報取得
        SetMissionTriggers();

        // 次に再生するレール移動の目的地と経路のパスを設定
        railMoveController.SetNextRailPathData(originRailPathData);

        // 経路の準備が完了するのを待つ
        yield return new WaitUntil(() => railMoveController.GetMoveSetting());

        // ゲームの状態をプレイ中に変更する
        currentGameState = GameState.Play_Move;
    }

    /// <summary>
    /// パスデータよりミッションの発生有無情報取得
    /// </summary>
    private void SetMissionTriggers() {

        // 配列の初期化
        isMissionTriggers = new bool[originRailPathData.GetIsMissionTriggers().Length];

        // ミッション発生有無の情報を登録
        isMissionTriggers = originRailPathData.GetIsMissionTriggers();

        // ムービー再生情報用の配列を初期化
        isMoviePlays = new bool[originRailPathData.GetIsMoviePlays().Length];

        // ムービー再生有無の情報を登録
        isMoviePlays = originRailPathData.GetIsMoviePlays();
    }

    /// <summary>
    /// ミッションの発生有無の判定
    /// </summary>
    /// <param name="index"></param>
    public void CheckMissionTrigger(int index) {

        if (isMissionTriggers[index]) {

            // ミッション発生
            PreparateMission(originRailPathData.pathDataDetails[index].missionEventDetail);

            Debug.Log("ミッション発生");

        } else {
            // ミッションなし。次のパスへ移動を再開
            railMoveController.CountUp();
        }
    }

    /// <summary>
    /// ミッションの準備
    /// </summary>
    /// <param name="missionEventDetail"></param>
    private void PreparateMission(MissionEventDetail missionEventDetail) {

        // ミッションの時間設定
        currentMissionDuration = missionEventDetail.missionDuration;

        // 武器取得イベントか判定
        if (missionEventDetail.eventTypes[0] == EventType.Weapon) {
            // 武器の情報を取得してセット
            weaponEventInfo.SetWeaponData(DataBaseManager.instance.GetWeaponData(missionEventDetail.eventNos[0]));
            weaponEventInfo.Show();
        } else {

            // ミッション内の各イベントの生成(敵、ギミック、トラップ、アイテムなどを生成)
            eventGenerator.PrepareGenerateEnemies(missionEventDetail.enemyPrefabs, missionEventDetail.eventTrans);
        }

        // ミッション開始
        StartCoroutine(StartMission(missionEventDetail.clearConditionsType));
    }

    /// <summary>
    /// ミッション開始
    /// </summary>
    /// <param name="clearConditionsType"></param>
    /// <returns></returns>
    private IEnumerator StartMission(ClearConditionsType clearConditionsType) {

        // ゲームの進行状態をミッション中に変更
        currentGameState = GameState.Play_Mission;

        // ミッションの監視
        yield return StartCoroutine(ObservateMission(clearConditionsType));

        // ミッション終了
        EndMission();
    }

    /// <summary>
    /// ミッションの監視
    /// 各イベントの状態を監視
    /// </summary>
    /// <param name="clearConditionsType"></param>
    /// <returns></returns>
    private IEnumerator ObservateMission(ClearConditionsType clearConditionsType) {

        // クリア条件を満たすまで監視(currentMissionDuration 変数には、敵の数か、残り時間が入る)
        while (currentMissionDuration > 0) {

            // クリア条件が時間経過の場合
            if (clearConditionsType == ClearConditionsType.TimeUp) {

                // カウントダウン
                currentMissionDuration--;
            }

            // 武器取得イベントかつ、武器選択のいずれかのボタンを押したら
            if (weaponEventInfo.gameObject.activeSelf && weaponEventInfo.isChooseWeapon) {
                // イベント終了
                currentMissionDuration = 0;

                weaponEventInfo.Hide();

                Debug.Log("武器取得イベント終了");
                yield break;
            }
            yield return null;
        }
        Debug.Log("ミッション終了");
    }

    /// <summary>
    /// ミッション終了
    /// </summary>
    public void EndMission() {

        // 武器の取得イベントの場合には武器を取得せずにポップアップを閉じる
        if (weaponEventInfo.gameObject.activeSelf) {
            weaponEventInfo.Hide();
        }

        // 今回分の敵の情報をクリア
        ClearEnemiesList();

        // ゲームの進行状態を移動中に変更
        currentGameState = GameState.Play_Move;

        // カメラの移動再開
        railMoveController.CountUp();
    }

    /// <summary>
    /// 敵の List をクリア
    /// </summary>
    private void ClearEnemiesList() {
        if (enemiesList.Count > 0) {
            for (int i = 0; i < enemiesList.Count; i++) {
                Destroy(enemiesList[i]);
            }
        }

        enemiesList.Clear();
    }

    /// <summary>
    /// 敵の情報を List から削除し、ミッション内の敵の残数を減らす
    /// </summary>
    /// <param name="enemy"></param>
    public void RemoveEnemyList(EnemyController enemy) {

        currentMissionDuration--;

        enemiesList.Remove(enemy);
    }

    /// <summary>
    /// 敵の情報をリストに追加
    /// </summary>
    /// <param name="enemy"></param>
    public void AddEnemyList(EnemyController enemy) {
        enemiesList.Add(enemy);
    }

    /// <summary>
    /// ルートの分岐確認の準備
    /// </summary>
    /// <param name="nextbranchNo">moveCount</param>
    public void PreparateCheckNextBranch(int nextbranchNo) {

        StartCoroutine(CheckNextBranch(nextbranchNo));
    }

    /// <summary>
    /// ルートの分岐判定
    /// </summary>
    /// <param name="nextStagePathDataNo"></param>
    /// <returns></returns>
    private IEnumerator CheckNextBranch(int nextStagePathDataNo) {
        if (nextStagePathDataNo >= DataBaseManager.instance.GetStagePathDetasListCount()) {
            // 終了
            Debug.Log("ゲーム終了");

            // プレイヤー側のクリアの準備
            playerController.PrepareClearSettings();

            // すべての武器を非表示
            weaponChanger.InactiveWeapons();

            // カメラの演出
            cameraController.ClearCameraRoll(playerController.transform.position + new Vector3(0, 0, 10), new Vector3(0, 180, 0), new float[2] { 1.5f, 2.0f });

            yield break;
        }

        // ルートに分岐があるかどうかの判定
        if (DataBaseManager.instance.GetBranchDatasListCount(nextStagePathDataNo) == 1) {

            Debug.Log("分岐なしで次のルートへ");

            // 分岐なしの場合、次の経路を登録
            originRailPathData = DataBaseManager.instance.GetRailPathDatasFromBranchNo(nextStagePathDataNo, BranchDirectionType.NoBranch);
        } else {
            // 分岐がある場合、UI に分岐を表示し、選択を待つ

            Debug.Log("ルートの分岐発生");

            // 分岐がある場合、分岐イベントを発生させて、画面上に矢印のボタンを表示
            uiManager.GenerateBranchButtons(DataBaseManager.instance.GetBranchDirectionTypes(nextStagePathDataNo));

            // 分岐を選択するまで待機(while でもOK)
            yield return new WaitUntil(() => uiManager.GetSubmitBranch().Item1 == true);

            // 選択した分岐のルートを設定
            originRailPathData = DataBaseManager.instance.GetRailPathDatasFromBranchNo(nextStagePathDataNo, uiManager.GetSubmitBranch().Item2);
        }

        // ルート内のミッション情報を設定
        SetMissionTriggers();

        // 経路を移動先に設定
        railMoveController.SetNextRailPathData(originRailPathData);

        // レール移動の経路と移動登録が完了するまで待機
        yield return new WaitUntil(() => railMoveController.GetMoveSetting());

        // ゲームの進行状態を移動中に変更する
        currentGameState = GameState.Play_Move;
    }

    /// <summary>
    /// ムービーを再生するか確認
    /// </summary>
    /// <param name="index"></param>
    public void CheckMoviePlay(int index) {

        Debug.Log(index);

        if (!isMoviePlays[index]) {

            Debug.Log("ムービー再生 なし");

            // ミッション発生有無の確認
            CheckMissionTrigger(index);
        } else {

            // ムービー再生の準備
            StartCoroutine(PrepareMoviePlay(index));
        }
    }

    /// <summary>
    /// ムービー再生の準備
    /// </summary>
    /// <param name="index"></param>
    /// <returns></returns>
    private IEnumerator PrepareMoviePlay(int index) {

        Debug.Log("ムービー準備開始");

        // Canvas を非表示
        uiManager.SwitchActivateCanvas(false);

        // 弾を発射をできないようにする
        playerController.IsShootPerimission = false;

        yield return StartCoroutine(PlayMovie());


        /// ムービー再生
        IEnumerator PlayMovie() {

            Debug.Log("ムービー再生開始");

            // ムービー再生の準備と再生
            VideoClipManager.instance.PrepareVideoClip(originRailPathData.pathDataDetails[index].missionEventDetail.videoNo, originRailPathData.pathDataDetails[index].missionEventDetail.videoClip);

            // ムービーの準備時間だけ待機
            yield return new WaitForSeconds(1.5f);

            Debug.Log("ムービー準備待機 終了");

            // ムービー再生が終了するまで待機（どちらの処理でも待機できます）
            yield return new WaitUntil(() => !VideoClipManager.instance.IsVideoPlaying);
            //yield return new WaitForSeconds((float)originRailPathData.pathDataDetails[index].missionEventDetail.videoClip.length);

            Debug.Log("ムービー再生　終了");

            // 画面のフェードインが戻るまでの間、待機してから
            yield return new WaitForSeconds(1.0f);

            // Canvas を表示
            uiManager.SwitchActivateCanvas(true);

            // ムービーが終了したので弾の発射を許可
            playerController.IsShootPerimission = true;

            // ミッション発生有無の確認
            CheckMissionTrigger(index);
        }
    }
}

using System.Collections;
using System.Collections.Generic;
using UnityEngine;

public class Title : MonoBehaviour
{ 


////*  処理を追加します  *////


　　void Start()
    {
　　　　SoundManager.instance.PlayBGM(SoundDataSO.BgmType.Title);
    }


////*  ここまで  *////


　　void Update()
    {
        if(Input.GetMouseButtonDown(0)){
            TransitionManager.instance.FadeNextScene(1.0f, SceneName.Main);   //  <=  シーン遷移したい列挙子を選択します
        }
    }
}