Unity 숙련 - 2

이준호·2023년 12월 11일

📌 Unity 게임 개발 숙련

📌 애니메이션 컨트롤

➔ 🔥 핵심 내용

Aimation & Animator

이 두 컴포넌트는 서로 다른 목적과 사용 케이스에 따라 애니메이션을 제어하는 데 사용된다. Animation은 더 간단한 애니메이션에 사용되며, Animator는 더 복잡한 애니메이션 시퀀스와 상태 관리에 사용된다.

Animation :

Animation 컴포넌트는 게임 오브젝트에 애니메이션을 추가하는 데 사용된다.
이 컴포넌트는 애니메이션 클립을 재생할 수 있다.
Animation 컴포넌트는 간단한 애니메이션에 적합하며, 스크립트를 통해 직접 제어할 수 있다.
애니메이션 클립은 Unity의 Animation window를 통해 생성하거나 편집할 수 있다.
예를 들어, 이 컴포넌트를 사용하여 오브젝트의 크기를 변경하거나 색상을 변환하는 등의 간단한 애니메이션을 생성할 수 있다.

Animator

Animator 컴포넌트는 애니메이션의 상태를 제어하고 전환을 관리하는 데 사용된다.
Animator 컴포넌트는 Animation Controller를 사용하여 애니메이션의 복잡한 상태 기계를 구현할 수 있다.
Animator 컴포넌트는 여러 애니메이션 클립을 조절하고, 애니메이션 간의 전환을 제어하고, 복잡한 애니메이션 시퀀스를 구현하는 데 적합하다.
예를 들어, 캐릭터의 걷기, 뛰기, 점프 등의 애니메이션을 관리하는 데 사용될 수 있다.
Animator 컴포넌트는 Mecanim 애니메이션 시스템의 일부로서, 애니메이션 블렌딩, 트리, 상태 머신 등의 기능을 제공한다.

StringToHash

유니티 애니메이션 시스템에서 자주 사용되는 기능이다. 문자열을 해시 값으로 변환하며, 이로써 성능을 개선하고 코드의 가독성을 유지한다.

문자열 비교는 상대적으로 연산 비용이 큰 작업이다. "StringToHash"는 문자열을 고유한 정수 값인 해시 값으로 변환하여 이 연산 비용을 크게 줄일 수 있다.
해시 값은 고유하기 때문에 다른 문자열이 동일한 해시 값을 갖는 확률이 매우 낮다. 이를 활용해 문자열을 해시로 변환하면 효율적인 문자열을 비교할 수 있다.
애니메이션 파라미터를 지정할 때 문자열 대신 해시 값을 사용하면 CPU시간을 절약하고 애니메이션 성능을 향상시킬 수 있다.
그러나 주의할 점은 동일한 문자열은 항상 동일한 해시 값을 반환하지만, 반대로 동일한 해시 값이 항상 동일한 문자열을 반환하지는 않는다. 이 점으로 인해 해시 충돌이 발생할 수 있다.
또한, "StringToHash" 함수는 문자열을 해시 값으로 변환할 때 일방향으로 작동하기 때문에, 해시 값을 다시 원래의 문자열로 변환하는 것은 불가능하다.

➔ 애니메이션 컨트롤 하기

만들기

TopDownAnimations

public class TopDownAnimations : MonoBehaviour
{
    protected Animator animator;
    protected TopDownCharacterController controller;

    protected virtual void Awake()
    {
        animator = GetComponentInChildren<Animator>();
        controller = GetComponent<TopDownCharacterController>();
    }
}

TopDownAnimationController

public class TopDownAnimationController : TopDownAnimations
{
    // StringToHash : 특정한 문자열을 일정한 공식에 의해서 숫자값(Hash값)으로 변환을 한다.
    // 사용하는 이유? : Animator안에서 키값을 string으로 제공을 했을 때, 문자열 연산은 비용이 매우 높다.
    // 그래서 문자열을 비교하지 말고 Hash값(숫자값)을 비교하라고 처리르 해주는 것이다.
    // 이미 고유한 Hashtable이 존재하기 떄문에 Hash값으로 줘도 동일하게 처리가 이루어진다.
    private static readonly int IsWalking = Animator.StringToHash("IsWalking");
    private static readonly int Attack = Animator.StringToHash("Attack");
    private static readonly int IsHit = Animator.StringToHash("IsHit");

    protected override void Awake()
    {
        base.Awake();
    }

    void Start()
    {
        controller.OnAttackEvent += Attacking;
        controller.OnMoveEvent += Move;
    }

    private void Move(Vector2 obj)
    {
        animator.SetBool(IsWalking, obj.magnitude > .5f);
    }

    private void Attacking(AttackSO obj)
    {
        animator.SetTrigger(Attack);
    }

    private void Hit()
    {
        animator.SetBool(IsHit, true);
    }

    private void OnBecameInvisible()
    {
        animator.SetBool(IsHit, false);
    }
}

player_idle - Animation Clip

Player - MainSprte 클릭
Ctrl + 6 또는 Window ➔ Animation ➔ Animation 클릭

Creat 클릭 ➔ Animations - Player 폴더 생성 ➔ player_idle 이름 설정 ➔ 확인
Samples 12 설정 ( 없으면 밑에 사진처럼 설정 변경 )

knight_f_idle_anim_f0 ~ 3 선택 하여 넣기
두 칸씩 띄어 배치 ( 자연스럽게 알아서 조정 )

player_run - Animation Clip

Creat New Clip 클릭

Animations - Player 폴더 ➔ player_run 이름 설정 ➔ 확인
Samples 12 설정
knight_f_run_anim_f0 ~ 3 선택 후 넣기

player_hit - Animation Clip

Creat New Clip 클릭
Animations - Player 폴더 ➔ player_hit 이름 설정 ➔ 확인
Samples 12 설정
knight_f_hit-anim_f0 선택 후 2회 넣기

Add Property ➔ Sprite Renderer Color ➔ + 클릭

시작과 끝 프레임을 클릭하여 각각 설정

player_attack - Animation Clip

Creat New Clip 클릭
Animations - Player 폴더 ➔ player_attack 이름 설정 ➔ 확인
Samples 12 설정
WeaponSprite의 Position과 Scale 추가

수정

Animatior Controller

Window ➔ Animation ➔ Animator 클릭
Animations/Player/MainSprite 클릭
idle, hit, run 남기고 삭제
Entry 우클릭 ➔ Set StateMachine Default State ➔ idle 클릭

Parameter 클릭 ➔ IsWalking(Bool), Attack(Trigger), IsHit(Bool) 추가

idle 우클릭 ➔ Make Transition ➔ run 클릭
Transition 설정 변경 ➔ Has Exit Time 체크 해제, Condition 추가

run 우클릭 ➔ Make Transition ➔ idle 클릭
Transition 설정 변경 ➔ Has Exit Time 체크 해제, Condition 추가

hit & idle 도 다음과 같이 수정

Player 오브젝트

Player 오브젝트에 TopDownAnimationController.cs 추가

추가

Layer

Animator ➔ Layer ➔ +

Attack 이름 변경 ➔ Weight 1 ➔ Blending Additive ( Additive : 기존에 Layer에 추가되는 형식 )

Empty 노드 추가 ( 공격 이외에는 평소에는 나오면 안되기 때문 )

다음과 같이 설정 후 Transition 설정 변경

📌 적 구현

➔ 🔥 핵심 내용

FindGameObjectWithTag

"FindGameObjectWithTag"는 지정된 태그와 일치하는 첫 번째 활성 GameObject를 반환한다. 이 메서드는 특정 태그를 가진 오브젝트를 빠르게 찾을 수 있도록 돕는다.
태그를 사용하면 씬 내에서 특정 유형의 오브젝트를 쉽게 찾을 수 있으며, 코드에서 게임 오브젝트를 참조할 때 유용하다.
그러나 "FindGameObjectWithTag"는 매우 비싼 연산이다. 즉, 이 메서드를 사용하면 CPU를 많이 사용하게 된다. 따라서 이 메서드를 매 프레임마다 호출하면 게임 성능에 심각한 영향을 미칠 수 있다.
따라서 일반적으로는 이 메서드를 Start나 Awake와 같은 초기화 메서드에서 한 번만 호출하는 것이 권장된다. 오브젝트를 찾은 후에는 참조를 저장하고 나중에 재사용한다.
게임 오브젝트가 많은 큰 씬에서는 태그 대신 레이어나 다른 메서드를 사용하는 것이 더 효율적일 수 있다.

Physics.Raycast 또는 Physics2D.Raycast

Raycasting은 일련의 콜라이더와 교차하는지를 감지하는 데 사용되는 기술이다. 이는 레이저 포인터나 총알을 쏘는 효과를 만들거나, 플레이어의 시야를 계산하는 등 다양한 방식으로 사용된다.
Unity에서는 Physics.Raycast 또는 Physics2D.Raycast를 사용하여 Raycast를 수행할 수 있다. 이를 메서드는 시작점, 방향, 최대 거리, 그리고 선택적으로 레이어 마스크를 매개변수로 받는다.
Raycast는 hit정보를 반환한다. 이 정보에는 충돌한 객체, 충돌 지점, 충돌 지점의 정규화된 벡터 등이 포함된다.
Raycast는 충돌 검사에 비해 계산 비용이 많이 든다. 따라서 불필요한 Raycast를 줄이고, 가능한 경우 레이어 마스크를 사용하여 검사 범위를 제한하는 것이 성능에 좋다.
Raycast는 비주얼 디버깅을 위해 Debug.DrawRay와 함께 사용할 수 있다. 이를 통해 Scene뷰에서 Raycast의 경로를 시각적으로 확인할 수 있다.

➔ 근거리 적 만들기

만들기

GameManager

public class GameManager : MonoBehaviour
{
    public static GameManager instance;

    public Transform Player { get; private set; }
    [SerializeField] private string playerTag = "Player";

    private void Awake()
    {
        instance = this;
        Player = GameObject.FindGameObjectWithTag(playerTag).transform;
    }
}

GameManager 오브젝트에 추가

TopDownEnemyController

public class TopDownEnemyController : TopDownCharacterController
{
    GameManager gameManager;
    protected Transform ClosestTarget { get; private set; }

    protected override void Awake()
    {
        base.Awake();
    }

    protected virtual void Start()
    {
        gameManager = GameManager.instance;
        ClosestTarget = gameManager.Player;
    }

    protected virtual void FixedUpdate()
    {

    }

    // 가까운 적과의 거리를 구하는 메소드
    protected float DistanceToTarget()
    {
        return Vector3.Distance(transform.position, ClosestTarget.position); // 현재 오브젝트와 가까운 타겟 까지의 거리
    }

    // 타겟의 방향을 구하는 메소드
    protected Vector2 DirectionToTarget()
    {
        // transform.position에서 ClosestTarget.position를 바라보는 방향
        return (ClosestTarget.position - transform.position).normalized; // normalized : 정규화 하여 방향만 남긴다.
    }
}

TopDownContactEnemyController (근거리 적)

public class TopDownContactEnemyController : TopDownEnemyController
{
    [SerializeField][Range(0f, 100f)] private float followRange;
    [SerializeField] private string targetTag = "Player";
    private bool _isCollidingWithTarget;

    [SerializeField] private SpriteRenderer characterRendere;

    protected override void Start()
    {
        base.Start();
    }

    protected override void FixedUpdate()
    {
        base.FixedUpdate();

        Vector2 direction = Vector2.zero;
        if (DistanceToTarget() < followRange)
        {
            direction = DirectionToTarget();
        }

        CallMoveEvent(direction);
        Rotate(direction);
    }

    private void Rotate(Vector2 direction)
    {
        float rotZ = Mathf.Atan2(direction.y, direction.x) * Mathf.Rad2Deg;
        characterRendere.flipX = Mathf.Abs(rotZ) > 90f;
    }
}

Goblin

Default AttackData 생성 ➔ Goblin_DefaultAttackData 이름 변경

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

하위에 빈 오브젝트 생성 - MainSprite 이름 변경 ➔ Sprite Renderer 추가 ➔ goblin_idle_anim_f0 설정, Order in Layer4

Goblin 오브젝트에 필요 컴포넌트 추가

Animation Clip

Player Animation을 참고하여 Goblin 애니메이션 생성

수정

Player Object

Player ➔ Tag ➔ Player 수정

Animator Controller

Animator Controller 수정 ➔ Base Layer, Hit

➔ 원거리 적 만들기

만들기

TopDownRangedEnemyController (원거리 적)

public class TopDownRangeEnemyController : TopDownEnemyController
{
    [SerializeField] private float followRange = 15f;
    [SerializeField] private float shootRange = 10f;

    protected override void FixedUpdate()
    {
        base.FixedUpdate();

        float distance = DistanceToTarget();
        Vector2 direction = DirectionToTarget();

        IsAttacking = false;
        if(distance <= followRange)
        {
            if(distance <= shootRange)
            {
                int layerMaskTarget = Stats.CurrentStates.attackSO.target;
                // Enemy와 Player 사이에 지형(장애물)이 있다면 공격(원거리)할 필요가 없다. 막혀있는 지형이 있는지 검사하는 코드
                RaycastHit2D hit = Physics2D.Raycast(transform.position, direction, 11f, (1 << LayerMask.NameToLayer("Level")) | layerMaskTarget);
                
                if(hit.collider != null && layerMaskTarget == (layerMaskTarget | (1 << hit.collider.gameObject.layer)))
                {
                    CalllLookEvent(direction);
                    CallMoveEvent(Vector2.zero);
                    IsAttacking = true;
                }
                else
                {
                    CallMoveEvent(direction);
                }
            }
            else
            {
                CallMoveEvent(direction);
            }
        }
        else
        {
            CallMoveEvent(direction);
        }
    }
}

Orc_Shaman

Ranged AttackData 생성 ➔ Orc_Shaman_RangedAttackData 이름 변경

빈 오브젝트 생성 - Orc_Shaman 이름 변경
하위에 빈 오브젝트 생성 - mainSprite 이름 변경 ➔ Sprite Renderer 추가 ➔ orc_shaman_idle_anim_f0 설정, Order in Layer 4

다음과 같이 WeaponPivot 및 하위 오브젝트를 생성

Orc_Shaman 오브젝트에 필요 컴포넌트 추가

Animaton Clip

Goblin과 동일하게 설정

수정

Animation Controller

Goblin과 동일하게 설정

📌 넉백 구현

넉백을 걸어주면, 시간과 힘을 주고 그 값을 저장해 놨다가 넉백을 해야할 때, 자동적으로 넉백이 진행되고, duration이 줄어들어 0이되면 더이상 넉백에 대해서는 처리를 하지 않는다.

수정

TopDownMovement

--------------------- 생략 ---------------------
private Vector2 _knockback = Vector2.zero;
private float knockbackDuration = 0.0f;

private void FixedUpdate()
{
    ApplyMovment(_movementDirection);
    if(knockbackDuration > 0.0f)	// 추가
    {
        knockbackDuration -= Time.fixedDeltaTime;	// 추가
    }
}
--------------------- 생략 ---------------------
public void ApplyKnockback(Transform other, float power, float duration)	// 추가
{
    knockbackDuration = duration;	// 추가
    _knockback = -(other.position - transform.position).normalized * power;	// 추가
}

 // 넉백을 걸어주면, 시간과 힘을 주고 그 값을 저장해 놨다가 넉백을 해야할 때, 자동적으로 넉백이 진행되고
 // duration이 줄어들어 0이되면 더이상 넉백에 대해서는 처리를 하지 않는다.
private void ApplyMovment(Vector2 direction)
{
    direction = direction * _stats.CurrentStates.speed;

    if(knockbackDuration > 0.0f)	// 추가
    {
        direction += _knockback;	// 추가
    }
    _rigidbody.velocity = direction;
}

📌 데미지 피격 구현

➔ Health System 만들기

Health System 만들기

public class HealthSystem : MonoBehaviour
{
    [SerializeField] private float healthChangeDelay = .5f;

    private CharacterStatsHandler _statsHandler;
    private float _timeSinceLastChange = float.MaxValue;

    public event Action OnDamage;
    public event Action OnHeal;
    public event Action OnDeath;
    public event Action OnInvincibilityEnd;

    public float CurrentHealth { get; private set; }

    public float MaxHealth => _statsHandler.CurrentStates.maxHealth;

    private void Awake()
    {
        _statsHandler = GetComponent<CharacterStatsHandler>();
    }

    private void Start()
    {
        CurrentHealth = _statsHandler.CurrentStates.maxHealth;
    }

    private void Update()
    {
        if (_timeSinceLastChange < healthChangeDelay)   // 딜레이 체크
        {
            _timeSinceLastChange += Time.deltaTime;
            if (_timeSinceLastChange >= healthChangeDelay )
            {
                OnInvincibilityEnd?.Invoke();	// 무적시간 끝
            }
        }
    }

    // 체력 회복 or 감소 메소드
    public bool ChangeHealth(float change)
    {
        if (change == 0 || _timeSinceLastChange < healthChangeDelay)
        {
            return false;
        }

        _timeSinceLastChange = 0f;
        CurrentHealth += change;
        CurrentHealth = CurrentHealth > MaxHealth ? MaxHealth : CurrentHealth;  // 최대 체력을 넘지 못하는 처리

        if ( change > 0)    // change값이 양수? 체력 회복
        {
            OnHeal?.Invoke();
        }
        else    // change값이 음수? 체력 감소
        {
            OnDamage?.Invoke();
        }

        if (CurrentHealth <= 0f)
        {
            CallDeath();
        }

        return true;
    }

    private void CallDeath()
    {
        OnDeath?.Invoke();
    }
}

시스템 적용하기

Player - HealthSystem 추가
Goblin, OrcShaman Prefab - HealthSystem 추가

TopDownAnimationController 수정

--------------------- 생략--------------------- 
private HealthSystem _healthSystem;

protected override void Awake()
{
    base.Awake();
    _healthSystem = GetComponent<HealthSystem>();	// 추가
}

--------------------- 생략--------------------- 

void Start()
{
    controller.OnAttackEvent += Attacking;
    controller.OnMoveEvent += Move;

    if(_healthSystem != null) // 추가
    {
        _healthSystem.OnDamage += Hit; // 추가
        _healthSystem.OnInvincibilityEnd += InvincibilityEnd; // 추가
    }
}

RangedAttackController 수정

    private void OnTriggerEnter2D(Collider2D collision)
    {
        // 비트연산 1 << collision.gameObject.layer : collision.gameObject.layer 를 왼쪽으로 하나 밀고
        // levelCollisionLayer.value와 | 연산 하나라도 1이면 1
        if (levelCollisionLayer.value == (levelCollisionLayer.value | (1 << collision.gameObject.layer)))
        {
            // ClosestPoint : 가장 가까운 position , _direction * .2f : 벽에 부딪힌 데서 조금 안쪽으로 오게 하는 연산
            DestoryProjectile(collision.ClosestPoint(transform.position) - _direction * .2f, fxOnDestory);
        }
        // 밑에 다 추가
        else if (_attackData.target.value == (_attackData.target.value | (1 << collision.gameObject.layer)))
        {
            HealthSystem healthSystem = collision.GetComponent<HealthSystem>();
            if (healthSystem != null)
            {
                healthSystem.ChangeHealth(-_attackData.power);
                if (_attackData.isOnKnockback)
                {
                    TopDownMovement movement = collision.GetComponent<TopDownMovement>();
                    if (movement != null)
                    {
                        movement.ApplyKnockback(transform, _attackData.knockbackPower, _attackData.knockbackTime);
                    }
                }
            }
            DestoryProjectile(collision.ClosestPoint(transform.position), fxOnDestory);
        }
    }

적 Layer 설정하기

Goblin Prefab - Layer ➔ Enemy

OrcShaman도 동일하게 적용

AttackData 수정하기

Player_RangedAttackData ➔ Target ➔ Enemy
Goblin_DefaultAttackData, Orc_Shaman_RangedAttackData ➔ Target ➔ Player

TopDownContactEnemyController 수정

private HealthSystem healthSystem;
private HealthSystem _collidingTargetHealthSystem;
private TopDownMovement _collidingMovement;

protected override void Start()
{
    base.Start();
    
    healthSystem  = GetComponent<HealthSystem>();
    healthSystem.OnDamage += OnDamage;
}

// "자신"이 데미지를 받았을 때, 처리할 함수
// 이렇게 만들어두지 않으면 공격을 받아도 따라가질 않고 가만히 서있는다.
// 그래서 "자신"이 데미지를 받았을 때, followRange를 크게 늘려주어서 따라오게 만드는 것.
private void OnDamage()
{
    followRange = 100f;
}

protected override void FixedUpdate()
{
    base.FixedUpdate();

    if(_isCollidingWithTarget)
    {
        ApplyHealthChange();
    }

-------------------------- 생략 -------------------------- 

private void OnTriggerEnter2D(Collider2D collision)
{
    GameObject receiver = collision.gameObject;

    if(!receiver.CompareTag(targetTag))
    {
        return;
    }

    _collidingTargetHealthSystem = receiver.GetComponent<HealthSystem>();
    if( _collidingTargetHealthSystem != null )
    {
        _isCollidingWithTarget = true;
    }

    _collidingMovement = receiver.GetComponent<TopDownMovement>();
}

private void OnTriggerExit2D(Collider2D collision)
{
    if (!collision.CompareTag(targetTag))
    {
        return;
    }

    _isCollidingWithTarget = false;
}

private void ApplyHealthChange()
{
    AttackSO attackSO = Stats.CurrentStats.attackSO;
    bool hasBeenChanged = _collidingTargetHealthSystem.ChangeHealth(-attackSO.power);
    if(attackSO.isOnKnockback && _collidingMovement != null )
    {
        _collidingMovement.ApplyKnockback(transform, attackSO.knockbackPower, attackSO.knockbackTime);
    }
}

Goblin 오브젝트 수정

Circle Collider 2D 추가
isTrigger 체크

➔ 적 죽이기

DisappearOnDeath 만들기

public class DisappearOnDeath : MonoBehaviour
{
    private HealthSystem _healthSystem;
    private Rigidbody2D _rigidbody;

    private void Start()
    {
        _healthSystem = GetComponent<HealthSystem>();
        _rigidbody = GetComponent<Rigidbody2D>();
        _healthSystem.OnDeath += OnDeath;
    }

    void OnDeath()
    {
        // 죽었을 때, 움직이면 이상하다. 그래서 못 움직이게 고정.
        _rigidbody.velocity = Vector3.zero;

        // "나"를 포함해서 그 하위에 있는 모든 SpriteRenderer를 찾아와서 컬러를 조정 ( 투명하게 조정 )( 연출 )
        foreach (SpriteRenderer renderer in transform.GetComponentsInChildren<SpriteRenderer>())
        {
            Color color = renderer.color;
            color.a = 0.3f;
            renderer.color = color;
        }

        // Behaviour : MonoBehaviour 위에 있는(부모) 클래스 (컨트롤 클릭으로 타고 들어가서 확인 가능)
        // Behaviour이 Component의 키고 끄는 기능을 관리하기에 동작하는 모든 컴포넌트를 꺼준다. (죽었으니까)
        // Behaviour : Component , Behaviour이 Component를 상속받음
        foreach (Behaviour component in transform.GetComponentsInChildren<Behaviour>())
        {
            component.enabled = false;
        }

        Destroy(gameObject, 2f);
    }
}

추가하기

Goblin, Orc_Shaman ➔ DisappearOnDeath.cs 추가

📌 파티클 생성

➔ 🔥 핵심 내용

파티클 시스템(Particle System)

파티클 시스템은 수 천개의 작은 2D 또는 3D 오브젝트들을 관리하고, 그들의 동작과 생애를 제어한다. 각각의 작은 오브젝트를 '파티클'이라고 부른다.
파티클 시스템의 주요 컴포넌트는 'emitter'(발사체), 'particles'(파티클), 'animator'(애니메이터), 'renderer'(렌더러)등으로 이루어져 있다.
Unity의 파티클 시스템은 시간에 따른 파티클의 행동을 시뮬레이션하며, 이를 위해 각 파티클에 대한 위치, 속도, 수명, 색상, 크기 등의 정보를 저장한다.
파티클 시스템은 성능 최적화를 위해 다양한 기능을 제공한다. 예를 들어, 시스템의 최대 파티클 수를 제한하거나, 파티클의 적용범위를 제한하는 등의 기능이 있다.

애니메이션 이벤트(Animation Events)

애니메이션 이벤트를 사용하면 애니메이션이 진행되는 동안 코드를 실행시킬 수 있다. 예를 들어, 캐릭터가 특정 동작을 할 때 사운드를 재생하거나, 특정 애니메이션 프레임에서 파티클 시스템을 발사하는 등의 작업을 할 수 있다.
애니메이션 이벤트는 Unity 애니메이션 편집기에서 설정할 수 있다. 편집기를 통해 애니메이션 타임라인에 이벤트를 추가하고, 해당 이벤트가 호출할 함수를 지정할 수 있다.
애니메이션 이벤트는 해당 애니메이션 클립이 재생되는 게임 오브젝트에 연결된 모든 스크립트에서 호출할 수 있는 함수를 실행할 수 있다.
이벤트는 특정 프레임에서만 실행되며, 애니메이션 상태가 변경될 때에도 자동으로 실행되지 않는다.
애니메이션 이벤트를 사용하면 애니메이션과 코드의 상호작용을 더욱 유연하게 관리할 수 있다. 이를 통해 애니메이션의 시각적 효과와 사운드 효과 등의 프로그래밍적 요소를 조화롭게 통합할 수 있다.
애니메이션 이벤트를 통해 호출되는 함수는 일반적으로 공용 함수(public function)이어야 하며, 매개변수가 없거나 최대 하나의 매개변수를 가질 수 있다.

➔ 걸음 효과 만들기

DustParticles 추가

Player 우클릭 ➔ Particle System 추가, DustParticles 이름 변경

최하단 Renderer - Order in Layer 4
다음과 같이 변경

DustParticleControl 만들기

public class DustParticleControl : MonoBehaviour
{
    [SerializeField] private bool createDustOnWalk = true;
    [SerializeField] private ParticleSystem dustParticleSystem;

    public void CreateDustParticles()
    {
        if (createDustOnWalk)
        {
            // bool값이 들어오면 파티클을 멈추고 다시 시작하게 한다.
            dustParticleSystem.Stop();
            dustParticleSystem.Play();
        }
    }
}

적용하기

Player - MainSprite ➔ DustParticleControl 추가
Ctrl + 6 또는 Window - Animation - Animation 클릭
player_run 1, 3 프레임 애니메이션 이벤트 추가

➔ 투사체 소멸 효과 만들기

ImpactParticleSystem 추가하기

ProjectileManager우클릭 ➔ Particle System 추가, ImpactParticleSystem 이름 변경

최하단 Renderer - Order in Layer 4
다음과 같이 변경

적용하기

Projectile Manager - Impact Particle System ➔ Impact Particle System 추가

ProjectileManager 수정 ( 추가 )

    public void CreateImpactParticlesAtPosition(Vector3 position, RangedAttackData attackData)
    {
        _impactParticleSystem.transform.position = position;    // 파티클 시스템을 해당 위치로 보낸다.
        ParticleSystem.EmissionModule em = _impactParticleSystem.emission;  // EmissionModule을 가져온다 EmissionModule ?: 생성하는 느낌
        em.SetBurst(0, new ParticleSystem.Burst(0, Mathf.Ceil(attackData.size * 5)));   // 사이즈별로 크기를 다르게, 충격파가 커지게
        ParticleSystem.MainModule mainModule = _impactParticleSystem.main;  // main파티클 시스템을 가져온다.
        mainModule.startSpeedMultiplier = attackData.size * 10f;    // 처음에 속도를 곱해주는 값을 만들어준다. ( 실제 사이즈에 비례하게 커지게 만들어준다. )
        _impactParticleSystem.Play();
        // 우리가 만든걸 그 위치로 가져가서 상대가 가지고있는 EmissionModule이랑 MainModule을 가지고서
        // 한번 Play를 던지는 것이다. 그러고 또 다른곳에 가서 또 던지고
    }

RangedAttackController 수정 ( 추가 )

    void DestoryProjectile(Vector3 position, bool createFx)
    {
        if(createFx)
        {
            _projectileManager.CreateImpactParticlesAtPosition(position, _attackData);
        }
        gameObject.SetActive(false);
    }

📌 사운드 컨트롤

➔ 🔥 핵심 내용

사운드를 처리하는 주요 컴포넌트

AudioClip :

AudioClip은 사운드 파일을 유니티에서 사용할 수 있도록 하는 데이터 타입이다.
.wav, .mp3, .ogg 등 다양한 형식의 오디오 파일을 지원한다.

AudioSource :

AudioSource 컴포넌트는 사운드를 재생하는 데 사용된다.
AudioSource에 AudioClip을 연결하여 재생할 수 있다.
AudioSource는 3D사운드 설정, 볼륨 조절, 사운드 반복 재생 들의 설정을 제공한다.

AudioListener :

AudioListener 컴포넌트는 사운드를 듣는 포인트를 나타낸다.
일반적으로 주요 카메라에 AudioListener가 위치한다.
게임에는 하나의 AudioListener만 있어야 한다.

➔ 사운드 매니저 만들기

SoundManager 만들기

public class SoundManager : MonoBehaviour
{
    public static SoundManager instance;

    [SerializeField][Range(0f, 1f)] private float soundEffectVolume;
    [SerializeField][Range(0f, 1f)] private float soundEffectPitchVariance;
    [SerializeField][Range(0f, 1f)] private float musicVolume;
    private ObjectPool objectPool;

    // AudioSource : 실제로 사운드를 출력할 얘
    // Scene 어딘가에 AudioListener가 소리를 들어주는 역할 보통 Camera(카메라)에 달려있다.
    // 이 게임은 2D이기 때문에 따로 3D 사운드를 설정하지 않는다. 그래서 어디있든 소리가 들린다.
    // 3D 게임에서는 거리에 따라서 오디오의 차이가 있기 때문에, 그런 처리들도 이루어질 수 있다.
    private AudioSource musicAudioSource;
    public AudioClip musicClip; // AudioClip : 실제 음원

    private void Awake()
    {
        instance = this;
        musicAudioSource = GetComponent<AudioSource>();
        musicAudioSource.volume = musicVolume;
        musicAudioSource.loop = true;

        objectPool = GetComponent<ObjectPool>();
    }

    private void Start()
    {
        ChangeBackGroundMusic(musicClip);
    }

    // static 메서드들은 static변수들만 사용할 수 있다. (정적인 애들끼리만 사용 가능)
    // 그렇기에 정적인 변수 instance를 통해서만 그 객체의 값을 가져오고 사용할 수 있다.
    public static void ChangeBackGroundMusic(AudioClip music)
    {
        instance.musicAudioSource.Stop();
        instance.musicAudioSource.clip = music;
        instance.musicAudioSource.Play();
    }

    public static void PlayClip(AudioClip clip)
    {
        GameObject obj = instance.objectPool.SpawnFromPool("SoundSource");
        obj.SetActive(true);
        SoundSource soundSource = obj.GetComponent<SoundSource>();
        soundSource.Play(clip, instance.soundEffectVolume, instance.soundEffectPitchVariance);
    }
}

SoundSource 만들기

// Sound Clip을 컨트롤 하기 위한 클래스
public class SoundSource : MonoBehaviour
{
    private AudioSource _audioSource;

    public void Play(AudioClip clip, float soundEffectVolume, float soundEffectPitchVariance)
    {
        if (_audioSource == null)
            _audioSource = GetComponent<AudioSource>();

        CancelInvoke(); // 이전의 Invoke가 남아있는 상태여서 사운드를 실행해야 하는데 꺼져버리는걸 대비 Invoke캔슬 ( 취소 )
        // 다시 등록
        _audioSource.clip = clip;
        _audioSource.volume = soundEffectVolume;
        _audioSource.Play();
        _audioSource.pitch = 1f + Random.Range(-soundEffectPitchVariance, soundEffectPitchVariance);

        Invoke("Disable", clip.length + 2); // clip.length + 2 시간 이후에 Disable(); 실행
    }

    // 끄는 작업 메서드
    public void Disable()
    {
        _audioSource.Stop();
        gameObject.SetActive(false);    // 재사용 대비 활성화 / 비활성화
    }
}

SoundManager 오브젝트 만들기

GameManager 하위에 SoundManager 빈 오브젝트 생성
SoundManager 스크립트 추가

ObjectPool 스크립트 추가

SoundSource 오브젝트 만들기

빈 오브젝트 생성 ➔ SoundSource 이름 변경
AudioSource 컴포넌트 추가
SoundSource 스크립트 추가
프리팹으로 만들기

ObjectPool 설정

SoundManager와 같이 있는 ObjectPool 다음과 같이 설정

➔ 소리 재생하기

TopDownShooting 수정 (추가)

public AudioClip shootingClip;

----------------- 생략 ----------------- 
    private void CreatProjectile(RangedAttackData rangedAttackData, float angle)
    {
        // ( 발사 위치, 회전각, 공격정보 ) 를 넘겨준다.
        _projectileManager.ShootBullet(projectileSpawnPosition.position, RotateVector2(_aimDirection, angle), rangedAttackData);
        
        if (shootingClip)
            SoundManager.PlayClip(shootingClip);
    }

HealthSystem 수정 (추가)

public AudioClip damageClip;
----------------- 생략 ----------------- 
public bool ChangeHealth(float change)
{
----------------- 생략 ----------------- 
    if ( change > 0)    // change값이 양수? 체력 회복
    {
        OnHeal?.Invoke();
    }
   else    // change값이 음수? 체력 감소
   {
         OnDamage?.Invoke();

         if (damageClip)
            SoundManager.PlayClip(damageClip);
    }
----------------- 생략 ----------------- 
}

Player의 컴포넌트 수정

TopDownShooting - DM-CGS-20 추가
HealthSystem - DM-CGS-44 추가

📌 UI 만들기

➔ 🔥 핵심 내용

UGUI (Unity's User Interface)

Unity의 기본 UI시스템으로 게임 내의 사용자 인터페이스를 구축하는 데 사용된다.

Canvas :

UGUI에서 모든 UI요소는 Canvas라는 컴포넌트 내에 배치된다.
Canvas는 스크린 공간, 월드 공간, 카메라 공간의 3가지 렌더 모드를 지원한다.

Rect Transform :

Unity의 기본 Transform 대신 UI요소에는 Rect Transform이 사용된다.
위치, 크기, 회전, 스케일을 지정하는데 사용되며, 앵커 및 피벗을 사용하여 부모와의 상대적인 위치를 지정한다.

UI Components :

UGUI는 다양한 UI요소들을 제공한다. : 버튼, 이미지, 텍스트, 슬라이더, 스크롤 바 등

Event System

UGUI의 이벤트 시스템은 UI상호작용을 관리한다.
마우스 클릭, 드래그, 키보드 입력 등 다양한 입력 이벤트를 처리한다.

TextMeshPro

TextMeshPro는 원래 독립적인 개발자에 의해 Unity 에셋 스토어에서 판매되었다. 그러나 이후 Unity Technologies에 인수되어 Unity의 기본 기능으로 포함되었다. 이러한 변화는 2017년에 발생했으며, 그 리후로 TextMeshPro는 Unity 사용자들에게 무료로 제공되고 있다.
TextMeshPro는 Unity에서 제공하는 고급 텍스트 렌더링 시스템이다. 기본 텍스트 구성 요소보다 훨씬 더 많은 기능과 정확성을 제공한다.

➔ 배경색 바꾸기

Background Color 변경

Main Camera - Background - 색 바꾸기 ( 아무 색이나 상관없다. )

➔ UI 만들기

만들기

Canvas

Creat ➔ UI ➔ Canvas

Canvas ➔ Canvas Scaler 다음과 같이 수정

Wave

Wave 빈 오브젝트 만들기 ➔ 다음과 같이 수정

하위에 UI - Image 추가
Alt 누른 상태로 Stretch 클릭

Image의 Color Alpha 값 감소

TextMeshPro 2개 추가 후 다음과 같이 설정

HPBar

Wave 빈 오브젝트 만들기 ➔ 다음과 같이 수정

하위에 UI - Slider 추가
Handle Slide Area 삭제
Background Color ➔ Wave Image 같은 Color
Fill Area - Fill Color 붉은 계열로 변경
Wave 참고 하여 다음과 같이 수정

GameOver

GameOver 빈 오브젝트 만들기 ➔ 전체 크기로 늘리기

Image, Text, Button * 2 추가
Image 전체 사이즈로 늘리기, 알파값 줄이기

Text ➔ GameOver Text 설정 ➔ 크기와 위치를 화면을 보고 맞추기

Button - Color 각각 설정

다음의 화면과 유사하게 배치

➔ 스크립트 적용하기

GameManager 수정

GameManager가 아닌 UIManager를 따로 활용하여 관리하는 것이 나중을 생각하면 더 좋을듯 하다.

public class GameManager : MonoBehaviour
{
    public static GameManager instance;

    public Transform Player { get; private set; }
    [SerializeField] private string playerTag = "Player";
    private HealthSystem playerhealthSystem;

    [SerializeField] private TextMeshProUGUI waveText;
    [SerializeField] private Slider hpGaugeSlider;
    [SerializeField] private GameObject gameOverUI;

    private void Awake()
    {
        instance = this;
        Player = GameObject.FindGameObjectWithTag(playerTag).transform;
        
        playerhealthSystem = Player.GetComponent<HealthSystem>();
        playerhealthSystem.OnDamage += UpdateHealthUI;
        playerhealthSystem.OnHeal += UpdateHealthUI;
        playerhealthSystem.OnDeath += GameOver;

        gameOverUI.SetActive(false);
    }

    private void UpdateHealthUI()
    {
        hpGaugeSlider.value = playerhealthSystem.CurrentHealth / playerhealthSystem.MaxHealth;
    }

    private void GameOver()
    {
        gameOverUI.SetActive(true);
    }

    private void UpdateWaveUI()
    {
        // waveText.text =
    }

    public void RestartGame()
    {
        // GetActiveScene().buildIndex : 지금 켜져있는 Scene의 번호를 가져와서 다시 Load를 시켜라.
        SceneManager.LoadScene(SceneManager.GetActiveScene().buildIndex);   
    }

    public void ExitGame()
    {
        Application.Quit();
    }
}

Button - OnClick (Unity Event) 설정

GameManager을 설정
메서드를 선택

GameManager 컴포넌트 설정

다음과 같이 설정

📌 로직 구현하기

➔ 🔥 핵심 내용

코루틴(Coroutin)

코루틴은 비동기적으로 실행되는 함수로, 특정 코드 블럭의 실행을 일시적으로 중지하고 다시 시작할 수 있게 해준다.
IEnumerator 리턴 타입의 함수에서 yield return을 사용하여 코루틴을 구현할 수 있다.
StartCoroutine함수를 통해 코루틴을 시작할 수 있고, StopCoroutine함수를 통해 코루틴을 중지할 수 있다.
코루틴은 프레임 간의 지연, 비동기 작업, 시간에 따른 애니메이션 등의 작업에 주로 사용된다.
yield return null은 다음 프레임까지 대기를 의미하고, yield return new WaitForSeconds(n)은 n초 동안 대기를 의미한다.
코루틴은 별도의 스레드에서 실행되지 않는다. 따라서 Unity의 메인 스레드에서 안전하게 Unity API를 호출할 수 있다.
코루틴은 일반 함수와는 다르게 실행을 일시 중단하고 나중에 다시 시작할 수 있어, 시간 지연, 반복, 조건부 대기 등의 작업을 수행할 때 매우 유용하다.

➔ 게임 로직 추가하기

로직 추가

GameManager

----------------------- 생략 ----------------------- 
    [SerializeField] private int currentWaveIndex = 0;
    private int currentSpawnCount = 0;
    private int waveSpawnCount = 0;
    private int waveSpawnPosCount = 0;

    public float spawnInterval = .5f;
    public List<GameObject> enemyPrefabs = new List<GameObject>();  // 딕셔너리로 다양하게 그룹을 만들어서 오크만 나올때는 오크 고블린이 나올땐 고블린 그렇게도 가능

    [SerializeField] private Transform spawnPositionsRoot;
    private List<Transform> spawnPositions = new List<Transform>();
----------------------- 생략 ----------------------- 
    private void Awake()
    {
        instance = this;
        Player = GameObject.FindGameObjectWithTag(playerTag).transform;
        
        playerhealthSystem = Player.GetComponent<HealthSystem>();
        playerhealthSystem.OnDamage += UpdateHealthUI;
        playerhealthSystem.OnHeal += UpdateHealthUI;
        playerhealthSystem.OnDeath += GameOver;

        gameOverUI.SetActive(false);

        // spawnPosition의 위치들을 다 가져와서 저장시킨다.
        for (int i = 0; i < spawnPositionsRoot.childCount; i++)
        {
            spawnPositions.Add(spawnPositionsRoot.GetChild(i)); // GetChild 가 transform을 반환하기 때문에, .tranform은 안해도 된다. 
        }
    }
----------------------- 생략 ----------------------- 
    private void Start()
    {
        StartCoroutine("StartNextWave");
    }

    // 코루틴 : IEnumerator return타입을 가져서 비동기적으로 실행할 수 있게 해준다.
    // 코드를 일정부분에서 일시정지 하거나 멈추거나 다시 시작하게 하는 코드를 구성할 수 있게 해준다.
    // Thread에서 동작하는 것은 아니고 Unity Main Thread안에서 동작하는 구분점을 가지고서 코드를 동작하게 한다.
    // 일반적인 'return'보다는  'yield return'이라는 것을 쓴다. 
    // 'yield return'으로 이 코드의 실행을 반환해 놨다가 다시 그 부분에 돌아온다.
    // 'yield return'을 만나면 실행에 대한 순서를 반환했다가 다시 돌아와서 동작한다.
    IEnumerator StartNextWave()
    {
        while(true)
        {
            if (currentSpawnCount == 0) // currentSpawnCount : 소환되어 있는 몹의 갯수 (0 ? 처음 or 다 잡음)
            {
                UpdateWaveUI(); // Wave 최신화
                yield return new WaitForSeconds(2f);    // new WaitForSeconds 도 변수로 캐싱해서 사용하는 것이 좋다.
            
                if (currentWaveIndex % 10 == 0) // currentWaveIndex 가 10의 배수다? ( 10 단위로 난이도 증가 )
                {
                    // 생성하는 포지션 증가
                    waveSpawnPosCount = waveSpawnPosCount + 1 > spawnPositions.Count ? waveSpawnPosCount : waveSpawnPosCount + 1;
                }

                if (currentWaveIndex % 5 == 0)
                {

                }

                if (currentWaveIndex % 3 == 0)
                {
                    waveSpawnCount += 1;    // 한번에 만들어지는 몬스터 증가
                }

                // 몇 군데에 얼마씩 생성?
                for(int i = 0; i  < waveSpawnPosCount; i++) // 위치 갯수
                {
                    int posIdx = Random.Range(0, spawnPositions.Count); // 랜덤 위치에
                    for(int j = 0; j < waveSpawnCount; j++) // 만드는 갯수
                    {
                        int prefabIdx = Random.Range(0, enemyPrefabs.Count); // 랜덤 몬스터
                        GameObject enemy = Instantiate(enemyPrefabs[prefabIdx], spawnPositions[posIdx].position, Quaternion.identity);
                        enemy.GetComponent<HealthSystem>().OnDeath += OnEnemyDeath;
                        // enemy.GetComponent<CharacterStatsHandler>
                        currentSpawnCount++;
                        yield return new WaitForSeconds(spawnInterval);
                    }
                }

                currentWaveIndex++;
            }
            yield return null;
        }
    }

    private void OnEnemyDeath()
    {
        currentSpawnCount--;
    }

    private void UpdateHealthUI()
    {
        hpGaugeSlider.value = playerhealthSystem.CurrentHealth / playerhealthSystem.MaxHealth;
    }

    private void GameOver()
    {
        gameOverUI.SetActive(true);
        StopAllCoroutines();    // Coroutin이라는 것 자체가 오브젝트에 귀속되는 것이기 때문에 이 오브젝트에서 돌고있는 코루틴을 다 멈춰라.
    }

    private void UpdateWaveUI()
    {
        waveText.text = (currentWaveIndex + 1).ToString();  // 0부터 시작하기에 + 1
    }

SpawnPositions 추가

Level 하위 빈 오브젝트 생성 ➔ SpawnPositions 이름 변경
하위 빈 오브젝트 생성
인스펙터에서 기즈모 설정

몬스터가 생성되고 싶은 위치만큼 추가

GameManager 컴포넌트 수정

Enemy Prefabs 추가. Spawn Position Root 추가

📌 스텟 계산하기 (복잡함)

➔ 🔥 핵심 내용

switch문 & 패턴 매칭

Switch문 : 프로그래밍에서 조건에 따라 다른 동작을 수행하도록 하는 제어 구조. 다양한 경우의 수를 가진 조건을 처리할 때 효율적.
패턴 매칭 : C# 7.0부터 추가된 기능으로, 일치하는 패턴에 따라 코드를 실행. switch문을 이용하여 객체의 타입이나 값에 따라 처리를 다르게 할 수 있다.
패턴 매칭 in switch문 : 코드의 가독성을 높이고 유지 보수를 쉽게 하는데 도움을 준다. 객체의 타입을 확인하거나 특정 조건을 충족하는지 여부를 확인하면서 동시에 변수에 값을 할당 할 수 있다.

예제 :

	- **`case RangedAttackData _:`** **`CurrentStats.attackSO`**가 **`RangedAttackData`**타입일 경우에 실행.

case MeleeAttackConfig _: CurrentStats.attackSO가 MeleeAttackConfig타입일 경우에 실행

이런 방식을 이용하면, 여러 타입의 객체를 적절하게 처리할 수 있어 확장성과 유연성이 향상된다.

➔ 추가 스텟을 위한 계산 공식

CharacterStatsHandler 수정

public class CharacterStatsHandler : MonoBehaviour
{
    private const float MinAttackDelay = 0.03f;
    private const float MinAttackPower = 0.5f;
    private const float MinAttackSize = 0.4f;
    private const float MinAttackSpeed = 0.1f;

    private const float MinSpeed = 0.8f;

    private const int MinMaxHealth = 5;

    [SerializeField] private CharacterStats baseStats;
    public CharacterStats CurrentStats { get; private set; }
    public List<CharacterStats> statsModifiers = new List<CharacterStats>();

    private void Awake()
    {
        UpdateCharacterStats();
    }

    #region Stats Add || Remove
    // AddStatModifier();, RemoveStatModifier() : 새로운 캐릭터 스탯을 추가하거나 뺄수있게
    // 예) 아이템을 장착했다 ? 아이템에 대한 스탯이 포함이 되고 원래 스탯에다 이 스탯을 추가한다.
    public void AddStatModifier(CharacterStats statModifier)
    {
        statsModifiers.Add(statModifier);
        UpdateCharacterStats();
    }

    public void RemoveStatModifier(CharacterStats statModifier)
    {
        statsModifiers.Remove(statModifier);
        UpdateCharacterStats();
    }
    #endregion

    #region UpdateStats
    private void UpdateCharacterStats()
    {
        AttackSO attackSO = null;
        if (baseStats.attackSO != null)
        {
            attackSO = Instantiate(baseStats.attackSO);
        }

        CurrentStats = new CharacterStats { attackSO = attackSO };  // CurrentStats 생성, baseStats을 (CurrentStats에다가)넘겨 받는다.
        UpdateStats((a, b) => b, baseStats);    // ( (a, b) => b  : a, b를 받아서 b를 쓰겠다. ) , (baseStats(CurrnetStats)을 가져가서 UpdateStats에 쓰겠다.)
        if (CurrentStats.attackSO != null)  // attackSO가 있는지 체크
        {
            CurrentStats.attackSO.target = baseStats.attackSO.target;   // 타겟 설정
        }

        foreach (CharacterStats modifier in statsModifiers.OrderBy(o => o.statsChangeType)) // statsChangeType에 맞춰서 OrderBy(오름차순)정렬
        {
            if (modifier.statsChangeType == StatsChangeType.Override)   // 덮어씌우기
            {
                UpdateStats((o, o1) => o1, modifier);
            }
            else if (modifier.statsChangeType == StatsChangeType.Add)   // 더하기
            {
                UpdateStats((o, o1) => o + o1, modifier);
            }
            else if (modifier.statsChangeType == StatsChangeType.Multiple)  // 곱하기
            {
                UpdateStats((o, o1) => o * o1, modifier);
            }
        }

        LimitAllStats();    // 최소 스탯 리밋 체크
    }

    // Func : 매개변수 앞에 2개를 받아서 반환(3번째) 밑의 경우 float을 2개 받아서 float을 반환
    private void UpdateStats(Func<float, float, float> operation, CharacterStats newModifier)
    {
        CurrentStats.maxHealth = (int)operation(CurrentStats.maxHealth, newModifier.maxHealth);
        CurrentStats.speed = operation(CurrentStats.speed, newModifier.speed);

        UpdateAttackStats(operation, CurrentStats.attackSO, newModifier.attackSO);

        // 내가가진 타입(CurrentStats)과 넘겨받은 타입(newModifier)이 다르면 처리하지 않는다.
        // 예) Ranged Type인데 다른 타입이 들어오면 ? 처리 x
        if (CurrentStats.attackSO.GetType() != newModifier.attackSO.GetType())
        {
            return;
        }

        // 새로운 타입의 처리
        switch (CurrentStats.attackSO)
        {
            case RangedAttackData _:
                ApplyRangedStats(operation, newModifier);
                break;
        }
    }

    // AttackStats
    private void UpdateAttackStats(Func<float, float, float> operation, AttackSO currentAttack, AttackSO newAttack)
    {
        if (currentAttack == null || newAttack == null || currentAttack.GetType() != newAttack.GetType())
        {
            return;
        }

        currentAttack.delay = operation(currentAttack.delay, newAttack.delay);
        currentAttack.power = operation(currentAttack.power, newAttack.power);
        currentAttack.size = operation(currentAttack.size, newAttack.size);
        currentAttack.speed = operation(currentAttack.speed, newAttack.speed);
    }

    // RangedStats
    private void ApplyRangedStats(Func<float, float, float> operation, CharacterStats newModifier)
    {
        RangedAttackData currentRangedAttacks = (RangedAttackData)CurrentStats.attackSO;

        if (!(newModifier.attackSO is RangedAttackData))
        {
            return;
        }

        RangedAttackData rangedAttackModifier = (RangedAttackData)newModifier.attackSO;
        currentRangedAttacks.multipleProjectilesAngel = operation(currentRangedAttacks.multipleProjectilesAngel, rangedAttackModifier.multipleProjectilesAngel);
        currentRangedAttacks.spread = operation(currentRangedAttacks.spread, rangedAttackModifier.spread);
        currentRangedAttacks.duration = operation(currentRangedAttacks.duration, rangedAttackModifier.duration);
        currentRangedAttacks.numberofProjectilesPerShot = Mathf.CeilToInt(operation(currentRangedAttacks.numberofProjectilesPerShot, rangedAttackModifier.numberofProjectilesPerShot));
        currentRangedAttacks.projectileColor = UpdateColor(operation, currentRangedAttacks.projectileColor, rangedAttackModifier.projectileColor);
    }

    // Color(Ranged)
    private Color UpdateColor(Func<float, float, float> operation, Color currentColor, Color newColor)
    {
        return new Color(operation(currentColor.r, newColor.r),
                         operation(currentColor.g, newColor.g),
                         operation(currentColor.b, newColor.b),
                         operation(currentColor.a, newColor.a));
    }
    #endregion

    #region LimitStats
    private void LimitStats(ref float stat, float minVal)
    {
        stat = Mathf.Max(stat, minVal);
    }

    private void LimitAllStats()
    {
        if (CurrentStats == null || CurrentStats.attackSO == null)
        {
            return;
        }

        LimitStats(ref CurrentStats.attackSO.delay, MinAttackDelay);
        LimitStats(ref CurrentStats.attackSO.power, MinAttackPower);
        LimitStats(ref CurrentStats.attackSO.size, MinAttackSize);
        LimitStats(ref CurrentStats.attackSO.speed, MinAttackSpeed);
        LimitStats(ref CurrentStats.speed, MinSpeed);
        CurrentStats.maxHealth = Mathf.Max(CurrentStats.maxHealth, MinMaxHealth);
    }
    #endregion
}

📌 아이템

➔ 아이템 추가하기

PickupItem 만들기

public abstract class PickupItem : MonoBehaviour
{
    [SerializeField] private bool destroyOnPickup = true;   // Pickup했을 때, 삭제할 것인가?
    [SerializeField] private LayerMask canBePickupBy;   // 내가 먹을 수 있는 건지 Layer로 체크
    [SerializeField] private AudioClip pickupSound;

    private void OnTriggerEnter2D(Collider2D other)
    {
        // 내가 먹을 수 있는 녀석인지 검사
        if (canBePickupBy.value == (canBePickupBy.value | (1 << other.gameObject.layer)))
        {
            OnPickedUp(other.gameObject);   // 픽업
            if (pickupSound)
                SoundManager.PlayClip(pickupSound); // 사운드

            if (destroyOnPickup)
            {
                Destroy(gameObject);    // 삭제
            }
        }
    }

    // 추상 메서드 (이 클래스를 상속받는 클래스들은 이 메서드를 무조건 구현 해야한다.)
    protected abstract void OnPickedUp(GameObject receiver); 
}

PickupStatMofifiers 만들기

public class PickupStatModifiers : PickupItem
{
    [SerializeField] private List<CharacterStats> statsModifier;

    // 어떠한 스텟을 가지고 있다가 CharacterStatsHandler에다 추가해준다.
    protected override void OnPickedUp(GameObject receiver)
    {
        CharacterStatsHandler statsHandler = receiver.GetComponent<CharacterStatsHandler>();
        foreach(CharacterStats stat in statsModifier)
        {
            statsHandler.AddStatModifier(stat);
        }
    }
}

PickupHeal 만들기

public class PickupHeal : PickupItem
{
    [SerializeField] int healValue = 10;
    private HealthSystem _healthSystem;

    protected override void OnPickedUp(GameObject receiver)
    {
        _healthSystem = receiver.GetComponent<HealthSystem>();
        _healthSystem.ChangeHealth(healValue);
    }
}

GameManager 수정

if(currentWaveIndex % 5 ==0)
{
    CreateReward();
}

--------------- 생략  ---------------

void CreateReward()
{
    // spawnPositions 랜덤중에 하나를 받아서 그 위치에 생성하게 한다.
    int idx = Random.Range(0, rewards.Count);
    int posIdx = Random.Range(0, spawnPositions.Count);

    GameObject obj = rewards[idx];  // rewards중 하나 랜덤 할당
    Instantiate(obj, spawnPositions[posIdx].position, Quaternion.identity);
}

Item Object 만들기

아이템에 사용될 스프라이트 꺼내기

red ➔ Pickup Heal 추가

green ➔ Pickup Stat Modifiers 추가

yellow ➔ Pickup Stat Modifiers 추가
Ranged Attack Data 생성 ➔ Yellow_RangedAttackData 이름 변경

GameManager 컴포넌트 수정

신에 배치된 아이템 프리팹화 ➔ 삭제
원하는 만큼 보상을 추가

📌 로직 강화하기

➔ 로직 강화

코드 추가

public class GameManager : MonoBehaviour
{
 ... 생략 ...

    [SerializeField] private CharacterStats defaultStats;
    [SerializeField] private CharacterStats rangedStats;

 ... 생략 ...

    private void Start()
    {
        UpgradeStatInit();
        StartCoroutine("StartNextWave");
    }

    IEnumerator StartNextWave()
    {
        while(true)
        {
            if(currentSpawnCount == 0)
            {
                UpdateWaveUI();
                yield return new WaitForSeconds(2f);

                if(currentWaveIndex % 20 == 0)
                {
                    RandomUpgrade();
                }

                ... 생략 ...


                for(int i =  0; i < waveSpawnPosCount;i++)
                {
                    int posIdx = Random.Range(0, spawnPostions.Count);
                    for(int j = 0; j <waveSpawnCount;j++)
                    {
                        int prefabIdx = Random.Range(0,enemyPrefebs.Count);
                        GameObject enemy = Instantiate(enemyPrefebs[prefabIdx], spawnPostions[posIdx].position, Quaternion.identity);
                        enemy.GetComponent<HealthSystem>().OnDeath += OnEnemyDeath;
                        // enemy가 새로 찍어질 때 마다 GetComponent로 가져오므로 웨이브에 따라 랜덤으로 스텟을 올려둔 default, ranged 스텟을 추가(더하기)하여 강하게 만든다.
                        enemy.GetComponent<CharacterStatsHandler>().AddStatModifier(defaultStats);
                        enemy.GetComponent<CharacterStatsHandler>().AddStatModifier(rangedStats);
                        currentSpawnCount++;
                        yield return new WaitForSeconds(spawnInterval);
                    }
                }

                currentWaveIndex++;
            }

            yield return null;
        }
    }

 ... 생략 ...

    void UpgradeStatInit()
    {
    	// 캐릭터 오브젝트를 바로 수정해버리면 남아버리기 때문에, 미리 복사를 한다. (Instantiate)
        defaultStats.statsChangeType = StatsChangeType.Add;
        defaultStats.attackSO = Instantiate(defaultStats.attackSO);

        rangedStats.statsChangeType = StatsChangeType.Add;
        rangedStats.attackSO = Instantiate(rangedStats.attackSO);
    }

    void RandomUpgrade()
    {
        switch (Random.Range(0,6))
        {
            case 0:
                defaultStats.maxHealth += 2;
                break;

            case 1:
                defaultStats.attackSO.power += 1;
                break;

            case 2:
                defaultStats.speed += 0.1f;
                break;

            case 3:
                defaultStats.attackSO.isOnKnockback = true;
                defaultStats.attackSO.knockbackPower += 1;
                defaultStats.attackSO.knockbackTime = 0.1f;
                break;

            case 4:
                defaultStats.attackSO.delay -= 0.05f;
                break;

            case 5:
                RangedAttackData rangedAttackData = rangedStats.attackSO as RangedAttackData;
                rangedAttackData.numberofProjectilesPerShot += 1;
                break;

            default:
                break;
        }
    }
}

GameManager 컴포넌트 수정

RangedAttackData, DefaultAttackData 생성
Default Stats와 Ranged Stats를 수정

이준호

No Easy Day

이전 포스트

디자인 패턴 7가지

다음 포스트