어느 게임 개발자의 기록

런타임에 객체의 정보를 파악하기 위해 사용되는 기술입니다. 리플렉션을 활용하면 런타임에 객체, 필드, 메서드 등의 정보를 얻을 수 있습니다. 

델리게이트란 메서드를 더욱 유연하게 사용할 수 있도록 도와주는 문법입니다. 델리게이트에 함수를 바인딩하여 사용하면 call back을 편하고 안전하게 구현할 수 있으며, 동시에 호출되어야 하는 여러 메서드를 하나로 묶어 관리할 수 있게 됩니다.

Update와 LateUpdate는 매 프레임마다 호출되는 함수입니다. 오브젝트가 매 프레임마다 수행해야 하는 작업이 있다면, Update혹은 LateUpdate 내부에 코드를 작성하여 처리할 수 있습니다. Update와 lateUpdate 모두 매 프레임마다 호출되지만, LateUpdate 함수는 모든 오브젝트의 Update 함수가 호출된 이후에 호출됩니다. 모든 객체에 대해 Update 가 이루어진 이후에 추가적으로 처리해야 할 작업이 있다면, LateUpdate에서 처리할 수 있습니다.

FixedUpdate는 프레임마다 호출되는 함수가 아니라 일정 주기마다 호출되는 함수입니다. Update와 LateUpdate는 호출 간격이 들쑥날쑥한 반면, FixedUpdate는 정해진 주기마다 호출되기 때문에 항상 일정한 호출 간격을 보장받습니다. 이러한 특징으로 인해 물리 연산을 주로 FixedUpdate에서 처리합니다.

씬에서 사용될 게임 오브젝트를 미리 정의하여 파일의 형태로 보관하는 것을 프리팹이라고 합니다. 해당 게임 오브젝트가 보유할 컴포넌트, 트랜스폼 정보 등을 정의하여 파일의 형태로 저장한 뒤, 실제 씬에 오브젝트가 생성될 때, 해당 파일의 값을 참조하여 오브젝트를 생성하게 됩니다. 원본이 변하지 않고 항상 동일한 상태를 유지하기 때문에 생성되는 오브젝트들의 통일성을 보장할 수 있습니다.

boxing은 데이터를 object타입 혹은 참조 형식으로 변환하는 것을 의미하며, unboxing은 변환된 것을 원래의 상태로 되돌리는 것을 의미합니다. 하나의 클래스가 다양한 자료형에 대응하기 위해선, 모든 자료형이 공통으로 상속받고 있는 object 클래스를 이용해야 합니다. 이를 위해, 데이터를 object 클래스의 참조형으로 변환하여 통일성있게 저장하고, 실제로 사용할 땐 다시 원본의 상태로 되돌려 값을 사용하게 됩니다. 하지만, boxing과 unboxing은 그 횟수가 많아질수록 성능에 큰 부담을 주게 됩니다. 이를 완화하기 위해 generic이라는 문법을 사용할 수 있습니다. boxing, unboxing은 런타임에 실행되는 반면, generic은 대부분의 연산이 컴파일 타임에 처리되기 때문에 성능 부분에서 큰 향상을 기대할 수 있습니다.

C#언어에 포함되어 있는 쿼리 기능입니다. LINQ는 다량의 데이터를 편하고 안전하게 사용할 수 있도록 도와줍니다. LINQ는 C#에서 제공하는 컬렉션에만 사용가능한 것이 아니라, 프로세스 외부의 데이터베이스나 XML 등에도 편리하게 사용할 수 있습니다.

ref와 out은 모두 참조 전달에 사용되는 키워드입니다. ref의 경우 특정 변수를 참조하도록 하는 키워드입니다. ref로 선언된 변수는 선언과 동시에 가리키는 대상이 정해져야 하며, 가리키는 대상은 반드시 초기화가 되어있어야 합니다.

 out 키워드는 참조 전달 중에서도 함수 내부에서 값을 저장해주는 역할을 위해 사용되는 키워드입니다. out의 경우 가리키는 대상이 초기화가 되어 있지 않아도 되지만, 함수 내부에서는 반드시 값을 저장해주어야 합니다.

ref를 이용해 out을 모두 대체할 수는 있지만, 구분하여 사용함으로써 변수가 어떻게 사용되는 지를 더욱 명확히 할 수 있습니다.   

여러 클래스 간에 공통의 인터페이스를 정의하기 위해 사용되는 문법입니다. 추상 클래스와 유사하지만, 모든 함수가 abstract로 선언되어야 하며 멤버 변수 및 부모 클래스를 가질 수 없다는 차이점이 있습니다. 이러한 차이는 인터페이스가 다중 상속을 통해 사용된다는 특징으로 인해 발생합니다.

다중 상속은 다이아몬드 문제 등 여러 문제를 야기할 수 있기 때문에 C#에선 다중상속을 막아놓았지만, 인터페이스는 다중 상속을 통해 구현되는 기능이기 때문에 interface로 선언된 클래스에만 다중 상속이 허락되어 있습니다. 상술했던 추상 클래스와 인터페이스의 차이점은 다중상속으로 인한 문제점을 방지하기 위해 언어 차원에서 제약을 걸어둔 것이라고 할 수 있습니다.

Colider는 충돌을 탐지하기 위해 사용되는 컴포넌트입니다. 각 오브젝트 간의 충돌 검사를 위해선 Colider 컴포넌트가 필수적으로 필요합니다.

RigidBody는 대상에 다양한 물리를 적용하기 위해 사용되는 컴포넌트입니다. 중력, 마찰력 등의 물리법칙을 간편하게 오브젝트에 적용할 수 있게 됩니다. 

만약, 주먹에 맞은 대상이 후방으로 밀려나는 효과를 구현하고 싶다면, Colider를 사용해 주먹과 대상의 충돌을 검사한 뒤, RigidBody를 통해 일정 힘을 가함으로써 대상을 밀려나도록 할 수 있습니다.

레이캐스팅이란,  특정 지점에서 광선을 발사하여 경로에 존재하는 오브젝트를 검출하는 충돌 검사 기법입니다. 3D 공간에 있는 물체를 클릭하는 기능을 구현하고 싶을 때, 2D 공간에 투영되어 있는 마우스 좌표를 3D 월드 좌표로 변환한 뒤 레이캐스팅을 사용하여 경로에 있는 물체를 탐지하여 상호작용이 발생하도록 구현할 수 있습니다. 뿐만 아니라, 총을 발사하는 것을 레이캐스팅을 사용해 구현할 수도 있으며 전방의 벽을 탐지하기 위해서도 사용할 수 있습니다. 

객체와 유니티 엔진을 결합하기 위해 상속해야 하는 클래스입니다. 모노비헤이비어 클래스를 상속받음으로써 클래스와 에디터를 연동할 수 있으며, 객체의 생명주기가 유니티 엔진에 의해 관리되도록 할 수 있습니다. 또한, 클래스 내에서 유니티 엔진의 프레임워크를 사용할 수 있게 되면서 편리하고 유연한 개발이 가능해집니다.

함수를 중지하거나 재개하는 기능을 제공해주는 문법입니다. 코루틴에 의해 중지된 함수를 재개하는 것은 일반적인 함수 호출에 비해 빠르기 때문에, 코루틴 함수 내부에 반복문으로 기능을 정의한 후 이를 중지하고 재개하는 방식으로 활용한다면 성능의 향상을 기대할 수 있게 됩니다. 또한, 입력, 응답 등을 기다리는 대기 시간이 발생할 때 코루틴 함수를 재개하여 다른 작업을 처리하도록 한다면 작업 사이의 비는 시간을 최소화하여 성능을 극대화할 수 있게 됩니다.

두 키워드 모두 값의 수정을 막는 키워드입니다. const의 경우 대상을 아예 상수화하기 때문에 컴파일 단계에서 값이 정해져야 합니다. 그렇기 때문에 const로 선언된 변수는 선언과 동시에 초기화가 이루어져야 합니다. 런타임에 생성자가 호출된 이후 값이 정해지는 커스텀 클래스의 경우 const 키워드를 사용할 수 없으며, 멤버 변수로 선언된 const 변수는 모든 인스턴스가 같은 값을 공유하게 된다는 특징이 있습니다.

반면, readonly 키워드의 경우 힙영역에 동적으로 메모리를 할당하여 값을 저장하며, 생성자에 한해 런타임에 값이 변경되는 것이 허락됩니다. 이러한 특징으로 인해, 모든 자료형에 대해 readonly 키워드를 사용할 수 있으며 인스턴스 별로 다른 값을 보유할 수 있게 됩니다. 하지만, 런타임에 힙영역을 참조하는 이유로 const 변수에 비해 낮은 성능을 보유하게 된다는 단점이 있습니다. 

델리게이트에 제약이 추가된 특수한 형태입니다. 발행 구독 패턴을 사용해 특정 상황에 실행되어야 하는 여러 함수들을 관리할 때 유용하게 사용할 수 있습니다.

event는 일반적인 델리게이트와 달리 대입 연산이 불가능하고 증감연산만 가능하며, event를 소유한 객체 외부에서 바인딩된 함수를 호출할 수 없다는 특징이 있습니다.

유니티에서 제공하는 스크립팅 백엔드입니다. 모노의 경우 런타임에 코드를 기계어로 변환하기 때문에 컴파일 타임이 il2cpp에 비해 빠르지만, 런타임 퍼포먼스가 il2cpp에 비해 저조하다는 단점이 있습니다.

반면, il2cpp는 빌드 과정에서 기계어 번역을 마치기 때문에 컴파일 타임이 느리다는 단점이 있지만, 모노에 비해 런타임 퍼포먼스가 우수하다는 장점이 있습니다.

프로젝트에 있어 효율성, 개발 속도 등에서 이점을 챙기고자 한다면 모노를 사용하는 것이 유리하며 고성능 퍼포먼스를 노리고자 한다면 il2cpp를 사용하는 것이 좋습니다.

일반적으로는 null을 대입할 수 없지만, Nullable 객체를 활용하면 null을 대입할 수 있게 됩니다. 

참조 전달이란, 값을 그대로 전달하는 것이 아니라 값이 저장된 메모리 영역이 어디인지를 전달하는 것이다.

값을 그대로 전달하게 되면, 함수 내부에서 그 값을 사용하기 위해 복사가 발생하게 된다. 하지만, 메모리 영역의 위만 전달하게 된다면 함수 내부에선 값을 복사하지 않고도 위치를 참조해 변수에 직접 접근할 수 있게 된다.

이해가 안된다면, call by value와 call by reference에 대해 검색해보자.

얕은 복사는 값을 그대로 복사하는 것입니다. 얕은 복사의 경우 연산이 매우 가볍지만 포인터 변수가 가지고 있는 주소값을 그대로 복사하기 때문에 댕글링 포인터 등의 문제가 발생할 수 있다는 문제점이 있습니다. 이러한 위험성을 해결하기 위해 새로운 메모리 영역을 할당하여 포인터 변수가 가리키고 있는 메모리 주소에 저장된 값을 복사하는 것을 깊은 복사라고 합니다.

클래스의 캐스팅 성공 여부를 확인하는 연산자입니다. is연산자는 특정 클래스가 다른 클래스로 캐스팅이 가능한지 여부를 파악하여 true, false로 가능 여부를 반환해줍니다.

as연산자는 클래스의 캐스팅 여부를 확인하는 동시에 캐스팅이 가능하다면 캐스팅을 함께 진행해줍니다. 즉, as 연산자는 캐스팅 성공시엔 캐스팅된 대상을 반환하며 실패시엔 null을 반환합니다. \

두 클래스 모두 C#의 컬렉션에 포함된 클래스입니다. sortedset의 경우 이진 트리 기반의 자료구조입니다. 데이터를 key로만 저장하며 원소가 삽입되거나 삭제될 때마다 정렬 작업을 실행합니다. 

반면, dictionary는 해시테이블 기반의 자료구조입니다. 데이터를 해싱된 key와 value를 쌍으로 저장하며, 원소가 삽입되거나 삭제되어도 정렬 작업을 수행하지 않습니다.

이러한 특성들로 인해, dictionary가 sortedset에 비해 속도 측면에선 우수한 성능을 보이지만 dictionary는 데이터가 너무 적을 때엔 메모리 낭비가 심할 수 있다는 단점이 있습니다. 

C#의 컬렉션에 포함된 자료구조이며, generic을 기반으로 반들어진 클래스입니다. List는 일종의 동적 배열이기 때문에, 데이터가 메모리에 연속적으로 위치하고 있으며 배열의 크기가 가변적이라는 특성이 있습니다.

박싱이란, 값 형식을 참조 형식으로 변환하는 것을 의미하며 언박싱이란 박싱된 데이터를 원래의 형식으로 돌려놓는 것을 의미합니다. C#의 모든 자료형은 object를 상속받고 있기 때문에, object의 참조 형식을 활용하면 다양한 자료형을 통일성있게 사용이 가능합니다. 하지만, 박싱과 언박싱은 커다란 오버헤드를 유발하는 작업이기 때문에 최적화 측면에선 지양하는 것이 좋습니다.

공유되는 자원이 훼손되지 않도록 주의하여 설계해야 합니다. 하나의 프로세스에 속한 여러 스레드는 스택 메모리를 제외한 모든 메모리를 공유하게 됩니다. 여러 스레드가 같은 메모리 영역에 대해 읽고 쓰는 작업을 동시다발적으로 수행하게 된다면, 해당 메모리 영역엔 실제 프로그래머의 의도와 다른 값이 저장될 수 있습니다. 이를 방지하기 위해선 아토믹, 뮤텍스, 세마포어 등을 활용할 수 있습니다. 

직렬화는 현재 메인 메모리에 저장되어 있는 데이터를 바이트 스트림으로 변환하는 것을 의미하며, 역직렬화는 바이트 스트림으로 저장되어 있는 데이터를 읽어 메인 메모리에 저장하는 것을 의미합니다. 주로 게임의 세이브 데이터나 네트워크 송수신에 사용됩니다.

TCP와 UDP는 모두 네트워크 통신 프로토콜입니다. TCP는 연결 지향성 프로토콜로, 통신하는 두 대상이 1:1로 연결된 상태로 통신을 하게 됩니다. 3way handshake, 4way handshake를 통해 안전하게 두 대상을 연결하며, 송수신 과정에서 데이터가 훼손되지 않도록 흐름 제어, 혼잡 제어 등의 기법을 추가적으로 활용합니다. 이로 인해, 매우 높은 데이터의 신뢰성을 기대할 수 있지만, 통신 속도가 상대적으로 느리다는 단점이 있습니다.

UDP는 비연결 지향성 프로토콜로, 통신하는 대상이 서로 연결되지 않은 상태로 통신하게 됩니다. 이로 인해, 패킷이 수신되는 경로가 일정하지 않아 수신 순서와 송신 순서가 달라질 수 있어 데이터가 훼손될 가능성이 있습니다. 하지만 UDP는 통신에 있어 추가적인 데이터 검증, 보호 절차를 거치지 않기 때문에 매우 빠른 통신 속도를 보인다는 장점이 있습니다.

c++ 표준에선 자료형의 크기가 구현체에 따라 달라질 수 있음을 명시하고 있습니다. 즉, int 자료형의 크기는 일정하지 않으며 운영체제 등의 환경에 따라 크기가 달라질 수 있습니다. 그렇기 때문에, 자료형을 사용할 때엔 __int32, __int64등 그 크기가 함께 명시되어 있는 자료형을 사용하는 것이 좋습니다. 

하나의 클래스를 여러 파일에서 나누어 정의할 수 있도록 해주는 키워드 입니다. 아주 많은 메서드를 가진 클래스를 하나의 파일에서 모두 정의하는 경우 가독성이 매우 떨어질 수 있기 때문에, 클래스를 여러 조각으로 나누어 정의하고자 할 때 사용하는 키워드입니다.

바로 위의 부모 클래스에 접근할 수 있도록 도와주는 키워드 입니다. base 키워드를 사용하면 부모 클래스의 메서드, 프로퍼티 등을 자식 클래스에서 직접적으로 사용할 수 있게 됩니다.

C++에서 함수 포인터, 함수 객체, 람다 함수 등의 callable을 편하고 안전하게 사용할 수 있도록 제공해주는 템플릿 클래스입니다. 일반적인 C스타일의 함수 포인터에 비해 가독성이 좋고 사용성이 매우 편리하고 안전하게 사용할 수 있는 클래스이며, std::bind 함수와 함께 사용하면 파라미터와 함수를 묶어 더욱 편리하고 유연하게 사용할 수 있게 됩니다

NULL과 nullptr은 모두 값이나 가리키는 대상이 없음을 표현할 때 사용하는 키워드입니다. NULL은 0을 매크로를 사용해 정의한 것으로 정수 0과 완전히 동일합니다. 그렇기 때문에 여러 파라미터에 대해 오버로딩된 함수를 호출하는 경우, 포인터 타입이 아닌 정수값을 파라미터로 받는 함수를 호출할 가능성이 있습니다.

이러한 문제를 해결하기 위해 C++에선 포인터임을 명시하는 nullptr이라는 키워드를 제공해줍니다. nullptr은 정수 0이 아닌 포인터 타입으로 간주되기 때문에 포인터 변수를 파라미터로 받는 함수를 정확하게 호출할 수 있게 됩니다.

즉, NULL은 값형이지만 nullptr은 참조형이라는 것이 차이라고 할 수 있습니다.

C++ 코드의 빌드는 전처리기, 컴파일, 어셈블리, 링커 이렇게 크게 4개의 단계로 이루어집니다. 전처리기 단계에선 주석을 제거하고 불필요한 공백을 제거한 뒤, 코드에 사용된 매크로를 모두 실제 사용되는 값으로 치환하는 과정을 거칩니다. 또한 포함된 헤더파일의 코드를 모두 복사하여 하나의 파일에 붙여넣어 헤더파일과 C++파일을 하나로 묶게 됩니다.

이후에는 컴파일 단계가 실행이 됩니다. 컴파일 단계에선 작성된 코드의 유효성을 검사하여 발생할 수 있는 오류를 사전에 잡아내는 역할을 합니다. 발견된 오류가 없다면 작성된 C++ 코드를 저수준의 어셈블리어로 변환하는 과정을 거치게 됩니다.

이후, 어셈블리 단계에선 어셈블리어로 변환된 코드를 실제 하드웨어가 이해할 수 있는 기계어로 변환하여 obj파일을 생성하게 됩니다.

마지막으로 실행되는 링커 단계에선 여러 개의 obj 파일과 정적 라이브러리를 하나로 묶어 최종적으로 실행될 수 있는 exe파일을 만들게 됩니다.

문자열의 불필요한 복사를 줄이기 위해 사용할 수 있는 클래스 입니다. 함수의 파라미터로 std::string을 사용할 경우, 참조형을 사용하더라도 상황에 따라 복사 및 동적 할당이 발생할 수 있습니다. 하지만, string_view는 내부에 const char* 타입의 변수와 문자열의 사이즈 만을 보유하고 있기 때문에 추가적인 동적 할당이 발생하지 않고, 복사 또한 매우 가벼운 연산으로 수행될 수 있습니다. 하지만, 읽기 전용 클래스인 만큼 string에 비해 문자열을 유연하게 사용하는 것이 불가능하므로 적재적소에 사용하는 것이 중요합니다.

C++ 함수 호출 규약 중 하나로 멤버 함수를 호출할 때 사용되는 방식입니다. 멤버 함수는 호출될 때, 항상 호출자의 주소를 알고 있어야 하기 때문에, 멤버 함수는 컴파일 과정에서 파라미터의 가장 앞에 클래스의 포인터 형이 추가되고, 이 곳에 호출자의 주소가 대입되는 과정으로 실행됩니다. 함수 내부의 멤버함수 또한, 첫 번째 인자로 받은 포인터를 사용해 호출하는 방식으로 이루어집니다. 이러한 멤버 함수의 호출 방식을 this call이라고 합니다.

프로그램이 실행되어 메인 메모리에 위치하게 되면 이를 프로세스라고 부릅니다. 운영체제에서 독립적인 메모리를 할당하는 단위입니다. 

map과 unordered_map은 모두 key와 value를 쌍으로 저장하는 자료구조입니다. map은 완전 이진 트리를 기반으로 설계되어 있으며, 원소가 삽입되거나 삭제될 때마다 정렬을 하며 트리의 균형을 유지합니다. 

반면, unordered_map은 해시테이블 기반으로 설계되어 있으며, 원소가 삽입되거나 삭제되더라도 정렬을 수행하지 않습니다.

이러한 차이들로 인해, unordered_map을 사용하게 되면 일반적으로 map에 비해 높은 성능을 기대할 수 있지만 커스텀 클래스를 사용할 경우엔 해시 함수를 직접 구현해야 한다는 불편함이 있고, 데이터가 적을 때엔 메모리의 낭비가 심할 수 있다는 단점이 있습니다.

const는 컴파일 타임에 값이 상수로 치환되기 때문에, 선언과 동시에 초기화가 되어야 하며 데이터가 스택 영역에 저장됩니다. 반면, readonly는 생성자에서 값을 초기화 할 수 있으며 데이터가 힙 영역에 동적으로 저장됩니다.

const는 컴파일 타임에 상수화가 이루어지고 stack 영역에 저장되기 때문에 readonly로 선언된 변수에 비해 성능 부분에서 이점이 있지만, 기본 자료형에 대해서만 사용이 가능하고 값이 수정될 때마다 새로 컴파일을 해야 한다는 불편함이 있습니다.

반면 readonly는 런타임에 초기화가 이루어지고 데이터가 힙 메모리에 위치하기 떄문에 성능 상에선 다소 불리함이 있을 수 있지만, 커스텀 클래스에도 사용할 수 있으며 값을 수정하여도 새로 컴파일하지 않는다는 장점이 있습니다.

하나의 대상이 다양하게 표현될 수 있는 성질을 의미합니다. 상속관계의 클래스를 업캐스팅, 다운캐스팅 하는 것이 다형성의 대표적인 예시입니다.

sealed 키워드는 클래스의 파생을 제한하는 키워드입니다. sealed 키워드가 포함되어 정의된 클래스는 다른 클래스의 부모 클래스가 될 수 없으므로 항상 말단에 위치한 클래스임을 보장받습니다.

[]으로 원소에 접근하는 경우, 대상에 빠르게 접근할 수 있지만 범위를 초과한 인덱스를 사용할 경우 예외를 방출하지 않고 프로세스를 종료하기 때문에 안정성이 낮고 디버깅에 불리하다는 단점이 있습니다.

반면, at을 사용하는 경우 범위를 초과한 인덱스를 사용할 경우 예외를 방출하기 때문에 디버깅 측면에선 유리하지만 []를 사용해 접근하는 것에 비해 느릴 수 있다는 단점이 있습니다.

CPU에서 실행중인 프로세스, 스레드가 다른 프로세스, 스레드로 교체되는 것을 의미합니다. 잦은 컨텍스트 스위칭은 성능 저하의 원인이 될 수 있으므로 프로그램을 설계할 때엔 컨텍스트 스위칭을 최소화하는 방향으로 설계해야 합니다.

CPU가 작업하고 있는 것을 잠시 중단하고 먼저 처리해야 할 작업을 수행하는 것을 의미합니다. 주로 실행중인 작업에서 예외가 발생하여 이를 처리해야 할 경우에 인터럽트가 발생합니다.

malloc의 경우엔 메모리만 할당해주고 추가적인 작업을 수행하지 않지만, new는 메모리 할당 뿐만 아니라 메모리 영역에 생성자 호출하여 값을 초기화 하는 작업과 메모리 영역의 포인터를 자료형에 맞게 타입 캐스팅하는 작업까지 이루어집니다.

이러한 과정의 차이로 인해, malloc는 반환형이 void*이며 생성자를 호출할 수 없지만 new의 경우 반환형이 자료형에 맞는 포인터 타입이며 생성자를 호출할 수 있습니다. 하지만, malloc은 자료형에 영향을 받지 않는 만큼 메모리 크기를 자유롭게 할당할 수 있지만 new의 경우엔 자료형이 차지하는 메모리 크기의 배수만큼만 할당할 수 있습니다.

람다함수란 이름이 없는 함수를 의미합니다. 일반적인 함수는 미리 선언과 정의를 해놓으면 이를 재사용하는 방식으로 이루어지지만 람다 함수는 필요할 때마다 즉석으로 정의하여 사용하는 방식으로 이루어집니다. 

람다함수는 스택 메모리에 저장되기 때문에 지역을 벗어나면 메모리에서 사라지지만 일반적인 함수는 프로세스가 끝날 때까지 코드 영역에 위치하기 때문에, 재사용성이 낮은 함수의 경우 람다함수를 사용하는 것이 메모리 측면에선 이점이 있을 수 있습니다.

또한, 필요할 때마다 그 자리에 정의하면 되기 때문에 사용성이 좋다는 장점이 있지만, 무분별하게 사용하게 되면 가독성을 심하게 저하할 수 있다는 단점이 있습니다. 

가비지 컬렉터 알고리즘의 한 종류입니다. 트리 구조로 연결되어 있는 오브젝트를 순회하여 참조 가능한 오브젝트에 표시를 한 뒤, 다시 모든 메모리를 훑어 표시가 되어 있지 않은 오브젝트를 제거하는 방식으로 이루어집니다. 

두 기법 모두 드로우 콜을 줄이기 위해 사용할 수 있는 기법입니다. 배칭은 같은 머티리얼을 공유하는 여러 매쉬를 하나로 결합하여 한 번의 드로우 콜로 렌더링을 해결하는 기법입니다.

인스턴싱이란 지오메트리 셰이더를 사용하여 동일한 지오메트리를 사용하는 여러 객체를 병렬적으로 렌더링하는 기법입니다. 전쟁 시뮬레이션 게임에서 수많은 병사를 렌더링할 때 인스턴싱 기법을 사용하면 병사의 수 만큼 드로우 콜이 발생하는 것이 아니라 1번의 드로우 콜로 렌더링을 해결할 수 있게 됩니다.

메모리가 효율적으로 사용되지 못하는 상황을 의미합니다. 메모리 단편화는 내부 단편화와 외부 단편화로 분류됩니다.

내부 단편화란, 필요한 메모리보다 더 많은 메모리를 할당하여 메모리가 낭비되는 상황을 의미합니다. 외부 단편화란, 메모리의 할당과 해제가 반복되면서 할당된 메모리들 사이에 작은 틈이 발생하는 것을 의미합니다. 이러한 경우 실제 메인 메모리에 물리적 공간이 충분함에도 불구하고 연속적으로 존재하지 않기 때문에 메모리를 할당할 수 없는 상황이 발생할 수 있습니다.

어떠한 클래스나 메서드 등을 선언할 때, 다양한 자료형에 대응하기 위해선 일반적으로 자료형에 따라 여러 개를 선언하여야 합니다. 이러한 불편함을 해결하기 위해 C#에서 지원해주는 키워드가 generic입니다. generic을 사용하게 되면 하나의 클래스나 메서드가 여러 자료형에 대해 대응할 수 있게 되며 코드의 재사용성이 매우 높아집니다.

using System;
using System.Collections.Generic;
using System.Diagnostics.SymbolStore;
using System.Linq;
using System.Runtime.InteropServices;
using System.Text;
using System.Threading.Tasks;

namespace C_Study
{
    public class FightLevel : GameLevel
    {
        public override void Update()
        {
            Console.Clear();
            
            if(SelectedMonster == null)
            {
                SelectMonster();
            }
            else
            {
                Fight();
            }
        }

        public FightLevel(GameCore parrentCore)
        {
            _parentCore = parrentCore;
            _playerLog = null;
            _monsterLog = null;
        }

        public void Fight()
        {
            if(_selectedMonster == null)
            {
                return;
            }

            DevFunctions.WriteLineColored("플레이어 정보", ConsoleColor.Blue);
            Console.WriteLine("HP : {0} / {1}", _parentCore.CurrentPlayer.CurrentHP, _parentCore.CurrentPlayer.MaxHP);
            Console.WriteLine();

            DevFunctions.WriteLineColored("몬스터 정보", ConsoleColor.Red);
            Console.WriteLine("이름 : {0}", _selectedMonster.Name);
            Console.WriteLine("HP : {0} / {1}", _selectedMonster.CurrentHP, _selectedMonster.MaxHP);
            Console.WriteLine();

            if (_selectedMonster.CurrentHP <= 0)
            {
                Win();   
            }
            else if(_parentCore.CurrentPlayer.CurrentHP <= 0)
            {
                Lose();   
            }
            else
            {
                WriteFightLog();
                SelectBehavior();
                MonsterBehavior();
            }
        }

        private void Win()
        {
            Console.WriteLine("전투에서 승리하였습니다!");

            _parentCore.CurrentPlayer.CurrentEXP += _selectedMonster.WinEXP;
            _parentCore.CurrentPlayer.Money += _selectedMonster.WinMoney;

            Console.WriteLine("아무 키나 입력시 메뉴 선택창으로 돌아갑니다.");

            Console.Read();

            _selectedMonster = null;
            _monsterLog = null;
            _playerLog = null;

            _parentCore.CurrentLevel = LevelType.Menu;
        }
        private void Lose()
        {
            Console.WriteLine("전투에서 패배하였습니다..");
            Console.WriteLine("아무 키나 입력시 메뉴 선택창으로 돌아갑니다.");

            Console.Read();

            _selectedMonster = null;
            _monsterLog = null;
            _playerLog = null;

            _parentCore.CurrentPlayer.CurrentHP = 1;
            _parentCore.CurrentLevel = LevelType.Menu;
        }


        private void WriteFightLog()
        {
            DevFunctions.WriteLineColored("나의 행동", ConsoleColor.Blue);
            
            if(_playerLog != null)
            {
                Console.WriteLine("{0}", _playerLog);
                Console.WriteLine();
            }

            DevFunctions.WriteLineColored("적의 행동", ConsoleColor.Red);
            if(_monsterLog != null)
            {
                Console.WriteLine("{0}", _monsterLog);
            }

            Console.WriteLine();
        }

        private void SelectBehavior()
        {
            Console.WriteLine("1. 공격한다.\n2. 아이템을 사용한다.\n3. 도망친다.");

            string input = Console.ReadLine();

            if (DevFunctions.IsNumeric(input) == false)
            {
                return;
            }

            if (input.Length > 1)
            {
                return;
            }

            int toInt = int.Parse(input);

            switch (toInt)
            {
                case 1:
                    PlayerAttack();
                    break;
            }
        }

        private void PlayerAttack()
        {
            int Damage = GameFunctions.GetCalculatedDamage(_parentCore.CurrentPlayer, _selectedMonster);
            bool isCritical = GameFunctions.isCritical(_parentCore.CurrentPlayer);

            string CriticalMsg = "";

            if(isCritical == true) 
            {
                Damage = (int)(Damage * _parentCore.CurrentPlayer.CriticalPower);
                CriticalMsg = "[크리티컬!] ";
            }

            _playerLog = "적에게 공격 : " + CriticalMsg + Damage.ToString() + "의 피해를 입혔습니다.";

            _selectedMonster.CurrentHP -= Damage;
        }
        private void MonsterBehavior()
        {
            if(_selectedMonster.CurrentHP <= 0)
            {
                _monsterLog = "사망하였습니다.";
                return;
            }

            int Damage = GameFunctions.GetCalculatedDamage(_selectedMonster, _parentCore.CurrentPlayer);
            bool isCritical = GameFunctions.isCritical(_selectedMonster);

            string CriticalMsg = "";

            if (isCritical == true)
            {
                Damage = (int)(Damage * _selectedMonster.CriticalPower);
                CriticalMsg = "[크리티컬!] ";
            }

            _monsterLog = "플레이어에게 공격 : " + CriticalMsg + Damage.ToString() + "의 피해를 입혔습니다.";

            _parentCore.CurrentPlayer.CurrentHP -= Damage;
        }

        private void SelectMonster()
        {
            DevFunctions.WriteLineColored("전투하고 싶은 몬스터를 선택하세요.", ConsoleColor.DarkCyan);
            Console.WriteLine();

            Console.WriteLine("1. 고블린 (적정 레벨 : 1)");
            Console.WriteLine("2. 오우거 (적정 레벨 : 5)");
            Console.WriteLine("3. 드래곤 (적정 레벨 : 10)");
            Console.WriteLine("4. 이전으로 돌아간다.");

            string input = Console.ReadLine();

            if (DevFunctions.IsNumeric(input) == false)
            {
                return;
            }

            if (input.Length > 1)
            {
                return;
            }

            int toInt = int.Parse(input);

            switch (toInt)
            {
                case 1:
                    _selectedMonster = new Goblin();
                    break;
                case 4:
                    _parentCore.CurrentLevel = LevelType.Menu;
                    _selectedMonster = null;
                    break;
            }
        }

        public static Monster SelectedMonster
        {
            get { return _selectedMonster; }
            set { _selectedMonster = value; }
        }

        private static Monster _selectedMonster;
        private static string _playerLog;
        private static string _monsterLog;
    }
}

public int CurrentEXP
{
    get { return _currentEXP; }
    set 
    {
        _currentEXP = value;

        if (_currentEXP >= _maxEXP)
        {
            LevelUp();
        }
    }
}

private void LevelUp()
{
    _currentEXP -= _maxEXP;
    Console.WriteLine("레벨이 상승하였습니다!");

    MaxEXP = (int)(_maxEXP * 1.1f);

    _level++;

    _attPower += 10;
    _defPower += 2;
}

public class GameFunctions
{
    public static int GetCalculatedDamage(ICreatureStat attacking, ICreatureStat attacked)
    {
        Random random = new Random();

        int MinAtt = (int)(attacking.AttPower * 0.9f);
        int MaxAtt = (int)(attacking.AttPower * 1.1f);

        int Att = random.Next(MinAtt, MaxAtt);
        int Def = attacked.DefPower;

        float DefRate = Def / 100.0f;
        DefRate = 1.0f - DefRate;

        return (int)(Att * DefRate);
    }

    public static bool isCritical(ICreatureStat attacking)
    {
        Random random = new Random();
        int randomValue = random.Next(0, 100);

        if (randomValue <= attacking.CriticalProb_100)
        {
            return true;
        }
        else
        {
            return false;
        }
    }
}

런타임에 객체를 계속 생성하고 파괴하는 것이 오버헤드를 유발할 뿐만 아니라 외부 단편화의 원인이 될 수 있기 때문에 이를 방지하기 위해 미리 메모리를 크게 할당해놓고 사용하는 기법을 메모리 풀링이라고 합니다. 

메모리의 할당과 해제가 반복되면 할당된 메모리 사이에 틈이 발생하게 됩니다. 이러한 틈이 많아지면 실제 메모리에 공간이 충분함에도 불구하고 메모리를 할당하지 못하거나 비효율적으로 할당해야 하는 상황이 발생할 수 있습니다. 이를 외부단편화라고 합니다.

HDD, SDD등의 보조 기억장치의 도움을 받아 메인 메모리의 물리적 용량보다 더 큰 범위의 용량을 사용하는 기법을 가상 메모리라고 합니다.  

싱글톤 패턴을 사용해보았습니다. 플레이어의 스탯 혹은 보유한 아이템 정보 등을 보관하기 위해선 레벨과 무관하게 존재하는 클래스가 필요했고, 이를 전역 클래스로 구현하였습니다. 하지만, 이 클래스의 인스턴스가 여러개 생성되면 데이터가 안정적으로 보관되지 못할 가능성이 있기 때문에 하나의 인스턴스만 존재함을 보장해야했습니다. 이를 위해 싱글톤 패턴을 활용하였습니다.

static_cast, dynamic_cast, reinterpret_cast, const_cast가 있습니다. static_cast는 컴파일 타임에 타입 캐스팅이 이루어지기 때문에 성능에 큰 영향을 주지 않는다는 장점이 있지만, 타입 캐스팅의 성공 여부를 반환하지 않아 안전하지 않다는 단점이 있습니다. 반면, dynamic_cast는 런타임에 타입 캐스팅이 이루어집니다. 타입 캐스팅이 실패시 nullptr을 반환하기 때문에 안전하게 사용할 수 있다는 장점이 있지만 성능에 영향을 줄 수 있다는 단점이 있습니다. 

reinterpret_cast는 가장 넓은 범위의 캐스팅을 지원하는 키워드입니다. static_cast는 값을 유지하기 위해 자료형에 따라 비트에 저장된 값을 변경하지만 reinterpret_cast는 비트에 저장된 값을 유지하는 방식의 캐스팅입니다. 다양한 형태의 타입 캐스팅을 지원하지만 자료형에 따라 값을 해석하는 것이 달라지기 때문에 안전하지 못하다는 단점이 있습니다. const_cast는 포인터 변수의 상수성을 일시적으로 제거해주는 타입 캐스팅입니다. 상수화 되어있는 포인터 변수가 다른 대상을 가리키게 하고 싶을 때 사용할 수 있습니다.

대상을 참조 타입으로 사용하기 위한 키워드입니다. C#에서 객체는 모두 참조 타입으로 사용되지만 구조체와 string을 제외한 기본 자료형 등은 기본적으로 참조 타입이 아니기 때문에 ref 한정자를 통해 참조 타입으로 사용할 수 있습니다.   

class는 new를 통해서만 생성할 수 있기 때문에 참조 형식으로만 사용할 수 있습니다. 반면, struct는 new 키워드 없이도 생성할 수 있어 값 타입으로 사용할 수 있습니다. struct는 일반적으로 stack영역에 위치하기 때문에 heap 영역에 위치하는 class보다 성능적인 부분에서 우위에 있지만, class와 달리 상속이 불가능하다는 단점이 있습니다. 

여러 작업이 동시에 실행되는 것처럼 보이지만 물리적으로는 동시에 실행되지 않는 것을 동시성이라 하며, 물리적으로 동시에 실행되고 있는 것을 병렬성이라고 합니다.

운영체제에서 사용자가 마음껏 접근할 수 있는 영역을 유저영역이라 하며, 함부로 접근할 수 없도록 제한되어 있는 영역을 커널 영역이라고 합니다. 운영체제는 메모리 관리, 하드웨어 상호작용 등 저수준의 작업을 처리하는 역할을 합니다. 사용자가 이를 함부로 수정하게 되면 기기에 큰 문제를 발생시킬 수 있기 때문에 일부 영역에 대해선 접근할 수 없도록 막아두고 있으며, 이 영역을 커널 영역이라고 합니다. 반면, 문제가 발생하더라도 쉽게 해결할 수 있거나 국소적인 문제만 발생할 수 있는 영역에 대해선 자유로운 접근을 허용하고 있으며 이를 유저 영역이라고 합니다.

대표적으로 메모리 풀링 기법이 있습니다. 외부 단편화는 잦은 메모리의 할당과 해제로 인해 발생하기 때문에, 미리 메모리 블록을 할당해놓은 뒤 이를 재사용하는 메모리 풀링 기법을 활용하면 외부 단편화 문제를 최소화할 수 있습니다.

클래스, 구조체 등을 분류하기 위해 사용하는 문법입니다. 네임스페이스 안에 존재하는 클래스, 구조체 등은 네임스페이스를 통해 사용해야 하기 때문에 역할이나 사용처 등을 쉽게 알아볼 수 있다는 장점이 있습니다. 하지만, 매번 네임 스페이스를 통해 사용하는 것이 다소 불편하기 때문에 using 문법을 활용하여 이를 생략할 수도 있습니다. 

자식 클래스의 소멸자가 호출되는 것을 보장하기 위해 사용합니다. 특정 클래스가 부모 클래스로 업캐스팅되어있는 상태에서 소멸하게 되면, 자식 함수의 소멸자가 호출되지 않을 수 있습니다. 소멸자에서 메모리 해제 등의 중요한 작업이 이루어지는 경우 문제가 발생할 수 있기 때문에 소멸자를 가상화하여 반드시 호출되도록 할 수 있습니다.

CPU와 메인 메모리의 작업 처리 속도 차이로 인해, CPU에서 메인 메모리에 접근하는 경우 CPU에 병목 현상이 발생할 수 있습니다. 현대의 컴퓨터는 이러한 병목현상을 완화하기 위해, CPU가 메인 메모리에 접근했을 때 일정량의 데이터를 캐시 메모리로 복사한 뒤 CPU가 캐시 메모리의 데이터를 먼저 탐색하도록 설계되어 있습니다. 캐시 메모리는 메인 메모리에 비해 매우 빠른 작업 처리 속도를 보유하고 있기 때문에 높은 성능 향상을 기대할 수 있습니다.

원하는 데이터가 캐시 메모리에서 발견될 확률을 캐시 적중률이라고 합니다. 캐시 메모리에 원하는 데이터가 없을 경우 CPU는 메인 메모리에 접근하여 데이터를 다시 캐시로 옮겨오는 작업을 실행하게 됩니다. 원하는 데이터를 캐시 메모리에서 많이 발견할 수 있다면 CPU가 메인 메모리에 접근하는 횟수가 적어지기 때문에 캐시 적중률이 높을수록 높은 성능을 기대할 수 있습니다.

접근 제한 지정자란, 외부의 접근을 허용하는 정도를 설정하는 키워드 입니다. 접근 제한 지정자는 public, protected, private 총 3개의 종류가 있습니다. public는 모든 곳에서 접근을 허용하는 키워드이며, protected는 상속 관계에서만 접근을 허용하는 키워드입니다. private는 어느 곳에서도 접근을 허용하지 않는 키워드입니다.

리터럴 초기화는 변수가 생성되는 동시에 값을 초기화 하지만, 초기화 리스트는 생성자가 호출될 때 초기화를 실행하기 때문에 리터럴 초기화보다 늦은 시기에 실행되게 됩니다.

TCP는 연결 지향형 통신 프로토콜입니다. 소켓을 이용해 서로를 1:1로 연결하여 통신하기 때문에 안전하게 통신할 수 있습니다. 하지만, 안정성을 위해 패킷 송수신에 부가적인 작업을 많이 하는 만큼 반응성은 다소 느리다는 단점이 있습니다.

UDP는 비연결 지향형 통신입니다. 서로 연결되어 있지 않고 데이터 검증, 보호 등의 작업을 수행하지 않기 때문에 데이터의 신뢰성이 TCP에 비해 낮다는 단점이 있지만 매우 빠르게 통신할 수 있다는 장점이 있습니다.

이러한 특징으로 인해 TCP는 파일의 전송 등 데이터의 신뢰성이 중요한 작업에 자주 이용되며, UDP는 실시간 게임이나 동영상 스트리밍처럼 데이터의 신뢰성보다 속도에 중점을 둬야하는 경우 자주 사용하게 됩니다.

abstract는 대상을 추상화하는 키워드입니다. abstract 키워드에 의해 추상화 된 대상은 독립적으로 존재할 수 없게 되므로 자식 클래스에서 대상을 구체화해야만 정상적으로 사용이 가능합니다.

interface는 추상화된 객체에 몇가지 제약을 더해 외부에서 편하고 안전하고 기능을 사용할 수 있도록 도와주는 키워드입니다. interface는 C#에서 유일하게 다중상속이 허락된 객체이지만, 다중상속의 위험성을 방지하기 위해 부모 클래스는 가지는 것이 불가능하고 멤버 변수를 가질 수 없습니다. 또한, 내부에 선언된 메서드는 모두 자식 클래스에서 재정의되어야만 합니다. 

객체 지향의 4가지 특징은 상속, 캡슐화, 추상화, 다형성입니다. 상속은 한 클래스 내부에서 선언, 정의한 것을 다른 클래스가 물려받는 것을 의미합니다. 이는 객체의 성질을 표현하는 것에도 도움이 되지만 코드의 재사용성을 높이는 것에도 도움이 됩니다.

캡슐화는 연관이 있는 특성을 묶어 내부에서 구현한 뒤, 구체적인 구현부는 외부에 공개하지 않고 기능 사용에 관련된 인터페이스만 공개하는 것을 의미합니다. 캡슐화가 잘 된 객체의 경우 외부에서 객체의 성질을 함부로 변형할 수 없지만, 필요에 따라 객체에서 제공하는 기능은 사용할 수 있기 때문에 안정성, 유지보수성 등을 높일 수 있습니다. 

추상화는 클래스를 상속받을 대상의 공통적인 속성을 추려내는 것을 의미합니다. 자식 클래스들이 모두 공통적인 속성을 보유하고 있다면, 해당 속성과 관련된 메서드, 멤버 변수 등을 부모 클래스에서 선언한 뒤 자식 클래스에서 이를 정의하는 방향으로 설계할 수 있습니다. 이러한 과정을 거치면 다양한 자식 클래스가 통일성 있게 작동할 수 있습니다.

다형성이란 대상이 다양한 모습으로 표현되고 사용될 수 있는 것을 의미합니다. 상속 관계에 있는 클래스가 부모 클래스로도 표현될 수 있고 자식 클래스로도 표현될 수 있는 것이 다형성의 대표적인 예시입니다.

이러한 객체지향의 특징을 살리는 방향으로 코드를 설계한다면 안전하고 유지보수가 용이하며 사용이 편리하고 가독성이 높은 코드를 설계할 수 있습니다.

LOD는 특정 기준에 따라 버텍스의 수를 조절하여 매쉬의 디테일 수준을 조절하는 기법입니다. 멀리 있는 대상 혹은 작게 그려지는 대상을 디테일하게 렌더링하는 것은 연산의 낭비로 이어질 수 있기 때문에, 거리, 투영면적 등의 기준에 따라 LOD단계를 조절하여 최적화를 달성할 수 있습니다.

밉맵은 LOD와 동일한 기술을 텍스쳐에 적용하는 기술입니다. 디테일하게 렌더링 될 필요가 없는 대상의 텍스쳐 해상도를 낮춰 연산 낭비를 줄이는 기법입니다.

두 기술 모두 속도 측면에선 최적화에 큰 도움이 되지만, 단계별 리소스를 별도로 저장해야 하기 때문에 메모리를 많이 사용하게 된다는 단점이 있습니다.

렌더링 파이프라인이란, 데이터로만 존재하는 오브젝트를 모니터에 출력하기 위해 거치는 일련의 과정을 의미합니다. 렌더링 파이프라인은 3D공간에 있는 물체에 WVP 행렬을 곱하여 2D 평면에 투영한 뒤, 뷰포트 행렬을 통해 대상이 그려질 픽셀을 건져내고 쉐이더 등을 통해 최종적인 색상을 결정하는 과정으로 진행됩니다.

멤버 변수나 메서드가 인스턴스에 종속되지 않고 클래스에 종속되도록 만들어주는 키워드입니다.

static으로 생성된 멤버 변수는 프로세스가 생성되고 초기화되는 과정에서 메모리에 저장되기 때문에 인스턴스가 생성되지 않은 시점에서도 대상을 사용할 수 있게 됩니다. static 멤버 변수는 데이터 영역에 위치하는 만큼, 멤버 변수가 인스턴스별로 생성되는 것이 아니라 모든 인스턴스가 하나의 변수를 공유하여 사용하게 됩니다. 여러 인스턴스가 하나의 변수를 공유하는 만큼 static 멤버 변수의 데이터의 안전성을 보장할 수 있는 방향으로 설계해야 합니다.

static 메서드의 경우는 함수를 호출하는데 this가 필요하지 않기 때문에 인스턴스가 없어도 독립적으로 사용할 수 있게 됩니다. 다만, 이러한 이유 때문에 함수 내부에서 this가 필요한 작업은 수행할 수 없다는 단점이 있습니다.

컬렉션이란, 닷넴 프레임워크에서 지원해주는 데이터 관리용 클래스를 의미합니다.

List는 generic을 기반으로 데이터를 보관하는 자료구조이고, ArrayList는 object를 기반으로 데이터를 보관하는 자료구조 입니다.

List는 generic을 사용하는 만큼 선언할 때 명시한 자료형에 해당하는 데이터만 저장할 수 있지만, ArrayList는 C#의 모든 객체가 공통으로 상속받고 있는 object 자료형으로 데이터를 저장하기 때문에 모든 자료형의 데이터를 저장할 수 있습니다.

List는 자료형이 한정되어 있는 만큼 ArrayList에 비해 활용성이 다소 제한되어 있지만, 그만큼 안정성이 높으며 boxing, unboxing과정을 거치지 않아 성능 부분에서도 우위에 있다는 장점이 있습니다. 반대로 ArrayList는 안정성이 낮고 boxing, unboxing 과정으로 인해 느린 속도를 보인다는 단점이 있지만 활용성이 매우 넓다는 장점이 있습니다. 

두 알고리즘 모두 그래프를 완전탐색하는 알고리즘입니다. BFS는 너비우선탐색으로 시작 노드와 가까이에 있는 노드를 우선적으로 탐색하는 알고리즘입니다. 반면, DFS는 노드의 자식노드를 재귀적으로 순회하며 탐색하는 알고리즘입니다. BFS는 가까이에 있는 대상을 DFS보다 먼저 탐색할 확률이 높지만, DFS는 반대로 멀리 있는 대상을 BFS보다 먼저 탐색할 확률이 높다는 차이가 있습니다.

모든 데이터는 차지하는 메모리 크기의 배수에 해당하는 메모리 주소에 위치해야 합니다. 구조체처럼 메모리에 연속적으로 위치해야 하는 데이터들이 메모리 주소에 올바르게 위치하려면 데이터 사이에 패딩 데이터를 추가하여 데이터가 위치하는 메모리 주소를 맞춰주어야 합니다. 이를 메모리 정렬이라고 합니다. 

메모리 풀링 등을 사용하여 미리 할당한 메모리영역 내에서 메모리가 비효율적으로 사용되는 것을 의미합니다. 실제 필요한 메모리 공간에 비해 불필요하게 많은 메모리를 할당하는 경우 내부 단편화가 발생할 수 있습니다.

프로그래머가 유니티 엔진을 사용할 때는 C#을 사용해 코드를 작성하게 됩니다. 닷넴 프레임워크에서 작동되는 C#은 컴파일 타임에 IL이라는 중간언어로 번역되고  IL이 런타임에 기계어로 변환되는 과정을 거치지만, 유니티 엔진은 그러한 과정을 거치지 않고 IL을 다시 C++로 디컴파일 한 뒤 다시 기계어로 컴파일하는 과정을 거칩니다. 이 작업을 통해 실제로 실행되는 게임은 C++ 코드로 실행되며 닷넴 프레임워크에 의해 실행될 때에 비해 높은 성능을 가지게 됩니다. 

내적은 두 벡터의 방향이 얼마나 일치하는지를 구하는 수학적 개념입니다. 두 벡터를 내적하게 되면 두 벡터의 길이와 사잇각의 코사인 값을 곱한 스칼라 값을 얻을 수 있습니다. 두 벡터의 길이를 안다면 두 벡터의 사잇각을 구할 수 있기 때문에, 게임 프로그래밍에선 두 오브젝트의 위치 관계를 구하는데 사용할 수 있습니다.

외적은 두 벡터가 속한 평면의 법선 벡터를 구하는 수학적 개념입니다. 두 벡터를 외적하게 되면, 두 벡터에 모두 수직인 벡터를 구할 수 있습니다. 이를 활용하여 두 오브젝트의 위치 관계를 구하는데 사용할 수 있습니다.

내적의 경우, 대상이 나의 앞에 있나 뒤에 있나를 구할 수 있지만 왼편에 있는지 오른편에 있는지는 구할 수 없기 때문에 외적을 추가적으로 사용하여 나의 왼편에 있는지 오른편에 있는지를 구할 수 있습니다.

CPU의 코어는 동시에 여러 작업을 수행할 수 없습니다. 하지만, 실제 컴퓨터에선 여러 작업이 동시에 수행되어야 하기 때문에 CPU는 프로세스를 작은 작업으로 쪼갠 뒤 이를 고속으로 번갈아 수행하며 여러 프로세스가 동시에 실행되는 것처럼 보이게 해줍니다. 

이처럼 여러 프로세스가 번갈아가며 수행될 때 효율성을 높이기 위해선 프로세스를 어떤 순서로 얼만큼씩 작업하는가를 구체적으로 설정할 필요가 있습니다. 이를 구체적으로 설정하는 작업을 프로세스 스케줄링이라 하며 이는 운영체제에 의해 수행됩니다.

선점형 스케줄링이란 한 작업이 실행되고 있을 때 다른 작업을 수행하기 위해 현재 작업이 중단될 가능성이 있는 스케줄링을 의미합니다. 

비선점형 스케줄링이란 현재 실행중인 작업이 완료되기 전까진 다른 작업을 수행하지 않는 스케줄링을 의미합니다.

소켓 통신이란, 소켓을 사용하는 통신 방법을 의미합니다. 소켓을 사용하여 서버와 클라이언트가 특정 포트번호를 통해 양방향으로 통신하는 방식으로, TCP 프로토콜의 통신 방법입니다.

깊은 복사의 단점인 성능 저하를 최소화하기 위해, 다시는 사용되지 않을 것이 확신한 객체를 복사할 때 얕은 복사를 응용한 이동 연산을 사용하는 최적화 기법입니다.

자료형을 프로그래머가 명시하지 않고 컴파일러의 추론에 맡기는 키워드 입니다. 자료형이 길고 복잡하거나 프로그래머가 추론하기 힘든 상황에 편리하게 사용할 수 있지만, 자료형을 한 눈에 알아볼 수 없기 때문에 가독성이 저하될 수 있다는 단점이 있습니다.

private void SelectShopItem()
{
    DevFunctions.WriteLineColored("구매하고 싶은 물건의 번호를 입력하세요.", ConsoleColor.Cyan);
    Console.WriteLine(); 

    Console.Write("1. 사과 : ");
    DevFunctions.WriteColored("30원", ConsoleColor.Red);
    DevFunctions.WriteLineColored("[사용시 HP를 50 회복합니다.]", ConsoleColor.Green);

    Console.Write("2. 배 : ");
    DevFunctions.WriteColored("50원", ConsoleColor.Red);
    DevFunctions.WriteLineColored("[사용시 HP를 100 회복합니다.]", ConsoleColor.Green);

    Console.Write("3. 필살의 영약 : ");
    DevFunctions.WriteColored("200원", ConsoleColor.Red);
    DevFunctions.WriteLineColored("[사용시 다음 공격의 크리티컬 확률이 50% 증가합니다.]", ConsoleColor.Green);

    Console.WriteLine("4. 구매를 종료합니다.");

    string input = Console.ReadLine();

    if (DevFunctions.IsNumeric(input) == false)
    {
        return;
    }

    if (input.Length > 1)
    {
        return;
    }

    int toInt = int.Parse(input);

    switch (toInt)
    {
        case 1:
            BuyItem(ItemName.사과);
            break;
        case 2:
            break;
        case 3:
            break;
        case 4:
            _updateFunc = null;
            _selectFunc = new SelectFunc(SelectMenu);
            _shopMsg = null;
            break;
    }
}

 private void BuyItem(ItemName itemName)
 {
     if (Item.isCanBuy(_parentCore.CurrentPlayer, itemName) == true)
     {
         SetShopMsg_Buy(itemName);
         Item.BuyItem(_parentCore.CurrentPlayer, itemName);
     }
     else
     {
         SetShopMsg_Failed();
     }
 }
 
 private void SetShopMsg_Buy(ItemName itemName)
{
    _shopMsg = new Tuple<string, ConsoleColor>(itemName.ToString() + "를 구매하였습니다", ConsoleColor.Blue);
}

private void SetShopMsg_Failed()
{
    _shopMsg = new Tuple<string, ConsoleColor>("소지 금액이 모자랍니다.", ConsoleColor.Red);
}

public static bool isCanBuy(Player player, ItemName itemName)
{
    switch(itemName)
    {
        case ItemName.사과:
            return (player.Money >= 30);
    }

    return false;
}

public static void BuyItem(Player player, ItemName itemName)
{
    switch (itemName)
    {
        case ItemName.사과:
            player.Inventory.Add(new Apple());
            player.Money -= 30;
            break;
    }
}

private void WriteShopMsg()
{
    string Str = "소지 금액 : " + _parentCore.CurrentPlayer.Money.ToString();
    DevFunctions.WriteLineColored(Str, ConsoleColor.Yellow);

    if (_shopMsg != null)
    {
        DevFunctions.WriteLineColored(_shopMsg.Item1, _shopMsg.Item2);
    }
}