Brain Backup

[Unity] UnityWebRequest.Post을 사용한 json전송의 문제

게임 개발자(진) — Sat, 4 Mar 2023 16:42:18 +0900

어떤 문제?

프로젝트에서 사용하고 있는 유니티 에디터 버전: 2020.3.42f1

//ex_WWW는 UnityWebRequest객체

ex_WWW = UnityWebRequest.Post(ex_URL, data); //data는 json을 string으로 변환한 것
ex_WWW.downloadHandler = (DownloadHandler)new DownloadHandlerBuffer();
ex_WWW.SetRequestHeader("Content-Type", "application/json");

위처럼, UnityWebRequest.Post를 사용해서 string형식의 json을 바로 보내려고 시도하면 이론상 정상적으로 보내져야 하지만, 현재 제대로 보내지지 않습니다

패킷을 확인해보아도 JSON이 아닌, Line-based text data로 인식되고 있습니다.

유니티 포럼

링크

UnityWebRequest.Post(url, jsonData) sending broken Json

I'm doing the following: (Don't worry it will be over HTTPS) UnityWebRequest.Post(url,jsonData) The json data is as follows: {"username":"some...

forum.unity.com

유니티에 재직중인 개발자의 과거 발언에 따르면,

UnityWebRequest.Post(string,string)에서 2번째 인자로 넘겨주는 내가 보내고자하는 string데이터는 application/x-www-form-urlencoded라고 가정하고 처리가 되는 것 같습니다.

따라서 UnityWebRequest.Post를 이용한 json 전송은 지양해야할 것 같습니다.

그럼 json을 어떻게 Post?

따라서, 의도대로 string 형태의 json을 보내고 싶다면

0. UnityWebRequest를 생성해주면서 method를 Post로 설정해줍니다.

ex_WWW = new UnityWebRequest(ex_URL, "POST");

1. string 형식의 json을 (여기선 data) utf8로 인코딩한 후 byte배열로 얻습니다.

byte[] jsonToSend = System.Text.UTF8Encoding().GetBytes(data);

2. UploadHandlerRaw를 통해서 앞서 얻은 byte배열을 uploadHandler에 집어넣어 줍니다.

ex_WWW.uploadHandler = new UploadHandlerRaw(jsonToSend);

3. 서버로부터 응답정보를 얻기 위해서 downloadHandler를 설정해줍니다.

ex_WWW.downloadHandler = (DownloadHandler)new DownloadHandlerBuffer();

4. RequestHeader를 json으로 설정해줍니다.(서버에서 json이라고 인식할수있게)

ex_WWW.SetRequestHeader("Content-Type", "application/json");

[Unity] PlayerPrefs을 활용한 데이터 저장

게임 개발자(진) — Sat, 4 Mar 2023 14:44:27 +0900

PlayerPrefs란?

유니티에서 데이터 관리를 위해 제공해주는 클래스입니다.

int, float, string, bool 타입의 변수를 저장/불러오기 기능을 제공해줍니다.

멤버 함수

* DeleteAll => 모든 키 값을 삭제
* DeleteKey => 특정 키 값을 삭제
* GetFloat => 지정한 float 타입의 키 값을 로드
* GetInt => 지정한 int 타입의 키 값을 로드
* GetString => 지정한 String 타입의 키 값을 로드
* HasKey => 해당 키가 존재하는 여부를 반환
* Save => 변경된 모든 키 값을 물리적인 저장 공간에 저장
* SetFloat => 지정한 키로 float 타입의 값을 저장
* SetInt => 지정한 키로 int 타입의 값을 저장
* SetString => 지정한 키로 string 타입의 값을 저장

PlayerPrefs.SetString("Name", 스트링값);
//위와같은 방식으로 사용합니다.
//첫번째 인자는 Key로 사용되고, 두번째 인자는 Value로 들어가게 됩니다.

값 저장 위치

유니티에서 설정한 ComPany Name과 Product Name을 기준으로 저장위치가 정해집니다.

1. 레지스트리 편집기를 실행한후

2. HKEY_CURRENT_USER => SOFTWARE => Unity => UnityEditor => [Company Name] => [Product Name]

[C++ 서버] 여러개의 lock을 잡을때

게임 개발자(진) — Sun, 26 Feb 2023 05:35:14 +0900

std::lock(), std::adopt_lock

mutex m1;
mutex m2;


std::lock(m1,m2);
//내부적으로 정한 방식에 의해서 항상 동일한 순서로 m1,m2의 lock을 걸어줍니다.
//먼저 lock걸리는것이 무엇인지는 모르지만 매번 그 순서는 동일합니다.


lock_guard<mutex> g1(m1,std::adopt_lock);
lock_guard<mutex> g2(m2,std::adopt_lock);
//std::adopt_lock : 이미 lock된 상태니까, 나중에 소멸될 때 unlock 해줘!

std::lock()을 통해서 일정한 순서를 유지한채 lock을 걸 수 있습니다.

2개 이상의 mutex가 들어 갈 수 있습니다.

무엇이 먼저 lock걸릴지는 모르지만 항상 그 순서는 일정합니다.

lock_guard<>()에 std::adopt_locck을 옵션으로 주어서

소멸될때 unlock시키는 방법도 가능합니다.

그 외 아이디어

mutex를 다루는 별도의 클래스를 만들어주고, 일종의 ID를 부여해서, 무조건 ID가 큰 애가 먼저 실행이 되어야 하는등 규칙을 설정하기.
아래 그림처럼 Lock을 그래프를 통해서 추적해서, 순환이 일어나는지 확인하기(순환이 일어나면 비정상 상황으로 간주)

[C++ 서버] Lock 기초(mutex)

게임 개발자(진) — Sat, 25 Feb 2023 23:40:08 +0900

mutex를 활용한 lock

#include "pch.h"
#include <iostream>
#include <thread>
#include <mutex>

vector<int32> v;
mutex m;

void Push()
{
	for (int32 i = 0; i < 10000; i++)
	{
		//자물쇠 잠그기
		m.lock();

		v.push_back(i);

		//자물쇠 풀기
		m.unlock();
	}
}

int main()
{  
	std::thread t1(Push);
	std::thread t2(Push);
	t1.join();
	t2.join();
}

lock(), unlock()을 통해서 상호배제(Mutual Exclusion)을 수행합니다.

(뮤텍스와 세마포어의 차이가 궁금하다면? 링크)

std::lock_guard<>의 원리

위처럼 lock(), unlock()을 사용자가 직접 적어주게 된다면, 코드가 길어질수록 실수의 여지가 생기게 됩니다.

그래서 나타난 것이 RAII(Resource Acquisition Is Initialization)패턴을 사용한 방법입니다.

c++에서는 RAII패턴을 사용한 lock방식인 std::lock_guard<>를 제공해줍니다.

그 원리를 알기위해서 먼저, std::lock_guard<>를 사용하지않고 직접 구현해서 사용해보겠습니다.

#include "pch.h"
#include <iostream>
#include <thread>
#include <mutex>

vector<int32> v;
mutex m;

template<typename T>
class LockGuard
{
public:
	LockGuard(T& m)
	{
		_mutex = &m;
		_mutex->lock();
	}
	~LockGuard()
	{
		_mutex->unlock();
	}

private:
	T* _mutex;
};

void Push()
{
	for (int32 i = 0; i < 10000; i++)
	{
		LockGuard<std::mutex> lockGuard(m);
		v.push_back(i);
	}
}

int main()
{  
	std::thread t1(Push);
	std::thread t2(Push);
	t1.join();
	t2.join();
}

LockGuard 클래스를 보시면 작동 원리를 알 수 있습니다.

생성자에서 락을 걸어주고,

소멸자에서 자동으로 락을 풀어줍니다.

즉, LockGuard가 존재하는 { }범위를 벗어나면 자동으로 lock이 해제되는 방식입니다!

실수를 많이 줄일수 있겠죠??

std::lock_guard<> 사용법

#include "pch.h"
#include <iostream>
#include <thread>
#include <mutex>

vector<int32> v;
mutex m;

void Push()
{
	for (int32 i = 0; i < 10000; i++)
	{
		std::lock_guard<std::mutex> lockGuard(m);
		v.push_back(i);
	}
}

int main()
{  
	std::thread t1(Push);
	std::thread t2(Push);
	t1.join();
	t2.join();
}

C++에서는 직접 구현할필요없이 std::lock_guard<>를 제공하기 때문에 위처럼 간편히 사용 가능합니다.

std::unique_lock<> 사용법

std::unique_lock<>이란 std::lock_guard<>와 비슷하지만 기능이 추가된 녀석입니다.

mutex m;
std::unique_lock<std::mutex> uniqueLock(m);

이런식으로 사용하면 std::lock_guard<>와 동일한 기능을 수행합니다.

mutex m;
std::unique_lock<std::mutex> uniqueLock(m,std::defer_lock);

~~~~//여러 코드들 

uniqueLock.lock() //이때 잠기게 됨

그러나 옵션으로 std::defer_lock을 인자로 전달하면 lock이 생성하는 즉시 잠기는 것이 아닌, 그 시점을 프로그래머가 정할수있습니다. (defer: 미루다, 연기하다)

lock()멤버 함수를 사용해서 그 시점을 정하게 됩니다.

[C++서버] Atomic

게임 개발자(진) — Sat, 25 Feb 2023 07:06:33 +0900

Atomic의 필요성

#include <iostream>
#include <thread>

int sum = 0;

void Add()
{
	for (int32 i = 0; i < 100'0000; i++)
	{
		sum++;
	}
}

void Sub()
{
	for (int32 i = 0; i < 100'0000; i++)
	{
		sum--;
	}
}
int main()
{  
	std::thread t1(Add);
	std::thread t2(Sub);
	t1.join();
	t2.join();
	cout << sum;
}

쓰레드 2개를 이용해서 동시에 전역변수(data영역) sum에 접근하는 코드를 예시로 들겠습니다.

그냥 생각했을때는 더하는 횟수와 빼는 횟수가 같기 때문에 0이 출력될것이라고 생각됩니다.

그러나 실제로는 매번 값이 바뀌지만 0이 아닌 값이 나오게 됩니다.

왜 그럴까요?

sum++을 어셈블리단에서 파해쳐보겠습니다.

간단히 설명하자면

1. 메모리 주소에 있는 값을 eax레지스트리로 가져온다.
2. eax레지스트리의 값을 1증가시킨다.
3. eax레지스트리의 값을 다시 원래 메모리주소에다가 붙여넣어준다

.의 과정을 거치게 됩니다.

즉, Add()를 실행하는 쓰레드와 Sub()를 실행하는 쓰레드가 서로 비동기적으로 실행되기때문에

예를 들어 sum=0일때

Add()함수, Sub()함수 모두 2번의 과정까지 진행됐다고 가정하고

Add()가 먼저 3번과정을 통해서 메모리에다가 1을 집어넣으면

Sub()가 3번과정을 통해서 자신이 계산한 -1값을 같은 메모리주소에다가 넣어주게됩니다.

즉, 실제로는 더하기,빼기가 한번씩 일어났지만 -1이 최종값이 들어가게 되는 상황이 되는겁니다.

이러한 상황을 막기 위해서는 위 1~3번 과정을 한번에 실행시킨다는 보장이 필요합니다.

이를 위해 사용하는것이 Atomic입니다.

Atomic 사용법

#include <iostream>
#include <thread>
#include <atomic> //atomic헤더 파일 필요!!

atomic<int32> sum = 0; //atomic 사용법

void Add()
{
	for (int32 i = 0; i < 100'0000; i++)
	{
		sum++;
	}
}

void Sub()
{
	for (int32 i = 0; i < 100'0000; i++)
	{
		sum--;
	}
}
int main()
{  
	std::thread t1(Add);
	std::thread t2(Sub);
	t1.join();
	t2.join();
	cout << sum;
}

-헤더: #include <atomic>
-사용법: atomic<자료형> 변수명

위처럼 atomic을 사용하게되면 정상적으로 0이 출력됩니다.

이때 sum++대신

sum.fetch_add(1)

sum--대신

sum.fetch_add(-1)

을 사용해도 똑같습니다.

[C++서버] 쓰레드 기초

게임 개발자(진) — Sat, 25 Feb 2023 00:16:09 +0900

쓰레드 생성(std::thread)

#include <iostream>
#include <thread> //헤더파일

void HelloThread()
{
	cout<<"Hello Thread"<<endl;
}

void HelloParam(int32 num)
{
	cout<<num<<endl;
}

int main()
{
	std::thread t0(HelloThread); //쓰레드 생성 및 실행
    
    std::thread t1; //쓰레드 생성만 한 상태.
    t1=std::thread(HelloThread); //이런식으로 실행가능
    
    std::thread t2(HelloParam,17); //이런식으로 인자 넘기기 가능
}

join()

#include <iostream>
#include <thread> //c++ 11부터 표준
void HelloThread()
{
	cout << "Hello Thread" << endl;
}

int main()
{
	std::thread t(HelloThread);
	cout << "Hello Main" << endl;
    
	t.join(); //메인쓰레드에서 t가 끝날때까지 기다린다. 안쓰면 오류
}

위 상황일때, 자식 쓰레드(t)가 아직 실행중인데, 부모 쓰레드(main)가 종료된다면 문제가 생길 수 있습니다.

이 상황을 막기 위해서 C++에서 join() 멤버함수를 제공합니다.

위 상황에서는 main함수는 t.join()을 만난 순간, t쓰레드의 실행이 다 끝날때까지 기다렸다가 끝난다면 이어서 실행하게 됩니다.

메인 스레드가 종료되고도 자식 스레드가 계속 실행중이라면 비정상적인 상황으로 간주하는데, 이것이 의도한 것이라면 detach()함수를 사용해야 합니다.

joinable()

#include <thread> //c++ 11부터 표준

void HelloThread()
{
	cout << "Hello Thread" << endl;
}

int main()
{
	std::thread t(HelloThread);

	cout << "Hello Main" << endl;

	if(t.joinable())
		t.join();
}

joinable()은 해당 쓰레드의 id가 0인지 아닌지를 체크하는 기능을 합니다.

즉,

std::thread t;

if(t.joinable())
	cout<<"통과";

위 코드라면, 쓰레드 t가 살아있지 않기때문에 "통과"가 출력되지 않습니다.

hardware_concurrency()

std::thread t(HelloThread);

int32 count=t.hardware_concurrency(); //cpu의 쓰레드 갯수

동시적으로 동작할수있는 CPU의 쓰레드 갯수를 알려줍니다.

만약 이 정보가 사용가능하지 않다면 0을 리턴해줍니다.

get_id()

std::thread t(HelloThread);

auto id=t.get_id(); //쓰레드마다 id. 1234이런건아닌데 다 다름

쓰레드에 부여된 id를 확인할 수 있습니다.

detach()

링크

실행 스레드를 스레드 개체에서 분리하여 실행이 독립적으로 계속되도록 합니다. 할당된 리소스는 스레드가 종료되면 해제됩니다.

detach()를 호출한 이후에 *this는 더 이상 어떤 쓰레드도 소유하지 않습니다.

[Unity] UI에서 블로커 구현하기

게임 개발자(진) — Sun, 19 Feb 2023 22:04:08 +0900

블로커란?

위처럼 게임 옵션ui를 켰을때, ui를 제외한 다른 부분은 클릭을 눌러도 반응하지 않게 구현하고 싶을때가 있습니다.

이럴때 블로커를 구현하여서 개발자의 의도대로 옵션ui만 클릭이 되도록 할 수 있습니다.

블로커 구현

1. 블로커를 구현하고자 하는 UI 프리팹을 선택합니다.

2. image 오브젝트를 추가해줍니다. 전 이름을 Blocker로 바꾸겠습니다.(자유)
그리고 크기를 카메라를 다 덮을 크기로 설정해줍니다.

Alpha값 0으로 설정

3. 방금 생성한 image의 Color속성에서 A(투명도 값)을 0으로 설정해줍니다. 그럼 투명한 Blocker가 됩니다.
그리고 반드시 Raycast Target이 체크되어 있어야합니다.

4. 반드시 Blocker는 가장 위로 올려줘야 합니다. 아래서부터 위로 인식하기 때문에, 가장 아래에 둔다면 정작 의도한 ui의 클릭도 먹통이 되어 버립니다.

[Unity] 현재 애니메이터의 상태(state), 파라미터 값 아는 방법

게임 개발자(진) — Sat, 18 Feb 2023 20:12:44 +0900

상태 아는 방법

상황: 현재 Hit애니메이션이 실행중인지를 알고 싶을때

애니메이터

anim = GetComponent<Animator>();

anim.GetCurrentAnimatorStateInfo(0).IsName("Hit")

애니메이터.GetCurrentAnimatorStateInfo(해당 레이어의 인덱스).IsName(스테이트의 이름)

을 통해서 알 수 있습니다.

true/false를 반환해줍니다.

파라미터 값 아는 방법

anim.GetCurrentAnimatorStateInfo(0).speed;

애니메이터.GetCurrentAnimatorStateInfo(해당 레이어의 인덱스).파라미터이름

을 통해서 알 수 있습니다.

리턴값은 AnimatorStateInfo입니다.

공식 문서 링크

[Unity] 헤더추가로 인스펙터 깔끔하게 정리하기!

게임 개발자(진) — Sat, 18 Feb 2023 20:11:31 +0900

헤더추가 전

스크립트

인스펙터

헤더추가 후

[Header("~~~")] 사용

스크립트

인스펙터

[Unity] 애니메이션 이벤트

게임 개발자(진) — Sat, 18 Feb 2023 20:10:39 +0900

애니메이션 이벤트는 왜 사용하는가?

예를 들면, 달리는 애니메이션을 적용하는데, 발이 땅에 닿는 순간에만 발자국 소리를 내고 싶습니다.

이때, 애니메이션창을 통해서 확인했을때, 발이 땅에 닿는 순간에 이벤트를 추가하여 자신이 미리 설정해둔 함수를 실행시키게 설정해둔다면(이 경우엔 발자국 소리를 내는 함수가 되겠습니다.) 깔끔하게 구현이 가능해집니다.

사용 방법

Ctrl+6 또는 위 과정을 통해 애니메이션창 키기

1. 먼저 애니메이션 창을 Ctrl+6 또는 위 과정을 통해서 켜줍니다.

애니메이션창

2. 그럼 위와같은 애니메이션 창이 나타납니다.

애니메이션이 적용돼있는 프리팹

3. 애니메이션이 적용돼있는 프리팹을 더블 클릭해줍니다. 이때, 해당 프리팹은 당연히 Animator 컴포넌트가 있어야 하고, 이벤트를 발생시킬때 사용할 함수가 정의돼있는 스크립트가 있어야 합니다!!

4. 그럼 애니메이션창에서 해당 프리팹의 Animator에 들어있는 애니메이션들의 목록이 나타나게 됩니다.
애니메이션 이벤트를 추가하고 싶은 애니메이션을 선택해 줍니다.

애니메이션 이벤트 적절한 위치에 추가

5. 자기가 원하는 애니메이션의 타이밍에 맞춰서 Add Animation Event를 해줍니다. (우클릭)

이벤트 함수 설정해주기

6. 추가한 애니메이션 이벤트를 누르면 인스펙터창에 어떤 함수를 연동해줄건지 고르는 창이 뜹니다.
여기에 뜨는 함수의 목록은 당연히 해당 프리팹의 스크립트 상에 있는 함수들만 뜨게 됩니다.

뱀서라이크 게임(유티니 엔진)

게임 개발자(진) — Mon, 6 Feb 2023 16:51:32 +0900

VR Story(언리얼 엔진을 활용한 vr교육용 게임)

게임 개발자(진) — Sat, 4 Feb 2023 22:50:34 +0900

언리얼 엔진

문장을 만들어서 vr기기로 해당 문장을 구현해주는 게임을 목표로 하였기 때문에 사실적인 그래픽이 중요했습니다.

따라서 언리얼 엔진을 사용하기로 결정하였습니다.

맵

메인메뉴등을 담당하는 메인 맵, 도시 맵, 산 맵, 평지 맵, 집 맵

이렇게 총 5개를 구현하였습니다.

산 지형을 구현하는 곳에서는 Landmass를 이용하여서 지형을 만들었습니다.

나무,꽃,풀 등을 랜덤으로 빠르게 배치하기 위해서 폴리지 툴을 사용하였습니다.

에셋들을 환경에 맞게 배치했습니다.

포인트 라이트 와 리플렉션등을 배치해서 사실적인 맵 구현에 힘썼습니다.

VR에서 텔레포트 기능 구현 및 AI이동을 위한 정보를 얻기 위해서 NavMeshBoundsVolume을 배치했습니다.

애니메이션

에픽스토어에 존재하는 애니메이션은 최대한 사용하였으며, 없을시에는 컨트롤릭을 사용해서 직접 애니메이션을 구현하였습니다.

시간마다의 각 스켈레톤의 위치를 지정하여서 애니메이션을 만들었습니다.

블루프린트/C++

애니메이션, 위젯 등 빠르게 결과물을 내야하는 곳에서는 블루프린트를 사용하였으며,

문장 구조 저장 및 구현등의 메인 로직은 c++은 사용하였습니다.

vr 기능 추가

넓은 맵을 이동하게 하기 위해서 VR컨트롤러의 버튼을 통해서 표시된 위치로 순간이동 하는 기능을 만들었습니다.

그리고 UI를 직접 클릭하려면 VR 특성상 직접 다가가려면 힘들기 때문에 컨트롤러에서 레이저를 발사하여 충돌여부를 판단하게해서 원거리 상호작용을 구현하였습니다.

컨트롤러 좌 메뉴버튼을 누르면 메인메뉴로 돌아가는 버튼, 새 문장을 만드는버튼, 서버에 현재 세상을 업로드하는 버튼을 만들어놨습니다.

HUD

VR에서는 일반적으로 스크린에 표시하는 위젯이 구현되지않습니다.

무조건 3D 위젯만 가능하기 때문에 카메라에 3D위젯을 붙이는 대신, depth계산을 안해서 카메라와 이 위젯사이에 다른 물체가 와도 가려지지 않게 했습니다.

서버

●API 서버에는 Django + Django rest framework 모듈을 사용합니다

●Django에서는 기본적인 백엔드 서버 라이브러리를 제공하며, DB 데이터를 python에서 타입으로 다룰 수 있게 제공합니다.

●Django restful framewor에서는 데이터 CRUD 연산에 대해 브라우저 API와 JSON API 형태를 둘 다 제공하는데,

●이를 통해 적은 개발 비용으로 사용자와 어플리케이션에 대해 지원하며,

●관리자는 웹브라우저로 접근해서 데이터를 편하게 관리할 수 있고 어플리케이션에서는 rest api로 접근해서 데이터를 바로 사용할 수 있게 합니다.

인게임 영상

https://youtu.be/uBLQJ81vsuo

[Unity] Json을 이용한 데이터 관리

게임 개발자(진) — Fri, 3 Feb 2023 01:58:05 +0900

기본 사용법(유니티 기능)

{
  "stats": [
    {
      "level": "1",
      "hp": "100",
      "attack": "10"
    },
    {
      "level": "2",
      "hp": "150",
      "attack": "15"
    },
    {
      "level": "3",
      "hp": "200",
      "attack": "20"
    }
  ]
}

위와 같은 내용을 지닌 Json을 가지고 예시를 들겠습니다. (파일 경로: Data/StatData )

[Serializable]
public class Stat
{
	public int level;
	public int hp;
	public int attack;
}

[Serializable]
public class StatData
{
	public List<Stat> stats = new List<Stat>();
}

public void Init()
{
	TextAsset textAsset = Resources.Load<TextAsset>("Data/StatData");
    StatData data = JsonUtility.FromJson<StatData>(textAsset.text);
}

[Serializable] 붙여줘야 함

JsonUtility.FromJson<>(); 사용 ==> List형태로 저장됨

위처럼 Json의 내용을 클래스로 쪼개서 최종적으로는 List형태로 저장이 됩니다.

(위 코드에선 stats 리스트에 모든 내용이 저장됨.)

이때 주의점은, level,hp,attack,stats의 이름이 반드시 Json에 있는 단어와 같아야 합니다.

자료형도 같아야 합니다.

그리고 접근지정자는 public또는 [SerializeField]를 붙여줘야 합니다.

그러나, List보다는 딕셔너리를 사용해서 Key를 통해 접근하는 것이 아무래도 좋겠죠?

[Serializable]
public class Stat
{
	public int level;
	public int hp;
	public int attack;
}

[Serializable]
public class StatData
{
	public List<Stat> stats = new List<Stat>();
}

public void Init()
{
	public Dictionary<int, Stat> StatDict {get; private set;} = new Dictionary<int,Stat>();

	TextAsset textAsset = Resources.Load<TextAsset>("Data/StatData");
    StatData data = JsonUtility.FromJson<StatData>(textAsset.text);
    
    foreach(Stat stat in data.stats) //딕셔너리로 변환해주는 과정
    	StatDict.Add(stat.level,stat);
}

마지막 2줄을 통해서 리스트를 딕셔너리로 변환해 줄 수 있습니다.

(data.stats.ToDictionary();를 사용해도 되는 것으로 알지만 과거 ios쪽 버그가 있어서 꺼린다고 합니다..?)

데이터 매니저 및 데이터구조 따로 관리(참고)

/*데이터 매니저*/ //DataManager.cs
using System;
using System.Collections;
using System.Collections.Generic;
using UnityEngine;

public interface ILoader<Key, Value>
{
    Dictionary<Key, Value> MakeDict();
}

public class DataManager
{
    public Dictionary<int, Stat> StatDict { get; private set; } = new Dictionary<int, Stat>(); //외부에서 얘를 뽑아서 사용하게 될 것임.

    public void Init()
    {
        StatDict = LoadJson<StatData, int, Stat>("StatData").MakeDict();
    }

    Loader LoadJson<Loader, Key, Value>(string path) where Loader : ILoader<Key, Value>
    {
		TextAsset textAsset = Managers.Resource.Load<TextAsset>($"Data/{path}");
        return JsonUtility.FromJson<Loader>(textAsset.text);
	}

}

/*받아올 Json데이터 구조를 따로 관리*/ //Data.Contents.cs
using System;
using System.Collections;
using System.Collections.Generic;
using UnityEngine;

#region Stat

[Serializable]
public class Stat
{
	public int level;
	public int hp;
	public int attack;
}

[Serializable]
public class StatData : ILoader<int, Stat>
{
	public List<Stat> stats = new List<Stat>();

	public Dictionary<int, Stat> MakeDict()
	{
		Dictionary<int, Stat> dict = new Dictionary<int, Stat>();
		foreach (Stat stat in stats)
			dict.Add(stat.level, stat);
		return dict;
	}
}

#endregion

저는 위 방식을 사용해서 Json을 읽고 있습니다.

[Unity] 코루틴(Coroutine)

게임 개발자(진) — Thu, 2 Feb 2023 13:10:07 +0900

코루틴이란?

(좌)일반 함수 / (우) 코루틴

코루틴은 함수 실행중, 중간에 빠져나가고 다른 작업을하다가 다시 중단된 시점부터 이어서 실행하고를 가능하게 해주는 함수를 의미합니다.

그리고 코루틴의 실행은 어느 스레드에서든 가능합니다.(thread-safe를 의미하지는 않음.)

(A쓰레드에서 코루틴을 생성하고 실행하다가 중단하고, B스레드에서 다시 실행하더라도 코루틴은 중단 지점으로부터 정상적으로 재개된다는 것입니다.)

C#의 코루틴

C#자체가 코루틴을 지원하고 있습니다.

    class CoroutineTest : IEnumerable
    {
        public IEnumerator GetEnumerator()
        {
            yield return 1;
            yield return 2;
            yield return 3;
        }
    }
    
    void Init()
    {
    	CoroutineTest test = new CoroutineTest();
        foreach(int t in test)
        {
        	Debug.Log(t);
        }
    }
    
    //Init()실행시 출력 결과:
    //1
    //2
    //3

class Program
{
    public IEnumerator Coroutine()
    {
        int i = 0;
        Console.WriteLine($"Coroutine {++i}");
        yield return null;

        Console.WriteLine($"Coroutine {++i}");
        yield return null;

        Console.WriteLine($"Coroutine {++i}");
        yield return null;
    }
    
    static void Main(string[] args)
    {
        Program program = new Program();
        IEnumerator coroutine = program.Coroutine();

        Console.WriteLine("Main 1");
        coroutine.MoveNext();
        Console.WriteLine("Main 2");
        coroutine.MoveNext();
        Console.WriteLine("Main 3");
        coroutine.MoveNext();
    }
}

// OUTPUT :
// Main 1
// Coroutine 1
// Main 2
// Coroutine 2
// Main 3
// Coroutine 3

위와같이 사용 가능합니다.

IEnumerator와 yield를 이용하는 것입니다.

IEnumerator 객체에 MoveNext()를 사용해서 다음 yield return을 실행 가능해집니다.

    void Start()
    {
        IEnumerator enumerator = SomeNumbers();
 
        Debug.Log("=====================================");
 
        // MoveNext()에서 실제로 SomeNumbers()가 실행됩니다. 
        // 처음에는 "yield return 3;" 까지만 실행됩니다.
        while (enumerator.MoveNext()) 
        {
            object result = enumerator.Current;
            Debug.Log("Number: " + result);
        }
    }
  
    IEnumerator SomeNumbers()
    {
        Debug.Log("yield return 1");
        yield return 3;
        Debug.Log("yield return 2");
        yield return 5;
        Debug.Log("yield return 3");
        yield return 8;
        // 이후에는 함수의 끝을 만나게 되므로 더이상 yield(양보)가 일어나지 않습니다.
    }

yeid break;
//코루틴을 임의로 종료시키고 싶을때 사용

참고할만한 링크: 링크, 링크

유니티에서 코루틴

	private Coroutine co; //전역변수로 코루틴 변수 선언

	void Init()
    {
        co = StartCoroutine("CoExploadAfterSeconds", 4.0f);
        StartCoroutine("CoStopExplode", 2.0f);
    }

    IEnumerator CoStopExplode(float seconds)
    {
        Debug.Log("Stop Enter");
        yield return new WaitForSeconds(seconds);
        Debug.Log("Stop Execute!!!!");
        if (co != null)
        {
            StopCoroutine(co);
            co = null;
        }
    }

    IEnumerator CoExploadAfterSeconds(float seconds)
    {
        Debug.Log("Explode Enter");
        yield return new WaitForSeconds(seconds);
        Debug.Log("Explode Execute!!!!");
    }

결과

유니티에선 WaitForSeconds()를 활용하여 일정시간동안 코루틴함수를 중지시킬 수 있습니다.

StartCoroutine("코루틴함수명",인자) 를 통해서 코루틴함수를 실행 시킬 수 있으며,

StopCoroutine("코루틴함수명") 또는 위처럼 저장해놓은 co변수를 넣어서도 가능.

위 예시에서는 CoExploadAfterSeconds()를 통해서 Explode Enter를 먼저 출력한 후 4초 후에 Explode Execute 를 출력할 예정이었지만 CoStopExplode에서 2초만 기다리고 StopCoroutine(co)를 해줬기 때문에 Explode Excute!!!는 출력되지 않는 것을 확인할 수 있습니다.

위처럼 유니티에서는 함수의 실행 및 중단을 비동기적으로 관리하기 위해서 주로 사용됩니다.

[Unity] 애니메이션 및 행동 관리하기(with 스테이트 패턴)

게임 개발자(진) — Mon, 30 Jan 2023 06:21:00 +0900

그냥 조건문으로 관리하면 안되나?

처음 유니티를 배운 후, 캐릭터의 애니메이션 및 행동을 관리해주기 위한 스크립트를 짜보라 하면 보통 아래같은 방식으로 작성합니다

if(뛰는 중)
{
	뛰는 애니메이션 실행.
    움직일 목적지로 이동시킴.
    
    if(죽음)
    {
    	죽는 애니메이션 실행.
        각종 필요한 처리..
    	...
    }
    else
    {
    	if(속도를 줄여서 걷게됨)
        {
        	...
        }
    }
}
else if(먹는 중)
{
    if(죽음)
        {
            ...
        }
    else if()...
}

이런식으로 조건문속에 조건문을 넣고 넣고...

간단한 애니메이션과 상태를 지닌 게임이라면 이렇게 해도 무방합니다.

하지만 이 방식은 결국 코드가 복잡해지는 한계에 봉착합니다.

이를 해결할 수 있는 방식중에 하나가 스테이트 패턴을 사용하기 입니다.

스테이트 패턴

일단 가정을 플레이어컨트롤러에 대한 스크립트라고 하겠습니다.

저 같은 경우는 가독성을 위해서 enum으로 플레이어의 상태를 지정해보겠습니다.

public enum PlayerState
	{
		Die,
		Moving,
		Idle,
	}

위와 같이 Die, Moving, Idle 기본적인 3가지로 가정합니다.

그리고 핵심은, Update문에서 볼 수 있습니다.

void Update()
    {
		switch (_state)
		{
			case PlayerState.Die:
				UpdateDie();
				break;
			case PlayerState.Moving:
				UpdateMoving();
				break;
			case PlayerState.Idle:
				UpdateIdle();
				break;
		}
	}

state에 따라서 해당하는 상태에서 일어나야 할 일을 처리해주는 함수를 호출해줍니다.

이런 식으로 하면, if문이 얼기설기 중첩되는 방식을 쉽게 막아주며 가독성도 높일 수 있습니다.

그리고 아래와 같이 각 상태에 해당하는 함수를 구성해 봤습니다.

void UpdateDie()
	{
		// 아무것도 못함
	}
    
void UpdateMoving()
	{
		Vector3 dir = _destPos - transform.position;
		if (dir.magnitude < 0.0001f)
		{
			_state = PlayerState.Idle;
		}
		else
		{
			float moveDist = Mathf.Clamp(_speed * Time.deltaTime, 0, dir.magnitude);
			transform.position += dir.normalized * moveDist;
			transform.rotation = Quaternion.Slerp(transform.rotation, Quaternion.LookRotation(dir), 20 * Time.deltaTime);
		}

		// 애니메이션
		Animator anim = GetComponent<Animator>();
		// 현재 게임 상태에 대한 정보를 넘겨준다
        //애니메이터에서 speed변수값이 변경되면 뛰기 애니메이션을 변경되게 설정해놨음
		anim.SetFloat("speed", _speed);
	}
    
    void UpdateIdle()
	{
		// 애니메이션
		Animator anim = GetComponent<Animator>();
		anim.SetFloat("speed", 0);
	}

활용법은 무궁무진할 것입니다.

단점은 상태가 움직이면서 스킬을 쓰는 등, 상태가 복잡해지면 약간 복잡해 질 수 있습니다.

그래도 기존 방식보다는 확실히 코드를 읽는데 수월한 건 변함없습니다.

[Unity] 애니메이션 기초(스테이트 머신) 및 파라미터 설정

게임 개발자(진) — Sat, 28 Jan 2023 19:28:38 +0900

Animator Controller

Animator 컴포넌트

캐릭터등에 애니메이션을 적용하려면 먼저 Animator 컴포넌트를 추가해야 합니다.

그리고 이 Animator의 구조를 설정해주려면 Animator Controller가 필요합니다.

준비된 애니메이션(Animation Clip)

애니메이션(Animation Clip)을 준비했다면, 애니메이션 컨트롤러에 애니메이션들을 넣어줍니다.

애니메이션 컨트롤러에 애니메이션들을 설정해줌.

이번 예시 같은 경우엔, Stand 애니메이션을 기본 애니메이션으로 설정해주었습니다.

위 사진을 보면, 화살표를 볼 수 있는데, 이 화살표에 조건을 추가해 줌으로써 애니메이션의 변화를 만들 수 있습니다.

Parameters 추가

조건을 위한 파라미터 추가방법

조건에 사용하기 위한 파라미터는 위 방법으로 생성할 수 있습니다.

저같은 경우에는 Float형식의 Speed변수와 Trigger형식의 Dead변수를 반들어주었습니다.

전이 조건 설정

Stand->Run으로 가기 위한 조건

위 사진은 Stand애니메이션에서 Run애니메이션으로 뻗어있는 화살표의 인스펙터창입니다.

Conditions부분을 보면 Speed파라미터가 0.01보다 클때 애니메이션이 변화하도록 설정한 것을 알 수 있습니다.

또한 저 같은 경우 즉각적인 애니메이션의 변화를 원해서 Has Exit Time을 꺼주었습니다.

그리고 Transition Duration을 0.01(사실상 0)으로 설정해주었습니다.

이 옵션은 애니메이션을 부드럽게 이어주기 위한 옵션인데 예를들어 Transition Duration이 1이라면 이전 애니메이션과 바뀔 애니메이션을 1초동안 부드럽게 섞어서 이어줍니다.

그러나 2D 애니메이션일 경우에는 이 블렌드(Transitioni Duration)가 제대로 작동하지 않습니다. 따라서 저는 거의 0에 가까운 0.01로 설정해주었습니다.

Has Exit Time이란?

Exit Time은 파라미터에 의존하지 않고 상태의 정규화된 시간에 의존하는 특별한 전환입니다.
예를들어 Stand->Run으로 전이하는 화살표일때, Has Exit Time이 켜져있고 Exit Time이 0.5(50%)라면,
전이 조건이 만족되어도 ,이전 애니메이션, 즉 Stand 애니메이션이 최소 절반을 만족해야 전이가 발생합니다.
정해진 시간이 지나면 알아서 다른 상태로 옮길려는 특성이 있습니다.

Any State

Any State는 이름 그대로 어떤 상태에 있었더라도(가령, 달리기..가만히 서있기 등등) 화살표 조건을 만족하면 해당 상태로 변환하게 됩니다.

Dead 트리거를 conditions으로 설정

저 같은 경우엔, Dead 파라미터가 켜진다면 죽은것으로 판단하고AnyState->Dead로 움직이게 설정하였습니다.

스크립트에서 사용

그리고 위 파라미터는 스크립트에서

Animator _anim = GetComponent<Animator>();
//변수 이름_(anim)은 임의로 지정했음

를 통해서 애니메이터 컴포넌트를 얻은 뒤,

_anim.SetFloat("Speed",_inputVec.magnitude);
//파라미터이름,값

의 방식으로 조정할 수 있습니다.

[Unity] Input System을 스크립트에서 사용하는법

게임 개발자(진) — Wed, 25 Jan 2023 03:31:17 +0900

해당 포스트에 이어서 쓰는 내용입니다.

Behavior

로직 제어용 스크립트

Player Input의 Behavior

현재 게임 오브젝트에 키 입력값을 전달받고 로직을 제어할 스크립트를 붙여줬습니다.

Behavior란?
:입력이 들어왔을 때, 해당 내용을 전달해주는 방법을 고르는 부분

- Send Messages, Broadcast Messages : 유니티의 Send Message 기능을 사용하여 특정 함수를 호출하는 방법
- Invoke Unity Events, Invoke C Sharp Events : 유니티나 C#의 이벤트 기능을 사용하는 방법

위 방법을 스크립트에서 사용하기 위해선
using UnityEngine.InputSystem;
위와 같은 네임스페이스 적용이 필요함.

Message를 선택했을 때

특정 키가 입력을 인식하면, 특정 함수를 자동으로 호출하는 방식
Broadcast Messages의 경우, 하위 계층에 있는 오브젝트들까지 제어를 할 수 있음
함수명이 "On + Actions name" 으로 구성된다.

현재 "Move" Actions 하나만 설정 해놨는데,

해당 Actions에서 받는 키를 입력하게 되면, On + Actions name 이름인 함수를 자동으로 호출합니다.

void OnMove(InputValue value)
{
	Vector2 input=value.Get<Vector2>();
    //"Move" Actions에 해당하는 키 리턴은 'Vector2'로 받도록 설정해놨기 때문
    if(input!=null)
    {
    }
}
//"Move" Actions에 해당하는 키 입력 시 자동으로 호출됨.
/*
저 같은 경우 w,a,s,d,화살표를 Move 액션에 입력키로 설정해놨기때문에
해당 키들이 눌린다면 위 OnMove가 호출됩니다.
*/



//만약에 Action Type을 "Button"으로 설정한 "Jump" Actions도 추가했었다 하면
vod OnJump()
{
}
//Action Type이 "Button"인 경우에는 따로 매개변수가 없습니다.

Invoke Unity Events 기능 사용

Unity의 Event방식 사용
해당 Actions에 대한 키 입력이 들어오면, 설정한 이벤트 함수를 호출해 줌.

public void OnMove(InputAction.CallbackContext context)
{
	Vector2 input = context.ReadValue<Vector2>();
}

인스펙터창에서 함수를 지정해주기 위해선 반드시 함수의 접근지정자를 public으로 해줘야 합니다.

(C#스크립트를 바로 끌어다 놓는것이 아닌, 하이레키창에 있는 오브젝트를 드래그해서 찾아야함)

[Unity] Input받는 방법 (Input System 이용)

게임 개발자(진) — Wed, 25 Jan 2023 00:50:27 +0900

기존 방법

    [SerializeField] Vector2 _inputVec;
    
    void Update()
    {
        _inputVec.x = Input.GetAxisRaw("Horizontal");
        _inputVec.y = Input.GetAxisRaw("Vertical");
    }

Project Settings-Input Manager

Project Settings-Input Manager를 보면 Horizontal, Vertical...등등 각 이름에 대한 버튼 할당과 type이나 axis등에 대한 정보도 설정해줄 수 있습니다. 이를 코드를 통해서 이용하는 것이구요.

그러나 vr, 엑박컨트롤러, 플스컨트롤러등등... 다양한 컨트롤러에 대응하기에 위 방법은 수고스러운 면이 많습니다.

그래서 Input System을 사용하게 되었습니다.

Input System

다양한 플랫폼에서 빠르게 컨트롤 설정 가능
하나의 코드를 통해 다양한 플랫폼의 입력 환경을 지원할 수 있는 것이 특징
Package Manager에서 Input System을 설치하여 적용 가능

1)패키지 설치

Window-Package Manager

Package Manager에서 Unity Registry로 설정해줍니다.

Input System 설치

Input System을 Install해줍니다.

2) 설치 확인

Project Settings-Player-Active Input Handling이 Input Manager(Old)가 아니면 적용이 되어 있는 것입니다.

패키지 매니저의 In Project에 Input System이 잘 들어가 있는지도 확인해줍니다.

3)Input Actions 파일 생성

Input Actions파일은 어떤 키를 누르면, 어떤 기능이 작동되어야한다.

후처리는 어떤식으로 해줄 것이다 등의 내용을 담고 있습니다.

Project창에서 Input Actions를 생성해줍니다.

현재 No Control Schemas상태입니다.

Control Schemas란 어떤 플랫폼에서 input을 어떤 설정으로 사용하겠다는 내용을 미리 저장해 놓는 것을 말합니다.

예시를 보여드리겠습니다.

PC에 해당하는 요소들 추가(키보드,마우스)

먼저 PC라는 이름의 스키마를 만들고 PC에선 키보드,마우스를 사용할 것이기때문에 2개를 추가해줬습니다.

그리고 예를들어서 VR도 게임에서 활용하고자 한다면, 그에 맞는 input설정이 필요하겠죠?

그냥 빈 깡통형식으로 VR스키마를 하나 만들어주겠습니다.

기존 Input System을 그대로 썼다면, 빌드할때 플랫폼따라서 코드를 수정한다던지 등등 신경쓸게 많았겠지만,

이 방식으로 하면 이 부분만 바꿔서 빌드해주면 되기때문에 간단합니다.

4) Action Maps 설정

캐릭터, 몬스터, UI 등 다른 곳에 사용할 키들을 맵으로 각각 묶어서 저장할 수 있음

예시로 PC플랫폼에서 플레이어캐릭터에게 사용할 키 맵을 만들 것이기 때문에, "Player"란 이름으로 생성했습니다.

5) Actions 설정

Actions는 어떤 행위에 사용될 키 입력을 받을 것인지에 대한 설정

Move 액션 추가

이동에 관한 내용을 생성하기위헤 "Move"라고 설정하였습니다.(이름은 자유)

하위에 있는 <No Binding>은 일단 지워줍니다.

Action Type

Action Type이란?

Value : 입력 들어온 값에 따라 결정 ('+' 값이 들어오면 오른쪽, '-'값이 들어오면 왼쪽 같은 방식)
Button : 버튼이 눌렸는지, 안 눌렸는지에 따라 입력 여부 결정(점프)
Pass Through : Value와 비슷하지만 약간의 차이(영상 링크). 대부분 Value를 쓰면 됨.

Control Type

Control Type은 해당 키가 눌렸을 때, 스크립트에서 어떤 자료형 타입으로 리턴받아 사용할 지 정하는 옵션입니다.

저는 캐릭터 이동에 WASD 또는 ↑←→↓을 사용한다고 가정하고 키 바인딩을 4개 하도록 하겠습니다.

Add Up\Down\Left\Right Composite 선택

결과

No Binding은 아직 키 설정을 안해줬다는 뜻입니다.

2D Vector->WASD로 이름 변경

저는 이름을 각각 W,A,S,D로 설정해주고 관련 설정을 적용해주겠습니다.

w 검색해서 클릭

최종 완성된 모습

6. 적용할 게임 오브젝트에 Player Input 컴포넌트 추가

Player Input컴포넌트를 추가한 후, 미리 만들어두었던 Input Actions파일을 설정해줍니다.

Default Schema

Default Schema는 빌드할 때, 타겟 플랫폼에 맞게 설정해 주면 됩니다.

Any로 해놓으면 알아서 설정되긴 합니다.

Default Map

Default Map은 현재 Player Input 컴포넌트가 부착된 오브젝트가 제 경우엔 플레이어캐릭터이므로, 아까 생성했던 "Player" Map을 선택해줬습니다.

이제 입력받은 키 내용을 스크립트에서 사용하면 됩니다.

그 방법에 대해선 다음 글에서 다루겠습니다. ==>(다음 포스트 링크)

[Unity] Awake와 Start차이

게임 개발자(진) — Tue, 24 Jan 2023 21:44:12 +0900

https://docs.unity3d.com/kr/530/Manual/ExecutionOrder.html

유니티의 이벤트 함수 실행순서를 살펴보면 Awake가 먼저 실행되고 Start가 실행됩니다.

Awake

Awake는 Start보다 무조건 먼저 실행됩니다.
프리팹이 인스턴스화 된 직후에 호출됩니다. 오브젝트가 비활성화되어 있다면 awake 함수는 호출되지 않다가 오브젝트가 활성되는 순간 호출됩니다. 그 후 오브젝트를 비활성화(Deactive) -> 활성화(Active) 해도 다시 호출되지 않습니다. 최초 1회만 호출됩니다.
보통 변수등의 초기화, 스크립트간 참조(reference)를 Awake에서 해줍니다.
Awake 만 있는 스크립트에 경우 스크립트 활성화(Enable) 버튼이 뜨지 않습니다. OnEnable, Start 같은 함수가 있어 스크립트가 비활성화(Disable) 해 놓았더라도 Awake 함수는 호출됩니다.

[주의할 점]:
각 게임 오브젝트의 Awake()의 호출 순서는 랜덤이기 때문에, 스크립트간의 참조(reference) 설정을 위해서만 Awake를 사용하고, 그걸 이용해서 정보를 주고 받을 때는 Start를 사용해야 합니다.(Start 과정에서는 이미 모든 오브젝트들의 Awake가 끝났기 떄문에)

Start

Start는 Awake보다 늦게 실행됩니다.
스크립트 인스턴스가 활성화된 경우에 호출합니다. 즉 게임 오브젝트 + 스크립트 모두 활성화되어있을 때 최초 1회의 한정하여 호출합니다. 호출 시기는 첫 번째 프레임 업데이트 전입니다.

gameObject.SetActive(false)와 this.enabled=false 차이

(링크)

1번은 gameObject.SetActive(false)

2번은 this.enabled=false

1의 체크가 해제된 상태(=gameObject.SetActive(false))일때

A) 게임오브젝트를 비활성화한 상태로 게임을 시작하면, 또는
B) 프리팹 설정에서 1번 체크박스를 꺼놓은 프리팹을 게임 중에 Instantiate(prefab) 으로 생성할 경우

Awake도, Start도, OnEnable도 모두 호출되지 않습니다.

만약 이걸 다시 체크하게 된다면, Awake,OnEnable,Start가 실행될 것입니다.

2의 체크만 해제된 상태(=this.enabled=false)일때

위 사진의 1번 체크박스는 켜져있지만 2번 체크박스는 꺼진 상태를 의미합니다.
게임 오브젝트는 활성화되어 있기때문에 Awake는 호출되지만,Start()와 OnEnable()는 호출되지 않습니다.
이 두 함수는 컴포넌트의 활성화 여부에 따라 호출됩니다.
게임이 돌아가는 도중에 체크박스를 켜거나 GetComponent<Component>().enabled = true 설정을 하면, 그 이후 OnEnable과 Start가 호출되게 됩니다.

[Unity] 오브젝트를 이동시키는 방법들

게임 개발자(진) — Sun, 22 Jan 2023 04:35:13 +0900

유니티에서 이동(위치 변경)을 위해서 사용하는 방법은 아래와 같습니다.

transform.Translate()

transform.position에 직접 값을 입력해주는 방법

Rigidbody.MovePosition()

Rigidbody.position에 직접 값을 입력해주는 방법

Rigidbody.AddForce()

Rigidbody.AddRelativeForce()

Rigidbody.velocity

Transform.Translate()

//transform.Translate(new Vector3(float, float, float));

void Update () 
    {
        // 게임 오브젝트 기준으로 이동
        transform.Translate(Vector3.right * Time.deltaTime);

        // 월드 좌표 기준으로 이동
        transform.Translate(Vector3.forward * Time.deltaTime, Space.World);
    }

매 프레임마다 값만큼 이동합니다.

물리작용이 필요없는(rigid body가 없는) 오브젝트에서 사용합니다.

transform.position에 직접 입력

transform.position=new Vector3(x,y,z);
//해당 위치로 이동합니다. (거리가 매우 가까운게 아니라면, 텔레포트같은 느낌)

transform.localPosition=new Vector3(x,y,z);
//localPosition은 상대좌표를 나타냄. 게임오브젝트의 부모가 있을 경우 부모로부터의 떨어진 좌표를 의미

Transform target;
float speed=10f;

void FixedUpdate()
{
	Vector3 a= transform.position;
	Vector3 b= target.position;
	transform.position=Vector3.Lerp(a,b,speed);
    //이런식으로 Lerp를 이용해서 부드럽게? 이동 구현 가능
}

public Transform Target;
public float Speed = 1.0f;

void Update()
{
	transform.position = Vector3.MoveTowards(transform.position, Target.position, Speed * Time.deltaTime);
    //현재위치, 목표위치, 속도   를 인자로 넘겨주면 현재 위치에서 목표 위치로 일정한 속도로 움직임
}

만약 rigidbody가 있는 오브젝트라면 transform.position은 지양하는것이 좋습니다.

이걸 사용하면 모든 콜라이더들이 rigidbody와의 상대적 위치를 재계산하기 때문입니다.

상황에따라서 RigidBody.position이나 RigidBody.MovePosition()을 사용합시다.

Rigidbody.MovePosition()

//rb는 리지드바디 컴포넌트를 의미

rb.MovePosition(new Vector3 (x,y,z));
//target지점의 position으로 RigidBody를 이동시킴

Rigidbody.MovePosition에는 interpolation옵션이 있기 때문에 Rigidbody가 있는 오브젝트의 경우 Rigidbody.MovePosition을 사용한 움직임을 구현하는것이 좋습니다. (Rigidybody.position은 interpolation은 없는듯..? 링크) (Rigidbody의 interpolation링크,)

transform.position을 이용하는 방법과의 차이점은, transform.position을 설정하는 것은 "텔레프트"의 개념입니다. 매우 작은거리를 계속 텔레포트 시킨다면 눈으로 보기에는 Rigidbody.MovePosition과 유사해 보입니다. 그러나 transform.position을 이용한다면, 이전 위치와 새 위치 사이에 있는 다른 오브젝트는 이동의 영향을 받지 않습니다. 또한 목표 위치에 있는 콜라이더는 다음 업데이트 시 이동한 리지드바디와 즉시 물리반응을 하게 됩니다.

그러나 rigidbody.MovePosition()을 사용하면 유니티가 이전 위치와 새 위치 사이의 직선 경로를 추적하고 업데이트 간에 해당 경로를 따라 빠르게 이동한 것처럼 처리합니다. 즉, 이전 경로와 새로운 경로 사이에 어떤 물리작용을 하는 물체가 존재한다면 물리 작용이 일어나게 됩니다.(transform.position의 경우 아무일도 안일어남)

rigidbody 2D일때 중력,공기저항 비정상!

즉, rigidbody컴포넌트를 지닌 오브젝트는 왠만하면 이 함수를 이용하면 되는데, 문제점이 있습니다.

바로, rigidbody 2D일 경우에는 Rigidbody2D.MovePosition을 통한 이동이 중력이나 선형 공기저항에는 영향을 받지 않습니다.(링크). 2D일 경우에는 MovePosition+중력을 적용해주기 위한 코드를 추가해주던지 다른 방법(rigidbody.velocity를 이용...)을 사용해야 겠습니다. 3d일 경우에는 정상이기때문에 사용하셔도 됩니다.

(위 문제는 rigidbody2d.moveposition은 위치를 고정시키려하는데 rigidbody2d.gravityscale은 당기려 하기 때문에, 이 과정에서 중력이 이겨서 천천히 중력의 방향대로 끌려가는것 같습니다.)

Rigidbody.position

rigid body컴포넌트를 지닌 물체를 텔레포트할때 사용합니다.

transform.position을 사용하여 텔레포트를 구현하면 모든 콜라이더들이 rigidbody와의 상대적인 위치를 재계산하기 때문에 성능적으로 이걸 사용하는것이 이득입니다.

(즉 움직이는 물체는 rigidbody컴포넌트를 달아주고 그것을 활용하여 움직여주는게 성능적으로 이득이라는 것이겠죠?)

또한 지속적인 움직임(캐릭터 이동등..)을 위해서는 interpolation이 적용되는 Rigidbody.MovePosition()을 사용하는 것이 좋다고 합니다.

링크

Rigidbody.AddForce()

rigidbody.AddForce(new Vector3(x,y,z), ForceMode mode=ForceMode.Force);
//AddForce(방향*힘,힘의 종류)

말 그대로 리지드바디에 힘을 가해주는 것입니다.

단순히 이 기능만을 이용하여 움직임을 구현한다면 빙판에서 움직이는 것처럼 움직일 것입니다. (남아있는 힘들과의 벡터계산등을 통해서...이동이 결정되므로)

이때 힘의종류, 즉 파라미터로 넣어주는 ForceMode는 어떤 식으로 힘을 전달할 것인가를 결정해줍니다.

질량을 고려한다면, F=ma 공식이 적용되어서 질량에따른 가속도가 달라집니다.

Force: 연속적인 힘+ 질량을 고려함 (일반적인 물리 현상)

Acceleration: 연속적인 힘, 질량을 무시함 (질량에 관계없이 가속을 주고 싶다면 이용)

Impulse: 불연속적인 힘+ 질량 고려함 (짧은 순간의 힘, 충돌이나 폭발과 같은 것에 쓰임)

VelocityChange: 불연속적인 힘+ 질량 무시함 (질량을 무시해야하고 짧은 순간의 힘을 구현할떄)

이때, AddForce의 힘의 방향은 Global Coordinate입니다.

Rigidbody.AddRelativeForce()

rigidbody.AddRelativeForce(new Vector3(x,y,z), ForceMode mode=ForceMode.Force);
//AddRelativeForce(방향*힘,힘의 종류)

Rigidbody.AddForce는 Global coordinate가 기준이기 때문에 Local Coordinate를 기준으로 힘을 주고 싶을 때 사용합니다.

극단적인 예로, 차같은 경우 좌회전을 하는데 global인 경우 좌회전하기 전에는 w가 분명 직진인데 그 후에는 오른쪽이 됩니다. 이런 것을 해결해 주기 위해서 사용합니다.

그러나, AddForce로도 해당 오브젝트의 로컬 좌표로 힘을 가해줄 수 있는데,

rigidbody.AddForce(transform.forward)
//transform.forward를 사용하면 로컬좌표 기준 앞 방향을 world coordinate로 변환해서 알려줌

이런식으로 구현해도 됩니다.

Rigidbody.velocity

rigidbody에 질량과 상관없이 속도를 부여합니다.

공식문서에서는 이 값을 직접 수정하면, 비현실적인 동작이 발생할 수 있기 때문에 왠만하면 수정하지 말라고 안내합니다.

일반적인 사용법은 1인칭 fps게임에서 점프할 때 속도를 변경하는 것인데, 이는 즉각적인 속도 변화를 원하기 때문이라고 합니다.

링크

Rigidbody-velocity - Unity 스크립팅 API

The velocity vector of the rigidbody. It represents the rate of change of Rigidbody position.

docs.unity3d.com

rigidbody2d.velocity를 사용

rigidbody2d의 경우 rigidbody2d.MovePosition은 중력적용이 이상하기 때문에, 중력을 고려한 점프가 필요한 경우엔 rigidbody2d.velocity를 사용해도 괜찮을 것 같습니다. rigidbody2d.AddFoce를 사용해도 괜찮을 것이구요.. (위 사진 출처:링크)

[Unity] Update(), FixedUpdate() 그리고 Physics Loop

게임 개발자(진) — Sat, 21 Jan 2023 21:41:56 +0900

출처

Update()

유니티엔진에서 Update()는 매 프레임 호출됩니다.

DirectX, OpenGL, Vulkan..등 그래픽스 라이브러리를 사용한 게임엔진은 기본적으로

Game Loop(게임 루프)를 통해서 프레임 기반 동작이 수행됩니다.

/* Main Function */

// Game Loop
while(...)
{
    // User Inputs..
    // Game Logics..
    // Draw Calls..
    // ...
}

이런식으로 메인 스레드에 무한 반복문을 통해 게임 루프를 작성하고, 이 게임 루프의 반복이 프레임의 진행을 뜻합니다.

즉, 게임 루프를 한번 실행하면 한 프레임이 지난 것입니다.

// Unity Game Loop
while(...)
{
    // ...
    
    foreach(var m in monoBehavioursWhoHaveUpdateMethod)
    {
        m.Update();
    }
    
    // ...
}

유니티 엔진은 Update()메소드가 존재하는 모든 MonoBehaviour를 찾아서 스크립팅 런타임이 내부적으로 저장해놓았다가 게임 루프에서 일괄적으로 순회하며 호출해주는 방식이라고 합니다.

그리고 많이들 Update()문에서 사용하는 Time.delTime은 게임 루프의 이전 수행과 현재 수행 간의 시간 간격을 저장한 값입니다. 이를 통해서 보정을 진행하죠 보통..

FixedUpdate()

FixedUpdate()는 잘못 이해하고 계신분들이 많습니다.

설정해놓은 일정한 주기로 실행되고(기본값 0.02초) 물리를 위한 연산이기때문에 Update()와는 별개의 루프라고 생각할 수 있습니다. 하지만 이는 틀렸습니다.

유니티의 내부 동작 구조를 살펴봅시다.(링크)

빨간색=매 프레임 마다 실행되는 로직,즉 Game Loop

노란색=Game Loop속에 Physics Loop가 포함된것을 확인 가능.

게임 루프속에 피직스 루프가 포함되어 있습니다.

피직스 루프안에는 FixedUpdate가 처음부분에서 시작됩니다.

즉, Update()와 FixedUpdate()는 완전히 분리된 것이 아닙니다.

Fixed Time Step값이 deltaTime보다 작으면, Physics Loop가 여러 번 반복하여 실행되는 원리입니다.

예를 들면,

Fixed Time Step은 0.02이고,

이번 프레임의 deltaTime이 0.1이었다면

0.1 / 0.02 = 5회 만큼 Physics Loop가 실행될 것으로 예측할 수 있습니다.

반대로, deltaTime이 0.005처럼 너무 작았다면

이번 프레임에는 Physics Loop가 한 번도 실행되지 않을 수 있습니다.

FixedUpdate()는 Physics Loop의 초입에 실행되며,

결국 게임 루프와는 별개로 일정한 주기마다 호출되는 것이 아니라

게임 루프 내에서 중첩 루프를 통해 호출된다는 것을 알 수 있습니다.

그치만 이렇게 생각하면 복잡하므로, 개발시에는 일정 주기로 FixedUpdate에서 물리계산을 진행한다~~라고 생각해도 될 것 같습니다.

Physics Loop의 필요성

그렇다면 왜 물리 업데이트는 기본적으로 0.02초의 주기를 갖고,

이 주기에 따라 계산된 횟수로 Physics Loop가 실행되는 것일까요?

물리 업데이트가 단순히 프레임 기반으로 실행되는, 반대의 상황을 가정해보면 쉽게 이해할 수 있습니다.

이런식으로 공이 벽에 부딪혀서 원래는 튕겨나갈것으로 생각을 했으나

컴퓨터가 너무 안좋아서 프레임이 낮다면??(update주기가 너무 느리다면?)

위 처럼 충돌을 감지못하고 통과해 버릴 수도 있습니다.

즉, Frame Rate에 따른 신뢰성 낮은 물리 시뮬레이션결과를 얻게 됩니다.

따라서 Fixed Time Step주기를 정하고

deltaTime이 너무 오래 걸렸으면

deltaTime과 Fixed Time Step의 관계에 따라 그만큼 Physics Loop를 반복함으로써

일정한 주기로 물리 업데이트가 진행되는 것처럼 보정하는 방식을 사용합니다.

Physics Loop를 왜 Game Loop속에 넣었을까?

이론적으로는 Physics Loop용 별도의 스레드를 통해서 일정한 주기로 수행되게 한다면 최고일텐데 왜 그랬지 않았을까요?

아마 스레드 간 데이터 동기화 문제로 보입니다.

메인스레드에서는 물리관련에 접근하지 못하게하고, FixedUpdate()및 내부 물리 연산에서는 물리와 관련없는 데이터에 접근하지 못하도록 완전히 분리하는 방식을 채택한다면, 프로그래머 입장에서 난이도가 매우 어려워지고, 물리 업데이트의 결과는 트랜스폼에 적용되어야 하므로 동기화 문제에서 자유롭지 못합니다.

그래서 메인 스레드와 물리 스레드의 공유 데이터를 모두 동기화(lock...)하자니, 게임 루프를 기반으로 동작하는 메인 스레드 특성 상 물리 스레드는 게임 루프의 동작에 종속되고, 반대로 게임 루프도 물리 스레드의 동작에 종속되는 최악의 경우가 발생할 수 있습니다.

따라서 위와같은 복잡한 문제를 가질바에 Physics Loop를 게임 루프 내에서 실행하고, deltaTime과 fixedDeltaTime의 관계에 따라 실행 횟수를 보정해주는 방식을 채택한 것으로 보입니다.

[Unity] tag, layer, sorting layer차이

게임 개발자(진) — Sat, 21 Jan 2023 05:50:45 +0900

요약

-Tag는 단일 게임 오브젝트를 관리하기 위해 사용
-Layer는 그룹으로 묶어 관리하기 위해서 사용
-Sorting Layer는 게임 오브젝트의 렌더링 순서를 정의하기 위해 사용

게임오브젝트의 인스펙터창에서 확인할 수 있는 Tag, Layer

tag나 layer를 기본값 이외에도 추가 가능

Tags, Sorting Layers, Layers 목록

Tag

Tag는 각 게임 오브젝트를 식별하는 용도로 사용합니다.

많이 사용하는 방식으로는, 충돌을 검사하는 OnCollision, OnTrigger 함수에서 CompareTag()함수를 사용합니다.

private void OnTriggerEnter2D(Collider2D collision)
{
    if (collision.transform.CompareTag("PlayerAttack"))
    {
        OnDamage(collision.transform);
    }
}

위 방식 외에도 단순 문자열 비교등으로도 사용 가능한데, 이렇게 한다면 해당 문자열을 가져오기 위해 문자열의 복사본을 생성하게되고 유니티 시스템상 복사본을 생성할때 GC(가비지콜렉터)가 호출되기 때문에 성능상 손해를 볼 수 있습니다.(약 27%의 성능 손해) (링크)

if (collision.tag == "PlayerAttack"){ ... }
if (collision.tag.Equals("PlayerAttack")){ ... }

Layer

Layer는 오브젝트 그룹을 만들고 관리하는 용도입니다.

기본 레이어는 Default로 설정되어 있습니다.
상위 오브젝트와 하위 오브젝트는 서로 다른 레이어를 가질 수 있습니다.

Layer를 사용하는 방법

1) 선택적 렌더링

:카메라로부터 특정 레이어만을 렌더링하게 설정 가능합니다.

2) 레이어 충돌 매트릭스 (Layer Collision Matrix)

:서로 충돌할 수 있는 레이어를 정의할수있습니다.

주의) Layer Collision Matrix는 프로젝트 세팅의 Physics와 Physics2D에 각각 존재하는데, 서로의 설정이 서로에게 영향을 주지 못합니다.

3) 레이 캐스팅 충돌 (Raycasting Collision)

레이캐스팅은 레이저를 쏴서 모든 오브젝트에 대해 충돌을 판단하는것이 기본인데, 비효율적이기 때문에,

Layer Mask를 사용하면 특정 레이어와의 충돌을 판정할 수 있습니다.

예를 들면 바닥 레이어로 설정된 곳만 마우스로 클릭할 수 있게 한다던지...등등

//특정 Layer만 raycast하기
RaycastHit hit;
float distance = 10f;
int layerMask = 1 << LayerMask.NameToLayer("Player");  // Player 레이어만 충돌 체크함
//(레이어마스크는 비트플래그 방식이기때문에 위처럼 사용)
Physics.Raycast (transform.position, transform.TransformDirection (Vector3.forward), out hit, distance  ,layerMask);


또는

Ray ray = Camera.main.ScreenPointToRay(Input.mousePosition);
RaycastHit hit;
float distance = 10f;
Physics.Raycast(ray, out hit,distance, LayerMask.GetMask("Wall"));
//위처럼 LayerMask.GetMask()를 이용할수도있음

Sorting Layer

게임 오브젝트 내에서 렌더링 순서를 정의합니다.

주로 2D 시스템에서 스프라이트를 정렬하는데 유용합니다.

Sorting Layer나 Order in Layer를 조절해줘야지 위 캐릭터의 그림자분이 캐릭터뒤로 가게 설정할 수 있습니다.

[Unity] Rigidbody의 Gravity의 기준은?

게임 개발자(진) — Sat, 21 Jan 2023 05:42:34 +0900

Rigidbody의 Gravity를 설정할 수 있다는건 다들 알고 계실겁니다.

그런데, 이 중력 크기의 기준은 어디에 있을까요?

Project Settings에 들어가서 Physics의 Gravity가 바로 그 기준입니다.

현재 Rigidbody 2D를 사용했기때문에 Physics 2D를 보면 y축 -9.81값이 설정되어 있는것을 알 수 있습니다.

즉, 기본 값은 지구의 중력을 흉내내고 있습니다.

만약, Rigidbody의 Gravity Scale을 1로 설정한다면 y축 -9.81의 중력을 그대로 받겠다는 뜻이 되겠습니다.

[Unity] 방해되는 3d 아이콘 크기 줄이기

게임 개발자(진) — Sat, 21 Jan 2023 05:35:39 +0900

위처럼 오브젝트보다 아이콘이 커서 불편할때가 존재합니다.

이때는 3d 아이콘의 크기를 줄여줘야 합니다.

이 부분을 조절하면 간단하게 조절이 가능합니다.

[Unity] Sprite Atlas (스프라이트 아틀라스)

게임 개발자(진) — Sat, 21 Jan 2023 01:54:55 +0900

Sprite란? (링크)

Sprites는 2D 그래픽 오브젝트입니다.
만약 3D 작업을 주로 해왔다면 Sprites는 스탠다드 텍스처라고 생각하면 됩니다.

Sprite Atlas란? (링크)

스프라이트 아틀라스(Sprite Atlas)는 여러 개의 텍스처를 단일 텍스처로 결합하는 에셋입니다.

Sprite Atlas를 왜 쓰는가? (링크)

Draw call을 줄여서 성능을 향상시키기 위해서입니다.
(Draw call? => cpu가 gpu에게 그려달라고 요청하는것. 당연히 적을수록 좋음)

위 스프라이트 아틀라스를 사용할 수 있도록 나눠보도록 하겠습니다.

Sprite Mode

-Single:이미지 자체를 하나의 Sprite를 지정합니다.
-Multiple:이미지를 여러 Sprite로 나눌 수 있습니다.
-Polygon:사각형, 원, 삼각형 등의 모양을 Sprite으로 만들어 사용할 수 있습니다.

Pixels Per Unit
Unit은 유니티의 거리 단위를 의미합니다.
즉, 위 빨간색 사각형은 1x1 unit을 의미합니다.
Pixels per unit이란 저 한칸의 한 변의 길이를 몇 픽셀로 설정할지에 대한 옵션입니다.
(ex. 100으로 설정하면 한칸을 100x100픽셀로 인식하겠다는 뜻.)
(보통 주 캐릭터의 픽셀갯수를 따라가는 것 같습니다.)

Mesh Type (참고 링크)

스프라이트는 mesh를 기반으로 이미지를 보여줍니다.
mesh는 컴퓨터 그래픽스에서 물체의 모양을 구성하는 vertex,edge,face등을 갖는 데이터입니다.
Mesh Type에는 Full Rect와 Tight 두 가지 타입이 있습니다.
-Full Rect: 이미지와 동일한 형태로 스프라이트를 렌더링합니다. RGBA를 기반으로 투명 영역을 포함하는 사각 영역 전체를 렌더링합니다.

-Tight: 스프라이트의 투명 영역을 제외하고, RGBA를 기반으로 일정 영역을 렌더링합니다.

Extrude Edges

렌더링 할 때 가장자리의 여유 공간을 길이로 나타낸 수치입니다. Mesh Type과 연관이 있습니다.
Mesh Type이 Full Rect일때는 전체 영역을 렌더링하므로 영향이 없지만, Tight일 경우 이 수치를 증가시키면 각 영역을 기준으로 투명 영역을 더 많이 포함하는 것을 볼 수 있습니다.

Pivot

스프라이트의 회전 기준점입니다.

Wrap Mode(링크)

텍스쳐를 정점에 입히는 방식(컴퓨터 그래픽스 u,v관련). 보통 Clamp로 설정

Filter Mode(링크)

컴퓨터 그래픽스의 interpolate방식 선택..

-Point(no filter): 보간 안함. 픽셀게임에서는 이걸 선택
-Bilinear: 이중 선형 보간으로 필터링
-Trilinear: 삼중 선형 보간으로 필터링

Compression

텍스쳐를 압축하는 방식 선택.
도트의 경우 굳이 압축할 필요가 없기떄문에 None을 선택

이번에 사용한 스프라이트 아틀라스는 일정한 사각형 크기로 그려진것을 합친것이기 때문에,

Sprite Mode를 Multiple로 설정합니다.

캐릭 하나하나가 18x18을 기준으로 그려졌기때문에 Pixels Per Unit은 18로 설정해줍니다.

픽셀아트이기 때문에 Filter Mode는 Point로 설정해줍니다. 그리고 Compression도 None으로 설정합니다.

그리고 Apply를 누른 뒤, Sprite Editor에 들어갑니다.

Slice에서 Type을 Grid By Cell Size로 설정해줍니다.

그리고 Pixel Size와 Padding등을 픽셀아트 제작자가 의도한 대로 적어서 Slice해줍니다.

오른쪽 위 빨간색쪽을 누르면 위 같이 alpha값만 보는 화면으로 넘어갑니다.(=색 상관없이 픽셀이 존재하는 부분은 흰색으로 표현됨)

이를 통해서 바닥에 발이 붙어있어야 하는 부분이 잘 붙어있나 확인하여서 제대로 잘랐는지 한번 더 확인 가능합니다.

그리고 순서를 인식하기 쉽게 이름을 알아서 각 조각마다 입력해줍니다.

모두 확인했다면 Apply를 눌러서 잘라줍니다.

그러면 Project창에서 위처럼 나눠진 모습을 확인 가능합니다.

[C++] 셋(set),맵(map)

게임 개발자(진) — Tue, 3 Jan 2023 17:26:29 +0900

셋(set), 멀티셋(multiset), 맵(map), 멀티맵(multimap)은 이진 탐색 트리(BST)를 기반으로 하는 연관 컨테이너(associative container)입니다.

(정확히 말하면 Red-black-tree. 스스로 균형을 맞추는 bst라고 생각)

따라서 vector,list,deque같은 시퀀스 컨테이너들과 비교했을때, 트리구조가 갖는 장점을 그대로 가져갑니다.

셋(set)

자동으로 정렬됨
중복된 원소 없음(중복된 원소를 허락하고 싶다면 multiset 사용)

데이터의 존재 유무를 판별할때 사용합니다.

std::set<int> s; //셋 정의

s.insert(10); //셋에 키값 추가

//셋에 해당 키가 있는지 확인하는 방법
auto itr = s.find(20);
if (itr != s.end()) 
{
  std::cout << "Yes" << std::endl;
} 
else 
{
  std::cout << "No" << std::endl;
}

셋에 원소를 추가하거나 지우는 작업은 O(log N)입니다.

범위기반 for문또한 사용 가능하며, 원소들의 접근 순서는 반복자를 이용해서 접근했을때와 동일합니다.

멀티셋(multiset)

셋에서 중복된 원소를 허락한 버전입니다.

std::multiset<std::string> s;

  s.insert("a");
  s.insert("b");
  s.insert("a");
  s.insert("c");
  s.insert("d");
  s.insert("c");

  print_set(s);
 
/*출력결과
a
a
b
c
c
d
*/

기존 set이라면 a,b,c,d 이렇게 출력됐을 것입니다.

맵(map)

자동으로 정렬됨
중복된 key 없음(중복된 key를 허락하고 싶다면 multimap 사용)

맵은 셋과 거의 동일하지만 셋은 key만 보관하지만, 맵은 key-value를 보관합니다.

map<string,int> student_score;

student_score.insert(std::pair<std::string,int>("김남제",50));

student_score.insert(std::make_pair("엄준식", 100));

student_score["찬우정"]=60;

첫번째로 입력하는 타입은 key의 타입이고, 두번째는 value의 타입입니다.

위 세가지 방법으로 key-value의 추가가 가능합니다.

[]연산자의 경우, 만일 해당하는 키가 맵에 없다면 추가될 것이고, 있다면 value값이 바뀌게 됩니다.

insert는 이미 해당하는 키가 있다면 새로운 value로 대체하지 않고 무시합니다.

template <typename K, typename V>
void print_map(std::map<K, V>& m) {
  // 맵의 모든 원소들을 출력하기
  for (auto itr = m.begin(); itr != m.end(); ++itr) {
    std::cout << itr->first << " " << itr->second << std::endl;
  }
}

template <typename K, typename V>
void print_map(std::map<K, V>& m) {
  // kv 에는 맵의 key 와 value 가 std::pair 로 들어갑니다.
  for (const auto& kv : m) {
    std::cout << kv.first << " " << kv.second << std::endl;
  }
}

셋의 경우 *itr가 저장된 원소를 바로 가리켰지만, 맵은 반복자가 맵에 저장되어 있는 std::pair를 가리킵니다.

따라서 itr->first로 해당 원소의 키를, itr->second로는 해당 원소의 값을 알 수 있습니다.

범위기반 for문을 사용하면 std::pair값을 받아와서 위처럼 사용가능합니다.

주의할 점

 map<string,int> student_score;
 
student_score.insert(std::pair<std::string,int>("김남제",50));

std::cout<<"엄준식의 성적은? "<<student_score["엄준식"];

//출력: 0

위처럼 엄준식은 map에 key로 없지만, 위처럼 사용하게되면 자동으로 값의 디폴트 생성자를 호출해서 원소를 추가해버립니다. 따라서 안전한 사용을 위해서는 find 함수를 통해 확인 후 사용하는것이 좋습니다.

멀티맵(multi map)

맵에서 중복된 원소를 허락하는 버전입니다.

  template <typename K, typename V>
  void print_map(const std::multimap<K, V>& m) {
  // 맵의 모든 원소들을 출력하기
  for (const auto& kv : m) {
    std::cout << kv.first << " " << kv.second << std::endl;
  }
}

  std::multimap<int, std::string> m;
  m.insert(std::make_pair(1, "hello"));
  m.insert(std::make_pair(1, "hi"));
  m.insert(std::make_pair(1, "ahihi"));
  m.insert(std::make_pair(2, "bye"));
  m.insert(std::make_pair(2, "baba"));

  print_map(m);

  std::cout << "--------------------" << std::endl;

  // 1 을 키로 가지는 반복자들의 시작과 끝을
  // std::pair 로 만들어서 리턴한다.
  auto range = m.equal_range(1);
  for (auto itr = range.first; itr != range.second; ++itr) {
    std::cout << itr->first << " : " << itr->second << " " << std::endl;
  }
  
  
  /*출력 결과
1 hello
1 hi
1 ahihi
2 bye
2 baba
--------------------
1 : hello 
1 : hi 
1 : ahihi 
*/

unordered_set과 unordered_map

셋,맵은 bst를 이용하기 때문에, 어쩔수없이 정렬이 되는데, 이 오버헤드를 없애고자 나온 것이

unordered_set과 unordered_map입니다.

unordered_set과 unordered_map은 bst가 아닌, 해시맵을 사용하기 때문에 insert,erase,find 모두가 O(1) (보통의 경우)로 수행됩니다.

(그래서 사실 hashset, hashmap이란 이름이 어울리지만 이러한 이름을 너무 많이 쓰고 있어서 충돌을 피하려고 위와같은 이름으로 했다고 합니다.)

해시 함수란 임의의 크기의 데이터를 고정된 크기의 데이터로 대응시켜주는 함수라고 볼 수 있습니다.

이 때 보통 고정된 크기의 데이터라고 하면 일정 범위의 정수값을 의미합니다.

해시 함수의 가장 중요한 성질은, 만약에 같은 원소를 해시 함수에 전달한다면 같은 해시값을 리턴한다는 점입니다.

이 덕분에 원소의 탐색을 빠르게 수행할 수 있습니다.

간색 공과 보라색 공 처럼 다른 원소임에도 불구하고 같은 해시값을 갖는 경우가 있을 것입니다.

이를 해시 충돌(hash collision) 이라고 하는데, 이 경우 같은 상자에 다른 원소들이 들어있게 됩니다.

따라서 만약에 보라색 공이 이 셋에 포함되어 있는지 확인하고 싶다면 먼저 보라색 공의 해시값을 계산 한 뒤에, 해당하는 상자에 있는 모든 원소들을 탐색해보아야 할 것입니다.

운이 매우 매우 나쁘다면 다른 색들의 공이 모두 1 번 상자에 들어갈 수 도 있습니다.

이 경우 탐색이 O(1) 은 커녕 O(N) (여기서 n 은 상자의 개수가 아니라 원소의 개수) 으로 실행될 것입니다.

처음부터 많은 개수의 상자를 사용할 수 없기 때문에 (메모리를 낭비할 순 없으므로..) 상자의 개수는 삽입되는 원소가 많아짐에 따라 점진적으로 늘어나게 됩니다.

문제는 상자의 개수가 늘어나면 해시 함수를 바꿔야 하기 때문에 (더 많은 값들을 해시값으로 반환할 수 있도록) 모든 원소들을 처음부터 끝 까지 다시 insert 해야 합니다. 이를 rehash 라 하며 만큼의 시간이 걸립니다.

기본 타입들(int, double 등등) 과 std::string 의 경우 라이브러리 자체적으로 해시 함수가 내장되어 있으므로, 그냥 사용하셔도 됩니다. 그러나 직접 만든 클래스의 경우 해쉬함수를 직접 만들어줘야 합니다. 그리고 셋이나 맵과는 다르게 순서대로 정렬하지 않기 때문에 operator< 는 필요하지 않지만 hash collision시 상자 안에 있는 원소들과 비교를 해야하기 때문에 operator==는 필요합니다...

(자세한 것은 https://modoocode.com/224 이곳과 https://woo-dev.tistory.com/106 이곳 참고)

[Python] 컴프리헨션(함축)

게임 개발자(진) — Fri, 23 Sep 2022 21:57:10 +0900

리스트 컴프리헨션

[표현식 for 항목 in 순회 가능한 객체]

의 방식으로 사용 예시

number_list=[number-1 for number in range(1,6)]

print(number_list) #출력: [0, 1, 2, 3, 4]

rows=range(1,4)
cols=range(1,3)
cells=[(row,col) for row in rows for col in cols]

for cell in cells:
    print(cell)

"""
출력:
(1, 1)
(1, 2)
(2, 1)
(2, 2)
(3, 1)
(3, 2)
"""

튜플 언패킹(각 튜플로부터 row와 col의 값만 출력하기 위해서)

rows=range(1,4)
cols=range(1,3)
cells=[(row,col) for row in rows for col in cols]

for row,col in cells:
    print(row,col)
"""
출력:
1 1
1 2
2 1
2 2
3 1
3 2
"""

[표현식 for 항목 in 순회 가능한 객체 if 조건]

의 방식으로 사용 예시

number_list=[number for number in range(1,6) if number %2 ==1]

print(number_list) #출력: [1, 3, 5]

딕셔너리 컴프리헨션

{키_표현식 : 값_표현식 for 표현식 in 순회 가능한 객체}

word='letters'

letter_counts1={letter: word.count(letter) for letter in word}
print(letter_counts1)
#출력: {'l': 1, 'e': 2, 't': 2, 'r': 1, 's': 1}


letter_counts2={letter: word.count(letter) for letter in set(word)} #set을 사용해봄
print(letter_counts2)
#출력: {'l': 1, 'r': 1, 's': 1, 'e': 2, 't': 2}

셋 컴프리헨션

{표현식 for 표현식 in 순회 가능한 객체}

a_set={number for number in range(1,6) if number % 3 ==1}
print(a_set) #출력: {1, 4}

제네레이터 컴프리헨션

튜플은 컴프리헨션이 없습니다.

괄호 안의 내용은 제너레이터 컴프리헨션이고 이것은 제너레이터 객체를 반환합니다.

number_thing=(number for number in range(1,6))

print(type(number_thing)) #출력: <class 'generator'>

number_thing=(number for number in range(1,6))

for number in number_thing:
    print(number)
"""
출력:
1
2
3
4
5
"""

number_thing=(number for number in range(1,6))

number_list=list(number_thing)
print(number_list) #출력: [1, 2, 3, 4, 5]

제네레이터는 한 번만 실행될 수 있음.
리스트,셋,문자열,딕셔너리는 메모리에 존재하지만, 제너레이터는 즉석에서 그 값을 생성하고, 이터레이터를 통해서 한 번에 값을 하나씩 처리한다.
제너레이터는 이 값을 기억하지 않으므로 다시 시작하거나 제너레이터를 백업할 수 없다.

[Python] 숫자 시퀀스 생성하기: range()

게임 개발자(진) — Fri, 23 Sep 2022 20:41:15 +0900

사용법

range(start,stop,step) 형식을 사용

start를 생략하면 범위는 0에서 시작합니다.

stop은 꼭 입력해야합니다.

step의 기본값은 1이며, -1을 지정하면 거꾸로 진행할 수 있습니다.

예시

zip(),range()와 같은 함수는 순회 가능한 객체를 반환합니다.

그러므로 for ...in 형태로 순회가 가능합니다.

또한 객체를 리스트와 같은 시퀀스로 변환할 수 있습니다.

for x in range(0,3):
    print(x)
"""
출력:
0
1
2
"""


for x in range(2,-1,-1):
    print(x)
"""
출력:
2
1
0
"""

for x in range(2, 0, -1):
    print(x)
"""
출력:
2
1
"""

print(list(range(0,3))) #출력: [0, 1, 2]

print(list(range(0,11,2))) #출력: [0, 2, 4, 6, 8, 10]

[Python] 여러 시퀀스 순회하기: zip()

게임 개발자(진) — Fri, 23 Sep 2022 18:35:17 +0900

zip()함수를 사용하면 여러 시퀀스를 병렬로 순회할 수 있습니다.

days=['Monday','Tuesday','Wednesday']
fruits=['banana','orange','peach']
drinks=['coffee','tea','beer']
desserts=['tiramisu','ice cream','pie','pudding'] #혼자만 4개임.

for day,fruit,drink,dessert in zip(days,fruits,drinks,desserts):
    print(day, ": drink", drink, "-eat", fruit, "- enjoy", dessert)
    """
    출력:
    Monday : drink coffee -eat banana - enjoy tiramisu
	Tuesday : drink tea -eat orange - enjoy ice cream
	Wednesday : drink beer -eat peach - enjoy pie
    """
    
    #desserts의 pudding이 출력 안 되는걸 볼 수 있습니다.

zip() 함수는 동일한 오프셋에 있는 항목으로부터 튜플을 만들 수 있습니다.

small='a','b','c'
big='A','B','C'

print(list(zip(small,big)))
#출력:[('a', 'A'), ('b', 'B'), ('c', 'C')]

print(dict(zip(small,big)))
#출력: {'a': 'A', 'b': 'B', 'c': 'C'}

small='a','b','c'
big='A','B','C'

print(zip(small,big)) #불가능한 표현
#출력: <zip object at 0x000002a64353a940>

그러나 위와같이 zip()단독으로 바로 print를 하게 되면 오브젝트의 위치를 반환하는 것을 알 수 있습니다.

즉, zip()에 의해 반환되는 값은 튜플이나 리스트 자신이 아니라 하나로 반환될 수 있는 순회 가능한 값이라는것을 알 수 있습니다.

[Python] 라인 유지하기: \

게임 개발자(진) — Fri, 23 Sep 2022 17:23:13 +0900

line_test='abc'+ \
    'def'+ \
    'ghi'

print(line_test) #출력: abcdefghi

파이썬에서 \문자를 라인의 끝에 입력하면,

다음 라인을 여전히 같은 라인으로 인식합니다.

[Python] 셋(Set)

게임 개발자(진) — Fri, 23 Sep 2022 03:52:14 +0900

셋은 값(value)를 버리고 키(key)만 있는 딕셔너리와 같습니다.

마찬가지로 키는 유일해야 합니다.

존재하는지 여부만 판단할때 셋을 사용합니다.

키에 어떤 정보를 첨부해서 그 결과를 얻고 싶을땐 딕셔너리를 사용합니다.

셋 생성: set(), { , , }

empty_set1=set()
# empty_set2={} ==> 이건 빈 딕셔너리를 의미한다! 빈 셋이 아님

set1={1,2,3}
print(set1) #출력: {1, 2, 3}

딕셔너리의 키와 마찬가지로 셋은 순서가 없다!

데이터 타입 변환: set()

리스트,문자열,튜플,딕셔너리로부터 중복된 값을 버린 셋을 생성할 수 있습니다.

리스트->셋

list=['aaa','bbb','ccc','aaa']
set_test=set(list)
print(set_test) #출력: {'ccc', 'bbb', 'aaa'}

문자열->셋

string='letters'

set_test=set(string)
print(set_test) #출력: {'s', 'l', 't', 'e', 'r'}

튜플->셋

tuple=('aaa','bbb','ccc','aaa')
set_test=set(tuple)
print(set_test) #출력: {'bbb', 'ccc', 'aaa'}

딕셔너리->셋

dict_test={'a':'hello', 'b':'world', 'c':'!!!!'}
set_test=set(dict_test)
print(set_test) #출력: {'a', 'c', 'b'}

in 활용

drinks={
    'martini': {'vodka','vermouth'},
    'black russian': {'vodka','kahlua'},
    'white russian': {'cream','kahlua','vodka'},
    'manhattan': {'rye','vermouth','bitters'},
    'screwdirver': {'orange juice','vodka'}
}

for name,contents in drinks.items():
    if 'vodka' in contents:
        print(name) 
"""
출력:
martini
black russian
white russian
screwdirver
"""

셋을 집합으로 활용

a={1,2}
b={2,3}

#----인터섹션(교집합)----#
print(a&b) #출력:{2}
print(a.intersection(b)) #출력:{2}

#----유니온(합집합)----#
print(a|b) #출력:{1, 2, 3}
print(a.union(b)) #출력:{1, 2, 3}

#----디퍼런스(차집합)----#
print(a-b) #출력:{1}
print(a.difference(b)) #출력:{1}

#----익스클루시브(대칭 차집합:한 쪽 셋에는 들어 있지만 양쪽 모두에 들어 있지 않은)----#
print(a^b) #출력:{1, 3}
print(a.symmetric_difference(b)) #출력:{1, 3}

#----서브셋(부분집합)----# #a가 b의 부분집합인가?
print(a<=b) #출력:False
print(a.issubset(b)) #출력:False

#----프로퍼 서브셋(진부분집합)----#
print(a<b) #출력:False

#----슈퍼셋(서브셋의 반대)----#
print(a>=b) #출력:False
print(a>=a) #출력:True

drinks={
    'martini': {'vodka','vermouth'},
    'black russian': {'vodka','kahlua'},
    'white russian': {'cream','kahlua','vodka'},
    'manhattan': {'rye','vermouth','bitters'},
    'screwdirver': {'orange juice','vodka'}
}

for name,contents in drinks.items():
    if 'vodka' in contents and not contents & {'vermouth','cream'}: #교집합 활용
        print(name)
"""
출력:
black russian
screwdirver
"""

폰(Pawn)

게임 개발자(진) — Mon, 12 Sep 2022 20:38:50 +0900

폰(Pawn)이란?

언리얼에서 폰은 플레이어가 빙의하여 키보드 입력을 통해 움직이는등의 상호작용이 가능한 액터입니다.

폰과 액터의 차이는

먼저 이름이 MyPawn으로 Pawn클래스를 하나 만들었습니다.

보시는 바와 같이 APawn을 상속하고 있습니다. (A는 언리얼의 네이밍 컨벤션)

작명규칙 링크

코딩 표준

언리얼 엔진 4 코드베이스에 에픽게임즈가 사용하는 표준과 규칙입니다.

docs.unrealengine.com

Pawn의 구조가 궁금해서 타고 들어가서 보면,

Actor를 상속받고 있는 것을 볼 수 있습니다.

//MyPawn.h

// Called to bind functionality to input
virtual void SetupPlayerInputComponent(class UInputComponent* PlayerInputComponent) override;

MyPawn.h를 보면 원래 Actor클래스에는 없었던 SetupPlayerInputComponent가 기본적으로 있는 것을 볼 수 있습니다.

이 컴포넌트를 통해서 키보드 입력이라던지 마우스 움직임이라던지의 입력을 관리하게 됩니다.

이런식으로 액터에다가 추가 기능들이 더해진 것이 Pawn입니다.

언리얼에서 로그 찍기

게임 개발자(진) — Fri, 9 Sep 2022 23:36:21 +0900

로그 사용법

//카테고리, 로깅 수준, 형식, 인자 
UE_LOG(LogTemp,Warning,TEXT("BeginPlay %d"),3);

카테고리는 원하는걸 적으면 됩니다.

로깅 수준의 종류는 링크 에서 확인 가능합니다. (언리얼 에디터 상에서 색상이 바뀌고 파일로 기록이 남는등의 차이)

기본적으로 저장된 로그파일은 Saved\Logs 경로에서 확인할 수 있습니다.

그리고 형식,인자는 printf()에서 쓰는 방식처럼 쓰면 됩니다.

예시

void AMyActor::BeginPlay()
{
	Super::BeginPlay();
	
	//카테고리, 로깅 수준, 형식, 인자
	UE_LOG(LogTemp, Warning, TEXT("BeginPlay %d"), 3);
}

액터의 BeginPlay() 부분에 써봤습니다.

출력 로그 창에 다음과 같이 뜨게 됩니다. (로깅수준이 Warning이라 노란색)

액터(Actor) 기초

게임 개발자(진) — Fri, 9 Sep 2022 22:26:35 +0900

언리얼에서 액터(Actor) 이란?

액터는 월드에 배치하는 오브젝트를 의미합니다. 물체의 가장 기본이 된다고도 볼 수 있습니다.

이번 포스트에서는 Actor에 겉모습을 지정해보겠습니다.

먼저 c++ 클래스로 Actor를 생성합니다. 이름은 MyActor 기본으로 생성하겠습니다.

MyActor.h 와 MyActor.cpp 초기상태

//MyActor.h 초기상태

#pragma once

#include "CoreMinimal.h"
#include "GameFramework/Actor.h"
#include "MyActor.generated.h"

UCLASS()
class TISTORY_API AMyActor : public AActor
{
	GENERATED_BODY()
	
public:	
	// Sets default values for this actor's properties
	AMyActor();

protected:
	// Called when the game starts or when spawned
	virtual void BeginPlay() override;

public:	
	// Called every frame
	virtual void Tick(float DeltaTime) override;
};

//MyActor.cpp 초기상태
#include "MyActor.h"

// Sets default values
AMyActor::AMyActor()
{
 	// Set this actor to call Tick() every frame.  You can turn this off to improve performance if you don't need it.
	PrimaryActorTick.bCanEverTick = true;
}

// Called when the game starts or when spawned
void AMyActor::BeginPlay()
{
	Super::BeginPlay();
	
}

// Called every frame
void AMyActor::Tick(float DeltaTime)
{
	Super::Tick(DeltaTime);

}

Actor에 겉모습 입히기

언리얼에는 2가지의 Mesh유형이 존재합니다.

하나는 StaticMesh, 다른 하나는 SkeletalMesh입니다.

보통 관절의 움직임등이 필요한(ex 캐릭터) 액터에는 SkeletalMesh를,

그 외에는 전부 StaticMesh를 사용합니다.

참고링크

이번 포스트에서는 단순한 의자 형태의 Actor을 생성할 것이기 때문에 StaticMesh를 사용합니다.

//MyActor.h에 추가
private:
	UPROPERTY(VisibleAnywhere)
	UStaticMeshComponent* Mesh;

MyActor.h에 위 코드를 추가합니다.

UPROPERTY() 는 언리얼에서 제공하는 기능(리플렉션)을 사용하기 위해서 반드시 붙여줘야합니다.

UPROPERTY()와 관련된 내용은==>링크

VisibleAnywhere와 관련된 내용은 ==> 링크

//MyActor.cpp에 추가
AMyActor::AMyActor()
{
 	// Set this actor to call Tick() every frame.  You can turn this off to improve performance if you don't need it.
	PrimaryActorTick.bCanEverTick = true;

	Mesh = CreateDefaultSubobject<UStaticMeshComponent>(TEXT("MESH"));

	RootComponent = Mesh;

	static ConstructorHelpers::FObjectFinder<UStaticMesh> SM(TEXT("StaticMesh'/Game/StarterContent/Props/SM_Couch.SM_Couch'"));

	if (SM.Succeeded())
	{
		Mesh->SetStaticMesh(SM.Object);
	}
}

Mesh = CreateDefaultSubobject<UStaticMeshComponent>(TEXT("MESH"));

RootComponent = Mesh;

Mesh에 관한 메모리 관리를 언리얼 상에서 자동으로 해주게 됩니다.

즉 직접 delete할 필요가 없습니다. (일종의 스마트포인터)

TEXT는 해시값으로 사용하기 위해서 주는 값인데, 겹치지 않게 주면 됩니다.

왜 굳이 TEXT()를 사용해서 전달을 해주냐면, 기기마다 문자열 체계가 다를 수 있기 때문에 해당 호환성을 위해서 언리얼에선 문자열을 TEXT()를 사용해서 사용합니다.

그리고 컴포넌트 중에 하나를 RootComponent로 설정해줘야합니다.

지금은 스태틱메시컴포넌트를 루트컴포넌트로 설정했습니다. (규칙같은 거니까 그냥 쓰면 됩니다.)

static ConstructorHelpers::FObjectFinder<UStaticMesh> SM(TEXT("StaticMesh'/Game/StarterContent/Props/SM_Couch.SM_Couch'"));

리소스를 로드하는 과정입니다.

로드하고 싶은 스태틱메시를 Ctrl+C 를 하던가, 파일 경로 복사를해서 TEXT()속에 붙여넣어야 합니다.

그럼 이제 SM에 해당 스태틱메시가 로드된 상태입니다.

if (SM.Succeeded())
{
	Mesh->SetStaticMesh(SM.Object);
}

SM에 해당 스태틱메시 로드가 정상적으로 됐다면

스태틱메시컴포넌트인 Mesh에 해당 로드된 오브젝트를 설정해줍니다.

이제 빌드를 완료하고 방금 만든 MyPawn클래스를 맵에 끌어다놓으면 의도한대로 겉모습이 바뀐걸 볼 수 있습니다.

추가로

//MyActor.h에 추가

UPROPERTY(EditAnywhere,Category=Stat)
int32 Hp;

UPROPERTY(EditAnywhere,Category = Stat)
int32 Mp;

이런식으로 int32형으로 카테고리를 지정해주고 빌드하면

이런식으로 프로퍼티창에 생기게 됩니다.

UPROPERTY()를 안쓰면 뜨지 않습니다.

visible과 edit의 차이

게임 개발자(진) — Fri, 9 Sep 2022 21:12:45 +0900

Visible, Edit의 차이? 왜 이렇게 쓸까

언리얼 코드를 짜다보면 UPROPERTY뒤 ( ) 사이에 쓰는 키워드들을 본 적이 있을 것입니다.

여기서 Visible과 Edit의 차이를 궁금해서 찾다가 알아낸 사실을 기록하려고 합니다.

UPROPERTY(VisibleAnywhere) 
UStaticMeshComponent *Body; 

UPROPERTY(EditAnywhere,Category=IDtest)
int32 ID;

언뜻봐서는 직관적으로 Visible은 언리얼에디터에서 수정이 불가능하겠지? Edit은 수정이 가능한것이겠지? 라고 생각했었습니다.

그러나 위 코드처럼 Body와 ID를 만들었을때 충격적이게도 Body에 속하는 속성들을 언리얼 상에서 수정이 가능하였고 ID또한 수정이 가능하였습니다.

그러나

UPROPERTY(EditAnywhere) 
UStaticMeshComponent *Body;

이렇게 작성했을경우 Body의 속성을 언리얼에디터에서 수정이 불가능하였습니다. 도대체 어떤 차이일까?

확인해본 결과 객체에 visible을 사용했을 경우 객체일 경우 오브젝트 안의 속성들을 언리얼에디터에서 수정이 가능하지만 edit을 사용했을때는 객체의 레퍼런스 자체를 변경하는 옵션이(staticmesh에서 다른 컴포넌트로 한다던지…) 언리얼 에디터상에서 나타나고 오브젝트 안의 속성들을 수정할수없었다.

즉 왠만해서는 객체에는 visible을 쓰는게 맞을것 같고 int32 ID같은 일반적인 자료형의 경우에는 수정을 원할때만 Edit 키워드를 쓰면 될 것 같다.

이것은 visible과 edit뒤에 붙는 키워드 3개인 DefaultsOnly, InstanceOnly, Anywhere 세개와의 조합을 표로 나타낸 것입니다.

해당 표는 https://darkcatgame.tistory.com/62 해당 블로그에서 잘 정리해뒀기에 인용하였습니다.

#이 기능은 언리얼 오브젝트라는 특별한 객체에만 사용 가능.

[C++] 하키(1358번)

게임 개발자(진) — Fri, 9 Sep 2022 19:37:46 +0900

문제

풀이

첫번째 예제를 예로 들면

이런 상황이라고 볼 수 있습니다.

이 문제를 푸는 알고리즘은 다음과 같습니다.

직사각형안인가?
왼쪽 반원 중심부터 거리가 r(=h/2) 이하인가?
오른쪽 반원 중심부터 거리가 r(=h/2) 이하인가?

위 셋 중에 하나라도 포함된다면 링크안에 있는것으로 판별합니다.

코드로 표현하면 다음과 같습니다.

#include<iostream>
#include<cmath>
using namespace std;

int main()
{
    double w,h,x,y,p; //p는 선수의 수
    cin>>w>>h>>x>>y>>p;
    int aws=0;
    for(int i=0; i<p; i++)
    {
        double p_x,p_y;
        cin>>p_x>>p_y;
        
        double distance_from_left_circle=sqrt(pow((x-p_x),2)+pow(y+h/2-p_y,2));
        double distance_from_right_circle=sqrt(pow((x+w-p_x),2)+pow(y+h/2-p_y,2));
        
        if((p_x>=x && p_x<=x+w) && (p_y>=y && p_y<=y+h)) //직사각형 안인가?
            aws++;
        else if(distance_from_left_circle<=h/2) //왼쪽 반원 안에 있는가?
            aws++;
        else if(distance_from_right_circle<=h/2) //오른쪽 반원 안에 있는가?
            aws++;
    }
    cout<<aws;
}

[Python] 딕셔너리(딕트)

게임 개발자(진) — Fri, 9 Sep 2022 19:17:16 +0900

딕셔너리는 값(value)에 상응하는 고유한 키(key)를 지정합니다.

즉, key-value 형태로 이루어져있습니다.

키는 대부분 문자열이지만 불변하는 파이썬의 어떤 타입도 될 수 있습니다.

딕셔너리는 항목의 순서를 따지지 않습니다.

다른 언어에서는 딕셔너리를 연관 배열, 해시, 해시맵 등이라고 부릅니다.
파이썬에서는 딕셔너리를 딕트라고도 부릅니다.

딕셔너리 생성

중괄호{}안에 콤바로 구분된 키:값 쌍을 지정합니다.

empty_dict={}

dict={'day':'2022년 9월 9일',
      '시간':'오후 5시 40분',
      '장소':'우리집',
      '좋아하는 숫자':'01'}

print(dict['시간']) #출력:오후 5시 40분

print(dict) #출력:{'day': '2022년 9월 9일', '시간': '오후 5시 40분', '장소': '우리집', '좋아하는 숫자': '01'}

딕셔너리로 변환하기: dict()

dict() 함수를 사용해서 두 값으로 이루어진 시퀀스를 딕셔너리로 변환할 수 있습니다.

각 시퀀스의 첫 번째 항목은 키(key), 두번째 항목은 값(value)로 사용됩니다.

list=[['지역','서울'],['스마트폰','아이폰']]

dict_test=dict(list)

print(dict_test) #출력:{'지역': '서울', '스마트폰': '아이폰'}   ==>이 순서는 바뀔수 있습니다.
print(dict_test['스마트폰']) #출력:아이폰

------------------------------------------------------------------------------------------

test=[('지역','서울'),('스마트폰','아이폰')]

dict_test=dict(test)

print(dict_test) #출력:{'지역': '서울', '스마트폰': '아이폰'}아이폰
print(dict_test['스마트폰']) #출력:아이폰

------------------------------------------------------------------------------------------

test=['ab','cd','ef']

dict_test=dict(test)

print(dict_test) #출력:{'a': 'b', 'c': 'd', 'e': 'f'}
print(dict_test['e']) #출력:f

항목 추가/변경하기:[key]

키가 딕셔너리에 이미 존재하는 경우, 그 값은 새 값으로 대체됩니다.

키가 존재하지 않는 경우, 새 값이 키와 사전에 추가됩니다.

리스트와 달리 딕셔너리를 할당할 때는 인덱스의 범위가 벗어나는 예외에 대해 걱정할 필요가 없습니다.

dict_test={'day':'2022년 9월 9일',
      '시간':'오후 5시 40분',
      '장소':'우리집',
      '좋아하는 숫자':'01'}

dict_test['전공']='컴공'

print(dict_test['전공']) #출력:컴공
print(dict_test) #출력:{'day': '2022년 9월 9일', '시간': '오후 5시 40분', '장소': '우리집', '좋아하는 숫자': '01', '전공': '컴공'}

딕셔너리 결합하기: update()

first={'a':1,'b':2}
second={'b':3,'c':4}

first.update(second)

print(first) #출력:{'a': 1, 'b': 3, 'c': 4}

만약에 두 딕셔너리에 키 값이 겹친다면, ( ) 속에 있는딕셔너리가 경쟁에서 이깁니다.

키와 del로 항목 삭제

test={'a':1,'b':2}

del test['a']

print(test) #출력:{'b': 2}

모든 항목 삭제: clear()

test={'a':1,'b':2}

test.clear()

print(test) #출력:{}

또는

test={'a':1,'b':2}

test={}

print(test) #출력:{}

빈 딕셔너리를 할당해도 됩니다.

key 존재 여부 확인: in

test={'a':1,'b':2}

print('b' in test) #출력:True

항목 얻기:[key], get()

test={'a':1,'b':2}

print(test['a']) #출력:1

print(test.get('a')) #출력:1

print(test.get('c')) #출력:None

print(test.get('c','Not Exist')) #출력:Not Exist

모든 키, 값 얻기: keys(), values()

test={'a':1,'b':2}

print(test.keys()) #출력:dict_keys(['a', 'b'])

list_test=list(test.keys())
print(list_test) #출력:['a', 'b']

아래 코드와 같이 list()를 호출해서 dict_keys객체를 리스트로 변환하는 응용도 가능합니다.

test={'a':1,'b':2}

print(test.values()) #출력:dict_values([1, 2])

list_test=list(test.values())
print(list_test) #출력:[1, 2]

모든 쌍의 key-value 얻기: items()

test={'a':1,'b':2}

print(test.items()) #출력:dict_items([('a', 1), ('b', 2)])

list_test=list(test.items())
print(list_test) #출력:[('a', 1), ('b', 2)]

각 키와 값은 (key,value) 와 같이 튜플로 반환됩니다.

할당:=, 복사: copy()

test={'a':1,'b':2}

testA=test
testA['a']=8
print(test['a']) #출력:8

할당 '=' 같은 경우에는 리스트와 마찬가지로 원본에도 영향을 미칩니다. (마치 포인터같처럼)

test={'a':1,'b':2}

testB=test.copy()
testB['a']=8
print(test['a']) #출력:1

그러나 복사 'copy()'같은 경우에는 말 그대로 복사기 때문에 영향을 미치지 않습니다.

딕셔너리의 키는 불변하기 때문에 리스트,틱셔너리,셋은 다른 딕셔너리의 키가 될 수 없는데,

튜플은 딕셔너리의 키가 될 수 있습니다.

[Python] 튜플(tuple)

게임 개발자(진) — Fri, 9 Sep 2022 17:32:45 +0900

튜플은 불변한 성질을 갖습니다.

즉, 튜플을 정의한 후에는 추가,삭제,수정을 할 수 없다는 뜻입니다.

그렇기때문에 튜플은 상수의 리스트라고 생각할 수 있습니다.

튜플을 사용하는 이유

튜플은 리스트의 append(),insert()등과 같은 함수가 없고 함수의 수도 적습니다.

튜플을 생성한 후에는 수정할 수 없기 때문입니다.

그럼 왜 튜플을 사용할까요?

튜플은 더 적은 공간을 사용합니다.
실수로 튜플의 항목이 손상될 염려가 없다.
네임드 튜플은 객체의 단순한 대안이 될 수 있습니다.
함수의 인자들은 튜플로 전달됩니다.

그렇지만 보통 리스트와 딕셔너리를 더 많이 사용하는 편입니다.

튜플 생성하기

TupleA='hi','hello'
TupleB=('python','study')

print(TupleA) #출력:('hi', 'hello')
print(TupleB) #출력:('python', 'study')

( )는 써도 되고 안써도 됩니다.

튜플 언패킹(tuple unpacking)

Tuple=('hi','hello','bye')

a,b,c=Tuple #####튜플 언패킹####

print(a,b,c) #출력:hi hello bye

a='hhh'
print(a) #출력:hhh

print(Tuple) #출력:('hi', 'hello', 'bye')

튜플은 한 번에 여러 변수를 할당할 수 있는데 이를 튜플 언패킹이라고 합니다.

값 교환

a='aaaa'
b='bbbb'

a,b=b,a

print(a,b) #출력:bbbb aaaa

한 문장에서 값을 교환하기 위해 임시 변수를 사용하지 않고 튜플을 사용할 수 있습니다.

다른 객체를 튜플로

list=['hi','hello']

tuple_test=tuple(list)
print(tuple_test) #출력:('hi', 'hello')

tuple()은 다른 객체를 튜플로 만들어줍니다.

[C++] 주식가격(Lv.2)

게임 개발자(진) — Thu, 8 Sep 2022 19:31:27 +0900

문제

풀이

2중 for문을 사용했습니다.

처음 for문은 검사할 시점의 주식가격을 결정하고

두번째 for문에서는 첫번째 for문에서 결정된 가격에비해 하락이 있었나 여부를 판단해서 계산합니다.

#include <string>
#include <vector>

using namespace std;

vector<int> solution(vector<int> prices) {
    vector<int> answer;
    for(int i=0; i<prices.size(); i++)
    {
        int count=0;
        for(int j=i+1; j<prices.size(); j++)
        {
            if(prices[i] <= prices[j])
                count++;
            else
            {
                count++;
                break;
            }
        }
        answer.push_back(count);
    }
    return answer;
}

[C++] 어린 왕자(1004번)

게임 개발자(진) — Thu, 8 Sep 2022 18:21:08 +0900

문제

풀이

진입/이탈을 세는 매커니즘은 다음과 같습니다.

출발점이 해당 행성계 안에 있는지 확인합니다.
도착점이 해당 행성계 안에 있는지 확인합니다.
출발,도착점 둘다 해당 행성계 안에 있거나 밖에 있는거 아니면 count를 증가시켜줍니다. (=진입/이탈횟수를 저장하는 변수)

#include<iostream>
#include<vector>
#include<tuple>
#include<cmath>

using namespace std;

int main()
{
    int t; //테스트케이스
    cin>>t;
    
    for(int i=0; i<t; i++)
    {
        int startX,startY,endX,endY;
        cin>>startX>>startY>>endX>>endY;
        pair<int,int> start=make_pair(startX,startY); //출발점
        pair<int,int> end=make_pair(endX,endY); //도착점
        
        int n; //행성계 갯수
        cin>>n;
        vector<tuple<int,int,int>> v; //행성계들의 (x,y,반지름) 이 저장됨
        for(int i=0; i<n; i++)
        {
            int x,y,r;
            cin>>x>>y>>r;
            v.push_back(make_tuple(x,y,r));
        }
        
        int count=0;
        for(int i=0; i<n; i++)
        {
            double distance_from_start=sqrt(pow(get<0>(v[i])-start.first,2)+pow(get<1>(v[i])-start.second,2));
            double distance_from_end=sqrt(pow(get<0>(v[i])-end.first,2)+pow(get<1>(v[i])-end.second,2));
            
            bool is_start_in_planet=distance_from_start < get<2>(v[i]); //출발점이 해당 행성계에 있는가
            bool is_end_in_planet=distance_from_end < get<2>(v[i]); //도착점이 해당 행성계에 있는가?
            
            if(is_start_in_planet!=is_end_in_planet) //출발,도착점중 하나는 행성계 안에 있고 하나는 밖에 있을때만 count++
                count++;
        }
        
        cout<<count<<"\n";
    }
    
}

[Python] 리스트(List)

게임 개발자(진) — Thu, 8 Sep 2022 16:54:57 +0900

튜플은 항목을 할당하고 나서 바꿀수없는 '불변(immutable)'한 성질을 갖습니다.

리스트는 그와 반대로 자유롭게 수정하거나 삭제할 수 있는 mutable한 성질을 갖습니다.

리스트 생성하기: [ ]또는 list()

week=['Monday','Tuesday','Wednesday','Thursday','Friday','Saturday','Sunday']

empty_list=[] #빈 리스트 생성
empth_list_another=list() #빈 리스트 생성

참고로 리스트는 값이 유일할 필요가 없습니다.

요소들이 순서는 상관없이 유일한 값으로만 유지될 필요가 있다면,
리스트보단 셋(set)을 사용하는 것이 더 좋습니다.

슬라이스로 항목 추출

week=['Monday','Tuesday','Wednesday','Thursday','Friday','Saturday','Sunday']

print(week[0:3]) #출력:['Monday', 'Tuesday', 'Wednesday']

print(week[::2]) #출력:['Monday', 'Wednesday', 'Friday', 'Sunday']

print(week[::-2]) #출력:['Sunday', 'Friday', 'Wednesday', 'Monday']

print(week[::-1]) #출력:['Sunday', 'Saturday', 'Friday', 'Thursday', 'Wednesday', 'Tuesday', 'Monday']

리스트의 슬라이스 또한 슬라이스입니다.

마지막 코드같은경우 리스트를 반전시키는 효과를 냅니다.

리스트 끝 항목 추가: append()

week=['Monday','Tuesday','Wednesday','Thursday','Friday','Saturday','Sunday']

week.append('good')
print(week) #출력:['Monday', 'Tuesday', 'Wednesday', 'Thursday', 'Friday', 'Saturday', 'Sunday', 'good']

특정 위치에 항목 추가: insert()

week=['Monday','Tuesday','Wednesday','Thursday','Friday','Saturday','Sunday']

week.insert(2,'good')
print(week) #출력:['Monday', 'Tuesday', 'good', 'Wednesday', 'Thursday', 'Friday', 'Saturday', 'Sunday']

첫번째 인자로 오프셋을 주는데, 리스트의 끝을 넘는 오프셋을 주면 append()처럼 끝에다가 추가합니다.

오프셋으로 항목 삭제하기: del

week=['Monday','Tuesday','Wednesday','Thursday','Friday','Saturday','Sunday']

del week[2]

print(week) #출력:['Monday', 'Tuesday', 'Thursday', 'Friday', 'Saturday', 'Sunday']

del은 리스트 함수가 아닌 파이썬 구문입니다.
del은 할당(=)의 반대입니다.

값으로 항목 삭제하기: remove()

리스트에서 삭제할 항목의 위치를 모르는 경우, 값을 이용해서 삭제할 수 있습니다.

week=['Monday','Tuesday','Wednesday','Thursday','Friday','Saturday','Sunday']

week.remove('Tuesday')

print(week) #출력:['Monday', 'Wednesday', 'Thursday', 'Friday', 'Saturday', 'Sunday']

오프셋으로 항목을 얻은 후 삭제하기: pop()

week=['Monday','Tuesday','Wednesday','Thursday','Friday','Saturday','Sunday']

print(week.pop()) #맨마지막인 Sunday삭제
print(week.pop(3)) #오프셋3번에 위치한 Thursday삭제
print(week) #출력:['Monday', 'Tuesday', 'Wednesday', 'Friday', 'Saturday']

pop()은 리스트에서 항목을 가져오는 동시에 그 항목을 삭제합니다.

인자를 주지 않으면 -1을 사용합니다.(맨 끝)

값으로 오프셋 찾기: index()

week=['Monday','Tuesday','Wednesday','Thursday','Friday','Saturday','Sunday']

print(week.index('Friday')) #출력:4

존재여부 확인: in

week=['Monday','Tuesday','Wednesday','Thursday','Friday','Saturday','Sunday']

print('Sunday' in week) #출력:True

리스트에 값이 적어도 하나 존재하면 in은 True를 반환합니다.

값 세기: count()

test=['hi','hi','hi','hello',123]
print(test.count('hi')) #출력:3

리스트에 특정 값이 얼마나 있는지

리스트 병합하기: extend() 또는 +=

week=['Monday','Tuesday']
others=['hi','hello']
another=['world','python']

week.extend(others)
print(week) #출력:['Monday', 'Tuesday', 'hi', 'hello']


week+=another
print(week) #출력:['Monday', 'Tuesday', 'hi', 'hello', 'world', 'python']

week=['Monday','Tuesday']

a=100
other=['hello','hi']
week.append(a)
week.append(other)

print(week) #출력:['Monday', 'Tuesday', 100, ['hello', 'hi']]

이때 append()를 사용하면 항목을 병합하지 않고, 그 자체가 하나의 리스트로 추가됩니다.

(리스트는 다른 타입의 요소를 포함할 수 있습니다)

정렬하기: sort(), sorted()

week=['Monday','Tuesday','Wednesday','Thursday','Friday','Saturday','Sunday']

week.sort()
print(week) #출력:['Friday', 'Monday', 'Saturday', 'Sunday', 'Thursday', 'Tuesday', 'Wednesday']

week.sort(reverse=True)
print(week) #출력:['Wednesday', 'Tuesday', 'Thursday', 'Sunday', 'Saturday', 'Monday', 'Friday']

sort()는 리스트 자체를 내부적으로 정렬합니다.
기본적으로 오름차순으로 정렬
reverse=True를 추가하면 내림차순으로 정렬됩니다

항목 갯수 얻기: len()

week=['Monday','Tuesday','Wednesday','Thursday','Friday','Saturday','Sunday']

print(len(week)) #출력:7

할당: =, 복사: copy(), list()변환함수, 슬라이스[:]

a=[1,2,3]

b=a
print(b) #출력:[1, 2, 3]

b[0]='change'
print(b) #출력:['change', 2, 3]
print(a) #출력:['change', 2, 3]

주의할점은 b=a를 한 후에 b의 값을바꾸면 a의 값도 마찬가지로 변경이 됩니다.

마치 포인터를 사용하는 것 처럼..

위와같은 상황을 피하고 싶다면 복사를 해야합니다.

a=[1,2,3]

b=a.copy()
print(b) #출력:[1, 2, 3]

c=list(a)
print(c) #출력:[1, 2, 3]

d=a[:]
print(d) #출력:[1, 2, 3]

b[0]='changeB'
c[0]='changeC'
d[0]='changeD'

print(a) #출력:[1, 2, 3]
print(b) #출력:['changeB', 2, 3]
print(c) #출력:['changeC', 2, 3]
print(d) #출력:['changeD', 2, 3]

copy() 함수
list() 변환 함수
슬라이스 [:]

를 사용해서 한 리스트를 새로운 리스트로 복사할 수 있습니다.

이들은 자신만의 값을 가진 새로운 객체입니다.

[Python] 문자열 다루기

게임 개발자(진) — Wed, 7 Sep 2022 02:08:35 +0900

문자열 함수에 관한 표준 문서 웹사이트

print

print("hello") #출력:hello

print('hello') #출력:hello

print("hello 'world'") #출력: hello 'world'

print('hello "world"') #출력: hello "world"



print("hello" + "world") #출력: helloworld

print("hello","world") #출력: hello world

print("hello" "world") #출력: helloworld

파이썬은 문자열을 ' ' 또는 " "로 감싸서 표현합니다.

이때 저 기호 자체를 문자열로 만들고싶다면 위 코드의 3,4번째같이 사용하면 됩니다.

+를 이용하여 두 문자열을 이어붙일수 있습니다.

,를 사용해서 이어붙이면 사이에 자동으로 공백 한칸이 추가됩니다.

print('hello', end='%^&') 
print("world") 
#출력 : hello%^&world


print('hello', 'world', sep='-')
#출력: hello-world


f = open('test.txt', 'w')
print('hello world', file=f)
f.close()
#test.txt에 hello world가 저장됨


import sys
print('MyError', file=sys.stderr)
#표준에러처리로 MyError가 발생함

end 인자를 사용하면 print함수 마지막 효과를 변경할 수 있습니다. (기본값은 개행)

sep 인자를 사용하면 콤마로 구분된 문자열을 다르게 결합할 수 있습니다. (기본값은 공백)

file 인자를 사용하면 출력 결과를 파일, 표준에러처리로 보낼 수 있습니다.

i = 123

f = 3.14

s = 'Hello'

print('i: %d, f: %f, s: %s' % (i, f, s))

#출력 : i: 123, f: 3.140000, s: Hello

C언어식 표현방법도 가능합니다.

이스케이프 문자

print("escape \'test") #출력 : escape 'test

복제하기: *

print("ha" * 3) 
#출력: hahaha

문자 추출: []

string="abcdefg"

print(string[0]) #출력:a

print(string[1]) #출력:b

print(string[-1]) #출력:g

print(string[-2]) #출력:f

가장 왼쪽은 0, 오른쪽으로 1,2,3...

가장 오른쪽은 -1, 왼쪽으로 -2,-3,-4...

슬라이스: [start:end:step]

start는 시작 오프셋(맨 처음을 의미하는것이 아님. 이 자리에 들어오는 숫자가 시작지점이라는 뜻)을 의미,

end는 끝 오프셋(맨 끝 말하는것이 아닌, 이 자리에 들어오는 숫자가 끝 지점이라는뜻)을 의미,(실제로는 이것 바로 앞까지를 의미함)

step은 옵션.

이들 중 일부 생략 가능

[ : ] 처음부터 끝까지 전체 시퀀스를 추출한다
[start:] start오프셋부터 끝까지 시퀀스를 추출한다
[:end] 처음부터 (end-1)오프셋까지 시퀀스를 추출한다
[start : end] start오프셋부터 (end-1) 오프셋까지 시퀀스를 추출한다
[start:end:step] step만큼 문자를 건너뛰면서, start 오프셋부터 (end-1)오프셋까지 시퀀스를 추출한다.

string="abcdefg"

print(string[1:2]) #출력: b

print(string[3::2]) #출력: df

문자열 길이: len()

print(len("abc")) #출력: 3

스페이스와 줄바꿈도 포함된 길이가 나옵니다.

문자열 나누기: split()

string="ca t, do g, compu ter"

print(string.split()) #출력: ['ca', 't,', 'do', 'g,', 'compu', 'ter']

print(string.split(",")) #출력: ['ca t', ' do g', ' compu ter']

a=string.split()
print(a[1]) #출력: t,

특정 구분자를 기준으로 하나의 문자열을 작은 문자열들의 리스트로 나누기 위해서 문자열 내장함수 split()을 사용합니다.

구분자를 지정하지 않으면 split()은 문자열에 등장하는 공백 문자(줄바꿈,스페이스,탭)을 사용합니다.

문자열로 결합하기: join()

join()함수는 split()함수의 반대입니다.

join()함수는 문자열 리스트를 하나의 문자열로 결합합니다.

string_list=['hello','world','python']

join_string='#'.join(string_list)

print(join_string) #출력: hello#world#python

문자열 정렬( center(), ljust(), rjust() )

string="hello world"

print(string.center(30)) #출력:         hello world          

print(string.ljust(30)) #출력:hello world                   

print(string.rjust(30)) #출력:                   hello world

지정한 공간에서 정렬함

center,ljust,rjust가 있음

대체하기: replace()

string="hello world hello world hello world"

print(string.replace("hello","hi",2)) #출력:hi world hi world hello world

인자로 바꿀 문자열, 대체할 새 문자열, 바꿀 문자열에 대한 횟수를 입력합니다.

횟수를 생략하면 모든 문자열에대해서 바꿉니다.

그 외 다양한 함수

string="hello world"

print(string.startswith("he")) #출력: True

startswith() : 특정 문자로 시작하는지 여부를 출력해줌

string="hello world"

print(string.endswith("orld")) #출력: True

endswith() : 특정 문자로 끝나는지 여부를 출력해줌

string="is is is is"

print(string.find("is")) #출력: 0

find(): 특정 문자가 첫번째로 나오는 오프셋을 출력해줌

string="is is is is"

print(string.rfind("is")) #출력: 9

rfind(): 특정 문자가 마지막으로 나오는 오프셋을 출력해줌

string="is is is is"

print(string.count("is")) #출력: 4

count(): 특정 문자가 몇 번 나오는지 출력해줌

string="this is *"
print(string.isalnum()) #출력: False


Ironman="ILoveYou3000"
print(Ironman.isalnum()) #출력: True

Ironman="I Love You3000"
print(Ironman.isalnum()) #출력: False

isalnum(): 글자와 숫자로만 이루어져 있는가를 출력해줌 (띄어쓰기도 안됨)

string="hello world this is PYTHON..!.."


print(string.strip('.')) #출력: hello world this is PYTHON..!

print(string.capitalize()) #출력: Hello world this is python..!..

print(string.title()) #출력: Hello World This Is Python..!..

print(string.upper()) #출력: HELLO WORLD THIS IS PYTHON..!..

print(string.lower()) #출력: hello world this is python..!..

print(string.swapcase()) #출력: HELLO WORLD THIS IS python..!..

strip(): 양끝에서 특정 시퀀스를 삭제

capitalize(): 첫 단어를 대문자로

title(): 모든 단어의 첫글자를 대문자로

upper(): 모두 대문자로

lower(): 모두 소문자로

swapcase(): 대문자는 소문자로, 소문자는 대문자로

[C++] 백준-터렛(1002번)

게임 개발자(진) — Tue, 6 Sep 2022 01:01:31 +0900

문제

풀이

int t;
cin>>t;

먼저 테스트케이스의 갯수 T를 입력받습니다.

   int x1,y1,r1,x2,y2,r2;
   for (int i = 0; i < t; i++)
   {
      cin>>x1>>y1>>r1>>x2>>y2>>r2;
      double distance=sqrt(pow(x1-x2,2)+pow(y1-y2,2));
      
      ...

x1,y1,r1 x2,y2,r2값을 입력받고, 두 원의 중심 사이의 거리를 distance에 저장합니다.

//원이 겹칠떄
if (distance == 0 && r1 == r2)
	cout << -1<<"\n";

원이 겹칠때 교점이 무한개이므로 -1을 출력합니다.

//원이 한점에서 만날때
else if (distance == r1 + r2 || distance + (r1 > r2 ? r2 : r1) == (r1 > r2 ? r1 : r2))
	cout << 1<<"\n";

distance ==r1+r2 는 왼쪽의 상황,

distance + (r1 > r2 ? r2 : r1) == (r1 > r2 ? r1 : r2) 는 오른쪽의 상황을 의미합니다.

//원이 아예 안만날때
else if (distance > r1 + r2 || distance + (r1 > r2 ? r2 : r1) < (r1 > r2 ? r1 : r2))
	cout << 0<<"\n";

distance > r1 + r2는 왼쪽 상황

distance + (r1 > r2 ? r2 : r1) < (r1 > r2 ? r1 : r2)는 오른쪽 상황입니다.

이때 원이 완전히 겹치는 경우에도 distance + (r1 > r2 ? r2 : r1) < (r1 > r2 ? r1 : r2) 이 조건문에 걸리게되는데,

앞서서 원이 겹치는건 if문으로 먼저 처리를 해주었기 때문에 따로 처리를 해주지 않아도 됩니다.

//원이 2점에서 만날때
else
	cout << 2<<"\n";

그 외 나머지 상황은 원이 2점에서 만나는 것이기때문에 2를 출력해줍니다.

이 과정을 테스트케이스 t만큼 반복해주면 됩니다.

#include<iostream>
#include<cmath>
#include<math.h>
using namespace std;

int main()
{
   int t;
   cin>>t;
   int x1,y1,r1,x2,y2,r2;
   for (int i = 0; i < t; i++)
   {
      cin>>x1>>y1>>r1>>x2>>y2>>r2;
      double distance=sqrt(pow(x1-x2,2)+pow(y1-y2,2));

      //원이 겹칠떄
      if (distance == 0 && r1 == r2)
         cout << -1<<"\n";
      //원이 한점에서 만날때
      else if (distance == r1 + r2 || distance + (r1 > r2 ? r2 : r1) == (r1 > r2 ? r1 : r2))
         cout << 1<<"\n";
      //원이 아예 안만날때
      else if (distance > r1 + r2 || distance + (r1 > r2 ? r2 : r1) < (r1 > r2 ? r1 : r2))
         cout << 0<<"\n";
      //원이 2점에서 만날때
      else
         cout << 2<<"\n";
   }
}

최종코드입니다.

[C++] 올바른 괄호 (Lv.2)

게임 개발자(진) — Mon, 5 Sep 2022 12:46:15 +0900

문제

풀이

고려해야할 핵심 내용은 다음과 같습니다.

자신의 작업이 완료되었을때 자기 앞의 모든 일이 완료되어야만 배포 가능하다.( 아니면 대기 )

저는 이를 다음과 같은 매커니즘으로 풀었습니다.

각 progresses에 for문을 사용해서 해당하는 speeds를 더해줍니다. (for문을 한바퀴 다 돌때마다 day가 하루씩 지난다는 생각)
만약 progresses의 어떤 작업이 100이상이 되었다면 작업이 끝났다는 것인데 이때 해당 작업의 위치의 인덱스가 0일때만 해당 날짜에 배포된 처리를 해줍니다. = 벡터에서 erase해줍니다.
for문을 한번 다 돌았을때 배포된 작업의 갯수가 0이 아니라면 aws벡터(reuturn 예정인 벡터)에 push_back해줍니다.
만약 배포된 작업의 갯수가 총 작업의 갯수와 같아진다면 반복문을 종료하고 return해줍니다.

코드로 구현하면 다음과 같습니다.

#include <string>
#include <vector>

using namespace std;

vector<int> solution(vector<int> progresses, vector<int> speeds) {
    int complete=0; //완료된 작업의 갯수
    int progresses_num=progresses.size();
    vector<int> aws;
    while(complete!=progresses_num) //작업이 모두 완료 될때까지 while문 실행
    {
        int limit=progresses.size();
        int temp=0; //해당 날짜에 배포된 작업의 갯수
        for(int i=0; i<limit; i++)
        {
            progresses[i]=progresses[i]+speeds[i];
            if(progresses[i]>=100 && i==0) //해당 작업이 완료되었고 앞에 작업이 꿑나서 erase된 상태라면
            {
                temp++;
                progresses.erase(progresses.begin()+i);
                speeds.erase(speeds.begin()+i);
                i--; //벡터에서 erase해줬으므로 i--를 해주고 그 다음에 i++하게됨으로 정상작동
                limit--; 
                complete++;
            }
        }
        if(temp!=0) //1개 이상 배포된 날일때만 push_back해줌
            aws.push_back(temp);
    }
    return aws;
}

[C++] 소숫점 고정해서 출력하기

게임 개발자(진) — Mon, 5 Sep 2022 00:10:31 +0900

소숫점 고정

cout<<fixed; 
cout.setf(ios::fixed);

위 두 코드 둘 중에 아무거나 써도 됩니다.

보통 윗 방법으로 많이 쓰는 것 같습니다.

그리고 위 코드를 치는 순간 기본적으로 소숫점 6자리까지 출력이 됩니다. (소숫점 7자리에서 반올림함)

ex)

#include<iostream>
using namespace std;

int main()
{
   double r=1.123456789;
   cout<<fixed;
   cout<<r;
}

//출력 결과: 1.123457

소숫점 자릿수 설정

cout.precision(7); //소숫점 7자리까지 표현. (소숫점 8자리에서 반올림함)

소숫점 고정 해제

cout.unsetf(ios::fixed);