게임을 사용하는 가상 공간의 본질

벡터와 스칼라

물리학에서의 정의

• 벡터: 크기와 방향을 가진 대상
• 스칼라: 크기만 있는 물리량

수학에서의 정의

• 벡터: 벡터 공간의 원소
• 스칼라: 체 집합의 원소

선형 변환 (Linear Trasformation)

선형성을 가진 변환.

선형 변환 과정을 통해 빠르게 공간을 변형하고, 변환된 공간도 원래대로 돌리는게 가능해진다.

렌더링 파이프 라인

모델링을 카메라가 바라보고, 바라본 공간을 모니터에 투영해주는 일련의 공간 변환 체제

행렬 (Matrix)

선형 변환을 수행하는 도구

가상 공간을 빠르게 변환시키는 일종의 명령어

렌더링 파이프라인에서 공간을 변환하는데 사용되는 행렬이 존재한다.

평면 방정식

여러개의 평면을 사용해서 공간안에 자신의 영역을 만들 수 있다.

ax + by +cz + d = 0

평면 방정식의 예

절두체

• 카메라 보는 영역에 해당하는 절두체
• 6개의 평면으로 구성되어 보이는 물체만 그리도록 처리할 수 있다

중요 뽀인트!

1. 수의 체계와 벡터 공간
2. 선형 변환과 행렬

경사가 가파른 지면을 플레이어가 연속해서 점프하여 위로 향하지 못하도록 경사가 가파르면 미끄러지도록 해보자.

핵심 코드

핵심 코드만 보도록 하자.

// 미끄러지는지 여부 체크
private bool isSliding;
// 미끄러지는 속도
private Vector3 slopeSlideVelocity;

private void SetSlopeSlideVelocity()
{
    // transform.position + Vector3.up: 캐릭터와 가까운 지면을 놓치지 않기 위해 원점을 높임
    if (Physics.Raycast(transform.position + Vector3.up, Vector3.down, out RaycastHit hitInfo, 5))
    {
        // 경사 각도 결정
        float angle = Vector3.Angle(hitInfo.normal, Vector3.up);
        // Charater Contoller의 경사 각도와 비교
        if (angle >= characterController.slopeLimit)
        {
            slopeSlideVelocity = Vector3.ProjectOnPlane(new Vector3(0, ySpeed, 0), hitInfo.normal);
            return;
        }
    }

    // 슬라이딩할 때 부드러운 감속을 주기 위해
    if (isSliding)
    {
        // 배속을 주기 위해 *3
        slopeSlideVelocity -= slopeSlideVelocity * Time.deltaTime * 3;

        // 크기가 1보다 작아지면 충분히 감속했다고 판단
        if (slopeSlideVelocity.magnitude > 1)
        {
            return;
        }
    }

    slopeSlideVelocity = Vector3.zero;
}

Vector3.Angle

public static float Angle(Vector3 from, Vector3 to);

두 벡터 A,B가 있을 때 Vector3.Angle(A, B)는 A와 B 사이의 각도를 반환한다.

각도의 부호가 없으며, 항상 0도 이상 180도 미만의 값을 가진다.

Vector3.ProjectOnPlane

public static Vector3 ProjectOnPlane(Vector3 vector, Vector3 planeNormal); 주어진 평면에 대해 벡터를 투영 시키는 역할을 한다. 벡터를 주어진 평면에 수직인 벡터롤 변환한다.

ex) 구불한 바닥 평면에 방향 벡터를 투영하여 수직인 벡터를 얻음으로써, 평면 바닥을 따라 움직이는 벡터를 얻을 수 있다.

투영

빨간 사각형으로 표시된 벡터는 녹색 평면에 투영되어 검은색 사각형으로 표시된 벡터가 된다.

법선 벡터 (Normal)

법선 벡터는 특정 지점 또는 표면에서 수직으로 나아가는 벡터를 말한다. 표면의 각 점에서 법선 벡터는 해당 점에서 표면을 수직으로 가리키며, 이는 표면이 어떤 방향을 향하는지를 나타낸다.

코드 리뷰

// 경사 각도 결정
float angle = Vector3.Angle(hitInfo.normal, Vector3.up);

Raycast를 통하여 충돌된 오브젝트의 정보를 얻고, 충돌 지점에서의 법선 벡터와 Vector3.up 이용하여 경사면의 각도를 구한다.

slopeSlideVelocity = Vector3.ProjectOnPlane(new Vector3(0, ySpeed, 0), hitInfo.normal);

평면을 충돌된 오브젝트의 법선벡터로 할당하고, 벡터를 중력으로 감소되고 있는 ySpeed로 할당해 투영된 평면에 수직인 벡터를 얻음으로써, 경사면의 기울기대로 중력을 적용시킨다.

스크립트

경사면에서 미끄러지는 핵심 코드와 더불어 예외 처리를 적용한 PlayerMovement의 전체 코드를 보자.

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

public class PlayerMovement : MonoBehaviour
{
    public float rotationSpeed = 720;

    public float jumpHeight = 2;
    public float gravityMultiplier = 1.5f;

    public float jumpHorizontalSpeed = 3;

    public float jumpButtonGracePeriod = 0.2f;

    public Transform cameraTransform;

    private CharacterController characterController;
    private Animator animator;

    private float ySpeed;
    private float originalStepOffset;

    private float? lastGroundedTime;
    private float? jumpButtonPressedTime;

    private bool isJumping;
    private bool isGrounded;

    // 미끄러지는지 여부 체크
    private bool isSliding;
    // 미끄러지는 속도
    private Vector3 slopeSlideVelocity;


    private void Start()
    {
        characterController = GetComponent<CharacterController>();
        animator = GetComponent<Animator>();
        originalStepOffset = characterController.stepOffset;
    }

    void Update()
    {
        float horizontalInput = Input.GetAxis("Horizontal");
        float verticalInput = Input.GetAxis("Vertical");

        Vector3 movementDirection = new Vector3(horizontalInput, 0, verticalInput);

        float inputMagnitude = Mathf.Clamp01(movementDirection.magnitude);

        if (Input.GetKey(KeyCode.LeftShift) || Input.GetKey(KeyCode.RightShift))
        {
            inputMagnitude *= 0.5f;
        }

        animator.SetFloat("Input Magnitude", inputMagnitude, 0.05f, Time.deltaTime);

        movementDirection = Quaternion.AngleAxis(cameraTransform.rotation.eulerAngles.y, Vector3.up) * movementDirection;
        movementDirection.Normalize();

        float gravity = Physics.gravity.y * gravityMultiplier;

        // 점프 시작, 위쪽 방향이동 체크, 점프 버튼을 더 이상 누르지 않는지
        // 세가지 조건이 충족되면 중력값을 두배로 늘린다.
        if(isJumping && ySpeed > 0 && Input.GetButton("Jump") == false)
        {
            gravity *= 2;
        }

        ySpeed += gravity * Time.deltaTime;

        // 경사속도 설정
        SetSlopeSlideVelocity();
        // 경사면인지 검사
        if(slopeSlideVelocity == Vector3.zero)
        {
            isSliding = false;
        }

        if (characterController.isGrounded)
        {
            lastGroundedTime = Time.time;
        }
        if(Input.GetButtonDown("Jump"))
        {
            jumpButtonPressedTime = Time.time;
        }

        if (Time.time - lastGroundedTime <= jumpButtonGracePeriod)
        {
            if (slopeSlideVelocity != Vector3.zero)
            {
                isSliding = true;
            }

            characterController.stepOffset = originalStepOffset;

            // 슬라이딩이 아닌 경우만 실행
            if (isSliding == false)
            {
                ySpeed = -0.8f;
            }

            animator.SetBool("isGrounded", true);
            isGrounded = true;
            animator.SetBool("isJumping", false);
            isJumping = false;
            animator.SetBool("isFalling", false);

            // 슬라이딩이 아닌 경우에만 점프
            if (Time.time - jumpButtonPressedTime <= jumpButtonGracePeriod && isSliding == false)
            {
                ySpeed = Mathf.Sqrt(jumpHeight * -2 * gravity);

                animator.SetBool("isJumping", true);
                isJumping = true;

                lastGroundedTime = null;
                jumpButtonPressedTime = null;
            }
        }
        else
        {
            characterController.stepOffset = 0;

            animator.SetBool("isGrounded", false);
            isGrounded = false;

            if ((isJumping && ySpeed < 0) || (ySpeed < -2.5f))
            {
                animator.SetBool("isFalling", true);
            }
        }

        if (movementDirection != Vector3.zero)
        {
            animator.SetBool("isMoving", true);
            Quaternion toRotation = Quaternion.LookRotation(movementDirection, Vector3.up);
            transform.rotation = Quaternion.RotateTowards(transform.rotation, toRotation, rotationSpeed * Time.deltaTime);
        }
        else
        {
            animator.SetBool("isMoving", false);
        }

        // 슬라이딩이 아닐때만 떨어짐
        if(isGrounded == false && isSliding == false)
        {
            Vector3 velocity = movementDirection * inputMagnitude * jumpHorizontalSpeed;
            velocity.y = ySpeed;

            characterController.Move(velocity * Time.deltaTime);
        }

        // 슬라이딩 이동 처리
        if(isSliding)
        {
            Vector3 velocity = slopeSlideVelocity;
            velocity.y = ySpeed;

            characterController.Move(velocity * Time.deltaTime);
        }
    }

    private void SetSlopeSlideVelocity()
    {
        // transform.position + Vector3.up: 캐릭터와 가까운 지면을 놓치지 않기 위해 원점을 높임
        if (Physics.Raycast(transform.position + Vector3.up, Vector3.down, out RaycastHit hitInfo, 5))
        {
            // 경사 각도 결정
            float angle = Vector3.Angle(hitInfo.normal, Vector3.up);
            // Charater Contoller의 경사 각도와 비교
            if (angle >= characterController.slopeLimit)
            {
                slopeSlideVelocity = Vector3.ProjectOnPlane(new Vector3(0, ySpeed, 0), hitInfo.normal);
                return;
            }
        }

        // 슬라이딩할 때 부드러운 감속을 주기 위해
        if(isSliding)
        {
            // 배속을 주기 위해 *3
            slopeSlideVelocity -= slopeSlideVelocity * Time.deltaTime * 3;

            // 크기가 1보다 작아지면 충분히 감속했다고 판단
            if (slopeSlideVelocity.magnitude > 1)
            {
                return;
            }
        }

        slopeSlideVelocity = Vector3.zero;
    }

    private void OnAnimatorMove()
    {
        // 슬라이딩이 아닐때만 적용
        if(isGrounded && isSliding == false)
        {
            Vector3 velocity = animator.deltaPosition;
            velocity.y = ySpeed * Time.deltaTime;

            characterController.Move(velocity);
        }
    }

    private void OnApplicationFocus(bool focus)
    {
        if (focus)
        {
            Cursor.lockState = CursorLockMode.Locked;
        }
        else
        {
            Cursor.lockState = CursorLockMode.None;
        }
    }
}

일시중지하는 간단한 방법들을 알아보자.

Time.timeScale

Time.timeScale을 이용한 스크립트를 작성해보자.

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

public class PauseController : MonoBehaviour
{
    private bool isPaused;

    private void Update()
    {
        if(Input.GetKeyDown(KeyCode.Escape))
        {
            isPaused = !isPaused;

            if(isPaused)
            {
                Time.timeScale = 0;
            }
            else
            {
                Time.timeScale = 1;
            }
        }
    }
}

Time.timeScale을 이용한 일시중지는 간단하지만 timeScale이 0이 되더라도 스크립트 실행에서 Update() 메서드는 중지되지 않는다는 문제가 있다.

• 예를 들어 입력은 계속 처리될 것이다.

스크립트 비활성화

유니티 이벤트를 사용하여 스크립트 활성/비활성화를 통해 위 문제를 해결해보자.

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

public class PauseController : MonoBehaviour
{
    public UnityEvent GamePaused;
    public UnityEvent GameResumed;

    private bool isPaused;

    private void Update()
    {
        if(Input.GetKeyDown(KeyCode.Escape))
        {
            isPaused = !isPaused;

            if(isPaused)
            {
                Time.timeScale = 0;
                GamePaused.Invoke();
            }
            else
            {
                Time.timeScale = 1;
                GameResumed.Invoke();
            }
        }
    }
}

유니티 이벤트를 추가하고 활성/비활성화할 스크립트를 연결한다.

timeScale이 0으로 설정된 경우 FixedUpdate() 메서드는 절대로 호출되지 않는다.

커스텀 기즈모를 활용하는 방법을 간단히 알아보자.

스크립트

웨이포인트 스크립트 활용하여 기즈모를 그리는 코드를 추가해보자.

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

public class WaypointPath : MonoBehaviour
{
    public Transform GetWaypoint(int waypointIndex)
    {
        return transform.GetChild(waypointIndex);
    }

    public int GetNextWaypointIndex(int currentWaypointIndex)
    {
        int nextWaypointIndex = currentWaypointIndex + 1;
        if(nextWaypointIndex == transform.childCount)
        {
            nextWaypointIndex = 0;
        }

        return nextWaypointIndex;
    }

    private void OnDrawGizmos()
    {
        for (int waypoinIndex = 0; waypoinIndex < transform.childCount; waypoinIndex++)
        {
            // 웨이포인트 지점에 원 그리기
            var waypoint = GetWaypoint(waypoinIndex);

            Gizmos.color = Color.cyan;
            Gizmos.DrawSphere(waypoint.position, 0.2f);

            // 다음 웨이포인트까지 선그리기
            int nextWaypointIndex = GetNextWaypointIndex(waypoinIndex);
            var nextWaypoint = GetWaypoint(nextWaypointIndex);

            Gizmos.color = Color.yellow;
            Gizmos.DrawLine(waypoint.position, nextWaypoint.position);
        }
    }
}

씬 뷰

개선

#1 선택한 경우만

웨이포인트 오브젝트의 부모, 자식 오브젝트를 클릭했을 때만 기즈모가 나오도록 수정해보자.

// 네임스페이스 추가
using System.Linq;
using UnityEditor;

// 수정
private void OnDrawGizmos()
{
    if (IsWaypointSelected())
    {
        for (int waypoinIndex = 0; waypoinIndex < transform.childCount; waypoinIndex++)
        {
            // 웨이포인트 지점에 원 그리기
            var waypoint = GetWaypoint(waypoinIndex);

            Gizmos.color = Color.cyan;
            Gizmos.DrawSphere(waypoint.position, 0.2f);

            // 다음 웨이포인트까지 선그리기
            int nextWaypointIndex = GetNextWaypointIndex(waypoinIndex);
            var nextWaypoint = GetWaypoint(nextWaypointIndex);

            Gizmos.color = Color.yellow;
            Gizmos.DrawLine(waypoint.position, nextWaypoint.position);
        }
    }
}

private bool IsWaypointSelected()
{
    // 현재 오브젝트를 선택했는지
    if (Selection.transforms.Contains(transform))
    {
        return true;
    }

    // 현재 오브젝트의 자식 오브젝트가 선택되었는지
    foreach (Transform child in transform)
    {
        if (Selection.transforms.Contains(child))
        {
            return true;
        }
    }

    return false;
}

#2 관련 오브젝트가 선택된 경우

실제로 움직이는 플랫폼 오브젝트를 선택했을 때도 웨이포인트 기즈모가 출력되도록 수정해보자.

WaypointPath 스크립트 수정

private void OnDrawGizmos()
{
    if (IsWaypointSelected())
    {
        DrawWaypointGizmo();
    }
}

public void DrawWaypointGizmo()
{
    for (int waypoinIndex = 0; waypoinIndex < transform.childCount; waypoinIndex++)
    {
        // 웨이포인트 지점에 원 그리기
        var waypoint = GetWaypoint(waypoinIndex);

        Gizmos.color = Color.cyan;
        Gizmos.DrawSphere(waypoint.position, 0.2f);

        // 다음 웨이포인트까지 선그리기
        int nextWaypointIndex = GetNextWaypointIndex(waypoinIndex);
        var nextWaypoint = GetWaypoint(nextWaypointIndex);

        Gizmos.color = Color.yellow;
        Gizmos.DrawLine(waypoint.position, nextWaypoint.position);
    }
}

실제 오브젝트를 조작하는 스크립트 수정

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

public class MovingPlatform : MonoBehaviour
{
    public WaypointPath waypointPath;

    private void OnDrawGizmosSelected()
    {
        waypointPath.DrawWaypointGizmo();
    }
}

웨인포인트에 따라 움직이는 플랫폼을 만들고, 플레이어가 플랫폼에 탑승하도록 만들어보자.

씬 구성

MovingPlatform이라는 프리팹을 씬에 구성하고, 빈오브젝트를 만들어 웨이포인트를 관리할 WaypointPath1 오브젝트와 하위 오브젝트로 실제 경유할 Waypoin 오브젝트 3개를 배치했다.

스크립트

Path를 관리할 오브젝트를 작성해보자. WaypointPath1 오브젝트에 부착.

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

public class WaypointPath : MonoBehaviour
{
    public Transform GetWaypoint(int waypointIndex)
    {
        return transform.GetChild(waypointIndex);
    }

    public int GetNextWaypointIndex(int currentWaypointIndex)
    {
        int nextWaypointIndex = currentWaypointIndex + 1;
        if(nextWaypointIndex == transform.childCount)
        {
            nextWaypointIndex = 0;
        }

        return nextWaypointIndex;
    }
}

플랫폼을 직접 움직이는 스크립트를 작성해보자. MovingPlatform 오브젝트에 부착.

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

public class MovingPlatform : MonoBehaviour
{
    public WaypointPath waypointPath;
    public float speed = 1;

    private int targetWaypointIndex;

    private Transform previousWaypoint;
    private Transform targetWaypoint;

    // 목표 경유지까지 걸리는 시간
    private float timeToWaypoint;
    // 경과된 시간
    private float elapsedTime;

    private void Start()
    {
        TargetNextWaypoint();
    }

    private void FixedUpdate()
    {
        elapsedTime += Time.deltaTime;

        // 경과된 시간을 목표 경유지까지 걸리는 시간으로 나누어 완료될 비율을 계산
        float elapsedPercentage = elapsedTime / timeToWaypoint;
        // 시작과 끝에 속도가 느려지게
        elapsedPercentage = Mathf.SmoothStep(0, 1, elapsedPercentage);

        transform.position = Vector3.Lerp(previousWaypoint.position, targetWaypoint.position, elapsedPercentage);
        // 회전값도 적용
        transform.rotation = Quaternion.Lerp(previousWaypoint.rotation, targetWaypoint.rotation, elapsedPercentage);

        // 목표 경유지까지 이동했는지 검사
        if (elapsedPercentage >= 1)
        {
            TargetNextWaypoint();
        }
    }

    private void TargetNextWaypoint()
    {
        previousWaypoint = waypointPath.GetWaypoint(targetWaypointIndex);
        targetWaypointIndex = waypointPath.GetNextWaypointIndex(targetWaypointIndex);
        targetWaypoint = waypointPath.GetWaypoint(targetWaypointIndex);

        elapsedTime = 0f;

        float distanceToWaypoint = Vector3.Distance(previousWaypoint.position, targetWaypoint.position);

        // 거리를 속도로 나누어 해당거리에 도달하는 데 걸리는 시간 계산
        timeToWaypoint = distanceToWaypoint / speed;
    }

    private void OnTriggerEnter(Collider other)
    {
        other.transform.SetParent(transform);
    }

    private void OnTriggerExit(Collider other)
    {
        other.transform.SetParent(null);
    }
}

Mathf.SmoothStep public static float SmoothStep(float from, float to, float t); 보간 속도는 처음부터 점차 빨라지고 끝으로 갈수록 느려진다. from: 시작점 to: 종료점 t: 비율

문제 해결

#1 플랫폼과 같이 움직이기

플랫폼과 같이 움직이고 회전하도록 하기위해 MovingPlatform 스크립트에 OnTrigger 함수를 추가해 Enter일 때는 플랫폼의 자식으로, Exit일 때는 자식을 해제하므로써 플랫폼과 같은 움직임을 보이도록 수정하였다.

#2 버벅거리는 움직임

Update메서드에 제어되는 플랫폼 오브젝트에 실제로 올라타면 움직임이 버벅이는 것처럼 보인다. 이는 플레이어 오브젝트에 부착된 Character Controller와 관련이 있다. 이를 해결하기 위해 플랫폼 오브젝트가 FixedUpdate에서 제어되도록 수정하였다.

Idle 상태에서 일정시간이 지나면 지루한 모션등의 다른 모션을 취하도록 수정해보자.

블렌드 트리 구성

일단 사용할 여러가지 Idle 모션을 블렌드 트리로 구성하고, 매개변수와 Threshord값을 설정한다.

스크립트 추가

애니메이터 State에서 스크립트를 생성한다.

스크립트

일정 시간을 Idle 상태에서 머물 경우 다른 Idle 모션으로 변경하는 스크립트를 작성해보자.

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

public class BoredBehaviour : StateMachineBehaviour
{
    // 지루해질 때까지의 시간
    public float timeUntilBored = 3;
    // 애니메이션 갯수
    public int numberOfBoredAnimations = 3;

    private bool isBored;
    // Idle 상태 시간 저장
    private float idleTime;

    // OnStateEnter is called when a transition starts and the state machine starts to evaluate this state
    override public void OnStateEnter(Animator animator, AnimatorStateInfo stateInfo, int layerIndex)
    {
        ResetIdle(animator);
    }

    // OnStateUpdate is called on each Update frame between OnStateEnter and OnStateExit callbacks
    override public void OnStateUpdate(Animator animator, AnimatorStateInfo stateInfo, int layerIndex)
    {
        if(isBored == false)
        {
            idleTime += Time.deltaTime;

            if(idleTime > timeUntilBored)
            {
                isBored = true;
                int boredAnimation = Random.Range(1, numberOfBoredAnimations + 1);

                animator.SetFloat("BoredAnimation", boredAnimation);
            }
        }
        // 상태 정보를 이용하여 애니메이션의 정규화된 시간을 확인하여
        // 지루한 애니메이션을 1회만 재생하도록 제어
        else if (stateInfo.normalizedTime % 1 > 0.98f)
        {
            ResetIdle(animator);
        }
    }

    private void ResetIdle(Animator animator)
    {
        isBored = false;
        idleTime = 0;

        animator.SetFloat("BoredAnimation", 0);
    }
}

(stateInfo.normalizedTime % 1 > 0.98f) 사용 이유 Loop 애니메이션의 경우 normalizedTime이 0에서 시작해 계속 증가하기 때문에 0과 1사이의 값이 아니다. Loop가 계속 되면서 1이상으로 계속 늘어나게 된다.

• % 나머지 연산자를 이용해 항상 애니메이션이 끝까지 재생되도록 한다.

문제 해결

#1 Idle 모션 끊김

Idle 모션 재생 중 다른 Bored 모션으로 전환이 이루어진다. Idle 모션이 끝난 뒤 다른 Bored 모션으로 전환하도록 수정해보자.

// 조건을 추가하여 Loop가 시작 부분에 가까워졌는지 체크한다.
if(idleTime > timeUntilBored && stateInfo.normalizedTime % 1 < 0.02f)

#2 모션 전환

모션이 전환될 때 전환이 부드럽게 이루어지지 않는 부분을 수정해보자.

// 애니메이션 재생에 dampTime을 적용한다.
animator.SetFloat("BoredAnimation", boredAnimation, 0.2f, Time.deltaTime);

#3 Idle 모션으로 되돌아갈 때

기본 Idle 모션과 3가지 Bored 모션이 블렌드 트리로 묶여있기 때문에 Bored 모션 재생 후 Idle 모션으로 돌아갈 때 3가지 Bored 모션이 조금씩 표시되면서 부자연스러운 젼환을 보여준다.

이를 해결하기 위해 bored 모션 사이에 기본 Idle 모션을 배치하여 다른 애니메이션을 거치지 않도록 함으로써 자연스러운 전환을 이끌어낼 수 있다.

스크립트 수정

관련 문제를 해결한 전체 스크립트를 보자.

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

public class BoredBehaviour : StateMachineBehaviour
{
    public float timeUntilBored = 3;
    public int numberOfBoredAnimations = 3;

    private bool isBored;
    private float idleTime;

    private int boredAnimation;

    // OnStateEnter is called when a transition starts and the state machine starts to evaluate this state
    override public void OnStateEnter(Animator animator, AnimatorStateInfo stateInfo, int layerIndex)
    {
        ResetIdle();
    }

    // OnStateUpdate is called on each Update frame between OnStateEnter and OnStateExit callbacks
    override public void OnStateUpdate(Animator animator, AnimatorStateInfo stateInfo, int layerIndex)
    {
        if(isBored == false)
        {
            idleTime += Time.deltaTime;

            // 모션이 처음에 가까운지도 같이 체크
            if(idleTime > timeUntilBored && stateInfo.normalizedTime % 1 < 0.02f)
            {
                isBored = true;
                boredAnimation = Random.Range(1, numberOfBoredAnimations + 1);
                // 기본 Idle 모션 추가 후 올바른 bored 모션을 얻기 위한 공식
                boredAnimation = boredAnimation * 2 - 1;

                // 가장 가까운 기본 Idle 모션으로 전환
                animator.SetFloat("BoredAnimation", boredAnimation - 1);
            }
        }
        else if (stateInfo.normalizedTime % 1 > 0.98f)
        {
            ResetIdle();
        }

        // damptime 추가
        animator.SetFloat("BoredAnimation", boredAnimation, 0.2f, Time.deltaTime);
    }

    private void ResetIdle()
    {
        // bored 모션이 실행 중이라면 가장 가까운 기본 idle 모션을 재생하도록 리셋
        if(isBored)
        {
            boredAnimation--;
        }

        isBored = false;
        idleTime = 0;
    }
}

키를 누르는 시간에 따라 점프의 높이에 변화를 줘보자.

스크립트

이전의 점프 스크립트를 수정한다.

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

public class PlayerMovement : MonoBehaviour
{
    // ...생략

    // 점프 높이
    public float jumpHeight = 2;
    // 작용하는 중력
    public float gravityMultiplier = 1.5f;

    // ...생략

    void Update()
    {
        // ...생략

        // 작용하는 중력 계산
        float gravity = Physics.gravity.y * gravityMultiplier;

        // 점프 시작, 위쪽 방향이동 체크, 점프 버튼을 더 이상 누르지 않는지
        // 세가지 조건이 충족되면 중력값을 두배로 늘린다.
        if(isJumping && ySpeed > 0 && Input.GetButton("Jump") == false)
        {
            gravity *= 2;
        }

        ySpeed += gravity * Time.deltaTime;

        // ...생략

        if (Time.time - lastGroundedTime <= jumpButtonGracePeriod)
        {
            characterController.stepOffset = originalStepOffset;
            ySpeed = -0.8f;

            animator.SetBool("isGrounded", true);
            isGrounded = true;
            animator.SetBool("isJumping", false);
            isJumping = false;
            animator.SetBool("isFalling", false);

            if (Time.time - jumpButtonPressedTime <= jumpButtonGracePeriod)
            {
                // jumpHeight만큼 점프하도록하는 공식
                ySpeed = Mathf.Sqrt(-jumpHeight * 2 * gravity);

                animator.SetBool("isJumping", true);
                isJumping = true;

                lastGroundedTime = null;
                jumpButtonPressedTime = null;
            }
        }
        else
        {
            characterController.stepOffset = 0;

            animator.SetBool("isGrounded", false);
            isGrounded = false;

            if ((isJumping && ySpeed < 0) || (ySpeed < -2.5f))
            {
                animator.SetBool("isFalling", true);
            }
        }

        // ...생략
    }

    // ...생략
}

gravityMultiplier 값에 따라 체공 시간이 달라진다

MathF.Sqrt public static float Sqrt (float x); 제곱근을 반환하는 함수

카메라 정렬을 특정 키가 눌리거나 게임패드의 오른쪽 트리거가 눌렸을 때 다시 중앙으로 돌아오도록 변경해보자.

자동 중앙 조정

• FreeLock 카메라의 Recenter To Target Heading 옵션 비활성화한다.
• 키가 눌렸을 때 바로 정렬이 될 수 있도록 Wait Time과 Recentering Time의 값을 수정한다.

키 할당

Project Settings->Input Manager에서 Axis를 하나 추가하여 Recenter에 사용할 키를 할당하자.

Joystick Axis의 10th axis는 오른쪽 트리거에 해당한다. 게임패드마다 설정이 다를수도 있으니 안되면 다른 Axis값을 찾아 설정하자.

스크립트

카메라 중앙 조정을 제어할 스크립트를 작성하고, FreeLock 오브젝트에 부착하여 테스트한다.

using System.Collections;
using System.Collections.Generic;
using UnityEngine;
using Cinemachine; // <-- namespace 추가

public class CameraRecenter : MonoBehaviour
{
    private CinemachineFreeLook camera;

    private void Start()
    {
        camera = GetComponent<CinemachineFreeLook>();
    }

    private void Update()
    {
        // 값이 1이면 왼쪽 컨트롤을 눌렀거나 오른쪽 트리거를 눌렀다는 의미
        if(Input.GetAxis("CameraRecentre") == 1)
        {
            camera.m_RecenterToTargetHeading.m_enabled = true;
        }
        else
        {
            camera.m_RecenterToTargetHeading.m_enabled = false;
        }
    }
}

애니메이터 구성

점프 애니메이션에는 점프할 때, 점프 중, 착지할 때 3가지 애니메이션을 구성

스크립트

전체 코드를 보자.

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

public class PlayerMovement : MonoBehaviour
{
    public float rotationSpeed = 720;
    public float jumpSpeed = 5;

    public float jumpButtonGracePeriod = 0.2f;

    public Transform cameraTransform;

    private CharacterController characterController;
    private Animator animator;

    private float ySpeed;
    private float originalStepOffset;

    private float? lastGroundedTime;
    private float? jumpButtonPressedTime;

    private bool isJumping;
    private bool isGrounded;

    private void Start()
    {
        characterController = GetComponent<CharacterController>();
        animator = GetComponent<Animator>();
        originalStepOffset = characterController.stepOffset;
    }

    void Update()
    {
        float horizontalInput = Input.GetAxis("Horizontal");
        float verticalInput = Input.GetAxis("Vertical");

        Vector3 movementDirection = new Vector3(horizontalInput, 0, verticalInput);

        float inputMagnitude = Mathf.Clamp01(movementDirection.magnitude);

        if (Input.GetKey(KeyCode.LeftShift) || Input.GetKey(KeyCode.RightShift))
        {
            inputMagnitude *= 0.5f;
        }

        animator.SetFloat("Input Magnitude", inputMagnitude, 0.05f, Time.deltaTime);

        movementDirection = Quaternion.AngleAxis(cameraTransform.rotation.eulerAngles.y, Vector3.up) * movementDirection;
        movementDirection.Normalize();

        ySpeed += Physics.gravity.y * Time.deltaTime;

        if(characterController.isGrounded)
        {
            lastGroundedTime = Time.time;
        }
        if(Input.GetButtonDown("Jump"))
        {
            jumpButtonPressedTime = Time.time;
        }

        if (Time.time - lastGroundedTime <= jumpButtonGracePeriod)
        {
            characterController.stepOffset = originalStepOffset;
            ySpeed = -0.8f;

            animator.SetBool("isGrounded", true);
            isGrounded = true;
            animator.SetBool("isJumping", false);
            isJumping = false;
            animator.SetBool("isFalling", false);

            if (Time.time - jumpButtonPressedTime <= jumpButtonGracePeriod)
            {
                ySpeed = jumpSpeed;

                animator.SetBool("isJumping", true);
                isJumping = true;

                lastGroundedTime = null;
                jumpButtonPressedTime = null;
            }
        }
        else
        {
            characterController.stepOffset = 0;

            animator.SetBool("isGrounded", false);
            isGrounded = false;

            /* 낙하 애니메이션 전환 처리 */
            if ((isJumping && ySpeed < 0) || (ySpeed < -2))
            {
                animator.SetBool("isFalling", true);
            }
        }

        if (movementDirection != Vector3.zero)
        {
            animator.SetBool("isMoving", true);
            Quaternion toRotation = Quaternion.LookRotation(movementDirection, Vector3.up);
            transform.rotation = Quaternion.RotateTowards(transform.rotation, toRotation, rotationSpeed * Time.deltaTime);
        }
        else
        {
            animator.SetBool("isMoving", false);
        }
    }

    private void OnAnimatorMove()
    {
        Vector3 velocity = animator.deltaPosition;
        velocity.y = ySpeed * Time.deltaTime;

        characterController.Move(velocity);
    }

    private void OnApplicationFocus(bool focus)
    {
        if (focus)
        {
            Cursor.lockState = CursorLockMode.Locked;
        }
        else
        {
            Cursor.lockState = CursorLockMode.None;
        }
    }
}

낙하 중 처리

if ((isJumping && ySpeed < 0) || (ySpeed < -2))
{
    animator.SetBool("isFalling", true);
}

• (isJumping && ySpeed < 0) 처리의 의미는 점프의 최고 높이에 도달했을 때 낙하 애니메이션을 처리하기 위함.
• (ySpeed < -2) 처리의 의미는 계단을 내려올 때나 경사를 내려올때도 낙하 애니메이션 처리가 되지 않도록 하기위한 체크

문제 상황

#1 연속된 점프

연속으로 점프를 누를 경우 착지 애니메이션 재생되면서 곧바로 점프 시작 애니메이션으로 바뀌지 않아 어색한 애니메이션이 연결된다.

이유는

착지 후 Idle 모션으로 돌아갈 때 트랜지션 시간이 0.6로 설정되어 있기 때문이다.

이를 해결하기 위해서는 Interruption Source를 Next State로 설정하여 다음 상태의 전환이 현재 상태를 중단 시키도록 할 수 있다.

전환 흐름

1. 착지 -> Idle 전환 중
2. 점프 버튼이 눌린다면
3. 착지 -> Idle 전환 중단
4. Idle -> 점프 전환 시작 다음 상태인 Idle의 상태 전환이 우선권을 가짐

#2 점프 중 이동

현재 코드로는 점프 중 이동을 할 수 있다. 이를 해결해보자.

점프 중 이동이 되지 않는 이유는 루트 모션에서 움직임을 제어하기 때문이므로 지상에 있을 때는 루트 모션이 제어하도록하고, 점프 중에는 새로운 이동 제어를 추가해준다.

private void OnAnimatorMove()
{
    if (isGrounded)
    {
        Vector3 velocity = animator.deltaPosition;
        velocity.y = ySpeed * Time.deltaTime;

        characterController.Move(velocity);
    }
}

지상에서만 제어하도록 수정

public float jumpHorizontalSpeed = 3;

void Update()
{
    // ...생략

    if (isGrounded == false)
    {
        Vector3 velocity = movementDirection * inputMagnitude * jumpHorizontalSpeed;
        velocity.y = ySpeed;

        characterController.Move(velocity * Time.deltaTime);
    }
}

Update() 메서드 하단에 점프 중 이동 추가

스크립트

y의 위치만 Character Controller가 제어하고 XZ의 움직임은 Root Motion에 맡겨야하는데, Root Motion의 동작과 Character Controller가 서로 경쟁을 벌임으로서 약간의 동작 결함이 발생할 수 있다.

OnAnimatorMove 메서드를 활용해서 움직임을 Character Controller가 모두 조작하도록 통합해 볼 것이다.

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

public class PlayerMovement : MonoBehaviour
{
    public float rotationSpeed = 720;
    public float jumpSpeed = 5;

    public Transform cameraTransform;

    private CharacterController characterController;
    private Animator animator;

    private float ySpeed;

    private void Start()
    {
        characterController = GetComponent<CharacterController>();
        animator = GetComponent<Animator>();
    }

    void Update()
    {
        float horizontalInput = Input.GetAxis("Horizontal");
        float verticalInput = Input.GetAxis("Vertical");

        Vector3 movementDirection = new Vector3(horizontalInput, 0, verticalInput);

        float inputMagnitude = Mathf.Clamp01(movementDirection.magnitude);

        if (Input.GetKey(KeyCode.LeftShift) || Input.GetKey(KeyCode.RightShift))
        {
            inputMagnitude *= 0.5f;
        }

        animator.SetFloat("Input Magnitude", inputMagnitude, 0.05f, Time.deltaTime);

        movementDirection = Quaternion.AngleAxis(cameraTransform.rotation.eulerAngles.y, Vector3.up) * movementDirection;
        movementDirection.Normalize();

        ySpeed += Physics.gravity.y * Time.deltaTime;

        if (movementDirection != Vector3.zero)
        {
            Quaternion toRotation = Quaternion.LookRotation(movementDirection, Vector3.up);
            transform.rotation = Quaternion.RotateTowards(transform.rotation, toRotation, rotationSpeed * Time.deltaTime);
        }
    }

    // 기본 루트모션의 동작을 재정의할 수 있다.
    private void OnAnimatorMove()
    {
        // movementDirection * speed 속도를 animator.deltaPosition으로 대체
        // animator.deltaPosition 이는 애니메이션에 의해 결정되는 위치 변경이다.
        Vector3 velocity = animator.deltaPosition;
        // 프레임마다의 위치 변경은 animator.deltaPosition이 담당하므로 ySpeed에 Time.deltaTime을 곱해준다.
        velocity.y = ySpeed * Time.deltaTime;

        characterController.Move(velocity);
    }
}

Character Controller와 물리 시스템을 이용하여 장애물을 밀어내는 방법에 대해 알아보자.

씬 구성

적당한 상자에 RigidBody 컴포넌트를 추가하고 씬을 구성한다.

스크립트

Character Controller의 충돌 감지 메서드를 활용하여 상자를 밀어보자.

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

public class ObstaclePush : MonoBehaviour
{
    public float forceMagnitude = 1;

    // Character Controller가 충돌하며 호출되는 메서드
    private void OnControllerColliderHit(ControllerColliderHit hit)
    {
        // 부착된 리지드바디 캐싱
        Rigidbody rigidbody = hit.collider.attachedRigidbody;

        if(rigidbody != null)
        {
            // 힘을 줄 방향은 캐릭터 정면
            Vector3 forceDirection = hit.gameObject.transform.position - transform.position;
            // y축은 배제
            forceDirection.y = 0;
            forceDirection.Normalize();

            // 특정 위치에서 힘을 가하는 메서드
            rigidbody.AddForceAtPosition(forceDirection * forceMagnitude, transform.position, ForceMode.Impulse);
        }
    }
}

Rigidbody.AddForceAtPosition public void AddForceAtPosition (Vector3 force, Vector3 position, ForceMode mode= ForceMode.Force); 지정된 위치에서 물리적인 힘을 가하는 함수

ForceMode.Force: 연속 + 질량 적용 : 현실적인 물리 현상 ForceMode.Accel: 연속 + 질량 무시 : 오브젝트 질량 관계 없이 가속 ForceMode.Impulse: 불연속 + 질량 적용 : 폭발이나 충돌과 같은 짧은 순간의 힘 ForceMode.VelocityChange: 불연속 + 질량 무시 : 질량이 다른 오브젝트들을 같은 속도로 움직이고 싶을 때

Cinemachine을 이용하여 3인칭 카메라를 만들어보자.

FreeLock 카메라

씬에 FreeLock 카메라를 추가한다.

FreeLock 카메라에 Follow 타겟과 Look At 타겟을 지정한다.

Orbits

FreeLock 카메라를 선택하고 씬 뷰를 보면 3개의 빨간색 원을 볼 수 있다.

이는 카메라의 세가지 궤도 반경을 보여준다. 상단, 중단, 하단의 Rig의 높이와 반경을 변경하여 카메라 높이가 변경됨에 따라 캐릭터에 얼마나 가까이 위치하는지 설정할 수 있다.

카메라가 높을수록 반경이 커지고, 카메라가 낮을수록 확대된다.

스크립트

카메라가 바라보는 방향으로 움직이도록 스크립트를 작성해보자.

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

public class PlayerMovement : MonoBehaviour
{
    public float maximumSpeed = 3;
    public float rotationSpeed = 720;
    public Transform cameraTransform;

    private CharacterController characterController;
    private Animator animator;

    private void Start()
    {
        characterController = GetComponent<CharacterController>();
        animator = GetComponent<Animator>();
    }

    void Update()
    {
        float horizontalInput = Input.GetAxis("Horizontal");
        float verticalInput = Input.GetAxis("Vertical");

        Vector3 movementDirection = new Vector3(horizontalInput, 0, verticalInput);

        float inputMagnitude = Mathf.Clamp01(movementDirection.magnitude);
        float speed = inputMagnitude * maximumSpeed;

        if (Input.GetKey(KeyCode.LeftShift) || Input.GetKey(KeyCode.RightShift))
        {
            inputMagnitude *= 0.5f;
        }

        animator.SetFloat("Input Magnitude", inputMagnitude, 0.05f, Time.deltaTime);

        // 카메라의 y회전만으로 새회전을 생성
        // 카메라의 y회전을 이동 방향에 적용
        movementDirection = Quaternion.AngleAxis(cameraTransform.rotation.eulerAngles.y, Vector3.up) * movementDirection;
        movementDirection.Normalize();

        Vector3 velocity = movementDirection * speed;

        characterController.Move(velocity * Time.deltaTime);

        if (movementDirection != Vector3.zero)
        {
            Quaternion toRotation = Quaternion.LookRotation(movementDirection, Vector3.up);
            transform.rotation = Quaternion.RotateTowards(transform.rotation, toRotation, rotationSpeed * Time.deltaTime);
        }
    }

    private void OnApplicationFocus(bool focus)
    {
        // 어플리케이션이 포커스를 받으면 커서를 숨긴다.
        if (focus)
        {
            Cursor.lockState = CursorLockMode.Locked;
        }
        else
        {
            Cursor.lockState = CursorLockMode.None;
        }
    }
}

Quaternion.AngleAxis public static Quaternion AngleAxis (float angle, Vector3 axis); axis을 기준으로 angle만큼 회전시킨 회전량 angle: 회전량 axis: 기준축

카메라 정렬

캐릭터와 같은 방향을 향하도록 카메라를 자동으로 정렬시키는 기능을 추가해보자.

Binding Mode

FreeLock 카메라의 Binding Mode 값을 Lock To Target On Assign으로 변경한다.

Recenter to Target Heading

다시 중심 맞추기의 Enabled 값을 활성화한다.

게임패드

게임패드의 오른쪽 썸스틱을 이용하여 마우스와 같은 기능을 수행하도록 해보자.

Edit->Project Settings->Input Manager로 들어가 Mouse X, Mouse Y를 복사하고 다음 설정을 적용한다.

블렌드 유형이 1D라면 블렌딩이 단일 매개변수롤 제어된다는 것을 의미한다. 보통 사용의 목적은 속도를 기준으로 블렌딩할 때이다.

이동 방향과 속도를 기준으로 블렌딩하려는 경우

• 2D Simple Directional
• 2D Freeform Directional
• 2D Freeform Cartesian

을 사용한다.

블렌딩

Input Magnitude 매개변수의 값에 따라 Idle, Walking, Running 애니메이션을 자연스럽게 블렌딩하도록 설정할 수 있다.

스크립트

Input Magnitude 매개변수를 조작하여 블렌딩 애니메이션을 조작해보자. 점프 구현 스크립트의 이동부분을 수정한다.

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

public class PlayerMovement : MonoBehaviour
{
    // 최대 속도 정의
    public float maximumSpeed = 3;

    void Update()
    {
        // ...생략

        Vector3 movementDirection = new Vector3(horizontalInput, 0, verticalInput);
        // 입력 크기와 최대 속도에 따라 캐릭터가 움직이는 속도 정의
        float inputMagnitude = Mathf.Clamp01(movementDirection.magnitude);
        float speed = inputMagnitude * maximumSpeed;

        // 키보드에서의 걷기 행동 추가
        if(Input.GetKey(KeyCode.LeftShift) || Input.GetKey(KeyCode.RightShift))
        {
            inputMagnitude *= 0.5f;
        }

        animator.SetFloat("Input Magnitude", inputMagnitude);

        movementDirection.Normalize();

        // ...생략
    }
}

문제 해결

걷기와 달리기 사이의 애니메이션이 스냅되는 문제를 해결해보자.

// 수정
animator.SetFloat("Input Magnitude", inputMagnitude, 0.05f, Time.deltaTime);

애니메이션이 너무 빨리 바뀌지않도록 감쇠하는 효과가 있도록 dampTime을 설정한다.

Mono : JIT 컴파일을 사용하여 런타임 시점에 요청 시 코드를 컴파일한다. IL2CPP : AOT 컴파일을 사용하여 실행 전에 전체 애플리케이션을 컴파일한다.

Mono는 사용하기 쉽고 컴파일 시간이 빠르고, IL2CPP는 컴파일 시간이 느리지만 플랫폼에 맞는 최대 성능을 낼 수 있다.

JIT(Just-In-Time) 프로그램에서 코드가 실행되는 시점에 기계어로 번역하는 컴파일 기법 동적 번역 런타임 컴파일

AOT(Ahead-Of-Time) 런타임 시 수행해야 할 작업량을 줄이기 위해 빌드 타임에서 미리 컴파일하는 기법

Mono

c#으로 작성된 스크립트를 IL(Intermediate Language) 코드로 컴파일한 후 런타임 환경에서 실행된다.

AOT 컴파일을 지원하지 않는 플랫폼에 적합

IL2CPP

IL(Intermediate Language) 2(to) CPP(C++)의 약자로 IL(Intermediate Language) 코드를 c++ 코드롤 전환하고, 타겟 플램폼에서 직접 실행될 수 잇는 적합한 네이티브 바이너리 파일로 컴파일한다.

Mono나 JIT 컴파일을 지원하지 않는 플랫폼에 적합

IL2CPP의 장점

• c++을 지원하는 플랫폼이 더 많기 때문에 다양한 플랫폼을 지원할 수 있다.
• 타겟 플랫폼에 최적화된 c++ 코드를 생성하기 때문에 성능이 향상된다.
• 역설계하기 어려운 컴파일된 c++로 대체되기 때문에 보안성이 개선된다.

장애물에 막힌 카메라의 충돌 처리를 Cinemachine으로 해결해보자.

CinemachineCollider

버츄얼 카메라에서 확장 컴포넌트를 추가한다.

전략 선택

충돌을 처리할 전략과 댐핑시간을 선택한다.

점프 후 착지한 후 곧바로 점프하려고 할 때 의도와는 다르게 입력이 씹히거나, 높은 곳에서 아래로 점프할 때 생각했던 타이밍에 점프가 되지 않아 불쾌한 조작 경험을 줄 수 있는 환경을 해결하기 위해 점프를 하는데에 유예 시간을 적용하여 좀 더 부드럽고, 불합리하다고 느끼지 않도록 개선해보도록 하겠다.

스크립트 수정

점프 구현 스크립트를 수정한다.

/* 
 * 변수 추가
 */

// 점프버튼 유예 시간
public float jumpButtonGracePeriod = 0.2f;

// 마지막 땅 접지 시간
private float? lastGroundedTime;
// 점프 버튼을 누른 시간
private float? jumpButtonPressedTime;


/* 
 * 업데이트 메서드 수정 
 */

void Update()
{
    //...중략

    if (characterController.isGrounded)
    {
        lastGroundedTime = Time.time;
    }
    if (Input.GetButtonDown("Jump"))
    {
        jumpButtonPressedTime = Time.time;
    }

    if (Time.time - lastGroundedTime <= jumpButtonGracePeriod)
    {
        characterController.stepOffset = originalStepOffset;
        ySpeed = -0.8f;

        if (Time.time - jumpButtonPressedTime <= jumpButtonGracePeriod)
        {
            ySpeed = jumpSpeed;

            lastGroundedTime = null;
            jumpButtonPressedTime = null;
        }
    }
    else
    {
        characterController.stepOffset = 0;
    }

    //...중략
}

버튼을 누른 시점 땅에 접지 한 시점 을 저장하여, 유예 시간 전에 버튼이 눌렸다면 점프를 실행할 수 있도록 스크립트를 수정했다.

Time.time - Null 허용 값 형식의 연산 결과는 Null이다.

Character Controller를 이용하여 점프를 구현해보자.

스크립트

PlayerMovement 스크립트를 이어서 사용한다.

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

public class PlayerMovement : MonoBehaviour
{
    public float speed = 5;
    public float rotationSpeed = 720;
    // 점프 속도 설정
    public float jumpSpeed = 5;

    private CharacterController characterController;
    // 현재 적용받는 y의 속도값
    private float ySpeed;
    // CharacterController의 StepOffset 설정값
    private float originalStepOffset;

    private void Start()
    {
        characterController = GetComponent<CharacterController>();
        // 설정된 StepOffset값 저장
        originalStepOffset = characterController.stepOffset;
    }

    void Update()
    {
        //..증략

        // 중력에 의한 ySpeed 감소
        ySpeed += Physics.gravity.y * Time.deltaTime;

        // 지상에 있는 경우만 점프
        if(characterController.isGrounded)
        {
            // 기존 설정값으로 다시 설정
            characterController.stepOffset = originalStepOffset;
            // 안정된 점프를 위한 초기화
            ySpeed = -0.8f;

            // 점프
            if (Input.GetButtonDown("Jump"))
            {
                ySpeed = jumpSpeed;
            }
        }
        else
        {
            // 점프 중에는 어딜 올라갈 필요가 없으니 0으로 설정
            characterController.stepOffset = 0;
        }

        // 점프 속도를 포함한 velocity 계산
        Vector3 velocity = movementDirection * magnitude;
        velocity.y = ySpeed;

        // Move() 메서드로 변경
        characterController.Move(velocity * Time.deltaTime);

        //...중략
    }
}

CharacterController.Move public CollisionFlags Move (Vector3 motion); Grounded 체크 가능 중력에 영향 받지 않음 Time.deltaTime은 내장 되어있지 않음

문제 해결

ySpeed가 계속 감소하는 문제

ySpeed가 계속 감소하기 때문에 높은 곳에서 떨어질 때 지면에 바로 스냅하는 문제가 발생한다. 이를 해결하기 위해 땅에 접지해있을 때는 ySpeed를 초기화해주도록 한다.

if(characterController.isGrounded)
{
    ySpeed = -0.8f;
}

여기서 ySpeed를 0이 아닌 -0.8로 초기화해주는 이유는 isGrounded 체크의 불안정성으로 ySpeed의 값이 더욱 감소했다가 0으로 초기화되는 문제를 해결하기 위함이다.

벽으로 점프했을 때 문제

벽으로 점프하게 되면 Character Controller의 Step Offset 속성으로 인해 계단을 타는 듯한 현상이 발생하게 된다. 이를 해결하기 위해 낙하 중일 때는 Step Offset의 값을 0으로 설정해준다.

if(characterController.isGrounded)
{
    characterController.stepOffset = originalStepOffset;
}
else
{
    characterController.stepOffset = 0;
}

시네머신을 이용하여 간단한 Follow Camera를 만들어보자.

구성

Window->Package Manager를 통해 Cinemachine 설치하고 Virtual Camera 생성

카메라 설정

팔로우 타겟 지정 (회전은 원하지 않으므로 Look At 타겟은 지정하지 않음)

카메라를 움직이는 알고리즘 선택 (Framing Transposer)

카메라의 x축 앵글을 45도로 수정

최종 화면

캐릭터 움직임의 기초를 제공하는 Character Controller 컴포넌트를 추가하여 장애물을 고려한 이동 처리를 구현해보자.

씬 구성

경사진 지역과 계단 지역을 만들어준다.

플레이어 오브젝트 구성

플레이어 오브젝트에 Character Controller 컴포넌트를 부착한다.

스크립트 수정

Character Controller 컴포넌트를 이용하여 이동하도록 코드를 수정한다.

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

public class PlayerMovement : MonoBehaviour
{
    //...중략

    private CharacterController characterController;

    private void Start()
    {
        characterController = GetComponent<CharacterController>();
    }

    void Update()
    {
        //...중략

        Vector3 movementDirection = new Vector3(horizontalInput, 0, verticalInput);
        float magnitude = Mathf.Clamp01(movementDirection.magnitude) * speed;
        movementDirection.Normalize();

        characterController.SimpleMove(movementDirection * magnitude);

        //...중략
    }
}

CharacterController.SimpleMove public bool SimpleMove (Vector3 speed); 중력을 적용 받음 Grounded 체크 가능 y축의 속도는 무시됨 Time.deltaTime은 내장되어 있음

Character Controller 속성

유니티 레퍼런스

대각선으로 움직일 때 속도가 빨라지는 부분을 해결하기 위해 이동 벡터를 정규화시켜주었다. 이는 게임패드로 조작 시 왼쪽 썸스틱의 기울기와는 상관없이 일정한 움직임을 갖도록 했다. 이를 해결해보자.

이동 벡터를 정규화하지 않고 게임패드로 움직여보면 썸스틱의 기울기에 따라 이동속도가 달라지는 걸 볼 수 있다.

해결책

1. 이동 벡터를 정규화하기 전 이동 벡터의 크기를 구한다.

   float magnitude = movementDirection.magnitude;

2. 이동 벡터의 크기가 1을 넘지 못하도록 처리한다.

   magnitude = Mathf.Clamp01(magnitude);

3. 이동속도와 곱해준다.

   transform.Translate(movementDirection * magnitude * speed * Time.deltaTime, Space.World);

   
   

이동 벡터의 크기를 이용하여 게임패드 왼쪽 썸스틱의 기울기에 따라 이동속도가 조절되도록 하여 문제를 해결할 수 있다.