GHZMRSpace/Assets/Studio/_4ShowScene/PlayerFunctionModule/Scripts/PlayerContainer.cs

using SC.XR.Unity.Module_InputSystem;
using ShadowStudio.Tool;
using ShadowStudio.UI;
using System;
using System.Collections;
using System.Collections.Generic;
using UnityEngine;
using XRTool.Util;

namespace ShadowStudio.Model
{
    /// <summary>
    /// 用户角色同步
    /// </summary>
    public class PlayerContainer : GoodsComponen
    {
        public static string userArtId = "ArtId_GamePlayer";
        public static string containerName = "PlayerContainer";
        private Peer user;
        private TextMesh nameLable;
        private PlayerAnimatorController playerAnimator;
        private Transform leftHandTarget;
        private Transform rightHandTarget;
        private Transform playerRoot;
        private bool leftActive = false;
        private bool rightActive = false;
        private Transform containerTransfer;
        public TextMesh NameLable
        {
            get
            {
                if (!nameLable)
                {
                    nameLable = UnityUtil.GetBreadthChild<TextMesh>(transform, "NameLable");
                }
                return nameLable;
            }
        }

        public PlayerAnimatorController PlayerAnimator
        {
            get
            {
                if (!playerAnimator)
                {
                    playerAnimator = GetComponentInChildren<PlayerAnimatorController>();
                }
                return playerAnimator;
            }
        }

        public Transform PlayerRoot
        {
            get
            {
                if (!playerRoot)
                {
                    playerRoot = UnityUtil.GetBreadthChild<Transform>(transform, "PlayerRoot");
                }
                return playerRoot;
            }
        }

        public Transform LeftHandTarget
        {
            get
            {
                if (!leftHandTarget)
                {
                    leftHandTarget = UnityUtil.GetBreadthChild<Transform>(transform, "LeftHandTarget");
                }
                return leftHandTarget;
            }
        }
        public Transform RightHandTarget
        {
            get
            {
                if (!rightHandTarget)
                {
                    rightHandTarget = UnityUtil.GetBreadthChild<Transform>(transform, "RightHandTarget");
                }
                return rightHandTarget;
            }
        }
        public override void SetContainer(ArtContainerHandler container, UnityEngine.Object art, ArtInfo info)
        {
            base.SetContainer(container, art, info);

            if (art is GameObject && PlayerRoot)
            {
                GameObject obj = art as GameObject;
                UnityUtil.SetParent(PlayerRoot, obj.transform);
            }
            containerTransfer = Container.transform;
        }

        private void Start()
        {
            StartCoroutine(SynUser());
        }

        private IEnumerator SynUser()
        {
            while (user == null)
            {
                yield return new WaitForFixedUpdate();
            }
            if (NameLable)
            {
                NameLable.text = user.NickName;
            }
            //if (PlayerAnimator)
            //{
            //    PlayerAnimator.SetHands(LeftHandTarget, RightHandTarget);
            //}
            if (user.PeerId == CommonMethod.MyPeer.PeerId)
            {
                DispatcherBase.KeyDownDelegateRegister(OnKeyDownAction);
                DispatcherBase.KeyUpDelegateRegister(OnKeyUpAction);
                if (PlayerAnimator)
                {
                    PlayerAnimator.gameObject.SetActive(false);
                }
                if (NameLable)
                    NameLable.gameObject.SetActive(false);
                Container.data.art_id = user.PeerId;
                Container.data.id = 0;
                Container.data.goods_name = user.NickName;
                Container.data.goods_info = UnityUtil.TransferToString(containerTransfer, 2);
                containerTransfer = Container.transform;
                GameSession.Instance.ReSetBodyForward();
                while (user != null)
                {
                    containerTransfer.position = GameSession.Instance.gameHead.position;
                    containerTransfer.forward = GameSession.Instance.BodyForward;
                    if (PlayerAnimator)
                    {
                        //PlayerAnimator.playerHead.forward = GameSession.Instance.gameHead.forward;
                        PlayerAnimator.playerHead.rotation = GameSession.Instance.gameHead.rotation;
                        Vector3 leftpos;
                        Quaternion leftRot;
                        if (leftActive = GameSession.Instance.TryHandLeftPosition(out leftpos, out leftRot))
                        {
                            if (!PlayerAnimator.HandLeft.gameObject.activeSelf)
                            {
                                PlayerAnimator.HandLeft.gameObject.SetActive(true);
                            }
                            PlayerAnimator.HandLeft.position = leftpos;
                            PlayerAnimator.HandLeft.rotation = leftRot;
                        }
                        else
                        {
                            if (PlayerAnimator.HandLeft.gameObject.activeSelf)
                            {
                                PlayerAnimator.HandLeft.gameObject.SetActive(false);
                            }
                        }
                        Vector3 rightpos;
                        Quaternion rightRot;
                        if (rightActive = GameSession.Instance.TryHandRightPosition(out rightpos, out rightRot))
                        {
                            if (!PlayerAnimator.HandRight.gameObject.activeSelf)
                            {
                                PlayerAnimator.HandRight.gameObject.SetActive(true);
                            }
                            PlayerAnimator.HandRight.position = rightpos;
                            PlayerAnimator.HandRight.rotation = rightRot;
                        }
                        else
                        {
                            if (PlayerAnimator.HandRight.gameObject.activeSelf)
                            {
                                PlayerAnimator.HandRight.gameObject.SetActive(false);
                            }
                        }
                    }
                    if (!ArtInfoMgr.Instance.IsSingleMan())
                    {
                        SendTransfer(2, (int)TransferState.Over);
                    }
                    yield return new WaitForFixedUpdate();
                }
            }
        }

        private void OnKeyUpAction(InputKeyCode keyCode, InputDevicePartBase part)
        {
            if (part.PartType == InputDevicePartType.HandLeft)
            {
                if (PlayerAnimator)
                {
                    PlayerAnimator.LeftHandState = 0;
                }
            }
            else if (part.PartType == InputDevicePartType.HandRight)
            {
                if (PlayerAnimator)
                {
                    PlayerAnimator.RightHandState = 0;
                }
            }
        }

        private void OnKeyDownAction(InputKeyCode keyCode, InputDevicePartBase part)
        {
            if (part.PartType == InputDevicePartType.HandLeft)
            {
                if (PlayerAnimator)
                {
                    PlayerAnimator.LeftHandState = 1;
                }
            }
            else if (part.PartType == InputDevicePartType.HandRight)
            {
                if (PlayerAnimator)
                {
                    PlayerAnimator.RightHandState = 1;
                }
            }
        }
        private void OnDestroy()
        {
            DispatcherBase.KeyDownDelegateUnRegister(OnKeyDownAction);
            DispatcherBase.KeyUpDelegateUnRegister(OnKeyUpAction);
        }

        /// <summary>
        /// 设置同步
        /// </summary>
        /// <param name="state"></param>
        /// <param name="status"></param>
        public override void SendTransfer(int state, int status)
        {
            //var data = Container.data;
            if (PlayerAnimator)
            {
                Container.data.goods_extended = UnityUtil.QuaterToString(PlayerAnimator.playerHead.localRotation) + "!";
                if (leftActive)
                {
                    Container.data.goods_extended += UnityUtil.TransferToString(PlayerAnimator.HandLeft, 2);
                }
                Container.data.goods_extended += "!";
                if (rightActive)
                {
                    Container.data.goods_extended += UnityUtil.TransferToString(PlayerAnimator.HandRight, 2);
                }
                Container.data.status = 10 * PlayerAnimator.LeftHandState + PlayerAnimator.RightHandState;
            }
            base.SendTransfer(2, state);
            //data.goods_info = UnityUtil.TransferToString(containerTransfer, state);
            //ArtInfoMgr.Instance.SendTransfer(data);
        }

        public override void TransferSyn(GoodsInfo goods, bool smooth = true)
        {
            float smoothTween = Container.smoothTween;
            //base.TransferSyn(goods, smooth);
            Posture posture = UnityUtil.GetPosture(goods.goods_info);
            containerTransfer.localPosition = Vector3.Lerp(containerTransfer.localPosition, posture.position, (Time.deltaTime * smoothTween));
            Quaternion q = Quaternion.Euler(posture.angle);
            containerTransfer.localRotation = Quaternion.Lerp(containerTransfer.localRotation, q, (Time.deltaTime * smoothTween));

            if (PlayerAnimator && !string.IsNullOrEmpty(goods.goods_extended))
            {
                string[] exts = goods.goods_extended.Split('!');
                Quaternion rot = UnityUtil.StringToQuater(exts[0]);
                if (!string.IsNullOrEmpty(exts[1]))
                {
                    Posture left = UnityUtil.GetPosture(exts[1]);
                    if (!PlayerAnimator.HandLeft.gameObject.activeSelf)
                    {
                        PlayerAnimator.HandLeft.gameObject.SetActive(true);
                    }
                    Quaternion leftRot = Quaternion.Euler(left.angle);
                    PlayerAnimator.HandLeft.localRotation = Quaternion.Lerp(PlayerAnimator.HandLeft.localRotation, leftRot,
                    (Time.deltaTime * smoothTween));
                    {
                        PlayerAnimator.HandLeft.localPosition = Vector3.Lerp(PlayerAnimator.HandLeft.localPosition, left.position,
                            (Time.deltaTime * smoothTween));
                    }
                }
                else
                {
                    if (PlayerAnimator.HandLeft.gameObject.activeSelf)
                    {
                        PlayerAnimator.HandLeft.gameObject.SetActive(false);
                    }
                }
                if (!string.IsNullOrEmpty(exts[2]))
                {
                    Posture right = UnityUtil.GetPosture(exts[2]);
                    if (!PlayerAnimator.HandRight.gameObject.activeSelf)
                    {
                        PlayerAnimator.HandRight.gameObject.SetActive(true);
                    }
                    Quaternion rightRot = Quaternion.Euler(right.angle);
                    PlayerAnimator.HandRight.localRotation = Quaternion.Lerp(PlayerAnimator.HandRight.localRotation, rightRot,
                    (Time.deltaTime * smoothTween));
                    {
                        PlayerAnimator.HandRight.localPosition = Vector3.Lerp(PlayerAnimator.HandRight.localPosition, right.position,
                            (Time.deltaTime * smoothTween));
                    }
                }
                else
                {
                    if (PlayerAnimator.HandRight.gameObject.activeSelf)
                    {
                        PlayerAnimator.HandRight.gameObject.SetActive(false);
                    }
                }

                PlayerAnimator.playerHead.localRotation = Quaternion.Lerp(PlayerAnimator.playerHead.localRotation, rot,
                    (Time.deltaTime * smoothTween));
                if (PlayerAnimator.HandLeft.gameObject.activeSelf)
                {
                    PlayerAnimator.LeftHandState = (goods.status / 10) >= 1 ? 1 : 0;
                }
                if (PlayerAnimator.HandRight.gameObject.activeSelf)
                {
                    int rightState = goods.status % 10;
                    PlayerAnimator.RightHandState = rightState >= 1 ? 1 : 0;
                }
            }
        }
        /// <summary>
        /// 设置用户信息
        /// </summary>
        /// <param name="peer"></param>
        public void SetPeer(Peer peer)
        {
            this.user = peer;
        }

        public void StopSyn()
        {
            StopAllCoroutines();
            user = null;
        }
    }
}