smart-bow-infrared/Assets/WildAttack/Scripts/Manager/GameMananger.cs

using AppUI.Bluetooth;
using System.Collections;
using System.Collections.Generic;
using UnityEngine;
using UnityEngine.EventSystems;
using UnityEngine.UI;

namespace WildAttack
{
    /// <summary>
    /// 射击类型枚举
    /// </summary>
    public enum ShootTypeEnum
    {
        FixedScreen = 1,
        FixedCrossHair = 2,
        moreScreen = 3,// 超出范围 调整相机
    }

    /// <summary>
    /// 当前玩家的类型
    /// </summary>
    public enum PlayerTypeEnum { 
        First = 0,//玩家1
        Second = 1 //玩家2
    }

    /// <summary>
    /// 塔防游戏类型
    /// </summary>
    public enum GameTypeEnum
    {
        SinglePlayer = 0,   // 单人模式
        LocalTwoPlayer = 1 // 本地双人对战（同屏或同设备）
    }


    /// <summary>
    /// 游戏管理器
    /// </summary>
    public class GameMananger : Singleton<GameMananger>
    {
        #region Members
        [SerializeField]
        private GameTypeEnum gameTypeEnum = GameTypeEnum.SinglePlayer;//当前游戏类型
        public GameTypeEnum CurrentGameType => gameTypeEnum;

        private int hp = 0;
        public int HP { get { return hp; } }
        private int hpMax = 0;
        public int HPMax { get { return hpMax; } }

        private int totalScore = 0;
        private int uploadScore = 0;
        public int TotalScore { get { return totalScore; } }
        public int barrelTriggerCount = 0;

        //2p 新加分数计算 开始 ***************
        private int totalScore_2P = 0;
        private int uploadScore_2P = 0;
        public int TotalScore_2P { get { return totalScore_2P; } }
        // 2p 新加分数计算 结束 ***************
      

        private ShootTypeEnum typeEnum = ShootTypeEnum.FixedScreen;

        // 原始旋转
        Vector3 originalBowRotation;
        // 弓箭旋转对应的对象 对弓箭的操作体现在这个obj上
        Transform CrossHairTrans;
        // 弓箭旋转对应的对象 对弓箭的操作体现在这个obj上
        // 原始旋转
        Vector3 originalBowRotation_2P;
        Transform CrossHairTrans_2P;
        // 射箭速度
        private float smartBowSpeed;
        private float testSpeed;

        // 语言类型 配合csv
        private LanguageType languageType;
        public LanguageType Language { get { return languageType; } }

        // 相机初始旋转信息位置信息
        private Vector3 camOriEular;
        private Vector3 camOriPos;

        // 游戏结束时 相机目标点
        private Transform gameOverTrans;
        // 弓
        private Bow bow;
        // 弓2
        private Bow bow_2P;

        // 城门动画控制
        private Animator wallAnim;

        // 特效
        private ParticleSystem addHpParticle;
        private ParticleSystem failParticle;
        private ParticleSystem victoryParticle;

        //触摸检测器
        JCUnityLib.TouchChecker touchChecker = new JCUnityLib.TouchChecker();

        UserGameAnalyse1 userGameAnalyse1;

        //游戏计算的分数只有射箭出来算
        bool bAddCountScore = false;
        bool bAddCountScore_2P = false;
        #endregion

        #region Function
        public void InitGameType(GameTypeEnum gameType) {
            gameTypeEnum = gameType;
        }
        public void Init(UserGameAnalyse1 _userGameAnalyse1)
        {
            userGameAnalyse1 = _userGameAnalyse1;
            camOriEular = Camera.main.transform.eulerAngles;
            camOriPos = Camera.main.transform.position;
            gameOverTrans = GameObject.Find("GameOver").transform;
            bow = GameObject.Find("Bow").GetComponent<Bow>();
            languageType = LanguageType.CH;
            if (TextAutoLanguage2.GetLanguage() == LanguageEnum.English)
                languageType = LanguageType.EN;
            else if (TextAutoLanguage2.GetLanguage() == LanguageEnum.Japan)
                languageType = LanguageType.JP;

            Debug.Log("languageType:"+ languageType);
            CrossHairTrans = GameObject.Find("CrossHairTrans").transform;
            originalBowRotation = CrossHairTrans.eulerAngles;
            //双人部分
            if (gameTypeEnum == GameTypeEnum.LocalTwoPlayer) {
                bow_2P = GameObject.Find("Bow_2P").GetComponent<Bow>();
                CrossHairTrans_2P = GameObject.Find("CrossHairTrans_2P").transform;
                originalBowRotation_2P = CrossHairTrans_2P.eulerAngles;
            }
            wallAnim = GameObject.Find("Wall").GetComponent<Animator>();

            hpMax = Mathf.FloorToInt(GameModule.GetInstance().GetData("wallHp"));
            hp = hpMax;
            totalScore = 0;
            uploadScore = 0;
            barrelTriggerCount = 0;

            totalScore_2P = 0;
            uploadScore_2P = 0;

            //shootSpawn = GameModule.GetInstance().GetData("downTime");
            shootSpawn = 0;
            shootSpawn_2P = 0;

            smartBowSpeed = GameModule.GetInstance().GetData("speedTimes");
            testSpeed = GameModule.GetInstance().GetData("testspeed");

            Transform particleTrans = GameObject.Find("finalPos/ParticleTrans").transform;
            addHpParticle = particleTrans.Find("addhp").GetChild(0).GetComponent<ParticleSystem>();
            failParticle = particleTrans.Find("fail").GetChild(0).GetComponent<ParticleSystem>();
            victoryParticle = particleTrans.Find("victory").GetChild(0).GetComponent<ParticleSystem>();


            Physics.autoSyncTransforms = true;
            InitForLimitBound();
            InitTouchChecker();
        }

        /// <summary>
        /// 射击类型相关接口
        /// </summary>
        /// <returns></returns>
        public ShootTypeEnum GetShootType()
        {
            return typeEnum;
        }
        public void SetShootType(ShootTypeEnum type)
        {
            this.typeEnum = type;
            if (this.typeEnum == ShootTypeEnum.FixedScreen)
            {
                bow.transform.Find("CameraParent").DetachChildren();
                GameObject.Find("UIBoxLeft").GetComponent<CanvasGroup>().blocksRaycasts = true;
            }
            else if (this.typeEnum == ShootTypeEnum.FixedCrossHair)
            {
                CrossHair.instance._rectTransform.anchoredPosition = new Vector2(0, 0);
                Camera.main.transform.SetParent(bow.transform.Find("CameraParent"));
            }
            else if (this.typeEnum == ShootTypeEnum.moreScreen)
            {
                bow.transform.Find("CameraParent").DetachChildren();
                GameObject.Find("UIBoxLeft").GetComponent<CanvasGroup>().blocksRaycasts = false;
            }
        }

        /// <summary>
        /// 游戏是否结束
        /// </summary>
        public bool isOver = false;
        /// <summary>
        /// 胜利失败
        /// </summary>
        public bool isWin;

        /// <summary>
        /// 游戏结束
        /// </summary>
        /// <param name="isWin"></param>
        public void GameOver(bool isWin)
        {
            isOver = true;
            // 血量回复
            this.hp = isWin ? hp : hpMax;
            this.isWin = isWin;
            // 城门对应动画
            wallAnim.SetBool(isWin ? "open" : "dead", true);

            //单人游戏城门才加分数
            if(gameTypeEnum == GameTypeEnum.SinglePlayer)
                AddScore(StagePropertyModule.GetInstance().GetData(1).score * (6 - barrelTriggerCount));

            // 特效
            if (isWin)
            {
                failParticle.Stop();
                victoryParticle.Play();
            }
            else
            {
                failParticle.Play();
                victoryParticle.Stop();
                // 失败时有城门破坏音效
                AudioSource ads = GameObject.Find("ProcessAudioSource").GetComponent<AudioSource>();
                ads.clip = Resources.Load<AudioClip>("Process/Broken");
                if (UserSettings.ins.openEffect) ads.Play();
            }

            //单人时候才上传射击分数
            //关卡结束时候触发
            if(CurrentGameType == GameTypeEnum.SinglePlayer)
                OnUploadScore();

            // 调用其他管理类的GameOver
            ProcessManager.GetInstance().GameOver(false);
            if (!isWin) EnemyManager.GetInstance().GameOver();
            UIManager.GetInstance().HideMainPanel();
        }
        //荒野射击上传分数到服务器
        public void OnUploadScore() {
            if (uploadScore > 0)
            {
                //游戏结束上传一个分数
                Debug.Log("荒野射击上传的积分为：" + uploadScore);
                RankComp.Instance.uploadSinglePlayerGameRes(uploadScore);
                uploadScore = 0;
            }

        }
        /// <summary>
        /// 血量
        /// </summary>
        /// <param name="hp"></param>
        public void SubHp(int hp)
        {
            this.hp -= hp;
            UIManager.GetInstance().SubHp();
            if (this.hp <= 0)
            {
                GameOver(false);
            }
        }
        public void AddHp(int hp)
        {
            this.hp += hp;
            if (hp != (int)GameModule.GetInstance().GetData("wallHp"))
            {
                addHpParticle.Play();
            }
            if (this.hp > hpMax)
            {
                this.hp = hpMax;
            }
            // 血量重置
            if (hp == hpMax)
            {
                UIManager.GetInstance().ResetHpBar();
            }
            // ui更新血条
            UIManager.GetInstance().AddHp();
        }

        /// <summary>
        /// 计分
        /// </summary>
        /// <param name="score"></param>
        public void AddScore(int score, PlayerTypeEnum playerTypeEnum = PlayerTypeEnum.First)
        {
            if (playerTypeEnum == PlayerTypeEnum.First)
            {
                //在射箭状态下触发的才计算分数，手点触发射箭后不计算分数
                if (!bAddCountScore) return;
                totalScore += score;
                //只记录一个上传的分数
                uploadScore += score;
            }
            else {
                //在射箭状态下触发的才计算分数，手点触发射箭后不计算分数
                if (!bAddCountScore_2P) return;
                totalScore_2P += score;
                //只记录一个上传的分数
                uploadScore_2P += score;

            }
         
        }
        public void SetScore(int score)
        {
            totalScore = score;
            barrelTriggerCount = 0;

            //双人时候也设置一下分数
            if (CurrentGameType == GameTypeEnum.LocalTwoPlayer)
                totalScore_2P = score;
        }

        // Update is called once per frame
        public void Update()
        {
            //检测相机
            if (CurrentGameType == GameTypeEnum.LocalTwoPlayer)
            {
                bow.gameObject.SetActive(!isOver);
                bow_2P.gameObject.SetActive(!isOver);
            }
            else {
                bow.gameObject.SetActive(!isOver);
            }
            // BGM
            if (!Camera.main.GetComponent<AudioSource>().isPlaying)
            {
                if (UserSettings.ins.openBGM)
                    Camera.main.GetComponent<AudioSource>().Play();
            }
            else {
                //如果正在播放
                if (!UserSettings.ins.openBGM)
                    Camera.main.GetComponent<AudioSource>().Stop();
            }
            // 设计间隔
            if (shootSpawn > 0)
            {
                shootSpawn -= Time.deltaTime;
            }
            if (shootSpawn_2P > 0) {
                shootSpawn_2P -= Time.deltaTime;
            }
            // unity调试用
#if UNITY_EDITOR
            #region pc端操作
            if (Input.GetKeyDown(KeyCode.N))
            {
                AddHp(5);
            }
            if (Input.GetKeyDown(KeyCode.M))
            {
                SubHp(5);
            }

            if (Input.GetKeyDown(KeyCode.P))
            {
                foreach (var item in EnemyManager.GetInstance().enemyList)
                {
                    item.Hitted(4, false);
                }
            }
            UpdateBowUnityEditor();
            if (CurrentGameType == GameTypeEnum.LocalTwoPlayer)
                UpdateBowUnityEditor(PlayerTypeEnum.Second);
            if (Input.GetKeyDown(KeyCode.Space) || Input.GetKeyDown(KeyCode.Z))
            {
                ShootOut(testSpeed,true, PlayerTypeEnum.First);
            }
            if (Input.GetKeyDown(KeyCode.Space) || Input.GetKeyDown(KeyCode.C))
            {
                if (CurrentGameType == GameTypeEnum.LocalTwoPlayer)
                    ShootOut(testSpeed,true,PlayerTypeEnum.Second);
            }
            if (Input.GetKeyDown(KeyCode.I))
            {
                GameOver(true);
            }
            if (Input.GetKeyDown(KeyCode.O))
            {
                GameOver(false);
            }
            #endregion
#endif

            if (BowCamera.isTouchMode) touchChecker.Update();

            // 游戏结束后相机移动到对应位置
            if (isOver)
            {
                Camera.main.transform.position = Vector3.Lerp(Camera.main.transform.position, gameOverTrans.position, 2 * Time.deltaTime);
                Camera.main.transform.eulerAngles = Vector3.Lerp(Camera.main.transform.eulerAngles, gameOverTrans.eulerAngles, 2 * Time.deltaTime);

                // 到达目标点显示ui
                if (Vector3.Distance(Camera.main.transform.position, gameOverTrans.position) < 0.01f)
                {
                    UIManager.GetInstance().GameOver(isWin);
                    InitForLimitBound();
                }
            }
        }

        /// <summary>
        /// ui检测
        /// </summary>
        /// <returns></returns>
        //private bool CheckCrossHairOverUI()
        //{
        //    if (!isOver) return false;

        //    EventSystem eventSystem = EventSystem.current;
        //    PointerEventData pointerEventData = new PointerEventData(eventSystem);
        //    // 获取准星pos 通过eventsystem检测下方是否有按钮
        //    pointerEventData.position = new Vector3(UIManager.GetInstance().GetCrossHairPos().x, UIManager.GetInstance().GetCrossHairPos().y, 0);
        //    //射线检测ui
        //    List<RaycastResult> uiRaycastResultCache = new List<RaycastResult>();
        //    eventSystem.RaycastAll(pointerEventData, uiRaycastResultCache);
        //    if (uiRaycastResultCache.Count > 0)
        //    {
        //        // 是否有button
        //        Button btn = uiRaycastResultCache[0].gameObject.GetComponent<Button>();
        //        if (btn == null)
        //        {
        //            // 防止检测到button下的text （ui注意设置 button下text不要勾选raycast
        //            btn = uiRaycastResultCache[0].gameObject.transform.GetComponentInParent<Button>();
        //            if (btn == null)
        //            {
        //                return false;
        //            }
        //        }
        //        btn.onClick.Invoke();
        //        //Debug.Log("eventsystem 触发 + " + uiRaycastResultCache[0].gameObject.name);
        //        return true;
        //    }
        //    else
        //    {
        //        return false;
        //    }
        //}

        /// <summary>
        /// 初始化相机等
        /// </summary>
        public void ResetMainCamera()
        {
            isOver = false;
            InitForLimitBound();
            ResetAim();
            //重置2P
            if (CurrentGameType == GameTypeEnum.LocalTwoPlayer)
                ResetAim(PlayerTypeEnum.Second);

            // 城门动画
            wallAnim.SetBool("dead", false);
            wallAnim.SetBool("open", false);
            // 特效
            failParticle.Stop();
            failParticle.Clear();
            victoryParticle.Stop();
            victoryParticle.Clear();
            // 相机
            Camera.main.transform.position = camOriPos;
            Camera.main.transform.eulerAngles = camOriEular;
        }

        /// <summary>
        ///  pc端旋转弓
        /// </summary>
        /// <param name="playerTypeEnum">用户类型</param>
        private void UpdateBowUnityEditor(PlayerTypeEnum playerTypeEnum = PlayerTypeEnum.First)
        {
            float _shootSpawn = playerTypeEnum == PlayerTypeEnum.First ? shootSpawn : shootSpawn_2P;

            if (_shootSpawn <= GameModule.GetInstance().GetData("downTime") && _shootSpawn > 0) return;

            float x = Input.GetAxis("Horizontal") / 2;
            float y = Input.GetAxis("Vertical") / 2;

            if (x != 0 || y != 0)
            {
                Transform targetCrossHair = playerTypeEnum == PlayerTypeEnum.First ? CrossHairTrans : CrossHairTrans_2P;

                if (isOver)
                {
                    targetCrossHair.eulerAngles = LimitCrossHair(new Vector3(targetCrossHair.eulerAngles.x - y, targetCrossHair.eulerAngles.y + x, 0), playerTypeEnum);
                    Debug.Log($"isOver:{isOver}");
                }
                else
                {
                    targetCrossHair.eulerAngles = LimitAngles(new Vector3(targetCrossHair.eulerAngles.x - y, targetCrossHair.eulerAngles.y + x, 0));
                    CrossHairTransRaycast(playerTypeEnum);
                }
            }
        }
        /// <summary>
        /// 移动端用户触屏监听
        /// </summary>
        private void InitTouchChecker()
        {
            touchChecker.onMoved += delegate (Touch t, bool isOnUI)
            {
                if (isOnUI) return;
                if (shootSpawn <= GameModule.GetInstance().GetData("downTime") && shootSpawn > 0) return;

                Vector3 dis = t.rawPosition - t.deltaPosition;
                if (dis.x != 0 || dis.y != 0)
                {
                    if (isOver)
                    {
                        CrossHairTrans.eulerAngles = LimitCrossHair(new Vector3(CrossHairTrans.eulerAngles.x - (t.deltaPosition.y * Time.deltaTime), CrossHairTrans.eulerAngles.y + (t.deltaPosition.x * Time.deltaTime), 0));
                    }
                    else
                    {
                        CrossHairTrans.eulerAngles = LimitAngles(new Vector3(CrossHairTrans.eulerAngles.x - (t.deltaPosition.y * Time.deltaTime), CrossHairTrans.eulerAngles.y + (t.deltaPosition.x * Time.deltaTime), 0));
                        CrossHairTransRaycast();
                    }
                }
            };
            touchChecker.onEnded += delegate (Touch t, bool isOnUI)
            {
                if (isOnUI) return;
                ShootOut(testSpeed);
            };
        }
        /// <summary>
        /// 归位
        /// </summary>
        public void ResetAim(PlayerTypeEnum playerTypeEnum = PlayerTypeEnum.First)
        {
            bool isFirstPlayer = playerTypeEnum == PlayerTypeEnum.First;

            Transform crossHair = isFirstPlayer ? CrossHairTrans : CrossHairTrans_2P;
            Bow bowObj = isFirstPlayer ? bow : bow_2P;

            // 如果连接了蓝牙弓，调用 SDK 校准
            if (SmartBowController.Instance && SmartBowController.Instance.IsBluetoothModuleInited())
            {
                crossHair.localRotation = Quaternion.Euler(Vector3.zero);
                bowObj.transform.localRotation = crossHair.localRotation;

                //红外设备校准偏离点,记录全屏
                if (CurrentGameType == GameTypeEnum.SinglePlayer)
                {
                    //单人模式下，九轴走DoIdentity
                    if (SmartBowDeviceHub.ins?.Aim?.bRuning9Axis() == true)
                    {
                        SmartBowDeviceHub.ins?.Aim?.DoIdentity();
                    }
                    else
                    {
                        //单点
                        InfraredDemo._ins?.OnClick_SetAdjustPointsOffset_full();
                    }
                }
                else
                {
                    //双人只有偏移校准
                    InfraredDemo._ins?.SetAdjustPointsOffset_full(isFirstPlayer?PlayerType.FirstPlayer: PlayerType.SecondPlayer);
                }
            
            }
            else
            {
                if (isOver)
                {
                    crossHair.localEulerAngles = Vector3.zero;
                }
                else
                {
                    crossHair.localEulerAngles = Vector3.zero;
                    bowObj.transform.eulerAngles = crossHair.eulerAngles;
                }
            }
        }

        /// <summary>
        /// 最高分
        /// </summary>
        private int highScore;
        public void SetHighScore(int score)
        {
            highScore = score;
        }
        public int GetHighScore()
        {
            return highScore;
        }

        #endregion

        #region InfraredCamera
        public void OnScreenPointUpdate(Vector2 point, PlayerTypeEnum playerTypeEnum = PlayerTypeEnum.First)
        {
            //// 判断射击间隔
            //if (shootSpawn <= GameModule.GetInstance().GetData("downTime") && shootSpawn > 0) return;

            //Ray ray = Camera.main.ScreenPointToRay(point);
            //Vector3 rayEndPoint = ray.GetPoint(200);
            //Quaternion quat = Quaternion.LookRotation(rayEndPoint - Camera.main.transform.position);
            //CrossHairTrans.rotation = quat;
            //CrossHairTransRaycast();
            // 确保 GameModule 和 downTime 的值是有效的
            var gameModule = GameModule.GetInstance();
            if (gameModule == null) { return; }
            // 判断射击间隔
            float _shootSpawn = playerTypeEnum == PlayerTypeEnum.First ? shootSpawn : shootSpawn_2P;
            if (_shootSpawn <= gameModule.GetData("downTime") && _shootSpawn > 0) return;

            // 确保 Camera.main 是有效的
            Camera mainCamera = Camera.main;
            if (mainCamera == null){ return; }

            // 确保 CrossHairTrans 不为 null
            Transform crossHair = playerTypeEnum == PlayerTypeEnum.First ? CrossHairTrans : CrossHairTrans_2P;
            if (crossHair == null) return;

            // 计算射线
            Ray ray = mainCamera.ScreenPointToRay(point);
            Vector3 rayEndPoint = ray.GetPoint(200);
            Quaternion quat = Quaternion.LookRotation(rayEndPoint - mainCamera.transform.position);
            crossHair.rotation = quat;
            // 进行射线检测
            CrossHairTransRaycast(playerTypeEnum); // 用带 playerTypeEnum 的版本
        }
        #endregion

        #region SmartBlueToothSDK


        public void OnRotationUpdate(Quaternion rotation, PlayerTypeEnum playerTypeEnum = PlayerTypeEnum.First)
        {
            Transform crossHair = playerTypeEnum == PlayerTypeEnum.First ? CrossHairTrans : CrossHairTrans_2P;
            if (crossHair == null) return;
            // 判断射击间隔
            float _shootSpawn = playerTypeEnum == PlayerTypeEnum.First ? shootSpawn : shootSpawn_2P;
            if (_shootSpawn <= GameModule.GetInstance().GetData("downTime") && _shootSpawn > 0) return;

            // 旋转插值
            Vector3 offset = isOver ? gameOverTrans.eulerAngles : originalBowRotation;

            Vector3 newOffset = Vector3.zero;
            if (offset.x != 0)
            {
                newOffset.x = offset.x - 360f;
            }
            if (offset.y != 0)
            {
                newOffset.y = offset.y - 360f;
            }
            //Bow.Instance.transform.localRotation = rotation;
            float speed = 2f;
            Vector3 offsetEuler = rotation.eulerAngles;

            // 真实旋转（弓箭sdk传回的参数有时为360有时为0
            offsetEuler.x = offsetEuler.x > 180 ? offsetEuler.x - 360 : offsetEuler.x;
            offsetEuler.y = offsetEuler.y > 180 ? offsetEuler.y - 360 : offsetEuler.y;

            offsetEuler = new Vector3(offsetEuler.x * speed, offsetEuler.y * speed, offsetEuler.z * speed) + newOffset;

            // 检测超出屏幕
            if (isOver)
            {
                crossHair.eulerAngles = LimitCrossHair(offsetEuler, playerTypeEnum);
            }
            else
            {
                crossHair.eulerAngles = LimitAngles(offsetEuler);
                CrossHairTransRaycast(playerTypeEnum);
            }
        }
        public Vector3 hitPoint;
        /// <summary>
        /// 射线检测指向点 用于同步弓旋转（1P/2P）
        /// </summary>
        /// <returns></returns>
        Vector3 CrossHairTransRaycast(PlayerTypeEnum playerTypeEnum = PlayerTypeEnum.First)
        {
            Transform crossHair = playerTypeEnum == PlayerTypeEnum.First ? CrossHairTrans : CrossHairTrans_2P;
            Bow bowObj = playerTypeEnum == PlayerTypeEnum.First ? bow : bow_2P;

            Ray ray = new Ray(crossHair.position, crossHair.forward);
            RaycastHit hitInfo;
            Vector3 point;

            if (Physics.Raycast(ray, out hitInfo, 100, ~1 << LayerMask.NameToLayer("Plane")))
            {
                point = hitInfo.point;
            }
            else
            {
                point = crossHair.position + crossHair.forward * 100f;
            }

            bowObj.transform.LookAt(point);
            Physics.SyncTransforms();

            return point;
        }
        /// <summary>
        /// 现在准心范围（1P/2P）
        /// </summary>
        /// <param name="angles"></param>
        /// <returns></returns>
        public Vector3 LimitCrossHair(Vector3 angles, PlayerTypeEnum playerTypeEnum = PlayerTypeEnum.First)
        {
            Vector3 viewPos = Camera.main.WorldToViewportPoint(CrossHairTransRaycast(playerTypeEnum));


            if (viewPos.x > 0 && viewPos.x < 1 && viewPos.y > 0 && viewPos.y < 1)
            {
            }
            else
            {
                if (viewPos.x < 0)
                {
                    angles.y += 1f;
                }
                else if (viewPos.x > 1)
                {
                    angles.y -= 1f;
                }

                if (viewPos.y < 0)
                {
                    angles.x -= 1f;
                }
                else if (viewPos.y > 1)
                {
                    angles.x += 1f;
                }
            }

            return angles;
        }

        private float shootSpawn = 0;

        private float shootSpawn_2P = 0;
        /// <summary>
        /// 射箭监听
        /// </summary>
        /// <param name="speed"></param>
        public void OnModuleShooting(float speed, PlayerTypeEnum playerTypeEnum = PlayerTypeEnum.First)
        {
            // speed区间 7~20？
            // 在这里判断是否和ui交互？ 优先判断ui 不是ui再射箭

            ShootOut(speed * smartBowSpeed,true, playerTypeEnum);
            //Debug.Log("OnModuleShooting:"+speed);
            //TipText.Show((speed * smartBowSpeed).ToString());
            // 角度 OnRotationUpdate
        }
        /// <summary>
        /// 射击
        /// </summary>
        /// <param name="speed">速度</param>
        /// <param name="bAddCount">是否添加记录</param>
        /// <param name="playerTypeEnum">玩家类型</param>
        void ShootOut(float speed,bool bAddCount = false, PlayerTypeEnum playerTypeEnum = PlayerTypeEnum.First)
        {
            if (isOver) return;
            if (playerTypeEnum == PlayerTypeEnum.First)
            {
                //根据射箭状态赋值
                bAddCountScore = bAddCount;
                //单人才计算射击次数
                if (bAddCount && CurrentGameType == GameTypeEnum.SinglePlayer) userGameAnalyse1?.changeShootingCount(1);
                if(CrossHairTrans)
                     bow.Shoot(speed, CrossHairTrans);
            }
            else {
                bAddCountScore_2P = bAddCount;
                if(CrossHairTrans_2P)
                    bow_2P.Shoot(speed, CrossHairTrans_2P);
            }
        }

        /// <summary>
        /// 射击时间
        /// </summary>
        /// <param name="spawn"></param>
        /// <param name="playerTypeEnum">玩家类型</param>
        public void SetShootSpawn(float spawn, PlayerTypeEnum playerTypeEnum = PlayerTypeEnum.First)
        {
            if(playerTypeEnum == PlayerTypeEnum.First)
                shootSpawn = spawn;
            else
                shootSpawn_2P = spawn;
        }
        #endregion

        #region 限制其显示范围不超出屏幕
        private float _screenHeightHalf;
        private float _screenNormal;
        private float _rangeRotateY;
        private float _rangeRotateX;
        /// <summary>
        /// 标记是否出界（-1：未出界；0：左边出界；1：右边出界；2：上边出界；3：下边出界；）
        /// </summary>
        public int outBoundIndex = -1;
        void InitForLimitBound()
        {
            Camera camera = Camera.main;
            _rangeRotateX = camera.fieldOfView / 2;
            float _screenWidthHalf = Screen.width / 2f;
            _screenHeightHalf = Screen.height / 2f;
            _screenNormal = _screenHeightHalf / Mathf.Tan(_rangeRotateX / 180f * Mathf.PI);
            _rangeRotateY = Mathf.Atan(_screenWidthHalf / _screenNormal) / Mathf.PI * 180f;
        }
        public Vector3 LimitAngles(Vector3 angles)
        {
            InitForLimitBound();
            Vector3 offset = isOver ? gameOverTrans.eulerAngles : originalBowRotation;
            //Unity默认范围（0，360）格式化为自定义范围（-180，180）
            angles.y = angles.y > 180 ? angles.y - 360 : angles.y;
            angles.x = angles.x > 180 ? angles.x - 360 : angles.x;
            //记录原来的角度
            float angleY = angles.y;
            float angleX = angles.x;
            //返回限制边界后的角度
            angles.y = Mathf.Clamp(angleY, -_rangeRotateY + (offset.y - 360), _rangeRotateY + (offset.y - 360));
            float rayLen = _screenNormal / Mathf.Cos(Mathf.Abs(angles.y) / 180 * Mathf.PI);
            float maxRangeRotateX = Mathf.Atan(_screenHeightHalf / rayLen) / Mathf.PI * 180f - offset.x;
            if (isOver)
            {
                if (angleX < -15f)
                {
                    angles.x = -15f;
                }
                else if (angleX > 45f)
                {
                    angles.x = 45f;
                }
            }
            else
            {
                if (Mathf.Abs(angleX) > Mathf.Abs(30f)) angles.x = 30f * (angleX > 0 ? 1 : -1);
            }
            if (angles.y < -_rangeRotateY + (offset.y - 360) + 0.5f)
            {
                outBoundIndex = 0;
            }
            else if (angles.y > _rangeRotateY + (offset.y - 360) - 0.5f)
            {
                outBoundIndex = 1;
            }
            else if (angles.x < -30f + 0.5f)
            {
                outBoundIndex = 2;
            }
            else if (angles.x > 30f - 0.5f)
            {
                outBoundIndex = 3;
            }
            else
            {
                outBoundIndex = -1;
            }
            return angles;
        }

        #endregion
    }
}