PuppyClient/Assets/Scripts/Home/DogInScene.cs

using System;
using System.Collections;
using UnityEngine;
//using UnityEngine.Rendering.PostProcessing;

/* 本类用于管理场景中所有狗的状态包括动画状态，随机数分配等
 */

//[CreateAssetMenu(fileName = "DogInScene", menuName = "Scriptable Objects/DogInScene")]
public class DogInScene //: ScriptableObject
{
    //通用参数段
    public DogProperty dogProperty;
    public GameObject gameObject { set; get; }
    public Animator animator;
    public Vector3 moveToLocation;
    public float moveSpeed;     // 用来控制狗的移动速度 0 0.5跑，0.75快跑，1跳
    //public string dogState;       // 狗的状态代码分类通道，包括三大类使用道具(itemConsume),闲置(idle),训练（training),自由活动（interact)等
    public DogState dogState = DogState.IDLE;

    // 喝水吃饭参数段
    public DateTime drinkStartTime, eatStartTime;      // 记录吃喝开始时间
    public bool itemConsumeProgress = false;     // 是否在吃和喝的进程中。如果是的话，跳过常规动画检测
    public bool isMovingToBowl;
    private float shortIntakeTime = 0.5f;      // 喝水和吃饭的短时间间隔，单位秒。当宠物吃饱喝足时候调用。
    private float longIntakeTime = 10f;       // 喝水和吃饭的长时间间隔，单位秒。当宠物没有吃饱喝足时候调用。



    // 随机动作参数段
    public int randomFactor;
    public DateTime animationStartTime;     // 记录上一个动画开始时间的，每个随机动作间隔至少30秒
    private int activeIndex;      // 动物的活动指数
    public bool isMoving;       // 动物正在移动，避免其他随机动作发生
    public bool isSleeping;       // 动物正在正在睡觉，避免触发其他动画

    // 固定参数
    private const float moveSpeedAdj = 0.025f;

    // interact training 相关的参数
    public DateTime interactLastUpdate;     // 上次交互指令时间
    public bool isMovingToPlayer;      // 是否在向玩家移动
    public string interactAnimation = "";        // 交互动画
    public DateTime interactAnimationStartTime;        // 交互动画开始时间

    #region 通用函数段

    // 这个函数主要是为了在狗的属性发生变化时，重新加载狗的属性
    public void ReloadDogProperty()
    {
        foreach (var dog in UserProperty.dogs)
        {
            if (dog.d_id == dogProperty.d_id)
            {
                this.dogProperty = dog;
                break;
            }
        }
    }
    public void SetGameObject(GameObject gameObject)
    {
        this.gameObject = gameObject;
        this.animator = gameObject.GetComponent<Animator>();
        this.randomFactor = UnityEngine.Random.Range(0, 51);        // 生成一个随机整数（0 到 50 之间），用于时间校验
        Debug.Log(this.gameObject.name + "random factor is:" + randomFactor);
    }


    public DogInScene(DogProperty property)
    {
        this.dogProperty = property;
        this.activeIndex = (int)Math.Round((property.liveliness + property.intimate) * UnityEngine.Random.Range(0.01f, 0.5f));
        this.isMoving = false;
    }

    public void RemoveZzzParticle()
    {
        // 关闭狗的睡觉粒子特效
        var zzzParticle = gameObject.transform.Find("zzzParticle").gameObject;
        if (zzzParticle != null)
        {
            zzzParticle.SetActive(false);
        }
    }

    // 关闭所有animation动画的状态，回到默认的状态
    public void ResetAnimationStatus()
    {

        // 获取所有参数
        AnimatorControllerParameter[] parameters = animator.parameters;
        foreach (AnimatorControllerParameter parameter in parameters)
        {
            if (parameter.type == AnimatorControllerParameterType.Bool)
            {
                animator.SetBool(parameter.name, false);
            }
        }
    }

    bool IsPlayingAnimation(string stateName)
    {
        // 获取当前动画状态信息
        AnimatorStateInfo stateInfo = animator.GetCurrentAnimatorStateInfo(0); // 参数 0 表示第一个动画层
        // 检查当前状态是否是目标状态，并且是否正在播放
        return stateInfo.IsName(stateName) && stateInfo.normalizedTime < 1.0f;
    }
    #endregion

    #region interact交互函数段
    // 启动交互行为准备过程
    public void SetupInteract()
    {
        Debug.Log("SetupInteract:" + this.gameObject.name);
        HomeController.Instance.SetDogsIsTrigger(false);
        DogBarkController.Instance.PlayDogBarkWithDelay(3);    // 狗叫相应一下
        RemoveZzzParticle();       // 关闭睡觉粒子特效
        if (dogProperty.voiceCall == 10)
        {
            // GameData.isFirstInteraction = false;
            PlayerPrefs.SetString("isFirstInteraction", "false");
            PlayerPrefs.Save();
            GameTool.PauseGameTime();
            string msg = GameTool.GetValueAtPath(EnviromentSetting.languageData, new string[] { "game_message", "first_touch_interactive", EnviromentSetting.languageCode });
            if (msg.Contains("<<dog_name>>"))
            {
                msg = msg.Replace("<<dog_name>>", dogProperty.dog_name);
            }
            MessageBoxController.ShowMessage(msg, () => GameTool.ResumeGameTime());

        }
        // 加载Interact animator controller,避免过于复杂的Animator Controller
        Animator animator = gameObject.GetComponent<Animator>();
        RuntimeAnimatorController animatorController = Resources.Load<RuntimeAnimatorController>(DogBreedController.GetDogAnimationController(dogProperty.breed, "home_interact"));
        animator.runtimeAnimatorController = animatorController;

        float randomIndex = UnityEngine.Random.Range(0, 1f);
        animator.SetFloat("randomIndex", randomIndex);

        //this.dogState = "interact";
        this.dogState = DogState.INTERACT;       // 设置狗的状态为交互状态
        this.interactLastUpdate = DateTime.Now;
        this.moveToLocation = new Vector3(0f, 0f, -3f);
        this.isMovingToPlayer = true;

        // 如果狗距离超出一定范围才开始移动
        float distance = Vector3.Distance(gameObject.transform.position, moveToLocation);
        Debug.Log(this.gameObject.name + "interact move to player distance:" + distance);
        if (distance > 2.5f)
        {
            this.animator.SetTrigger("move");       // 切换为走路动画
            this.animator.SetBool("isMoving", true);        // 保持为走路动画
            this.animator.SetFloat("moveSpeed", 0.5f);
        }
        else
        {
            this.animator.SetBool("isMoving", false);
            this.gameObject.transform.LookAt(new Vector3(0f, 1f, -8f));
            this.isMovingToPlayer = false;
        }

    }
    public void MovetoPlayer()
    {

        // 如果距离目标小于0.5米就把速度调整为零
        if (Vector3.Distance(moveToLocation, this.gameObject.transform.position) < 0.5f)
        {
            Debug.Log(this.gameObject.name + "current move speed:" + moveSpeed);
            this.SetMoveSpeed(0);
            Debug.Log(this.gameObject.name + "reduce move speed:" + moveSpeed);
        }

        // 如果狗距离到达重点就停止跑步动画
        float distance = Vector3.Distance(gameObject.transform.position, moveToLocation);
        //Debug.Log(this.gameObject.name + "interact move to player distance:" + distance);
        if (distance > 2.5f)      // 一定距离内就开始停下来，否则刹不住
        {
            this.gameObject.transform.LookAt(moveToLocation);
            this.gameObject.transform.position = Vector3.MoveTowards(gameObject.transform.position, moveToLocation, dogProperty.runSpeed * (1 + moveSpeed) * 0.02f * moveSpeedAdj);  // 第一个0.02对应50帧fixupdate画面，后面一个数字对应速度调整，对应RM动画.position = Vector3.MoveTowards(gameObject.transform.position, moveToLocation, dogProperty.runSpeed * (1 + moveSpeed) * 0.02f * moveSpeedAdj);  // 第一个0.02对应50帧fixupdate画面，后面一个数字对应速度调整，对应RM动画
        }
        else
        {
            this.animator.SetBool("isMoving", false);
            this.gameObject.transform.LookAt(new Vector3(0f, 1f, -8f));
            this.isMovingToPlayer = false;
        }
    }

    // 交互行为计时器
    public bool InteractTimeout()
    {

        TimeSpan ts = new TimeSpan();
        ts = DateTime.Now - this.interactLastUpdate;
        if (ts.TotalSeconds > 10)
        {
            Debug.Log("InteractTimeout:" + this.gameObject.name);
            //this.dogState = "idle";
            this.dogState = DogState.IDLE;
            return true;
        }
        else { return false; }
    }

    // 交互动画行为计时器（暂时设定为6秒）
    public IEnumerator InteractAnimationCountDown()
    {

        TimeSpan ts = new TimeSpan();
        ts = DateTime.Now - this.interactAnimationStartTime;
        if (ts.TotalSeconds < EnviromentSetting.interactTimeoutSec)
        {
            yield return new WaitForSeconds(0.25f);
        }
        else
        {
            Debug.Log("InteractAnimation count down stop:" + this.gameObject.name);
            this.ResetAnimationStatus();
        }
    }

    public void ExitInteract()
    {

        // 结束交互行为，恢复原有的菜单
        this.dogState = DogState.IDLE;
        HomeController.Instance.SetDogsIsTrigger(true);
        // 恢复场景idle对应的Animator Controller
        Animator animator = gameObject.GetComponent<Animator>();
        RuntimeAnimatorController animatorController = Resources.Load<RuntimeAnimatorController>(DogBreedController.GetDogAnimationController(dogProperty.breed, "home_default"));
        animator.runtimeAnimatorController = animatorController;
        this.RandomMove();
    }

    // 狗播放问号的表情
    public void PlayQuestionMark()
    {
        var questionMark = gameObject.transform.Find("QuestionMarkParticle").gameObject;
        if (questionMark != null)
        {
            var particleQuestionMark = questionMark.GetComponent<ParticleSystem>();
            if (particleQuestionMark != null && !particleQuestionMark.isPlaying)
            {
                particleQuestionMark.Play();
            }
        }
    }
    #endregion

    #region 随机动作控制函数
    // 随机选择宠物动作
    public void IdleAnimation()
    {
        this.animationStartTime = DateTime.Now;
        this.animator.SetInteger("activeIndex", activeIndex);
        //Debug.Log("activeIndex:" + this.activeIndex);
        float randomIndex = UnityEngine.Random.Range(0, 1f);
        this.animator.SetFloat("randomIndex", randomIndex);
        //this.dogState = "idle";
        this.dogState = DogState.IDLE;
        //Debug.Log("randomIndex:" + randomIndex);
    }

    public void SetMoveSpeed(float speed)
    {
        this.moveSpeed = speed;
    }

    // 宠物随机移动
    public void RandomMove()
    {
        //this.animator.SetBool("isMoving", true);
        // 如果距离目标小于0.5米就把速度调整为零
        if (Vector3.Distance(moveToLocation, this.gameObject.transform.position) < 0.5f)
        {
            //Debug.Log(this.gameObject.name + "current move speed:" + moveSpeed);
            this.SetMoveSpeed(0);
            //Debug.Log(this.gameObject.name + "reduce move speed:" + moveSpeed);
        }

        if (isMoving == false)
        {
            animationStartTime = DateTime.Now;      // 设置动画开始时间
            float x = UnityEngine.Random.Range(-5f, 5f);
            float z = UnityEngine.Random.Range(0f, 5f);
            this.moveToLocation = new Vector3(x, 0, z);
            //Debug.Log("move to location:" + x + ", " + z);
            this.isMoving = true;
            //this.animator.SetTrigger("move");
            this.animator.SetBool("isMoving", true);
            animator.Play("move");
            this.animator.SetFloat("moveSpeed", this.moveSpeed);
        }
        if (this.animator.GetBool("isMoving"))
        {
            this.gameObject.transform.LookAt(moveToLocation);
            this.gameObject.transform.position = Vector3.MoveTowards(gameObject.transform.position, moveToLocation, dogProperty.runSpeed * (1 + moveSpeed) * 0.02f * moveSpeedAdj);  // 第一个0.02对应50帧fixupdate画面，后面一个数字对应速度调整，对应RM动画
        }


        // 如果狗距离到达重点就停止跑步动画
        float distance = Vector3.Distance(gameObject.transform.position, moveToLocation);
        if (distance < 0.1)
        {
            this.animator.SetBool("isMoving", false);
            //this.moveSpeed = 0.4f;
            this.isMoving = false;
            IdleAnimation();
        }
    }

    public void Sleep()
    {
        this.animator.SetTrigger("sleep");
        this.animator.SetBool("isSleeping", true);
        this.isSleeping = true;
        //this.dogState = "sleep";
        this.dogState = DogState.SLEEP;
        var zzzParticle = gameObject.transform.Find("zzzParticle").gameObject;
        if (zzzParticle != null)
        {
            zzzParticle.SetActive(true);
        }
    }

    public void Listen()
    {
        //StopCoroutine(movingCoroutine);
        //this.animator.SetTrigger("listen");
        ResetAnimationStatus();
        this.animator.SetBool("isListening", true);
        animator.Play("base");
        this.isSleeping = false;     // 主人呼叫可以唤醒狗
        this.gameObject.transform.LookAt(new Vector3(0, 0, -6));
        HomeController.playerCam.Priority = 10;
        HomeController.dogCam.Priority = 1;
        HomeController.lastCameraChange = DateTime.Now;
        //this.dogState = "listen";
        this.dogState = DogState.LISTEN;
    }

    public IEnumerator RotationToPlayerAndListen()
    {
        //计算自己方向和player之间连线的夹角
        float rotationSpeed = 60f;
        float stopAngle = 15f;      // 旋转最小角度，小于这个角度就不旋转
        Vector3 virtualLookAtTarget = new Vector3(0, 0, -6);
        Vector3 direction = virtualLookAtTarget - this.gameObject.transform.position;
        float targetAngle = Vector3.SignedAngle(this.gameObject.transform.forward, direction, Vector3.up);      // 目标旋转角度
        if (MathF.Abs(targetAngle) <= stopAngle)
        {
            // 旋转角度小于指定度就不旋转
            Listen();
            yield break;
        }
        else
        {
            if (targetAngle > 0)
            {
                // 逆时针旋转
                this.animator.SetBool("isTurningLeft", true);
                if (IsPlayingAnimation("turn Left") == false)
                {
                    this.animator.Play("turn Left");
                }
                this.gameObject.transform.Rotate(0, rotationSpeed * Time.deltaTime, 0);
            }
            else
            {
                // 顺时针旋转
                this.animator.SetBool("isTurningRight", true);
                if (IsPlayingAnimation("turn Right") == false)
                {
                    this.animator.Play("turn Right");
                }
                this.gameObject.transform.Rotate(0, -rotationSpeed * Time.deltaTime, 0);
            }
        }
        while (true)
        {
            yield return new WaitForSeconds(0.1f);
            // 再次计算夹角
            direction = virtualLookAtTarget - this.gameObject.transform.position;
            targetAngle = Vector3.SignedAngle(this.gameObject.transform.forward, direction, Vector3.up);      // 目标旋转角度
            // Debug.Log("target angle:" + targetAngle);
            if (MathF.Abs(targetAngle) <= stopAngle)
            {
                this.animator.SetBool("isTurningLeft", false);
                this.animator.SetBool("isTurningRight", false);
                Listen();
                yield break;
            }
            else
            {
                if (targetAngle > 0)
                {
                    // 逆时针旋转
                    this.gameObject.transform.Rotate(0, rotationSpeed * Time.deltaTime, 0);
                }
                else
                {
                    // 顺时针旋转
                    this.gameObject.transform.Rotate(0, -rotationSpeed * Time.deltaTime, 0);
                }
            }
        }
    }

    #endregion

    #region 喝水，吃食等道具消费函数
    // 开始整个使用道具的流程
    public void StartItemConsume(ItemGroup group)
    {
        RemoveZzzParticle();       // 关闭睡觉粒子特效
        GameObject bowl = GameObject.Find("Bowl_water");        // 先指定一个碗，编译通过
        BoxCollider boxCollider = gameObject.GetComponent<BoxCollider>();       // 喝水吃饭场景关闭isTrigger
        boxCollider.isTrigger = false;

        this.itemConsumeProgress = true;        // 开启使用道具过程
        //this.dogState = "itemConsume";
        this.dogState = DogState.ITEM_CONSUME;

        if (group == ItemGroup.WATER)
        {
            bowl = GameObject.Find("Bowl_water");       // 开启整个喝水的进程
        }
        if (group == ItemGroup.FOOD)
        {
            bowl = GameObject.Find("Bowl_food");        // 开启整个吃食物的进程
        }

        this.moveToLocation = bowl.transform.position;
        this.isMovingToBowl = true;
        this.animator.SetTrigger("move");       // 切换为走路动画
        this.animator.SetBool("isMoving", true);        // 保持为走路动画
        this.animator.SetFloat("moveSpeed", this.moveSpeed);

    }

    public void MovetoBowl()
    {

        // 如果距离目标小于0.5米就把速度调整为零
        if (Vector3.Distance(moveToLocation, this.gameObject.transform.position) < 0.5f)
        {
            Debug.Log(this.gameObject.name + "current move speed:" + moveSpeed);
            this.SetMoveSpeed(0);
            Debug.Log(this.gameObject.name + "reduce move speed:" + moveSpeed);
        }

        var vamUI = GameObject.Find("VoiceAndMenu");
        if (vamUI != null)
        {
            vamUI.SetActive(false);
        }
        this.gameObject.transform.LookAt(moveToLocation);
        this.gameObject.transform.position = Vector3.MoveTowards(gameObject.transform.position, moveToLocation, dogProperty.runSpeed * (1 + moveSpeed) * 0.02f * moveSpeedAdj);  // 第一个0.02对应50帧fixupdate画面，后面一个数字对应速度调整，对应RM动画
        //this.gameObject.transform.position = Vector3.MoveTowards(gameObject.transform.position, moveToLocation, (100+dogProperty.runSpeed) * (1 + moveSpeed) * 0.02f * 0.015f);  // 第一个0.02对应50帧fixupdate画面，后面一个数字对应速度调整，对应IF动画
        //Debug.Log("current position:" + gameObject.transform.position.x + "z:" + gameObject.transform.position.z);

        // 如果狗距离到达重点就停止跑步动画
        float distance = Vector3.Distance(gameObject.transform.position, moveToLocation);
        if (distance < 0.1)
        {
            this.animator.SetBool("isMoving", false);
        }
    }

    public IEnumerator DrinkAnimation()

    {
        this.animator.SetBool("isMoving", false);       // 关闭移动动画
        TimeSpan ts = new TimeSpan();
        var targetBowl = GameObject.Find("Bowl_water");


        // 摄像头看向水盆位置
        HomeController.dogCam.m_LookAt = targetBowl.transform;
        HomeController.dogCam.Priority = 10;
        HomeController.playerCam.Priority = 1;

        float intakeTime;
        if (dogProperty.thirsty >= 90)
        {
            intakeTime = shortIntakeTime;      // 如果狗口渴程度大于90，喝水时间为短时间
        }
        else
        {
            intakeTime = longIntakeTime;       // 否则喝水时间为长时间
        }
        while (ts.TotalSeconds < intakeTime)
        {
            yield return new WaitForSeconds(0.25f);
            ts = DateTime.Now - this.drinkStartTime;
            //Debug.Log("结束饮水过程:" + ts.TotalSeconds);

            // 狗一致看向碗，确保就算被撞击后依然看向碗
            this.gameObject.transform.LookAt(targetBowl.transform.position);
        }
               // 结束吃狗粮动画
        this.animator.SetBool("isEating", false);
        itemConsumeProgress = false;      // 关闭整个道具使用的进程
        dogState = DogState.IDLE;
        QuitItemConsume();

        if (!HomeController.Instance.isHideBowlRunning)
        {
            HomeController.Instance.StartCoroutine(HomeController.Instance.HideBowlAfterItemConsume(ItemGroup.WATER));       // 启动碗隐藏的协程
        }
    }

    public IEnumerator EatAnimation()
    {
        this.animator.SetBool("isMoving", false);       // 关闭移动动画
        TimeSpan ts = new TimeSpan();
        var targetBowl = GameObject.Find("Bowl_food");


        // 摄像头看向盆位置
        HomeController.dogCam.m_LookAt = targetBowl.transform;
        HomeController.dogCam.Priority = 10;
        HomeController.playerCam.Priority = 1;

        float intakeTime;
        if (dogProperty.satiety >= 90)
        {
            intakeTime = shortIntakeTime;      // 如果狗饱腹程度大于90，喝水时间为短时间
        }
        else
        {
            intakeTime = longIntakeTime;       // 否则喝水时间为长时间
        }
        while (ts.TotalSeconds < intakeTime)
        {
            yield return new WaitForSeconds(0.25f);
            ts = DateTime.Now - this.eatStartTime;

            // 狗一致看向碗，确保就算被撞击后依然看向碗
            this.gameObject.transform.LookAt(targetBowl.transform.position);
        }
        // 结束吃狗粮动画
        this.animator.SetBool("isEating", false);
        itemConsumeProgress = false;      // 关闭整个道具使用的进程
        dogState = DogState.IDLE;
        QuitItemConsume();

        if (!HomeController.Instance.isHideBowlRunning)
        {
            HomeController.Instance.StartCoroutine(HomeController.Instance.HideBowlAfterItemConsume(ItemGroup.FOOD));       // 启动碗隐藏的协程
        }
    }

    public void QuitItemConsume()
    {
        // var uiPlaceholder = GameObject.Find("UI Placeholder");
        // var vamUI = uiPlaceholder.transform.Find("VoiceAndMenu").gameObject;
        // vamUI.SetActive(true);
        BoxCollider boxCollider = gameObject.GetComponent<BoxCollider>();       // 喝水吃饭场景关闭isTrigger
        boxCollider.isTrigger = true;
        this.moveSpeed = UnityEngine.Random.Range(0.3f, 0.6f);
        RandomMove();
    }

    #endregion

}

// Change the accessibility of the DogState enum to public to match the accessibility of the field "dog_state".
public enum DogState
{
    ITEM_CONSUME,
    IDLE,
    TRAINING,
    INTERACT,
    SLEEP,
    LISTEN
}