고양멍멍이

이 게시글은 Bloomberg의 기사를 대충 번역한 것으로, 어색한 부분 / 오역이 있을 수 있습니다.

원제목 : Blockchain in Gaming Is all the Rage for No Good Reason

원작성자 : Jason Schreier

투자자를 위한 떡밥

비디오 게임 산업은 트렌드를 쫒는데 집착하고 있습니다. PUBG와 포트나이트의 성공에 따라온 배틀 로열이 있었고, 그 이전에는 포켓몬 Go, 리그 오브 레전드 등등이 있어왔습니다.

보통 이러한 트렌드 따라가기는 말이 됩니다 : 어떤 게임이 돈을 펑펑 벌고 있으니, 모두가 그걸 따라가려고 하는 것이죠. 하지만 현재 화두인 블록체인은, 별다른 성과 없이 엄청난 기대와 돈을 끌어들이고 있습니다. 크립토-전도사들이 주장하는 컨셉 대다수가 비디오 게임에서는 수 년 전부터 가능했기 때문입니다.

사용자가 가상 데이터의 소유권을 증명할 수 있는 분산 데이터베이스인 블록체인은, 금융이나 예술과 같은 많은 분야에서 사용되어 왔습니다. 하지만 게임 업계에서는 성공을 거두지 못했는데, 이는 시도가 부족했기 때문은 아닙니다.

지난 3년 동안, 어떠한 방식이 되었건 블록체인을 사용하겠다 약속한 게임 회사들은 수천, 수억 달러의 투자를 받았습니다. 특히 NFT(대체 불가능한 토큰)이라는 단어와 짝을 이룬 분산 데이터베이스만큼 VC(벤처 캐피털)의 욕구를 자극하는 것은 없었습니다. 2021년 시점에서 자신만의 NFT 전략을 수립하고 발표하지 않는 것은 경제적 대가를 가져올 수 있습니다.

그래서 이번 달 대형 게임 퍼블리셔들의 분기별 수익 보고 자리에서, 많은 퍼블리셔들이 주주들에게 자신들은 시대의 흐름에 뒤쳐지고 있지 않다는 것을 알리려 했습니다. 일렉트로닉 아츠(EA) CEO Ansrew Wilson은 NFT에 대해 "미래 게이밍의 중요한 부분"이라고 했지만, "그것이 어떻게 작동할지 알아내기에는 아직 이르다"라고 덧붙였습니다.

유비소프트의 CEO Yves Guillemot는 블록체인을 "혁명"이라고 했으며 그의 회사가 해당 분야의 핵심이 되길 원한다고 했습니다. 스퀘어 에닉스도, 테이크 투 인터랙티브도 비슷한 발언을 했습니다.

하지만 이런 뉴스메이커들은 하나같이 블록체인이 어떤 혁명을 가져올 것인지 설명하기 어려워했습니다. NFT 옹호자들은 플레이어가 의상, 무기와 같은 고유 아이템을 구입하고, 그 아이템들을 퍼블리셔에 관계없이 게임에서 게임으로 이동 가능한 세상이 열릴 것이라 얘기합니다. (블록체인은 아이템의 소유권을 증명하는데 사용됩니다.)

하지만 블록체인에서 내가 소유하는 것은 일련의 연속된 숫자와 문자 뿐입니다 : 이것을 식별하고 디지털 개체로 변환하는 것은 각 게임들에 달려있습니다. 이것은 여러 의문점을 불러옵니다. 만일 내가 MS의 헤일로에서 멋진 새 헬멧을 구입했다면, 그리고 그 헬멧을 언차티드로 가져오기를 원한다면, 왜 소니에서 이 작업을 지원해야 할까요? 다른 게임의 헬멧이 지원되도록 개발자들이 시간과 예산을 사용할 이유가 무엇이며, 누가 이 과정에서 이득을 얻게 될까요?

이런 비전은 오직 한 가지 시나리오에서만 실용적입니다 : 하나의 회사가 여러 게임을 만들고, 플레이어가 전체 생태계에서 아이템을 옮길수 있도록 허락해주는 경우.

예를 들어, 유비소프트는 어새신크리드에서 구입한 코스튬을 와치독스로 가져올 수 있습니다. 하지만 이 방법은 세이브 파일과 계정 시스템 하에서 이미 수년 전부터 가능했던 일입니다. 매스 이펙트에서 캐릭터의 선택이 타이틀을 건너뛰어 영향을 주는 것은 이 방식으로 구축되었습니다.

게임 회사들이 블록체인에 투자하는 것은 지금 당장 실용적인 기술이기 때문이 아니라, 언젠가 멋진 기술이 될 것으로 들리기 때문입니다. 예를 들어, Zynga는 블록체인 게이밍 부사장을 고용했다고 이번 주 발표했습니다. 인터뷰에서 Zynga CEO Frank Gibeau는 자기도 아직 해당 직위가 정확히 뭘 의미하는지 모르겠다고 했습니다.

"장기적으로는 산업 구조의 일부라고 생각하지만, 단기적으로는 그저 밈이 될 수 있다고 생각합니다. 하지만 기본 펀더멘털이 긍정적이라 생각하기 때문에 괜찮습니다"

Gibeau는 플레이어가 아이템에 투자하고 소유하는 것에 "심오한 무엇인가가 있다"며 이 컨셉이 새로운 멋진 게임을 이끌어낼 잠재력이 있다고 생각한다 말했습니다. 하지만 그는 어떻게, 왜, 언제 그렇게 될지는 말하지 못했습니다. 그저 "우리가 개발해 나감에 따라, 흐름의 일부가 될 것이라는 것은 확신합니다"라고 말했습니다.

이런 발언은 블록체인에 대해 설교하는 임원들로부터 자주 들을 수 있습니다. 이는 존재하지 않는 문제에 대한 해결책이고, 수리가 필요 없는 물건을 위한 도구입니다. 냉소주의자들은 대부분의 게임 퍼블리셔는 단지 분석가들과 투자자들에게 숨을 헐떡이는 공룡으로 비치지 않기 위해 블록체인을 밀고 있을 뿐이라고 말할 것입니다.

만약에 블록체인 게이밍이 정말 시작된다면, 누가 이익을 얻게 될까요? 2018년에 나와 필리핀에서 특히 인기를 끌고 있는 Axie Infinity의 예를 보겠습니다. 게임의 메카닉은 복잡하지만, 간단하게 말하자면 플레이어는 고유한 몬스터들을 구입할 수 있으며, 이를 기르고 다른 플레이어에게 팔아 이득을 취할 수 있습니다.

함정은 게임을 시작하는 데에도 돈을 지불해야 한다는 것입니다. (현재 약 $1500) "scholars"라 불리는 많은 플레이어들은 입장료를 지불하지 못해 부유한 플레이어들에게 의존하고 있으며, 그들에게 수익의 많은 부분을 지불하고 있습니다.

다른 경제처럼, Axie Infinity에도 판매자와 구매자가 있습니다. 판매자보다 구매자가 많은 동안, 이런 "play-to-earn" 구조는 계속 굴러갈 수 있습니다. 하지만 신규 플레이어가 더이상 들어오지 않으면 어떻게 될까요? 사람들이 팔리지 않은 캐릭터로 가득한 PC를 구입해서 차고 안에 전시해둘까요?

현재 게이밍에서, 블록체인은 혼란스럽고 근시안적입니다. 이는 잠재적인 환경적 파괴나 각 거래에 따른 비용 문제를 고려하기 전임에도 그렇습니다. 아마 게임사 경영진들은 투자자들에게 그저 그들이 듣고 싶은 말을 해주고 있을 뿐일지도 모르지만, 지금까지 봐온 수많은 게이밍 유행들과는 달리 이것은 실제로 사람들을 해칠 수 있습니다.

[관련 기사]

Xbox chief Phil Spencer가 NFT 게이밍이 착취적으로 느껴진다 표현 (링크)

Steam에서 NFT와 블록체인에 기반한 모든 게임 금지 (링크)

[문제링크]

0. 수학, 기하학 문제

1. P1, P2, P3를 이은 선이 시계방향인지 아닌지 알려면 P1-P2, P1-P3선의 기울기를 비교하면 된다

• 위 그림과 같이, 1-2-3처럼 반시계방향일때는 1-2보다 1-3의 기울기가 크고,
• 반대로 1-2-3'처럼 시계방향일때는 1-2보다 1-3이 작다

2. 두 점으로부터 기울기는 간단하게 (y2-y1)/ (x2-x1) 로 얻을 수 있다

• 하지만 나누기 연산으로 정확도 문제가 발생하게 된다

3. 필요한것은 두 기울기의 비교이지 정확한 값이 아니므로, 양 측에 (x2-x1) * (x3-x1)을 곱해줘서 정수로 비교한다

• (y2-y1) / (x2-x1) ○ (y3-y1) / (x3-x1) 에서
• (y2-y1) * (x3-x1) ○ (y3-y1) * (x2-x1) 으로

import java.io.BufferedReader;
import java.io.InputStreamReader;
import java.util.StringTokenizer;

public class Main{
	public static void main(String[] args)throws Exception {
		BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
		
		StringTokenizer st = new StringTokenizer(br.readLine());
		int x1 = pint(st.nextToken());
		int y1 = pint(st.nextToken());
		
		st = new StringTokenizer(br.readLine());
		int x2 = pint(st.nextToken());
		int y2 = pint(st.nextToken());
		
		st = new StringTokenizer(br.readLine());
		int x3 = pint(st.nextToken());
		int y3 = pint(st.nextToken());
		
		int line1 = (y3-y1)*(x2-x1); // 1-3
		int line2 = (y2-y1)*(x3-x1); // 1-2
		if(line1 == line2)System.out.println(0);
		else if(line1 > line2)System.out.println(1);
		else System.out.println(-1);
	}
	
	static int pint(String s) {
		return Integer.parseInt(s);
	}
}

[문제링크]

0. 두 포인터 문제

1. 두 포인터 사용을 위해 전체 입력값을 정렬해준다

• Arrays.sort는 최악 N제곱으로 나오는 함수이므로, Collections.sort를 이용했다

2. 양 끝 값을 초기 포인터로, 두 값의 차이를 초기 합(min)로 지정한다

3. 현재 포인터가 가리키는 용액의 합이 현재 min보다 작다면, 새로운 min으로 지정하고 포인터를 저장한다

4. 현재 포인터 용액의 합이 양수라면 + 용액이 약해져야하고, 음수라면 - 용액이 약해져야한다

import java.io.BufferedReader;
import java.io.InputStreamReader;
import java.util.ArrayList;
import java.util.Collections;
import java.util.StringTokenizer;

public class Main{
	public static void main(String[] args)throws Exception {
		BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
		
		int N = pint(br.readLine());
		ArrayList<Integer> num = new ArrayList<>(N);
		StringTokenizer st = new StringTokenizer(br.readLine());
		for (int i = 0; i < N; i++) {
			num.add(pint(st.nextToken()));
		}
		
		Collections.sort(num);
		
		int fst=0, snd=N-1;
		int min = Math.abs( num.get(fst)+num.get(snd) );
		int minMinus=num.get(fst), minPlus=num.get(snd);
		
		while(fst<snd) {
			int cur = num.get(fst)+num.get(snd);
			if(Math.abs(cur)<min) {
				min = Math.abs(cur);
				minMinus=num.get(fst); minPlus=num.get(snd);
			}
			
			if(cur<0) {
				fst++;//- 용액 약화
			}
			else {
				snd--;//+ 용액 약화
			}
		}
		System.out.println(minMinus+" "+minPlus);
	}
	
	static int pint(String s) {
		return Integer.parseInt(s);
	}
}

[문제링크]

0. 아이의 위치를 최소한으로 바꾸면서 순서를 정렬하는 방법 = 이미 정렬된 가장 긴 문자열을 찾고, 그 나머지를 이동하면 된다

• 가장 긴 증가하는 부분 수열(LIS)을 구하면 된다

1. DP를 통해 이전까지 진행한 결과들 중 현재 순서보다 작으면서 그 값이 제일 큰 값을 구한다

2. 해당 값 +1이 현재 지점까지의 LIS이다

3. LIS를 마지막까지 구한 후, 가장 큰 LIS 길이를 구한다

4. 해당 LIS에 속하지 않는 아이들을 이동하면 된다. 즉, (전체 아이 수 - LIS길이) = (이동해야하는 아이 수)

import java.io.BufferedReader;
import java.io.InputStreamReader;

public class Main{
	public static void main(String[] args)throws Exception {
		BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
		
		int N = pint(br.readLine());
		int[] num = new int[N];
		int[] dp = new int[N];
		for (int i = 0; i < N; i++) {
			num[i]=pint(br.readLine());
		}
		int lis=0;
		for (int i = 0; i < N; i++) {
			int max=0;
			for (int j = 0; j < i; j++) {
				if(num[j] < num[i]  && max<dp[j])max=dp[j];
			}
			dp[i]=max+1;
			lis = Math.max(dp[i], lis);
		}
		System.out.println(N-lis);
	}
	
	static int pint(String s) {
		return Integer.parseInt(s);
	}
}

[문제링크]

0. a-b 두 노드간 최단 거리 구하기

1. 다익스트라, 벨만 포드 등 다양하게 풀이 가능하다

2. bfs로 탐색, 목표 노드가 발견되는 즉시 탈출

import java.io.BufferedReader;
import java.io.InputStreamReader;
import java.util.ArrayList;
import java.util.LinkedList;
import java.util.Queue;
import java.util.StringTokenizer;

public class Main {
	public static void main(String[] args)throws Exception {
		BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
		
		StringTokenizer st = new StringTokenizer(br.readLine(), " ");
		int a = pint(st.nextToken())-1;
		int b = pint(st.nextToken())-1;
		
		st = new StringTokenizer(br.readLine(), " ");
		int n = pint(st.nextToken());
		int m = pint(st.nextToken());
		
		ArrayList<ArrayList<Integer>> adjList = new ArrayList<>();
		for (int i = 0; i < n; i++) {
			adjList.add(new ArrayList<>());
		}
		
		for (int i = 0; i < m; i++) {
			st = new StringTokenizer(br.readLine(), " ");
			int from = pint(st.nextToken())-1;
			int to = pint(st.nextToken())-1;
			
			adjList.get(from).add(to);
			adjList.get(to).add(from);
		}
		
		int count=-1;
		boolean findAns=false;
		boolean[] isVisit = new boolean[n];
		Queue<Integer> qu = new LinkedList<Integer>();
		qu.offer(a);
		while(!qu.isEmpty()) {
			count++;
			int len = qu.size();
			for (int i = 0; i < len; i++) {
				int cur = qu.poll();
				if(cur==b) {
					findAns=true;
					break;
				}
				
				for(int next : adjList.get(cur)) {
					if(!isVisit[next]) {
						isVisit[next]=true;
						qu.offer(next);
					}
				}
			}
			if(findAns)break;
		}
		
		System.out.println(findAns?count:-1);
	}
	
	static int pint(String s) {
		return Integer.parseInt(s);
	}
}

문제상황

public class SignScript : MonoBehaviour
{
    public string text;
}

  다음과 같이 public으로 변수를 선언하면 unity 엔진에서 해당 변수의 값을 오브젝트마다 넣어줄 수 있다.

  이때 string의 경우 Enter는 입력되지 않고, \n과 같은 줄바꿈 문자를 삽입하더라도 줄바꿈이 일어나지 않는다.

  이는 입력한 \n을 \\n으로 인식해 작성한 그대로 화면에 출력하기 때문이다.

해결방법

1. Replace함수 사용

public class SignScript : MonoBehaviour
{
    public string text;
    // Start is called before the first frame update
    void Start()
    {
        text = text.Replace("\\n", "\n");
    }
}

  \\n을 \n으로 치환하면, 원래 역할인 줄바꿈을 당연히 잘 수행한다.

  하지만...

• \t, \r 등 사용하는 특수문자마다 다 replace를 해줘야 한다
• 정말로 화면에 "\n" 문자가 찍혀야 한다면 방법이 없다

  이런 문제점이 발생한다

2. TextArea 설정

public class SignScript : MonoBehaviour
{
    [TextArea]
    public string text;
}

  string 위에 [TextArea]를 선언하면, Unity의 Text입력부분이 여러줄 입력 가능한 큰 공간이 된다.

  이 공간에서는 Enter로 줄바꿈 입력이 가능하니 있는 그대로 입력해 사용할 수 있다.

※ 주의사항

  TextArea를 붙였다가 제거한 경우, 원래의 한줄 Text로 돌아오며 기존 입력의 최상위 한줄만 보이게 된다.

  하지만 실제로는 입력했던 값들이 다 그대로 남아 있으니, 제대로 삭제하지 않으면 2번째 줄부터는 그대로 유지되게 된다.

[문제링크]

0. 수학 문제

1. 위 그림과 같이n, m크기의 표에서 달팽이가 한바퀴를 이동하면, 총 4번 회전하고 시작점의 (+1, +1)위치에 서게되며, n-2, m-2크기의 표가 된다

2. 해당 과정을 n 혹은 m이 3보다 작아질때까지 반복한다

• 즉, n과 m 둘 중 작은쪽이 1 혹은 2가 되는 횟수 x만큼 반복한다
• 각 반복마다 4회 회전이 발생하므로, 이 시점까지 발생한 회전은 4x이다
• 또한 이 시점에서 좌표는 (x, x)이다

3. n 혹은 m이 1 혹은 2까지 작아졌다면, 총 6가지 경우의 수가 존재한다

• 1 * 1
• 1 * m
• n * 1
• 2 * 2
• 2 * m (2*2와 회전횟수 / 도착지점은 동일하다)
• n * 2

4. 각 경우마다, 다음과 같은 경로를 거쳐 최종 도착지점에 도달하게 된다

5. n과 m의 값을 통해 어떤 경우인지 판단하고, 해당하는 회전 횟수 / 도착지점을 적용한다

import java.io.BufferedReader;
import java.io.InputStreamReader;
import java.util.StringTokenizer;

public class Main{
	public static void main(String[] args)throws Exception {
		BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
		
		StringTokenizer st = new StringTokenizer(br.readLine(), " ");
		int n = pint(st.nextToken());
		int m = pint(st.nextToken());
		
		long min = (Math.min(n, m)-1)/2;
		
		long x=min+1,y=min+1;
		long count = 4*min;
		
		n-=2*min;
		m-=2*min;
		if(n==1) {
			y+=m-1;
		}
		else if(m==1) {
			count++;
			x+=n-1;
			
		}
		else if(n==2) {
			count+=2;
			x++;
		}
		else {
			count+=3;
			x++;
		}
		System.out.println(count);
		System.out.println(x+" "+y);
	}
	
	static int pint(String s) {
		return Integer.parseInt(s);
	}
}

[문제링크]

0. 최단 거리 탐색 문제, BFS

1. 큰 덩어리가 움직이므로, 4방향 각각 이동 가능한지 판단하는 함수 chk를 만든다

2. 맵 크기가 1000*1000이므로 초기값은 1000000보다 큰 임의의 수를 선택

3. 시작지점부터 BFS로 탐색 진행

4. 최종 지점의 값이 초기값이라면 도달 불가하므로 -1을 출력, 값이 변했다면 해당 값을 출력한다

import java.io.BufferedReader;
import java.io.InputStreamReader;
import java.util.Arrays;
import java.util.LinkedList;
import java.util.Queue;
import java.util.StringTokenizer;

public class Main{
	static int[][] map;
	static int[][] answer;
	static int H,W,Sx,Sy,Ex,Ey;
	static int ans;
	public static void main(String[] args)throws Exception {
		BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
		
		StringTokenizer st = new StringTokenizer(br.readLine(), " ");
		int n = pint(st.nextToken());
		int m = pint(st.nextToken());
		map = new int[n][m];
		answer = new int[n][m];
		
		for (int i = 0; i < n; i++) {
			Arrays.fill(answer[i], 1000001);
			st = new StringTokenizer(br.readLine());
			for (int j = 0; j < m; j++) {
				map[i][j] = pint(st.nextToken());
			}
		}
		st = new StringTokenizer(br.readLine());
		H = pint(st.nextToken()); W = pint(st.nextToken());
		Sx = pint(st.nextToken())-1; Sy = pint(st.nextToken())-1;
		Ex = pint(st.nextToken())-1; Ey = pint(st.nextToken())-1;
		
		Queue<int[]> qu = new LinkedList<int[]>();
		qu.offer(new int[] {Sx,Sy,0});
		answer[Sx][Sy]=0;
		//bfs
		while(!qu.isEmpty()) {
			int[] cur = qu.poll();
			if(cur[0]+H < n && answer[cur[0]+1][cur[1]]>cur[2]+1 && chk(cur[0], cur[1], 0) ) {
				answer[cur[0]+1][cur[1]]=cur[2]+1;
				qu.offer(new int[] {cur[0]+1, cur[1], cur[2]+1});
			}
			if(cur[0]-1 >=0 && answer[cur[0]-1][cur[1]]>cur[2]+1 && chk(cur[0], cur[1], 1) ) {
				answer[cur[0]-1][cur[1]]=cur[2]+1;
				qu.offer(new int[] {cur[0]-1, cur[1], cur[2]+1});
			}
			if(cur[1]-1 >=0 && answer[cur[0]][cur[1]-1]>cur[2]+1 && chk(cur[0], cur[1], 2) ) {
				answer[cur[0]][cur[1]-1]=cur[2]+1;
				qu.offer(new int[] {cur[0], cur[1]-1, cur[2]+1});
			}
			if(cur[1]+W < m && answer[cur[0]][cur[1]+1]>cur[2]+1 && chk(cur[0], cur[1], 3) ) {
				answer[cur[0]][cur[1]+1]=cur[2]+1;
				qu.offer(new int[] {cur[0], cur[1]+1, cur[2]+1});
			}
		}
		System.out.println(answer[Ex][Ey]>1000000 ? -1 : answer[Ex][Ey]);
	}

	static boolean chk(int x, int y, int type) {
		boolean returnV = true;
		if(type==0) {
			//chk down
			for (int i = y; i < y+W; i++) {
				if(map[x+H][i]==1)returnV=false;
			}
		}
		else if(type==1){
			//chk up
			for (int i = y; i < y+W; i++) {
				if(map[x-1][i]==1)returnV=false;
			}
		}
		else if(type==2){
			//chk left
			for (int i = x; i < x+H; i++) {
				if(map[i][y-1]==1)returnV=false;
			}
		}
		else if(type==3){
			//chk right
			for (int i = x; i < x+H; i++) {
				if(map[i][y+W]==1)returnV=false;
			}
		}return returnV;
	}
	
	static int pint(String s) {
		return Integer.parseInt(s);
	}
}