Game Development

LeetCode 4번 Median of Two Sorted Arrays

Dev Owen — Sat, 23 Sep 2023 16:40:59 +0900

문제 링크

Example 1:

Input: nums1 = [1,3], nums2 = [2]
Output: 2.00000
Explanation: merged array = [1,2,3] and median is 2.

Example 2:

Input: nums1 = [1,2], nums2 = [3,4]
Output: 2.50000
Explanation: merged array = [1,2,3,4] and median is (2 + 3) / 2 = 2.5.

풀이

두 배열을 하나의 배열로 합친 후 해당 배열에서 가장 중간 값을 찾아주면 됩니다.

여기서 배열의 크기가 짝수일 경우에는 중간의 2개 값을 더하고 절반의 값을 출력해주면 됩니다.

class Solution {
public:
    double findMedianSortedArrays(vector<int>& nums1, vector<int>& nums2) 
    {
        nums1.insert(nums1.end(), nums2.begin(), nums2.end());
        sort(nums1.begin(), nums1.end());
        
        int arraySize = nums1.size();
        int hlafSize = arraySize / 2;

        double res = nums1[hlafSize];

        if (arraySize % 2 == 0)
        {
            res += nums1[hlafSize - 1];
            res /= 2;
        }

        return res;
    }
};

Time Submitted	Status	RunTime	Memory
07/25/2021 19:21	Accepted	19ms	89.91MB

C# Generic Enum Type을 효율적으로 Int로 변환시켜보자

Dev Owen — Wed, 5 Oct 2022 02:28:25 +0900

해당 글은 https://www.slideshare.net/devcatpublications/enum-boxing-enum-ndc2019 의 내용을 바탕으로 제작되었습니다.

자세한 설명은 해당 링크를 통해서 확인하시면 됩니다!

이무림, Enum의 Boxing을 어찌할꼬? 편리하고 성능좋게 Enum 사용하기, NDC2019

Nexon Korea 이무림 편리하고 성능좋게 Enum 사용하기 Enum의 Boxing을 어찌할꼬?

www.slideshare.net

Enum Type 을 Generic으로 받아 Int로 변환하는 경우 Boxing이 일어나게된다.

public static int Enum32ToInt<T>(T e) where T : Enum
{
	return (int)(object)e;
}

우리는 Boxing이 일어나게 되면 게임 성능에 좋지 못하다는걸 알 수 있다.

그럼 어떻게 해야 Boxing이 일어나지 않고 간단하게 처리할 수 있을까?

가장 간단한 방법인 포인터를 이용하는 방법을 알아보도록 하자

일단 기본적으로 Enum은의 value 는 int이라는 점을 기억하자

UnSafe Pointer를 사용해보자

UnSAfe Pointer란 c# 에서 Pointer를 사용할 수 있게 하는 것 이다.

C++에서 Pointer를 배운사람이라면 아래의 코드를 이해하기 쉬울 것이다.

public static class EnumConvertUtils
{
    private struct Shell<T> where T : Enum
    {
        public int IntValue;
        public T Enum;
    }

    public static int Enum32ToInt<T>(T e) where T : Enum
    {
        Shell<T> s;
        s.Enum = e;

        unsafe
        {
            int* pi = &s.IntValue;
            pi += 1;
            return *pi;
        }
    }

    public static T IntToEnums32<T>(int value) where T : Enum
    {
        var s = new Shell<T>();

        unsafe
        {
            int* pi = &s.IntValue;
            pi += 1;
            *pi = value;
        }

        return s.Enum;
    }

LeetCode 6번 ZigZag Conversion

Dev Owen — Wed, 4 Aug 2021 00:00:13 +0900

문제 링크

ZigZag Conversion - LeetCode

Level up your coding skills and quickly land a job. This is the best place to expand your knowledge and get prepared for your next interview.

leetcode.com

문제

The string "PAYPALISHIRING" is written in a zigzag pattern on a given number of rows like this: (you may want to display this pattern in a fixed font for better legibility)

P   A   H   N
A P L S I I G
Y   I   R

And then read line by line: "PAHNAPLSIIGYIR"

Write the code that will take a string and make this conversion given a number of rows:

string convert(string s, int numRows);

Example 1:

Input: s = "PAYPALISHIRING", numRows = 3
Output: "PAHNAPLSIIGYIR"

Example 2:

Input: s = "PAYPALISHIRING", numRows = 4
Output: "PINALSIGYAHRPI"
Explanation:
P     I    N
A   L S  I G
Y A   H R
P     I

Example 3:

Input: s = "A", numRows = 1
Output: "A"

풀이

해당 문제는 주여진 문자열을 지그재리로 배열한 후 출력하시면 됩니다.

Input: s = "ac"
Output: "a"

class Solution {
public:
	string convert(string s, int numRows)
	{
		vector<string> zigzag(numRows);
		string answer = "";
		bool isDown = true;
		for (int i = 0, j = 0; i < s.size(); i++)
		{
			zigzag[j] += s[i];
			
			if (numRows > 1)
			{
				if (i != 0 && i % (numRows - 1) == 0)
				{
					isDown = !isDown;
				}

				j += (isDown == true ? 1 : -1);
			}
		}

		for (int i = 0; i < numRows; i++)
		{
			answer += zigzag[i];
		}
		return answer;
	}
};

Time Submitted	Status	RunTime	Memory
08/03/2021 23:14	Accepted	4 ms	10.8 MB

시간 복잡도 : O(N^2)

LeetCode 5번 Longest Palindromic Substring

Dev Owen — Sun, 25 Jul 2021 22:28:54 +0900

문제 링크

Longest Palindromic Substring - LeetCode

Level up your coding skills and quickly land a job. This is the best place to expand your knowledge and get prepared for your next interview.

leetcode.com

문제

Example 1:

Input: s = "babad"
Output: "bab"
Note: "aba" is also a valid answer.

Example 2:

Input: s = "cbbd"
Output: "bb"

Example 3:

Input: s = "a"
Output: "a"

Example 4:

Input: s = "ac"
Output: "a"

풀이

이 문제는 주어진 문자열에서 가장 긴 팰린드롭을 구하면 되는 문제입니다.

class Solution {
private:

	string answer;
public:
	void Palindrome(int _left, int _right, string& _s)
	{
		//cout << _left << " " << _right << endl;
		while (true)
		{
			if (_left < 0 || _right >= _s.size())
			{
				break;
			}
			else if (_s[_left] != _s[_right])
			{
				break;
			}
			else
			{
				--_left;
				++_right;
			}
		}
		
		int len = _right - _left - 1;

		if (answer.size() < len)
		{
			answer = _s.substr(_left + 1, len);
		}
	}

	string longestPalindrome(string s)
	{
		for (int i = 0; i < s.size(); i++)
		{
			Palindrome(i - 1, i + 1, s);
			Palindrome(i, i + 1, s);	// abba 같은 경우
		}
		return answer;
	}
};

Time Submitted	Status	RunTime	Memory
07/25/2021 22:22	Accepted	28 ms	14.4 MB

시간 복잡도 : O(N^2)

LeetCode 3번 Longest Substring Without Repeating Characters

Dev Owen — Sun, 25 Jul 2021 19:30:59 +0900

문제 링크

Longest Substring Without Repeating Characters - LeetCode

Level up your coding skills and quickly land a job. This is the best place to expand your knowledge and get prepared for your next interview.

leetcode.com

문제

Example 1:

Input: s = "abcabcbb"
Output: 3
Explanation: The answer is "abc", with the length of 3.

Example 2:

Input: s = "bbbbb"
Output: 1
Explanation: The answer is "b", with the length of 1.
Example 3:

Example 3:

Input: s = "pwwkew"
Output: 3
Explanation: The answer is "wke", with the length of 3.
Notice that the answer must be a substring, "pwke" is a subsequence and not a substring.

풀이

이 문제는 주어진 문자열에서 문자를 중복하여 사용하지 않고 가장 긴 문자열의 길이를 리턴하는 문제입니다.

class Solution {
public:
	int lengthOfLongestSubstring(string s)
	{
		map<char, int> dict;
		int maxLen = 0, begin = 0;
		char key;

		for (int i = 0; i < s.size(); i++)
		{
			key = s[i];

			// 현재 노드 안에 있고, 시작 지점이 현재 중복되는 노드보다 앞에 있을 경우
			if (dict.find(key) != dict.end() && dict[key] >= begin)
			{
				maxLen = max(maxLen, i - begin);
				begin = dict[key] + 1;
			}

			dict[key] = i;
		}
		return max(maxLen, (int)s.size() - begin);
	}
};

Time Submitted	Status	RunTime	Memory
07/25/2021 19:21	Accepted	16 ms	8.5 MB

시간 복잡도 : O(N)

LeetCode 2번 Add Two Numbers

Dev Owen — Sun, 25 Jul 2021 17:21:03 +0900

문제 링크

Add Two Numbers - LeetCode

Level up your coding skills and quickly land a job. This is the best place to expand your knowledge and get prepared for your next interview.

leetcode.com

문제

Example 1:

Input: l1 = [2,4,3], l2 = [5,6,4]
Output: [7,0,8]
Explanation: 342 + 465 = 807.

Example 2:

Input: l1 = [0], l2 = [0]
Output: [0]

Example 3:

Input: l1 = [9,9,9,9,9,9,9], l2 = [9,9,9,9]
Output: [8,9,9,9,0,0,0,1]

풀이

이 문제는 주어진 단일 연결 리스트에 값들을 더하고 올림이 발생할 경우 다음 위치에 노드에 1을 더해줘야 합니다.

class Solution {
public:
	ListNode* addTwoNumbers(ListNode* l1, ListNode* l2)
	{
		ListNode* answer = new ListNode();
		ListNode* answerBegin = answer;

		answerBegin = answer;
		int val;
		while (l1 != nullptr || l2 != nullptr)
		{
			val = 0;
			if (l1 != nullptr)
			{
				val += l1->val;
				l1 = l1->next;
			}
			if (l2 != nullptr)
			{
				val += l2->val;
				l2 = l2->next;
			}

			val += answer->val;
			answer->val = val % 10;

			if (l1 != nullptr || l2 != nullptr || val >= 10)
			{
				answer->next = new ListNode(val / 10);
				answer = answer->next;
			}
		}
		return answerBegin;
	}
};

Time Submitted	Status	RunTime	Memory
07/25/2021 15:05	Accepted	16 ms	71.3 MB

시간 복잡도 : O(N)

ㅁ

LeetCode 1번 Two Sum

Dev Owen — Sun, 25 Jul 2021 14:32:44 +0900

문제 링크

Two Sum - LeetCode

Level up your coding skills and quickly land a job. This is the best place to expand your knowledge and get prepared for your next interview.

leetcode.com

문제

Given an array of integers nums and an integer target, return indices of the two numbers such that they add up to target.

You may assume that each input would have exactly one solution, and you may not use the same element twice.

You can return the answer in any order.

Example 1:

Input: nums = [2,7,11,15], target = 9
Output: [0,1]
Output: Because nums[0] + nums[1] == 9, we return [0, 1].

Example 2:

Input: nums = [3,2,4], target = 6 
Output: [1,2]

Example 3:

Input: nums = [3,3], target = 6 
Output: [0,1]

풀이

이 문제는 주어진 배열에서 두 개의 원소를 더하여 Target이 되는 값을 찾으면 되는 문제입니다.

해당 문제의 풀이 과정은 크게 2가지로 되어 있습니다.

1. 브루트 포스 ( 느림 )

class Solution
{
public:
    vector<int> twoSum(vector<int>& nums, int target)
    {

        for (int i = 0; i < nums.size(); i++)
        {
            for ( int j = i + 1; j < nums.size(); j++ )
            {
                if ( nums[i] + nums[j] == target )
                {
                    return {i, j};
                }
            }
        }
        return {};
    }
};

Time Submitted	Status	RunTime	Memory
07/25/2021 14:25	Accepted	312 ms	10.1 MB

시간 복잡도 : O(N^2)

2. 해시를 이용 ( 빠름 )

class Solution
{
public:
    vector<int> twoSum(vector<int>& nums, int target)
    {
        map<int, int> dict;

        for (int i = 0; i < nums.size(); i++)
        {
            if (dict.find(target - nums[i]) == dict.end())
            {
                dict[nums[i]] = i;
            }
            else
            {
                return { i, dict[target - nums[i]] };
            }
        }
        return {};
    }
};

Time Submitted	Status	RunTime	Memory
07/25/2021 14:25	Accepted	8ms	10.1ms

시간 복잡도 : O(N)

Jump Point Search 알고리즘 ( C# 소스코드 )

Dev Owen — Sun, 18 Jul 2021 18:28:43 +0900

Jump Point Search(JPS)를 이용하여 최단 거리를 찾아 봅시다.

실제로 큰 맵을 가진 게임에서 사용되는 JPS 알고리즘에 대해서 알아보도록 하겠습니다.

[ 참고 ]

해당 포스팅에는 JPS 알고리즘을 C#으로 구현한것이 제공됩니다.

JPS알고리즘 말고, JSP(b) 알고리즘, JPS(+) 알고리즘에 대해서도 조금이나마 내용이 나옵니다.

JPS 알고리즘 이란

A* 알고리즘을 기반으로 한 알고리즘 중 하나인 JPS 알고리즘 입니다.

JPS 알고리즘은 A*의 문제점인 갈 수 있는 노드들의 휴리스틱 값을 구한후 리스트에 넣어 연산하는 과정에 많은 오버헤드가 발생하여 속도가 느린 것을 보안한 알고리즘입니다.

이름 그대로 Jump Point Search 즉 내가 어디로 점프 해야할 지를 구하여 해당 노드에서만 연산한다는 점으로 A* 알고리즘의 문제점을 해결할 수 있게 되었습니다.

Jump Point를 생성하는 규칙은 코너의 여부입니다.

코너의 규칙은 2가지로 직직할 떄와, 대각선으로 이동할때로 나뉩니다.

1. 직진 일때 코너를 구하는 방식 ( Ex 오른쪽 방향 )

1. 현재 방향으로 쭉 직진합니다.

2. 현재 위치에서 아래가 막혀있고 오른쪽 아래가 막혀있지 않은 경우.

3. 현재 위치에서 위가 막혀있고 오른쪽 위가 막혀있지 않은 경우.

2. 대각선 일때 코너를 구하는 방식 (Ex 오른쪽 위)

1. 현재 방향으로 쭉 직진합니다.

2. 현재 위치에서 아래가 막혀있고 오른쪽 아래가 막혀있지 않은 경우.

3. 현재 위치에서 왼쪽이 막혀있고 왼쪽 위가 막혀있지 않은 경우.

4. 현재 위치에서 오른쪽 방향과 위쪽 방향을 1번 규칙으로 검사 후 코너가 나왔을 경우 해당 위치에 코너를 생성하지 않고 해당 작업을 진행한 위치에서 노드를 생성.

해당 규칙의 말을 그림으로 설명하자면 아래의 그림입니다. 각 각 대각선을 이동하면서 오른쪽과 위쪽으로 검사를 한번씩 더 해줍니다. 그리고 노드를 발견할 시 해당 노드에서 생성이 아닌 부모노드에서 생성합니다.

휴리스틱은 무엇을 사용했을까?

JPS에서 사용하는 휴리스틱은 A*에서 사용된 휴리스틱과 동일합니다.

private int Heuristic(Vector2Int _currPosition, Vector2Int _endPosition)
{
    int x = Mathf.Abs(_currPosition.x - _endPosition.x);
    int y = Mathf.Abs(_currPosition.y - _endPosition.y);
    int reming = Mathf.Abs(x - y);

    return MOVE_DIAGONAL_COST * Mathf.Min(x, y) + MOVE_STRAIGHT_COST * reming;
}

전체적인 소스코드

소스코드의 길이가 1000줄이 넘어 깃 허브를 통하여 A*와 JPS가 구현되어있는 프로젝트를 올리도록 하겠습니다.

Dev-Owen-Git/Unity_AStar_JPS_Algorithm

Contribute to Dev-Owen-Git/Unity_AStar_JPS_Algorithm development by creating an account on GitHub.

github.com

A* 알고리즘

Dev Owen — Thu, 15 Jul 2021 23:18:47 +0900

**A*를 이용하여 길을 찾아 보자**

게임에서 사용되되는 알고리즘 중 기초적인 알고리즘 중 하나인 A*를 알아보도록 하겠습니다.

A* 작동하는 법

[ 참고 ]

이번 포스팅에서는 A*를 구현하는 방식에 대해서 알려드립니다.

전체적인 소스코드는 따로 주어지지 않습니다. 직접 스크립트를 작성해보며 실력을 기르시기 바랍니다.

**A* 알고리즘 이란**

그래서 A*가 어떤 알고리즘 이냐면 현재의 위치에서 목적지 까지의 최단 경로를 구하는 알고리즘 입니다.

A*에서는 크게 3가지로 구성 되어 있다고 보시면 됩니다.

1. 현재 노드까지 오는데 필요했던 비용 ( g Cost )

2. 현재 노드에서 목적지 까지 가는데 필요한 비용 ( h Cost )

3. 현재 노드에까지 온 비용과 목적지 까지 비용을 합친 비용 ( f Cost )

위에 있는 3가지의 비용을 알아보기 위해서는 A* 알고리즘에서 제일 중요한 역할을 하는 함수 중 하나인 휴리스틱( Heuristic )을 이용해 보도록 하겠습니다.

휴리스틱이란?

휴리스틱이란 어려운것이 아닙니다. 간단하게 설명을 해보자면 현재 위치에서 목적지까지 가는데 걸리는 비용을 예측하는 함수라고 생각하시면 됩니다.

함수와 함께 휴리스틱의 값을 구하는 방법을 알아 보도록 하겠습니다.

const int MOVE_STRAIGHT_COST = 10;
const int MOVE_DIAGONAL_COST = 14;

public int Heuristics(Vector2Int _currPosition, Vector2Int _endPosition)
{
    int xDistance = Mathf.Abs(_currPosition.x - endPosition.x);
    int yDistnace = Mathf.Abs(_currPosition.y - _endPosition.y);
    int reming = Mathf.Abs(xDistance - yDistnace);
    return MOVE_DIAGONAL_COST * Mathf.Min(xDistance, yDistnace) + MOVE_STRAIGHT_COST * reming;
}

직선 거리의 값은 10, 대각선의 거리의 값은 14입니다. 이유는 피타고라스 법칙 때문에 대각선은 √2 이기 때문에 14가 되게 됩니다.

이값과 거리를 통하여 최단거리의 비용을 예측해보도록 하겠습니다.

1. x, y 중 가장 짧은 값은 대각선으로 이동하는 거리가 됩니다.

2. x. y 의 값을 뺀 후 나온값의 절대값은 직선으로 이동해야하는 거리가 되게 됩니다.

직접 계산해 보시면 알 수 있습니다.

**그래서 A*는 어떻게 만드는 건가요?**

기본적인 내용은 알아보았으니 A*를 직접 구해보도록 합시다.

A*는 전체적으로 아래의 일을 반복합니다.

1. 현재 지점에서 갈 수 있는 모든 노드들의 휴리스틱 값을 구한 후 리스트에 넣어줍니다.

2. 리스트에 들어간 값중 fCost가 가장 작은 노드를 꺼내 해당 노드에서 갈 수 있는 모든 노드를 리스트에 넣습니다.

아래의 코드는 위에 2가지를 반복하는 코드입니다.

while (nextPaths.Count > 0)
{
    PathNode currentNode = GetLowestFCostNode(nextPaths);
    currentNode.obj.GetComponent<Image>().color = Color.green;

    if (currentNode == endNode)
    {
        lastNode = currentNode;
        FindPath(lastNode);
        yield break;
    }

    AddClosePath(currentNode.position);
    nextPaths.Remove(currentNode);

    neighbours = GetNeighbourList(currentNode);

    for (int i = 0; i < neighbours.Count; i++)
    {
        neighbour = neighbours[i];
        if (GetClosePath(neighbour.position) == true) continue;
        int nextGCost = currentNode.gCost + Heuristics(currentNode.position, neighbour.position);
        if (nextGCost < neighbour.gCost)
        {

            neighbour.prevNode = currentNode;
            neighbour.gCost = nextGCost;
            neighbour.hCost = Heuristics(neighbour.position, endPosition);

            if (nextPaths.Contains(neighbour) == false)
            {
                nextPaths.Add(neighbour);
            }
        }
    }
}

**A*의 단점**

많은 사람들이 사용하는 A*에도 단점이 존재합니다. 그건은 바로 넓은 맵을 탐사할 경우 시간이 오래 걸린다는 것입니다.

그 이유는 각각의 노드의 휴리스틱의 값을 구해야 하고, 그 값을 큐나 리스트에 넣은 뒤 다시 fCost가 제일 작은 값을 꺼내 탐색을 해야하기 때문입니다.

이러한 단점을 보안한 알고리즘인 JPS 알고리즘은 다음 포스팅을 통해 글을 작성하도록 하겠습니다.

간단하게 JPS에 대해 알려드리자면 갈 수 있는 모든 노드를 리스트에 넣는 것이 아닌 현재 노드에서 갈 수 있는

특정 포인트를 찾아 해당 포인트만 리스트에 넣는 알고리즘 입니다.

JPS 알고리즘 알아보러 가기

Jump Point Search 알고리즘 ( C# 소스코드 )

Jump Point Search(JPS)를 이용하여 최단 거리를 찾아 봅시다. 실제로 큰 맵을 가진 게임에서 사용되는 JPS 알고리즘에 대해서 알아보도록 하겠습니다. [ 참고 ] 해당 포스팅에는 JPS 알고리즘을 C#으로

game-dev.tistory.com

Unity Ml Agent Ray Perception Sensor를 이용해 보자

Dev Owen — Fri, 2 Jul 2021 02:28:22 +0900

유니티 ML Agent에 Ray Perception Sensor를 이용해 보자

현재 ML Agent에서 제공해주는 Ray Perception Sensor를 이용하여 인공지능을 학습시켜 보도록 하겠습니다.

[ 관련 자료 ]

ML Agent가 처음이신 분들은 저의 포스팅 중 기본 강의를 보고 오시기 바랍니다 [ 바로 가기 ]

해당 ML-Agent 버전은 2.1.0-exp-1을 사용하고 있습니다.

[ Sensor를 사용하자 ]

저희는 이떄까지 인공지능이 학습을 하기 위해 필요한 정보값을 넘겨주기 위해 아래와 같은 함수를 사용했습니다.

public override void CollectObservations(VectorSensor sensor) { }

위의 함수를 통하여 각각의 정보를 보내며 인공지능이 학습을 하는데 있어 필요한 정보들을 계속 보내주었습니다.

하지만 Sensor를 사용하면 인공지능이 직접 판단하며 정보를 가지게 됩니다.

간단한 인공지능에 센서를 달아 직접 움직이게 해보도록 하겠습니다.

해당 컨퍼넌트를 추가 시켜줍니다. 그리고 Ray에 인식시킬 Tag를 넣어주시기만 하면 됩니다.

나머지는 스크립트에서 보도록 하겠습니다.

아래의 스크립트는 간단한 스크립트 입니다. 값으로 이동 시키고 가장 최단거리로 이동시킬 수 있게 움직일떄 마다 값을 Reward를 - 해줬습니다.

public override void OnActionReceived(ActionBuffers actions)
{
    Vector3 velocity = new Vector3( actions.ContinuousActions[0], 0, actions.ContinuousActions[1]);
    rb.AddForce( velocity, ForceMode.VelocityChange );

    SetReward(-1 / MaxStep);
}

그리고 적에게 부딧힐 경우 점수 1점을 주게하였습니다.

private void OnCollisionEnter(Collision other) 
{
    if ( other.gameObject.CompareTag("Enemy") ) 
    {
        SetReward( +1 );
        EndEpisode();
    }
}

아래는 전체 소스코드 입니다.

using System.Collections;
using System.Collections.Generic;
using UnityEngine;
using Unity.MLAgents;
using Unity.MLAgents.Sensors;
using Unity.MLAgents.Actuators;
public class BlueAgnet : Agent
{
    [ SerializeField ] Rigidbody rb;
    [SerializeField] Transform target;

    public override void OnEpisodeBegin()
    {
        transform.localPosition = new Vector3(0, 1, 0);
        target.localPosition = new Vector3( Random.Range(-6, 6) , 1, Random.Range(-6, 6));

        rb.velocity = Vector3.zero;
    }


public override void OnActionReceived(ActionBuffers actions)
{
    Vector3 velocity = new Vector3( actions.ContinuousActions[0], 0, actions.ContinuousActions[1]);
    rb.AddForce( velocity, ForceMode.VelocityChange );

    SetReward(-1 / MaxStep);
}

private void OnCollisionEnter(Collision other) 
{
    if ( other.gameObject.CompareTag("Enemy") ) 
    {
        SetReward( +1 );
        EndEpisode();
    }
}
}

해당 스크립트를 넣어주고 학습을 한 결과 아래와 같은 결과물이 나오게 되었습니다.

결론

Sensor라는 컨퍼넌트에 대해서 알게 되었기에 이제 이것을 으용해서 새로운 인공지능을 한 번 만들어 봐야 할 거 같습니다. 간단한것은 Sensor로 어느정도 다 처리가 되기 떄문에 유용하게 사용할 수 있을꺼 같습니다.