언리얼 스크립트에서 한글을 사용했을 때 한글이 깨지는 문제를 해결하는 방법을 알아봅시다.

 

타임라인

0:00 인트로

0:13 한글 깨짐 문제와 해결법

2:03 아웃트로

 

[투네이션]

 

-

 

toon.at

[Patreon]

 

WER's GAME DEVELOP CHANNEL님이 Game making class videos 창작 중 | Patreon

WER's GAME DEVELOP CHANNEL의 후원자가 되어보세요. 아티스트와 크리에이터를 위한 세계 최대의 멤버십 플랫폼에서 멤버십 전용 콘텐츠와 체험을 즐길 수 있습니다.

www.patreon.com

[디스코드 채널]

 

Join the 베르의 게임 개발 채널 Discord Server!

Check out the 베르의 게임 개발 채널 community on Discord - hang out with 399 other members and enjoy free voice and text chat.

discord.com

 

반응형

Programming 

스크립트로 게임 오브젝트 생성하고 파괴하기

 

작성 기준 버전 :: 2019.2

 

[본 포스트의 내용은 유튜브 영상으로도 시청하실 수 있습니다]

 

 

씬에 새로운 게임 오브젝트를 생성하는 제일 기본적인 방법은 하이어라키 뷰에 우클릭해서 생성하고자 하는 게임 오브젝트를 선택하는 것이었다. 하지만 이렇게 에디터의 하이어라키 뷰에서 생성한 게임 오브젝트는 다른 컴포넌트나 스크립트의 개입 없이는 파괴되지 않기 때문에, 정적인 오브젝트이다.

 

반대로 스크립트의 개입으로 게임 플레이 도중에 생성되고 파괴되는 것을 동적으로 오브젝트를 생성하거나 파괴한다고 한다.

 

그럼 이제부터 이렇게 스크립트를 이용해서 게임 플레이 도중에 게임 오브젝트를 생성하고 파괴하는 방법을 알아보도록 하자.

 

게임 오브젝트 생성하기

 

public class GameObjectCreator : MonoBehaviour

{

    void Start()

    {

        new GameObject();

    }

}

 

게임 오브젝트를 생성하기 위해서는 위의 예시 코드와 같이 new GameObject()라는 코드를 작성하면 된다.

 

이 코드는 C#에서는 GameObject라는 클래스의 객체를 메모리에 생성하는 코드이지만, 유니티 엔진에서는 GameObject 클래스의 객체를 메모리에 생성하면서 씬에 실제 게임 오브젝트 역시 생성하는 기능을 한다.

 

 

이대로 코드를 저장하고 에디터로 돌아가서 하이어라키 뷰에서 게임 오브젝트를 하나 생성하고, 방금 만든 GameObjectCreator 컴포넌트를 부착해준 뒤, 플레이 버튼을 보면 "New Game Object"라는 이름으로 게임이 시작되는 시점에는 씬에 없던 새로운 게임 오브젝트가 동적으로 생성된 것을 볼 수 있다.

 

하지만 이렇게 생성된 게임 오브젝트는 말 그대로 '빈' 게임 오브젝트이다. 게임에서 아무것도 없는 빈 게임 오브젝트가 할 수 있는 역할은 아마 없을 것이다. 빈 게임 오브젝트에 새로운 역할을 부여해주려면 새로운 컴포넌트를 부착해야 한다.

 

그러니 앞 단계에 이어서 게임 오브젝트에 스크립트로 컴포넌트를 붙이는 방법을 알아보자.

 

프로젝트 뷰에 우클릭해서 TestComponent라는 이름으로 C# 스크립트를 생성한다. 그리고 GameObjectCreator 스크립트 파일에서 아래와 같이:

 

public class GameObjectCreator MonoBehaviour

{

    void Start()

    {

        var newObj = new GameObject().AddComponent<TestComponent>();        newObj.name = "Test Component Game Object";

    }

}

 

.AddComponent 함수를 사용하면 비어있는 게임 오브젝트에 스크립트로 방금 만든 TestComponent 컴포넌트를 부착할 수 있다. 

 

그리고 .name 프로퍼티를 이용하면 게임 오브젝트의 이름을 바꿀 수 있다. 이렇게 생성한 게임 오브젝트의 이름을 적절하게 바꿔주면 나중에 에디터에서 작업할 때 찾고자 하는 게임 오브젝트를 빠르게 찾을 수 있게 된다.

 

 

코드를 저장하고 에디터로 돌아가서 실행해보면 게임이 플레이되면 아까처럼 새로운 게임 오브젝트가 생성되는데 새 게임 오브젝트의 이름이 "New Game Object"가 아닌 "Test Component Game Object"인 것을 볼 수 있다. 그리고 이 "Test Component Game Object"를 하이어라키 뷰에서 클릭해보면 이렇게 TestComponent가 부착되어 있는 것을 볼 수 있다.

 

게임 오브젝트 파괴하기

 

게임 오브젝트를 생성하기만 하고 생성된 게임 오브젝트를 적절하게 제거하지 않으면 게임이 사용하는 메모리가 점점 늘어나면서 게임이 점점 느려지고 마지막엔 결국 게임이 멈춰버릴 수도 있다.

 

그럼 이제 생성된 게임 오브젝트를 스크립트로 파괴하는 방법을 알아보자.

 

이번에는 TestComponent 스크립트 파일을 연다.

 

public class TestComponent : MonoBehaviour

{

    void Start()

    {

        Destroy(gameObject);

    }

 

    private void OnDestroy()    {        Debug.Log(name + "가 파괴됨!");

 

    }

}

 

Start 함수에서 Destory 함수를 호출하고 매개변수로 파괴하고자 하는 게임 오브젝트를 넣어주면 된다. 우리는 TestComponent가 부착된 게임 오브젝트가 파괴되기를 원하기 때문에 gameObject 프로퍼티를 넣어준다.

 

그리고 OnDestroy 함수를 만들고 게임 오브젝트가 파괴될 때, 파괴되는 게임 오브젝트의 이름과 함께 파괴되었다는 로그를 남겨주는 코드를 작성한다.

 

 

코드를 저장하고 에디터로 돌아가서 플레이해보면 게임이 시작되자마자 Test Component Game Object가 파괴되었다는 로그만 남기고 사라져버린다.

 

Destroy(gameObject, 5f);

 

게임 오브젝트가 생성되자마자 바로 파괴되는 것이 아니라 일정한 시간이 지난 뒤에 파괴되는 것을 원한다면, Destroy 함수의 두 번째 매개변수에 실수형 매개변수를 넣어주면 된다.

 

유니티 스크립트 작업의 기반이 되는 C# 프로그래밍에는 함수 오버로딩이라고 하는 기능을 제공하는데 이것은 똑같은 이름의 함수라도 입력하는 매개변수에 따라서 비슷하지만 다른 동작을 하도록 구현할 수 있도록 만들어준다.

 

gameObject만 매개변수로 넣었을 때의 Destory 함수는 입력받은 게임 오브젝트를 바로 파괴하지만, 두 번째 매개변수로 실수형 숫자를 같이 넣어주면, 넣어준 숫자만큼의 시간이 지난 후에 입력받은 gameObject를 파괴하는 식으로 조금 다르게 동작한다.

 

참고로 두 번째 매개변수의 시간은 초 단위로 동작한다. 그러니까 이 TestComponent가 부착된 게임 오브젝트는 생성되고나서 5초가 지나면 파괴된다.

 

코드를 저장하고 에디터로 돌아가서 플레이 버튼을 눌러보면 게임 오브젝트가 생성되고 약 5초가 지난 뒤 파괴되는 것을 확인할 수 있다.

 

이런 식으로 스크립트로 게임 오브젝트를 생성하고 원하는 시점에 파괴되게 만들 수 있다.

 

반응형

Tutorial (8) 

스크립트 작업 기초

 

작성 기준 버전 :: 2019.2

 

[본 튜토리얼의 내용을 유튜브 영상을 통해서 확인하실 수도 있습니다]

 

이번 섹션에서는 스크립트 작업으로 기초적인 커스텀 컴포넌트를 만드는 법을 배워보자.

 

본격적인 섹션 진행에 앞서 게임 오브젝트와 컴포넌트에 관련된 지식이 필요하다면 이 포스트를 참고해보자.

 

또한 이번 섹션을 진행하기 위해서는 C# 프로그래밍에 대한 기초적인 지식을 필요로 한다.

 

커스텀 컴포넌트 생성

 

[그림 1]

 

우선 커스텀 컴포넌트를 만들기 위해서 C# 스크립트를 하나 생성해보자. 프로젝트 뷰에 우클릭하여 [Create > C# Script] 항목을 선택한다.

 

 

그렇게하면 NewBehaviourScript라는 이름으로 C# 스크립트 파일이 하나 생성된다.

 

 

바로 엔터 키를 누르지 말고 파일의 이름을 ScriptingTest로 변경하고 엔터 키를 누르도록 하자. C# 스크립트 파일은 제일 처음 이름이 정해질 때, 스크립트 파일 내부의 클래스 이름이 정해지며, 스크립트 파일의 이름과 클래스의 이름이 일치하는 것을 권장하기 때문에 클래스의 이름을 처음에 제대로 정하는 것이 나중에 수정하는 것보다 좋다. 특히 나중에 파일의 이름을 바꾸면 내부의 클래스의 이름도 수동으로 바꿔야하므로 굉장히 번거롭다.

 

 

그리고 생성된 스크립트 파일을 더블클릭하면 비주얼 스튜디오가 열립니다.

 

모노비헤이비어 클래스 상속

 

using System.Collections;
using System.Collections.Generic;
using UnityEngine;

public class ScriptingTest : MonoBehaviour
{
    // Start is called before the first frame update
    void Start()
    {
        
    }

    // Update is called once per frame
    void Update()
    {
        
    }
}

 

최초로 생성된 기본 코드는 위와 같다. 먼저 생성된 ScriptingTest 클래스가 모노비헤이비어(MonoBehaviour) 클래스를 상속받고 있는 것을 볼 수 있다. 이 유니티로 게임을 제작할 때 사용되는 C# 클래스는 이 모노비헤이비어를 상속받는 클래스과 상속받지 않는 클래스로 크게 나누어진다.

 

 

모노비헤이비어 상속 여부에 따른 차이는, 모노비헤이비어를 상속받지 않은 클래스는 게임 오브젝트에 컴포넌트로써 부착되지 못한다는 것에 있다. 때문에 컴포넌트로써 게임 오브젝트에 부착되어서 씬 내부에 존재해야하는 클래스는 모노비헤이비어를 상속받는게 필수이고, 씬에 컴포넌트로 배치되지 않고 코드 내부에서 개념적으로만 존재할 클래스는 모노비헤이비어를 상속받지 않아야 한다.

 

모노비헤이비어의 라이프 사이클

 

 

 

 

모노비헤이비어를 상속받아서 게임 오브젝트에 부착되어 동작하는 스크립트를 잘 활용하려면 모노비헤이비어의 라이프 사이클에 대해서 잘 알아두는 것이 좋다. 모노비헤이비어를 상속받는 컴포넌트는 생성되어 게임 오브젝트에 부착되는 순간부터 위의 이미지와 같은 과정을 거친다.

 

그리고 위의 모노비헤이비어 상속 파트에서 본 코드 블럭을 보면 Start() 함수와 Update() 함수가 구현되어 있는 것을 볼 수 있다. 이와 같이 거치는 과정의 이름으로 함수를 만들어두면 해당 과정을 거칠 때, 그 함수가 실행되는 구조이다.

 

그럼 각 과정이 언제 호출되는지 어떻게 구현하면 되는지에 대해서 하나씩 알아보자.

 

Awake

 

private void Awake()
{
    Debug.Log("Awake");   
}

 

Awake 과정은 스크립트 인스턴스가 로딩될 때 단 한 번 호출되는 함수이다. 컴포넌트에 대한 초기화가 필요한 경우에 사용된다. 참고로 모노비헤이비어를 상속받는 클래스는 생성자 대신에 Awake() 함수를 구현해서 사용해야 한다.

 

OnEnable

 

private void OnEnable()
{
    Debug.Log("OnEnable");   
}

 

OnEnable 과정은 모노비헤이비어를 상속받은 컴포넌트가 부착된 게임 오브젝트가 활성화될 때마다 호출되는 함수이다.

 

 

에디터의 씬에서 게임 오브젝트를 선택하면 인스펙터 뷰에서 선택한 게임 오브젝트에 대한 정보를 볼 수 있는데, 이 중에 게임 오브젝트 이름 앞에 체크박스가 있다. 이 체크박스를 클릭해보면 체크박스 상태에 따라서 게임 오브젝트가 활성화되었다 비활성화되었다하는 것을 볼 수 있다. 이렇게 게임 오브젝트가 활성화될 때마다 OnEnable() 콜백 함수가 호출되는 것이다. 참고로 게임 오브젝트가 비활성화된 상태에서는 해당 게임 오브젝트에 부착된 모든 컴포넌트가 동작을 멈춘다.

 

Start

 

private void Start()
{
    Debug.Log("Start");   
}

 

Start 과정은 Update 과정이 실행되기 직전에 단 한 번 호출된다. 모노비헤이비어의 라이프 사이클 중에 단 한 번 호출된다는 점이 Awake와 같지만 Start는 게임 오브젝트가 활성화된 경우에만 호출된다는 차이점이 있다.

 

Update

 

private int i = 5;
private void Update()
{
    i--;
    if(i >= 0)
    {
        Debug.Log("Update :: " + i);
    }
    else
    {
        Destroy(gameObject);
    }
}

 

Update 과정은 모노비헤이비어가 활성화된 상태에서 매 프레임마다 호출된다. 대부분의 게임의 동작 처리는 이 Update() 함수에서 수행되는 경우가 많다. 다만, 이 Update() 함수는 프레임마다 호출되기 때문에 프레임 드랍이 발생하는 경우에는 호출 횟수가 줄어든다. 프레임과 상관 없이 코드가 작동하기 원한다면 FixedUpdate() 함수를 사용해야 한다.

 

Update() 함수는 OnEnable() 함수를 설명하면서 이야기했듯이 게임 오브젝트가 비활성화된 상태에서는 동작하지 않는다.

 

LateUpdate

 

private void LateUpdate()
{
    Debug.Log("LateUpdate");   
}

 

LateUpdate는 단어 그대로 늦은 업데이트로 Update() 함수가 실행된 직후에 실행되는 업데이트 함수이다. Update() 함수에서 게임 로직을 처리한 직후에 처리하고 싶은 로직이 있다면 이곳에서 처리하면 된다.

 

FixedUpdate

 

private void FixedUpdate()
{
    Debug.Log("FixedUpdate");   
}

 

FixedUpdate는 매 프레임마다 호출되는 Update와 달리 지정된 시간마다 호출되는 업데이트 함수이다. 때문에 프레임이 들쭉날쭉한 상황에서도 일정한 시간마다 호출된다. 주로 호출 시간에 따라서 결과가 달라지면 안되는 물리적인 계산에 사용된다.

 

OnDisable

 

private void OnDisable()
{
    Debug.Log("OnDisable");   
}

 

OnDisable 과정은 모노비헤이비어가 비활성화되는 경우에 사용된다. 그리고 오브젝트가 삭제되는 경우에도 호출된다.

 

OnDestroy

 

private void OnDestroy()
{
    Debug.Log("OnDisable");   
}

 

OnDestory 과정은 모노비헤이비어가 제거될 때 호출된다.

 

 

위의 코드를 모두 ScriptingTest 클래스에 작성하고 플레이시켜보면 위의 이미지와 같은 순서로 로그가 발생하는 것을 볼 수 있다.

 

 

 

 

 

변수

 

우리가 게임을 만들면서 사용될 값, 공격력, 방어력, 공격속도, 이동속도, HP 등의 데이터나 정보를 담아둘 것을 변수라고 부른다. 유니티 엔진에서 스크립트를 작성하는 C#은 담고자하는 값의 종류에 따라서 변수의 종류가 나누어진다. 그럼 이 변수의 종류에 대해서 알아보도록 하자.

 

정수(int)

 

int i = 10;

 

첫 번째 변수 유형은 정수형이다. 정수형 변수 int는 0과 양의 정수, 음의 정수를 담기 위한 변수로, -2,147,483,648부터 2,147,483,647까지 담을 수 있다. 

 

남아있는 라이프의 갯수, 현재 생산된 인구 수 등의 정수로 딱 떨어지는 곳에서 사용될 수 있다.

 

실수(float)

 

float f = 3.14159f;

 

두 번째 변수 유형은 실수형이다. 실수형 변수 float은 소수를 담기 위한 변수로 일반적으로 소수점 다섯 번째자리 0.00001까지 정확도를 표현할 수 있다.

 

주로 1.2초 같은 시간이나 20.25%와 같은 확률 등을 표현할 때, 주로 사용된다.

 

문자열(string)

 

string str = "hello";

 

세 번째 변수 유형은 문자열입니다. 문자열 변수 string은 말그대로 문자들의 집합인 문자열을 담는 변수이다.

 

주로 캐릭터나 아이템의 이름, 설명, 게임에서 사용되는 대사 자막 등의 데이터를 담는데 사용된다.

 

논리값(bool)

 

bool isMoveable = true;

 

네 번째 변수 유형은 논리값이다. 논리값 변수 bool은 참(true) 혹은 거짓(false)의 상태를 가지는 변수로 주로 조건을 처리할 때 사용된다.

 

이 외에도 각 종류의 변수를 묶음 단위로 취급하는 배열 등이 있고, 일반 C# 클래스나 모노비헤이비어를 상속받은 클래스 역시 변수가 될 수 있다.

 

 

함수

 

함수는 게임 기능을 수행하기 위한 작업을 하나의 블록으로 묶은 것을 의미한다. 모노비헤이비어의 라이프 사이클에 대해서 설명하면서 본 Awake, OnEnable, Start, Update, OnDisable, OnDestroy 역시 함수이다. 일반적으로 함수는 하나의 기능 단위로 작성되는 경우가 많다.

 

int attackDamage = 10;

public bool Attack(Monster monster)
{
    monster.hp -= attackDamage;
    return monster.hp <= 0;
}

 

위의 예시 코드는 몬스터를 공격해서 체력을 공격력만큼 깎고, 몬스터의 체력이 0 이하가 되면 true를 반환하도록 코드가 작성되어 있다. 이렇게 하면 Attack() 함수를 호출하여 몬스터의 체력을 깎고 공격한 몬스터가 죽었는가에 따라서 여러가지 처리를 할 수 있게 된다.

 

 

공개 수준 결정

 

개발자는 코드를 작성하면서 변수나 함수에 대해서 공개 수준을 결정할 수 있다.

 

public int i;

protected float f;

private string str;
 
public void Function1() { }
 
protected void Function2() { }
 
private void Function3() { }

 

변수와 함수의 공개 수준은 앞에 표시된 public, protected, private 키워드를 통해서 결정된다. 이러한 공개 수준은 일반적인 C# 프로그래밍에서와 같이 public은 클래스 외부에서 접근이 가능하고 protected는 해당 클래스를 상속받은 클래스에서만 접근이 가능하다. 그리고 private는 해당 클래스의 내부에서만 사용 가능하다.

 

public class ScriptingTest : MonoBehaviour
{
    public int attackDamage = 10;
}

 

그리고 유니티 엔진만의 특징으로는 모노비헤이비어 클래스를 상속받은 클래스에서 public으로 설정된 변수는 에디터의 인스펙터 뷰에서 바로 보고 수정할 수 있다는 장점이 있다.

 

 

이러한 방식의 장점은 매번 게임의 수치가 바뀔 때마다 프로그래머가 코드를 수정하고 새로 빌드 과정을 거칠 필요없이 게임 디자이너가 에디터에서 즉석으로 값을 바꿀 수 있다는 것이다.

 

하지만 인스펙터 뷰에서 보이게 하고자 하는 모든 변수를 public으로 설정하면 코드 내부에서 어떤 클래스에서던지 접근이 가능해진다. 이런 경우를 방지하고자 protected나 private로 설정한 채로 인스펙터 뷰에 공개하고 싶을 수도 있다.

 

[SerializeField]
private int attackDamage = 10;

 

그럴 때는 SerializeField라는 어트리뷰트를 해당 변수 앞에 명시해주면 private나 protected로 둔 상태로도 인스펙터 뷰에 변수를 공개할 수 있다.

 

[HideInInspector]
public int attackDamage = 10;

 

그와 반대로 변수를 public으로 둔 상태로 인스펙터 뷰에 공개하고 싶지 않다면 HideInInspector 어트리뷰트를 붙여주면 된다.

 

모노비헤이비어 클래스를 상속받아서 만들어진 컴포넌트는 클래스를 기반으로 변수를 어떻게 구성하고 함수를 어떻게 구현하느냐에 따라서 그 컴포넌트의 기능과 역할이 정해진다. 

반응형
  1. 료용 2020.01.26 23:22 신고

    베르님 글보고 맨날 이상한닉으로 질문하다가 결국 티스토리 가입했습니다 ㅋㅋㅋ

    기본적인설명을 심플하게 잘쓰셔놧네요

    • wergia 2020.01.27 03:48 신고

      고정으로 들어오시게되었군요!
      감사합니다 료옹님! 언제나 제가 다시봐도 이해하기 쉽게 쓰려고 노력중입니다 ㅎㅎ
      근데 다시 옛날 글보니까 오타도 많고 그렇더라구요 나중에 수정을 좀 해야겠어요

    • wergia 2020.01.27 03:49 신고

      아 료용님이구나 ㅎㅎ
      새벽에 잠이 안와서 반쯤 깬 상태로 보는거라 닉네임을 잘못봤네요

  2. 료용 2020.02.03 02:18 신고

    좋은글들 잘보고있습니다.

    동방프로젝트게임을 친구가하는걸 보고있는데 전에했던플레이를 다시 볼수있는 기능이있던데

    베르님 혹시 리플레이영상 만드실수있으신가요? 저는 도저히 감도안오더라고요 어떻게시작해야될지도...

    • wergia 2020.02.03 03:50 신고

      리플레이 기능을 만드는걸 이야기 하시는 건가요?
      이 부분은 나중에 포스트로 한번 써봐야겠네요.
      다만, 우선 먼저 말씀 드리자면 리플레이 기능은 여러방법으로 만들 수 있는데, 첫
      번째는 게임 내의 오브젝트의 위치와 컴포넌트가 가지는 값을 모두 기록하고 있다가 그 기록을 따라 생성된 리플레이 오브젝트들이 따라가게 만드는 방법이 있고,
      두번째 방법은 사용자의 입력을 기록하여, 그 기록대로 움직이게 하는 방법,
      세번째 방법은 카메라로 바라보는 장면을 렌더텍스쳐로 모조리 따서 영상으로 만들어서 실시간으로 저장하는 방법 정도가 있겠네요.
      가장 최적의 방법은 두번째 방안이 되겠습니다. 자세한 설명은 포스트에서 뵙죠.

  3. 료용 2020.02.03 23:00 신고

    답변고맙습니다. 근데 탄까지 쏘는 그런게임인데 그렇다면 카메라자체를 저장하는 세번째방법이 맞지않나요? 두번째방법에서 적이쏘는 탄막같은것을 담아낼수있나요??

    • wergia 2020.02.04 09:22 신고

      간단하게 말해서 사용자의 입력을 기록한다고 했는데, 음.. 좀 더 정확하게 말하면 이벤트를 기록하는 겁니다. 사용자나 적의 비행체가 움직이는 이벤트, 탄을 발사하는 이벤트, 데미지를 입는 이벤트 등을 기록하는 겁니다.
      탄막 같은것도 발사되는 이벤트랑 탄에서 또 다른 탄이 생성되는 이벤트를 기록하면 됩니다.
      카메라 자체를 저장하는 건 사실 그렇게 추천하지는 않습니다. 게임 프레임을 로직이랑 실제 렌더링 돌리는데 30프레임 60프레임 방어하기도 바쁜데 실시간으로 렌더링하는걸 영상으로 저장하는 것도 생각보다 무거운 작업입니다.

  4. 료용 2020.02.07 17:09 신고

    그렇게해서 결국 했던걸 다시 행동하게 한다는거죠? 근데 왜이렇게 어려워보이죠 ㅋㅋㅋㅋㅋㅋㅋㅋ

    • wergia 2020.02.08 12:55 신고

      처음에 설계를 잘하고 들어가야되는 부분이기는 합니다. 애초에 리플레이를 생각안하고 짠 코드에 리플레이 기능을 추가하려면 크게 고생하게 되더라구요. 난이도로 치자면 카메라를 그대로 녹화하는게 제일 쉽기는 합니다. 다만, 게임 성능 문제도 있고 그냥 영상으로 녹화된 리플레이는 배틀그라운드처럼 막 게임 속을 자유롭게 이동하면서 리플레이를 감상하는게 불가능해지죠. 근데 고사양의 게임이 아니고, 게임 리플레이 속을 자유롭게 돌아다닐 필요가 없다면 카메라를 그대로 녹화하는 방법도 나쁘지는 않습니다.

DontDestroyOnLoad 

파괴하지 않을 게임 오브젝트 만들기

 

작성 기준 버전 :: 2019.1.4f1

 

[이 포스트의 내용을 유튜브 영상으로도 시청하실 수 있습니다]

 

유니티에서는 씬(Scene, 장면) 단위로 게임이 플레이될 공간이나 장소 등을 구현하며, 한 씬에서 다른 씬으로 넘어갈 때는, 기존 씬이 언로드되면서 기존 씬에 있던 게임 오브젝트(Game Object)는 모두 파괴된다. 아래의 예시를 보자.

 

 

위 이미지는 Destroy Object라는 이름의 게임 오브젝트 다섯 개를 배치한 Test Scene의 캡처 화면이다. 플레이가 시작되면 아무것도 없는 Other Scene으로 넘어가게 설계되어 있다.

 

 

설계대로 플레이 버튼을 누르면 Test Scene에서 Other Scene으로 이동하며 씬에 배치되어 있는 다섯 개의 Destroy Object가 사라지는 것을 볼 수 있다.

 

 

 

DontDestoryOnLoad 사용법

 

위의 예시에서 볼 수 있듯이 유니티에서는 새로운 씬을 불러오면 이전 씬에 남아있던 게임 오브젝트들은 모두 사라진다. 하지만 개발자의 의도나 설계에 따라서 몇몇 게임 오브젝트들은 다른 씬으로 넘어갈 때 파괴되지 않도록 할 필요성이 생길 수도 있다.

 

public class DontDestoryObject : MonoBehaviour
{
    private void Awake()
    {
        DontDestroyOnLoad(gameObject);
    }
}

 

씬 로드시 파괴하지 않을 오브젝트로 만들려면 바로 위의 코드처럼 DontDestroyOnLoad()함수를 호출해서 매개변수로 자신의 게임 오브젝트를 전달하면 된다.

 

   

이렇게 파괴하지 않을 오브젝트로 만들어진 게임 오브젝트는 게임 플레이가 시작되고 함수가 호출되면 위의 이미지처럼 Test Scene에서 DontDestroyOnLoad 영역으로 옮겨진다.

 

 

만들어진 스크립트를 Dont Destroy Game Object라는 이름의 구체 게임 오브젝트에 붙인 다음 플레이 버튼을 눌러보면 Test Scene에서 Other Scene으로 넘어가면서 Destroy Object는 전부 사라지지만 Dont Destory Game Object는 남아있는 것을 확인할 수 있다.

 

 

Don't Destroy On Load 게임 오브젝트 파괴하기

 

Don't Destory On Load로 설정된 게임 오브젝트는 그럼 파괴할 수 없는 것인가? 라고 생각할 수도 있다. 하지만 제일 앞의 단어가 Can't가 아니라 Don't 임을 명심하자. 파괴할 수 없는 것이 아니라 파괴하지 않는 것이다.

 

Destroy(gameObject);

 

Don't Destory On Load로 설정된 게임 오브젝트는 Destroy() 함수를 이용하면 손쉽게 다시 파괴할 수 있다.

 

 

설계시 주의 사항

 

Don't Destory On Load 게임 오브젝트를 사용한 설계를 할 때는 주의할 점이 있다.

 

 

위의 이미지와 같이 Don't Destory On Load가 적용된 게임 오브젝트가 들어있는 씬과 다른 씬을 여러 번 왔다 갔다 하는 방식의 구조를 생각해보자. 

 

Test Scene에 진입하면 파괴하지 않는 게임 오브젝트가 Don't Destroy On Load 영역으로 이동되면서 씬을 이동해도 파괴되지 않게 될 것이다. 그 다음 Other Scene으로 이동했다가 다시 Test Scene으로 돌아오면 어떻게 될까? 파괴하지 않는 게임 오브젝트는 Don't Destroy On Load 영역으로 이동했으니 더 이상 Test Scene에 남아있지 않을까?

 

아니다. 씬을 새로 불러올 때는 해당 씬의 초기 상태로 불러오기 때문에 파괴하지 않는 게임 오브젝트는 새 것이 생성되어 있으며 이것은 그대로 다시 Don't Destroy On Load 영역으로 옮겨진다. 즉, 똑같은 파괴하지 않는 게임 오브젝트가 2개가 되어버리는 것이다.

 

 

그대로 두 씬을 왕복하면 같은 게임 오브젝트가 계속해서 누적되는 문제가 발생한다. 이 문제는 그대로 불필요한 메모리 사용을 증가시킬 것이고, 뿐만 아니라 예측할 수 없는 작동 문제 역시 일으킬 수 있다. 

 

 

해결 방법 1 : 중복 검사 후 파괴하기

 

public class DontDestoryObject : MonoBehaviour
{
    private void Awake()
    {
        var obj = FindObjectsOfType<DontDestoryObject>();
        if (obj.Length == 1)
        {
            DontDestroyOnLoad(gameObject);
        }
        else
        {
            Destroy(gameObject);
        }
    }
}

 

해당 게임 오브젝트를 파괴하지 않는 게임 오브젝트로 설정하는 이유가 게임 내에서 단 하나만 존재하는 오브젝트를 만들고자 하는 경우라면 가장 간단하고 손쉬운 해결 방법으로는 게임 오브젝트가 생성된 직후에 실행되는 Awake() 함수에서 현재 씬에 있는 같은 오브젝트가 몇 개인지 검사를 한 뒤 2개 이상이라면 생성된 오브젝트를 파괴하는 방법이다.

 

 

해결 방법 2 : 초기화 씬 구현하기

 

 

두 번째 방법으로는 파괴하지 않는 게임 오브젝트를 생성하는 전용 씬을 만들고 그 씬에서 파괴하지 않는 게임 오브젝트를 생성한 뒤 다른 씬만 오가는 방식이다. 이 방법 게임 내에서 단 하나만 존재하는 오브젝트를 만들고자 하는 경우에 유용한 방법이다.

 

 

해결 방법 3 : 라이프 사이클 관리하기

 

파괴하지 않는 게임 오브젝트는 위의 예시에서 볼 수 있듯이 씬을 이동한다고 해서 파괴되지 않는다. 그렇기 때문에 제대로 관리하지 않는다면 생성되는 족족 Don't Destroy On Load 영역에 게임 오브젝트가 쌓일 것이다. 

 

위의 두 가지 방법은 게임 내에서 해당 오브젝트를 단 하나만 만들고자 하는 경우에 유용한 방법이다. 만약 해당 오브젝트가 파괴되지 않아야 하지만 여러 개의 오브젝트를 만드는 것을 허용하는 구조라면 위의 방법들은 적절하지 않다.

 

또한 앞선 예시들은 모두 파괴하지 않을 게임 오브젝트를 정적으로 씬에 배치를 해서 씬이 불러와질 때마다 생성되게 만드는 구조를 채용했다. 하지만 이와 반대로 같은 종류의 파괴되지 않을 게임 오브젝트를 여러 개 생성하는 것을 허용하려고 한다면 정적인 씬 배치 방식보다는 프리팹으로 관리하며 원하는 시점에 생성하는 것이 좋다.

 

 

이러한 경우에 더욱 주의해야할 점은 파괴하지 않는 게임 오브젝트들이 동적으로 여러 개 생성되어 작동하고 있으며, 이후에도 계속해서 생성된다는 점이다. 때문에 파괴하지 않은 게임 오브젝트들에 대해서 제대로 추적/관리해야 하며 해당 오브젝트의 사용이 끝나면 파괴하는 식으로 라이프 사이클(Life Cycle) 관리가 필요하다.

반응형

Scriptable Object 

스크립터블 오브젝트(Scriptable Object) 기본 사용법

 

작성 기준 버전 :: 2019.1 ~ 2019.2

 

[이 포스트의 내용은 유튜브 영상으로도 시청하실 수 있습니다]

 

스크립터블 오브젝트(Scriptable Object)는 유니티에서 제공하는 대량의 데이터를 저장하는 데 사용할 수 있는 데이터 컨테이너이다. 스크립터블 오브젝트를 사용하면 값의 사본이 생성되는 것을 방지하여 프로젝트의 메모리 사용을 줄일 수 있으며 이것은 모노비헤이비어(MonoBehaviour) 스크립트에 변경되지 않는 데이터를 저장하는 프리팹을 사용하는 프로젝트에서 유용하다고 한다. 변경되지 않는 데이터를 사용하는 프리팹의 데이터를 일반 변수로 구현할 경우 인스턴스화 할때마다 프리펩에 이 데이터에 대한 자체 사본이 생성되는데, 스크립터블 오브젝트를 사용하면 메모리에 스크립터블 오브젝트의 데이터 사본만을 저장하고 이를 참조하는 방식으로 작동한다고 한다.

 

스크립터블 오브젝트 클래스는 유니티에서 기본적으로 제공하는 것으로 모노비헤이비어 클래스와 마찬가지로 기본 유니티 오브젝트(Unity Object)에서 파생되지만, 모노비헤이비어와 달리, 게임 오브젝트에 컴포넌트로 부착할 수 없고, 프로젝트에 에셋으로 저장된다.

 

 

스크립터블 오브젝트 만들기

 

스크립터블 오브젝트를 만들기 위해서는 ScriptableObject 클래스를 상속받아서 아래의 코드와 같이 구현하면 된다.

 

using UnityEngine;

[CreateAssetMenu(fileName = "Zombie Data", menuName = "Scriptable Object/Zombie Data", order = int.MaxValue)]
public class ZombieData : ScriptableObject
{
    [SerializeField]
    private string zombieName;
    public string ZombieName { get { return zombieName; } }
    [SerializeField]
    private int hp;
    public int Hp { get { return hp; } }
    [SerializeField]
    private int damage;
    public int Damage { get { return damage; } }
    [SerializeField]
    private float sightRange;
    public float SightRange { get { return sightRange; } }
    [SerializeField]
    private float moveSpeed;
    public float MoveSpeed { get { return moveSpeed; } }
}

 

CreateAssetMenu 속성은 스크립터블 오브젝트 스크립트를 이용해서 빠르고 쉽게 에셋을 생성할 수 있게 만들어주는 속성이다.

 

 

 

코드를 빌드하고 에디터로 돌아가서 Assets 메뉴를 보면 추가한 menuName 대로 Create>Scriptable Object>Zombie Data 항목이 새로 생긴 것을 볼 수 있다.

 

 

그리고 그 항목을 선택하면 Zombie Data의 스크립터블 오브젝트가 생성된다.

 

 

생성된 Zombie Data 스크립터블 오브젝트를 선택해보면 위의 이미지와 같이 좀비의 정보에 대한 프로퍼티들이 보인다.

 

 

 

 

스크립터블 오브젝트 사용하기

 

앞에서 스크립터블 오브젝트를 생성하는 방법을 배웠으니 이번에는 스크립터블 오브젝트를 사용하는 방법에 대해서 알아보자.

 

 이름 체력 데미지 시야  이동속도 
일반 좀비(Normal Zombie) 10  10 
스피드 좀비(Speed Zombie) 10 
파워 좀비(Power Zombie)  10  10 
탱커 좀비(Tank Zombie)  20  10  1.5 
센서 좀비(Sensor Zombie) 20 

 

위의 표와 같이 다섯 종류의 좀비 데이터를 담을 스크립터블 오브젝트를 만들어보자.

 

 

우선 제일 처음 만든 스크립터블 오브젝트를 복사해서 다섯 개로 만든다.

 

 

각 파일의 이름을 좀비 종류에 맞게 바꿔준다.

 

 

 

그리고 표의 내용에 맞게 각 스크립터블 오브젝트에 데이터를 입력해준다.

 

public class Zombie : MonoBehaviour
{
    [SerializeField]
    private ZombieData zombieData;
    public ZombieData ZombieData { set { zombieData = value; } }

    public void WatchZombieInfo()
    {
        Debug.Log("좀비 이름 :: " + zombieData.ZombieName);
        Debug.Log("좀비 체력 :: " + zombieData.Hp);
        Debug.Log("좀비 공격력 :: " + zombieData.Damage);
        Debug.Log("좀비 시야 :: " + zombieData.SightRange);
        Debug.Log("좀비 이동속도 :: " + zombieData.MoveSpeed);
    }
}

 

그 다음에는 좀비 데이터를 사용할 좀비 클래스를 작성하고

 

 

좀비 클래스를 사용하는 프리팹을 만들어준다.

 

public enum ZombieType 
{
    Normal, Power, Sensor, Speed, Tank 
}

public class ZombieSpawner : MonoBehaviour
{
    [SerializeField]
    private List<ZombieData> zombieDatas;
    [SerializeField]
    private GameObject zombiePrefab;
    
    void Start()
    {
        for (int i = 0; i < zombieDatas.Count; i++)
        {
            var zombie = SpawnZombie((ZombieType)i);
            zombie.WatchZombieInfo();
        }
    }
    
    public Zombie SpawnZombie(ZombieType type)
    {
        var newZombie = Instantiate(zombiePrefab).GetComponent<Zombie>();
        newZombie.ZombieData = zombieDatas[(int)type];
        return newZombie;
    }
}

 

좀비를 소환하는 좀비 스포너 클래스를 만들고 Start() 함수에는 테스트용 코드를 작성한다.

 

 

코드를 작성한 뒤에는 씬에 좀비 스포너 게임 오브젝트를 만들고 거기에 Zombie Spawner 컴포넌트를 붙인 뒤에, 앞에서 만든 좀비 데이터 스크립터블 오브젝트와 좀비 프리팹을 프로퍼티에 넣어준다.

 

 

모든 세팅을 마친 다음에 플레이 버튼을 눌러서 실행해보면 좀비 게임 오브젝트가 생성되고, 콘솔 창에서는 각 좀비의 정보가 출력되는 것을 볼 수 있다.

 

 

그리고 하이어라키 뷰에서 각 좀비의 게임 오브젝트를 살펴보면 각 Zombie 컴포넌트의 Zombie Data 프로퍼티에는 서로 다른 좀비 데이터 스크립터블 오브젝트들이 참조되고 있는 것을 확인할 수 있다.

 

 

 

 

스크립터블 오브젝트의 특징 및 응용

 

에디터에서는 스크립터블 오브젝트에 데이터를 저장하는 작업이 언제나 가능하지만, 배포된 빌드에서는 데이터를 저장할 수 없고 개발시 설정한 스크립터블 오브젝트 에셋에 저장된 데이터만을 사용할 수 있다.

 

 

그리고 스크립터블 오브젝트는 에셋 파일 형태로 관리되기 때문에 에셋번들 태그를 이용해서 에셋 번들로 빌드하고 배포하는 방식으로 게임 데이터를 업데이트시키는데 사용할 수도 있다.

반응형
  1. 익명 2021.01.04 10:55

    비밀댓글입니다

  2. ?? 2021.07.07 20:06

    잘보았습니다.
    다만 예시가 어울리지 않다고 느끼는건 ScriptableObject 좀비 데이터를 5개 만든다해도 결국 5종의 좀비 밖에 사용못하는 것이므로
    설명에서 말한 것처럼 메모리가 적어지는 것 아닙니다.
    ScriptableObject 데이터가 의미있는 것은 하나의 데이터를 공유하는 경우에만 의미가 있어 보입니다.
    예를 들면 사운드 볼륨같은 것 말입니다.

Programming 

static 키워드를 파일 경로와 URL 표현에 사용하기


작성 기준 버전 :: 2019.1.4f1


유니티 엔진으로 게임을 만들 때, 스크립트 작업은 대부분 C# 스크립트로 이루어진다. 한 때 유니티 초기에는 자바 스크립트(Java Script)나 부(Boo) 같은 언어도 지원을 했었지만, 최신 버전의 유니티 엔진은 C#만을 지원한다. 그렇기 때문에 C#에서 지원하는 기본적인 문법을 충분히 배우고 활용하는 법을 공부해야한다.


이번에는 유니티에서 static 키워드를 활용하여 파일 경로와 URL 표현에 사용하는 방법에 대해서 알아볼 것이다. C#의 static 키워드에 대한 기본적인 내용은 링크를 통해서 확인할 수 있다.



파일 경로와 URL 표현


public class FileLoader : MonoBehaviour

{

    void Start()

    {

        LoadSomeFile(Application.dataPath + "/Save/" + "fileName.txt");

    }


    public void LoadSomeFile(string filePath)

    {

        // 파일을 로드하는 작업...

        Debug.Log(filePath);

    }

}


public class UrlDownloader : MonoBehaviour

{

    void Start()

    {

        StartCoroutine(DownloadSomeFile("https://SomeUrl/GameData/" + "fileName.png"));

    }


    public IEnumerator DownloadSomeFile(string filePath)

    {

        UnityWebRequest request = new UnityWebRequest(filePath);


        yield return request.SendWebRequest();


        var data = request.downloadHandler.data;

        // URL에서 받아온 데이터로 작업...

    }

}


모든 프로그래밍도 마찬가지겠지만 게임 프로그래밍 역시 게임 저장/불러오기나 네트워크 게임이라면 게임 데이터 받아오기 등의 파일 경로와 URL을 다루어야 할 일이 발생한다. 하지만 위의 코드처럼 경로와 URL을 코드에 하드코딩을 해버리면 나중에 파일 경로나 URL이 바뀌는 경우가 발생했을 때, 변경된 경로를 모두 찾아서 바꾸어야 하는 번거로움이 발생한다. 그리고 그 중에 하나라도 놓치는 경우가 발생한다면, 그것은 곧바로 게임이 제대로 동작하지 않은 버그로 직행한다.


이러한 문제를 막기 위해서 게임에서 사용되는 모든 경로는 하나의 클래스로 묶어두고 그 클래스에서 경로를 가져오도록 만드는게 좋다. 다만 클래스에서 경로를 불러올 때는 객체를 생성하지 않고 곧바로 불러올 수 있게 하는 것이 좋다. 바로 그런 점에서 static 키워드를 적용하면 매우 좋다.


public static class GamePath

{

    public static string savePath = Application.dataPath + "/Save/";

}


public static class GameURL

{

    public static string GameDataURL = "https://SomeUrl/GameData/";

}


위 예시 코드처럼 정적 클래스와 정적 변수를 만들어서 경로를 표현한다.


public class FileLoader MonoBehaviour

{

    void Start()

    {

        LoadSomeFile(GamePath.savePath + "fileName.txt");

    }


    public void LoadSomeFile(string filePath)

    {

        // 파일을 로드하는 작업...

        Debug.Log(filePath);

    }

}


public class UrlDownloader MonoBehaviour

{

    void Start()

    {

        StartCoroutine(DownloadSomeFile(GameURL.GameDataURL + "fileName.png"));

    }


    public IEnumerator DownloadSomeFile(string filePath)

    {

        UnityWebRequest request = new UnityWebRequest(filePath);


        yield return request.SendWebRequest();


        var data = request.downloadHandler.data;

        // URL에서 받아온 데이터로 작업...

    }

}

 

경로를 사용할 때는 바로 위 예시 코드처럼 사용하면 된다. 그러면 만약에 경로가 변경되었을 때, 모든 코드에서 수정된 경로를 일일이 찾아서 바꿀 필요없이 GamePath 클래스와 GameURL 클래스의 경로만 수정하면 모든 코드에 적용이 된다.


이런 식으로 코드 내에 상수로 들어가지만, 추후에 변경이 발생할 수 있는 부분을 정적 클래스로 묶어서 관리하면 좋다.

반응형

+ Recent posts