PuppyClient/Assets/Scripts/Home/HomeController.cs

using Cinemachine;
using Newtonsoft.Json;
using System;
using System.Collections;
using System.Collections.Generic;
using Unity.Collections.LowLevel.Unsafe;
using Unity.VisualScripting;
using UnityEngine;
using UnityEngine.InputSystem;
using UnityEngine.Animations;

//using UnityEngine.Rendering.PostProcessing;
using UnityEngine.SceneManagement;
using ZXing.Common;

/* 本代码控制室内场景
 * 控制宠物在Home场景动画
 * ！！！特别注意：Dog Initializer 必须挂载在同一个组件下，并且必须在本组价下方。确保比本组件先执行
 * 主要调节参数在FixedUpdate代码段里面
 * 提示用户注册
 */

public class HomeController : MonoBehaviour
{

    public static HomeController Instance;

    public static List<DogInScene> dogsInScene = new List<DogInScene>();
    public static bool listenBreak = false;       // 当按下说话按键后，所有狗停止行动，立刻切换到监听状态。
    public static CinemachineVirtualCamera playerCam, dogCam;
    public static DateTime lastCameraChange;
    private bool isSleepChecked = false;        // 用于检测第一次睡眠检测是否执行完成
    // Start is called once before the first execution of Update after the MonoBehaviour is created
    private GameObject centerOfDogs;
    private SceneMode sceneMode = SceneMode.NORMAL;        // 当前场景处在的模式

    //private bool isInteractMode = false;        // 场景是否在交互状态
    private Vector2 previousPointerPosition = Vector2.zero;     // 前一帧鼠标位置
    private GameObject interactDog;        // 交互的狗
    float interactTime = 0f;        // 交互时间

    //private bool isTrainingMode = false;        // 是否在训练状态
    private string trainingContent = String.Empty;        // 训练内容 _xx 对于language.json 0x开始提示 1x成功提示 2x失败提示
    private int totalTrainingTimes = 2;        // 训练总次数
    private int currentTrainingTimes = 0;        // 当前训练次数
    private string trainingDogId = "";        // 训练的狗id
    private bool isTrainingMsgShowed_1 = false;        // 第一条是否已经显示训练提示
    private bool isTrainingMsgShowed_2 = false;        // 第二条是否已经显示训练提示

    private void Awake()
    {
        if (Instance == null)
        {
            Instance = this;
            //DontDestroyOnLoad(gameObject);        // 必须关掉否则会导致原场景destroy不能执行
        }
        else
        {
            Destroy(gameObject);
        }
    }

    void Start()
    {
        dogsInScene.Clear();        // dogsInScene 是静态，每次启动要清空
        lastCameraChange = DateTime.Now;
        playerCam = GameObject.Find("VCam Player").GetComponent<CinemachineVirtualCamera>();
        dogCam = GameObject.Find("VCam Dog").GetComponent<CinemachineVirtualCamera>();
        centerOfDogs = GameObject.Find("CenterOfDogs");

        //InitialScene();
        StartCoroutine(InitialScene());
    }

    // Update is called once per frame
    void FixedUpdate()
    {
        if (SceneInitialCheck())      // 确保狗读取成功后执行代码
        {
            // 计算多只狗的中心位置，用于主摄像机瞄准
            centerOfDogs.transform.position = CenterOfDogs();

            if (!isSleepChecked)        // 每次启动检测只进行一次是否进入睡眠
            {
                // 判断是否在睡觉时间
                DateTime dateTime = DateTime.Now;

                foreach (var dog in dogsInScene)
                {
                    if (dateTime.Hour >= 22 || dateTime.Hour <= 5)      // 深夜模式，狗默认在睡觉状态
                    {
                        dog.Sleep();

                    }
                    else if (dog.dogProperty.stamina <= 10) { dog.Sleep(); }        // 狗体力太低了，进入睡觉模式
                    else
                    {
                        dog.IdleAnimation();
                    }
                }
                isSleepChecked = true;
            }

            #region 场景动画主循环
            // 检测狗是否被撞翻，如果是，立刻翻回来
            foreach (var dog in dogsInScene)
            {
                Quaternion curRotation = dog.gameObject.transform.rotation;
                if (curRotation.x != 0)
                {
                    curRotation.x = 0;
                }
                if (curRotation.z != 0)
                {
                    curRotation.z = 0;
                }
                dog.gameObject.transform.rotation = curRotation;
            }

            // 生成一个数据数用于随机开启动画，如果和狗的randomFactor相同就开启动画
            int randomCheck = UnityEngine.Random.Range(0, 51);

            // 检测是否有狗没有通过voiceCall训练，如果有，立刻进入训练模式
            if (sceneMode == SceneMode.NORMAL)        // 只有在正常模式下才可以进入训练模式
            {
                foreach (var dog in dogsInScene)
                {
                    if (!dog.dogProperty.voiceCallEnable)
                    {
                        //isTrainingMode = true;
                        sceneMode = SceneMode.TRAINING;
                        dog.RemoveZzzParticle();
                        trainingContent = "voiceCall";
                        trainingDogId = dog.dogProperty.d_id;
                        totalTrainingTimes = 2;
                        currentTrainingTimes = 0;
                        GameData.focusDog = dogsInScene.IndexOf(dog);
                        //GameData.focusDog = UserProperty.GetDogIndexById(dog.dogProperty.d_id);
                        dogsInScene[GameData.focusDog].SetupInteract();
                        interactDog = dogsInScene[GameData.focusDog].gameObject;
                        VoiceButtonOnlySwitch(true);        // 交互模式下关闭其他菜单
                    }
                    else if (dog.dogProperty.voiceCall > 40 && !dog.dogProperty.voiceCommandEnable && dog.dogProperty.voiceCallEnable)
                    {
                        // 当狗的voiceCall大于40，且没有voiceCommand能力时，进入第一阶段指令训练模式
                        int random = UnityEngine.Random.Range(0, 100);
                        if (random < 25 && !dog.dogProperty.commandSit)
                        {
                            trainingContent = "commandSit";
                        }
                        else if (random < 50 && !dog.dogProperty.commandStand)
                        {
                            trainingContent = "commandStand";
                        }
                        else if (random < 75 && !dog.dogProperty.commandBark)
                        {
                            trainingContent = "commandBark";
                        }
                        else if (random < 100 && !dog.dogProperty.commandLieDown)
                        {
                            trainingContent = "commandLieDown";
                        }
                        else
                        {
                            trainingContent = String.Empty;
                        }

                        if (trainingContent != String.Empty)
                        {
                            sceneMode = SceneMode.TRAINING;
                            dog.RemoveZzzParticle();
                            trainingDogId = dog.dogProperty.d_id;
                            totalTrainingTimes = 2;
                            currentTrainingTimes = 0;
                            GameData.focusDog = dogsInScene.IndexOf(dog);
                            //GameData.focusDog = UserProperty.GetDogIndexById(dog.dogProperty.d_id);
                            dogsInScene[GameData.focusDog].SetupInteract();
                            interactDog = dogsInScene[GameData.focusDog].gameObject;
                            VoiceButtonOnlySwitch(true);        // 交互模式下关闭其他菜单
                        }
                    }
                }
            }

            else if (this.sceneMode == SceneMode.TRAINING)
            {
                foreach (var dog in dogsInScene)
                {
                    if (dog.dogState == DogState.INTERACT || dog.dogState == DogState.TRAINING)
                    {
                        dogCam.m_LookAt = dog.gameObject.transform;     // 摄像机看向交互的狗
                        dogCam.Priority = 10;
                        // 单只狗在交互的状态控制代码
                        if (dog.isMovingToPlayer)
                        {
                            dog.MovetoPlayer();
                        }
                        else
                        {
                            dog.dogState = DogState.TRAINING;
                            if (!isTrainingMsgShowed_1 && !isTrainingMsgShowed_2 && currentTrainingTimes == 0)
                            {
                                string msg = GameTool.GetValueAtPath(EnviromentSetting.languageData, new string[] { "game_message", trainingContent + "_00", EnviromentSetting.languageCode });
                                MessageBoxController.ShowMessage(msg);
                                var BGM = GameObject.Find("BGM");
                                if (BGM != null)
                                {
                                    FadeBGM(BGM.GetComponent<AudioSource>(), false);
                                }
                                isTrainingMsgShowed_1 = true;
                            }
                            else if (!isTrainingMsgShowed_2 && isTrainingMsgShowed_1 && currentTrainingTimes == 1)
                            {
                                string msg = GameTool.GetValueAtPath(EnviromentSetting.languageData, new string[] { "game_message", trainingContent + "_01", EnviromentSetting.languageCode });
                                MessageBoxController.ShowMessage(msg);
                                isTrainingMsgShowed_2 = true;
                            }
                        }
                    }
                    else
                    {
                        // 暂时将其他非训练状态的狗game object隐藏
                        dog.gameObject.SetActive(false);
                    }
                }
            }
            else if (sceneMode == SceneMode.INACTIVE)
            {
                foreach (var dog in dogsInScene)
                {
                    if (dog.dogState == DogState.INTERACT)
                    {
                        dogCam.m_LookAt = dog.gameObject.transform;     // 摄像机看向交互的狗
                        dogCam.Priority = 10;
                        // 单只狗在交互的状态控制代码
                        if (dog.isMovingToPlayer)
                        {
                            dog.MovetoPlayer();
                        }
                        else if (dog.InteractTimeout())        // 如果交互时间结束，结束交互状态
                        {
                            dog.ExitInteract();
                            sceneMode = SceneMode.NORMAL;       // 交互结束，退出交互状态
                                                                //isInteractMode = false;        // 交互结束，退出交互状态
                            VoiceButtonOnlySwitch(false);        // 交互结束，打开其他菜单
                        }
                        else
                        {
                            PointerOnDog();        // 检测是否点击在狗上

                        }
                    }
                }
            }
            else
            {
                // 场景非交互模式下的控制代码
                foreach (var dog in dogsInScene)
                {
                    // 如果在eat drink进程结束前不执行随机场景代码
                    // 检测有隐藏的狗，显示出来
                    if (dog.gameObject.activeSelf == false)
                    {
                        dog.gameObject.SetActive(true);
                    }
                    if (dog.dogState == DogState.ITEM_CONSUME)
                    {
                        if (dog.isMovingToBowl)
                        {
                            dog.MovetoBowl();
                        }
                    }
                    else
                    {
                        // 随机动作控制控制   
                        RandomCameraChange();

                        if (listenBreak)        // 如果用户按下说话按键，立刻切换到监听状态
                        {
                            dog.Listen();
                        }
                        else if (dog.isMoving)
                        {
                            dog.RandomMove();
                        }

                        else if (randomCheck == dog.randomFactor && !dog.isSleeping)        // 当狗自身的随机数和系统随机数相同时候触发。约100秒触发一次。
                        {
                            TimeSpan ts = DateTime.Now - dog.animationStartTime;
                            if (ts.Seconds >= 30)        // 如果距离上一个动作超过30秒就可以开始新的动作
                            {
                                float r = UnityEngine.Random.Range(0, 1f);
                                if (r > 0.6)       // 随机选择开始动画，或者移动
                                {
                                    dog.IdleAnimation();
                                }
                                else        // 狗狗开始步行移动
                                {
                                    dog.SetMoveSpeed(0);
                                    dog.moveSpeed = 0;
                                    dog.RandomMove();
                                }
                            }
                        }
                    }
                }
            }
            #endregion


        }
    }

    private void OnDestroy()
    {
        Debug.Log("Home scene is destoried.");
    }
    //void AniOrWalk(DogInScene dog)        // 狗在普通状态下，随机或播放动画，或移动
    //{

    //}

    // 初始化场景，加载所有的狗，并配置components，添加到dogsInScene List里面去
    //void InitialScene()
    IEnumerator InitialScene()
    {
        //yield return null;     
        //yield return null;     
        yield return null;      // 跳过三帧，初始化最多三只狗
        //Debug.Log(isInitialDone);
        foreach (var dog in UserProperty.dogs)
        {
            DogInScene dogInScene = new DogInScene(dog);
            float x = UnityEngine.Random.Range(-1f, 1f);        // 随机生成位置，考虑到手机评估宽度限制宽度
            float z = UnityEngine.Random.Range(-5f, 5f);
            float y = UnityEngine.Random.Range(0, 360f);
            var initPosition = new Vector3(x, 0, z);
            StartCoroutine(DogComponentInstaller(dog));       // 加载狗的其他组件
            var dogGameObject = GameObject.Find(dog.dog_name);
            if (dogGameObject == null)
            {
                Debug.Log(dog.dog_name + "is not found in Home Controller");
            }
            dogGameObject.transform.position = initPosition;
            dogGameObject.transform.rotation = Quaternion.Euler(0, y, 0);
            dogGameObject.transform.localScale = new Vector3(2, 2, 2);
            dogInScene.SetGameObject(dogGameObject);
            dogsInScene.Add(dogInScene);
        }
    }

    // 加载狗的其他组件
    IEnumerator DogComponentInstaller(DogProperty dogProperty)
    {
        // 等待一帧，确保所有 Start() 方法都执行完成
        yield return null;

        // 第一帧以后开始执行
        GameObject dog = GameObject.Find(dogProperty.dog_name);

        // 加载指定的Animator controller
        Animator animator = dog.GetComponent<Animator>();
        RuntimeAnimatorController animatorController = Resources.Load<RuntimeAnimatorController>("Dog/AnimatorController/shibaInu/HomeDogAnimatorController");
        if (dogProperty.breed == "shibaInu") { animatorController = Resources.Load<RuntimeAnimatorController>("Dog/AnimatorController/shibaInu/HomeDogAnimatorController"); }

        animator.runtimeAnimatorController = animatorController;

        // 加载Rigidbody
        Rigidbody rigidbody = dog.AddComponent<Rigidbody>();
        //Rigidbody rigidbody = dog.GetComponent<Rigidbody>();
        //rigidbody.isKinematic = true;
        rigidbody.mass = 10;
        rigidbody.linearDamping = 10;
        rigidbody.angularDamping = 10;
        //rigidbody.freezeRotation = true;
        rigidbody.constraints = RigidbodyConstraints.FreezePositionY | RigidbodyConstraints.FreezeRotation;
        rigidbody.interpolation = RigidbodyInterpolation.Interpolate;
        rigidbody.collisionDetectionMode = CollisionDetectionMode.ContinuousSpeculative;

        // 加载box collider
        BoxCollider boxCollider = dog.AddComponent<BoxCollider>();
        boxCollider.isTrigger = false;
        boxCollider.center = new Vector3(0, 0.25f, 0);
        boxCollider.size = new Vector3(0.12f, 0.45f, 0.54f);

        // 加载Particle Question Mark
        ParticleSystem questionMarkParticle = Resources.Load<ParticleSystem>("Home/Particle_QuestionMark");
        questionMarkParticle = Instantiate(questionMarkParticle);
        questionMarkParticle.name = "QuestionMarkParticle";
        questionMarkParticle.transform.SetParent(dog.transform);
        questionMarkParticle.transform.localPosition = new Vector3(0, 0.4f, 0.4f);
        questionMarkParticle.transform.localRotation = Quaternion.Euler(-90, 0, 0);
        ParticleSystem ps = questionMarkParticle.GetComponent<ParticleSystem>();
        ps.Stop();

        // 加载sleep particle
        ParticleSystem zzzParticle = Resources.Load<ParticleSystem>("Home/Particle_Z");
        zzzParticle = Instantiate(zzzParticle);
        zzzParticle.name = "zzzParticle";
        zzzParticle.transform.SetParent(dog.gameObject.transform);
        zzzParticle.transform.localPosition = new Vector3(0.05f, 0.2f, 0.2f);
        zzzParticle.transform.localRotation = Quaternion.Euler(-90, 0, 0);
        zzzParticle.gameObject.SetActive(false);        // 默认关闭

        //yield return null;
    }

    // 场景随机切换镜头看向不同的狗
    void RandomCameraChange()
    {
        int delay = 10;     // 延迟10秒执行一次
        TimeSpan ts = DateTime.Now - lastCameraChange;
        if (ts.TotalSeconds < delay) { return; }
        int dogCount = dogsInScene.Count;
        int r = UnityEngine.Random.Range(0, dogCount + 1);
        if (r < dogCount)
        {
            dogCam.m_LookAt = dogsInScene[r].gameObject.transform;
            dogCam.Priority = 10;
            playerCam.Priority = 1;
        }
        else
        {
            dogCam.Priority = 1;
            playerCam.Priority = 10;
        }
        lastCameraChange = DateTime.Now;
    }

    // 检测场景是否初始化完成
    bool SceneInitialCheck()
    {
        bool initDone = true;
        if (dogsInScene.Count == UserProperty.dogs.Count)       // 检测是否所有狗都被加载
        {
            foreach (var dog in dogsInScene)
            {
                if (dog.gameObject.GetComponent<Animator>().runtimeAnimatorController == null)
                {
                    initDone = false;
                }
            }
        }
        else
        {
            initDone = false;
        }
        //Debug.Log("Home scene initial status:"+initDone);
        return initDone;
    }

    // 计算多只狗的中心位置，用于主摄像机瞄准
    private Vector3 CenterOfDogs()
    {
        Vector3 center = Vector3.zero;
        foreach (var dog in dogsInScene)
        {
            center += dog.gameObject.transform.position;
        }
        center /= dogsInScene.Count;
        return center;
    }

    #region 语音控制区
    // 用户语音呼唤上传，Voice call指令用于呼唤所有的狗，得分最高的过来进入交互模式
    public void VoiceCallRequest(string filePath)
    {
        Debug.Log("Voice Call Post request");

        string url = "/api/voice/call/";
        WWWForm form = new();
        form.AddField("user_id", UserProperty.userId);

        // TODO 待后台开发完成后，开启网络通讯功能，目前暂用临时直接赋值
        StartCoroutine(WebController.PostRequest(url, form, filePath, callback: VoiceCallCallback));
        sceneMode = SceneMode.INACTIVE;     // 场景进入交互模式
        //isInteractMode = true;        // 场景进入交互模式
        dogsInScene[0].SetupInteract();
        interactDog = dogsInScene[0].gameObject;
        VoiceButtonOnlySwitch(true);        // 交互模式下关闭其他菜单
    }

    // 语音呼唤上传回调函数
    void VoiceCallCallback(string json)
    {
        Debug.Log("Voice call callback");
        var data = JsonConvert.DeserializeObject<Dictionary<string, object>>(json);
        if (data != null && data["status"].ToString() == "success")
        {
            // 刷新狗的数据
            string dogJson = data["dogs"].ToString();
            UserProperty.FreshDogInfo(dogJson);

            // TODO 根据返回结果设定focusdog
            float highestScore = 0;
            string highestScoreDogId = "";
            var scores = data["call Score MFCC"].ToString();
            var scoresList = JsonConvert.DeserializeObject<Dictionary<string, float>>(scores);
            foreach (var score in scoresList)
            {
                if (score.Value > highestScore)
                {
                    highestScore = score.Value;
                    highestScoreDogId = score.Key;
                }
            }

            if (highestScore >= 60)        // 60分以上才可以进入交互模式
            {
                GameData.focusDog = UserProperty.GetDogIndexById(highestScoreDogId);
                VoiceButtonOnlySwitch(true);        // 交互模式下关闭其他菜单
                foreach (var dog in dogsInScene)
                {
                    if (dog.dogProperty.d_id == highestScoreDogId)
                    {
                        if (GameTool.Random100Check(dog.dogProperty.voiceCall))
                        {
                            dog.SetupInteract();
                            interactDog = dog.gameObject;
                            // focusdog 开启互动模式
                            HomeController.dogsInScene[GameData.focusDog].dogState = DogState.INTERACT;
                            HomeController.dogsInScene[GameData.focusDog].SetupInteract();
                        }
                    }
                }
            }
            else
            {
                HomeSoundEffectController.Instance.PlaySoundEffect(4);
            }

        }
        else
        {
            Debug.Log(data["message"]);
        }
    }

    // 用户语音呼唤上传，Voice call指令用于呼唤所有的狗，得分最高的过来进入交互模式
    public void VoiceCommandRequest(string filePath)
    {
        if (sceneMode == SceneMode.INACTIVE)
        {
            Debug.Log("Voice Command Post request");

            string url = "/api/voice/command/";
            WWWForm form = new();
            form.AddField("dog_id", UserProperty.dogs[GameData.focusDog].d_id);
            form.AddField("user_id", UserProperty.userId);

            StartCoroutine(WebController.PostRequest(url, form, filePath, callback: VoiceCommandCallback));
        }
        else if (sceneMode == SceneMode.TRAINING)
        {
            Debug.Log("Voice training Post request");
            //Debug.Log("current times before ++:" + this.currentTrainingTimes.ToString());
            this.currentTrainingTimes++;
            string url = "/api/voice/training/";
            WWWForm form = new();
            form.AddField("dog_id", UserProperty.dogs[GameData.focusDog].d_id);
            form.AddField("user_id", UserProperty.userId);
            form.AddField("voice_type", trainingContent);
            form.AddField("current_times", this.currentTrainingTimes);
            //Debug.Log("current times after ++:" + this.currentTrainingTimes.ToString());
            form.AddField("total_times", totalTrainingTimes);

            StartCoroutine(WebController.PostRequest(url, form, filePath, callback: VoiceCommandCallback));
        }

    }

    // 语音呼唤上传回调函数
    void VoiceCommandCallback(string json)
    {
        if (sceneMode == SceneMode.INACTIVE)
        {
            Debug.Log("Voice command callback");
            var data = JsonConvert.DeserializeObject<Dictionary<string, object>>(json);
            if (data != null && data["status"].ToString() == "success")
            {
                // 刷新狗的数据
                string dogJson = data["dogs"].ToString();
                UserProperty.FreshDogInfo(dogJson);

                // 找到得分最高的指令
                float highestScore = 0;
                string highestScoreCommand = "";
                string scores = data["commandScoreMFCC"].ToString();
                var scoresList = JsonConvert.DeserializeObject<Dictionary<string, float>>(scores);
                foreach (var score in scoresList)
                {
                    if (score.Value > highestScore)
                    {
                        highestScore = score.Value;
                        highestScoreCommand = score.Key;
                    }
                }

                if (highestScore >= 60)
                {

                    if (GameTool.Random100Check(dogsInScene[GameData.focusDog].dogProperty.voiceCommand))
                    {
                        string animationTrigger = highestScoreCommand.Substring(5);
                        string animationBool = "is" + highestScoreCommand + "ing";
                        var animator = dogsInScene[GameData.focusDog].gameObject.GetComponent<Animator>();
                        animator.SetTrigger(animationTrigger);
                        if (animationBool != "isSiting" || animationBool != "isLieing" || animationBool != "isDieing")
                        {
                            animator.SetBool(animationBool, true);
                            dogsInScene[GameData.focusDog].interactAnimation = animationBool;
                            dogsInScene[GameData.focusDog].interactAnimationStartTime = DateTime.Now;
                        }
                    }

                }
                else
                {
                    HomeSoundEffectController.Instance.PlaySoundEffect(4);
                }
            }
            else
            {
                Debug.Log(data["message"]);
            }
        }
        else if (sceneMode == SceneMode.TRAINING)
        {
            Debug.Log("Voice training Callback");
            var data = JsonConvert.DeserializeObject<Dictionary<string, object>>(json);
            if (data != null && data["status"].ToString().ToLower() == "success")
            {
                if (data["message"].ToString().ToLower() == "pass")
                {
                    var BGM = GameObject.Find("BGM");
                    if (BGM != null)
                    {
                        //BGM.GetComponent<AudioSource>().Play();
                        FadeBGM(BGM.GetComponent<AudioSource>(), true);
                    }
                    // TODO 刷新狗的数据
                    string dogJson = data["dogs"].ToString();
                    UserProperty.FreshDogInfo(dogJson);

                    string msg = GameTool.GetValueAtPath(EnviromentSetting.languageData, new string[] { "game_message", trainingContent + "_10", EnviromentSetting.languageCode });
                    Time.timeScale = 0f;
                    foreach (var dog in dogsInScene)
                    {
                        if (dog.dogProperty.d_id == trainingDogId)
                        {
                            dog.ExitInteract();
                        }
                    }
                    MessageBoxController.ShowMessage(msg, ResetTrainingModeParameters);
                    this.sceneMode = SceneMode.NORMAL;

                    GameData.isVoiceTrainingToday = true;        // 训练完成，设置为true
                    string todayDate = System.DateTime.Now.ToString("yyyy-MM-dd");
                    PlayerPrefs.SetString("lastTrainingDate", todayDate);
                    PlayerPrefs.Save();

                }
                else if (data["message"].ToString() == "fail")
                {
                    HomeSoundEffectController.Instance.PlaySoundEffect(4);

                    string msg = GameTool.GetValueAtPath(EnviromentSetting.languageData, new string[] { "game_message", trainingContent + "_20", EnviromentSetting.languageCode });
                    Time.timeScale = 0f;
                    MessageBoxController.ShowMessage(msg, RestartTraining);
                }
            }
            else
            {
                Debug.Log(data["message"]);
            }
        }
    }

    #endregion

    #region interact mode

    // 重置training相关参数
    private void ResetTrainingModeParameters()
    {
        //isTrainingMode = false;
        trainingContent = String.Empty;
        totalTrainingTimes = 2;
        currentTrainingTimes = 0;
        trainingDogId = "";
        isTrainingMsgShowed_1 = false;
        isTrainingMsgShowed_2 = false;
        Debug.Log("Reset Training Mode Parameters");
        Time.timeScale = 1f;
    }

    private void RestartTraining()
    {
        currentTrainingTimes = 0;
        isTrainingMsgShowed_1 = false;
        isTrainingMsgShowed_2 = false;
        Time.timeScale = 1f;
    }

    // 改变Voice And Menu 菜单形态
    public void VoiceButtonOnlySwitch(bool state)
    {
        // 交互时候关闭其他菜单
        var vamUI = GameObject.Find("VoiceAndMenu");
        if (vamUI != null)
        {
            var UIdocument = vamUI.transform.Find("UIDocument").gameObject;
            var voiceController = UIdocument.GetComponent<VoiceController>();
            voiceController.isCommandMode = state;
        }
    }

    // 检测是否点击在狗上
    void PointerOnDog()
    {
        //DetectTouchMethod();

        // 检查当前指针是否有效
        if (Pointer.current == null) return;

        // 获取当前指针的悬浮位置
        Vector2 pointerPosition = Pointer.current.position.ReadValue();
        var mainCamera = GameObject.Find("Camera").GetComponent<Camera>();
        Ray ray = mainCamera.ScreenPointToRay(pointerPosition);
        if (Physics.Raycast(ray, out RaycastHit hit))
        {
            //Debug.Log($"Clicked on: {hit.collider.gameObject.name}");
            // 射线检测起始点击是否在狗上
            if (hit.collider.gameObject == interactDog)
            {
                if (previousPointerPosition != pointerPosition)
                {
                    interactTime += Time.deltaTime;
                    Debug.Log("interactTime:" + interactTime);
                    foreach (var dog in dogsInScene)
                    {
                        if (dog.gameObject == interactDog)
                        {
                            dog.interactLastUpdate = DateTime.Now;
                        }
                    }
                    previousPointerPosition = pointerPosition;
                }
            }
            if (interactTime > 3)        // 如果交互时间超过1秒，播放心形粒子效果
            {
                HeartParticlePlay();
                var animation = interactDog.GetComponent<Animator>();
                animation.SetTrigger("Hug");
            }
        }
    }

    void HeartParticlePlay()
    {
        // 播放心形粒子效果
        var heartParticle = GameObject.Find("Particle Heart");
        heartParticle.GetComponent<ParticleSystem>().Play();
        interactTime = 0;
    }

    #endregion

    #region 场景环境控制
    // 淡入或淡出背景音乐
    private void FadeBGM(AudioSource bgmSource, bool fadeIn, float duration = 2f)
    {
        // fadeIn: true表示淡入 false表示淡出
        if (bgmSource == null) return; // 如果没有 AudioSource，则直接返回
        StartCoroutine(FadeBGMCoroutine(bgmSource, fadeIn, duration));
    }

    private IEnumerator FadeBGMCoroutine(AudioSource bgmSource, bool fadeIn, float duration)
    {
        float elapsedTime = 0f;
        float startVolume = bgmSource.volume;
        float targetVolume = fadeIn ? 1f : 0f; // 淡入目标音量为1，淡出目标音量为0

        while (elapsedTime < duration)
        {
            bgmSource.volume = Mathf.Lerp(startVolume, targetVolume, elapsedTime / duration);
            elapsedTime += Time.deltaTime;
            yield return null;
        }

        bgmSource.volume = targetVolume; // 确保音量达到目标值

        if (!fadeIn)
        {
            bgmSource.Stop(); // 如果是淡出，停止播放
        }
    }
    #endregion
}

public enum ItemGroup
{
    food,
    water
}

enum SceneMode
{
    TRAINING,
    INACTIVE,
    NORMAL,
}