📌 Unity 게임 개발 숙련

---

---

📌 애니메이션 컨트롤

➔ 🔥 핵심 내용

Light 컴포넌트

• 라이트 소스 : 게임 또는 3D 랜더링에 광원을 추가하는 데 사용된다. 이것은 특정 위치 또는 방향에서 발생하는 빛을 나타낸다.

• 유형 : 라이트는 여러유형이 있다. 이러한 유형 중 몇가지는 다음과 같다.

  	- 점 광원(Point Light) : 특정 지점에서 모든 방향으로 빛을 방산하는 라이트이다.

  • 방향성 라이트(Directional Light) : 특정 방향에서 모든 객체를 비추는 라이트이다. 이 라이트는 거리에 관게없이 동일한 강도로 모든 객체를 비춘다.
  • 스포트라이트(Spot Light) : 특정 방향으로 원뿔형의 빛을 발산하는 라이트이다.
  • 영역 라이트(Area Light) : 특정 영역에서 발생하고 그 주변에 빛을 발산하는 라이트이다. (예 : 실내 조명).

• 속성 : 각 라이트에는 여러 속성이 있다. 이러한 속성에는 위치, 방향, 강도(intensiy), 색상(color), 범위(range), 각도(angle) 등이 포함된다.

• 그림자 : 라이트는 그림자를 생성할 수 있다. 라이트와 객체 사이의 관계에 따라 그림자는 라이트가 부딪히는 객체 뒤에 생성된다.

• 성능 : 라이트는 렌더링 성능에 큰 영향을 미친다. 많은 라이트를 사용하면 특히 동적 그림자가 포함된 경우 렌더링 성능에 부정적인 영향을 미칠 수 있다. 따라서 최적화는 중요한 고려사항이다.

• 빛 반사 및 산란 : 라이트는 표면에 부딪히고 반사되거나 다른 방향으로 산란되어 재질과 표면의 실제성을 나타낸다. 이러한 효과는 물리 기반 렌더링(PBR)에서 중요한 요소다.

스카이박스

게임 세게의 배경을 둘러싸는 환경 매핑 기술이다. 큐브 맵(Cube Map)과 구체형 스카이박스(Sphere Map)등이 있으며, 주로 다음과 같은 특징을 가진다.

• 스카이박스는 6개의 텍스처로 구성된 큐브 맵 또는 하나의 구체로 텍스처가 매핑된 구체형 스카이박스로 구성된다.

• Unity에서는 씬의 배경으로 사용되며, 게임 환경을 확장시키는데 활용된다.

• 주로 하늘, 구름, 산 등의 자연적인 배경을 표현하는 데 사용된다.

• 미리 만들어진 스카이박스를 사용하거나 직접 만들어서 Unity에서 적용할 수 있다.

• 게임 중에 스카이박스를 동적으로 변경하여 낮과 밤 등의 시간대나 특정 이벤트에 맞게 배경을 변화시킬 수 있다.

• 성능에 영향을 미치므로 최적화에 주의해야 한다.

Rigidbody - ForceMode

Rigidbody 컴포넌트를 사용하여 게임 오브젝트에 물리적인 힘을 가할 때, 이 ForceMode를 사용하여 다양한 힘 적용 방식을 설정할 수 있다.

주요한 ForceMode종류는 다음과 같다.

• Force : 힘을 지속적으로 적용한다.

  • Rigidbody.AddForce(Vector3 force, ForceMode.Force);

• Acceleration : 가속도를 적용한다. 이전 힘의 누적에 따라 점진적으로 더 빠르게 움직이게 된다.

  • Rigidbody.AddForce(Vector3 force, ForceMode.Acceleration);

• Impulse : 순간적인 힘을 적용한다. 짧은 시간에 갑작스러운 움직임이 발생한다.

  • Rigidbody.AddForce(Vector3 force, ForceMode.Impulse);

• VelocityChange : 변화하는 속도를 적용한다. 물체의 현재 속도를 변경하면서 움직인다.

  • Rigidbody.AddForce(Vector3 force, ForceMode.VelocityChange);

이러한 ForceMode를 적절히 활용하여 게임 오브젝트에 원하는 물리적인 움직임과 효과를 부여할 수 있다.

➔ 지형 준비하기

• Externals - _Environments ➔ Scene에 배치

• Material 생성 - SkyBox 이름 변경 - 아래와 같이 변경(색은 자유롭게)

• Window - Rendering - Lighting ➔ Skybox Material 에 설정

➔ 플레이어 준비하기

오브젝트 준비

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

• 하위에 빈 오브젝트 생성 - CameraContainer 생성

• Main Camera 하위로 변경

• Capsule Collider 아래와 같이 추가

• Rigidbody 아래와 같이 추가

• 아래와 같이 Input Action 준비

• Player Input 추가

• Invoke Unity Events로 변경

스트립트 준비 (PlayerController.cs)

• PlayerController 스크립트 생성

• 추가

public class PlayerController : MonoBehaviour
{
    [Header("Movement")]
    public float moveSpeed;
    private Vector2 curMovementInput;
    public float jumpForce;
    public LayerMask groundLayerMask;

    [Header("Look")]
    public Transform cameraContainer;
    public float minXLook;
    public float maxXLook;
    private float camCurXRot;
    public float lookScnsitivity;

    private Vector2 mouseDelta;

    [HideInInspector]
    public bool canLook = true;

    private Rigidbody _rigidbody;

    public static PlayerController instance;
    private void Awake()
    {
        instance = this;
        _rigidbody = GetComponent<Rigidbody>();
    }

    private void Start()
    {
        Cursor.lockState = CursorLockMode.Locked;   // 1인칭 이기에 커서를 잠궈둔다.
    }

    // 물리적 처리
    private void FixedUpdate()
    {
        Move();
    }

    // 보통 카메라 처리
    private void LateUpdate()
    {
        if(canLook)
        {
            CameraLook();
        }
    }

    #region Actual Processing With Input Values (입력받은 값으로 실제 처리)
    private void Move()
    {
        // 캐릭터가 서있는 상태 * 입력한 값
        Vector3 dir = transform.forward * curMovementInput.y + transform.right * curMovementInput.x;
        dir *= moveSpeed;
        dir.y = _rigidbody.velocity.y;  // y값은 어차피 없애야 하는데, y값을 velocity에 있는 y값으로 가져온다. (그러면 그 위치 정도를 쓸 수 있다.)
        
        _rigidbody.velocity = dir;
    }

    void CameraLook()
    {
        // 마우스가 y로 움직였다는건 위아래로 움직이는 것이지만 로테이션은 x가 바뀌게 하고있다.
        // 3축으로 보면 x축으로 회전을 할 때에 캐릭터가 위아래를 보게 되기 때문에
        // 마우스를 밀고 땅겼을 때, x축이 바뀌는 것이 맞다.
        camCurXRot += mouseDelta.y * lookScnsitivity;
        camCurXRot = Mathf.Clamp(camCurXRot, minXLook, maxXLook);   // 가동범위 제한
        cameraContainer.localEulerAngles = new Vector3(-camCurXRot, 0, 0);  // 마우스의 상하에 따라 시야를 움직이게 해준다.

        transform.eulerAngles += new Vector3(0, mouseDelta.x * lookScnsitivity, 0); // 마우스로 카메라를 움직일 수 있게 해주는 준비
    }
    #endregion

    #region InputValue (입력값)
    public void OnLookInput(InputAction.CallbackContext context)    // InputAction.CallbackContext : InputAction 안에 있는 CallbackContext
    {
        mouseDelta = context.ReadValue<Vector2>();  // 입력 처리가 일어난 거에서(context) Vector2로 읽어온다(ReadValue<Vector2>)
    }

    public void OnMoveInput(InputAction.CallbackContext context)
    {
        // phase : 상태, context.phase ? context의 상태, InputActionPhase.Performed ? InputAction의 상태는 Performed
        // Startid, Performed, Cancle 각각 값을 언제 가져오느냐
        // Started : 처음 한번, 맨 처음 프레임에서 이루어 졌을때, 그 때 한번 가져옴. 그 다움부터는 제대로 반환이 x
        // Performed : 눌러지는 중
        // Canceled : 뗏다면
        if(context.phase == InputActionPhase.Performed)
        {
            curMovementInput = context.ReadValue<Vector2>();
        }
        else if(context.phase == InputActionPhase.Canceled)
        {
            curMovementInput = Vector2.zero;   // 키를 떼면 움직이면 안되니까
        }
    }


    public void OnJumpInput(InputAction.CallbackContext context)
    {
        if(context.phase == InputActionPhase.Started)
        {
            if(IsGrounded())    // IsGrounded() : 땅인지 체크
            {
                // ForceMode의 종류 4가지 Force, Impulse, Acceleration, VelocityChange
                // Impulse : 질량을 가지고서 처리
                _rigidbody.AddForce(Vector2.up * jumpForce, ForceMode.Impulse);
            }
        }
    }
    #endregion

    // 땅을 밟고있는치 체크 ( 무한 점프 막기 )
    private bool IsGrounded()
    {
        // 캐릭터 기준 앞,뒤,왼,오 4방향의 * 0.2만큼 간 아래를 체크 (3D맵은 자유롭기 때문에)
        // (Vector3.up * 0.01f) 하여 캐릭터의 바닥보다 조금 더 위에서 쏴줘서 예외 방지
        Ray[] rays = new Ray[4]
        {
            new Ray(transform.position + (transform.forward * 0.2f) + (Vector3.up * 0.01f), Vector3.down),
            new Ray(transform.position + (-transform.forward * 0.2f) + (Vector3.up * 0.01f), Vector3.down),
            new Ray(transform.position +(transform.right * 0.2f) +(Vector3.up * 0.01f), Vector3.down),
            new Ray(transform.position +(-transform.right * 0.2f) +(Vector3.up * 0.01f), Vector3.down)
        };

        for(int i = 0; i < rays.Length; i++)
        {
            if (Physics.Raycast(rays[i], 0.1f, groundLayerMask))
            {
                return true;    // Ray가 하나라도 바닥에 닿으면 true반환 (점프가 가능하게)
            }
        }

        return false;
    }

    // OnDrawGizmos : 기즈모가 항상 보인다.
    // OnDrawGizmosSelected : 컨택을 했을때 에만 Gizmos가 보인다. (복잡한 상태에서 유리)
    private void OnDrawGizmos()
    {
        Gizmos.color = Color.red;
        Gizmos.DrawRay(transform.position + (transform.forward * 0.2f), Vector3.down);
        Gizmos.DrawRay(transform.position + (-transform.forward * 0.2f), Vector3.down);
        Gizmos.DrawRay(transform.position + (transform.right * 0.2f), Vector3.down);
        Gizmos.DrawRay(transform.position + (-transform.right * 0.2f), Vector3.down);
    }
}

---

📌 플레이어 상태 및 UI

➔ 🔥 핵심 내용

인터페이스 복습

인터페이스를 통해 클래스들은 공통적인 동작을 정의하고, 이러한 동작들을 구현하는 클래스들은 해당 인터페이스를 구현(implement)함으로써 공통 규약을 준수할 수 있다.

인터페이스를 설명하는 주요 특징은 다음과 같다.

• 추상화 : 인터페이스는 추상적인 개념으로, 실제로 구현된 메서드가 없고, 메서드의 시그니처만을 가진다. 따라서 인터페이스는 인스턴스화될 수 없으며, 구현체가 필요하다.

• 메서드 시그니처 : 인터페이스는 구현 클래스가 반드시 구현해야 하는 메서드들의 시그니처를 정의한다. 메서드의 이름, 매개변수, 반환 타입이 포함된다.

• 다중 상속 가능 : 클래스는 하나의 클래스만 상속받을 수 있지만, 여러 인터페이스를 동시에 구현할 수 있다. 이를 통해 다중 상속을 흉내내는 것이 가능하다.

• 강제적 구현 : 클래스가 인터페이스를 구현하면, 인터페이스에서 정의한 모든 메서드를 반드시 구현해야 한다. 이로 인해 클래스는 인터페이스에 정의된 동작을 강제로 구현하게 된다.

• 인터페이스 간 확장 : 인터페이스는 다른 인터페이스를 확장(extends)할 수 있다. 리를 통해 더 큰 범위의 공통 동작을 정의할 수 있다.

➔ UI 만들기

UI 생성

• Canvas 생성 - Canvas Scaler 설정

• Health 배경 준비

• Image ➔ Icon 추가

• 2D Sprite Package 설치 - Squre 생성

• Image 추가 생성

• 빈 오브젝트 생성 ➔ Conditions 생성

• 앞서 만든 Health를 이용해 3개의 속성 생성

• Image 추가 ➔ Crosshair 생성

• Image 추가 ➔ DamageIndicator 생성

➔ 플레이어 속성

PlayerConditions.cs 추가

// 인터페이스가 효율적이다 이런건 없다. 구조에 맞춰서 클래스를 상속하게 할 것인지.
// 인터페이스를 사용할 것인지 고르면 된다.
public interface IDamagable
{
    void TakePhysicalDamage(int damageAmout);
}

// Cass Condition : 체력, 배고픔, 스태미너의 값들
[System.Serializable]   // 직렬화
public class Condition
{
    [HideInInspector]
    public float curValue;  // 최솟값
    public float maxValue;  // 최댓값
    public float startValue;    // 시작값
    public float regenRate; // 회복률
    public float decayRate; // 감소률
    public Image uiBar;

    public void Add(float amount)
    {
        curValue = Mathf.Min(curValue + amount, maxValue);
    }

    public void Subtract(float amount)
    {
        curValue = Mathf.Max(curValue - amount, 0.0f);
    }

    // 퍼센트값들은 대부분 0과 1을 사용한다.
    public float GetPercentage()
    {
        return curValue / maxValue;
    }
}

public class PlayerConditions : MonoBehaviour, IDamagable
{
    public Condition health;
    public Condition hunger;
    public Condition stamina;

    public float noHungerHealthDecay;   // 배고픔이 다 닳으면 피가 줄어들게

    public UnityEvent onTakeDamage; // 데미지를 받았을 때, 처리할 이벤트 받아두기 위한

    void Start()
    {
        health.curValue = health.startValue;
        hunger.curValue = hunger.startValue;
        stamina.curValue = stamina.startValue;
    }

    void Update()
    {
        hunger.Subtract(hunger.decayRate * Time.deltaTime); // 배고픔은 주기적으로 닳는다.
        stamina.Add(stamina.regenRate * Time.deltaTime);    // 스태미나느 주기적으로 회복한다.

        if (hunger.curValue == 0.0f)    // 배고픔이 0 ? 체력이 닳는다
            health.Subtract(noHungerHealthDecay * Time.deltaTime);

        if (health.curValue == 0.0f)    // 체력이 0 ? 사망
            Die();

        // UI화면 게이지 업데이트
        health.uiBar.fillAmount = health.GetPercentage();
        hunger.uiBar.fillAmount = hunger.GetPercentage();
        stamina.uiBar.fillAmount = stamina.GetPercentage();
    }

    public void Heal(float amount)
    {
        health.Add(amount);
    }

    public void Eat(float amount)
    {
        hunger.Add(amount);
    }

    // 스태미나를 사용할 수 있는지 체크
    public bool UseStamina(float amount)
    {
        if (stamina.curValue - amount < 0)
            return false;

        stamina.Subtract(amount);
        return true;
    }

    public void Die()
    {
        Debug.Log("플레이어 사망");
    }

    public void TakePhysicalDamage(int damageAmount)
    {
        health.Subtract(damageAmount);
        onTakeDamage?.Invoke();
    }
}

컴포넌트 설정

• 플레이어 오브젝트에 추가

---

📌 플레이어 데미지 처리

➔ 🔥 핵심 내용

Invoke

Invoke(string methodName, float time) : 지정된 시간 (time) 후에 지정된 메서드 (methodName)를 실행한다.

• methodName : 실행할 메서드의 이름을 문자열로 지정한다.

• time : 메서드를 실행할 시간을 초 단위로 지정한다.

using UnityEngine;

public class ExampleScript : MonoBehaviour
{
    private void Start()
    {
        Invoke("DelayedMethod", 2.0f);
    }

    private void DelayedMethod()
    {
        Debug.Log("This method is called after 2 seconds.");
    }
}

Invoke Repeating

InvokeRepeating(string methodName, float time, float repeatRate) : 지정된 시간 (time) 후에 지정된 메서드 (methodName)를 주기적으로 반복해서 실행한다.

• methodName : 실행할 메서드의 이름을 문자열로 지정

• time : 메서드를 처음 실행할 때 까지의 시간을 초 단위로 지정한다.

• repeatRate : 메서드를 반복해서 실행할 주기를 초 단위로 지정한다.

csharpCopy code
using UnityEngine;

public class ExampleScript : MonoBehaviour
{
    private void Start()
    {
        InvokeRepeating("RepeatingMethod", 2.0f, 3.0f);
    }

    private void RepeatingMethod()
    {
        Debug.Log("This method is called every 3 seconds after 2 seconds delay.");
    }
}

TryGetComponent

TryGetComponent는 Unity에서 사용하느 메서드로, 게임 오브젝트의 컴포넌트를 가져오는 기능을 제공한다. 이 메서드를 사용하면 특정한 컴포넌트가 게임 오브젝트에 연결되어 있는지 확인하고, 연결되어 있다면 해당 컴포넌트를 가져올 수 있다.

TryGetComponent 메서드의 형식은 다음과 같다.

public bool TryGetComponent<T>(out T component) where T : Component;

• T : 가져오려는 컴포넌트의 타입니다. MonoBehaviour를 상속한 컴포넌트는 모두 사용이 가능하다.

• component : 컴포넌트를 가져올 때 사용되는 out 매개변수이다.

사용법은 아래과 같다.

using UnityEngine;

public class ExampleScript : MonoBehaviour
{
    private void Start()
    {
        // 게임 오브젝트에 Rigidbody 컴포넌트가 있는지 확인하고 가져옵니다.
        Rigidbody rb;
        if (TryGetComponent<Rigidbody>(out rb))
        {
            // Rigidbody 컴포넌트가 있다면 해당 컴포넌트로 원하는 동작을 수행합니다.
            rb.AddForce(Vector3.up * 100f);
        }
        else
        {
            // Rigidbody 컴포넌트가 없다면 다른 처리를 수행합니다.
            Debug.Log("Rigidbody component not found.");
        }
    }
}

TryGetComponent는 컴포넌트가 없어도 예외를 발생시키지 않고, 컴포넌트가 있으면 해당 컴포넌트를 가져와서 사용할 수 있다. 이를 통해 더 안전하게 컴포넌트를 가져오고 사용할 수 있다.

➔ 캠프파이어 만들기

오브젝트 만들기

• CampFire 프리팹을 Scene에 배치

• Capsule Collider 추가

CampFire 만들기

public class CampFire : MonoBehaviour
{
    public int damage;
    public float damageRate;

    private List<IDamagable> thingsToDamage = new List<IDamagable>();   // 자주 넣고 빼고 하기에 규모가 커지면 리스트 보다는 해쉬를 사용 권장?

    private void Start()
    {
        InvokeRepeating("DealDamage", 0, damageRate);  // InvokeRepeating : n의 지연시간을 주고 m만큼 계속 지연실행을 해라
    }

    void DealDamage()
    {
        for(int i = 0; i < thingsToDamage.Count; i++)
        {
            thingsToDamage[i].TakePhysicalDamage(damage);
        }
    }

    // 캠프파이어 불에 닿으면 트리거 엔터 하여 thingsToDamage 리스트에 데미지 정보가 추가되고
    // InvokeRepeating 하여 DealDamage가 돌아가며 들어간 만큼의 데미지를 준다. damageRate 속도로 계속 실행
    // 트리거 엑시트 하면 다시 thingsToDamage 리스트의 데미지 정보가 빠진다.
    private void OnTriggerEnter(Collider other)
    {
        // TryGetComponent : bool형의 함수로 해당 타입의 컴포넌트를 찾았다면 true 반환 아니면 false하는 함수
        // 찾았다면 out되는 component에 해당 타입의 컴포넌트를 할당해준다.
        if (other.gameObject.TryGetComponent(out IDamagable damagable))
        {
            thingsToDamage.Add(damagable);  // thingsToDamage 에 IDamagable 을 Add
        }
    }

    private void OnTriggerExit(Collider other)
    {
        if (other.gameObject.TryGetComponent(out IDamagable damagable))
        {
            thingsToDamage.Remove(damagable);
        }
    }
}

➔ 데미지 인디케이터 적용하기

오브젝트 설정

• HUDCanvas - DamageIndicator 아래와 같이 설정

• Player - Player Conditions - OnTake Damage 설정

DamageIndicator 만들기

public class DamageIndicator : MonoBehaviour
{
    public Image image;
    public float flashSpeed;

    private Coroutine coroutine;

    public void Flash()
    {
        if (coroutine != null) // coroutine이 null이 아니라는 것은 이전에 coroutine이 돌아간 적이 있다는 것
        {
            StopCoroutine(coroutine); // 그래서 중지를 먼저 시켜준다.
        }

        image.enabled = true;
        image.color = Color.red;
        coroutine = StartCoroutine(FadeAway());
    }

    private IEnumerator FadeAway()
    {
        float startAlpha = 0.3f;
        float a = startAlpha;

        while(a > 0.0f)
        {
            a -= (startAlpha / flashSpeed) * Time.deltaTime;    // 한번에 깎을 값
            image.color = new Color(1.0f, 0.0f, 0.0f, a);
            yield return null;
        }

        image.enabled = false;
    }
}

---

📌 낮과 밤 구현 (공부 필요 이해 x)

➔ 🔥 핵심 내용

AnimationCurve

AnimationCurve는 Unity에서 애니메이션의 키프레임(Keyframe)을 이용하여 값을 보간(interpolate)하는데 사용되는 클래스이다. 이 클래스를 사용하여 시간에 따라 값을 부드럽게 변화시키는 커브를 정의하고, 이를 기반으로 애니메이션을 만들 수 있다.

AnimationCurve 클래스의 기본적인 구성 요소는 다음과 같다.

• 키 프레임(Keyframe) : 시간에 따른 값을 정의하는 점을 의미한다. 키프레임은 시간(t)과 해당 시간에 대응하는 값(value)으로 이루어진다.

• 보간 방식(Interpolation Mode) : 인접한 키프레임 사이의 값을 보간하는 방법을 지정한다. 기본적으로는 Cubic Bezier 보간이 사용되며, 선형, 스텝, 등 다양한 보간 방식을 선택할 수 있다.

주요한 AnumationCurve 메서드 및 사용법은 다음과 같다.

• AddKey : 새로운 키프레임을 추가한다.

using UnityEngine;

public class ExampleScript : MonoBehaviour
{
    private AnimationCurve curve;

    private void Start()
    {
        // 새로운 AnimationCurve 생성
        curve = new AnimationCurve();

        // 키프레임 추가 (시간, 값)
        curve.AddKey(0f, 0f);
        curve.AddKey(1f, 1f);
    }

    private void Update()
    {
        // 시간에 따라 값을 보간하여 출력
        float time = Time.time;
        float value = curve.Evaluate(time);
        Debug.Log("Time: " + time + ", Value: " + value);
    }
}

• Evaluate : 특정 시간에 해당하는 값을 보간하여 반환한다.

• Keys : 키프레임의 배열을 가져온다. 이를 통해 키프레임들은 추가, 수정, 삭제할 수 있다.

AnimationCurve는 주로 애니메이션 시간에 따른 값을 정의하는데 사용되며, 특히 더 복잡한 애니메이션을 제어하기 위해 사용되는 경우가 많다. 예를 들어, 오브젝트의 움직임, 크기 조정, 회전 등에 대한 애니메이션을 정의하거나, 재미있는 게임 요소들에 활용할 수 있다.

➔ 낮과 밤 구현

라이트 셋팅 설정

• 기존의 Directional Light - Sun으로 수정

• Sun - Ctrl + D - Moon으로 변경

DayNightCycle.cs

public class DayNightCycle : MonoBehaviour
{
    [Range(0.0f, 1.0f)]
    public float time;
    public float fullDayLength;	// 하루의 길이(시간)
    public float startTime = 0.4f;
    private float timeRate;
    public Vector3 noon;

    [Header("Sun")]
    public Light sun;
    public Gradient sunColor;   // Gradient : 그라데이션
    public AnimationCurve sunIntensity; // AnimationCurve : 그래프를 만들 수 있다. 그러면 원하는 타임값을 그때 그때 꺼내서 사용가능.

    [Header("Moon")]
    public Light moon;
    public Gradient moonColor;
    public AnimationCurve moonIntensity;

    [Header("Other Lighting")]
    public AnimationCurve lightingIntensityMultiplier;  // 환경광
    public AnimationCurve reflectionIntensityMultiplier;    // 반사광

    private void Start()
    {
        timeRate = 1.0f / fullDayLength;
        time  = startTime;
    }

    private void Update()
    {
        time = (time + timeRate * Time.deltaTime) % 1.0f;   // time 값을 퍼센트(%)로 쓸 것이라 % 1.0 을 해준다. (그래서 time은 0 ~ 0.9999... 까지만 설정 가능)

        UpdateLighting(sun, sunColor, sunIntensity);
        UpdateLighting(moon, moonColor, moonIntensity);

        // 빛이 바뀌는 것이지 프로젝트의 전체적인 환경이 바뀌는 것이 아니다.
        // 실제 Sun이나 Moon 오브젝트를 끄거나 켜도 차이가 크지 않다.
        // 그래서 그 부분을 조정해준다.
        RenderSettings.ambientIntensity = lightingIntensityMultiplier.Evaluate(time); // 빛을 계속 최소화 시켜줄려 한다.
        RenderSettings.reflectionIntensity = reflectionIntensityMultiplier.Evaluate(time);
    }

    void UpdateLighting(Light lightSource, Gradient colorGradiant, AnimationCurve intensityCurve)
    {
        float intensity = intensityCurve.Evaluate(time);    // AnimationCurve는 시간값을 주면 그 시간에 맞는 그래프 값을 가져온다.

        // 실제로 이 Direction Light가 각도가 변하는 것에 맞춰서 빛이 바뀌기 때문에, 햇빛의 변화와 거의 유사하다.
        // noon = 점심 , 점심은 햇빛을 위에서 쏜다(90도) 낮이 돌고 밤이 도는걸 구체로 따져 4등분을 하면 낮이 2번 돌고 밤이 2번 도는 것이다.
        // noon * 4.0f : 90도 * 4.0f = 360도 인데 ightSource == sun ? 0.25f : 0.75f 에서
        // lightSource가 sun일 때, 원을 봤을 때, 윗쪽 중앙에서 떠야한다 그래서 원의 90도 지점, 1 / 4 지점, 25%지점 즉 0.25f
        // 밤 즉, 달이 가장 꼭대기에 있는 상태는 0.75f, 반바퀴에 반반바퀴 돌아 3 / 4 돌았을 때
        // 0.25f || 0.75f 상태 (sun, moon) 일 때, 90도를 곱해주는 것
        // 360도를 기준으로 해, 달이 뜨는 위치를 잡아주는 것이다.
        lightSource.transform.eulerAngles = (time - (lightSource == sun ? 0.25f : 0.75f)) * noon * 4.0f;
        lightSource.color = colorGradiant.Evaluate(time);
        lightSource.intensity = intensity;

        GameObject go = lightSource.gameObject;
        if (lightSource.intensity == 0 && go.activeInHierarchy)
            go.SetActive(false);
        else if (lightSource.intensity > 0 && !go.activeInHierarchy)
            go.SetActive(true);
    }
}

오브젝트 설정

• 최종적으로 다음과 같이 설정

• Sun Intensity

• Moon Intensity

• Other Lighting 도 위와 같은 방법으로 설정

• 다양하게 설정을 변경하면서 원하는 효과를 만들어 볼 수 있다.

---

📌 아이템과 상호작용

➔ 아이템 데이터 만들기

준비

• 이미지 스프라이트 확인

• 레이어 추가

데이터 스크립트 작성

• Item Data 스크립트 추가

public enum ItemType
{
    Resource,   // 리소스
    Equipable,  // 장착
    Consumable  // 소모
}

public enum ConsumableType
{
    Hunger,
    Health
}

[CreateAssetMenu(fileName = "Item", menuName = "New Item")]
public class ItemData : ScriptableObject
{
    [Header("Info")]
    public string displayName;
    public string description;
    public ItemType type;
    public Sprite icon;
    public GameObject dropPrefab;

    [Header("Stacking")]
    public bool canStack;
    public int maxStackAmount;
}

데이터 생성

오브젝트 만들기

• Wood

• Carrot

• Rock

• Axe

• Sword

• 다음과 같이 적절한 오브젝트와 콜라이더 사이즈 구성

➔ 아이템 스크립트 작성

ItemObject

public class ItemObject : MonoBehaviour, IInteractable
{
    public ItemData item;

    public string GetInteractPrompt()
    {
        return string.Format("Pickup {0}", item.displayName);
    }
    public void OnInteract()
    {
        Destroy(gameObject);
    }
}

InteractionManager

public interface IInteractable
{
    string GetInteractPrompt();
    void OnInteract();
}

public class InteractionManager : MonoBehaviour
{
    public float checkRate = 0.05f;
    private float lastCheckTime;
    public float maxCheckDistance;
    public LayerMask layerMask;

    private GameObject curInteractGameObject;
    private IInteractable curInteractable;

    public TextMeshProUGUI promptText;
    private Camera camera;

    void Start()
    {
        camera = Camera.main;   // main 태그를 쓰고있는 카메라 하나만 자동적으로 잡힌다.
    }

    void Update()
    {
        if (Time.time - lastCheckTime > checkRate)
        {
            lastCheckTime = Time.time;

            // RaycastHit을 쏠 때는 Ray를 하나 준비해줘야 한다. 이 레이저를 어디다 쏠건지 준비를 하고 
            // 레이저를 쏴바서 충돌이 일어난 정보를 받아온다.
            Ray ray = camera.ScreenPointToRay(new Vector3(Screen.width / 2, Screen.height / 2));    // 화면에 정 중앙에서 쏘겟다.
            RaycastHit hit; // 충돌 정보를 담을 hit

            if (Physics.Raycast(ray,out hit, maxCheckDistance, layerMask))  // ray가 충돌 했다면?
            {
                if (hit.collider.gameObject != curInteractGameObject)   // 충돌한 오브젝트가 저장해놨던 오브젝트랑 다른가?
                {
                    curInteractGameObject = hit.collider.gameObject;
                    curInteractable = hit.collider.GetComponent<IInteractable>();
                    SetPromtText();
                }
            }
            else // ray가 충돌 한게 없다면?
            {
                curInteractGameObject = null;
                curInteractable = null;
                promptText.gameObject.SetActive(false);
            }
        }
    }

    private void SetPromtText()
    {
        promptText.gameObject.SetActive(true);
        promptText.text = string.Format("<b>[E]</b> {0}", curInteractable.GetInteractPrompt());
    }

    public void OnInteractInput(InputAction.CallbackContext callbackContext)
    {
        if (callbackContext.phase == InputActionPhase.Started && curInteractable != null)   // 키가 눌러졌고 눌려있는 시점에 바라보는 물체가 null이 아니라면
        {
            // 아이템을 먹으면 아이템에 대한 상호작용을 진행하고 초기화를 진행.
            curInteractable.OnInteract();
            curInteractGameObject = null;
            curInteractable = null;
            promptText.gameObject.SetActive(false);
        }
    }
}

➔ 프롬프트 적용하기

UI 만들기

• Hid Canvas - Text 생성

폰트 만들기

• Font Asset Creator 클릭

• 다음과 같이 설정 후 Generate Font Atlas

• Character Sequence
  32-126,44032-55203,12593-12643,8200-9900에
  영어 범위 : 32-126
  한글 범위 : 44032-55203
  한글 자모 : 12593-12643
  특수 문자 : 8200-9900
  글꼴에 따라 지원하지 않는 특수 문자는 missing

• 완요 후 Save

프롬프트 적용하기

• PromptText - Font 변경

• Interaction Manager 설정

• Player Input Event 설정

---