: 클래스를 하나의 인스턴스로만 존재하도록 만드는 패턴

• 하나만 존재(유일성)할 수 있는 클래스 -> 다른 클래스와 혼동할 가능성 적음, 편리하게 접근 가능

• 원하는 시점에 생성 -> 유연한 초기화

• MonoBehaviour를 상속받을 수 있다 -> 다양한 C# 기능활용

• 객체로써 존재 가능 -> 객체 지향의 디자인 패턴

• 단 하나의 인스턴스(객체)만 생성되도록 강제하고, 어디서든 그 객체에 쉽게 접근할 수 있게 만든 패턴

• 게임 전체를 관장하는 시스템에 주로 사용

• (주로 관리자(Manager)역할을 하는 스크립트에 사용) ```csharp 단순한 싱글톤 public class SimpleSingleton : MonoBehaviour { public static SimpleSignleton Instance {get; private set;} -> static 기반의 Instance
  void Awake() {

    Instance = this;
    -> 필요할 때 Instance에 this 할당

  } }

• 유일성이 보장된거는 아닌 단순한 static 기반의 싱글톤 생성

  ```csharp
  일반적인 싱글톤
  public class BasicSingleton : MonoBehaviour
  {
     private static BasicSingleton instance;
     public static BasicSingleton Instance
     {
         get => instance;
     }
  
     void Awake()
     {
         if(instance == null)
         {
             instance = this; -> 싱글턴 인스턴스 할당
             DontDestoryOnLoad(gameObject); -> 씬 전환되도 파괴되지 않도록 설정
         }
         else
         {
             Destroy(gameObject); -> 중복 방지
         }
     }
  }

  오브젝트가 아예 없을경우의 싱글톤
  public class BasicSingleton : MonoBehaviour
  {
     private static BasicSingleton instance;
     public static BasicSingleton Instance
     {
         get
         {
             if(instance == null) 
             {
                 var obj FindFirstObjectByType<BasicSingleton>();
                 -> 씬 상에서 오브젝트 찾기
                 if (obj != null) -> 씬 상에서 오브젝트 찾음
                     instance = obj; -> 오브젝트 할당
                 else -> 씬 상에서 오브젝트를 찾지 못했으면 직접 만들어서 연결
                 {
                     var newObj = new GameObject("Basic Singleton");
                     -> 오브젝트 생성
                     newObj.AddComponent<BasicSingleton>();
                     ->컴포넌트 생성
                     instance = newObj.GetComponent<BasicSingleton>();
                     -> 컴포넌트 할당
                 }
             }
  
             return instance
         }
     }
  
     void Awake()
     {
         if(instance == null)
         {
             instance = this; -> 싱글턴 인스턴스 할당
             DontDestoryOnLoad(gameObject); -> 씬 전환되도 파괴되지 않도록 설정
         }
         else
         {
             Destroy(gameObject); -> 중복 방지
         }
     }
  }

  제너릭 싱글톤

  : 싱글톤 제조기를 하나 만들어 두고, 다른 클래스들이 이 틀을 상속받기만 하면 자동으로 싱글톤이 되도록 만든 기법

  Generic<T>를 활용한 Singleton
  어떤 타입이던지 싱글톤을 생성 가능
  public class SingletonCore<T> : MonoBehaviour where T : MonoBehaviour
  {
     private static T instance;
     public static T Instance
     {
         get
         {
             if(instance == null) 
             {
                 instance == FindFirstObjectByType<T>();
  
                 if (instance == null)
                 {
                     var newObj = new GameObject(typeof(T).ToString());
                     instance = newObj.AddComponent<T>;
                 }
  
             }
  
             return instance
         }
     }
  
     protected virtual void Awake() -> 이 싱글톤이 Awake문을 사용할 수 도 있으니 선택적으로 오버라이드할 수 있게 생성
     {
         if(instance == null)
         {
             instance = this as T; -> 싱글턴 인스턴스 할당
             DontDestoryOnLoad(gameObject); -> 씬 전환되도 파괴되지 않도록 설정
         }
         else
         {
             Destroy(gameObject); -> 중복 방지
         }
     }
  }

  해당 클래스를 싱글톤화
  public class BasicClass : SingletonCore<BasicClass> -> 싱글톤코어를 상속 <원하는타입>
  {
     public int level;
  
     public void LevelUp()
     {
         level++;
     }
     //만약 Awake를 사용한다면 base.Awake()를 불러준다.
     public void override void Awake()
     {
         base.Awake(); //부모의 싱글톤 설정 기능을 실행
         level = 1;
     }
  }

전략 패턴 (Strategy Pattern)

: 동작을 캡슐화하여 런타임에 알고리즘을 쉽게 교체하는 패턴

1. 인터페이스 정의
2. 전략 구현
3. 컨텍스트(사용자) 설정

1.인터페이스 정의

이동 기능에 대한 인터페이스
public interface IMove
{
    void Move(Transform transform);
}

2.전략구현

달리는 이동 기능
public class MoveRun : IMove
{
    private float speed;

    public MoveRun(float speed)
    {
        this.speed = speed;
    }

    public void Move(Transform transform)
    {

    }
}

날아서 이동 기능
public class MoveFly : IMove
{
    private float speed;

    public MoveRun(float speed)
    {
        this.speed = speed;
    }

    public void Move(Transform transform)
    {

    }
}

수영해서 이동 기능
public class MoveSwim : IMove
{
    private float speed;

    public MoveRun(float speed)
    {
        this.speed = speed;
    }

    public void Move(Transform transform)
    {

    }
}

3. 컨텍스트(사용자)설정

   이동하는 대상
   public class Mover : MonoBehaviour
   {
    private IMove move;
   
    void Start()
    {
        move = new MoveRun(3f);
    }
   
    void Update()
    {
        move.Move(transform); -> start에 transform 주입 시, 생성자 주입 방식이 된다.(너는 평생 이 Transform만 움직여) 
   
        if(Input.GetKeyDown(KeyCode.Shift)
        {
            move = new MoveRun(3f);
        }
        else if(Input.GetKeyDown(KeyCode.Space)
        {
            move = new MoveFly(7f);
        }
        else if(Input.GetKeyDown(KeyCode.Tap)
        {
            move = new MoveSwim(2f);
        }
    }
   }

   오브젝트 풀 패턴 (Object Pool Pattern)

   : 오브젝트를 미리 생성하여 Pool에 저장해두고, 재사용하는 패턴

• 일반적으로 queue, stack 사용
• 최적화

public class StudyObjectPool : MonoBehaviour
{
    public Queue<GameObject> objQueue = new Queue<GameObject>();

    public GameObject objPrefab;
    -> 풀을 채워 넣을 원본(ex 총알, 몬스터 등)
    public Transform parent;
    -> 생성된 오브젝트들을 깔끔하게 정리하기 위한 폴더 역할의 부모 트랜스폼

    void Start()
    {
        CreateObject(50);
        -> 시작하자마자 50개 미리 생성
    }

    private void CreateObject(int amount)
    {
        for (int i = 0 ; i < amount ; i++)
        {
            GameObject obj = Instantiate(objPrefab, parent);
            -> 부모 밑에 오브젝트 생성
            EnqueueObject(obj);
            -> 생성 후 창고queue에 넣기
        }
    }

    private void EnqueueObject(GameObject newObj) -> 재활용
    {
        Rigidbody rb = newObj.GetComponent<Rigidbody>();

        rb.lineraVelocity = Vector3.zero;
        rb.angularVelocity = Vector3.zero;
        -> 물리적 힘 초기화
        //총알이 발사되기 이전, 상호작용 된것을 초기화

        newObj.SetActive(false);
        -> 비활성화
        obj.Queue.Enqueue(newObj);
        -> 창고에 넣기
    }

    public GameObject DequeueObject() -> 총알을 발사할 때, DequeueObject 호출을 통해 풀에서 꺼내 쓴다.
    {
        if(objQueue.Count < 3) -> 자동확장 로직 //준비해둔 50개를 쓰고 3개밖에 안남았을때 불안하기 때문에 즉시 50개 생성
            CreateObject(50);

        GameObject obj = objQueue.Dequeue();
        ->창고에서 꺼내기
        obj.SetActive(true);
        -> 활성화

        return obj; -> 배달
    }

}

public class PoolController : MonoBehaviour
{
    public StudyObjectPool pool;
    public Transform shootPoint;

    void Update()
    {
        if (Input.GetMouseButtonDown(0))
        {
            GameObject bullet = pool.DequeueObject();
            -> 풀에서 꺼낸다.(기존의 Instantiate 대체)
            bullet.transform.position = shootPoint.position;
            //총알 발사 기능
        }
    }
}

public class Bullet : MonoBehaviour
{
    public StudyObjectPool pool;

    void OnEnable()
    {
        Invoke("ReturnPool",10f);
        -> 10초 후 해당 오브젝트를 queue에 저장
    }
    private void ReturnPool()
    {
        pool.EnqueueObject(gameObject);
        -> 오브젝트를 queue에 저장
    }
}

유니티에 내장된 Pool 기능

using UnityEngine.Pool;

public class UnityPoolManager : MonoBehaviour
{
    public ObjectPool<GameObject> pool;
    public GameObject prefab;

    void Awake()
    {
        pool = new ObjectPool<GameObject>(CreateObject, GetObject, ReleaseObject);
    }

    private GameObject CreateObject()
    {
        GameObject obj = Instantiate(prefab);

        return obj;
    }

    private void GetObject(GameObject obj)
    {
        obj.SetActive(true);
    }

    private void ReleaseObject(GameObject obj)
    {
        obj.SetActive(false);
    }
}

public class PoolController : MonoBehaviour
{
    public UnityPoolManager poolManager;
    public Transform shootPoint;

    void Update()
    {
        if(Input.GetMouseButtonDown(0))
        {
            GameObject bullet = poolManager.pool.Get(); -> pool.Get()을 통해 GetObject()실행, 재고가 없을시 Create하고 Getobject 실행
            bullet.transform.position = shootPoint.position;
        }
    }
}

-> 유니티 풀 내부 함수 pool.Get() 이해하기 쉽게 하기 위한 함수 예시
public GameObject Get()
{
    GameObject item;

    // 1. 재고 확인
    if (재고가_없으면)
    {
        // 이때만 CreateObject가 호출
        item = CreateObject(); 
    }
    else
    {
        // 재고가 있으면 그냥 꺼냅니다.
        item = 창고.꺼내기();
    }

    // 2. 나가기 전에 활성화 (이건 항상 실행됨)
    GetObject(item);

    return item;
}

public class Bullet : MonoBehaviour
{
    public UnityPoolManager poolManager;

    void OnEnable()
    {
        Invoke("ReturnPool", 10f);
    }

    private void ReturnPool()
    {
        poolManager.pool.Release(gameObject);
    }
}

팩토리 패턴 (Factory Pattern)

: 객체 생성을 별도의 클래스(팩토리)에게 위임하고 객체 생성 로직을 캡슐화하여 유연성을 높이는 패턴

• 다양한 오브젝트, 객체를 복잡하게 생성하지 않고 위임하여 유연성을 높임
• 상속 구조, 상속 구조가 애매할때는 인터페이스를 주로 사용(IFactory)

1. 몬스터의 기본 설계도 (상속) ```csharp

-> 추상 클래스 : 몬스터 뼈대, 몬스터가 가져야 할 기능들 public abstract class MonsterCore { public abstract string Name {get;} public abstract void Attack(); }

2. 구체적인 몬스터 종류
```csharp
public class Slime : MonsterCore
{
    public override string Name => "슬라임";
    public override void Attack() => Debug.Log("슬라임공격");
}

public class Orc : MonsterCore
{
    public override string Name => "오크";
    public override void Attack() => Debug.Log("오크공격");
}

public class Dragon : MonsterCore
{
    public override string Name => "드래곤";
    public override void Attack() => Debug.Log("드래곤 공격");
}

3. 공장의 기본 설계도

   public abstract class MonsterFactory : MonoBehaviour -> 최상위 팩토리
   {
    public MonsterCore Spawn(string type)
    {
        MonsterCore monster = CreateMonster(type); -> 추상함수랑 연결되어 있음(구체적인 생성은 자식에게 미룸)
        Debug.Log($"{monster.Name}생성");
   
        return monster;
    }
   
    protected abstract MonsterCore CreateMonster(string type);
    -> 타입에 따라 어떻게 만들지 자식에서 정해라
   }

   public class ForestSpawner : MonsterFactory
   {
    protected override MonsterCore CreateMonster(string type) -> 오버라이드 재정의
    {
        MonsterCore monster = null;
        switch(type)
        {
            case : "Slime"
                monster = new Slime();
                break;
            case : "Orc"
                monster = new Orc();
                break;
        }
   
        return monster; -> 만든 몬스터 반환
    }
   
    IEnumerator Start() -> 1초마다 랜덤하게 몬스터 생성
    {
        while(true)
        {
            int ranIndex = Random.Range(0,2);
   
            string monsterType = ranIndex == 0 ? "Slime" : "Orc";
            Spawn(monsterType);
   
            yield return new WaitForSeconds(1f);
        }
    }
   }

명령 패턴 (Command Pattern)

: 명령을 객체로 만들어 캡슐화 하는 것

• 인터페이스 or 상속

상태 패턴 (State Pattern)

이벤트 버스 패턴 (Event Bus Pattern)

옵저버 패턴 (Observer Pattern)

: 현실 세계를 모형으로 모든 것을 객체로 표현하는 프로그래밍 방식

객체

• 속성과 기능을 가진 실체를 가진 대상
• 유니티에서 GameObject + Component로 객체를 구성

  객체 지향 프로그래밍의 특성

• 추상화 : 핵심 정보만 공개 (설계의 단순화)
• 상속 : 코드 재사용, 부모 기능 물려받기 (코드간결,유지보수 용이)
• 다형성 : 같은 함수, 다양한 동작 실행 (유연한 설계)
• 캡슐화 : 내부 정보 은닉, 접근 통제 (보안성과 안정성)

오버로딩(Overloading)

: 동일한 함수명의 매개변수를 다르게 설정해서 다른 기능을 구현하는 방법(다형성, 유연성)

    매개변수 타입만 다른 함수 3종

    public void Method(int a){}
    public void Method(float a){}
    public void Method(string a){}

    하나로 모든 타입을 받을 수 있는 제너릭을 활용한 함수

    public void Method<T>(T a){}

    함수명은 같지만 매개변수가 달라 다른 함수가 된다.

    private void TargetMovement(Transform target)
    {
        //target이 앞으로 이동하는 기능
    }
    private void TargetMovement(Transform target, Transform destination)
    {
        //target이 목적지를 향해 이동하는 기능
    }
    private void TargetMovement(Transform target, Transform destination, float speed)
    {
        //target이 목적지를 향해 speed의 속도를 가지고 이동하는 기능
    }

캡슐화(Encapsulation)

: 외부에서 직접 접근하는 것을 제한하여 데이터 무결성을 보장하는 방법 -> 속성과 함수를 하나의 클래스로 묶고, 접근을 제한하여 은닉성 부여

접근 제한자

• public : 모든 외부 접근 허용 (외부 접근 허용 필드, 메서드)
• private : 클래스 내부에서만 접근 가능 (내부 필드, 내부 로직 전용)
• protected : 상속받은 클래스까지 접근 가능 (자식 클래스에게만 접근 허용)

public int number; -> 외부 클래스 접근 O, 유니티 접근 O
private int number; -> 외부 클래스 접근 X, 유니티 접근 X -> 내부에서만 접근 가능
protected int number; -> 외부 클래스 접근 X, 유니티 접근 X -> 내부와 자식 클래스에서만 접근 가능

//[] 애티르뷰트 Attribute -> 코드에 대한 부가 정보를 기록하고 읽을 수 있는 기능(컴퓨터가 읽는 주석)
[HideInInspector] public int number; -> 외부 클래스 접근 O, 유니티 접근 X -> 인스펙터에서 수정을 방지
[SerializeField] private int number; -> 외부 클래스 접근 X, 유니티 접근 O
[SerializeField] protected int number; -> 외부 클래스 접근 X, 유니티 접근 O -> 내부와 자식 클래스 접근 O
[field:SerializeField] public int number{get; set;} -> 프로퍼티를 인스펙터에서 보여주는 기능

[System.Serializable]
public class Example
{
    public int num1;
    public int num2;
    private int num3;
}

public class Test : MonoBehaviour
{
    public Example example = new Example();
}

-> [System.Serializable]을 사용함으로써 Test스크립트를 사용하는 오브젝트는 num1,num2가 인스펙터에서 보여진다

프로퍼티(Property) : 캡슐화한 데이터(접근자, 설정자 메소드를 축약)

public class Example
{
    int num = 10;
    public int Num
    {
        get { return num; }
        set { num = value; } == public void SetNum(int value){num = value;} 컴파일러가 자동으로 매개변수 인식
    }
}

public class Example 
{
    public int Num {get;set;} -> 자동 구현 프로퍼티 : 프로퍼티를 더 축약
}

public class Example -> 프로퍼티를 인스펙터 창에서 보여주도록 설정
{
    [field:SerializeField]
    public int Num {get;set;}
}

직렬화 (Serialization)

: 데이터를 byte 배열로 변환하는 작업(데이터를 직선으로 바꾸는 기능) -> 게임저장 / 네트워크 연결 시 이용 -> public : 내부적으로 직렬화 과정을 거쳐서 유니티 에디터에서 보이도록 설정한 접근 제한자 -> 인스펙터 창 : 게임 오브젝트의 컴포넌트 필드 값을 확인하거난 변경하면 Unity 에디터가 해당 데이터를 직렬화한 후 인스펙터창에 표시

역직렬화 (Deserialize)

: byte 배열을 데이터로 변환하는 작업(직선 데이터를 원래대로 바꾸는 기능)

상속 (Inheritance)

: 부모 클래스를 자식 클래스가 물려 받아, 부모 클래스의 속성과 기능을 쓸 수 있는 방법 -> 기존 코드 재사용 용이, 확장도 가능

• 상속받은 변수는 그대로 사용 가능

class Monster
{
    //이동 기능
    //공격 기능
    //사망 기능
}

class Orc : Monster
{
    //오크 스킬 기능
    //오크 고유 기능
}

class Zombie : Monster
{
    //좀비 고유 기능
}

class OrcArcher : Orc
{
    //오크궁수 고유 스킬 (활쏘기)
    //오크궁수 고유 기능
}
Monster <- Orc <- OrcArcher

다형성 (Polymorphism)

: 다른 형태여도 같은 타입이라면 제어가능 -> 유연한 설계 가능

public class Character
{
    public float hp;
    public float damage;

    public virtual void Move(){}
    public virtual void Attack(){}   
}

public class Player : Character
{
    public override void Move()
    {
        Debug.Log("플레이어 이동");
    }
    public override void Attack()
    {
        Debug.Log("플레이어 공격");
    }
}

Virtual, Abstract, Override

: 상속받은 함수를 변경하는 기능

Virtual - Override

• 부모 클래스에서 virtual 사용 시, 자식 클래스에서 선택적 재정의(override) 가능
• base 키워드를 활용하여 기존 기능 + 추가 기능 구현 -> 기능 유연성
• 기능 확장

public class Monster : MonoBehaviour
{
    public virtual void Attack(){}
    public virtual void Shout(){}
}

public class Goblin : Monster
{
    public override void Attack()
    {
        base.Attack();
        // + 독 데미지 추가 기능
    }
    public override void Shout()
    {
        //shout 기능
    }
}

public class OrcMonster
{
    public override void Attack()
    {
        base.Attack();
        // + 범위 공격 추가 기능
    }
    public override void Shout()
    {
        //shout 기능
    }
}

Abstract - Override (추상 메소드)

• 부모 클래스에서 abstract 사용 시, 자식 클래스에서 필수적 재정의(override)
• 부모 클래스에서 기능 구현 불가 -> base 키워드 사용 불가
• 구조 설계, 기능 확장

public class Monster : MonoBehaviour
{
    public abstract void Attack(); -> 구현 불가
    public abstract void Shout();
}

public class Goblin : Monster
{
    public override void Attack()
    {
        //독 데미지 공격 기능
    }
    public override void Shout()
    {
        //shout 기능
    }
}

public class OrcMonster
{
    public override void Attack()
    {
        base.Attack();
        //범위 공격 기능
    }
    public override void Shout()
    {
        //shout 기능
    }
}

다중 상속

: 부모 클래스를 여러개 상속받는 것

public class Monster
{
    public virtual void Attack(){}
}

public class Orc : Monster
{
    public override void Attack(){}
}
public class Ogre : Monster
{
    public override void Attack(){}
}

public class CheifOrc : Orc, Ogre --> 오류 발생
{
    public override void Attack(){}
}

• 죽음의 다이아몬드 구조 : 하나의 부모 클래스를 두개의 자식 클래스가 상속받고 다시 하나의 자식 클래스가 상속받는 것

인터페이스 (Interface)

: 프로그래밍상 계약 혹은 약속으로 정의(구현해야 하는 기능, 추가 기능, 다형성)

• 추상 클래스로 대체 가능
• I붙이고 이름 ex) IAttack, IRun, IMove
• 인터페이스는 클래스가 아니라 다중 상속 기능이 가능
• 인스턴스 생성 불가

public interface IAttack
{
    public void Attack();
}
public interface IMove
{
    public void Move();
}

public class Orc : IAttack, IMove -> 다중 상속 가능
{
    public void Attack()
    {
        Debug.Log("Orc Attack");
    }

    public void Move()
    {
        //움직이는 기능
    }
}

public interface IDamageable
{
    int Hp {get; set;}

    void TakeDamage(int dmg);
    void Death();
}

public class Tree
{
    //파괴 불가능한 오브젝트
}

//파괴 가능한 오브젝트들
public class Wall : IDamageable
{
    public void TakeDamage(int amount){}
    public void Death(){}
}
public class Car : IDamageable
{
    public void TakeDamage(int amount){}
    public void Death(){}
}

Unity Script 생명주기

시작함수

void Awake()

: 가장 먼저 1번 실행되는 함수

void OnEnable()

: 오브젝트가 on될 때마다 1번 실행되는 함수

void Start()

: 1번 실행되는 함수

void OnDisable()

: 오브젝트가 off될 때마다 1번 실행되는 함수

void OnDestroy()

: 오브젝트가 파괴될때 1번 실행되는 함수

void FixedUpdate()

: 고정된 프레임마다 계속 실행

void Update()

: 컴퓨터 성능에 따라 계속 실행

void LateUpdate()

: Update 다음에 실행

physics 함수

OnCollision 이벤트

void OnCollisionEnter(Collision collision)

: 두 오브젝트가 충돌했을 때 1번 호출

void OnCollisionStay(Collision collision)

: 두 오브젝트가 충돌 상태를 유지하는 동안 호출

void OnCollisionExit(Collision collision)

: 두 오브젝트가 충돌 상태에서 벗어났을 때 호출

OnTrigger 이벤트

void OnTriggerEnter(Collider other)

: Collider 영역에 들어갔을 때 1번 호출

void OnTriggerStay(Collider other)

: Collider 영역에 들어간 상태를 유지하는 동안 호출

void OnTriggerExit(Collider other)

: Collider 영역을 벗어났을 때 1번 호출

OnCollision과 OnTrigger의 차이점

Input Event 함수

마우스 이벤트 함수

void OnMouseDown()

: 마우스로 누를 때 1번 실행

void OnMouseUp()

: 마우스로 뗄 때 1번 실행

void OnMouseEnter()

: 마우스 포인터가 진힙했을 때 1번

void OnMouseExit()

: 마우스로 포인터가 빠져나갔을 때 1번

void OnMouseOver()

: 마우스 오브젝트 위에 있을 때 계속 실행

void OnMouseDrag()

: 마우스를 누른 상태로 있을 때 계속 실행

void OnMouseUpAsButton()

: 오브젝트 범위 내에서 마우스를 뗀 경우 1번 실행

키보드 이벤트 함수(InputEvent 함수 X,프레임 상태에서 조회하는 Polling방식)

Input.Getkey(KeyCode key)

: 키를 누르고 있는 동안 계속 실행

Input.GetKeyDown(KeyCode key)

: 키를 누른 순간 1번 실행

Input.GetKeyUp(KeyCode key)

: 키를 뗀 순간 1번 실행

Input.GetAxis("Horizontal" or "Vertical")

: 입력값을 -1~1값으로 변환

Input.GetAxisRaw("Horizontal" or "Vertical")

: 보정 없는 즉기 값 변환 (-1.0.1)

Input.anyKey (if(Input.anyKey))

: 아무 키나 눌렀을 때 true

Input.anyKeyDown (if(Input.anyKeyDown))

: 아무 키나 처음 눌렀을 때 1번

조건문

: 조건의 결과를 보고 실행되는 문법

if-else 조건문

if (조건 A){
    조건 A가 true
}
else if(조건 B){
    조건 B가 true
}
else{
    그 외의 경우
}

Switch 조건문

switch (변수)
{
    case a:
        break;
        //변수가 a일경우 실행
    case b:
        break;
        //변수가 b일경우 실행
    case c:
        break;
        //변수가 c일경우 실행
    default:
        break;
        //변수의 값이 위의 값 이외의 경우 실행
}

Invoke 함수

: 호출 함수

Invoke("함수명", 지연시간)

: 지연시간 후 함수 실행

InvokeRepeating("함수명", 지연시간, 반복주기)

: 지연시간 후 함수 실행 한 후 반복주기 마다 실행 ex) InvokeRepeating("함수명",3f, 2f) -> 함수를 3초 후에 실행한 후 2초마다 반복 실행

CancelInvoke("함수명")

: 호출한 Invoke함수 취소 (Invoke,InvokeRepeating으로 예약된 호출만 취소가능)

Invoke("함수명", 지연시간);
InvokeRepeating("함수명", 처음 지연시간, 반복주기);
CancelInvoke("함수명");

반복문 함수

: 조건에 만족하면 반복해서 실행되는 문법

While 반복문

: 조건이 성립되는 동안 반복

while (조건 A){
    조건 A가 true인 경우 실행
}

do~while 반복문

: do -> while 조건 확인 -> do -> while 조건 확인 -> do ... : 조건에 맞지 않아도 do문은 한번 실행

do
{

}
while(조건 A)

for 반복문

: 순차적으로 반복

for(변수 정의; 반복범위; 증감단위){

}

for( i = 1; i < 3 ; i++){
    Debug.Log(i);
}

foreach 반복문

: 배열이나 리스트를 하나씩 반복

foreach(데이터타입 변수 in Collection){

}

private string[] personNames = ["철수","영희","영지"];


foreach(var personName in personNames){
    Debug.Log(personName);
}

철수
영희
영지

break, return, continue

break : 반복문을 빠져나오는 기능 return : 함수를 종료 continue : continue보다 아래 기능을 실행하지 않고 다시 반복문을 실행

Random

: Random.Range(int or float a, int or float b) : a~b까지의 랜덤 숫자 뽑기

코루틴(Coroutine)

(시작 시간과 끝나는 시간이 정해져있을때 사용, 느린판단을 할때)

yield return null; -> 1프레임 대기 Update 호출까지 대기 후 실행
yield return new WaitForFixedUpdated(); -> FixedUpdate 호출까지 대기 후 실행
yield return new WaitForSeconds(time); -> tiem 만큼 대기 후 실행
yield return new WaitForSecondsRealtime(time); -> Timescale에 영향 X, time 대기 후 실행
yield return new WaitForEndOffFrame(); -> 모든 렌더링 작업이 완료될 때까지 대기 후 실행
yield return new WaitUntill(()=>time > 10); -> 해당 조건이 true가 될때까지 대기 후 실행
yield break; -> 코루틴 종료

//함수 호출 방법
void Start(){
    StartCoroutine("Routine");
    StartCoroutine(nameof(Routine));
    StartCoroutine(Routine());
    //매개변수 한개(함수 이름으로 실행할 경우)
    StartCoroutine("Routine1",4);
    //매개변수 여러개(함수 자체로 실행)
    StartCoroutine(Rotuine2(1,2,3));
}

//코루틴 생성 방법
IEnumerator Routine(){
    Debug.Log("Hello");
    yield return new WaitForSeconds(3f);
}

IEnumerator Routine1(int a){
    Debug.Log("a");
    yield return null;
}

IEnumerator Routine2(int a, int b, int c){
    Debug.Log("a");
    Debug.Log("b");
    Debug.Log("c");
    yield return null;
}

//함수 종료 방법
private Coroutine runningCoroutine; -> 반환값 Coroutine을 담을 맴버 변수 선언

void Start()
{
    runningCoroutine = StartCoroutine(Running());
    Invoke("StopRoutine", 1.5f);
}

IEnumerator Running()
{
    Debug.Log("실행 1");
    yield return new WaitForSeconds(1.0f);

    Debug.Log("실행 2");
    yield return new WaitForSeconds(1.0f);

    Debug.Log("실행 3");
    yield return new WaitForSeconds(1.0f);
}

private void StopRoutine()
{
    StopCoroutine(runningCoroutine); -> StopCoroutine(Running())은 작동하지 않는다.
    Debug.Log("강제 종료");

    StopAllCoroutines(); // 클래스 내에서 실행되는 모든 Coroutine 정지
}

제너릭(Generic)

: 데이터 타입을 파라미터로 활용하는 변수

• 코드 재사용성 용이
• 호출시 타입 결정되기 때문에 성능 저하 X

public void Copy(int[] source, int[] target)
{
    for (int i = 0 ; i < source.Length ; i++)
    {
        target[i] = source[i];
    }
}

public void Copy(float[] source, float[] target)
{
    for (int i = 0 ; i < source.Length ; i++)
    {
        target[i] = source[i];
    }
}

public void Copy<T>(T[] source, T[] target) -> 일반화(모든 자료형 사용 가능->호출 시 자료형 재정의)
{
    for (int i = 0 ; i < source.Length ; i++)
    {
        target[i] = source[i];
    }
}

//오브젝트 풀 예시 문

public class ObjectPool<T> where T : Component -> 제약 조건(T타입에 대한 조건 지정)
{
    private Queue<T> pool = new Queue<T>();
    private T prefab;

    public ObjectPool(T prefab, int initialCount)
    {
        this.prefab = prefab;
        for(int i = 0; i <initialCount ; i++)
        {
            T obj = GameObject.Instantiate(prefab);
            obj.gameObject.SetActive(false);
            pool.Enqueu(obj);
        }
    }

    public T Get()
    {
        if(pool.Count > 0)
        {
            var obj = pool.Dequeue();
            obj.gameObject.SetActive(true);
            return obj;
        }

        return GameObject.Instantiate(prefab);
    }

    public void Return(T obj)
    {
        obj.gameObject.SetActive(false);
        pool.Enqueue(obj);
    }
}

매개변수 활용 : ref / out / params

일반 매개변수 (Call by Value)

• 기본값이며, 값 형식인 경우 복사본 전달
• 함수 내부에서 변경해도 원본은 변경되지 않는다.

ref (Call by Reference)

• 초기화된 변수만 전달 가능
• 함수 내부에서 변경 시 원본도 같이 변경

public int num = 10;

void Start()
{
        NormalParameter(num);
        RefParameter(ref num);
}

public void NormalParameter(int n)
{
        Debug.Log("호출 전 : " + n);
        n = 1;
        Debug.Log("호출 후 : " + num);
}
public void RefParameter(ref int n)
{
        Debug.Log("호출 전 : " + n);
        n = 1; 
        Debug.Log("호출 후 : " + num);
}

호출 전 : 10
호출 후 : 10 -> 원본이 변경 X

호출 전 : 10
호출 후 : 1 -> ref는 원본이 변경되었다.

Out (출력 전용 참조)

• 함수 내부에서 반드시 초기화해야한다.
• 초기화되지 않은 변수도 전달 가능
• 입력값은 무시, 출력용 목적으로 사용

public class OutParameter : MonoBehaviour
{
    void Start()
    {
        int a = Random.Range(1,100);
        int b = Random.Range(1,100);

        //Old 버전
        int result1 = 0;
        int result2 = 0;
           Divide(a,b,out result1,out result2);

        //Out 파라미터를 메소드를 호출할 때 선언 가능
        //현재 메소드가 호출되는 블록 내부에서 선언 이후 사용 가능
        Divide(a,b,out int result1, out int result2);

        // var 키워드 사용 가능
        // 메소드 정의에는 var를 사용할 수 없기 때문에 메소드 정의를 참고해서 자동 설정
        Divide(a, b, out var r1, out var r2);

        //메소드 정의는 2개의 out 파라미터를 사용하도록 되어 있지만 필요 없는 경우도 존재 가능 '_' 사용
        Divide(a,b,out var rr1, out _);

        Debug.Log($"{a} / {b} = {result1}");
        Debug.Log($"{a} / {b} = {result2}");

        Debug.Log($"{a} / {b} = {r1}");
        Debug.Log($"{a} / {b} = {r2}");

        Debug.Log($"{a} / {b} = {rr1}");
    }

    void Divide(int num1, int num2,out int r1,out int r2)
    {
        r1 = num1 / num2; ->몫
        r2 = num1 % num2; -> 나머지
    }
}

5 / 2 = 2
5 % 2 = 1

5 / 2 = 2
5 % 2 = 1

5 / 2 = 2

Params (가변 인자)

• 매개변수의 개수를 가변적으로 받을 때 사용
• 배열로 전달(개수가 정해지지 않은 자료형의 데이터를 넘기게 된다.)
• 메서드 정의 시 마지막 인자에만 사용 가능

void Like(int x, params string[] message)
{
    foreach (string s in message)
    {
        Debug.Log(s);
    }
}

void Start()
{
    int x = 3;
    Like(x, "맑음","나쁨","바람");
}

3
맑음
나쁨
바람

public int[] nums = {1,2,3,4,5};

void Start()
{
    ParamsParameter(1,2,3,4,5);
    ParamsParameter(10,20,30);
}

void ParmasParameter(params int[] numbers)
{
    string str = "";
    foreach (var number in numbers)
    {
        str += num + " ";
    }
    Debug.Log(str);
}

1 2 3 4 5
10 20 30

클래스와 함수 커스텀 : Partial / Sealed

Partial

• 분리 용도
• 하나의 클래스, 구조체, 인터페이스를 여러파일에 나누어 구현 가능
• 주로 Unity의 자동 생성 코드와 사용자 코드 분리, 대형 클래스 분할에 사용
• 실행시 하나로 합쳐져서 컴파일 진행 -> 컴파일 단계
• 네임스페이스가 동일해야 함
• 모든 부분 정의에서 같은 접근 제한자 사용 ex) 하나의 partial 정의가 public이면 다른 정의도 public

• 장점 : 가독성,협업,조직화

public partial class StudyPartial : MonoBehaviour
{
    void Start()
    {
        Debug.Log("Start method");
    }
}

public partial class StudyParital
{
    void Update()
    {
        Debug.Log("Update mehtod");
    }
}

Start method
Update method
Update method
Update method
Update method
...
-> 2개의 파일이 컴파일 시 내용이 합쳐져서 하나의 클래스가된다.

Sealed

• 봉인 용도
• 클래스를 상속하지 못하도록 방지
• 함수를 override 못하도록 막을 수 있다
• 클래스 앞 -> 더 이상 상속 불가
• override된 메서드 앞 -> 자식에서 override 불가

public class BaseClass : MonoBehaviour
{
    public virtual void Method()
    {
        Debug.Log("일반 함수");
    }
}

public class MiddleClass : BaseClass
{
    public sealed override void Method()
    {
        Debug.Log("봉인된 오버라이드 함수");
    }
}

public class LastClass : MiddleClass
{
    public override void Method() --> 함수가 봉인되었기 때문에 오류 발생(override 불가)
    {
        Debug.Log("오버라이드 함수");
    }
}

함수를 대신 실행하는 대리자 : Delegate

Delegate

: 함수를 참조

• 델리게이트 체인 (+= 등록, -= 제거)

접근제한자 delegate 반환타입 이름(매개변수)
public delegate void MyDelegate();

public class StudyDelegate : MonoBehaviour
{
    public delegate void MyDelegate();
    public MyDelegate onDelegate;

    void Start()
    {
        //onDelegate에 함수 할당
        onDelegate = MethodA;
        //MethodB 추가
        onDelegate += MethodB;
        //MethodC 추가
        onDelegate += MethodC;
        //MethodB 삭제
        onDelegate -= MethodB;

        //직접 실행
        onDelegate();
        //직접 실행과 동일한 방식
        //delegate.invoke -> 함수 즉시 호출, monobehaviour.invoke -> 지연 호출
        onDelegate.Invoke();
        //null 체크 방식
        OnDelegate?.Invoke();
    }
}

public class ParameterDelegate : MonoBehaviour
{
    public delegate void MyDelegate(int a = 10); -> 매개변수가 있는 함수 연결(default값을 10으로 설정)
    public Mydelegate onDelegate;

    void Start()
    {
        onDelegate += MethodA; -> 오류 발생
        onDelegate += MethodB;
    }

    private void MethodA(){} -> 매개변수가 없는 함수
    private void MethodB(int b){} -> 매개변수가 있는 함수
}

event/UnityEvent/EventHandler (Delegate 기반)

event

• 구독/발행 이벤트 패턴 용도

• 외부 호출 방지 -> 오직 선언된 클래스 내부에서만 Invoke 가능

• += -=로 구독 -> '='를 사용해서 외부에서 새롭게 할당 방지

• (delegate를 외부에서 함부로 호출하거나 초기화하지 못하게 막는 캡슐화된 기능)

• 함수 캡슐화

  public class ExampleEvent : MonoBehaviour
  {
    //델리게이트정의
    public delegate void InputKeyHandler();
   // public delegate void InputKeyHandler(string msg);
    //event 선언
    public event InputKeyHandler onInputKey;
    //위에 두줄 == public event Action onInputKey;
  
    public KeyCode keycode = KeyCode.Space;
  
    void start
    {
        // 구독
        onInputKey += OnInputKey;
    }
    void Update()
    {
        if (Input.GetKeyDown(keycode)
        {
            //구독자가 한명이라도 있으면 실행(즉, 0명인지 확인)
            onInputKey?.Invoke();
            //onInputKey?.Invoke($"{keyCode}를 눌렀습니다");
        }
    }
    public void OnInputKey()
    {
        Debug.Log("key Down");
    }
    /*public void OnInputKey(string msg)
    {
        Debug.Log(msg);
    }
    */
  }

UnityEvent

• 인스펙터상에 표시하여 이벤트를 등록 가능
• 외부에서 호출 가능, [SerializeField]를 활용하여 외부 접근 제한 가능
• AddListener, RemoveListener로 구독
• (인스펙터 창에서 이벤트를 연결할 수 있도록 만든 클래스)

using UnityEngine.Events; -> UnityEvent를 사용할려면 작성해야함

public class StudyUnityEvent : MonoBehaviour
{
    [SerializedField] private void UnityEvent onHappened -> 인스펙터 노출(외부 접근 제한)
    public UnityEvent uEvent;

    void Start()
    {
        //구독
        uEvent.AddListener(MethoA);
        uEvent.AddListener(MethoB);
        //매개변수가 있는 함수의 경우
        uEvent.AddListener(() => MethodC(10));

        //삭제
        uEvent.RemoveListener(MethoA);
    }

    void Update()
    {
        if (Input.GetKeyDown(KeyCode.Space)
        {
            //실행
            uEvent?.Invoke();
        }
    }

    private void MethodA(){}
    private void MethodB(){}
    private void MethodC(int num){}
}

UnityHandler

• Argument(인자)를 활용하는 Delegate

public delegate void EventHandler(object sender, EventArgs e);
//object sender -> 이벤트를 실행시키는 객체
//EventArgs e -> 이벤트 실행시 전달할 수 있는 매개변수

public class StudyEventHandler : MonoBehaviour
{
   private event EventHandler handler;
   //add, remove 이벤트 접근자
   public event EventHandler Handler //프로퍼티
   {
           add
        {
            Debug.Log($"{value.Method} 추가됨"); -> MethodA 추가됨
            handler += value;
        }
        remove
        {
            Debug.Log($"{value.Method} 삭제됨"); -> MethodA 삭제됨
            handler -= value;
        }
   }

  //EventHandler -> void 타입의 매개변수가 2개인 델리게이트

  //delegate의 작업에서 주로 쓰이는 형태 OnEnable <-> OnDisable
  //켜져있으면 자동등록
  void OnEnable()
  {
      Handler += MethodA;
  }
  //파괴되거나 없어지면 구독해제
  void OnDisable()
  {
      Hanbdler -= MethodA;
  }

  void Update()
  {
       if(Input.GetKeyDown(keyCode.Space)
          handler?.Invoke(this, EventArgs.Empty);
          -> 매개변수를 아무것도 넣은게 없다면 (이렇게할거면 다른거를 사용하는게 좋음)
  }

    public void MethodA(object o, EventArgs e)
    {

    }
}

public class ExternalClass : MonoBehaviour
{
    public StudyEventHandler study;
    void Start()
    {
        study?.Invoke(this, EventArgs.Empty); -> 실행불가능
    }
}

public class DataClass : EventArgs
-> Invoke를 통해 핸들러를 실행했을 때 데이터클래스의 정보를 활용하고 싶으면 DataClass에 EventArgs를 상속시키면 된다.
{
    public string dataName;
    public int dataNumer;
    public bool isData;

    public DataClass(string dataName, int dataNumber, bool isData)
    {
        this.dataName = dataName;
        this.dataNumber = dataNumber;
        this.isData = isData;
    }
}
public class StudyEventHandler : MonoBehaviour
{
    public event EventHandler handler;
    -> EventHandler는 여러 데이터를 활용하는 용도로 사용
    void Start()
    {
        handler += StartEvent;

        DataClass data1 = new DataClass("DataClass1",1,false);
        DataClass data1 = new DataClass("DataClass1",1,false);

        handler?.Invoke(this , data1); -> (data1을 Eventargs타입인 e로 자동변환 -> 업캐스팅)
        handler?.Invoke(this , data2);
    }

    private void StartEvent(object o, EventArgs e)
    {
        var data = (DataClass)e; -> 형변환(e를 DataClass형태로 전환 -> 다운캐스팅)
        Debug.Log($"Data Name : {data.dataName}");
    }
}

업캐스팅, 다운캐스팅 없이 전달하기 위해서 EventHandler<'T'>를 사용

public class StudyEventHandler : MonoBehaviour
{
    public event EventHandler<DataClass> handler;
      ->  제너릭<T>를 활용
      -> delegate void EventHandler<T>(object sender, T e)
    void Start()
    {
        handler += StartEvent;

        DataClass data1 = new DataClass("DataClass1",1,false);
        DataClass data1 = new DataClass("DataClass1",1,false);

        handler?.Invoke(this , data1);
        handler?.Invoke(this , data2);
    }

    private void StartEvent(object o, DataClass e) -> 제너릭<T> 타입을 DataClass로 설정을 했기때문에 EventArgs를 넣을 필요가 없어짐
    {
        Debug.Log($"Data Name : {e.dataName}");
          Debug.Log($"Data Name : {e.dataNumber}");
          Debug.Log($"Data Name : {e.isData}");
    }
}

익명함수와 람다

익명함수(Anonymous Method)

• 이름 없는 함수
• 한 번만 쓸건데 이름짓고 따로 만들기 귀찮은 상황 -> 간략하게 작성하자

public class StudyLamda : MonoBehaviour
{
     public delegate void MyDelegate();
      public MyDelegate myDelegate;

      void Start()
      {
          //myDelegate = OnLog;
          myDelegate = delegate -> 한번 쓰는 함수를 void OnLog(){} 쓰기 귀찮음 -> 일회용 함수 사용(함수 이름 X)
          {
              Debug.Log("Hello Unity");
          }
          myDelegate?.Invoke();

          //매개변수가 있는 익명함수
          //myDelegate += delegate ~ 도 사용 가능
          myDelegate = delegate (string s)
          {
              Debug.Log(s);
          }
          myDelegate?.Invoke("Hello Unity");
      }
      /*
      public void OnLog()
      {
          Debug.Log("Hello Unity");
      }
      */
}

람다

• 익명함수를 활용
• 함수를 생성하지 않아도 된다.

public class StudyLamda : MonoBehaviour
{
    public delegate void MyDelegate1();
      public delegate void MyDelegate2(string s);
      public delegate void MyDelegate3(string s);

      public MyDelegate1 myDelegate1;
      public MyDelegate2 myDelegate2;
      public MyDelegate2 myDelegate3

      void Start()
      {
          myDelegate1 = () => Debug.Log("Hello Unity");
          myDelegate1?.Invoke();

          myDelegate2 = (s) => Debug.Log(s);
          myDelegate2?.Invoke("Hello Unity");

          myDelegate3 = (s) =>
          {
              Debug.Log(s);
              Debug.Log("Hello Unity");
          }
          myDelegate3?.Invoke("Hello C#");
      }
}

Hello Unity
Hello Unity
Hello C#
Hello Unity

public class StudyLamda : MonoBehaviour
{
    public Button buttonUI;

      void Start()
      {
          buttonUI.onClick.AddListener( () => OnLog("Hello") );
      }
      private void OnLog(string msg)
      {
          Debug.Log("Hello Unity");
      }
}

Closure 이슈

: 외부 함수의 변수를 내부 함수가 참조할 때 발생 -> 내부 함수는 외부 함수의 실행이 끝난 후에도 외부 함수의 변수에 접근 가능

public class ExampleClosure : MonoBehaviour
{
     public Button[] buttonUIs;

      void Start()
      {
          for (int i = 0 ; i < 5 ; i++) -> 외부함수의 영역
        {
            int temp = i; -> Closure 이슈 방지, temp는 매 for문 바퀴마다 새로 생성               
            buttonUIs[i].onClick.AddListener(() => SetButton(temp)); ->(()=>Setbutton(temp))가 내부함수      
        }
      }
}

Func / Predicate / Action / UnityAction

Func

: 여러 개의 매개변수를 넣을 수 있고 반환타입이 있는 Delegate -> 마지막에 적은 타입이 반환타입

• 델리게이트 체인이 있을경우 가장 마지막에 실행된 메서드의 반환값만 남게 된다.

  접근제한자 Func<매개변수1, 매개변수2, 반환타입> 변수명;
  public Func<int, int, int -> 반환타입> myFunc;

  public class StudyFunc : MonoBehaviour
  {
    public Func<int,int,int> myFunc; -> int 반환타입
    public Func<string, string, bool> myFunc2; -> bool 반환타입
  
    void Start()
    {
        myFunc = AddMethod;
        int result = myFunc?.Invoke(10,7);
        Debug.Log($"최종 결과 : {result}");
  
        myFunc2 = CompareText
        bool result =2 myFunc2?.Invoke("hello", "unity");
        Debug.Log(result2);
    }
  
    private int AddMethod(int num1, int num2)
    {
        return num1 + num2;
    }
  
    public bool CompareText(string msg1, string msg2)
    {
        if (a==b)
            return true;
  
        return false;
    }
  }

  여러 개의 Func를 추가한 List

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

public class StudyFunc : MonoBehaviour { private List<Func<int, int>> funcList = new List<Func<int, int>>();

void Start()
{
    funcList.Add(AddMethod);
    funcList.Add(MinusMethod);
    funcList.Add(MultiplyMethod);

    -> 람다식으로 줄일 수 있음 (addmethod,minusmethod,multiplymethod가 필요없어짐)
    funcList.Add(n => n + 1);
    funcList.Add(n => n - 3);
    funcList.Add(n => n * 2);

    int result = 0;
    foreach (var func in funcList) -> 함수 순서대로 동작 
        result += func(5);

    Debug.Log($"최종 결과: {result}");
}

private int AddMethod(int n)
{
    return n + 1;
}

private int MinusMethod(int n)
{
    return n - 3;
}

private int MultiplyMethod(int n)
{
    return n * 2;
}

}

```text
18 (addmethod return : 6 + minusmethod return : 2 + multiplymethod return : 10)

Predicate

: 반환값이 boolean인 Delegate

접근제한자 Predicate<매개변수> 변수명;
public Preicate<int> myPredicate;

public class StudyPreicate : MonoBehaviour
{
    public Predicate<int> myPredicate;
    public int myLevel = 10;

    void Start()
    {
        myPredicate = n => n <= 10; (n <= 10) -> true 값이 n으로 반환
        string msg = myPredicate(myLevel) ? "초보자 사냥터 이용 가능" : ":초보자 사냥터 이용 불가능"; -> 반환값에 따라 ? 이용 가능(true) : 이용 불가능(false)
        Debug.Log(msg);
    }
}

Action

: 반환 타입이 없는 Delegate

접근제한자 Action 변수명;
접근제한자 Action<매개변수(여러개도 가능)> 변수명;

public class StudyAction : MonoBehaviour
{
    //매개변수 없는
    public Action myAction;
    //매개변수가 있는
    public Action<string> myAction2;

    void Start()
    {
        myAction = () => Debug.Log("Hello Unity");
        myAction?.Invoke();

        myAction2 = (s) => Debug.Log(s);
        myAction2?.Invoke("Hello Unity");        
    }
}

Action은 함수만 static

public class ExampleAction : MonoBehaviour
{
    public static Action myAction; -> myActiong만 static
    //public static event Action myAction; -> 캡슐화 작업을 통해 외부 작업 방지
    // Property는 변수 캡슐화 작업
    void Start()
    {
        myAction += AddMethod;
    }

    private void AddMethod()
    {
        Debug.Log("더하는 기능");
    }
}

public class ExampleClass : MonoBehaviour
{
    void Start()
    {
        ExampleAction.myAction += OtherMethod; -> 외부에서 실행할때, 굳이 싱글턴 또는 변수만들어서 할 필요없이 static된 myAction만 접근가능

        ExampleAction.myAction?.Invoke();
    }

    public void OtherMethod()
    {
        Debug.Log("기능");
    }
}

UnityAction

: Unity에서 제공하는 Action Delegate

• delegate -> +=, -=, ?.Invoke
• UnityEvent -> AddListener, RemoveListener, ?.Invoke

public class StudyUnityAction : MonoBehaviour
{
    public Button buttonUI;
    public UnityAction uAction;

    void Start()
    {
        uAction += MethodA;
        uAction += MethodB;
        uAction += MethodC;

        buttonUI.onClick.AddListener(uAction);
    }

    private void MethodA(){};
    private void MethodB(){};
    private void MethodC(){};


}

: 어떤 수 x에 대해 제곱의 대상 (result=num1^num2)

• Mathf.Pow(float a,float b)

public float num1 = 2, num2 = 3;

void start(){
    float result = Mathf.Pow(num1, num2);
    Debug.Log(result);
}

64

루트

: 어떤 수의 거듭제곱을 푸는 연산 (√16 = 4)

• Mathf.Sqrt(float a);

void start(){
    float result = Mathf.Sqrt(16f);
    Debug.Log(result);
}

4

로그

: 거듭제곱을 푸는 연산, Log의 밑 기준 몇 제곱인지 구하는 함수 (log₂(4))

• Mathf.Log(float a)

void start(){
    float value1 = Mathf.Log10(1000f);
    float value2 = Mathf.Log(4f, 2f); log₂(4)
    Debug.Log("value 1 : " + value1 +", value 2 : " + value2);
}

value 1 : 3, value 2 : 2

반올림, 올림, 내림

• Mathf.Round(float a) 반올림
• Mathf.Ceil(float a) 올림
• Mathf.Floor(float a) 내림

파이

: 원의 둘레

• Mathf.PI (= 180f)

라디안

:호도법으로 각도를 측정한 단위

• 도 -> 라디안 Mathf.Deg2Rad
• 라디안 -> 도 Mathf.Rad2Deg

float rad = degree * Mathf.Deg2Rad; //도 -> 라디안 구하는 방식
float deg = radian * Mathf.Rad2Deg; // 라디안 -> 도 구하는 방식

벡터

: 크기와 방향을 가지고 있는 값

• Vector3(x,y,z)

두 벡터 사이 거리 구하기

• Distance : 특정 두 점의 거리 계산 √(x^2 + y^2 + z^2)
• magnitude : 특정 벡터의 크기 계산 √(x^2 + y^2 + z^2)
• sqrMagnitude : 특정 벡터의 크기의 제곱 (x^2 + y^2 + z^2)
• normalized : 정규화된 벡터 (길이가 1인 방향 벡터)

내적 (Dot Product)

: 두 벡터 간의 크기와 방향 관계를 나타내는 연산 (두 벡터의 방향을 확인)

• Vector3.Dot(Vector3 A, Vector3 B)

외적 (Cross Product)

: 두 벡터로부터 수직인 새로운 벡터를 생성하는 연산 (두 벡터가 이루는 평면의 수직 벡터 변환) : 크기는 두 벡터로 이루어진 평면의 넓이와 관련

• Vector3.Cross(Vector3 A, Vector3 B)

반사 (Reflection) (?)

: 입사 벡터와 법선을 기준으로 반대쪽 방향 계산

• Vector3.Reflect(Vector3 inDirection, Vector3 inNormal) #inDirection : 입사 벡터, inNormal : 반사할 표면의 법선 벡터

Vector3 inDirection = new Vector3(1,-1,0).normalized;
Vector3 inNormal = Vector3.up;

Vector3 reflected = Vector3.Reflect(inDirection , inNormal);

Debug.Log($"입사각 : {inDirection}");
Debug.Log($"반사각 : {reflected}");

입사각 : (0.71, -0.71, 0.00)
반사각 : (0.71, 0.71, 0.00)

선형 보간 (Lerp)

: 두 점 사이의 부드러운 직선 경로

• Mathf.Lerp(Vector3 a,Vector3 b,float c) #a : 시작 값, b : 도착 값, c : 0~1사이 비율

구면 선형 보간 (Slerp)

: 두 점 사이의 부드러운 둥근 경로

• Quaternion.Slerp(Vector3 a, Vector3 b, float c)

행렬 (Matrix)

: 공간 변환(이동, 회전, 스케일)을 계산하는 수학 도구

역행렬 (Inverse Matrix)

: 변환을 되돌리는 행렬

회전 행렬 (Rotation Matrix)

: 회전을 행렬로 표현하여 벡터를 회전

오일러 각 (Euler Angles)

: X,Y,Z축을 기준으로 회전을 정의하는 방식

쿼터니언 (Quaternion)

: 4개의 값(x,y,z,w)로 구성된 회전 표현 방식

• Quaternion.Euler(float x,float y, float z)

public class Notation : MonoBehaviour
{
    string myName; // 카멜 표기법
    string my_name; // 스네이크 표기법

    string strMyName; // 헝가리안 표기법
    string s_myName; // 헝가리안 표기법
}

namespace

: 코드의 지역성 설정

#namespace 설정
namespace NamespaceExample{
}

#특정 namespace(NamespaceExample) 내부의 코드를 사용할 수 있도록 설정
using NamespaceExample

Class

: 속성(데이터)와 기능의 집합, 자유롭게 조합할 수 있는 하나의 데이터 구조체 -> 객체 지향 프로그래밍의 기초 클래스 안에 함수와 변수를 정의

class 클래스명 : MonoBehaviour{

}

class NPC : MonoBehaviour
{
    public string npcName;
    public int npcAge;

}
public class NPCManager : Monobehaviour
{
    void Start()
    {
        NPC npc1 = new NPC();
        npc1.npcNmae = "상인";
        npc1.npcAge = 50;
        Debug.Log(npc1.npcName);
        Debug.Log(npc1.npcAge);
    }
}

상인
50

new 연산자

: 메모리 상에 공간을 확보하고 생성한 객체를 저장

Struct

: 속성(데이터)ㅣ와 기능의 집합, 자유롭게 조합할 수 있는 하나의 데이터 구조체 -> Class와 매우 비슷하지만 메모리 상에 저장하는 방식이 다름 -> 상속을 받지 못한다

public struct Car{
    float price;
    int years;
    string name;
}

Method(함수)

: 기능 처리를 위한 작업의 단위

void 함수명()
{

}

매개 변수(Parmeter), 인자(Argument)

: 함수 실행에 필요한 추가 데이터 -> 함수 실행의 재료

 void Start()
 {
     num1 = 10;
    num2 = 5;
     AddNumber1();
    AddNumber2(20,10); //Argument(인자)
 }

 //매개변수가 없는 함수
  public void AddNumber1()
 {
     int result = num1 + num2;

 }
 //매개변수가 있는 함수
 public void AddNumber2(int num3, int num4) // Parmeter 매개변수값이 존재하는 함수
 {
     int result = num3 + num4;
 }

Variable(변수)

: 데이터를 저장할 수 있는 공간

public class ExampleVariable : MonoBehaviour
{
    // 맴버 변수
    int iNum;
    float fNum;
    double bNum;
    bool isYesNo;
    char c;
    string str;

    void Start()
    {    // 지역 변수
        int startNum;
        bool isStart;
    }
}

맴버 변수

• 필드 (Field) : 클래스나 구조체 내부에 선언된 변수를 가리킴
• 속성(Attribute) 또는 프로퍼티(Property) : 객체의 특성
• 인스턴스 변수 (Instance Variable) : 객체가 생성될 때마다 메모리에 할당되는 변수

지역 변수

• 로컬 변수 : 함수 내부에서 선언된 변수를 가리킴

스코프

• 변수의 유효 범위

자료형

: 메모리에 저장되는 데이터 형식

상수

: 변하지 않는 수(불변 값) -> 변수를 상수로 설정하는 키워드

const float PI1 = 3.1415f;
readonly float PI2 = 3.1415f;

const

• 컴파일 단계에서 값이 적용
• int, float, string, enum 등에 적용 가능
• 선언할 때 초기화가 필요

readonly

• 런타임 단계에서 값이 적용
• 모든 Type에 적용 가능
• 반드시 초기화 필요 X
• const보다 유연하다

접근 제한자

: 변수나 함수의 접근 권한을 설정 -> Access할 수 있는 보안 수준

private : 자신의 클래스만 접근 가능
protected : 자신의 클래스, 자신의 클래스를 상속받은 클래스만 접근 가능
public : 모든 클래스에서 접근 가능

클래스 접근

: ' . '을 찍어서 내부로 접근 가능

public class ScriptA
{

    public int num1 = 1; // public 맴버변수
      int num2 = 2; // private 맴버변수
    private int num3 = 3; // private 맴버변수
    [SerializeField] private int num4 = 4; // private 맴버변수
    protected int num5 = 5; //protected 맴버변수

    void Start(){
        int num6 = 6; // 지역변수
    }
}

public class ScriptB
{
    public ScriptA scriptA;

    void Start(){
        scriptA.num1 = 10;
        scriptA.num2 = 10;
        scriptA.num3 = 10;
        scriptA.num4 = 10;
        scriptA.num5 = 10;
        scriptA.num6 = 10;

    }
}

num1 = 10만 적용

필드

: 일반적인 변수

private int num1; //private 필드 : 자신의 클래스만 접근 가능
public int num2; //public 필드 : 다른 클래스에서 접근 가능

: 게임 오브젝트의 기능

Transform

: 게임 오브젝트의 위치, 회전, 크기 정보

Mesh Filter

:메쉬 필터에는 게임 오브젝트의 모양(Mesh)를 담을 수 있다.

Mesh Renderer

: 게임 오브젝트의 모양을 그리는 컴포넌트

Capsule Collider

Box Collider

RigidBody

유니티 3D에서 제공하는 기본 도형

Vertext(점), Edge(선), Polygon(삼각형)

Low 폴리와 High 폴리

: Polygon 수에 비례하는 퀄리티 -> Polygon수는 퀄리티와 최적화의 영향을 끼침

Empty GameObject

: 게임 오브젝트들의 그룹화 또는 스크립트를 실행하는 용도

Prefab

: Scene에 있는 Object를 Asset으로 포장하는 것

Prefab의 종류

• Origin Prefab : 원본 프리팹
• Varient Prefab : 원본 프리팹을 상속받는 프리팹
• Nested Prefab : 프리팹 안에 프리팹이 있는 구조

Pivot : 선택한 오브젝트의 기준 축

Center : 선택한 오브젝트의 자식오브젝트까지 포함한 중심 축

Local 좌표계, Global 좌표계

Local : 오브젝트 기준에서의 좌표

Global : World에서 오브젝트의 좌표

: Log를 확인할 수 있는 창 (단축키 : Ctrl + Shift + c)

Unity Editor Play 버튼 클릭 시 콘솔 창에서 Log, LogWarning, LogError를 확인할 수 있음

: 상세정보 창 (선택한 오브젝트 또는 Asset의 상세정보)

오브젝트 활성화 / 비활성화

: 오브젝트의 존재 상태를 키고 끄는 것 (단축키 : Alt + Shift + A)

오브젝트의 이름

Static 설정(정적 게임 오브젝트 설정)

: 무엇인가를 계산하기 위해 "움직이지 않는 게임 오브젝트" 설정

• Nothing : 어떠한 Static옵션도 적용 X
• Everything : 모든 Static 옵션을 활성화
• Contribute GI : 오브젝트가 라이트맵을 생성하고 사용하는데 필요한 정보 제공
• Occluder Static : 카메라에서 보이지 않는 오브젝트의 렌더링 방지
• Occludee Static : 해당 오브젝트가 다른 오브젝트에 의해 가려질 수 있음을 의미(즉, 다른 오브젝트에 의해 가려져 있을 때 렌더링에서 제외되어 성능 향상)
• Navigation Static : AI캐릭터가 이동할 수 있는 경로 계산
• Off Mesh Link Generation : Navigation system에서 Mesh간의 연결 링크를 자동으로 생성하도록 설정
• Reflection Probe Static : Reflection Probe에 의해 반사되는 환경을 계산(실시간으로 빛의 반사를 계산하여 환경의 실감나는 표현 도움)

Tag

: 오브젝트의 별명, 오브젝트를 식별할 수 있음

Layer

: 오브젝트 그룹, 오브젝트 소속

/>

: 리소스 관리창 (프로젝트의 파일 목록)

Asset : 유니티에서 사용하는 프로젝트 파일의 기본 단위

Project View Layout 변경

슬라이더 : Two Column Layout일 경우, 아이콘 크기 조절

프로젝트 폴더 생성 및 정리

: 자기가 편한데로 수정 가능 (협업일 경우, 통일)

Asset의 타입으로 검색

: 배치된 오브젝트들의 목록 (계층 구조(계단식 구조, 순서가 있다))

'+' 버튼 클릭 또는 마우스 우클릭 후 오브젝트 생성

• 검색 기능

계층 구조

: 순서, 부모 - 자식 관계가 있는 구조

: 실행 시 화면에 보이는 결과물 화면

Game View 해상도 설정

• HD(720p) : High Definition = 1280 * 720

• FHD(1080p) : Full High Definition = 1920 * 1080

• QHD(1440p) : Quad High Definition = 2560 * 1440

• UWQHD(1440p) : Ultra Wide Quad High Definition = 3440 * 1440

• UHD(2160p) : Ultra High Definition = 3840 * 2160

  • 2K = 2048 * 1080
  • 4k = 4096 * 2160
  • 8K = 8192 * 4320

Game View State

: 실행되고 있는 현재 성능 상태 표시

게임 내 Game View 종류

: 카메라 위치에 따른다.

• 1인칭 뷰
• 3인칭 뷰
• 탑다운 뷰
• 쿼터 뷰

: 포커스 기능

Snap

: 오브젝트의 트랜스 값을 떨어지게 변경 (Ctrl + 이동)

Vertex Snap

: 오브젝트를 모서리에 붙이는 기능 (V + 이동)

Surface Snap

: 평평한 면에 붙이는 기능 ( Ctrl + Shift + 이동)

Scene : 개발자가 구성하는 하나의 월드

Fly Through : Scene 공간을 날아다니는 기능

• 이동 : W, A , S , D + 마우스 오른쪽 클릭

• 가속 : 이동 중 + Shift

• 확대 : 마우스 휠

  
  

  

Tool Bar : 자주 사용하는 도구 상자 (왼쪽부터 4개를 주로 사용)

• Hand Tool(단축키 - Q) : 화면을 잡고 움직이는 기능

• Move Tool(단축키 - W) : 오브젝트의 위치를 조작

• Rotate Tool(단축키 - E) : 오브젝트의 회전을 조작

• Scale Tool(단축키 - R) : 오브젝트의 크기를 조작

Gizmo : Scene의 나침반

• Z축 : 앞쪽
• Y축 : 위쪽
• X축 : 오른쪽

Scene 렌더링 방식

Perspective : 원근법이 적용된 시점

Isometric : 원근법이 적용되지 않은 시점(Orthographic)

특정 window가 없어졌을 경우, window -> General -> 해당 레이아웃