📌 Unity 게임 개발 심화

---

---

📌 RPG FSM 프로젝트 셋팅

➔ URP란?

Unity의 Universal Render Pipeline의 약자로, 스크립트 가능한 렌더 파이프라인(Scriptable Render Pipeline)이다.

다음과 같은 특징을 가지고 있다.

• Cross-Platform Compatibility : URP는 Unity가 지원하는 모든 플랫폼에서 동작하도록 설계되었다. 이는 모바일, 데스크톱, 콘솔 게임 뿐만 아니라 AR, VR 어플리케이션에도 적합하다.

• Performance and Scalability : URP는 성능 및 확장성을 목표로 설계되었다. 특히 저사양 장치에서도 뛰어난 성능을 제공하도록 최적화되어 있다. 또한, 그래픽 설정을 쉽게 조절할 수 있어 다양한 장치에 적합하게 스케일링 할 수 있다.

• Modern Rendering Features : URP는 현대적인 렌더링 기술을 제공한다. 이에는 주요 라이트 유형, 표준 쉐이딩 모델, 환경 리플렉션 등이 포함된다.

• Customizability : URP는 사용자 정의 렌더링 파이프라인을 생성할 수 있도록 해주는 유연성을 제공한다. 이를 통해 특정 게임 또는 프로젝트에 필요한 고유한 렌더링 기능을 추가할 수 있다.

• Graphics Quality : URP는 높은 품질의 그래픽을 제공한다. 이는 향상된 라이트 모델, 표면 쉐이딩, 포스트 프로세싱 효과 등을 사용하여 휙득된다.

• Simplicity : URP는 Unity의 기존 렌더링 시스템에 비해 사용하기 쉽다. 이는 그래픽 설정을 단순화하고, 초기 설정을 쉽게 하도록 도와주는 도구가 포함되어 있다.

---

📌 상태 머신(FSM) 이란?

➔ 🔥 핵심 내용

유한 상태 머신 (FSM)

• 유한 상태 기계 (Finite State Machine, FSM)

• FSM의 개념

  • FSM은 유한 상태 기계를 나타내는 디자인 패턴이다.
  • 상태와 상태 간의 전환을 기반으로 동작하는 동작 기반 시스템이다.

• FSM의 구성 요소

  • 상태(State) : 시스템이 취할 수 있는 다양한 상태를 나타낸다.
  • 전환 조건(Transition Condition) : 상태 간 전환을 결정하는 조건이다.
  • 동작(Action) : 상태에 따라 수행되는 동작 또는 로직을 나태난다.

• FSM의 동작 원리

  • 초기 상태에서 시작하여 입력 또는 조건에 따라 상태 전환을 수행한다.
  • 상태 전환은 전환 조건을 충족할 때 발생하며, 전환 조건은 입력, 시간, 조건 등으로 결정된다.
  • 상태 전환 시 이전 상태의 종료 동작과 새로운 상태의 진입 동작이 수행된다.

• FSM의 장점

  • 상태를 명확하게 정의하고 상태 간 전환을 일관되게 괸리할 수 있다.
  • 복잡한 동작을 상태와 전환 조건으로 나누어 구현하므로 코드 유지 보수가 용이하다.
  • 다양한 동작을 유기적으로 조합하여 원하는 동작을 구현할 수 있다.

• FSM의 예시 : 플레이어 상태 관리

  • 상태 : 정지 상태, 이동 상태, 점프 상태
  • 전환 조건 : 이동 입력, 점프 입력, 충돌 등의 조건
  • 동작 : 이동 애니메이션 재생, 점프 처리, 이동 속도 조정 등

---

📌 플레이어 상태머신 준비

➔ 🔥 핵심 내용

프로빌더(ProBuilder)

프로빌더(ProBuilder)는 Unity의 유용한 에셋 중 하나로, 게임 개발자들이 빠르고 쉽게 3D 모델을 만들고 편집하는 도구이다. 기본적으로 Unity에서 제공하는 기능으로, 유료 라이센스가 필요없이 무료로 사용할 수 있다.

프로빌더의 주요 기능과 특징은 다음과 같다.

• 3D 모델링 : 프로빌더는 내장된 도구들을 사용하여 3D모델을 쉽게 생성할 수 있다. 기본적인 기하 도형(정육면체, 원기둥 등)을 생성하거나, 다른 모델링 도구를 사용하여 더 복잡한 모델은 만들 수 있다.

• 편집과 수정 : 프로빌더는 객체를 선택하고 이동, 회전 스케일 등을 수행하는 편집 도구를 포함하고 있다. 또한 정점, 엣지, 면 수준에서 세부적인 편집이 가능하다.

• UV 매핑 : 3D모델의 텍스처 UV매핑을 프로빌더에서 직접 할 수 있다. 이를 통해 텍스처를 정확하게 적용할 수 있다.

• 콜리전 설정 : 프로빌더는 간단한 콜리전 메쉬를 만들 수 있으며, 이를 통해 게임 캐릭터나 객체와 상호작용하는데 적용할 수 있다.

• 성능 최적화 : 프로빌더는 다른 모델링 도구와 함께 사용하여 메시의 폴리곤 개수를 최적화하고 게임 성능을 향상시킬 수 있다.

캐릭터 컨트롤러(Character Controller)

캐릭터 컨트롤러(Character Controller)는 Unity에서 캐릭터나 플레이어의 움직임과 충돌을 관리하기 위해 사용되는 컴포넌트이다. 이 컴포넌트는 물리 엔진이 아닌 캐릭터의 움직임을 프레임 기반으로 처리하므로, 주로 3D캐릭터를 제어하는 데 사용된다.

캐릭터 컨트롤러의 주요 기능과 특징은 다음과 같다.

• 캐릭터 이동 : 캐릭터 컨트롤러는 단순한 이동을 쉽게 구현할 수 있도록 메서드를 제공한다. 주로 이동 방향과 이동 속력을 설정하여 캐릭터를 움직이게 한다.

• 중력 적용 : 캐릭터 컨트롤러는 중력을 적용하여 점프나 떨어짐을 자연스럽게 처리할 수 있다.

• 충돌 처리 : 캐릭터 컨트롤러는 물리 엔진을 사용하지 않고, 캐릭터의 충돌을 감지하고 처리할 수 있다. 다른 콜리더와의 충돌을 통제하고, 경사로와의 상호작용 등을 지원한다.

• 바닥 검출 : 캐릭터 컨트롤러는 캐릭터가 바닥 위에 놓이도록 바닥 검출을 처리한다. 바닥과의 거리, 표면 노멀 등을 고려하여 캐릭터의 높이를 조절하거나 점프를 가능하게 한다.

• 움직임 제한 : 캐릭터 컨트롤러는 움직임을 제한하는 기능도 제공한다. 지정된 영역 내에서만 움직이도록 하거나, 지형의 경사를 따라 이동할 수 있도록 설정할 수 있다.

➔ 프로젝트 준비

패키지 설치

• Input System
• Cinemachine
• Pro Builder

➔ 지형 만들기

프로 빌더 사용하기

• Tools - ProBuilder - ProBuilder Window

• New Shape 클릭 - Pro Builder Shape Size (50 0 50)

• 포함된 Texture01 드래그 앤 드랍

• 면과 선을 선택하여 다음과 같은 모양의 지형을 준비.
  큐브와 아치를 추가.

• Extrude Faces 면 생성

➔ 플레이어 만들기

오브젝트 만들기

• 빈 오브젝트 생성 - Player 이름 변경

• Paladin 모델 추가

텍스처 수정하기

• Window - Rendering - Render Pipeline Converter 클릭

• 전체 선택 - Convert 클릭

Input Action 만들기

• Input Action 생성

• 다음과 같이 설정

• Input Actions - Generate C# Class 체크 - Apply

➔ StateMachine 준비하기

PlayerInput.cs 작성

public class PlayerInput : MonoBehaviour
{
    public PlayerInputActions InputActions { get; private set; }
    public PlayerInputActions.PlayerActions PlayerActions { get; private set; }

    private void Awake()
    {
        InputActions = new PlayerInputActions();

        PlayerActions = InputActions.Player;
    }

    private void OnEnable()
    {
        InputActions.Enable();
    }

    private void OnDisable()
    {
        InputActions.Disable();
    }
}

PlayerAnimationData.cs 작성

[Serializable]
public class PlayerAnimationData
{
    [SerializeField] private string groundParameterName = "@Ground";
    [SerializeField] private string idleParameterName = "Idle";
    [SerializeField] private string walkParameterName = "Walk";
    [SerializeField] private string runParameterName = "Run";

    [SerializeField] private string airParameterName = "@Air";
    [SerializeField] private string jumpParameterName = "Jump";
    [SerializeField] private string fallParameterName = "Fall";

    [SerializeField] private string attackParameterName = "@Attack";
    [SerializeField] private string comboAttackParameterName = "ComboAttack";


    // 땅에 있다.
    public int GroundParameterHash { get; private set; }
    public int IdleParameterHash { get; private set; }
    public int WalkParameterHash { get; private set; }
    public int RunParameterHash { get; private set; }

    // 공중에 있다.
    public int AirParameterHash { get; private set; }
    public int JumpParameterHash { get; private set; }
    public int fallParameterHash { get; private set; }

    // 공격중이다.
    public int AttackParameterHash { get; private set; }
    public int ComboAttackParameterHash { get; private set; }

    // 해시 초기화 메서드
    public void Initialize()
    {
        GroundParameterHash = Animator.StringToHash(groundParameterName);
        IdleParameterHash = Animator.StringToHash(idleParameterName);
        WalkParameterHash = Animator.StringToHash(walkParameterName);
        RunParameterHash = Animator.StringToHash(runParameterName);

        AirParameterHash = Animator.StringToHash(airParameterName);
        JumpParameterHash = Animator.StringToHash(jumpParameterName);
        fallParameterHash = Animator.StringToHash(fallParameterName);

        AttackParameterHash = Animator.StringToHash(attackParameterName);
        ComboAttackParameterHash = Animator.StringToHash(comboAttackParameterName);
    }
}

Player.cs 작성

public class Player : MonoBehaviour
{
    // AnimationAdata를 Header에 연결
    [field: Header("Animations")]
    [field: SerializeField] public PlayerAnimationData AnimationData { get; private set; }

    public Rigidbody Rigidbody { get; private set; }
    public Animator Animator { get; private set; }
    public PlayerInput Input { get; private set; }
    public CharacterController Controller { get; private set; }

    private void Awake()
    {
        // AnimationData 초기화 진행
        AnimationData.Initialize();

        Rigidbody = GetComponent<Rigidbody>();
        Animator = GetComponentInChildren<Animator>();
        Input = GetComponent<PlayerInput>();
        Controller = GetComponent<CharacterController>();
    }

    private void Start()
    {
        // 처음 시작시 Cursor에 Lock을 걸어준다.
        Cursor.lockState = CursorLockMode.Locked;
    }
}

플레이어 오브젝트 설정

• Player 오브젝트 - Player.cs 추가

IState.cs 작성

public interface IState
{
    public void Enter();
    public void Exit();
    public void HandleInput();
    public void Update();
    public void PhysicsUpdate();
}

StateMachine.cs 작성

public abstract class StateMachine
{
    protected IState currentState;

    public void ChangeState(IState newState)
    {
        currentState?.Exit();   // 이 전 상태를 마무리
        currentState = newState;    // 새로운 상태 적용
        currentState.Enter();   // 다시 시작
    }

    // 현재 State의 Handle을 실행
    public void HandleInput()
    {
        currentState?.HandleInput();
    }

    // 현재 State의 Update() 실행
    public void Update()
    {
        currentState?.Update();
    }

    public void PhysicsUpdate()
    {
        currentState?.PhysicsUpdate();
    }
}

---

📌 플레이어 스테이트 머신 만들기

➔ Player Script Object 준비

PlayerGroundData.cs 작성

[Serializable]
public class PlayerGroundData   // 회전, 이동의 처리
{
    [field: SerializeField][field: Range(0f, 25f)] public float BaseSpeed { get; private set; } = 5f;
    [field: SerializeField][field: Range(0f, 25f)] public float BaseRotationDamping { get; private set; } = 1f;

    [field: Header("IdleData")]

    [field: Header("WalkData")]
    [field: SerializeField][field: Range(0f, 2f)] public float WalkSpeedModifier { get; private set; } = 0.225f;

    [field: Header("RunData")]
    [field: SerializeField][field: Range(0f, 2f)] public float RunSpeedModifier { get; private set; } = 1f;
}

PlayerAirData.cs 작성

[Serializable]
public class PlayerAirData // 점프 데이터
{
    [field: Header("JumpData")]
    [field: SerializeField][field: Range(0f, 25f)] public float JumpForce { get; private set; } = 4f;
}

PlayerSO.cs 작성

[CreateAssetMenu(fileName = "Player", menuName = "Characters/Player")]
public class PlayerSO : ScriptableObject
{
    [field: SerializeField] public PlayerGroundData GroundData { get; private set; }
    [field: SerializeField] public PlayerAirData AirData { get; private set; }
}

Data 생성

• Create메뉴를 통해 PlayerSO생성

• 아래아 같이 설정

➔ Player Ground State 구성

PlayerBaseState.cs 작성

public class PlayerBaseState : IState
{
    protected PlayerStateMachine stateMachine;
    protected readonly PlayerGroundData groundData;

    // 역참조
    public PlayerBaseState(PlayerStateMachine playerStateMachine)
    {
        stateMachine = playerStateMachine;
        groundData = stateMachine.Player.Data.GroundData;
    }

    public virtual void Enter()
    {
        AddInputActionsCallbacks();
    }

    public virtual void Exit()
    {
        RemoveInputActionsCallbacks();
    }

    public virtual void HandleInput()
    {
        ReadMovementInput();
    }

    public virtual void PhysicsUpdate()
    {
        
    }

    public virtual void Update()
    {
        Move();
    }

    // InputAction한테 Callback을 걸어줄 것이다. (Evnet를 걸어주던 느낌)
    protected virtual void AddInputActionsCallbacks()
    {

    }

    protected virtual void RemoveInputActionsCallbacks()
    {

    }

    private void ReadMovementInput()
    {
        // 역참조 & 캐싱 (자주 사용되는 애들은 미리 캐싱을 해두는게 좋다)
        stateMachine.MovementInput = stateMachine.Player.Input.PlayerActions.Movement.ReadValue<Vector2>();
    }

    // 실제 이동처리
    private void Move()
    {
        Vector3 movementDirection = GetMovementDirection();

        Rotate(movementDirection);

        Move(movementDirection);
    }

    // 카메라가 바라보는 방향으로 이동, 하기위한 방향
    private Vector3 GetMovementDirection()
    {
        Vector3 forward = stateMachine.MainCameraTransform.forward; // 메인 카메라가 바라보는 정면
        Vector3 right = stateMachine.MainCameraTransform.right; // 오른쪽을 받아온다.

        forward.y = 0;  // y값을 제거해야 땅바닥을 보고 가지 않는다.
        right.y = 0;

        // Normalize : Vector 자체를 Normalize한다.
        // Normalized : Vector를 Normalize해서 가지고온다.
        forward.Normalize();
        right.Normalize();

        // 각각 이동해야하는 Vector. 앞으로가는 Vector, 우측으로 가는 Vector 에다 입력한
        // 이동 방향의 값을 곱해서 이동
        return forward * stateMachine.MovementInput.y + right * stateMachine.MovementInput.x;
    }

    private void Move(Vector3 movementDiraction)
    {
        float movementSpeed = GetMovementSpeed();
        stateMachine.Player.Controller.Move((movementDiraction * movementSpeed) * Time.deltaTime);  // 이동 방향 * 이동 스피드
    }

    private void Rotate(Vector3 movementDirection)
    {
        if (movementDirection != Vector3.zero)  // 입력이 됐을 때, (zero가 아닐 때)
        {
            Transform playerTransform = stateMachine.Player.transform;
            Quaternion targetRotation = Quaternion.LookRotation(movementDirection); // ()안의 방향을 바라보는 Quaternion
            playerTransform.rotation = Quaternion.Slerp(playerTransform.rotation, targetRotation, stateMachine.RotationDamping * Time.deltaTime);   // Slerp : 타원형 보간        
        }
    }

    private float GetMovementSpeed()
    {
        float movementSpeed = stateMachine.MovementSpeed * stateMachine.MovementSpeedModifier;  // 실제로 이동해야 하는 속도
        return movementSpeed;
    }

    // 애니메이션 처리들
    protected void StartAnimation(int animationHash)
    {
        stateMachine.Player.Animator.SetBool(animationHash, true);
    }

    protected void StopAnimation(int animationHash)
    {
        stateMachine.Player.Animator.SetBool(animationHash, false);
    }
}

PlayerGroundedState.cs 작성

public class PlayerGroundState : PlayerBaseState
{
    public PlayerGroundState(PlayerStateMachine playerStateMachine) : base(playerStateMachine)
    {
    }

    public override void Enter()
    {
        base.Enter();
        // Ground에 있으면 GroundState라는 bool값이 켜져있을 것이라 Ground상태인지 검사 가능
        StartAnimation(stateMachine.Player.AnimationData.GroundParameterHash);
    }

    public override void Exit()
    {
        base.Exit();
        StopAnimation(stateMachine.Player.AnimationData.GroundParameterHash);
    }

    public override void Update()
    {
        base.Update();
    }

    public override void PhysicsUpdate()
    {
        base.PhysicsUpdate();
    }
}

PlayerIdleState.cs 작성

public class PlayerIdleState : PlayerGroundState // 땅에 있을 때, Idle을 할 테니 Ground상속
{
    public PlayerIdleState(PlayerStateMachine playerStateMachine) : base(playerStateMachine)
    {
    }

    public override void Enter()
    {
        stateMachine.MovementSpeedModifier = 0f;    // Idle상태에 움직임을 미연에 방지
        base.Enter();
        StartAnimation(stateMachine.Player.AnimationData.IdleParameterHash);
    }

    public override void Exit()
    {
        base.Exit();
        StopAnimation(stateMachine.Player.AnimationData.IdleParameterHash);
    }

    public override void Update()
    {
        base.Update();
    }
}

PlayerStateMachine.cs 작성

public class PlayerStateMachine : StateMachine
{
    public Player Player { get; }

    // States
    public PlayerIdleState idleState { get; }

    public Vector2 MovementInput { get; set; }  // Input 입력값 Vector
    public float MovementSpeed { get; private set; }    // 이동 속도
    public float RotationDamping { get; private set; }  // 회전 댐핑
    public float MovementSpeedModifier { get; set; } = 1f;  // 이동 관련 곱하기 값

    public float JumpForce { get; set; }

    public Transform MainCameraTransform { get; set; }

    // 생성자
    public PlayerStateMachine(Player player)
    {
        this.Player = player;

        idleState = new PlayerIdleState(this);

        MainCameraTransform = Camera.main.transform;

        MovementSpeed = player.Data.GroundData.BaseSpeed;
        RotationDamping = player.Data.GroundData.BaseRotationDamping;
    }
}

➔ Player 설정

Player.cs 수정

''' 생략
// 데이터를 가져올 수 있게 준비
[field: Header("References")]
[field: SerializeField] public PlayerSO Data { get; private set; }

''' 생략
private void Awake()
{
    // AnimationData 초기화 진행
    AnimationData.Initialize();

    Rigidbody = GetComponent<Rigidbody>();
    Animator = GetComponentInChildren<Animator>();
    Input = GetComponent<PlayerInput>();
    Controller = GetComponent<CharacterController>();
    stateMachine = new PlayerStateMachine(this);    // PlayerStateMachine 생성자에게 this(자기자신.Player)를 넘겨준다.
}

private void Start()
{
    // 처음 시작시 Cursor에 Lock을 걸어준다.
    Cursor.lockState = CursorLockMode.Locked;
    stateMachine.ChangeState(stateMachine.idleState);
}

private void Update()
{
    stateMachine.HandleInput();
    stateMachine.Update();
}

private void FixedUpdate()
{
    stateMachine.PhysicsUpdate();
}
''' 생략

오브젝트 설정

• PlayerSO 연결

• Player Input 추가

• Character Controller 추가

Animator 설정

• Animator Controller 생성

• 플레이어 모델 - Animator 추가 - Animator Controller 연결

Animator Controller 설정

• Sub Sub-Machine 추가 - Ground로 변경

• Parameters 추가

• Transition 설정

• 각 상황에 맞는 파라미터의 True, False를 조절
  Has Exit Time 체크 해제

---

📌 플레이어 이동 상태 만들기

➔ 이동 상태 만들기

PlayerBaseState.cs 수정

'''생략
// InputAction한테 Callback을 걸어줄 것이다. (Evnet를 걸어주던 느낌)
protected virtual void AddInputActionsCallbacks()
{
    PlayerInput input = stateMachine.Player.Input;
    input.PlayerActions.Movement.canceled += OnMoveCanceled;    // .canceled : 키가 떼어졌을 때
    input.PlayerActions.Run.started += OnRunStarted;
}

protected virtual void RemoveInputActionsCallbacks()
{
    PlayerInput input = stateMachine.Player.Input;
    input.PlayerActions.Movement.canceled -= OnMoveCanceled;    
    input.PlayerActions.Run.started -= OnRunStarted;
}

protected virtual void OnMoveCanceled(InputAction.CallbackContext context)
{
        
}

protected virtual void OnRunStarted(InputAction.CallbackContext context)
{
        
}
'''생략

PlayerGroundState.cs 수정

''' 생략
protected override void OnMoveCanceled(InputAction.CallbackContext context)
{
    if (stateMachine.MovementInput == Vector2.zero) // 입력이 없으면
    {
        return;
    }

    // 이동키가 떼어졌을 때, 이걸 왜 Ground에서 만드냐?
    // 공중(Air)상태 || 구를 때, 등 Ground가 아닌 다른 State에 있을 때, 키를 떼면 다른 동작을
    // 해야한다. Idle로 넘어오면 안된다. 그래서 이 동작은 Ground가 보는게 맞다.
    // Ground일 때, 키를 떼면 어떻게 할 것인가? 에 대한 것이니까.
    stateMachine.ChangeState(stateMachine.IdleState);

    base.OnMoveCanceled(context);
}

protected virtual void OnMove()
{
    // 이동이 일어나면 Walk로 옮겨준다.
    stateMachine.ChangeState(stateMachine.WalkState);
}

PlayerWalkState.cs 작성

public class PlayerWalkState : PlayerGroundState
{
    public PlayerWalkState(PlayerStateMachine playerStateMachine) : base(playerStateMachine)
    {
    }

    public override void Enter()
    {
        stateMachine.MovementSpeedModifier = groundData.WalkSpeedModifier;  // Walk의 속도로 곱해주는 값
        // 부모 PlayerGroundState가 갖고있는 Enter()를 실행해 Ground파라미터를 키고
        // 다시 돌아와서 Walk파라미터를 켜준다. 그러면 WalkState에 들어왔으면
        // Ground, Walk 두개의 bool값이 켜진다.
        base.Enter();   
        StartAnimation(stateMachine.Player.AnimationData.WalkParameterHash);
    }

    public override void Exit()
    {
        base.Exit();
        StopAnimation(stateMachine.Player.AnimationData.WalkParameterHash);
    }

    // Walk(걷다가) Run을 누른다? 그럼 Run으로 전환
    protected override void OnRunStarted(InputAction.CallbackContext context)
    {
        base.OnRunStarted(context);
        stateMachine.ChangeState(stateMachine.RunState);
    }
}

PlayerRunState.cs 작성

public class PlayerRunState : PlayerGroundState
{
    public PlayerRunState(PlayerStateMachine playerStateMachine) : base(playerStateMachine)
    {
    }

    // 이동처리 들은 Base에서 해주기 때문에 애니메이션 및 속도만 처리
    public override void Enter()
    {
        stateMachine.MovementSpeedModifier = groundData.RunSpeedModifier;   // Run 속도로
        base.Enter();
        StartAnimation(stateMachine.Player.AnimationData.RunParameterHash);
    }

    public override void Exit()
    {
        base.Exit();
        StopAnimation(stateMachine.Player.AnimationData.RunParameterHash);
    }
}

PlayerStateMachine.cs 수정

using System.Collections;
using System.Collections.Generic;
using UnityEngine;

public class PlayerStateMachine : StateMachine
{
''' 생략
    // States
    public PlayerIdleState IdleState { get; }
    public PlayerWalkState WalkState { get; }
    public PlayerRunState RunState { get; }

''' 생략

    public PlayerStateMachine(Player player)
    {
        this.Player = player;

        IdleState = new PlayerIdleState(this);
        WalkState = new PlayerWalkState(this);
        RunState = new PlayerRunState(this);

        MainCameraTransform = Camera.main.transform;

        MovementSpeed = player.Data.GroundedData.BaseSpeed;
        RotationDamping = player.Data.GroundedData.BaseRotationDamping;
    }
}

PlayerIdleState.cs 수정

''' 생략

public override void Update()
{
    base.Update();

    if (stateMachine.MovementInput != Vector2.zero) // 이동이 일어났다면?
    {
        OnMove();   // OnMove() : Idle에서 Walk로 바꿔주는 처리
        return;
    }
}

---

📌 시네머신 카메라 적용

➔ 🔥 핵심 내용

시네머신(Cinemachine)

시네머신(Cinemachine)은 Unity에서 제공하는 고급 카메라 시스템이다. 이 시스템은 게임, 영화, 애니메이션 등에서 다양한 카메라 워크플로우를 지원하며, 카메라 이동, 추적, 매핑, 블렌딩 등을 쉽게 구현할 수 있도록 도와준다. 시네머신은 Unity 2017 버전 이후부터 기본적으로 포함되어 있으며, 유니티 에셋 스토어에서도 추가적인 확장 패키지를 얻을 수 있다.

시네머신의 주요 기능과 특징은 다음과 같다.

• 가상 카메라(Virtual Camera) : 시네머신은 가상 카메라를 사용하여 실제 카메라가 없는 상태에서도 여러 가상 카메라의 시점과 속성을 조작할 수 있다. 각 가상 카메라는 독립적인 카메라 속성을 가지며, 원하는 순간에 활성화 되거나 비활성화될 수 있다.

• 카메라 블렌딩 : 여러 가상 카메라 간에 자연스럽게 전환하기 위해 블렌딩 기능을 제공한다. 카메라의 위치, 회전,시야 등이 부드럽게 전환되어 자연스러운 카메라 이동을 구현할 수 있다.

• 트랙링과 추적 : 시네머신은 오브젝트나 캐릭터를 추적하여 자동으로 카메라를 따라가도록 지원한다. 특정 타겟을 추적하거나 경로를 따라 이동하는 카메라 워크플로우를 구현할 수 있다.

• 애니메이션 연동 : 시네머신은 애니메이션 시스템과 연동하여 카메라의 속성을 애니메이션과 동기화할 수 있다.

• 렌즈 세트 : 렌즈 세트를 사용하여 렌즈 조작을 편리하게 할 수 있다. 줌, 화각, 특수 렌즈 효과 등을 쉽게 적용할 수 있다.

➔ 시네머신 추가하기

Virtual Camera 추가하기

• Create - Cinemachine - Virtual Camera 클릭

• CameraLookPoint 추가

• Virtual Camera 수정

• Body, Aim 수정

• Add Extension ➔ Cinemachine Collider 추가

---

📌 플레이어 점프 상태 만들기

➔ 힘 적용하기

ForceReceiver.cs 만들기

public class ForceReciver : MonoBehaviour
{
    [SerializeField] private CharacterController controller;
    [SerializeField] private float drag = 0.3f;

    private Vector3 dampingVelocity;
    private Vector3 impact;
    private float verticalVelocity;

    // impact : 추가적인 힘을 받으면? 그 힘을 사용하기 위한 impacte
    public Vector3 Movement => impact + Vector3.up * verticalVelocity; // verticalVelocity : 수직의 힘

    private void Update()
    {
        if (verticalVelocity < 0f && controller.isGrounded) // 땅에 붙어있는가?
        {
            verticalVelocity = Physics.gravity.y * Time.deltaTime; // gravity : -9.7 ?
        }
        else // 땅이 아니라면?
        {
            verticalVelocity += Physics.gravity.y * Time.deltaTime; // 가속도 처리
        }

        // SmoothDamp : current => target 까지 값의 부드러운 변화
        impact = Vector3.SmoothDamp(impact, Vector3.zero, ref dampingVelocity, drag);
    }

    // 떨어지는 힘 초기화
    public void Reset()
    {
        impact = Vector3.zero;
        verticalVelocity = 0f;
    }

    public void AddForce(Vector3 force)
    {
        impact += force;
    }

    public void Jump(float jumpForce)
    {
        verticalVelocity += jumpForce;
    }
}

Player.cs 수정

''' 생략
public ForceReceiver ForceReceiver { get; private set; }

''' 생략
ForceReceiver = GetComponent<ForceReceiver>();

PlayerBaseState.cs 수정

''' 생략

private void Move(Vector3 movementDiraction)
{
    float movementSpeed = GetMovementSpeed();
    stateMachine.Player.Controller.Move(((movementDiraction * movementSpeed) + stateMachine.Player.ForceReciver.Movement) * Time.deltaTime);  // 이동 방향 * 이동 스피드 + ForceReciver
}

➔ 점프 상태 만들기

PlayerBaseState.cs 수정

''' 생략
protected virtual void AddInputActionsCallbacks()
{
    PlayerInput input = stateMachine.Player.Input;
    input.PlayerActions.Movement.canceled += OnMovementCanceled;
    input.PlayerActions.Run.started += OnRunStarted;

    stateMachine.Player.Input.PlayerActions.Jump.started += OnJumpStarted;
}

protected virtual void RemoveInputActionsCallbacks()
{
    PlayerInput input = stateMachine.Player.Input;
    input.PlayerActions.Movement.canceled -= OnMovementCanceled;
    input.PlayerActions.Run.started -= OnRunStarted;

    stateMachine.Player.Input.PlayerActions.Jump.started -= OnJumpStarted;
}

protected virtual void OnJumpStarted(InputAction.CallbackContext context)
{

}
''' 생략

PlayerGroundState.cs 수정

''' 생략
protected override void OnJumpStarted(InputAction.CallbackContext context)
{
    // 점프 키가 눌리면 JumpState로 변경 (GroundState안이니 땅에 붙어있는 상태이다.)
    stateMachine.ChangeState(stateMachine.JumpState);
}

PlayerAirState.cs 만들기

public class PlayerAirState : PlayerBaseState
{
    public PlayerAirState(PlayerStateMachine playerStateMachine) : base(playerStateMachine)
    {
    }

    public override void Enter()
    {
        base.Enter();
        StartAnimation(stateMachine.Player.AnimationData.AirParameterHash);
    }

    public override void Exit()
    {
        base.Exit();
        StopAnimation(stateMachine.Player.AnimationData.AirParameterHash);
    }
}

PlayerJumpState.cs 만들기

public class PlayerJumpState : PlayerAirState
{
    public PlayerJumpState(PlayerStateMachine playerStateMachine) : base(playerStateMachine)
    {
    }

    public override void Enter()
    {
        stateMachine.JumpForce = stateMachine.Player.Data.AirData.JumpForce;    // SO에 설정한 점프 값 만큼
        stateMachine.Player.ForceReciver.Jump(stateMachine.JumpForce);  // 매개변수로 대입

        base.Enter();

        StartAnimation(stateMachine.Player.AnimationData.JumpParameterHash);
    }

    public override void Exit()
    {
        base.Exit();

        StopAnimation(stateMachine.Player.AnimationData.JumpParameterHash);
    }

    public override void PhysicsUpdate()
    {
        base.PhysicsUpdate();

        // velocity.y가 0보다 작아저 음수가 되어 떨어지는 시점이 될 때
        if (stateMachine.Player.Controller.velocity.y <= 0)
        {
            stateMachine.ChangeState(stateMachine.FallState);   // 떨어지는(Fall)로 전환
            return;
        }
    }
}

PlayerFallState.cs 만들기

public class PlayerFallState : PlayerAirState
{
    public PlayerFallState(PlayerStateMachine playerStateMachine) : base(playerStateMachine)
    {
    }

    public override void Enter()
    {
        base.Enter();

        StartAnimation(stateMachine.Player.AnimationData.fallParameterHash);
    }

    public override void Exit() 
    {
        base.Exit();
        StopAnimation(stateMachine.Player.AnimationData.fallParameterHash);
    }

    public override void Update()
    {
        base.Update();

        if (stateMachine.Player.Controller.isGrounded)
        {
            stateMachine.ChangeState(stateMachine.IdleState);
            return;    
        }
    }
}

PlayerStateMachine.cs 수정

'''생략
public PlayerJumpState JumpState { get; }
public PlayerFallState FallState { get; }

'''생략
JumpState = new PlayerJumpState(this);
FallState = new PlayerFallState(this);

Animator Controller 수정

• Air Sub-State 추가 ➔ @Air 파라메터를 이용해 Transition 만들기

• Ground를 참고하여 파라메터를 맞춰 Transition 만들기

➔ 추락 만들기

PlayerGroundState.cs 수정

''' 생략
public override void PhysicsUpdate()
{
    base.PhysicsUpdate();

    // 땅이 아닐 때 && velocity.y 값이 Physics.gravity.y * Time.fixedDeltaTime 보다 작을 때
    // Physics.gravity.y * Time.fixedDeltaTime : gravity를 한 타임에 적용하는 값 , 훨씬 더 빠른속도로 떨어지고 있다면
    // 즉, 땅이 아니고 떨어지고 있다면 FallState로 바꿔라
    if (!stateMachine.Player.Controller.isGrounded && stateMachine.Player.Controller.velocity.y < Physics.gravity.y * Time.fixedDeltaTime)
    {
       stateMachine.ChangeState(stateMachine.FallState);
       return;
    }
}

---

📌 플레이어 공격 상태 만들기

➔ 공격 상태 준비하기

AttackInfoData.cs 만들기

[Serializable]
public class AttackInfoData
{
    [field: SerializeField] public string AttackName { get; private set; } // 공격의 이름
    [field: SerializeField] public int ComboStateIndex { get; private set; } // 콤보 상태의 인덱스
    [field: SerializeField][field: Range(0f, 1f)] public float ComboTransitionTime { get; private set; } // 콤보가 유지되는 시간
    [field: SerializeField][field: Range(0f, 3f)] public float ForceTransitionTime { get; private set; } // 공격을 누르는 시간
    [field: SerializeField][field: Range(-10f, 10f)] public float Force { get; private set; } // 힘을 언제 클릭하면 언제 적용할건지

    [field: SerializeField] public int Damage { get; private set; }
}

[Serializable]
public class PlayerAttackData
{
    [field: SerializeField] public List<AttackInfoData> AttackInfoDatas { get; private set; } // 콤보에 대한 종류를 가짐
    public int GetAttackInfoCount() { return AttackInfoDatas.Count;} // AttackInfo에 대한 Count를 가져옴. 몇개인지
    public AttackInfoData GetAttackInfo(int index) {  return AttackInfoDatas[index]; } // index를 대입하면 현재 사용하고있는 AttackData에 대해서 가져옴 
}

PlayerSO 수정

'''생략
[field: SerializeField] public PlayerAttackData AttakData { get; private set; }

Animator Controller 수정

• Attack Sub-State 추가, Transition 추가 (@Attack)

• 1Attack ➔ 2Attack : Combo Equals 1
  2Attack ➔ 3Attack : Combo Equals 2
  
  
  Entry ➔ 2Attack : ComboAttack True, Combo Equals 1
  Enrty ➔ 3Attack : ComboAttack True, Combo Equals 2
  
  
  *\➔Exit : ComboAttack False

➔ 공격 상태 만들기

PlayerAttackState.cs 만들기

public class PlayerAttackState : PlayerBaseState
{
    public PlayerAttackState(PlayerStateMachine playerStateMachine) : base(playerStateMachine)
    {
    }

    public override void Enter()
    {
    	stateMachine.MovementSpeedModifier = 0; // 공격중에 움직이지 않게
        base.Enter();

        StartAnimation(stateMachine.Player.AnimationData.AttackParameterHash);
    }

    public override void Exit()
    {
        base.Exit();
        StopAnimation(stateMachine.Player.AnimationData.AttackParameterHash);
    }
}

PlayerStateMachine.cs 수정

'''생략
public PlayerComboAttackState ComboAttackState { get; }

'''생략
public bool IsAttacking { get; set; }
public int ComboIndex { get; set; }

public PlayerStateMachine(Player player)
{
	'''생략
	ComboAttackState = new PlayerComboAttackState(this);

PlayerBaseState.cs 수정

''' 생략
protected void ForceMove()
{
   // 위 Move()와 달리 Direction값(매개변수)를 받지않고 ForceReciver가 갖고있는 Movemenet값으로만 처리하도록 만들어졌을 뿐이다 stateMachine.Player.Controller.Move(stateMachine.Player.ForceReceiver.Movement * Time.deltaTime);
}

''' 생략
// InputAction한테 Callback을 걸어줄 것이다. (Evnet를 걸어주던 느낌)
protected virtual void AddInputActionsCallbacks()
{
    PlayerInput input = stateMachine.Player.Input;
    input.PlayerActions.Movement.canceled += OnMoveCanceled;    // .canceled : 키가 떼어졌을 때
    input.PlayerActions.Run.started += OnRunStarted;

    stateMachine.Player.Input.PlayerActions.Jump.started += OnJumpStarted;

    // 지금은 공격, 점프, 달리기, 이동 등 전부 공용으로 사용되는 키 이기 때문에 이런식으로
    // 만들어 두었지만, 나중에 특정 상태에서만 사용할 키를 구현한다고 하면, 여기서 고용으로
    // 만들기 보다는 각 상황의 큰 상태들, Ground, Ataack, Air 등 그곳에서 override해서 구현하는
    // 것이 훨씬 더 깔끔할 것이다.
    // 지금은 공용이니까.-> 공격버튼을 공중에서도 쓰고, 점프중에서도 쓰고 할 수있는 상태이기 때문
    stateMachine.Player.Input.PlayerActions.Attack.performed += OnAttackPerformed;
    stateMachine.Player.Input.PlayerActions.Attack.canceled += OnAttackCanceled;
}

protected virtual void RemoveInputActionsCallbacks()
{
    PlayerInput input = stateMachine.Player.Input;
    input.PlayerActions.Movement.canceled -= OnMovementCanceled;
    input.PlayerActions.Run.started -= OnRunStarted;

    stateMachine.Player.Input.PlayerActions.Jump.started -= OnJumpStarted;

    stateMachine.Player.Input.PlayerActions.Attack.performed -= OnAttackPerformed;
    stateMachine.Player.Input.PlayerActions.Attack.canceled -= OnAttackCanceled;
}

// Performed : 눌려지고 있는 동안에는 true
protected virtual void OnAttackPerformed(InputAction.CallbackContext obj)
{
    stateMachine.IsAttacking = true;
}

// Cancel : 떼면 false
protected virtual void OnAttackCanceled(InputAction.CallbackContext obj)
{
    stateMachine.IsAttacking = false;
}

'''생략
protected float GetNormalizedTime(Animator animator, string tag)
{
    AnimatorStateInfo currentInfo = animator.GetCurrentAnimatorStateInfo(0); // GetCurrentAnimatorStateInfo : 현재 애니메이션 정보
    AnimatorStateInfo nextInfo = animator.GetNextAnimatorStateInfo(0); // GetNextAnimatorStateInfo : 다음 애니메이션 정보

    // IsInTransition : 매개변수로 받은 animator가 라인을 타고있나?
    // nextInfo.IsTag(tag) : 다음 tag가 Attack(매개변수 tag)인가?
    if (animator.IsInTransition(0) && nextInfo.IsTag(tag))
    {
        // 블랜지드 되어서 섞이고 있기 때문에 이미 트랜지션을 탔으면 다음 애니메이션을 가져오는 것이 맞다.
        return nextInfo.normalizedTime; // 다음꺼에 대한 normalizedTime을 넘겨줌
    }
    else if (!animator.IsInTransition(0) && currentInfo.IsTag(tag)) // currentInfo.IsTag(tag) : 나의 태그가 Attack이냐?
    {
        return currentInfo.normalizedTime; // 현재를 넘겨줌
    }
    else
    {
        return 0; // 둘 다 아니면 Attack이 아니라는 것. 0을 return;
    }
}

PlayerComboAttack.cs 만들기

public class PlayerComboAttackState : PlayerAttackState
{
    private bool alreadyAppliedForce; // 콤보를 적용 했는지
    private bool alreadyApplyCombo; // 포스를 적용 했는지

    AttackInfoData attackInfoData;

    public PlayerComboAttackState(PlayerStateMachine playerStateMachine) : base(playerStateMachine)
    {
    }

    public override void Enter()
    {
        base.Enter();

        StartAnimation(stateMachine.Player.AnimationData.ComboAttackParameterHash);

        // 가지고 있는 값의 초기화
        alreadyAppliedForce = false;
        alreadyApplyCombo = false;

        int comboIndex = stateMachine.ComboIndex;
        attackInfoData = stateMachine.Player.Data.AttackData.GetAttackInfo(comboIndex); // 현재 사용해야 하는 comboIndex에 대한 ComboAttack의 정보
        stateMachine.Player.Animator.SetInteger("Combo", comboIndex);
    }

    public override void Exit()
    {
        base.Exit();
        StopAnimation(stateMachine.Player.AnimationData.ComboAttackParameterHash);

        // 콤보를 적용하지 못한 상태로 이 State가 끝났다면, 공격중에 콤보를 성공하지 않앗다는 것
        // 그러니까 콤보정보를 0으로 돌려놔야 다음에 다시 공격할 때, 첫 콤보공격부터 나간다.
        if (!alreadyApplyCombo)
            stateMachine.ComboIndex = 0;    // 콤보를 적용하지 않았다면, 0으로 만든다.
    }

    private void TryComboAttack()
    {
        if (alreadyApplyCombo) return;  // 콤보어택을 이미 했다면?(true라면) return;

        if (attackInfoData.ComboStateIndex == -1) return; // Index가 -1 ? 즉 마지막 공격 그럼 return;

        if (!stateMachine.IsAttacking) return; // !IsAttacking ? 공격이 끝났다는 것, 그럼 return;

        alreadyApplyCombo = true; // 위에 모든 조건이 아니라 하면? true
    }

    private void TryApplyForce()
    {
        if (alreadyAppliedForce) return;    // 이미 적용한 적이 있다? return;
        alreadyAppliedForce = true; // 아니면 true;

        stateMachine.Player.ForceReciver.Reset();   // 갖고있던 힘. Force를 Reset

        // AddForce() : 내가 바라보고있는 정면에서 밀려나게
        stateMachine.Player.ForceReciver.AddForce(stateMachine.Player.transform.forward * attackInfoData.Force);
    }

    public override void Update()
    {
        base.Update();

        ForceMove();

        // animator의 tag값을 넘겨 해당 애니메이션의 normalizedTime을 가져온다.
        float normalizedTime = GetNormalizedTime(stateMachine.Player.Animator, "Attack"); 
        if (normalizedTime < 1f)    // 1보다 작다? 그럼 아직 애니메이션 진행중
        {
            if (normalizedTime >= attackInfoData.ForceTransitionTime)
                TryApplyForce(); // 힘 적용

            if (normalizedTime >= attackInfoData.ComboTransitionTime)
                TryComboAttack(); // 콤보 적용
        }
        else // 아니다? 처리 끝났을 때
        {
            if (alreadyApplyCombo)  // 콤보가 진행중? 다음 콤보로 변경
            {
                stateMachine.ComboIndex = attackInfoData.ComboStateIndex;
                stateMachine.ChangeState(stateMachine.ComboAttackState);
            }
            else
            {
                stateMachine.ChangeState(stateMachine.IdleState);
            }
        }
    }
}

PlayerGroundState.cs 수정

''' 생략
public override void Update()
{
    base.Update();

    if (stateMachine.IsAttacking) // IsAttacking 이 true라면?
    {
        OnAttack(); // 실행
        return;
    }
}

---

📌 적 만들기

Player와 거의 유사하다.

➔ 적 상태 머신 준비하기

EnemyStateMachine.cs 만들기

public class EnemyStateMachine : StateMachine
{
    public Enemy Enemy { get; }

    public Transform Target { get; private set; }

    public EnemyIdleState IdlingState { get; }
    public EnemyChasingState ChasingState { get; }
    public EnemyAttackState AttackState { get; }

    public Vector2 MovementInput { get; set; }
    public float MovementSpeed { get; private set; }
    public float RotationDamping { get; private set; }
    public float MovementSpeedModifier { get; set; } = 1f;

    public EnemyStateMachine(Enemy enemy)
    {
        Enemy = enemy;
        Target = GameObject.FindGameObjectWithTag("Player").transform;

        IdlingState = new EnemyIdleState(this);
        ChasingState = new EnemyChasingState(this);
        AttackState = new EnemyAttackState(this);

        MovementSpeed = enemy.Data.GroundedData.BaseSpeed;
        RotationDamping = enemy.Data.GroundedData.BaseRotationDamping;
    }
}

Enemy.cs 만들기

public class Enemy : MonoBehaviour
{
    [field: Header("References")]
    [field: SerializeField] public EnemySO Data { get; private set; }

    [field: Header("Animations")]
    [field: SerializeField] public PlayerAnimationData AnimationData { get; private set; }

    public Rigidbody Rigidbody { get; private set; }
    public Animator Animator { get; private set; }
    public ForceReciver ForceReceiver { get; private set; }
    public CharacterController Controller { get; private set; }

    private EnemyStateMachine stateMachine;

    void Awake()
    {
        AnimationData.Initialize();

        Rigidbody = GetComponent<Rigidbody>();
        Animator = GetComponentInChildren<Animator>();
        Controller = GetComponent<CharacterController>();
        ForceReceiver = GetComponent<ForceReciver>();

        stateMachine = new EnemyStateMachine(this);
    }

    private void Start()
    {
        stateMachine.ChangeState(stateMachine.IdlingState);
    }

    private void Update()
    {
        stateMachine.HandleInput();

        stateMachine.Update();
    }

    private void FixedUpdate()
    {
        stateMachine.PhysicsUpdate();
    }
}

EnemySO.cs 만들기

[CreateAssetMenu(fileName = "EnemySO", menuName = "Characters/Enemy")]
public class EnemySO : ScriptableObject
{
    [field: SerializeField] public float PlayerChasingRange { get; private set; } = 10f;
    [field: SerializeField] public float AttackRange { get; private set; } = 1.5f;
    [field: SerializeField][field: Range(0f, 3f)] public float ForceTransitionTime { get; private set; }
    [field: SerializeField][field: Range(-10f, 10f)] public float Force { get; private set; }
    [field: SerializeField] public int Damage { get; private set; }
    [field: SerializeField][field: Range(0f, 1f)] public float Dealing_Start_TransitionTime { get; private set; }
    [field: SerializeField][field: Range(0f, 1f)] public float Dealing_End_TransitionTime { get; private set; }

    [field: SerializeField] public PlayerGroundData GroundedData { get; private set; }
}

➔ 적 상태 적용하기

EnemyBaseState.cs 만들기

// Player와 거의 동일
public class EnemyBaseState : IState
{
    protected EnemyStateMachine stateMachine;

    protected readonly PlayerGroundData groundData;
    public EnemyBaseState(EnemyStateMachine ememyStateMachine)
    {
        stateMachine = ememyStateMachine;
        groundData = stateMachine.Enemy.Data.GroundedData;
    }

    public virtual void Enter()
    {

    }

    public virtual void Exit()
    {

    }

    public virtual void HandleInput()
    {

    }

    public virtual void Update()
    {
        Move();
    }

    public virtual void PhysicsUpdate()
    {

    }

    protected void StartAnimation(int animationHash)
    {
        stateMachine.Enemy.Animator.SetBool(animationHash, true);
    }

    protected void StopAnimation(int animationHash)
    {
        stateMachine.Enemy.Animator.SetBool(animationHash, false);
    }

    private void Move()
    {
        Vector3 movementDirection = GetMovementDirection();

        Rotate(movementDirection);
        Move(movementDirection);
    }

    protected void ForceMove()
    {
        stateMachine.Enemy.Controller.Move(stateMachine.Enemy.ForceReceiver.Movement * Time.deltaTime);
    }

    // 타겟을 방향으로 가져오게 한다.
    private Vector3 GetMovementDirection()
    {
        return (stateMachine.Target.transform.position - stateMachine.Enemy.transform.position).normalized;
    }

    private void Move(Vector3 direction)
    {
        float movementSpeed = GetMovementSpeed();
        stateMachine.Enemy.Controller.Move(((direction * movementSpeed) + stateMachine.Enemy.ForceReceiver.Movement) * Time.deltaTime);
    }

    private void Rotate(Vector3 direction)
    {
        if (direction != Vector3.zero)
        {
            direction.y = 0;
            Quaternion targetRotation = Quaternion.LookRotation(direction);

            stateMachine.Enemy.transform.rotation = Quaternion.Slerp(stateMachine.Enemy.transform.rotation, targetRotation, stateMachine.RotationDamping * Time.deltaTime);
        }
    }

    protected float GetMovementSpeed()
    {
        float movementSpeed = stateMachine.MovementSpeed * stateMachine.MovementSpeedModifier;

        return movementSpeed;
    }

    protected float GetNormalizedTime(Animator animator, string tag)
    {
        AnimatorStateInfo currentInfo = animator.GetCurrentAnimatorStateInfo(0);
        AnimatorStateInfo nextInfo = animator.GetNextAnimatorStateInfo(0);

        if (animator.IsInTransition(0) && nextInfo.IsTag(tag))
        {
            return nextInfo.normalizedTime;
        }
        else if (!animator.IsInTransition(0) && currentInfo.IsTag(tag))
        {
            return currentInfo.normalizedTime;
        }
        else
        {
            return 0f;
        }
    }

    // Enemy에서의 추가 코드
    protected bool IsInChaseRange()
    {
        // if (stateMachine.Target.IsDead) { return false; }

        // Enemy와 Target의 거리를 재고 그 거리를 구한다.
        // sqrMagnitude : (피타고라스)제곱근을 풀지 않은 Magnitude, 제곱근을 푸는 연산이 무겁다 보니
        float playerDistanceSqr = (stateMachine.Target.transform.position - stateMachine.Enemy.transform.position).sqrMagnitude;
        // 여기에서 곱하기를 한번 더 해준다.
        return playerDistanceSqr <= stateMachine.Enemy.Data.PlayerChasingRange * stateMachine.Enemy.Data.PlayerChasingRange;
    }
}

EnemyIdleState.cs 만들기

public class EnemyIdleState : EnemyBaseState
{
    public EnemyIdleState(EnemyStateMachine ememyStateMachine) : base(ememyStateMachine)
    {
    }

    public override void Enter()
    {
        stateMachine.MovementSpeedModifier = 0f;

        base.Enter();
        // 플레이어와 공유해서 쓸 것이다 보니 한번에 두개를 잡아준다.
        StartAnimation(stateMachine.Enemy.AnimationData.GroundParameterHash);
        StartAnimation(stateMachine.Enemy.AnimationData.IdleParameterHash);
    }

    public override void Exit()
    {
        base.Exit();
        StopAnimation(stateMachine.Enemy.AnimationData.GroundParameterHash);
        StopAnimation(stateMachine.Enemy.AnimationData.IdleParameterHash);
    }

    public override void Update()
    {
        if (IsInChaseRange())   // 근거리까지 도달을 했다면
        {
            stateMachine.ChangeState(stateMachine.ChasingState);
            return;
        }
    }
}

EnemyChasingState.cs 만들기

public class EnemyChasingState : EnemyBaseState
{
    public EnemyChasingState(EnemyStateMachine ememyStateMachine) : base(ememyStateMachine)
    {
    }

    public override void Enter()
    {
        stateMachine.MovementSpeedModifier = 1;
        base.Enter();
        StartAnimation(stateMachine.Enemy.AnimationData.GroundParameterHash);
        StartAnimation(stateMachine.Enemy.AnimationData.RunParameterHash);
    }

    public override void Exit()
    {
        base.Exit();
        StopAnimation(stateMachine.Enemy.AnimationData.GroundParameterHash);
        StopAnimation(stateMachine.Enemy.AnimationData.RunParameterHash);
    }

    public override void Update()
    {
        base.Update();

        if (!IsInChaseRange()) // 쫓아가는 거리 내에 없다면
        {
            stateMachine.ChangeState(stateMachine.IdlingState); // Idle로 전환
            return;
        }
        else if (IsInAttackRange()) // 공격 거리 안에 있다면
        {
            stateMachine.ChangeState(stateMachine.AttackState); // Attack로 전환
            return;
        }
    }

    private bool IsInAttackRange()
    {
        // if (stateMachine.Target.IsDead) { return false; }

        // 타겟과의 거리 비교해서
        float playerDistanceSqr = (stateMachine.Target.transform.position - stateMachine.Enemy.transform.position).sqrMagnitude;
        // AttackRange랑 비교
        return playerDistanceSqr <= stateMachine.Enemy.Data.AttackRange * stateMachine.Enemy.Data.AttackRange;
    }
}

Animator Controller 수정

• BaseAttack(Bool) Parameter 추가

• Transition 수정

PlayerAnimationData.cs 수정

'''생략
[SerializeField] private string baseAttackParameterName = "BaseAttack";
'''생략
public int BaseAttackParameterHash { get; private set; }

EnemyAttackState.cs 만들기

public class EnemyAttackState : EnemyBaseState
{
    private bool alreadyAppliedForce;

    public EnemyAttackState(EnemyStateMachine ememyStateMachine) : base(ememyStateMachine)
    {
    }

    public override void Enter()
    {
        stateMachine.MovementSpeedModifier = 0;
        base.Enter();
        StartAnimation(stateMachine.Enemy.AnimationData.AttackParameterHash);
        StartAnimation(stateMachine.Enemy.AnimationData.BaseAttackParameterHash);
    }

    public override void Exit()
    {
        base.Exit();
        StopAnimation(stateMachine.Enemy.AnimationData.AttackParameterHash);
        StopAnimation(stateMachine.Enemy.AnimationData.BaseAttackParameterHash);

    }

    public override void Update()
    {
        base.Update();

        ForceMove();

        float normalizedTime = GetNormalizedTime(stateMachine.Enemy.Animator, "Attack");
        if (normalizedTime < 1f)
        {
            if (normalizedTime >= stateMachine.Enemy.Data.ForceTransitionTime)
                TryApplyForce();

        }
        else
        {
            if (IsInChaseRange())   // 거리 체크
            {
                stateMachine.ChangeState(stateMachine.ChasingState);
                return;
            }
            else
            {
                stateMachine.ChangeState(stateMachine.IdlingState);
                return;
            }
        }

    }

    private void TryApplyForce()
    {
        if (alreadyAppliedForce) return;
        alreadyAppliedForce = true;

        stateMachine.Enemy.ForceReceiver.Reset();

        stateMachine.Enemy.ForceReceiver.AddForce(stateMachine.Enemy.transform.forward * stateMachine.Enemy.Data.Force);

    }
}

➔ 오브젝트 수정하기

오브젝트 만들기

• 플레이어 복제 - Enemy로 수정

• Player, Player Input ➔ Remove Component

• Enemy 추가

• EnemySO 생성 후 연결

플레이어 태그 설정

• 플레이어 오브젝트 ➔ Tag "Player" 수정

---

📌 피격 만들기

➔ 피격 시스템 구성하기

CharacterHealth.cs 만들기

public class Health : MonoBehaviour
{
    [SerializeField] private int maxHealth = 100;
    private int health;
    public event Action OnDie;

    public bool IsDead => health == 0;

    private void Start()
    {
        health = maxHealth;
    }

    public void TakeDamage(int damage)
    {
        if (health == 0) return;
        health = Math.Max(health - damage, 0);  // 0보다 밑으로 내려가는거 방지

        if (health == 0)
            OnDie?.Invoke();

        Debug.Log(health);
    }
}

Weapon.cs 만들기

public class Weapon : MonoBehaviour
{
    [SerializeField] private Collider myCollider;

    private int damage;
    private float knockback;

    // <Collider> : 모든 Collider들의 상위 Class
    private List<Collider> alreadyColliderWith = new List<Collider>();

    private void OnEnable()
    {
        alreadyColliderWith.Clear();    // 초기화
    }

    private void OnTriggerEnter(Collider other)
    {
        if (other == myCollider) return; // 나 자신?
        if (alreadyColliderWith.Contains(other)) return; // 이미 포함이 되어있나?

        alreadyColliderWith.Add(other); // 둘 다 아니라면 추가(.Add)

        if(other.TryGetComponent(out Health health))
        {
            health.TakeDamage(damage);
        }

        if(other.TryGetComponent(out ForceReciver forceReceiver))
        {
            Vector3 direction = (other.transform.position - myCollider.transform.position).normalized;
            forceReceiver.AddForce(direction * knockback);
        }

    }

    public void SetAttack(int damage, float knockback)
    {
        this.damage = damage;
        this.knockback = knockback;
    }
}

EnemyAttackState.cs 수정

'''생략
private bool alreadyAppliedDealing;

'''생략
public override void Enter()
{
    alreadyAppliedForce = false;
    alreadyAppliedDealing = false;
    stateMachine.MovementSpeedModifier = 0;
    base.Enter();
    StartAnimation(stateMachine.Enemy.AnimationData.AttackParameterHash);
    StartAnimation(stateMachine.Enemy.AnimationData.BaseAttackParameterHash);


'''생략
public override void Update()
{
    base.Update();

    ForceMove();

    float normalizedTime = GetNormalizedTime(stateMachine.Enemy.Animator, "Attack");
    if (normalizedTime < 1f)
    {
        if (normalizedTime >= stateMachine.Enemy.Data.ForceTransitionTime)
            TryApplyForce();

        // 공격 애니메이션이 진행 중에 애니메이션 진행속도에 if문을 걸어 weapon의 SetActive를
        // 켜주어 초기화(OnEnable)후 데미지 처리를 받게 하고(Weapon.cs) 공격 애니메이션이 끝, 공격이 끝나면
        // weapon의 SetActive를 꺼주어 데미지를 받지 않게 한다.
        // 딜을 아직 안넣은 상태 && normalizedTime 이 StartTime보다 커졌다면?
        if (!alreadyAppliedDealing && normalizedTime >= stateMachine.Enemy.Data.Dealing_Start_TransitionTime)
        {
            stateMachine.Enemy.Weapon.SetAttack(stateMachine.Enemy.Data.Damage, stateMachine.Enemy.Data.Force);
            stateMachine.Enemy.Weapon.gameObject.SetActive(true);
            alreadyAppliedDealing = true;
        }

        // 딜을 넣은 상태 && EndTime을 넘었다면?
        if (alreadyAppliedDealing && normalizedTime >= stateMachine.Enemy.Data.Dealing_End_TransitionTime)
        {
            stateMachine.Enemy.Weapon.gameObject.SetActive(false);
        }
    }
    else
    {
        if (IsInChaseRange())   // 거리 체크
        {
            stateMachine.ChangeState(stateMachine.ChasingState);
            return;
        }
        else
        {
            stateMachine.ChangeState(stateMachine.IdlingState);
            return;
        }
    }

}

Enemy.cs 수정

'''생략
[field: SerializeField] public Weapon Weapon { get; private set; }
public CharacterHealth CharacterHealth { get; private set; }

void Awake()
{
'''생략
    CharacterHealth = GetComponent<CharacterHealth>();

    stateMachine = new EnemyStateMachine(this);
}

private void Start()
{
    stateMachine.ChangeState(stateMachine.IdlingState);
    CharacterHealth.OnDie += OnDie;
}

'''생략

void OnDie()
{
    Animator.SetTrigger("Die");
    enabled = false;    // 오브젝트의 컴포넌트를 비활성화.
}

}

➔ 적용하기

Weapon 오브젝트 준비하기

• Weapon 오브젝트 생성

• 컴포넌트 추가

• Weapon 추가 - Collider 설정

Enemy 오브젝트 설정

• Enemy 컴포넌트에 Weapon 설정

Animator Controller 수정

• Die를 트리거로 만들기
  죽는 모션 연결

[Player도 동일하게 설정 (Player.cs, Weapon 오브젝트]

---