Grid의 셀 기준 좌표

Grid에서의 셀 좌표(Cell Position)은 정수값(Vector3Int)로 표현되며, 이는 셀의 상대적인 위치를 의미한다. 예를 들어 (0, 0, 0)좌표는 Grid의 중심 셀이고, (1, 0, 0)은 그 오른쪽 셀을 의미한다. Z 값은 대부분 0으로 두며, 동일 위치의 다른 타일 레이어 또는 타일 쌓기(stack) 등에 사용될 수 있다.

셀 -> 월드 위치 변환

• Grid는 셀 좌표를 월드 공간 좌표로 변환할 수 있다. 즉, (0, 0, 0) 셀은 Grid의 Transform 위치와 정렬되어 있고, (1, 0, 0)은 그 오른쪽에 한 칸 이동한 셀이다.
• 각 셀의 실제 크기는 Grid 컴포넌트의 Cell Size 값에 따라 달라진다 (기본값은 1, 1, 1)

셀 레이아웃(Cell Layout)

Grid에는 셀의 형태를 정의하는 Cell Layout 옵션이 있다.

• Rectangle: 일반적인 사각형 타일(2D 게임에서 가장 흔함)
• Hexagon: 육각형 타일(벌집 구조나 전략 게임)
• Isometric: 등각 뷰 타일(쿼터뷰 스타일)
• Isometric Z As Y: Z축을 Y로 해석해 타일을 위로 쌓을 수 있음 각 셀 레이아웃은 셀 간 배치 방식과 모양에 영향을 준다.

셀 사이즈(Cell Size)

이건 말 그대로 각 셀의 월드 상 크기이다. 기본은 (1, 1, 1)이고, 만약 타일 하나가 더 크거나 작게 보이도록 하려면 이 값을 조정하면 된다.

셀 간격(Cell Gap)

• 타일 사이에 얼마나 간격을 둘 것인지를 설정하는 속성 셀 크기 보다 절대값이 큰 음수를 입력하면 Unity는 셀 크기에 맞춰 절댓값을 자동으로 변경한다. 예를 들어, 셀 크기가 (1, 1, 0)이고 셀 간격이 (-2, -2, 0)으로 설정된 경우, 에디터는 셀 간격 값을 (-1, -1, 0)으로 자동 변경한다.
• 기본값은 (0,0,0)이다. 즉, 셀과 셀 사이에 간격이 없이 붙어 있다.
• 타일이 겹치거나 너무 빽빽해 보일 때, 이 값을 이용해 간격을 조절할 수 있다.

Cell Sizzle

셀 좌표의 축을 변경하거나 뒤집는 기능

• Siwzzle은 셀 좌표의 X, Y, Z 순서를 바꾸거나 반전시켜서 Tilemap이 셀 좌표를 다르게 해석하게 만든다.

• 3D 게임에서 z축 방향으로 타일을 쌓을 때
• 타일맵이 특정 방향으로 정렬되어 있어야 할 때
• 좌표계를 변형시켜서 다른 계산 방식과 맞출 때

일반적인 2D 게임에서는 대부분 XYZ 그대로 쓰지만, 3D 환경 또는 특수한 정렬 구조를 만들고 싶을 때 아주 유용해요.

타일맵 위치 계산 시 주의할 점:

• Tilemap.WorldToCell(worldPosition): 월드 좌표를 셀 좌표로 변환
• Tilemap.CellToWorld(cellPosition): 셀 좌표를 월드 좌표로 변환 주의: 이때 변환되는 위치는 타일의 기준점(Pivot)이 아닌 셀 기준 좌표이다. 따라서 타일의 실제 중심에 뭔가를 배치하려면, Offset값을 고려해야 한다.

• XY: Unity는 타일을 XY 평면을 따라 배치한다.
• XZ: Unity는 타일을 XZ 평면을 따라 배치합니다.
• YX: Unity는 타일을 YX 평면을 따라 배치합니다.
• YZ: Unity는 타일을 YZ 평면을 따라 배치합니다.
• ZX: Unity는 타일을 ZX 평면을 따라 배치합니다.
• ZY: Unity는 타일을 ZY 평면을 따라 배치합니다.
• Custom: 아래의 사용자 정의 방향 설정을 활성화하려면 이 옵션을 선택하세요.

Offset: 사용자 지정 방향의 위치 오프셋을 설정합니다. 이 옵션은 타일맵의 방향을 사용자 지정 으로 설정한 경우에만 사용할 수 있습니다 . Rotation: 사용자 지정 방향의 회전을 설정합니다. 이 옵션은 타일맵의 방향을 사용자 지정 으로 설정한 경우에만 사용할 수 있습니다 . Scale:사용자 지정 방향의 크기를 설정합니다. 이 옵션은 타일맵의 방향을 사용자 지정 으로 설정한 경우에만 사용할 수 있습니다 . Info:이것을 확장하면 타일맵에 있는 자산을 볼 수 있습니다.

• Tiles: 타일맵에 있는 타일 자산 목록을 표시합니다 .
• Sprites: 타일맵에 있는 스프라이트 목록을 표시합니다.

TcpClient는 TCP 소켓 통신을 쉽게 다루기 위한 C#의 고수준 API 클래스이다.

• 내부적으로 Socket 클래스를 감싸고 있고, IP 주소와 포트에 연결하고, 데이터를 스트림으로 읽고 쓸 수 있도록 도와준다.

  • 정확히는 System.Net.Sockets.TcpClient이다.

  생성자

  new TcpClient(SERVER_ADDRESS, SERVER_PORT)

  • 이 생성자는 TCP 클라이언트를 생성하면서 즉시 서버에 연결(connect)한다.

    new TcpClient("127.0.0.1", 1234)

  • "127.0.0.1" -> 연결할 서버의 IP주소 (로컬호스트)
  • 1234 -> 연결할 포트 번호

  • 이 값들은 TcpClient의 내부 Socket 필드에 저장되고, 연결이 시도된다.

인자들은 어디에 할당될까?

소스 코드를 보면 TcpClient는 내부적으로 Socket 객체를 생성하고, Connect() 메서드를 호출하여 IPAddress와 port로 연결을 시도한다.

// 내부적으로 이런 식으로 처리됨
_socket = new Socket(AddressFamily.InterNetwork, SocketType.Stream, ProtocolType.Tcp);
_socket.Connect(serverIPAddress, serverPort);

즉, 우리가 넘겨준 IP와 포트는 Socket.Connect()의 인자로 전달되어 바로 TCP 연결을 수행한다.

두 번째 용법의 using은 IDisopsable 인터페이스를 구현한 객체를 자동으로 Dispose() 해주는 문법이다.

• 용어로는 이것을 using 선언문(using declaration) 또는 using 구문 (using statement)라고 부른다.

https://storycompiler.tistory.com/223

System.Enum.GetValues(Type enumType)

• 주어진 enum 타입의 모든 정의된 값을 배열로 반환한다. 반환 타입은 Array, 그래서 반복문에 사용 가능하다.

사용 목적

• 버튼, 필터링 등 UI 생성 시 enum 기반 자동화에 매우 유용하다.
• 드롭다운 자동 생성이나 툴 개발에도 엄청 자주 쓴다.

예시

public enum ItemCategory
{
    Kitchen,
    Interior,
    Exterior
}

foreach (ItemCategory category in System.Enum.GetValues(typeof(ItemCategory)))

이럴 때 :

System.Enum.GetValues(typeof(ItemCategory))

→ 반환결과 :

Array: [ItemCategory.Kitchen, ItemCategory.Interior, ItemCategory.Exterior]

따라서 foreach 루프에서 category는 각각 순서대로 저 값을 가진다.

기타 팁: Enum.GetNames()

• Enum.GetNames(typeof(ItemCategory)) → ["Kitchen", "Interior", "Exterior"] 라는 문자열 배열 반환

 var existingItem = items.FirstOrDefault(i => i.itemData == itemData);

이 구문은 리스트에서 조건에 처음으로 부합하는 항목을 찾아 반환한다. 단, 없으면 null을 반환한다. (default값이기 때문이다)

함수 정의

T FirstOrDefault<T>(Func<T, bool> predicate)

• First(...) 와 달리, 조건을 만족하는 항목이 없어도 예외를 발생시키지 않음
• First(...) 는 조건에 맞는 항목이 없으면 InvalidOperationException 발생시킴

예시 코드

var existingItem = items.FirstOrDefault(i => i.itemData == itemData);

• items 리스트를 순회하면서 i.itemData == itemData 조건을 만족하는 첫 번째 아이템을 찾아서 existingItem에 저장
• 찾지 못하면 existingItem은 null이 됨

Where는 LINQ 메서드 중 하나로, 컬렉션(리스트 등)에서 특정 조건을 만족하는 요소들만 선택하는 필터링 함수이다.

items.Where(조건식)

→ 조건식을 만족하는 요소들만 "지연 평가"된 컬렉션으로 반환

예시 코드

    public List<InventoryItem> GetItemsByCategory(ItemCategory category) 
    {
        return items.Where(i => i.itemData.Category == category).ToList();
    }

이건 이렇게 해석할 수 있다:

"items 리스트에서 itemData.Category가 매개변수인 category와 같은 모든 InventoryItem 객체들을 추려라"

i는 리스트의 각 요소 (즉, InventoryItem)

i.itemData.Category → 아이템의 분류

== category → 매개변수로 받은 카테고리와 일치 여부 확인

결과적으로 조건에 맞는 요소만 필터링해서 반환된다.

.ToList()

• Where(...)의 반환형은 IEnumerable이다. Where(...)는 List가 아닌 IEnumerable 을 반환하기 때문에, 필터링된 결과를 .ToList()를 통해 리스트로 변환해준다.

즉, 필터링된 결과는 아직 진짜 리스트로 materialize(구현)된 게 아님

namespace System
{
    public abstract class Enum : ValueType
}

즉, 모든 enum 타입의 부모 클래스이다. C#에서 열거형(enum)을 만들면 자동으로 System.Enum을 상속받는다.

예시

public enum ItemCategory
{
    Kitchen,
    Interior,
    Exterior
}

→ 이 타입은 내부적으로 System.Enum을 기반으로 만들어진 값 형식이다. 즉,

ItemCategory myCategory = ItemCategory.Kitchen;

System.Enum e = myCategory; 

요약

사용 예시(SubCategory)

이 줄은 추상 클래스에서:

public virtual System.Enum SubCategory => null;

이건 "이 아이템이 속한 하위 카테고리를 리턴하게 하고 싶다, 그런데 그 하위 카테고리는 아이템마다 enum이 다를 수도 있으니까, 그냥 Enum 타입으로 뭉뚱그리자"는 전략이다.

예시 시나리오

public enum KitchenSubCategory { Stove, Sink, Refrigerator }
public enum InteriorSubCategory { Table, Chair, Lamp }

public class KitchenItemData : ItemData
{
    public KitchenSubCategory subCategory;
    public override ItemCategory Category => ItemCategory.Kitchen;
    public override System.Enum SubCategory => subCategory;
}

public class InteriorItemData : ItemData
{
    public InteriorSubCategory subCategory;
    public override ItemCategory Category => ItemCategory.Interior;
    public override System.Enum SubCategory => subCategory;
}

이러면 서브카테고리 enum 타입이 다 다르지만, 부모 클래스에서는 공통적으로 Enum 타입으로 처리할 수 있다!

주의할 점

• System.Enum은 abstract class라서 직접 인스턴스를 만들 수 없다 따라서 실제 값은 반드시 enum 형식 중 하나여야 한다.

의미

이 클래스를 Unity 인스펙터에 표시할 수 있게 만들어주는 마커 역할이다.

기본적으로 C# 클래스는 Unity의 인스펙터에 보이지 않는다 하지만 [System.Serializable]을 붙이면, Unity는 이 클래스를 "직렬화(serialize) 가능"하다고 판단하고 이 클래스를 필드로 가지고 있는 MonoBehaviour나 ScriptableObject에서 표시해준다.

예제

public class Inventory : MonoBehaviour
{
    public InventoryItem item;
}

• InventoryItem이 [System.Serializable]이 없다면 item은 인스펙터에 표시 X

• [System.Serializable]이 붙어 있으면 item의 itemData, quantity도 인스펙터에 표시

결론

[System.Serializable] 은 클래스(혹은 struct)를 인스펙터에서 노출 가능하게 해준다. 인스펙터에 표시되려면 필드 타입이 직렬화 가능해야 하고, 필드 자체는 public이거나 [SerializeField]로 선언되어야 한다.

• 이름 없는 함수(무명 함수)를 아주 간결하게 표현하는 문법이다. 코드를 더 간결하고 직관적으로 만들기 위해 쓴다.

기본 구조

(매개변수들) => 식 또는 {코드블록}

형태

(x,y) => x+y : 하나의 식이면 { } 생략 가능하다. x => x+4 : 매개변수가 1개이면 () 생략 가능하다. (x, y) => { return x+y; } 코드가 여러줄이면 { }와 return 필요

클로저

람다식 내부에서, 외부에 선언된 변수를 참조하거나 수정할 수 있다. 이 때, 람다식은 해당 외부변수를 자신과 함께 기억하고 다니는데, 이를 클로저(closure)라고 한다.

반복문과 클로저 문제

for문 안에서 람다를 만들 때, 외부 변수를 캡처(기억)하는 특성 떄문에 모든 람다가 같은 변수를 공유하는 문제가 발생 가능하다. 예제

List<Action> actions = new List<Action>();
for(int i = 0; i<3; i++)
{
    actions.Add() => Console.WriteLine(i)); 
}
foreach(var action in actions)
{
    action();
}

결과(예상vs실제)

• 기대하는 출력: 0\n 1\n 2\n
• 실제 출력: 3\n 3\n 3\n

왜 이런 결과가 나왔을까? for문의 i는 하나의 변수이다. 람다식이 i를 캡처할 때, i의 현재 값을 복사하는 것이 아니라, i 자체를 참조한다. for문이 끝난 후 i는 3이 되어 있고, 모든 람다가 그 3을 바라본다.

해결 방법 i를 복사한 새로운 지역변수를 만들어서 캡처하면 된다.

for(int i = 0; i<3; i++)
{
    int temp = i; // 복사
    actions.Add(()=> Console.WriteLine(temp));
}
foreach(var action in actions) { action(); }

• temp는 각 반복마다 새로 만들어진 지역변수이다.
• 그래서 각각 람다가 자신만의 temp를 캡처하게 된다.

Resources 클래스는 런타임 중 Resources 폴더에 위치한 에셋을 동적으로 불러오는 데 사용된다.

• Resources.Load, Resources.LoadAsync 등을 통해 에셋 로드가 가능하다.
• 에디터에서는 Resources.FindObjectOfTypeAll을 통해 에셋 검색이 가능하다.
• Resources 폴더는 Assets 내부 어디에서나 위치할 수 있으며, 여러 개 존재해도 된다.

⚠️주의할 점 Resources 폴더는 직접 생성해야 하며, 새 프로젝트에 자동으로 포함되지 않는다.

Resources.Load 사용법

기본 문법

public static Object Load(string path);
public static T Load<T>(string path) where T : Object;

• 경로는 Resources 폴더를 기준으로 작성하면 된다.
• 확장자는 생략한다. (.png, .prefab 등)
• 대소문자 구분이 없다.
• 슬래시(/)로 하위 폴더를 접근할 수 있다.

예제

GameObject go = Resources.Load<GameObject>("Prefabs/MyPrefab");
Texture2D tex = Resources.Load<Texture2D>("Textures/Glass");
AudioClip clip = Resources.Load<AudioClip>("Audio/Explosion");

가급적이면 제네릭을 사용하는 것이 타입 안정성과 가독성 측면에서 더 좋다.

Resources.Load의 장단점

장점

• 인스펙터에 의존하지 않고 동적으로 에셋을 로드 가능하다.

• 상황에 따라 편리하다.

  <상황 예시>

• 스크립트에서 에셋을 동적으로 선택해야 할 때*: 캐릭터가 입는 옷 종류가 20가지고, 런타임에 선택된 옷에 따라 텍스처를 바꿔야 한다면? Resources.Load("Clothes/" + selectedName)처럼 문자열만으로 동적으로 불러올 수 있다.)

단점

• Resources 폴더의 모든 에셋이 빌드에 포함 -> 앱 용량 증가
• 에셋 주소 하드코딩 -> 유지보수 어려움
• 메모리 관리가 어려움 -> 필요 없어진 에셋은 직접 언로드 필요

메모리 관리: Resources.UnloadUnusedAssets

메모리에서 더 이상 참조되지 않는 에셋들을 언로드(제거)해주는 함수이다. 비동기 함수이므로 yield return과 함께 쓰는 게 일반적이다.

yield return Resources.UnloadUnusedAssets();

• Resources.Load()를 했지만 어떤 GameObject나 ScriptableObject도 실제로 참조한 적이 없다면, Unity는 “이 리소스가 아직 사용 중일 수 있음”으로 판단해서 메모리에서 유지한다.
• 언로드 대상이 되려면, Load()로 한 번 이상 로드되었고 그걸 참조하던 모든 객체가 Destroy되거나 참조를 해제해야 한다.

주요 메서드 정리

전체 예제

using UnityEngine;

public class ExampleClass : MonoBehaviour
{
    void Start()
    {
        GameObject go = GameObject.CreatePrimitive(PrimitiveType.Plane);
        Renderer rend = go.GetComponent<Renderer>();
        rend.material.mainTexture = Resources.Load("glass") as Texture;
    }
}

"glass"는 Resources 폴더 내 텍스처이며, 형변환 없이 Resources.Load("glass")처럼 제네릭으로 사용하는 게 더 안전하다.

사용하려면 using UnityEngine.Serialization; 지시문을 추가해야 한다.

• Unity에서는 필드 이름이 변경되면 기존에 저장된 직렬화 데이터와 매칭되지 않아, 해당 값이 초기화되는 문제가 발생할 수 있다. 이때 FormerlySerializedAs 속성을 사용하면 이전 이름과의 연결을 유지하여 데이터를 잃지 않도록 해준다.

다음과 같은 클래스가 있다고 가정해보겠다.

using UnityEngine;

public class Enemy : MonoBehaviour
{
    public int hitpoints; // 체력
}

FormerlySerializedAs(oldName) 속성을 사용하면 직렬화된 값을 잃지 않고 필드의 이름을 바꿀 수 있다.

예를 들어, 아래와 같이 기존에 hitpoints라는 이름의 필드를 health로 변경하면서 FormerlySerializedAs("hitpoints")를 붙이면, 기존에 저장된 hitpoints 값이 health에 유지된다.

using UnityEngine;
using UnityEngine.Serialization;

public class Enemy : MonoBehaviour
{
    [FormerlySerializedAs("hitpoints")]
    public int health;
}

Unity의 직렬화 관련 참고사항

Unity는 기본적으로 public 필드를 직렬화하여 인스펙터에 표시하고 저장한다. private 또는 protected 필드를 직렬화하려면 [SerializeField] 속성을 사용해야 한다.

FormerlySerializedAs의 장점 요약

• 필드 이름 변경 시에도 기존에 저장된 데이터를 유지할 수 있다.
• 리팩토링 시 유용하다. 코드의 가독성이나 의미를 개선하기 위해 변수명을 변경하더라도, 데이터를 잃지 않게 도와준다.

Delegate란?

• Delegate는 메서드를 변수처럼 담을 수 있게 해주는 타입이다. 쉽게 말해, 메서드를 데이터처럼 다루게 해주는 기능이다.

정의하는 법

public delegate void MyDelegate(int number);

• delegate는 마치 메서드 정의처럼 생겼고, 그걸 통해 이 delegate에는 어떤 형태(시그니처)의 메서드만 들어올 수 있는지를 정의해주는 것이다.
• 이 MyDelegate 타입에는 매개변수가 int 하나고, 반환값이 void인 메서드만 담을 수 있다. 즉, MyDelegate는 일종의 메서드 틀(형식) 이라고 생각하면 된다.

<사용하는 법>

public delegate void MyDelegate();

void PrintA() => Debug.Log("A"); 
void PrintB() => Debug.Log("B");

void Start()
{
    MyDelegate myFunc;

    myFunc = PrintA; // 마치 값을 대입하듯 메서드를 담는다
    myFunc();        // A 출력

    myFunc = PrintB; // 다른 메서드로 교체 가능
    myFunc();        // B 출력
}

delegate 변수는 해당 delegate와 시그니처가 같은 메서드들을 값처럼 대입하고 바꿀 수 있다. 비유하자면 delegate는 메서드를 넣을 수 있는 틀 같은 것이다. 틀에 맞는 모양의 메서드만 들어갈 수 있다.

Delegate를 왜 사용할까?

• 한 코드가 다른 코드에 너무 의존하지 않게 만든다.
• • Deleate를 사용하지 않은 예시**

public class GameManager : MonoBehaviour
{
    public UIManager uiManager;
    public SoundManager soundManager;

    public void PlayerDied()
    {
        uiManager.ShowGameOver();       // 직접 호출
        soundManager.PlayDeathSound();  // 직접 호출
    }
}

- 해당 코드는 GameManager가 UIManager와 SoundManager를 직접 알고 있어야 하기 때문에, 결합도가 높은 상태이다. UIManager나 SoundManager의 내부 구현이 바뀌면 GameManager도 고쳐야 하는 문제가 발생한다.

• 또한 테스트나 재사용이 어렵고, 수정이 많을 수록 코드가 복잡해진다.

Delegate를 사용한 예시

public class GameManager : MonoBehaviour
{
    public delegate void PlayerDeathHandler();
    public event PlayerDeathHandler OnPlayerDied;

    public void PlayerDied()
    {
        OnPlayerDied?.Invoke();  // 외부에 알림만 함
    }
}

public class UIManager : MonoBehaviour
{
    public GameManager gameManager;

    void Start()
    {
        gameManager.OnPlayerDied += ShowGameOver; // 이벤트에 콜백 등록
    }

    void ShowGameOver()
    {
        Debug.Log("Game Over UI 표시");
        // 실제 UI 처리
    }
}

public class SoundManager : MonoBehaviour
{
    public GameManager gameManager;

    void Start()
    {
        gameManager.OnPlayerDied += PlayDeathSound;
    }

    void PlayDeathSound()
    {
        Debug.Log("죽음 사운드 재생");
        // 실제 사운드 재생
    }
}

• 여러 시스템을 하나의 이벤트로 연결 가능하다 (Delegate는 여러 메서드를 한 번에 연결하고 한 번에 실행할 수 있는 구조다.)
• 콜백 패턴 구현 가능 (비동기 작업 완료 후 처리 등)
• GameManager가 모든 것을 직접 알고 처리하지 않고, "플레이어가 죽었을 때" 일어날 일을 외부에서 등록해서 분리시켜주는 거다.

Delegate 선언 및 사용법

public delegate void OnClickAction;

public class ButtonExample : MonoBehaviour
{
    public OnClickAction onClick;

    void Start()
    {
        onClick = PrintMessage; // 메서드 대입
        onClick();              // 실행
    }

    void PrintMessage()
    {
        Debug.Log("버튼이 눌렸습니다!");
    }
}

익명 메서드 (Anonymous Method)

익명 메서드는 이름 없이 정의된 일회성 함수이다. 주로 한 번만 사용할 간단한 작업을 정의할 때 유용하다.

using UnityEngine;

public class Test : MonoBehaviour
{
    delegate void MyDelegate();

    void Start()
    {
        MyDelegate onClick = delegate { Debug.Log("익명 메서드 실행!"); };
        onClick();
    }
}

• 너무 복잡한 로직을 익명 메서드 안에 넣으면 가독성 저하가 생긴다.
• 람다식을 사용하면 더 간결하게 같은 로직을 작성할 수 있다. 예를 들어, 위의 예제를 람다식으로 바꾸면 다음과 같이 작성할 수 있다.

  using UnityEngine;
  

public class Test : MonoBehaviour { // 델리게이트 타입 선언 delegate void MyDelegate();

void Start()
{
    // 람다식으로 델리게이트 할당
    MyDelegate onClick = () => { Debug.Log("람다식 실행!"); };

    // 호출
    onClick();
}

}

이렇게 하면 코드가 더 짧고 읽기 쉬워진다. 람다는 간단한 함수 표현식을 더욱 직관적으로 작성할 수 있도록 돕는 문법적 요소이다.

## Action, Func, Predicate
얘네들은 델리게이트의 특정 형태(제네릭 버전)이다.
- Action, Func, Predicate는 자주 쓰이는 형태를 미리 제네릭으로 만들어둔 대표 delegate 타입이라고 보면 된다.

### Action
Action은 반환값이 없는(void) 메서드를 담을 수 있는 제네릭 delegate 타입이다.
즉, **어떤 동작만 수행하고, 결과를 돌려주지 않아도 되는 경우**에 주로 사용된다.
**예시**

```cs
Action sayHello = () => Debug.Log("Hello!");
sayHello();

Action<int> printScore = score => Debug.Log($"Score: {score}");
printScore(100); // 출력: Score: 100

Func

Func는 반환값이 있는 delegate 타입이다. 가장 마지막 제네릭 타입이 반환형이고, 그 앞에 오는 타입들은 매개변수 타입이다. 예시

Func<int, int> square = x => x * x;
Debug.Log(square(4)); // 출력: 16

Func<string, int> getLength = str => str.Length;
Debug.Log(getLength("Unity")); // 출력: 5

Predicate

Predicate는 반환형이 bool이고, 매개변수가 1개인 delegate 타입이다. 즉, 조건 판별용 함수를 담을 때 사용한다. 예시

Predicate<int> isEven = x => x % 2 == 0;
Debug.Log(isEven(10)); // 출력: True

event 한정자

event는 delegate 앞에 붙여 외부에서 직접 이벤트를 호출하지 못하게 막고, 해당 이벤트가 발생하는 시점을 해당 클래스로 제한하는 역할을 한다.

• 클래스 외부에서 직접 이벤트를 변경하거나 호출할 수 없게 만든다. 이벤트를 외부에서 +=(구독) 또는 -=(구독 해지) 방식으로만 조작할 수 있으며, 직접 호출할 수는 없다.

  public class HealthSystem
  {
    // 이벤트 선언
    public event Action OnDeath;
  
    public void Die()
    {
        Debug.Log("죽었습니다.");
        OnDeath?.Invoke(); // 이벤트를 내부에서만 발생시킴. 외부에서는 이벤트를 실행할 수 없음.
    }
  }
  
  

event의 핵심은 외부에서 이벤트를 구독하고 해지할 수 있지만, 이벤트를 발동시키는 책임은 해당 클래스로 제한된다는 점이다. 이로 인해 외부에서 OnDeath = null;처럼 이벤트를 null로 변경하거나 직접 Invoke를 호출하는 일이 불가능하다. 

##   Multicase Delegate(멀티캐스트)
  여러 메서드를 덧붙여 하나의 델리게이트로 묶는 방법을 제공한다. 
- += 연산자를 통해 여러 개의 메서드를 체인처럼 등록할 수 있으며, 
델리게이트가 호출되면 등록된 메서드들이 차례대로 실행된다.



```cs
public delegate void Notify();

Notify notify = () => Debug.Log("A");
notify += () => Debug.Log("B");

notify(); // 출력: A\nB

• notify()를 호출하면 A와 B가 차례대로 출력된다. 즉, 델리게이트에 등록된 여러 메서드들이 순차적으로 실행된다.
• notify -= () => Debug.Log("A");는 동작하지 않는다. 이유는 notify에 등록된 람다 표현식은 새로운 참조로 생성되기 때문에, 동일한 코드라고 하더라도 메모리 상에서 다른 객체로 취급된다.

이처럼 델리게이트는 여러 메서드를 등록하고 호출할 수 있기 때문에 멀티캐스트 델리게이트라고 불린다.

-> 메서드를 따로 정의해서 추가/제거하는 것이 안전하다.

void PrintA() => Debug.Log("A");

Notify notify = PrintA;  // 메서드를 델리게이트에 직접 할당
notify += PrintA;        // 메서드를 덧붙임
notify -= PrintA;        // 메서드를 안전하게 제거

Unity에서 Delegate를 자주 쓰는 곳

1. UI 버튼 클릭 처리
   • UI 버튼의 클릭 이벤트를 Delegate로 처리하여 다양한 행동을 유연하게 연결할 수 있다.
   2. 애니메이션/효과 완료 후 동작 처리
   • 애니메이션이나 효과가 끝났을 때 특정 작업을 수행하는 데 Delegate를 활용한다.
   3. 게임 상태 변화 알림 (HP 0, 클리어 등)
   • 게임 상태(예: HP 0, 클리어 등)가 변화할 때 필요한 알림을 Delegate로 처리하여 게임의 흐름을 관리한다.
   4. 씬 전환/로드 완료 콜백
   • 씬 전환이나 로드 완료 후 실행할 작업을 Delegate를 이용해 설정할 수 있다.

🔚결론

• Delegate는 메서드를 변수처럼 다루는 방법이다. 이를 통해 메서드를 동적으로 연결하고 실행할 수 있다.

• Delegate는 다양한 상황에서 효율적이고 유연한 이벤트 처리를 가능하게 합니다. 특히 Action, Func, Predicate는 자주 사용되는 Delegate 유형이다.

• Event는 Delegate에 대한 안전장치로, 외부에서 Delegate를 잘못 수정하거나 호출하는 것을 방지해준다.

• Unity에서는 콜백 구조나 비동기 처리에 필수적인 개념으로, Delegate를 적극적으로 활용하여 유연한 코드 구조를 만들 수 있다.

팁

• del()로 직접 호출할 수도 있지만, del.Invoke()로 실행하는 것을 권장한다. del?.Invoke()로 호출하면 null일 때, 안전하게 null 체크를 할 수 있다.
• 또한 del()로 호출하면 이것이 그냥 함수인지, delegate인지 헷갈릴 수 있다. 반면, Invoke로 호출하면 알기가 쉽다.

• 거스름돈(센트 단위)을 입력받아, 동전의 개수를 최소로 거슬러주는 문제이다.

사용할 수 있는 동전은 다음과 같다:

쿼터(Quarter): 0.25달러 → 25센트

다임(Dime): 0.10달러 → 10센트

니켈(Nickel): 0.05달러 → 5센트

페니(Penny): 0.01달러 → 1센트

동전의 개수를 최소화하려면 가능한 큰 단위의 동전부터 많이 사용하는 것이 유리하다. 따라서 가장 큰 단위부터 차례대로 해당 동전으로 거슬러줄 수 있는 개수를 계산하고, 나눠준 뒤 남은 금액을 저장하여 다음 단위 동전에 대해 같은 과정을 반복한다.

using System;

class Baekjoon
{
    static void Main(string[] args)
    {
        int t = int.Parse(Console.ReadLine());

        while (t>0)
        {
            t--;
            int c = int.Parse(Console.ReadLine());

            int quarter = c / 25;
            c %= 25;
            int dime = c / 10;
            c %= 10;
            int nickel = c / 5;
            c %= 5;
            int penny = c;

            Console.WriteLine($"{quarter} {dime} {nickel} {penny}");
        }
    }
}

혹시 틀린 부분이 있다면 편하게 댓글 달아주세요 :) 질문도 언제든지 환영입니다!

• C#에서 코드의 재사용성과 유연성을 향상해주는 도구이다.
• 데이터 형식을 일반화하여 재사용 가능한 코드를 작성할 수 있게 해준다.
• 제네릭을 사용하면 다양한 형식의 데이터를 처리하는 메서드와 클래스를 작성할 수 있으며, 컴파일 시점에서 형식 안정성(type safety)를 보장해준다.

제네릭은 언제 사용될까?

1. 여러 데이터 형식에 대해 동일한 로직을 적용해야 할 때
2. 컬렉션 타입에서 다양한 데이터 형식을 저장하고 관리해야 할 때
3. 데이터 형식에 따라 다른 연산을 수행해야 할 때

제네릭 사용법

<제네릭 메서드>

public class Utility
{
    public static void Swap<T>(ref T a, ref T b)
    {
        T temp = a;
        a = b;
        b = temp;
    }
}

// 사용 예시
int a = 10, b = 20;
Utility.Swap(ref a, ref b);

<제네릭 클래스>

public class Box<T>
{
    private T value;

    public void SetValue(T val) => value = val;
    public T GetValue() => value;
}

// 사용 예시
Box<int> intBox = new Box<int>();
intBox.SetValue(123);
int result = intBox.GetValue();

.NET의 제네릭 클래스들

.NET Framework에는 다양한 제네릭 클래스들이 포함되어 있다. 특히 System.Collections.Generic 네임스페이스에 있는 모든 컬렉션 관련 클래스들은 제네릭 타입이다.

• 예시: List, Dictionary<TKey, TValue>, Queue, Stack, LinkedList

제네릭 제약 조건(Generic Constraints)

• 제네릭의 제약 조건은 제네릭 타입 매개변수 T에 적용되는 제한사항이다.
• 이를 통해 특정 클래스나 인터페이스를 상속/구현하도록 강제하거나, 값 형식만 허용, 기본 생성자 요구 등의 제약을 설정할 수 있다.

<문법 예시>

public class MyClass<T> where T : 제약조건
{
    // 클래스 내용
}

public void MyMethod<T>(T param) where T : 제약조건
{
    // 메서드 내용
}

제약 조건 종류

🔎 비관리 형식(unmanaged)이란? 값 형식이며 내부 필드들까지 모두 값 형식으로 구성된 타입으로, 메모리 레이아웃이 고정되어 있고, 포인터 연산이 안전하게 가능한 타입.

제네릭 인터페이스

• 제네릭 인터페이스는 다양한 형식의 클래스들이 동일한 동작을 수행할 수 있도록 하는 형식 안정적인 인터페이스를 정의할 수 있다. <예제(유니티 게임 공격 시스템)>

  public interface IAttackable<T>
  {
    void Attack(T target);
  }
  

public class Enemy : MonoBehaviour, IAttackable { public void Attack(Player target) { Debug.Log("플레이어에게 공격!"); } }

- 이런 제네릭 인터페이스는 Player, Enemy, Boss 등 다양한 대상에게 공격할 수 있는 구조를 유연하게 구성할 수 있게 해준다.

## 제네릭 싱글톤 패턴
- MonoBehaviour 기반 클래스에 싱글톤을 적용하려면 제네릭을 이용하면 재사용성이 높아진다.
```cs
public class Singleton<T> : MonoBehaviour where T : MonoBehaviour
{
    private static T instance;

    public static T Instance
    {
        get
        {
            if (instance == null)
            {
                GameObject obj = GameObject.Find(typeof(T).Name);
                if (obj == null)
                {
                    obj = new GameObject(typeof(T).Name);
                    instance = obj.AddComponent<T>();
                }
                else
                {
                    instance = obj.GetComponent<T>();
                }
            }
            return instance;
        }
    }

    public void Awake()
    {
        DontDestroyOnLoad(gameObject);
    }
}

// 사용 예시
public class GameManager : Singleton<GameManager>
{
    public void InitGame() { }
}

✨ 마무리 팁

• 제네릭은 코드 중복을 줄이고 타입 안정성을 높이는 데 매우 강력한 도구이다.
• Unity나 .NET 기반 프로젝트에서도 많이 사용되며, 특히 컬렉션, 싱글톤, 인터페이스 구조에서 자주 활용된다.

• 10진수를 n진수로 바꿔주는 문제이다

10진법->N진법으로 변환하는 방법: 몫이 0이 될 때까지 10진수를 N으로 나누고 나머지를 기록한다. 나머지들을 거꾸로 이어붙이면 그것이 N진법 결과이다. <예시> 예제 입력대로 60466175 36 (10진수 60461175 -> 36진법)이라고 가정하겠다.

• 60466175 ÷ 36 = 1679615 … 35
• 1679615 ÷ 36 = 46656 … 35
• 46656 ÷ 36 = 1296 … 35
• 1296 ÷ 36 = 36 … 35
• 36 ÷ 36 = 1 … 0

나머지를 거꾸로 읽으면 0ZZZZ이다. 마지막 나머지(맨앞자리)가 0이므로 생략하면 ZZZZ이다.

using System;

class Baekjoon
{
    static void Main(string[] args)
    {

        string[] inputs = Console.ReadLine().Split();

        int n = int.Parse(inputs[0]); // 10진수 숫자
        int b = int.Parse(inputs[1]); // 바꿀 진법
        string result = "";

        while(n>0) // 몫이 0이 되면 중단
        {
            int remainder = n % b;

            if (remainder < 10) // 나머지가 0~9라면
                result = (char)('0' + remainder) + result;
            else // 10 이상이라면
                result = (char)('A' + (remainder - 10)) + result; // 낮은 자리수에서부터 시작하므로, 맨 앞에 붙여주어야 한다.

            n /= b;


        }
        Console.WriteLine(result);
    }
}

<코드 설명>

• 오른쪽에서 왼쪽으로 갈 수록 자릿수가 점점 커지기 때문에, result = 해당자릿수(나머지) + result를 해서 맨 앞에 붙여주었습니다.

혹시 틀린 부분이 있다면 편하게 댓글 달아주세요 :) 질문도 언제든지 환영입니다!

• n진수(2,4,6,12,36진수)를 10진수로 바꿔 출력하는 문제이다!

Convert.ToInt32(string, int)는 16진수까지만 지원하기 때문에, 36진수에는 적용할 수 없으므로 공식을 통해 문제를 풀어야 한다!!

n진수-> 10진수로 바꾸는 방법

• 맨 오른쪽부터 자릿값*(진법^자릿수위치)를 전부 더해주는 것이다. 예) 2AF 16을 입력받았다면, 16진수로 2 = 2, A = 10, F = 15이므로 15 x 16^0 = 15 x 1 = 15 10 x 16^1 = 10 x 16 = 160 2 x 16^2 = 2 x 256 = 512 따라서, 15 + 160 + 512 = 687이다.

<작성코드>

using System;

class Baekjoon
{
    static void Main(string[] args)
    {

        string[] inputs = Console.ReadLine().Split();

        string number = inputs[0];
        int baseNum = int.Parse(inputs[1]);
        int result = 0;
        int power = 1; // 진법의 거듭제곱

        for(int i=number.Length-1; i>=0; i--)
        {
            char c = number[i]; // 뒷자리부터
            int value; 

            if (char.IsDigit(c))
                value = c - '0';
            else
                value = c - 'A' + 10;

            result += value * power ;
            power *= baseNum;
        }

        Console.WriteLine(result);
    }
}

<코드 설명>

• char.IsDigit(char)를 이용해서 문자가 '0'~'9' 사이의 숫자라면 입력받은 숫자로 바꿔주기 위해 '0'을 빼주었습니다. 예) 문자 '3'은 아스키코드로 51이고, '0'은 48이므로 '3' - '0' = 3
• 또한 문자라면 c-'A'+10을 하여서 16진수 값이 나오게 해주었습니다. 예) 문자 c가 B라면, B는 아스키코드로 66, A는 65이므로 'B'-'A' = 1이다.(알파벳 순서) 여기에 10을 더해주면 실제 16진수값인 11이 나온다.

혹시 틀린 부분이 있다면 편하게 댓글 달아주세요 :) 질문도 언제든지 환영입니다!