XiuXianGame/Assets/Scripts/GameLogic/Combat/CombatTool/CombatCameraControllder.cs

using System;
using Common.Utility.CombatEvent;
using Fort23.Core;
using UnityEngine;
using Utility;
using Utility.CustomizeTimeLogic.FxLogic.TimeLineEvent;
using UTool.CustomizeTimeLogic.FxLogic.TimeLineEventinterface;

namespace GameLogic.Combat.CombatTool
{
    public class CombatCameraControllder : IDisposable, ICameraShaking
    {
        public Transform root;
        public Transform root2;
        public Camera Camera;
        public CombatController combatController;
        public StressReceiver StressReceiver;

        private bool isStartShake;

        public int FollowHeroId
        {
            get { return _followHeroId; }
        }

        private int _followHeroId = -1;


        public bool isStop;

        private bool isUpdateCameraToPath;
        private float currValue;
        public float _cameraSelectValue;
        private float targetValue;
        private float _currTime;
        private bool isUpdateFieldOfView;
        private float FieldOfViewTime;
        private float FieldOfViewTargetValue;
        private float FieldOfViewStartValue;
        private float FieldOfViewSpeed;

        private bool isStartMoveCamera;
        private float _MoveCameraTime;
        private float _lasetCombatValue;
        private float _moveToTargetValue;

        public void Init(CombatController combatController, Camera camera)
        {
            CombatEventManager.Instance.AddEventListener(CombatEventType.SencenBesselPathAlter, SencenBesselPathAlter);
            this.combatController = combatController;
            Camera = camera;
            root2 = Camera.transform.parent;
            root = Camera.transform.parent.parent;
            StressReceiver = camera.transform.GetComponentInParent<StressReceiver>();
            TimeLineSingletonEventManager.Instance.AddTimeLineBasic(this);
            EventManager.Instance.AddEventListener(CustomEventType.HeroClick, HeroClick);
            // CameraSelect_onValueChanged(0.7f);
            // EventManager.Instance.AddEventListener(CustomEventType.HeroClick, HeroClick);
        }

        private void SencenBesselPathAlter(IEventData eventData)
        {
            // isUpdateCameraToPath = true;
            // currValue = _cameraSelectValue;
            // if (CombatController.currActiveCombat.CombatSenceController.currBesselPath.isCentre)
            // {
            //     targetValue = 0.5f;
            // }
            // else
            // {
            //     targetValue = 0.7f;
            // }
            //
            // _currTime = 0;
        }

        protected void HeroClick(IEventData eventData)
        {
            HeroClickEventData heroClickEventData = eventData as HeroClickEventData;
            int heroId = heroClickEventData.heroId;
            if (_followHeroId == heroId)
            {
                _followHeroId = -1;
            }
            else
            {
                _followHeroId = heroId;
            }
        }

        public void CameraSelect_onValueChanged(float value)
        {
            _cameraSelectValue = value;
            Vector3 pos1 = new Vector3(0, -3, -0.7f);
            Vector3 e1 = new Vector3(20, 0, 0);
            Vector3 pos2 = new Vector3(9, -1, -1.4f);
            Vector3 e2 = new Vector3(17.77f, -28.25f, 1.165f);
            Camera.transform.localPosition =
                Vector3.Lerp(pos1, pos2, value);
            Camera.transform.localEulerAngles =
                Vector3.Lerp(e1, e2, value);
        }

        public void EnterCombat()
        {
            isStartMoveCamera = true;
            _MoveCameraTime = 0;
            _lasetCombatValue = _cameraSelectValue;
            _moveToTargetValue = 0.5f;
        }

        public void ExitCombat()
        {
            isStartMoveCamera = true;
            _MoveCameraTime = 0;
            _moveToTargetValue = _lasetCombatValue;
            _lasetCombatValue = _cameraSelectValue;
        }

        private void ShakeFinish()
        {
            isStartShake = false;
        }

        public void SetFieldOfView(float fieldOfView, float speed)
        {
            FieldOfViewSpeed = speed;
            FieldOfViewTime = 0;
            FieldOfViewStartValue = Camera.fieldOfView;
            FieldOfViewTargetValue = fieldOfView;
            isUpdateFieldOfView = true;
        }

        public void Update(float t)
        {
            if (isUpdateFieldOfView)
            {
                FieldOfViewTime += t * FieldOfViewSpeed;
                Camera.fieldOfView = Mathf.Lerp(FieldOfViewStartValue, FieldOfViewTargetValue, FieldOfViewTime);
                if (FieldOfViewTime >= 1)
                {
                    isUpdateFieldOfView = false;
                }
            }

            if (isStartMoveCamera)
            {
                _MoveCameraTime += t;

                float v = Mathf.Lerp(_lasetCombatValue, _moveToTargetValue, _MoveCameraTime);
                CameraSelect_onValueChanged(v);
                if (_MoveCameraTime >= 1)
                {
                    isStartMoveCamera = false;
                }
            }

            CombatHeroEntity combatHeroEntities = combatController.playerHeroEntity;
            if (!isStartShake && !isStop)
            {
                if (combatHeroEntities == null)
                {
                    return;
                }

                Vector3 dir = combatHeroEntities.faceDir;
                // CombatHeroEntity foucusTarget = combatHeroEntities.CombatAIBasic.currFocusTarget as CombatHeroEntity;
                // if (foucusTarget != null)
                // {
                //     dir = foucusTarget.dotPos - combatHeroEntities.dotPos;
                //     dir = dir.normalized;
                // }

                // Quaternion q = Quaternion.LookRotation(dir);
                Vector3 myHeroTarget = new Vector3(0, 8, -10);
                // myHeroTarget = q * myHeroTarget;
                Vector3 p = combatHeroEntities.GameObject.transform.TransformPoint(myHeroTarget);
                root.rotation = Quaternion.Lerp(root.rotation, combatHeroEntities.GameObject.transform.rotation,
                    1);
                root.position = Vector3.Lerp(root.position, p, 1);
            }

            // MoveRoot2();
        }

        private void MoveRoot2()
        {
            CombatHeroEntity combatHeroEntities = combatController.playerHeroEntity;

            if (combatHeroEntities == null)
            {
                return;
            }

            Vector3 dir = combatHeroEntities.faceDir;
            CombatHeroEntity foucusTarget = combatHeroEntities.CombatAIBasic.currFocusTarget as CombatHeroEntity;
            if (foucusTarget != null)
            {
                dir = foucusTarget.dotPos - combatHeroEntities.dotPos;
                dir = dir.normalized;
            }

            Quaternion q = Quaternion.LookRotation(dir);
            Vector3 myHeroTarget = new Vector3(0, 8, -10);
            myHeroTarget = q * myHeroTarget;
            Vector3 p = combatHeroEntities.GameObject.transform.TransformPoint(myHeroTarget);
            Vector3 newP = p - root.position;
            root2.rotation = Quaternion.Lerp(root2.rotation, q,
                0.3f);
            root2.localPosition = Vector3.Lerp(root2.localPosition, newP, 0.3f);
        }

        public void SetPos(Transform target)
        {
            Vector3 p = target.TransformPoint(new Vector3(0, 8, -10));
            root.rotation = Quaternion.Lerp(root.rotation, target.rotation,
                1);
            root.position = Vector3.Lerp(root.position, p, 1);
        }

        public void Dispose()
        {
            EventManager.Instance.RemoveEventListener(CustomEventType.HeroClick, HeroClick);
        }

        public void Shaking(float time, float size)
        {
            if (StressReceiver != null)
            {
                isStartShake = true;
                StressReceiver.InduceStress(time, size, ShakeFinish);
            }
        }

        public void Shaking(CameraShakingSerializtion cameraShakingSerializtion)
        {
            Shaking(cameraShakingSerializtion.qiangDu, 1);
        }
    }
}