2805【前端】超值礼包新增显示仙玉余额

client_linchunjie

2018-08-23 522ca3468a56c88cb15eaa428eb7499d3dba386f

 Core/Camera/CameraController.cs

@@ -1,334 +1,334 @@
using UnityEngine;
using System.Collections;

public class CameraController : MonoBehaviour
{
    public static CameraController Instance;

    [HideInInspector]
    public bool AcceptInput = true;

    public Transform Node;
    public Camera CameraObject;
    public Transform LookAtTarget;

    public Camera MaskCamera;
    public GameObject Mask;
    private Animation m_Animation;

    public float lookHeight = 0;

    public float Distance = 10.0f;
    public float MinDistance = 2.0f;
    public float MaxDistance = 10.0f;

    public float rotationX = 0.0f;
    public float rotationY = 35.0f;
    public float rotationSpeed = 5.0f;

    public float MinRotationY = 35.0f;
    public float MaxRotationY = 50.0f;

    public float MoveDamping = 0.1f;
    public float RotationDamping = 0.1f;
    public float ZoomDamping = 0.3f;

    private float m_CurrentRotationY;
    private float m_CurrentRotationX;
    private Vector3 m_MoveVelocity = Vector3.zero;
    private float m_ZoomVelocity = 0;

    [HideInInspector]
    public float originalDistance = 0;
    [HideInInspector]
    public float originalRotX = 0;
    [HideInInspector]
    public float originalRotY = 0;
    [HideInInspector]
    public float sceneDistance = 0;

    public bool IsPlayingAnim
    {
        get; private set;
    }

    void Awake()
    {
        Instance = this;
        CameraManager.sceneCamera = CameraObject;
        m_Animation = GetComponent<Animation>();
        sceneDistance = originalDistance = Distance;
        originalRotX = rotationX;
        originalRotY = rotationY;
        DontDestroyOnLoad(this);
    }

    public void PlayAnimationClip(string name)
    {
        AnimationClip _clip = Resources.Load<AnimationClip>("AnimationCurve/" + name);
        if (_clip != null)
        {
            IsPlayingAnim = true;
            m_Animation.AddClip(_clip, "start_show");
            m_Animation.Play("start_show");
        }
    }

    private void OnAnimationOver()
    {
        IsPlayingAnim = false;
    }

    public void ResetOriginal()
    {
        RotationDamping = 0.02f;
        ZoomDamping = 0.02f;
        sceneDistance = Distance = originalDistance;
        rotationX = originalRotX;
        rotationY = originalRotY;
    }

    public void SetLookTarget(Transform _target)
    {
        LookAtTarget = _target;
    }

    public void SetRotationX(float _angle)
    {
        rotationX = _angle;
    }

    public void ChangeRotationX(float _change_value)
    {
        rotationX += _change_value;
    }

    IEnumerator CameraRotationX(float _angle)
    {
        while (rotationX != _angle)
        {
            rotationX = Mathf.SmoothDampAngle(rotationX, _angle, ref m_CurrentRotationX, RotationDamping);
            if (Mathf.Abs(rotationX - _angle) <= 0.01f)
            {
                rotationX = _angle;
            }
            yield return null;
        }
    }

    // Update is called once per frame
    void Update()
    {
        // 是否正在播放摄像机动画
        if (IsPlayingAnim)
        {
            return;
        }
        //#if UNITY_EDITOR

        //if (AcceptInput)
        //{
        //    if (Input.GetMouseButtonDown(0))
        //    {
        //        Ray _ray = CameraObject.ScreenPointToRay(Input.mousePosition);
        //        RaycastHit _hit;
        //        if (Physics.Raycast(_ray, out _hit, 100, LayerUtility.WalkbleMask))
        //        {
        //            if (LookAtTarget != null)
        //            {
        //                LookAtTarget.transform.position = _hit.point;
        //            }
        //        }
        //    }
        //}

        //#endif

        Vector3 eulerAngles = transform.eulerAngles;

        float newCameraRotUp = Mathf.SmoothDampAngle(eulerAngles.x, rotationY, ref m_CurrentRotationY, RotationDamping);
        float newCameraRotSide = Mathf.SmoothDampAngle(eulerAngles.y, rotationX, ref m_CurrentRotationX, RotationDamping);

        Vector3 _dir = new Vector3(newCameraRotUp, newCameraRotSide, 0);
        if (_dir.magnitude > 0.01f)
        {
            transform.rotation = Quaternion.Euler(_dir);
        }

        if (LookAtTarget != null)
        {
            transform.position = Vector3.SmoothDamp(transform.position, LookAtTarget.position + new Vector3(0, lookHeight, 0), ref m_MoveVelocity, MoveDamping);
        }

        float dist = Mathf.SmoothDamp(-CameraObject.transform.localPosition.z, Distance, ref m_ZoomVelocity, ZoomDamping);
        CameraObject.transform.localPosition = -Vector3.forward * dist;
    }

    public void Apply()
    {
        if (LookAtTarget == null)
        {
            return;
        }
        transform.position = LookAtTarget.position + new Vector3(0, lookHeight, 0);
        transform.eulerAngles = new Vector3(rotationY, rotationX, 0);
        CameraObject.transform.localPosition = -Vector3.forward * Distance;
    }

    void OnDrawGizmos()
    {
        if (CameraObject != null)
        {
            Gizmos.color = new Color(1.0f, 1.0f, 0.0f, 0.8f); // Color.yellow;
            Gizmos.DrawSphere(CameraObject.transform.position, 0.2f);

            Gizmos.color = new Color(1.0f, 0.0f, 0.0f, 0.8f); // Color.yellow;
            Gizmos.DrawSphere(transform.position, 0.2f);

            Gizmos.color = Color.yellow;
            Gizmos.DrawLine(CameraObject.transform.position, transform.position);
        }
    }

    private void OnDestroy()
    {
        LookAtTarget = null;
        Instance = null;

        if (CameraManager.sceneCamera == CameraObject)
        {
            CameraManager.sceneCamera = null;
        }

    }

    private struct ZoomVo
    {
        public float scale;
        public float time;
    }

    public void StartZoom(float scale, float zoomTime)
    {

        if (zoomTime == 0)
        {
            return;
        }

        StopZoom();

        ZoomVo _vo = new ZoomVo
        {
            scale = scale,
            time = zoomTime
        };

        StartCoroutine("Zoom", _vo);
    }

    public void StopZoom()
    {
        StopCoroutine("Zoom");
    }

    IEnumerator Zoom(ZoomVo vo)
    {
        float _cacheDistance = Distance;
        float _time = 0;
        float _percent;
        float _zoomDistance = sceneDistance * vo.scale - Distance;
        while (_time < vo.time)
        {
            _percent = _time / vo.time;
            _percent = Constants.zoomAniCurve.animationCurve.Evaluate(_percent);
            Distance = _cacheDistance + _percent * _zoomDistance;
            _time += Time.deltaTime;
            yield return null;
        }
        Distance = _cacheDistance + _zoomDistance;
        //_cacheDistance = Distance;
        //_zoomDistance = m_OriginalDistance - Distance;
        //while (_time < vo.recoverTime)
        //{
        //    _percent = _time / vo.recoverTime;
        //    _percent = Constants.zoomAniCurve.animationCurve.Evaluate(_percent);
        //    Distance = _cacheDistance + _percent * _zoomDistance;
        //    _time += Time.deltaTime;
        //    yield return null;
        //}
        //Distance = m_OriginalDistance;
    }

    private struct ShakeVo
    {
        public Vector3 shakeDir;
        public float power;
        public float interval;
        public float duration;
    }

    public void DoShake(Vector3 dir, float power, float interval, float duration)
    {
        ShakeVo _vo = new ShakeVo
        {
            shakeDir = dir.normalized,
            power = power,
            interval = interval,
            duration = duration
        };

        Node.transform.localPosition = Vector3.zero;
        StopCoroutine("Shake");
        StartCoroutine("Shake", _vo);
    }

    public void StopShake()
    {
        Node.transform.localPosition = Vector3.zero;
        StopCoroutine("Shake");
    }

    IEnumerator Shake(ShakeVo vo)
    {
        float _percent = 0;
        float _interval = 0;
        float _duration = vo.duration;
        Vector3 _localPos = Vector3.zero;
        Vector3 _direction = vo.shakeDir;

        float _distance = Vector3.Distance(vo.power * _direction, Vector3.zero);

        while (_duration > 0)
        {
            _interval += Time.deltaTime;
            _percent = _interval / vo.interval;
            _percent = Constants.shakeAniCurve.animationCurve.Evaluate(_percent);
            Node.transform.localPosition = _localPos + _direction * _distance * _percent;
            if (_interval > vo.interval)
            {
                _localPos = Node.transform.localPosition;
                _direction = -_direction;
                _distance = Vector3.Distance(vo.power * _direction, _localPos);
                _interval = 0;
            }
            _duration -= Time.deltaTime;
            yield return null;
        }

        _interval = 0;
        _localPos = Node.transform.localPosition;
        _direction = (Vector3.zero - Node.transform.localPosition).normalized;
        _distance = Vector3.Distance(Vector3.zero, _localPos);
        while (_interval < vo.interval)
        {
            _interval += Time.deltaTime;
            _percent = _interval / vo.interval;
            _percent = Constants.shakeAniCurve.animationCurve.Evaluate(_percent);
            Node.transform.localPosition = _localPos + _direction * _distance * _percent;
            yield return null;
        }

        Node.transform.localPosition = Vector3.zero;
    }
}
using UnityEngine;

using System.Collections;



public class CameraController : MonoBehaviour

{

    public static CameraController Instance;



    [HideInInspector]

    public bool AcceptInput = true;



    public Transform Node;

    public Camera CameraObject;

    public Transform LookAtTarget;



    public Camera MaskCamera;

    public GameObject Mask;

    private Animation m_Animation;



    public float lookHeight = 0;



    public float Distance = 10.0f;

    public float MinDistance = 2.0f;

    public float MaxDistance = 10.0f;



    public float rotationX = 0.0f;

    public float rotationY = 35.0f;

    public float rotationSpeed = 5.0f;



    public float MinRotationY = 35.0f;

    public float MaxRotationY = 50.0f;



    public float MoveDamping = 0.1f;

    public float RotationDamping = 0.1f;

    public float ZoomDamping = 0.3f;



    private float m_CurrentRotationY;

    private float m_CurrentRotationX;

    private Vector3 m_MoveVelocity = Vector3.zero;

    private float m_ZoomVelocity = 0;



    [HideInInspector]

    public float originalDistance = 0;

    [HideInInspector]

    public float originalRotX = 0;

    [HideInInspector]

    public float originalRotY = 0;

    [HideInInspector]

    public float sceneDistance = 0;



    public bool IsPlayingAnim

    {

        get; private set;

    }



    void Awake()

    {

        Instance = this;

        CameraManager.sceneCamera = CameraObject;

        m_Animation = GetComponent<Animation>();

        sceneDistance = originalDistance = Distance;

        originalRotX = rotationX;

        originalRotY = rotationY;

        DontDestroyOnLoad(this);

    }



    public void PlayAnimationClip(string name)

    {

        AnimationClip _clip = Resources.Load<AnimationClip>("AnimationCurve/" + name);

        if (_clip != null)

        {

            IsPlayingAnim = true;

            m_Animation.AddClip(_clip, "start_show");

            m_Animation.Play("start_show");

        }

    }



    private void OnAnimationOver()

    {

        IsPlayingAnim = false;

    }



    public void ResetOriginal()

    {

        RotationDamping = 0.02f;

        ZoomDamping = 0.02f;

        sceneDistance = Distance = originalDistance;

        rotationX = originalRotX;

        rotationY = originalRotY;

    }



    public void SetLookTarget(Transform _target)

    {

        LookAtTarget = _target;

    }



    public void SetRotationX(float _angle)

    {

        rotationX = _angle;

    }



    public void ChangeRotationX(float _change_value)

    {

        rotationX += _change_value;

    }



    IEnumerator CameraRotationX(float _angle)

    {

        while (rotationX != _angle)

        {

            rotationX = Mathf.SmoothDampAngle(rotationX, _angle, ref m_CurrentRotationX, RotationDamping);

            if (Mathf.Abs(rotationX - _angle) <= 0.01f)

            {

                rotationX = _angle;

            }

            yield return null;

        }

    }



    // Update is called once per frame

    void Update()

    {

        // 是否正在播放摄像机动画

        if (IsPlayingAnim)

        {

            return;

        }

        //#if UNITY_EDITOR



        //if (AcceptInput)

        //{

        //    if (Input.GetMouseButtonDown(0))

        //    {

        //        Ray _ray = CameraObject.ScreenPointToRay(Input.mousePosition);

        //        RaycastHit _hit;

        //        if (Physics.Raycast(_ray, out _hit, 100, LayerUtility.WalkbleMask))

        //        {

        //            if (LookAtTarget != null)

        //            {

        //                LookAtTarget.transform.position = _hit.point;

        //            }

        //        }

        //    }

        //}



        //#endif



        Vector3 eulerAngles = transform.eulerAngles;



        float newCameraRotUp = Mathf.SmoothDampAngle(eulerAngles.x, rotationY, ref m_CurrentRotationY, RotationDamping);

        float newCameraRotSide = Mathf.SmoothDampAngle(eulerAngles.y, rotationX, ref m_CurrentRotationX, RotationDamping);



        Vector3 _dir = new Vector3(newCameraRotUp, newCameraRotSide, 0);

        if (_dir.magnitude > 0.01f)

        {

            transform.rotation = Quaternion.Euler(_dir);

        }



        if (LookAtTarget != null)

        {

            transform.position = Vector3.SmoothDamp(transform.position, LookAtTarget.position + new Vector3(0, lookHeight, 0), ref m_MoveVelocity, MoveDamping);

        }



        float dist = Mathf.SmoothDamp(-CameraObject.transform.localPosition.z, Distance, ref m_ZoomVelocity, ZoomDamping);

        CameraObject.transform.localPosition = -Vector3.forward * dist;

    }



    public void Apply()

    {

        if (LookAtTarget == null)

        {

            return;

        }

        transform.position = LookAtTarget.position + new Vector3(0, lookHeight, 0);

        transform.eulerAngles = new Vector3(rotationY, rotationX, 0);

        CameraObject.transform.localPosition = -Vector3.forward * Distance;

    }



    void OnDrawGizmos()

    {

        if (CameraObject != null)

        {

            Gizmos.color = new Color(1.0f, 1.0f, 0.0f, 0.8f); // Color.yellow;

            Gizmos.DrawSphere(CameraObject.transform.position, 0.2f);



            Gizmos.color = new Color(1.0f, 0.0f, 0.0f, 0.8f); // Color.yellow;

            Gizmos.DrawSphere(transform.position, 0.2f);



            Gizmos.color = Color.yellow;

            Gizmos.DrawLine(CameraObject.transform.position, transform.position);

        }

    }



    private void OnDestroy()

    {

        LookAtTarget = null;

        Instance = null;



        if (CameraManager.sceneCamera == CameraObject)

        {

            CameraManager.sceneCamera = null;

        }



    }



    private struct ZoomVo

    {

        public float scale;

        public float time;

    }



    public void StartZoom(float scale, float zoomTime)

    {



        if (zoomTime == 0)

        {

            return;

        }



        StopZoom();



        ZoomVo _vo = new ZoomVo

        {

            scale = scale,

            time = zoomTime

        };



        StartCoroutine("Zoom", _vo);

    }



    public void StopZoom()

    {

        StopCoroutine("Zoom");

    }



    IEnumerator Zoom(ZoomVo vo)

    {

        float _cacheDistance = Distance;

        float _time = 0;

        float _percent;

        float _zoomDistance = sceneDistance * vo.scale - Distance;

        while (_time < vo.time)

        {

            _percent = _time / vo.time;

            _percent = Constants.zoomAniCurve.animationCurve.Evaluate(_percent);

            Distance = _cacheDistance + _percent * _zoomDistance;

            _time += Time.deltaTime;

            yield return null;

        }

        Distance = _cacheDistance + _zoomDistance;

        //_cacheDistance = Distance;

        //_zoomDistance = m_OriginalDistance - Distance;

        //while (_time < vo.recoverTime)

        //{

        //    _percent = _time / vo.recoverTime;

        //    _percent = Constants.zoomAniCurve.animationCurve.Evaluate(_percent);

        //    Distance = _cacheDistance + _percent * _zoomDistance;

        //    _time += Time.deltaTime;

        //    yield return null;

        //}

        //Distance = m_OriginalDistance;

    }



    private struct ShakeVo

    {

        public Vector3 shakeDir;

        public float power;

        public float interval;

        public float duration;

    }



    public void DoShake(Vector3 dir, float power, float interval, float duration)

    {

        ShakeVo _vo = new ShakeVo

        {

            shakeDir = dir.normalized,

            power = power,

            interval = interval,

            duration = duration

        };



        Node.transform.localPosition = Vector3.zero;

        StopCoroutine("Shake");

        StartCoroutine("Shake", _vo);

    }



    public void StopShake()

    {

        Node.transform.localPosition = Vector3.zero;

        StopCoroutine("Shake");

    }



    IEnumerator Shake(ShakeVo vo)

    {

        float _percent = 0;

        float _interval = 0;

        float _duration = vo.duration;

        Vector3 _localPos = Vector3.zero;

        Vector3 _direction = vo.shakeDir;



        float _distance = Vector3.Distance(vo.power * _direction, Vector3.zero);



        while (_duration > 0)

        {

            _interval += Time.deltaTime;

            _percent = _interval / vo.interval;

            _percent = Constants.shakeAniCurve.animationCurve.Evaluate(_percent);

            Node.transform.localPosition = _localPos + _direction * _distance * _percent;

            if (_interval > vo.interval)

            {

                _localPos = Node.transform.localPosition;

                _direction = -_direction;

                _distance = Vector3.Distance(vo.power * _direction, _localPos);

                _interval = 0;

            }

            _duration -= Time.deltaTime;

            yield return null;

        }



        _interval = 0;

        _localPos = Node.transform.localPosition;

        _direction = (Vector3.zero - Node.transform.localPosition).normalized;

        _distance = Vector3.Distance(Vector3.zero, _localPos);

        while (_interval < vo.interval)

        {

            _interval += Time.deltaTime;

            _percent = _interval / vo.interval;

            _percent = Constants.shakeAniCurve.animationCurve.Evaluate(_percent);

            Node.transform.localPosition = _localPos + _direction * _distance * _percent;

            yield return null;

        }



        Node.transform.localPosition = Vector3.zero;

    }

}