DevFrog

Addressables in Unity

뎁프 — Wed, 11 Jan 2023 11:03:26 +0900

유니티에는 에셋을 다루는 다양한 방법이 있다.

몇 가지 예를 들자면,

변수를 Inspector에 노출시키고 Hierarchy에서 직접 에셋을 드래그&드롭으로 연결시켜놓는 방법.
Resources 폴더를 에셋을 넣고 Resources.Load()를 사용해 불러오는 방법.
에셋들을 묶음(Bundle) 단위로 관리, 배포하는 방법.

어드레서블은 다른 방식들 몇가지 단점들을 보완하고자 만들어진 방식이다.

어드레서블이란?

어드레서블은 유니티에서 사용되는 에셋 관리 시스템이다.
원하는 타이밍에 에셋을 로드할 수 있기 때문에 메모리 관리에 도움이 된다.
모든 에셋을 Resources.Load로 불러온다면 미리 메모리에 올려두어야 하고, 이는 로딩 타임에도 영향을 끼쳐 앱의 경쟁력이 떨어질 수 있으니, 프로젝트의 규모가 어느 정도 있다면 어드레서블 사용을 고려해 보자.
어드레서블은 비동기로 실행되기 때문에 멈춰진 화면을 보고만 있는 일은 없을 것이다.
백그라운드에서 로드가 끝났을 때 원하는 처리 하도록 만들자.
어드레서블을 클라우드에 있는 서버에 올려서 사용할 수도 있다. 이런 경우 빌드를 다시 받지 않아도 새로운 에셋들을 배포할 수 있게 된다.

로컬에서 Addressable 사용하기

Package Manager에서 Addressables를 인스톨하자.
Window > Asset Management > Addressables > Groups를 선택해 Addressables Groups 팝업을 띄운다.
그룹을 설정하고 원하는 에셋을 해당 그룹으로 그레그하면 등록시킬 수 있다. (에셋을 어드레서블로 등록시키는 방법은 다양하다)

마우스를 클릭하면 어드레서블 프리팹을 생성하는 간단한 스크립트이다.

지금은 경로를 string으로 전달하는 끔찍한 방식을 사용하고 있지만 다른 방식도 아래 설명될 것이다.

using UnityEngine;
using UnityEngine.AddressableAssets;
using UnityEngine.ResourceManagement.AsyncOperations;

public class TestAddressables : MonoBehaviour
    {
        private void Update()
        {
            if (Input.GetMouseButtonDown(0))
            {
                var asyncOperationHandler = 
                    Addressables.LoadAssetAsync<GameObject>("Assets/Prefabs/Characters/Players/Player.prefab");
                asyncOperationHandler.Completed += HandleOperation;
            }
        }

        private void HandleOperation(AsyncOperationHandle<GameObject> operation)
        {
            if (operation.Status == AsyncOperationStatus.Succeeded)
            {
                Instantiate(operation.Result);
            }
            else
            {
                Debug.Log("Failed to load!");
            }
        }
    }

람다식을 확용하여 좀 더 간결한 표현이 가능하다.

public class TestAddressables : MonoBehaviour
    {
        private void Update()
        {
            if (Input.GetMouseButtonDown(0))
            {
                Addressables.LoadAssetAsync<GameObject>("Assets/Prefabs/Characters/Players/Player.prefab").Completed +=
                    (operation) =>
                    {
                        if (operation.Status == AsyncOperationStatus.Succeeded)
                        {
                            Instantiate(operation.Result);
                        }
                        else
                        {
                            Debug.Log("Failed to load!");
                        }
                    };
            }
        }
    }

자, 이제 끔찍한 string 대신에 다른 Addressable 활용법들을 알아보자

먼저 Asset Reference를 살펴보자.

다음과 같이 변수를 선언하면 인스펙터에서 원하는 에셋을 드레그 해서 등록할 수 있다.

[SerializeField] private AssetReference assetReference;

Asset Reference를 통해 프리팹을 생성해 보자.

public class TestAddressables : MonoBehaviour
    {
        [SerializeField] private AssetReference assetReference;
        
        private void Update()
        {
            if (Input.GetMouseButtonDown(0))
            {
                assetReference.LoadAssetAsync<GameObject>().Completed +=
                    (operation) =>
                    {
                        if (operation.Status == AsyncOperationStatus.Succeeded)
                        {
                            Instantiate(operation.Result);
                        }
                        else
                        {
                            Debug.Log("Failed to load!");
                        }
                    };
            }
        }
    }

string이 없어지니 한결 후련하다!

다음과 같이 간단하게 Addressable GameObject를 생성 방법도 있다.

assetReference.InstantiateAsync();

어드레서블을 로드하는 다른 방법도 알아보자.

Lable을 통해 어드레서블 에셋 로드하기.

원하는 Lable을 추가해서 다수의 에셋을 해당 Lable로 등록 시킬 수 있다.

[SerializeField] private AssetLabelReference assetLabelReference;

인스펙터에 노출해서 원하는 레이블을 선택할 수 있다.

private void Update()
    {
        if (Input.GetMouseButtonDown(0))
        {
            Addressables.LoadAssetAsync<GameObject>(assetLabelReference).Completed +=
                (operation) =>
                {
                    if (operation.Status == AsyncOperationStatus.Succeeded)
                    {
                        Instantiate(operation.Result);
                    }
                    else
                    {
                        Debug.Log("Failed to load!");
                    }
                };
        }
    }

폴더 전체를 Addressable로 했을 때, 다수의 에셋들을 로딩하는 방법도 살펴보자.

폴더를 Addressable로 등록을 했더라도 폴더를 다이렉트로 접근하는 건 불가능하다.

하위에 있는 에셋에 일일히 접근해야 하는데 이런 접근 방법은 우리가 원하는 방법이 아니기 때문에

Lable을 사용하는게 바람직하다.

폴더를 Lable로 지정하면 하위에 에셋들이 모두 해당 Lable로 마크된다.

아까 언급한 AssetLableReference로 해당 폴더를 등록한다.

[SerializeField] private AssetLabelReference assetLabelReference;

private void Update()
{
    if (Input.GetMouseButtonDown(0))
    {
        Addressables.LoadAssetsAsync<GameObject>(assetLabelReference, (go) => 
        { 
        	Debug.Log(go);
        });
    }
}

두 번째 인자에 에셋을 불러올 때마다 실행하는 Action을 넣어줄 수 있다.

더 이상 불러온 에셋을 사용하지 않는다면 Release 해주도록 하자.

이 방법으로 메모리 공간을 절약할 수 있다.

[SerializeField] private AssetReferenceGameObject assetReferenceGameObject;

private GameObject spawnedGameObject;

private void Update()
{
    //불러오기
    if (Input.GetMouseButtonDown(0))
    {
        assetReferenceGameObject.InstantiateAsync().Completed +=
            (operation) => spawnedGameObject = operation.Result;
    }

    //놓아주기
    if (Input.GetMouseButtonDown(1))
    {
        assetReferenceGameObject.ReleaseInstance(spawnedGameObject);
    }
}

레퍼런스는 GameObject나 Sprite 등 강한 타입들도 지원을 하니 시간이 된다면 살펴보자.

[SerializeField] private AssetReferenceSprite assetReferenceSprite;
[SerializeField] private AssetReferenceGameObject assetReference;

아래 코드와 같이 원하는 타입을 만들어서 사용할 수도 있다.

[System.Serializable]
public class AssetReferenceAudioClip : AssetReferenceT<AudioClip>
{
	public AssetReferenceAudioClip(string guid) : base(guid) {}
}

Anti Cheat Toolkit

뎁프 — Wed, 4 Jan 2023 17:03:22 +0900

Unity Asset Store에서 구매 가능한 유료 치트 방지 플러그인이다.

크게 ObscuredTypes, ObscuredPrefs, ObscuredFile, ObscuredFilePrefs 4가지로 나눠져있다.

하나 씩 예제 코드와 함께 살펴보자.

ObscuredTypes

Cheat Engine, ArtMoney, GameCIH 등과 같은 모든 메모리 검색기에서 변수를 숨김.
모든 기본 타입 및 소수의 유니티 타입들을 커버한다.
모든 플랫폼에서 작동. (PC, Mac, iOS, Android, WP8, WinStore)
ObscuredCheatingDectector를 통한 임의 변조 감지 기능이 있다.

보호 기능이 없는 간단한 코드를 상상해 보자. (lives 변수 참고)

using UnityEngine;

public class ObscuredVars : MonoBehaviour
{
    private int lives = 5;

    private void OnGUI()
    {
        GUILayout.BeginArea(new Rect(5, 5, Screen.width - 10, Screen.width - 10));

        if (lives > 0)
        {
            GUILayout.Label("Lives: " + lives);

            if (GUILayout.Button("Kill player", GUILayout.ExpandWidth(false)))
            {
                lives--;
            }
        }
        else
        {
            GUILayout.Label("Game over!");

            if (GUILayout.Button("Start new game", GUILayout.ExpandWidth(false)))
            {
                lives = 5;
            }
        }
        
        GUILayout.EndArea();
    }
}

일반적으로 치터들은 변수를 찾을 때까지 검색을 반복한다.

아무런 보호 장치가 없다면, 이렇게 찾은 변수를 쉽게 조작할 수 있다.

ACTk을 사용해 변수를 보호하자.

간단하게 int형을 ObscuredInt형으로 교체하자.

public class ObscuredVars : MonoBehaviour
{
    private ObscuredInt lives = 5;

    private void OnGUI()
    {
        GUILayout.BeginArea(new Rect(5, 5, Screen.width - 10, Screen.width - 10));

        if (lives > 0)
        {
            GUILayout.Label("Lives: " + lives);

            if (GUILayout.Button("Kill player", GUILayout.ExpandWidth(false)))
            {
                lives--;
            }
        }
        else
        {
            GUILayout.Label("Game over!");

            if (GUILayout.Button("Start new game", GUILayout.ExpandWidth(false)))
            {
                lives = 5;
            }
        }
        
        GUILayout.EndArea();
    }
}

이제 해당 타입을 어느정도 보호했지만,

치터가 가짜 사본을 찾고 수정하는 것을 허용할 수 있다.

ObscuredCheatingDetector를 사용하여 부정 행위를 탐지해보자.

Cheater 감지에 대한 반응을 구현하고 Start함수에서 탐지기를 작동하자.

public class ObscuredVars : MonoBehaviour
{
    private ObscuredInt lives = 5;
    private bool cheaterDetected = false;

    private void Start()
    {
        ObscuredCheatingDetector.StartDetection(OnCheaterDetected);
    }

    private void OnCheaterDetected()
    {
        cheaterDetected = true;
    }

    private void OnGUI()
    {
        GUILayout.BeginArea(new Rect(5, 5, Screen.width - 10, Screen.width - 10));

        if (lives > 0)
        {
            GUILayout.Label("Lives: " + lives);

            if (GUILayout.Button("Kill player", GUILayout.ExpandWidth(false)))
            {
                lives--;
            }
        }
        else
        {
            GUILayout.Label("Game over!");

            if (GUILayout.Button("Start new game", GUILayout.ExpandWidth(false)))
            {
                lives = 5;
            }
        }
        
        GUILayout.EndArea();
    }
}

이렇게 하면 부정 행위 시도가 감지되며 변수는 안전합니다!

ObscuredPrefs

저장된 모든 데이터 암호화.
변조 감지.
저장된 데이터를 현재 디바이스에 잠금.
PlayerPrefs에서 자동으로 마이그레이션 됨.
추가 유형을 지원.
모든 플랫폼에서 작동. (PC, Mac, iOS, Android, WP8, WinStore)

보호 기능이 없는 간단한 코드입니다. (PlayerPrefs 사용법 참고)

using UnityEngine;

public class ObscuredPrefsExample : MonoBehaviour
{
    private int lives = 5;

    private void OnGUI()
    {
        GUILayout.BeginArea(new Rect(5, 5, Screen.width - 10, Screen.width - 10));
        OutputLivesWithKillButton();

        if (GUILayout.Button("Save lives", GUILayout.ExpandWidth(false)))
        {
            PlayerPrefs.SetInt("player lives", lives);
        }

        if (GUILayout.Button("Load lives", GUILayout.ExpandWidth(false)))
        {
            lives = PlayerPrefs.GetInt("player lives", lives);
        }
        
        GUILayout.EndArea();
    }

    private void OutputLivesWithKillButton(){}
}

이렇게 노출된 PlayerPrefs는 변조 되기 쉽다.

다음은 ACTk를 사용한 ObscuredPrefs를 살펴보자.

사용법은 간단하게 PlayerPrefs를 ObscuredPrefs로 교체하면 된다.

using UnityEngine;
using CodeStage.AntiCheat.Storage;

public class ObscuredPrefsExample : MonoBehaviour
{
    private int lives = 5;

    private void OnGUI()
    {
        GUILayout.BeginArea(new Rect(5, 5, Screen.width - 10, Screen.width - 10));
        OutputLivesWithKillButton();

        if (GUILayout.Button("Save lives", GUILayout.ExpandWidth(false)))
        {
            ObscuredPrefs.Set("player lives", lives);
        }

        if (GUILayout.Button("Load lives", GUILayout.ExpandWidth(false)))
        {
            lives = ObscuredPrefs.Get("player lives", lives);
        }
        
        GUILayout.EndArea();
    }

    private void OutputLivesWithKillButton(){}
}

추가적으로 부정 행위 감지 콜백을 추가하고 적절한 반응을 구현할 수 있다.

public class ObscuredPrefsExample : MonoBehaviour
{
    private int lives = 5;
    private bool cheated = false;

    private void Start()
    {
        ObscuredPrefs.NotGenuineDataDetected += OnCheatingDetected;
    }

    private void OnCheatingDetected()
    {
        cheated = true;
    }

    private void OnGUI()
    {
        GUILayout.BeginArea(new Rect(5, 5, Screen.width - 10, Screen.width - 10));
        OutputLivesWithKillButton();

        if (cheated)
        {
            GUILayout.Label("Cheater!");
        }

        if (GUILayout.Button("Save lives", GUILayout.ExpandWidth(false)))
        {
            ObscuredPrefs.Set("player lives", lives);
        }

        if (GUILayout.Button("Load lives", GUILayout.ExpandWidth(false)))
        {
            lives = ObscuredPrefs.Get("player lives", lives);
        }
        
        GUILayout.EndArea();
    }

    private void OutputLivesWithKillButton(){}
}

ObscuredFile

중요한 데이터를 보호하기 위한 파일 암호화 옵션이 있다.
파일 편집 시도를 포착하는 변조 감지 기능이 내장되어 있다.
- 실제 데이터 손상으로 인한 오탐 방지
- 암호화 및 일반 모드 모두에서 사용할 수 있다.
- 추가 구성 없이 이벤트만 수신만으로 가능.
다른 장치의 데이터를 감지하거나 완전히 방지하는 장치 잠금 옵션이 있다.
- 사용자 정의 ID 옵션. (이메일, 사용자 이름 등)
- 암호화 및 일반 모드 모두에서 사용할 수 있다.

ObscuredFile 요약

선택적으로 데이터를 암호화.
선택적으로 데이터를 장치 또는 사용자 지정 ID에 잠금.
변조 시도를 감지.
백그라운드 스레드에서 사용 가능.
플랫폼 제한이 없음.

간단한 사용 예:

public class ObscuredFileExample : MonoBehaviour
{
    private void Start()
    {
        var safeFile = new ObscuredFile();
        
        //write data:
        var writeResult = safeFile.WriteAllBytes(Encoding.UTF8.GetBytes("Some protected data"));
        if(writeResult.Success)
            Debug.Log($"Data saved to {safeFile.FilePath}");
        else
            Debug.Log($"Someting went wrong while writing data: {writeResult.Error}");
        
        //read data:
        var readResult = safeFile.ReadAllBytes();
        if (readResult.Success)
        {
            // process readResult.Data;
        }
        else if (readResult.CheatingDetected)
        {
            // punish cheaters
            // differentiate using DataFromAnotherDevice and DataIsNotGenuine readResult properties
        }
        else
        {
            // something went wrong and Data wasn't read
            Debug.LogError($"Something went wrong while reading data: {readResult.Error}");
        }
    }
}

ObscuredFilePrefs

ObscuredFile의 파워와 유연성.
PlayerPrefs의 단순성과 사용 용이성.
Prefs들을 List로 사용할 수 있음.

간단한 사용 예:

public class ObscuredFileExample : MonoBehaviour
{
    private void Start()
    {
        // first, let's init ObscuredFilePrefs and load existing prefs
        ObscuredFilePrefs.Init(true);
        
        // now, let's add cheating trigger listeners
        // I'll use same listener for both event in sake of demo simplicity
        ObscuredFilePrefs.NotGenuineDataDetected += CheaterDetected;
        ObscuredFilePrefs.DataFromAnotherDeviceDetected += CheaterDetected;
        
        // few silly prefs for demo purposes
        const string playerHealthKey = "Player health";
        const string playerSessionStart = "Player session start";
        
        // this is how you can set prefs using generics
        ObscuredFilePrefs.Set(playerHealthKey, 100);
        ObscuredFilePrefs.Set(playerSessionStart, DateTime.Now);
        
        // getting prefs is easy as well
        var loadedHealth = ObscuredFilePrefs.Get(playerHealthKey, 0);
        var loadedSessionStart = ObscuredFilePrefs.Get(playerSessionStart, DateTime.MinValue);
        
        Debug.Log($"{playerHealthKey}: {loadedHealth}");
        Debug.Log($"{playerSessionStart}: {loadedSessionStart}");
    }

    private void CheaterDetected()
    {
        Debug.Log("Cheater!");
    }
}

반복문 사용:

// iterating prefs is really easy as well:
var allPrefs = ObscuredFilePrefs.GetKeys();
foreach (var pref in allPrefs)
{
    Debug.Log(pref);
}

SpeedHackDetector

스피드핵을 감지한다.
오탐을 방지하기 위한 쿨다운 기능이 있다.
시간 변경을 준수한다.
모든 플랫폼에서 작동. (PC, Mac, iOS, Android, WP8, WinStore)

SpeedHack이란?

먼저 스피드 핵이 어떻게 작동하는지 보자.

씬의 큐브에서 이러한 회전 스크립트를 상상해 보자.

public class SpeedHackDetecting : MonoBehaviour
{
    private void Update()
    {
        transform.Rotate(Vector3.up, 60f * Time.deltaTime);
    }
}

이 코드는 치터가 치트엔진을 통해 스피드를 쉽게 바꿀 수 있다.

이러한 치트는 예방이 안되지만 감지 및 대응은 가능하다!

먼저 Hierarchy 메뉴에서 스피드핵 디텍터 오브젝트를 만들자.

이제 인스펙터에서 감지기를 구성하고 이벤트 콜백을 할당하기만 하면 된다.

예를 들어 부정 행위 감지 시 게임을 멈추고 팝업을 띄우는 식의 대응이 가능하다.

코드에서 이 작업을 수행할 수 있다.

public class SpeedHackDetecting : MonoBehaviour
{
    private bool cheater = false;

    private void Start()
    {
        SpeedHackDetector.StartDetection(OnSpeedHackDetected);
    }

    private void OnSpeedHackDetected()
    {
        cheater = true;
    }
}

간단하게 Start 함수에서 StartDetection을 해주는 것만으로 스피드핵을 감지할 수 있게 된다.

JSON in Unity

뎁프 — Fri, 30 Dec 2022 10:42:01 +0900

JSON이란?

서버와 클라이언트 사이에 데이터를 주고받을 때 사용하는 개방형 표준 포맷.
텍스트를 사용하기 때문에 사람이 이해하기 쉽다는 장점을 가지고 있다.
JSON은 유니티에서도 다양하게 사용 되는데, 게임에 필요한 데이터를 주고받거나, 게임 진행 상황 또는 설정을 저장할 때 등 광범위하게 사용된다.
JSON에서 {}중괄호는 객체를 의미하고 []대괄호는 배열을 나타낸다.
XML과 사용처가 비슷하지만 XML은 JSON에 비해 가독성이 떨어지고 데이터를 넣거나 파싱 하는 과정이 까다롭다.
JSON은 주석을 제공하지 않는다. 때문에 가독성을 위해 Key의 네이밍에 신경 쓸 필요가 있다.
작은 문법 오류에도 문제가 생길 수 있어서 문법에 오입력이 없도록 신경 쓰자. (JSON 검사기로 테스트)

JSON 코드 예시:

{
  "id": "someID",
  "level": 10,
  "exp": 33.3,
  "hp": 400,
  "items": ["Sword", "Armor", "Hp Potion", "Hp Potion", "Hp Potion"]
}

JSON에서 지원하는 데이터 타입들:

{
    "i":10,
    "f":99.9,
    "b":true,
    "str":"JSON Test"
    "iArray":[1,1,2,3,5,8,12,34],
    "iList":[0,2,4,6,8],
    "fDictionary":
    {
        "PIE":3.14159274,
        "Epsilon":1.401298E-45,
        "Sqrt(2)":1.41421354
    },
    "iVector":
    {
        "x":3,
        "y":2
    }
}

Newtonsoft JSON Library

외부 라이브러리인 Newtonsoft JSON Library를 사용하기 위해서 using Newtonsoft.Json을 선언해 준다.
테스트 용도로 사용할 클래스를 정의하자.
JSON이 담을 수 있는 대부분의 타입을 멤버 변수로 추가하였다.
Int, Float, Bool, String과 같이 기본적인 데이터 타입부터 배열, List, Dictionary와 같은 컨테이너 타입,
그리고 사용자가 직접 정의한 클래스 형식도 한 클래스에 묶어서 JSON 데이터 형식으로 만들 수 있다.

public class JsonTestClass
{
    public int i;
    public float f;
    public bool b;
    public string str;
    public int[] iArray;
    public List<int> iList = new List<int>();
    public Dictionary<string, float> fDictionary = new Dictionary<string, float>();
    public IntVector2 iVector;

    public class IntVector2
    {
        public int x;
        public int y;

        public IntVector2(int x, int y)
        {
            this.x = x;
            this.y = y;
        }
    }
}

생성자에서 값을 자동으로 초기화시켜 보았다.

public JsonTestClass()
{
    i = 10;
    f = 99.9f;
    b = true;
    str = "JSON Test string!";
    iArray = new int[] { 1, 1, 2, 3, 5, 6, 12, 21, 34, 55 };

    for (int idx = 0; idx < 5; idx++)
    {
        iList.Add(2 * idx);
    }

    fDictionary.Add("PIE", Mathf.PI);
    fDictionary.Add("Epsilon", Mathf.Epsilon);
    fDictionary.Add("Squrt(2)", Mathf.Sqrt(2));

    iVector = new IntVector2(3, 2);
}

모든 값을 출력하는 Print 함수도 정의해 준다.

public void Print()
{
    Debug.Log($"i = {i}");
    Debug.Log($"f = {f}");
    Debug.Log($"b = {b}");
    Debug.Log($"str = {str}");

    for (int idx = 0; idx < iArray.Length; idx++)
    {
        Debug.Log(string.Format("iArray[{0}] = {1}", idx, iArray[idx].ToString()));
    }
    for (int idx = 0; idx < iList.Count; idx++)
    {
        Debug.Log(string.Format("iList[{0}] = {1}", idx, iList[idx].ToString()));
    }
    foreach (var data in fDictionary)
    {
        Debug.Log(string.Format("iDictionary[{0}] = {1}", data.Key, data.Value));
    }

    Debug.Log("iVector = " + iVector.x + ", " + iVector.y);
}

자, 이제 Start에서 JSON 데이터를 테스트해보자.

하나의 오브젝트를 문자열인 JSON 데이터로 만드는 과정은 매우 간단하다.

JsonConvert.SerializeObject()를 통해서 오브젝트를 매게 변수에 넣어주면 끝이다.

이 과정을 '직렬화'라고 한다.

JsonTestClass jsonTest1 = new JsonTestClass();
string jsonData = JsonConvert.SerializeObject(jsonTest1);

그럼 이제 반대로 문자열이 된 JSON 데이터를 오브젝트로 변환해 보자.

JSON 데이터를 다시 오브젝트로 바꿀 때는, 어떤 오브젝트로 변환하는지 명시적으로 함수에 알려야 한다.

만약 JSON 데이터가 가진 구조가 함수에 알려준 클래스의 구조와 다르다면 변환 도중에 에러가 발생한다.

오브젝트 변환 후 아까 만든 Print() 함수를 통해 데이터를 확인해 보자.

JsonTestClass jsonTest2 = JsonConvert.DeserializeObject<JsonTestClass>(jsonData);
jsonTest2.Print();

주의 사항

MonoBehaviour를 상속받는 오브젝트를 Serialize 할 경우에 Self Referencing Loop, 즉 자기 참고 루프에 빠질 수 있게 때문에 주의가 필요하다.
MonoBehaviour를 상속 받는 오브젝트를 Serialize 하는 대신, 필요한 property를 클래스로 묶어서 해당 클래스만 Serialize 하거나 이후에 설명할 유니티가 기본 제공하는 JsonUtility를 통해 Serialize 하도록 하자.
Vector3 역시 자기 참조 루프에 빠지게 되니 따로 Serialize용 Vector 클래스를 만들어서 사용하도록 하자.

public class SerializableVector3
{
    public float x;
    public float y;
    public float z;
}

JSON Utility

유니티에서 기본 제공되는 Json Utility에 대해서 알아보자.

JsonUtility.ToJson() 함수를 통해 간단하게 오브젝트를 JSON 데이터로 만들 수 있다.

반대로 JSON 데이터에서 오브젝트로 만들 때는 JsonUtility.FromJson<objectType>(jsonData); 함수를 사용한다.

var jTest1 = new JsonTestClass();
var jsonData = JsonUtility.ToJson(jTest1);
Debug.Log(jsonData);

var jTest2 = JsonUtility.FromJson<JsonTestClass>(jsonData);
jTest2.Print();

MonoBehaviour를 상속받는 클래스의 Serialization

MonoBehaviour를 상속 받는 클래스를 Serialize 할 때는 GetComponent 등으로 직접 가져온 클래스의 오브젝트로 Serialize 해야 한다.

GameObject obj = new GameObject();
obj.AddComponent<TestMono>();
string jsonData = JsonUtility.ToJson(obj.GetComponent<TestMono>());

MonoBehaviour를 상속 받는 오브젝트의 JSON 데이터를 다시 오브젝트로 만들려면, 같은 형태의 오브젝트를 생성한 뒤 Deserialize해야 한다.

JsonUtility.FromJsonOverwrite() 함수는 JSON 데이터를 다시 오브젝트로 변환할 때, 새로운 오브젝트를 만들지 않고 기존에 있는 오브젝트 클래스의 변수 값을 덮어씌우는 처리를 한다.

이 기능을 이용하면 게임 내의 오브젝트를 JSON 데이터로 저장해서 게임 진행 상황을 저장하고 불러올 수 있다.

GameObject obj2 = new GameObject();
JsonUtility.FromJsonOverwrite(jsonData, obj2.AddComponent<TestMono>());

주의 사항

다만 JsonUtility의 단점은 기본적인 데이터 타입과 배열, 리스트에 대한 Serialize만 지원한다.
그래서 위에 Print() 함수로 출력된 텍스트를 보면 딕셔너리나 직접 정의한 클래스에 대한 데이터는 빠진 것을 알 수 있다.
직접 생성한 클래스의 경우에는 [System.Serializable] 어트리뷰트를 붙여줘야만 JSON 데이터로 변환된다.
딕셔너리를 사용하려면 외부 라이브러리를 사용해야 한다.

JSON 데이터 파일로 저장하기

먼저 JsonSaveLoader 테스트 클래스를 생성해 보자.
Start 함수에서 파일을 저장할 경로와 파일 이름으로 FileStream을 만들어준다. (보통 JSON 파일은 .json 확장자를 가진다)
문자열인 JSON 데이터를 Encoding.UTF8의 GetBytes 함수로 byte 배열로 만들어준다.
이렇게 만든 데이터를 FileStream에 써준다.

using System.IO;
using System.Text;
using UnityEngine;
using Newtonsoft.Json;

public class JsonSaveLoader : MonoBehaviour
{
    private void Start()
    {
        FileStream stream = new FileStream(Application.dataPath + "/test.json", FileMode.OpenOrCreate);
        JsonTestClass jTest1 = new JsonTestClass();
        string jsonData = JsonConvert.SerializeObject(jTest1);
        byte[] data = Encoding.UTF8.GetBytes(jsonData);
        stream.Write(data, 0, data.Length);
        stream.Close();
    }
}

이렇게 저장된 JSON 파일을 읽어 들이는 방법도 살펴보자.

이번에도 FileStream을 생성하되, FileMode를 Open으로 설정한다.

그다음에 이 문자열을 Deserialize해준다.

FileStream stream = new FileStream(Application.dataPath + "/test.json", FileMode.Open);
byte[] data = new byte[stream.Length];
stream.Read(data, 0, data.Length);
stream.Close();
string jsonData = Encoding.UTF8.GetString(data);
JsonTestClass jTest2 = JsonConvert.DeserializeObject<JsonTestClass>(jsonData);
jTest2.Print();

PlayerPrefs

뎁프 — Wed, 28 Dec 2022 12:29:57 +0900

가장 간단한 저장 시스템.
PlayerPrefs는 별도의 암호화 없이 로컬 레지스트리에 저장된다.
유저의 암호와 같이 중요한 데이터에는 사용하지 말 것. (중요한 데이터를 서버에 저장하자)
환경설정(음량 조절, 기타 옵션) 같은 것들을 저장하기 용이하다.
정수형, 실수형, 문자열 형식만 지원한다.
이보다 큰 데이터의 경우 이 3가지 데이터로 나눠서 저장해야 하는 불편함이 있다.
딕셔너리나 헤쉬맵과 같이 key와 value의 형태로 데이터를 저장한다.
key의 값은 string이며 value를 찾기 위한 식별자로 사용된다.
중복된 key와 다른 value를 입력했다면 덮어쓰기로 인해 가장 마지막 value가 저장된다.

PlayerPrefs 함수

입력	출력
PlayerPrefs.SetInt	PlayerPrefs.GetInt
PlayerPrefs.SetFloat	PlayerPrefs.GetFloat
PlayerPrefs.SetString	PlayerPrefs.GetString

입력 함수들:

SetInt(string key, int value) : int 값을 해당 key에 저장한다.
SetFloat(string key, float value) : float 값을 해당 key에 저장한다.
SetString(string key, string value) : string 값을 해당 key에 저장한다.

출력 함수들:

GetInt(string key) : key에 저장된 int 값을 불러온다.
GetFloat(string key) : key에 저장된 float 값을 불러온다.
GetString(string key) : key에 저장된 string 값을 불러온다.

기타 함수들:

Save() : 수정된 모든 preferences를 파일에 저장한다.
HasKey(string key) : key가 있는지 확인한다.
DeleteKey(string key) : key에 저장된 value를 삭제한다.
DeleteAll() : 모든 데이터를 삭제한다.

예시:

public void SaveData()
{
  PlayerPrefs.SetString("Input", inputField.text);
}

public void LoadData()
{
  inputField.text = PlayerPrefs.GetString("Input");
}

public void DeleteData()
{
  PlayerPrefs.DeleteKey("Input");
  PlayerPrefs.DeleteAll();
}

PlayerPrefs 저장 위치

Playerprefs는 데이터를 Window에서 Registery에 저장한다.

Window > 실행 > regedit

HKEY_CURRENT_USER/Software/Unity/UnityEditor/CompanyName/ProjectName

안드로이드는 안드로이드 api에서 제공하는 SharedPreferences에 저장한다.

정리:

암호화 없이 로컬에 저장된다는 점이 쓰기 어렵게 만든다.
데이터 타입의 제한도 큰 감점 요소.
그냥 Json파일로 저장하는게 나을지도?
Option이나 Menu와 관련된 데이터를 저장하는 용도로 괜찮아 보인다.
빠르게 프로토타이핑 할 때는 사용해도 좋겠다.

PlayerPrefs - Unity Documents: docs.unity3d.com/kr/530/ScriptReference/PlayerPrefs.html

UnityEngine.PlayerPrefs - Unity 스크립팅 API

Stores and accesses player preferences between game sessions.

docs.unity3d.com