Project_WL/Assets/Script/Util/RealCamera.cs

using System;
using System.Collections.Generic;
using UnityEngine;
using Random = UnityEngine.Random;

[Serializable]
public class cCamData
{
    public float minDistance = 1.5f;
    public float maxDistance = 1.6f;
    public float DistanceUp = 1f;
    public float cameraHeight = 78f;
}

public class RealCamera : MyCoroutine
{
    [Header("Camera Properties")]
    private float DistanceAway;                     //how far the camera is from the player.

    public float minDistance = 1;                //min camera distance
    public float maxDistance = 2;                //max camera distance

    public float DistanceUp = -2;                    //how high the camera is above the player
    public float smooth = 4.0f;                    //how smooth the camera moves into place
    public float rotateAround = 70f;            //the angle at which you will rotate the camera (on an axis)

    public Vector3 m_LookAt = Vector3.up;
    public Vector3 m_BackOffSet = new Vector3(0f, 0.1f, -0.2f);

    [HideInInspector] public bool m_BackMove;

    [Header("Player to follow")]
    public Transform target;                    //the target the camera follows
    Actor m_Target;
    bool isTarget;

    [Header("Layer(s) to include")]
    public LayerMask CamOcclusion;                //the layers that will be affected by collision

    [Header("Map coordinate script")]
    //    public worldVectorMap wvm;
    public float cameraHeight = 55f;
    public float cameraPan = 0f;
    float camRotateSpeed = 180f;
    Vector3 camPosition;
    Vector3 camMask;

    private float HorizontalAxis, VerticalAxis;
    int CamStatus = 1; // 0 초기, 1 평소, 2 followtarget 오른쪽뷰, 3 followtarget 탑뷰(고정), 4 보스전
    float DragEndTime;
    GameObject godummy, gowitch;
    List<Transform> list_tfCamactionTarget = new List<Transform>();

    bool islockTarget;
    Transform tf_lockTarget;

    Actor m_followTarget;

    // 이동 방향 리드/피치 (PD #755) — 값의 SOT = Resources/WL/CameraLeadSettings.asset.
    // 에셋이 없거나 enabled=false 면 아래 세 출력이 전부 0 → 기존 동작과 완전히 동일하다.
    readonly CameraMoveLead m_MoveLead = new CameraMoveLead();
    public CameraMoveLead Get_MoveLead() { return m_MoveLead; }

    public cCamData[] arr_cCamData; // 0 일반, 1 보스

    void Init_Cam()
    {
        int index = islockTarget ? 1 : 0;
        Set_DistanceUp(false);
        minDistance = arr_cCamData[index].minDistance;
        VerticalAxis = maxDistance = arr_cCamData[index].maxDistance;
        cameraHeight = arr_cCamData[index].cameraHeight;
    }
    public void Add_Rot(float rot) { rotateAround += rot; }
    public void Set_Rot(float rot) { rotateAround = rot; }
    public bool IsEnter() { return CamStatus == 0; }
    public void Set_Target(Transform _target)
    {
        target = _target;
        isTarget = target;
        if (isTarget)
        {
            m_Target = target.GetComponent<Actor>();
            Add_CamActionTarget(_target);
        }
    }
    public void Set_Target(Transform _target, float _camrot)
    {
        Set_Target(_target);
        CamStatus = 0;
        rotateAround = _camrot;
        Init_Cam();
    }
    public void Set_DistanceUp(bool vertical)
    {
        //DistanceUp = vertical ? 0f : arr_cCamData[islockTarget ? 1 : 0].DistanceUp;
        DistanceUp = vertical ? arr_cCamData[0].DistanceUp : arr_cCamData[islockTarget ? 1 : 0].DistanceUp;
    }
    public void Set_InsideBuilding(bool _active)
    {
        if (_active)
        {
            maxDistance = minDistance = 2f;
            DistanceUp = 1.5f;
            cameraHeight = 25f;
        }
        else
        {
            Init_Cam();
        }
    }
    public void Set_FollowTarget(Actor target)
    {
        m_followTarget = target;
        CamStatus = target ? 2 : 1;
    }
    public void Set_TopView(Actor target)
    {
        m_followTarget = target;
        CamStatus = target ? 3 : 1;
    }
    public void Add_CamActionTarget(Transform _target) { list_tfCamactionTarget.Add(_target); }
    public void Set_LockTarget(Transform locktarget)
    {
        tf_lockTarget = locktarget;
        islockTarget = tf_lockTarget;
        Init_Cam();
    }
    public void Set_TargetShow(Transform _target)
    {
        if (CamStatus != 0 && isTarget)
        {
            // 매개변수 타겟을 보게 카메라 회전
            Set_CamDummy(_target);
            Set_Coroutine(() => { rotateAround = godummy.transform.eulerAngles.y - 45f; }, 0.1f);
        }
    }
    void Set_CamDummy(Transform _target)
    {
        if (godummy == null) godummy = new GameObject("CamDummy");
        godummy.transform.position = target.position;
        godummy.transform.LookAt(_target);
    }
    public void Set_Axis(bool _horizontal, float _value)
    {
        DragEndTime = 1f;
        if (_horizontal) HorizontalAxis = _value;
        else             VerticalAxis = _value;
        //NewGameUI.Ins.m_GuideQuestUI.Add_GuideQuest(ePurpose.ScreenRot);
    }
    public void Set_AutoCam_byMyPC()
    {
        if (DragEndTime <= 0f)
        {
            if (DSUtil.CheckNull(gowitch)) gowitch = new GameObject("witchDummy");
            gowitch.transform.position = MyValue.MyPC.Get_position() + MyValue.MyPC.transform.forward;
            Set_TargetShow(gowitch.transform);
        }
    }
    public void MoveCam_TargetBack(Vector3 targetpos)
    {
        transform.position = targetpos;
        RotateCam_TargetBack();
    }
    public void RotateCam_TargetBack() { rotateAround = target.eulerAngles.y - 45f; }

    // Use this for initialization
    void Start()
    {
        //the statement below automatically positions the camera behind the target.
        //rotateAround = target.eulerAngles.y - 45f;
    }

    void LateUpdate()
    {
        Shaking();
        if (DragEndTime > 0f) DragEndTime -= Time.deltaTime;
        if (!isTarget) return;
        //if (m_Target.Get_CurAnim() == eAnim.Attack) return;

        // 캐릭터의 이동 방향 계산
        //Vector3 direction = target.position - previousPosition;

        //// 이동 방향이 존재할 때 캐릭터가 보는 방향으로 카메라 회전
        //if (direction.sqrMagnitude > 0.01f)
        //{
        //    // 캐릭터가 움직이고 있는 방향으로 회전 목표 각도 계산
        //    float targetRotationAngle = Mathf.Atan2(direction.x, direction.z) * Mathf.Rad2Deg;

        //    // 현재 회전 각도에서 목표 회전 각도로 부드럽게 보간
        //    rotateAround = Mathf.LerpAngle(rotateAround, targetRotationAngle, rotationSpeed * Time.deltaTime);
        //}

        // 카메라를 설정된 로직에 따라 업데이트
        if (CamStatus == 0)
        {
            var camTarget = list_tfCamactionTarget[0];
            Vector3 lTargetDir = camTarget.position - transform.position;
            transform.rotation = Quaternion.Slerp(transform.rotation, Quaternion.LookRotation(lTargetDir + m_LookAt), Time.deltaTime * 2.5f);

            Vector3 targetOffset = target.position;
            Quaternion rotation = Quaternion.Euler(cameraHeight, rotateAround, cameraPan);
            Vector3 vectorMask = Vector3.one;
            Vector3 rotateVector = rotation * vectorMask;
            DistanceAway = Mathf.Clamp(DistanceAway += VerticalAxis, minDistance, maxDistance);
            camPosition = targetOffset + Vector3.up * DistanceUp - rotateVector * DistanceAway;
            //transform.position = Vector3.Lerp(transform.position, camPosition, Time.deltaTime * 2.5f);
            transform.position = Vector3.Lerp(transform.position, camPosition, 1f); // 즉시 이동

            if (Vector3.Distance(transform.position, camPosition) < 0.05f)
            {
                list_tfCamactionTarget.RemoveAt(0);
                if (list_tfCamactionTarget.Count <= 0)
                {
                    CamStatus = 1;
                    Start_Game();
                }
            }
        }
        else if (CamStatus == 1)
            Update_Cam();
        else if (CamStatus == 2)
        {
            if (m_followTarget == null) return;

            // 팔로우 타겟 기준 위치 설정
            Vector3 followOffset = m_followTarget.transform.position + m_followTarget.transform.right * CamStatus2_x +
                                   Vector3.up * CamStatus2_up;

            // 카메라 위치 보간
            transform.position = Vector3.Lerp(transform.position, followOffset, Time.deltaTime * 5f);

            // 타겟의 머리 또는 약간 위를 보도록 설정
            Vector3 lookTarget = m_followTarget.transform.position + Vector3.up * CamStatus2_up;

            // 회전도 자연스럽게 보간
            Quaternion targetRot = Quaternion.LookRotation(lookTarget - transform.position);
            transform.rotation = Quaternion.Slerp(transform.rotation, targetRot, Time.deltaTime * 5f);
        }
        else if (CamStatus == 3)
        {
            transform.position = m_followTarget.Get_position() + Vector3.up * 10f;
            transform.eulerAngles = new Vector3(90f, transform.eulerAngles.y);
        }
    }
    public float CamStatus2_x = 4f; // 특정 스킬뷰
    public float CamStatus2_up = 1.4f; // 특정 스킬뷰

    void Start_Game()
    {
        ActorInfo.Ins.All_Stop(false);
        Time.timeScale = MyValue.Get_GameSpeed();
        DungeonInfo.Ins.Start_Dungeon(true);
    }

    void Update_Cam()
    {
        m_MoveLead.Evaluate(target, m_Target, transform, DistanceAway, cameraHeight,
                            out Vector3 leadOffset, out float pitchAdd, out float yawAdd);

        Vector3 targetOffset = target.position + leadOffset;
        Quaternion rotation = Quaternion.Euler(cameraHeight + pitchAdd, rotateAround + yawAdd, cameraPan);
        Vector3 vectorMask = Vector3.one;
        Vector3 rotateVector = rotation * vectorMask;
        camPosition = targetOffset + Vector3.up * DistanceUp - rotateVector * DistanceAway;
        camMask = targetOffset + Vector3.up * DistanceUp - rotateVector * DistanceAway;

        //occludeRay(ref targetOffset);
        transform.position = Vector3.Lerp(transform.position, camPosition, Time.deltaTime * smooth);

        if (m_BackMove)
        {
            Vector3 backOffsetDirection = -transform.forward.normalized * m_BackOffSet.z;
            transform.position += new Vector3(backOffsetDirection.x, 0f, backOffsetDirection.z);
        }

        if (islockTarget)
        {
            Set_CamDummy(tf_lockTarget);
            rotateAround = godummy.transform.eulerAngles.y - 45f;
        }

        transform.LookAt(target.position + leadOffset + m_LookAt);

        #region wrap the cam orbit rotation
        if (rotateAround > 360)     rotateAround = 0f;
        else if (rotateAround < 0f) rotateAround += 360f;
        #endregion

        rotateAround += HorizontalAxis * camRotateSpeed * Time.deltaTime;

        if (HorizontalAxis >= -0.1f || HorizontalAxis <= 0.1f) HorizontalAxis = 0f;
        //DistanceUp = Mathf.Clamp(DistanceUp += VerticalAxis, -0.79f, 2.3f);
        DistanceAway = Mathf.Clamp(DistanceAway += VerticalAxis, minDistance, maxDistance);
        if (VerticalAxis >= -0.1f || VerticalAxis <= 0.1f)
            VerticalAxis = 0f;
    }

    void occludeRay(ref Vector3 targetFollow)
    {
        #region prevent wall clipping
        //declare a new raycast hit.
        //linecast from your player (targetFollow) to your cameras mask (camMask) to find collisions.
        if (Physics.Linecast(targetFollow, camMask, out RaycastHit wallHit, CamOcclusion))
        {
            if (wallHit.collider.tag == "Untagged" && wallHit.collider.GetComponent<Actor>() == null &&
               (wallHit.collider.GetComponent<BoxCollider>() != null || wallHit.collider.GetComponent<MeshCollider>() != null || wallHit.collider.GetComponent<TerrainCollider>() != null))
            {
                //the smooth is increased so you detect geometry collisions faster.
                smooth = 10f;
                //the x and z coordinates are pushed away from the wall by hit.normal.
                //the y coordinate stays the same.
                camPosition = new Vector3(wallHit.point.x + wallHit.normal.x * 0.5f, camPosition.y, wallHit.point.z + wallHit.normal.z * 0.5f);
            }
        }
        else
            smooth = 4f;
        #endregion
    }

    #region 카메라 흔들림
    [Header("Camera Shake")]
    float m_shakeDuration = 0.3f;
    float m_shakeMagnitude = 0.1f;
    public AnimationCurve shakeCurve = AnimationCurve.EaseInOut(0, 1, 1, 0);

    private float m_shakeTimer = 0f;
    private Vector3 originalPosition;
    int curShakeType;

    /// <summary>
    /// shaketype : 0 약하게 1 보통 2 세게
    /// </summary>
    public void ShakeCamera(int shaketype)
    {
        //if (CamStatus == 3) return;
        if (curShakeType == shaketype && m_shakeTimer > 0f)
            return;

        curShakeType = shaketype;

        switch (shaketype)
        {
            default:
            case 0: // 약하게
                m_shakeMagnitude = 0.05f;
                m_shakeDuration = 0.2f;
                m_shakeTimer = 0.15f;
                break;
            case 1: // 보통
                m_shakeMagnitude = 0.1f;
                m_shakeDuration = 0.3f;
                m_shakeTimer = 0.25f;
                break;
            case 2: // 세게
                m_shakeMagnitude = 0.2f;
                m_shakeDuration = 0.4f;
                m_shakeTimer = 0.5f;
                break;
        }

        originalPosition = transform.localPosition;
    }

    void Shaking()
    {
        if (m_shakeTimer > 0f)
        {
            float percentComplete = 1 - (m_shakeTimer / m_shakeDuration);
            float damper = shakeCurve.Evaluate(percentComplete);

            Vector3 shakeOffset = Random.insideUnitSphere * m_shakeMagnitude * damper;
            //shakeOffset.y = 0; // 수직 흔들림 제거

            transform.localPosition = originalPosition + shakeOffset;
            m_shakeTimer -= Time.deltaTime;

            if (m_shakeTimer <= 0f)
                StopShake();
        }
    }

    public void StopShake()
    {
        m_shakeTimer = 0f;
        transform.localPosition = originalPosition;
    }
    #endregion
}