카메라 부분 입니다


using System.Collections;

using System.Collections.Generic;

using UnityEngine;


public class CameraManager : MonoBehaviour

{

    [SerializeField] MovingAction _movingAction;

    [SerializeField] Transform _target;

    [SerializeField] float _rotSpeed;


    public Vector3 offset { get; private set; }

    bool _cameraMove = false;

    bool _cameraRotate = false;

    

    void Start()

    {

        offset = new Vector3(transform.position.x, transform.position.y, transform.position.z);

        _movingAction._isFrontBackMoving += CameraMove;

        _movingAction._isLeftRightMoving += CameraRotate;

    }


    void LateUpdate()

    {

        if (_cameraMove)

            transform.position = _target.position + offset;


        if (_cameraRotate)

            transform.LookAt(_target);

    }


    void CameraMove()

    {

        _cameraMove = true;

    }


    void CameraRotate()

    {

        _cameraRotate = true;

    }

}


------------------------------------------------------------------------------------------------------------


이동하는 부분입니다.


using System.Collections;

using System.Collections.Generic;

using UnityEngine;

using static CustomPhysics;

using static ActorController;


public class MovingAction : BaseAction

{

    [Header("Action Data")]

    [SerializeField] float _runAniSpeed;

    [SerializeField] float _moveSpeed;

    [SerializeField] float _rotSpeed;

    [SerializeField] float _rotateSpeed;


    int _layerMask = (1 << 8);


    float minAzimuth = 0.0f; 

    float maxAzimuth = 360f; 


    float _minAzimuth; 

    float _maxAzimuth; 


    float _azimuth = 0.0f; 


    float _radius; 


    public delegate void IsFrontBackMoving();

    public event IsFrontBackMoving _isFrontBackMoving;


    public delegate void IsLeftRightMoving();

    public event IsLeftRightMoving _isLeftRightMoving;


    [SerializeField] CameraManager _cameraManager;


    public override void StartAction()

    {

        _minAzimuth = Mathf.Deg2Rad * minAzimuth;

        _maxAzimuth = Mathf.Deg2Rad * maxAzimuth;

        _radius = Vector3.Distance(Vector3.zero, _cameraManager.offset);

    }


    public override void UpdateAction()

    {

        _animator.SetFloat("Moving", Mathf.Min(1, _animator.GetFloat("Moving") + _runAniSpeed * Time.deltaTime));

    }


    void Moving(float moveDir, float moveDis)

    {

        if (moveDis * moveDis > Mathf.Epsilon)

        {

            Vector3 _moveDis = new Vector3(0.0f, 0.0f, moveDis).normalized;

            //Debug.Log(moveDis);

            _owner.transform.position = FixedMoveVector(_owner.transform.position, _moveDis * Time.fixedDeltaTime * _moveSpeed, _layerMask);

            _owner.transform.rotation = Quaternion.Slerp(_owner.transform.rotation, Quaternion.LookRotation(_moveDis), Time.fixedDeltaTime * _rotSpeed);

            _isFrontBackMoving();

        }


        if (moveDir * moveDir > Mathf.Epsilon)

        {

            Rotate(moveDir * Time.fixedDeltaTime * _rotateSpeed);

            Vector3 pos = _owner.transform.position;

            _owner.transform.position = SphericalCoordinates(pos);

            _owner.transform.rotation = Quaternion.Slerp(_owner.transform.rotation, Quaternion.LookRotation(SphericalRotateCoordinates(pos, moveDir)),                             Time.fixedDeltaTime * _rotSpeed);

            _isLeftRightMoving();

        }

    }


    public Vector3 SphericalCoordinates(Vector3 _pos)

    {

        _pos.x = _radius * Mathf.Sin(_azimuth);

        _pos.z = _radius * Mathf.Cos(_azimuth) - _radius;

        Vector3 result = new Vector3(_pos.x, 0.0f, _pos.z);

        return result;

    }


    public Vector3 SphericalRotateCoordinates(Vector3 _pos, float _moveDir)

    {

        _pos.x = _radius * Mathf.Sin(_azimuth);

        _pos.z = _radius * Mathf.Cos(_azimuth) - _radius;


        if (_moveDir > 0)

        {

            Vector3 resultRotate1 = new Vector3(_pos.z + _radius, 0.0f, -_pos.x);

            return resultRotate1;

        }


        else

        {

            Vector3 resultRotate = new Vector3(-_pos.z - _radius, 0.0f, +_pos.x);

            return resultRotate;

        }

    }


    public void Rotate(float newAzimuth)

    {

        _azimuth += newAzimuth;

        _azimuth = Mathf.Repeat(_azimuth, _maxAzimuth - _minAzimuth);

    }

}



---------------------------------------------------------------------------------------