[패스트캠퍼스 수강 후기] 올인원 패키지 : 유니티 포트폴리오 완성 100% 환급 챌린지 29회차 미션 시작합니다.

04. 배틀로얄 - 03, 04 챕터를 진행합니다.





실제 게임을 만드는 기법들을 최대한 활용하여 알찬 강의를 준비하겠다고 하십니다 ^^~ 좋네요~

미리 만들어서 배포해주신 프로젝트에 대한 설명을 시작합니다. 유니티로 해당 프로젝트를 열어서 보면 됩니다.

해당 Scene은 "2.Scenes" - "PlayGround" Scene을 열어 둔 화면입니다.


우측 상단의 "Layout"은 "Default"로 선택된 상태에서 Customize 하여 사용합니다.

창들을 드래그하여 배치하면 됩니다.

좌측상단은 "Scene"과 "Console" 창을 배치합니다.
좌측하단은 "Game Scene"을 배치합니다. "Asset Store"는 느리기 때문에 닫아줍니다.
우측에는 "Hierarchy", "Project", "Inspector"를 화면과 같이 설정해 줍니다.

최신 버전에서는 "2 by 3" Layout을 선택하고 조금 수정하면 됩니다.





"Edit" - "Preferences..."를 클릭하여 "General"에서 "Show Asset Store search hits [ ]"를 Uncheck 해줍니다.

개발 속도에서 차이가 있기 때문에 조금이라도 쾌적한 환경에서 작업하기 위한 팁입니다.





또 위와 같이 Hierarchy, Project, Inspector를 나란히 배치하기도 합니다.
Project는 1 Column으로 설정해 줍니다. 이렇게 하면 Hierarchy와 Project간에 GameObject를 설정하기가 수월해집니다.



일반적인 게임만드는 순서입니다.
1. 어떤 게임을 만들까
2. 엔진 선택 & 버전
3. 타겟 설정 (어느 디바이스, 스토어)
4. 타겟 디바이스와 유저
5. 게임 기준 설정: 프로그램 디자인간 단위 결정. 폴더 이름 규약. 기본 해상도 결정(16:9로 1920x1080, 1136x640, 4:3으로 1024:768)


배틀로얄 프로젝트는 FHD 즉 1920x1080 기준으로 PC에서 구현되는 게임을 기준으로 제작합니다.





위와 같이 "1920 x 1080" 해상도를 추가해 줍니다. 요즈음은 자동 변환 등 해상도 표현이 조금 나아지긴 했지만 타겟 해상도 결정은 중요한 사안입니다. 일단 기본 해상도로 시작해서 추후 다른 지원 해상도를 추가하는 형태를 고려하는 것이 좋습니다.



"Project" 폴더의 "Assets" 설명입니다.

1.Scripts
    /Common
        /AnimatorKey
        /ButtonName
2.Scenes
9.ResourcesData // 추후 3, 4 등 추가될 예정이라서..
PolygonBattleRoyale




 

 

 


Animator - Animator Parameters - AnimatorKey가 위와 같이 연동되어 구동됩니다.
문자열 오타로 인한 문제들의 가능성이 있기 때문에 상수로 설정하고 사용하는데 이것이 AnimatorKey 스크립트입니다.

실무에서는 이렇게 처리하여 SetParameter의 문자열 대신 해당 상수를 사용하여 호출합니다.

추가적으로 실무 게임 제작시에는 CharacterAnimatorKey, MonsterAnimatorKey, NPCAnimatorKey 등을 나누어 제작합니다.

namespace도 여러가지 편의성등을 위해 사용하는 것이 좋고, 대신 위의 "FC"를 사용할 필요는 없고 각자 게임에 맞는 namespace 이름을 정하여 제작하면 됩니다.




public class ButtonName
{
    public const string Sprint = "Sprint";
    public const string Jump = "Jump";
    public const string Aim = "Aim", Shoulder = "Aim Shoulder";
    public const string Shoot = "Fire1",
        Pick = "Interact",
        Change = "Change",
        Reload = "Reload",
        Drop = "Drop";
}




Unity - Edit - Project Settings... 에 보면 "Input Manager"에 사용 이름들이 정의되어 있습니다. 대소문자 구분되어야 하구요.

"Fire1" 같은 경우 명확한 구분이 안되기 때문에 게임내 "Shoot" 상수로 명확히 구분하여 혼선을 방지하고 있다고 생각하면 됩니다.




PolygonBattleRoyale 폴더는 Polygon Battle Royal Pack을 구매하여 해당 폴더에 설정해 준 것입니다.

강의에서는 꼭 필요한 것들만 사용되었으니 좀더 디테일하게 개발해보고 싶다면 해당 팩을 구매하여 사용하기를 추천합니다.

Tool 제작을 하여 사용하는데 아주 중요한 내용입니다.

Sound Tool, Effect Tool 2개를 만들어 사용할 예정입니다.



 

 

 



리소스 매니저는 리소스들을 적재하여 래핑해 놓은 것입니다.



제작하려는 Effect Tool, Sound Tool 2가지 툴 정보입니다.

+ 상단에는 Add, Copy, Remove를 수행합니다.
+ 좌측에는 요소 목록이 표시됩니다.
+ 우측에는 각 요소의 설정 기능이 표시됩니다.
+ 하단에는 "Reload Settings", "Save Settings" 버튼이 위치합니다.


Effect, Sound Tool도 각각 만드는 것이 아니라 Base Class를 만들고 상속을 통하여 재활용도를 높여서 사용합니다.

해당 기능을 Excel을 이용하는 경우도 많지만 오류/오타 등의 버그가 발생할 수 있고 이는 개발시간이 늘어지는 문제로 연결될 수 있습니다.
이렇듯 Tool을 만들어 놓으면 변환시간도 줄어들고 Unity에서 실행하면서 바로 값 변경을 하여 확인할 수 있기 때문에 결론적으로 개발시간의 단축 및 안정성도 높아진다고 볼 수 있겠습니다.

Simple is Best.. 제 삶의 모토 정한 문장인데.. 여기서 듣네요 ㅎㅎ..



<위의 코드들은 제가 보면서 주요한 함수, 코드를 확인하기 위해 타이핑한 용도로, 전체 소스코드가 아님에 주의해 주세요. 전체 코드는 교육 수강을 하면 완벽하게 받으실 수가 있답니다 ^^>

패스트캠퍼스 - 올인원 패키지 : 유니티 포트폴리오 완성 bit.ly/2R561g0

 

유니티 게임 포트폴리오 완성 올인원 패키지 Online. | 패스트캠퍼스

게임 콘텐츠 프로그래머로 취업하고 싶다면, 포트폴리오 완성은 필수! '디아블로'와 '배틀그라운드' 게임을 따라 만들어 보며, 프로그래머 면접에 나오는 핵심 개념까지 모두 잡아 보세요!

www.fastcampus.co.kr

 

[패스트캠퍼스 수강 후기] 올인원 패키지 : 유니티 포트폴리오 완성 100% 환급 챌린지 28회차 미션 시작합니다.

04. 배틀로얄 - 01, 02 챕터를 진행합니다.





오리엔테이션 시간입니다.




배틀로얄 게임 제작에 들어가기 전에 강사님에 대한 자세한 소개를 해주십니다.

다니셨던 회사들.. 유니티 강의.. 도서 출판.. 온라인 강좌.. 제작 게임 소개..

현업에서도 아낌없이 자료를 공유하는 것으로 유명하셨나 보네요.


 


최종적으로 만들게 될 배틀로얄 게임의 최종 모습입니다.

강의를 하게 된 계기도 소개해 주십니다. 현업에서도 활용가능하고 난이도가 높더라도 실제 개발시 필요한 내용들을 전달하고 싶으셨다고 하시네요.

앞선 강의에서도 보았듯이 현업에서 사용하는 내용들이 많이 나옵니다. 그만큼 어려워 보일 수 있고 오랜 시간동안 누적된 많은 정보량인데 한정된 강의에 넣으려니 얼마나 준비를 많이 하셨을까 싶습니다.



Q&A - 강의를 듣기 전에 미리 알아두어야 할 것들이 있나요?

입문 강의가 아니다보니 유니티 사용법을 하나하나 설명할 수는 없습니다. 배틀로얄 게임을 실제 제작하려고 해도 100~200시간은 걸리기 때문에 한정된 강의 시간에 설명을 모두 하며 제작을 하기는 어렵습니다.

Github 등에서 무료 유니티 게임을 다운받아 C# 소스를 많이 리딩하고, C# 슈팅 게임정도는 제작을 해본 경험이 필요합니다.

 


Q&A - 게임에 사용되는 리소스는 구입해야 하나요?

게임 강의를 위한 최소한의 리소스는 제공되기 때문에 구입할 필요 없습니다. 다만 좀더 풍부한 컨텐츠 제작을 원하거나 게임 제작 배포를 하겠다고 하면 에셋 구매를 하고 개발을 하면 됩니다.




게임 리소스 내려받기

배틀로얄 게임 제작시 최소 80시간은 들어갔다고 하시네요. 하지만 그것도 길기에 20시간 내에 가능하도록 7번이나 소스를 뒤엎으며 준비하셨다고 합니다. ^^~ 좋은 강의를 위한 노력 너무 감사드립니다.

게임 제작에 필수 기초적이면서도 꼭 필요한 사운드, 이펙트들은 게임들간 비슷할 수 있기에 하나하나 상세하게 설명하진 않습니다. 실무적으로 중요한 내용위주로 꼭 집어 설명할 예정입니다.





Git과 Sourcetree에 대해 간략히 설명해 주십니다. 리소스 준비하고 세팅하는데에도 시간이 걸리기 때문에 준비된 프로젝트를 Github에서 다운로드하여 해당 프로젝트에서 게임 개발을 시작하는 것입니다.

그리고 유니티를 설치해야겠지요.. Unity Hub로 다운로드.




Unity Version에 대한 문의가 많아 다른 버전을 설치하는 방법에 대해 설명해주십니다. ^^~

 

LTS : Long Time Service. 오랜 시간동안 서비스될 것이라는 의미. 따라서 장기 게임 프로젝트를 진행한다거나 할 때에는 LTS 버전을 사용하는 것이 안정성의 확보에 도움이 되겠습니다. 


* 알아두어야할 기본 지식
+ 유니티 애니메이션 시스템과 로코모션에 대해
+ 유니티 네비게이션 시스템에 대해

찾아보라고 말씀하시면서 직접 영상을 찾아 간단히 설명도 해주십니다. ㅎㅎ

DefaultAvatar라는 GameObject가 있다면 Animator 컴포넌트에 Avatar, Controller가 꼭 필요하며,
Avatar는 3D Modeling, Controller는 Animation 구동을 위한 데이터라고 생각하면 됩니다.

가장 중요한 건 디아블로 강의에서 배웠던 State 상태가 있고 Transition(이전)이 발생하며 다른 상태로 바뀌며 다른 Animation이 구동되는 시스템입니다.
가만히 있다가 -> 걷다가 -> 달리다가 등의 상태 변경인 것입니다.


마찬가지로 내비게이션 시스템을 위한 NavMesh를 간단히 설명해 주십니다.
이또한 디아블로 강의에서 설명이 있었지요. ㅎㅎ 그래서 강의 순서를 디아블로를 먼저 교육 내용으로 선정한 것 같습니다.


다음시간부터는 이러한 기초 내용을 알고 있다는 전제와 기초 프로젝트를 준비해놓은 상태에서 게임 제작을 시작합니다.





<위의 코드들은 제가 보면서 주요한 함수, 코드를 확인하기 위해 타이핑한 용도로, 전체 소스코드가 아님에 주의해 주세요. 전체 코드는 교육 수강을 하면 완벽하게 받으실 수가 있답니다 ^^>

패스트캠퍼스 - 올인원 패키지 : 유니티 포트폴리오 완성 bit.ly/2R561g0

 

유니티 게임 포트폴리오 완성 올인원 패키지 Online. | 패스트캠퍼스

게임 콘텐츠 프로그래머로 취업하고 싶다면, 포트폴리오 완성은 필수! '디아블로'와 '배틀그라운드' 게임을 따라 만들어 보며, 프로그래머 면접에 나오는 핵심 개념까지 모두 잡아 보세요!

www.fastcampus.co.kr

 

  1. 광고? 2021.01.07 22:10

    광고 ??? 돈받고하는 광고면 광고라 올리셔야 하는거 아닌가요 ?

    • BOOX 2021.01.22 22:54 신고

      돈을 받고 업체에서 제공해주는 문구와 사진을 사용하여 글을 올렸다면 광고겠습니다만..
      해당 유니티 교육은 제 돈을 주고 구입해서 듣고 100% 제가 전부 타이핑하여 작성한 글입니다.
      미션수행을 동반하였기에 동일한 제목과 글 끝에 링크를 넣어두긴 했습니다만, 유니티에 대한 내용을 전달함에 문제가 되지는 않을 것 같습니다. 내돈내산입니다.

[패스트캠퍼스 수강 후기] 올인원 패키지 : 유니티 포트폴리오 완성 100% 환급 챌린지 27회차 미션 시작합니다.

03. Firebase 네트워크 - 05-2, 05-3 챕터를 진행합니다.


지난 시간에 이어 사용자 데이터/저장 불러오기 준비단계입니다.
Newtonsoft Json Library에 대한 소개로 시작합니다.




JsonUtility
  - Unity에 포함된 Json Library를 사용하는 것이 일반적입니다.
  - 최소한의 기능만 제공하고 있지만, Unity만을 위한 Vector serialize와 MonoBehaviour serialize를 제공합니다.
  - MonoBehaviour의 Deserialize는 별도의 제공함수인 FromJsonOverwrite()를 사용해야 합니다.

Newtonsoft Json
  - JsonUtility에서 제공되지 않는 추가적인 Json 기능들을 사용할 수 있는 외부 Library
  - BSON 지원 : Binary JSON
  - MonoBehaviour와 Vector에 대한 지원 클래스가 없으므로 별도로 설정하여 사용 필요.
  
추가적으로 JsonUtility는 Property에 대한 Serialize를 지원하지 않는데, Newtonsoft JSON은 Property Serialize가 동작하게 되므로, Property Json 변환을 원하지 않는다면 설정되지 않도록 Attribute를 설정하는 기능이 필요합니다.




Newtonsoft Json 다운로드 및 설정 방법을 정리하였습니다.

1) 다운로드
2) 압축해제하여 폴더 확인
3) Newtonsoft.Json.dll을 드래그하여 Unity Assets 폴더에 드랍하여 설정하면 됩니다.

여기서는 Newtonsoft Json을 사용하여 진행합니다.



Json 함수에 대한 설명입니다.




Json을 사용하는 테스트를 위해 UI를 미리 구현하였고, 나머지는 기존과 동일하며 [Save User Data] [Load User Data]가 추가되었습니다.
이를 클릭하면 User Data를 불러오고 저장하는 기능을 하게 됩니다.

실제 게임에서는 로그인을 하면 바로 Load User Data를 호출하여 사용자 데이터를 가져오면 되고,
사용자 데이터가 변경될 때마다 Save User Data를 호출하여 Firebase database에 데이터를 저장하는 루틴으로 구성하면 되겠습니다.



스크립트 기능 구현을 시작합니다.


public class PlayerDataHandler : MonoBehaviour
{
    private DatabaseReference databaseRef;
    private string UserDataPath => "users"; // 루트 폴더
    private string StatsDataPath => "stats"; // /users/uid/stats
    private string EquipmentDataPath => "equipment";
    private string InventoryDataPath => "inventory";
    
    public StatsObject playerStats;
    public InventoryObject playerEquipment;
    public InventoryObject playerInventory;
    
    void Start() {
        databaseRef = FirebaseDatabase.DefaultInstance.RootReference;
    }
    
    public void OnClickedSave() {
        var userId = FirebaseAuthManager.Instance.UserId;
        if (userId == string.Empty) return;
        
        string statsJson = playerStats.ToJson();
        databaseRef.Child(UserDataPath).Child(userId).Child(StatsDataPath).SetRawJsonValueAsync(statsJson).ContinueWith(task => {
            if (task.IsCanceled) { Debug.LogError("Save user data was canceled"); return; }
            if (task.IsFaulted) { Debug.LogError("Save user data encountered an error: " + task.Exception); return; }
            Debug.LogFormat("Save user data in successfully: {0} {1}", userId, statsJson);
        }); // users/uid/stats
       
        string equipmentJson = playerEquipment.ToJson();
        databaseRef.Child(UserDataPath).Child(userId).Child(EquipmentDataPath).SetRawJsonValueAsync(equipmentJson).ContinueWith(task => {
            if (task.IsCanceled) { Debug.LogError("Save equipment data was canceled"); return; }
            if (task.IsFaulted) { Debug.LogError("Save equipment data encountered an error: " + task.Exception); return; }
            Debug.LogFormat("Save equipment data in successfully: {0} {1}", userId, equipmentJson);
        });
       
        string inventoryJson = playerInventory.ToJson();
        databaseRef.Child(UserDataPath).Child(userId).Child(InventoryDataPath).SetRawJsonValueAsync(inventoryJson).ContinueWith(task => {
            if (task.IsCanceled) { Debug.LogError("Save inventory data was canceled"); return; }
            if (task.IsFaulted) { Debug.LogError("Save inventory data encountered an error: " + task.Exception); return; }
            Debug.LogFormat("Save inventory data in successfully: {0} {1}", userId, inventoryJson);
        });
    }
    
    public void OnClickedLoad() {
        var userId = FirebaseAuthManager.Instance.UserId;
        if (userId == string.Empty) return;
        
        databaseRef.Child(UserDataPath).Child(userId).Child(StatsDataPath).GetValueAsync().ContinueWith(task => {
            if (task.IsCanceled) { Debug.LogError("Load user data was canceled"); return; }
            if (task.IsFaulted) { Debug.LogError("Load user data encountered an error: " + task.Exception); return; }
            
            DataSnapshot snapshot = task.Result;
            // snapshot.Child(userId).Child(StatsDataPath).Child("level").GetValue .... // Json 미사용시 처리.. ㅋㅋ
            playerStats.FromJson(snapshot.GetRawJsonValue());
            Debug.LogFormat("Load user data in successfully: {0} {1}", userId, snapshot.GetRawJsonValue());
        });
        
        databaseRef.Child(UserDataPath).Child(userId).Child(EquipmentDataPath).GetValueAsync().ContinueWith(task => {
            if (task.IsCanceled) { Debug.LogError("Load equipment data was canceled"); return; }
            if (task.IsFaulted) { Debug.LogError("Load equipment data encountered an error: " + task.Exception); return; }
            
            DataSnapshot snapshot = task.Result;
            playerEquipment.FromJson(snapshot.GetRawJsonValue());
            Debug.LogFormat("Load equipment data in successfully: {0} {1}", userId, snapshot.GetRawJsonValue());
        });
        
        databaseRef.Child(UserDataPath).Child(userId).Child(InventoryDataPath).GetValueAsync().ContinueWith(task => {
            if (task.IsCanceled) { Debug.LogError("Load inventory data was canceled"); return; }
            if (task.IsFaulted) { Debug.LogError("Load inventory data encountered an error: " + task.Exception); return; }
            
            DataSnapshot snapshot = task.Result;
            playerInventory.FromJson(snapshot.GetRawJsonValue());
            Debug.LogFormat("Load inventory data in successfully: {0} {1}", userId, snapshot.GetRawJsonValue());
        });
    }
}



// 기존 게임 개발시 클래스로서 추가된 코드만 작성하였습니다.
public class StatsObject : ScriptableObject
{
    // 기존코드들..
    
    public string ToJson() {
        return JsonConvert.SerializeObject(levelData, Formatting.Indented);
    }
    
    public void FromJson(string jsonString) {
        PlayerLevelData newLevelData = JsonConvert.DeserializeObject<PlayerLevelData>(jsonString);
        Level = newLevelData.level;
        Exp = newLevelData.exp;
    }
}

public class InventoryObject : ScriptableObject
{
    // 기존코드들..
    
    public string ToJson() {
        return JsonConvert.SerializeObject(container, Formatting.Indented);
    }
    
    public void FromJson(string jsonString) {
        Inventory newContainer = JsonConvert.DeserializeObject<Inventory>(jsonString);
        Debug.Log("from json: " + newContainer.slots.Length);
        
        for (int i = 0; i < Slots.Length; i++) {
            Slots[i].UpdateSlot(newContainer.slots[i].item, newContainer.slots[i].amount);
        }
    }
}


이렇든 Json을 사용하면 다층화된 데이터 구조를 가지는 구조 데이터를 간결하게 구현할 수가 있습니다.





이제 Unity 플레이를 하여 로그인하고,
[Save User Data]를 진행하여 다음과 같이 Firebase Database에 저장된 데이터를 확인할 수 있습니다.




마찬가지로 Database 내에서 데이터 정보를 강제로 수정을 하고, 유니티에서 [Load User Data]를 진행하면 변경된 정보를 가져와서 업데이트되는 것을 확인할 수 있습니다.


복잡하고 어려운 듯한 강의였지만,

결론적으로 회원 가입 및 사용자 데이터 관리 등의 복잡한 기능을 해주는 Firebase를 잘 활용하자! 이고..
Json이라는 엄청난 Library를 이용하여 복잡하고 다계층화된 데이터의 접근 처리를 쉽게할 수 있다! 라고 결론지으면 되겠습니다.

오래전에 DataManager라는 동일한 기능을 하는 클래스를 만들어서 썼었는데.. Json을 썼으면 되는 거였네요.. ^^;;; 무지로 인한 고생인거였겠죠.. ㅎㅎ




<위의 코드들은 제가 보면서 주요한 함수, 코드를 확인하기 위해 타이핑한 용도로, 전체 소스코드가 아님에 주의해 주세요. 전체 코드는 교육 수강을 하면 완벽하게 받으실 수가 있답니다 ^^>

패스트캠퍼스 - 올인원 패키지 : 유니티 포트폴리오 완성 bit.ly/2R561g0

 

유니티 게임 포트폴리오 완성 올인원 패키지 Online. | 패스트캠퍼스

게임 콘텐츠 프로그래머로 취업하고 싶다면, 포트폴리오 완성은 필수! '디아블로'와 '배틀그라운드' 게임을 따라 만들어 보며, 프로그래머 면접에 나오는 핵심 개념까지 모두 잡아 보세요!

www.fastcampus.co.kr

 

[패스트캠퍼스 수강 후기] 올인원 패키지 : 유니티 포트폴리오 완성 100% 환급 챌린지 26회차 미션 시작합니다.

03. Firebase 네트워크 - 04-3, 05-1 챕터를 진행합니다.



저번 시간에 이어 LeaderboardController를 구현합니다.
금번 교육 내용만 작성하였습니다.




핵심은 score를 기준으로 데이터를 가져와서 정렬하여 처리하는 것입니다.

public class LeaderboardController : MonoBehaviour
{
    // 기존코드들..
    
    private bool sendUpdatedLeaderboardEvent = false;
    private event EventHandler<LeaderboardArgs> OnUpdatedLeaderboard;
    
    void Update() {
        // 기존 코드들..
        
        if (sendRetrievedScoreEvent) {
            sendRetrievedScoreEvent = false;
            OnRetrievedScore(this, retrievedScoreArgs);
        }
        
        if (sendUpdatedLeaderboardEvent) {
            sendUpdatedLeaderboardEvent = false;
            OnUpdatedLeaderboard(this, new LeaderboardArgs {
                scores = topScores,
                startDate = -1,
                endDate = -1
            });
        }
    }
    
    private bool gettingUserScore = false;
    public int GetUserScore(string userId) {
        gettingUserScore = true;
        databaseRef.Child(AllScoreDataPath) // 해당 Path에서
            .OrderByChild(UserScore.userIdPath) // Id Path 기준
            .StartAt(userId) // 시작부터
            .EndAt(userId) // 끝까지 취합
            .GetValueAsync().ContinueWith(task => {
                if (task.Exception !=) throw task.Exception;
                if (!task.IsCompleted) return;
                
                if (task.Result.Children == 0) {
                    retrievedScoreArgs = new UserScoreArgs(null, string.Format("No Scores for User {0}", userId);
                }
                else {
                    var scores = ParseValidUserScoreRecords(task.Result, -1, -1).ToList(); // 시간 내에 있는지
                    if (scores.Count == 0) {
                        retrievedScoreArgs = new UserScoreArgs(null, string.Format("No Scores for User {0} within time range {1} ~ {2}", userId, startDate, endDate);
                    }
                    else {
                        var orderedScored = scores.OrderBy(score => score.score);
                        var userScore = orderedScored.Last(); // 가장 큰값
                        retrievedScoreArgs = new UserScoreArgs(userScore, userScore.userId + " Retrieved!");
                    }
                }
                
                gettingUserScore = false;
                sendRetrievedScoreEvent = true; // Update에서 Event 발생.
            });
    }
    
    private List<UserScore> ParseValidUserScoreRecords(DataSnapShot snapshot, long startTicks, long endTicks) {
        return snapshot.Children
            .Select(scoreRecord => UserScore.CreateScoreFromRecord(scoreRecord))
            .Where(score => score != null && score.timestamp > startTicks && score.timestamp <= endTicks)
            .Reverse()
            .ToList();
    }
   
    
    private bool gettingTopScores = false;
    private void GetInitialTopScores() {
        gettingTopScores = true;
        var query = databaseRef.Child(AllScoreDataPath).OrderByChild("score");
        query = query.LimitToLast(20); // 20개
        query.GetValueAsync().ContinueWith(task => {
            if (task.Exception != null) { return; } // error
            if (!task.IsCompleted || !task.Result.HasChildren) return; // error
            
            var scores = ParseValidUserScoreRecords(task.Result, -1, -1);
            foreach (var userScore in scores) {
                if (!userScores.Contains(userScore.userId)) { // 기존값 존재하지 않는다면
                    userScores[userScore.userId] = userScore;
                }
                else { // 기존값 존재한다면
                    if (userScores[userScore.userId].score < userScore.score)
                        userScores[userScore.userId] = userScore; // score 갱신
                }
            }
            
            SetTopScores();
        });
    }
    
    private void SetTopScores() {
        topScores.Clear();
        topScores.AddRange(userScores.Values.OrderbyDecending(score => score.score));
        sendUpdatedLeaderboardEvent = true;
        gettingTopScores = false;
    }
}






Canvas에 "Leaderboard Handler"와 "Leaderboard UI Controller"를 Attach 시켰습니다.
플레이를 진행합니다.



화면과 같이 user_id, username, score를 입력하고 [Add] [Get User Score] [Update] 등의 버튼을 클릭하여, 사용자의 Score를 입력, 최대점수 얻기, Score 갱신 등을 테스트할 수 있습니다.

그리고 오른쪽의 [Get Leaderboard]를 클릭하면 최고점수의 user 부터 표시되는 것을 확인할 수 있습니다.

소스코드 예외 사항에 대한 처리는 동영상에는 없지만, 강의 자료에는 포함되어 있으므로 해당 소스를 보면 좀더 파악하기 좋을 것입니다.

여기까지 하여 기본적인 함수들을 이용하여 Leaderboard의 구현이 완료되었습니다.





이제 사용자의 데이터를 저장/불러오기 작업입니다.

firebase의 database 보안규칙

auth = 인증된 사용자 토큰.






권한 규칙을 설정할 수 있습니다.

"규칙 플레이그라운드"를 통해서 읽기/쓰기 권한에 대한 테스트를 해볼 수 있습니다.

인증이 된 경우에만 읽기/쓰기 작업이 되는 것 등을 확인할 수 있습니다.
또한 인증은 되었지만 다른 아이디로 테스트를 하는 경우에도 보안 규칙이 적용되어 에러가 발생하는 것 등을 확인할 수 있습니다.





위의 내용은 데이터 검증과 색인에 대한 내용입니다. 권한 규칙과 비슷해보이지만 다른 내용입니다. ㅎㅎ

.validate - 데이터가 올바른 형식인지 등
.indexOn - 개발상에서는 설정하지 않지만 Release시에는 규모가 커져도 정상 작동하도록 색인화를 하게됨. Database 용량이 많이 켜져도 쿼리 성능을 유지하기 위한 것이라고 보면 되겠습니다.




<위의 코드들은 제가 보면서 주요한 함수, 코드를 확인하기 위해 타이핑한 용도로, 전체 소스코드가 아님에 주의해 주세요. 전체 코드는 교육 수강을 하면 완벽하게 받으실 수가 있답니다 ^^>

패스트캠퍼스 - 올인원 패키지 : 유니티 포트폴리오 완성 bit.ly/2R561g0

 

유니티 게임 포트폴리오 완성 올인원 패키지 Online. | 패스트캠퍼스

게임 콘텐츠 프로그래머로 취업하고 싶다면, 포트폴리오 완성은 필수! '디아블로'와 '배틀그라운드' 게임을 따라 만들어 보며, 프로그래머 면접에 나오는 핵심 개념까지 모두 잡아 보세요!

www.fastcampus.co.kr

 

[패스트캠퍼스 수강 후기] 올인원 패키지 : 유니티 포트폴리오 완성 100% 환급 챌린지 25회차 미션 시작합니다.

03. Firebase 네트워크 - 04-1, 04-2 챕터를 진행합니다.




leaderboard를 구현하려면 역시 Firebase를 설정해 주어야 합니다.

Firebase에는 아직 Unity에 대한 매뉴얼 등의 자료가 충분하지 않아 초반 설정 및 사용에 어려움이 있을 수 있습니다.

Firebase - Database - [Realtime 데이터베이스 만들기]

+ 잠금 모드로 시작 - read / write를 반드시 인증하여야 사용 가능
+ 테스트 모드로 시작 - 누구나 접근이 가능



Realtime 데이터베이스 만들기를 클릭하면 위와 같이 Database가 생성된 것을 확인할 수 있습니다.
현재는 테스트 모드로 진행을 하고 추후 접근 권한 설정은 다시 설명합니다.




이제 Unity에서 Install Package..를 진행하여 dotnet4 - FirebaseDatabase를 설치해줍니다.




FirebaseDatabase의 주요 함수들입니다.

Unity 에디터에서 Database에 접근하여 사용하기 위해 SetEditorDatabaseUrl()을 호출하여 사용하는데 이때 전달해야 하는 URL 정보는 google-services-desktop.json에 저장된 "firebase_url"과 동일해야 합니다.




위와 같이 잘 설정되어 있다면, 해당 URL 정보는 FirebaseApp.DefaultInstance.Options.DatabaseUrl에 저장된다는 내용입니다.



사용되는 함수에 대한 지속 설명입니다.

데이터 읽기, 변경 이벤트 등록, 정렬, 필터링 등 다양한 데이터에 접근하여 사용할 수 있는 함수들이 제공된다고 보면 됩니다.



Unity에서 구현할 Script classes 구조 설명입니다.

+ UserScore - User의 Score값을 저장하는 하나의 단위이며, FirebaseDatabase를 구성하는 한 단위입니다.
+ LeaderboardHandler - topScores 정보를 가지고 있고, Thread based 함수를 사용하여 Firebase Database에 접근합니다.
   또한 Firebase의 Database에는 사용자 순위 정보가 시간순으로 되어 있기 때문에 LeaderboardHandler에서 순위별 정렬 등도 처리합니다.


스크립트들을 구현합니다.

[Serializable]
public class UserScore_New
{
    public static string userIdPath = "user_id";
    public static string userNamePath = "username";
    public static string scorePath = "score";
    public static string timestampPath = "timestamp";
    public static string otherDataPath = "data";
    
    public string userId;
    public string userName;
    public long score;
    public long timestamp;
    public Dictionary<string, object> otherData;
    
    public UserScore_New(string userId, string userName, long score, long timestamp, Dictionary<string, object>otherData = null) {
        this.userId = userId;
        this.userName = userName;
        this.score = score;
        this.timestamp = timestamp;
        this.otherData = otherData;
    }
   
    // Firebase에서 전달받은 Record로 처리
    public UserScore_New(DataSnapshot record) {
        // record는 database 처리의 한 단위
        userId = record.Child(userIdPath).Value.ToString();
        if (record.Child(userNamePath).Exists) userName = record.Child(userNamePath).Value.ToString();
        long score;
        if (Int64.TryParse(record.Child(scorePath).Value.ToString(), out score)) this.score = score;
        else this.score = Int64.MinValue;
        long timestamp;
        if (Int64.TryParse(record.Child(timestampPath).Value.ToString(), out timestamp)) this.timestamp = timestamp;
        if (Int64.TryParse(record.Child(otherDataPath).Exists && record.Child(otherDataPath).HasChildren) {
            this.otherData = new Dictionary<string, object>();
            foreach (var keyValue in record.Child(otherDataPath).Children) {
                otherData[keyValue.Key] = keyValue.Value;
            }
        }
    }
    
    public static UserScore CreateScoreFromRecord(DataSnapshot record) {
        if (record == null) { Debug.LogWarning("Null DataSnapshot record in UserScore.CreateScoreFromRecord"); return null; }
        if (record.Child(userIdPath).Exists && record.Child(scorePath).Exists && record.Child(timestampPath).Exists) {
            return new UserScore(record);
        }
        Debug.ogWarning("Invalid record format in UserScore.CreateScoreFromRecord");
        return null;
    }
    
    // json to dictionary
    public Dictionary<string, object> ToDictionary() {
        return new Dictionary<string, object>() {
            {userIdPath, userId },
            {userNamePath, userName },
            {scorePath, score },
            {timestampPath, timestamp },
            {otherDataPath, otherData }
        };
    }
}




public static class FirebaseInitializer_New
{
    private static List<Action<DependencyStatus>> initializeCallbacks = new List<Action<DependencyStatus>>();
    private static DependencyStatus dependencyStatus;
    
    private static bool initialized = false;
    private static bool fetching = false;
    private static bool activateFetch = false;
    
    public static void Initialize(Action<DependencyStatus> callback) {
        lock (initializeCallbacks) {
            if (initialized) {
                callback(DependencyStatus);
                return;
            }
            
            initializeCallbacks.Add(callback);
            FirebaseApp.CheckAndFixDependenciesAsync().ContinueWith(task => {
                lock (initializeCallbacks) {
                    dependencyStatus = task.Result;
                    initialized = true;
                    CallInitializedCallbacks();
                }
            });
        }
    }
    
    private static void CallInitializedCallbacks() {
        lock (initializeCallbacks) {
            foreach (var callback in initializeCallbacks) {
                callback(dependencyStatus);
            }
            initializeCallbacks.Clear();
        }
    }
}





public class UserScoreArgs: EventArgs
{
    // User 1명에 대한 읽기, 쓰기 이벤트
    public UserScore score;
    public string message;
    public UserScoreArgs(UserScore score, string message) {
        this.score = score;
        this.message = message;
    }
}
public class LeaderboardArgs: EventArgs
{
    // User Score에 대한 읽기, 쓰기 이벤트
    pubic DataTime startDate;
    public DataTime endDate;
    public List<UserScore> scores;
}
public class LeaderboardController : MonoBehaviour
{
    private bool initialized = false;
    private bool readytoInitialize = false;
    private DatabaseReference = databaseRef;
    public string AllscoreDataPath => "all_scores"; // Firebase의 root
    
    pubic event EventHandler OnInitialized;
    
    private bool addingUserScore = false;
    private bool sendAddedScoreEvent = false;
    private UserScoreArgs addedScoreArgs;
    private event EventHandler<UserScoreArgs> OnAddedScore;
    
    privte void Start() {
        FirebaseInitializer_New.Initialize(dependencyStatus => {
            if (dependencyStatus == Firebase.DependencyStatus.Available) {
                readytoInitialize = true;
                InitializeDatabase();
            }
            else
                Debug.LogError("Could not resolve all Firebase dependencies: " + dependencyStatus);
        });
    }
   
    private void InitializeDatabase() {
        if (initialized) return;
        FirebaseApp app = FirebaseApp.DefaultInstance;
        if (app.Options.DatabaseUrl != null)
            app.SetEditorDatabaseUrl(app.Options.DatabaseUrl);
        databaseRef = FirebaseDatabase.DefaultInstance.RootReference;
        initialized = true;
        readytoInitialize = false;
        OnInitialized(this, null);
    }
    
    void Update() {
        if (sendAddedScoreEvent) { // user가 점수 쓰기 완료.
            sendAddedScoreEvent = false;
            OnAddedScore(this, addedScoreArgs);
        }
    }
   
    public Task AddScore(string userId, string userName, int score, long timestamp = 1L, Dictionary<string, object> otherData = null) {
        if (timestamp <= 0) timestamp = DateTime.UtcNow.Ticks / TimeSpan.TicksPerSecond; // Unity TactTime -> Unix TactTime
        
        var userScore = new UserScore(userId, userName, score, timestamp, otherData);
        return AddScore(userScore);
    }
   
    pubic Task<UserScore> AddScore(UserScore userScore) {
        if (addingUserScore) { Debug.LogError("Running add user score task!"); return null; }
        
        var scoreDictionary = userScore.ToDictionary();
        addingUserScore = true;
        
        return Task.Run(() => {
            var newEntry = databaseRef.Child(AllscoreDataPath).Push();
            return newEntry.SetValueAsync(scoreDictionary).ContinueWith(task => {
                if (task.Exception != null) { Debug.LogWarning("Exception adding score: " + task.Exception); return null; }
                if (!task.IsCompleted) { return null; }
                addingUserScore = false;
                addedScoreArgs = new UserScoreArgs(userScore, userScore.userId + " Added!");
                sendAddedScoreEvent = true;
                return userScore;
            }).Result;
        });
    }
    
    private bool gettingUserScore = false;
    public int GetUserScore(string userId) {
        gettingUserScore = true;
        databaseRef.Child(AllscoreDataPath)
            .OrderByChild(UserScore.userIdPath)
            .StartAt(userId)
            .EndAt(userId)
            .GetValueAsync().ContinueWith(task => {
                if (task.Exception !=) throw task.Exception;
                if (!task.IsCompleted) return;
            });
    }
}


오늘도 어려운 내용을 후루룩 머리속에 집어넣느라고 굳은 머리가 고생하네요.
이거 초기에 설정잡고 연동하고, 이벤트 처리 로직 등 할 때에는 고생했을 것 같네요 ㅠ.
잘 된 구조를 만들어 주셨으니 잘 가져다 쓰면 되겠습니다. ㅎㅎ





Firebase내 Database에 저장된 데이터의 구조입니다.


다음 시간에 leaderboard 마무리 및 사용자 데이터 처리에 대해 진행합니다.




<위의 코드들은 제가 보면서 주요한 함수, 코드를 확인하기 위해 타이핑한 용도로, 전체 소스코드가 아님에 주의해 주세요. 전체 코드는 교육 수강을 하면 완벽하게 받으실 수가 있답니다 ^^>

패스트캠퍼스 - 올인원 패키지 : 유니티 포트폴리오 완성 bit.ly/2R561g0


 

유니티 게임 포트폴리오 완성 올인원 패키지 Online. | 패스트캠퍼스

게임 콘텐츠 프로그래머로 취업하고 싶다면, 포트폴리오 완성은 필수! '디아블로'와 '배틀그라운드' 게임을 따라 만들어 보며, 프로그래머 면접에 나오는 핵심 개념까지 모두 잡아 보세요!

www.fastcampus.co.kr

 

[패스트캠퍼스 수강 후기] 올인원 패키지 : 유니티 포트폴리오 완성 100% 환급 챌린지 24회차 미션 시작합니다.

03. Firebase 네트워크 - 02, 03 챕터를 진행합니다.




Firebase 설정하기

1. Firebase에 가입하기

기본 Spark 무료 요금제이며, 실시간 데이터베이스의 사용량이 늘어나면 사용 제한이 걸리는 방식. Blaze 유료 종량제도 10G 까지는 과금되지 않음.




2. 프로젝트 추가하기.

콘솔로 이동 - 사용중인 프로젝트 목록이 나옵니다.

프로젝트를 "FastCampusDev"라는 이름으로 생성합니다. Google 애널리틱스 구성도 사용으로 하고, 다른 것들은 기본으로 하여 생성합니다.





3. 앱 추가하기: Unity -> Android

관리 메인 화면에서 "Unity" 앱 생성을 클릭하여 사용할 앱을 등록합니다.

"[v] Register as Android app"을 선택하고 Android 패키지 이름을 "comfastcampusdev.firebase"라고 작성합니다.
앱 닉네임은 "FastCampus Android Firebase"라고 작성합니다.





4. 구성 파일 다운로드

Firebase 콘솔에서도 다시 다운로드 가능합니다. 다운로드 파일을 Unity의 "Assets"에 적용하라는 안내도 보여주고 있네요.

 


google-services.json 파일을 다운로드 하고 편집기에서 열어서 살펴봅니다.


firebase_url이 중요합니다. firebase_url을 이용하여 database나 cloud storage등을 접근하여 사용하게 됩니다.
storage_bucket은 cloud storage에 파일 접근을 할 수 있게 해주는 주소입니다. 밑에 내용들은 Mobile에서 사용되는 Client 관련 정보라고 보면 됩니다.



해당 파일을 Unity Project의 "Assets"에 추가하여 줍니다.




5. Firebase SDK 다운로드

마찬가지로 Firebase Console에서 언제든 다운로드 가능합니다.




위의 그림과 같이 사용자 인증 설정하기를 진행해 주어야 합니다.

이메일/비밀번호, 전화, Google, Play게임, 게임 센터, Facebook, Twitter, GitHub, Yahoo, Microsoft, Apple, 익명 등 다양한 방법의 로그인을 제공합니다. 대단합니다. 항상 반복적으로 개발해와야 했던 내용이었 것만... 어느 반복이 너무 싫은 천재 개발자의 아이디어에서 시작된 것 같네요..

여기서는 테스트를 위해 "이메일/비밀번호" 방식을 "사용 설정"으로 변경하고 진행합니다.



Unity SDK 설치하기입니다.

Unity 상단 메뉴의 "Assets - Import Package - Custom Package..."를 클릭하여 Import 탐색기 다이알로그가 나타납니다.

여기서 아까 다운받은 firebase_unity_sdk_x.xx.x 폴더로 이동하면 dotnet3, dotnet4 폴더를 볼 수 있고, dotnet4로 진입합니다.

꼭 설치해야 하는 것은 FirebaseAnalytics입니다. 해당 기본 패키지를 설치합니다.

그리고 사용자 인증을 진행할 것이기 때문에 FirebaseAuth 패키지도 설치해줍니다.




사용자 인증 관련 주요 함수들입니다.

Singleton Pattern으로 구현되어 있기 때문에 DefaultInstance를 가져다가 사용하면 됩니다.

StreamingAssets 폴더에 google-services-desktop 파일이 생성되어 있다면 잘 된 것입니다.





Unity에서 사용할 Login UI입니다. 시간 관계상 구성된 상태로 진행합니다.

Email & Password 방식으로 로그인하고, 신규 가입이나 로그아웃 버튼 등이 추가된 상태입니다.


이제 인증을 위한 스크립트를 생성합니다.

public class FirebaseAuthController
{
    // Singletone
    private static FirebaseAuthController instance = null;
    public static FirebaseAuthController Instance {
        get {
            if (instance == null) instance = new FirebaseAuthController();
            return instance;
        }
    }
    
    private FirebaseAuth auth;
    private FirebaseUser user;
    
    private string displayName;
    private string emailAddress;
    private Uri photoUrl;
    
    public string UserId => user?.UserId ?? string.Empty;
    public string DisplayName => displayName;
    public string EmailAddress => emailAddress;
    public Uri PhotoUrl => photoUrl;
    
    public Action<bool> OnChangedLoginState;
    
    public void InitializeFirebase() {
        auth = FirebaseAuth.DefaultInstance;
        auth.StateChanged += OnAuthStateChanged;
        OnAuthStateChanged(this, null);
    }
    
    public void CreateUser(string email, string password) {
        auth.CreateUserWithEmailAndPasswordAsync(email, password).ContinueWith(task => {
            if (task.IsCanceled) { Debug.LogError("CreateUserWithEmailAndPasswordAsync was canceled."); return; }
            if (task.IsFaulted) { // 에러 발생된 경우 처리
                Debug.LogError("CreateUserWithEmailAndPasswordAsync encountered an error: " + task.Exception);
                int errorCode = GetFirebaseErrorCode(task.Exception);
                switch (errorCode) {
                case (int)AuthError.EmailAlreadyInUse:
                    Debug.LogError("Email Already In Use");
                    break;
                case (int)AuthError.InvalidEmail:
                    Debug.LogError("Invalid Email");
                    break;
                case (int)AuthError.WeakPassword:
                    Debug.LogError("Weak Password");
                    break;
                }
                return;
            }
            
            FirebaseUser newUser = task.Result; // 성공 결과
            Debug.LogFormat("Frebase user created successfully: {0} ({1})", newUser.DisplayName, newUser.UserId);
        });
    }
    
    public void SignIn(string email, string password) {
        auth.SignInWithEmailAndPasswordAsync(email, password).ContinueWith(task => {
            if (task.IsCanceled) { Debug.LogError("SignInWithEmailAndPasswordAsync was canceled."); return; }
            if (task.IsFaulted) { // 에러 발생된 경우 처리
                Debug.LogError("SignInWithEmailAndPasswordAsync encountered an error: " + task.Exception);
                int errorCode = GetFirebaseErrorCode(task.Exception);
                switch (errorCode) {
                case (int)AuthError.WrongPassword:
                    Debug.LogError("Wrong Password");
                    break;
                case (int)AuthError.UnverifiedEmail:
                    Debug.LogError("Unverified Email");
                    break;
                case (int)AuthError.InvalidEmail:
                    Debug.LogError("Invalid Email");
                    break;
                }
                return;
            }
            
            FirebaseUser newUser = task.Result; // 성공 결과
            Debug.LogFormat("Frebase user signed in successfully: {0} ({1})", newUser.DisplayName, newUser.UserId);
        });
    }
    
    public void SignOut() {
        auth.SignOut();
    }
    
    // Firebase의 exception id 가져오기
    private int GetFirebaseErrorCode(AggregateException exception) {
        FirebaseException firebaseException = null;
        foreach (Exception e in exception.Flatten().InnerExceptions) {
            firebaseException = e as FirebaseException; // Firebase Exception인 경우만 처리
            if (firebaseException != null) break;
        }
        return firebaseException?.ErrorCode ?? 0;
    }
   
    private void OnAuthStateChanged(object sender, EventArgs eventArgs) {
        if (auth.CurrentUser != user) {
            bool signedIn = (user != auth.CurrentUser && auth.CurrentUser != null);
            if (!signedIn && user != null) {
                Debug.Log("Signed out: " + user.UserId);
                OnChangedLoginState?.Invoke(false); // 로그아웃 이벤트 전달
            }
            
            user = auth.CurrentUser;
            if (signedIn) {
                Debug.Log("Signed in: " + user.UserId);
                displayName = user.DisplayName ?? string.Empty;
                emailAddress = user.Email ?? string.Empty;
                photoUrl = user.PhotoUrl ?? null;
                OnChangedLoginState?.Invoke(true); // 로그인 이벤트 전달
            }
        }
    }
}



public class FirebaseAuthUIController : MonoBehaviour
{
    public TMP_InputField emailInputField;
    public TMP_InputField passwordInputField;
    public TMP_Text outputText;
    
    void Start() {
        FirebaseAuthController.Instance.OnChangedLoginState += OnChangedLoginState;
        FirebaseAuthController.Instance.InitializeFirebase();
    }
    
    public void CreateUser() {
        string email = emailInputField.text;
        string password = passwordInputField.text;
        FirebaseAuthController.Instance.CreateUser(email, password);
    }
    
    public void SignIn() {
        string email = emailInputField.text;
        string password = passwordInputField.text;
        FirebaseAuthController.Instance.SignIn(email, password);
    }
    
    public void SignOut() {
        FirebaseAuthController.Instance.SignOut();
    }
    
    private void OnChangedLoginState(bool signedIn) {
        outputText.text = signedIn ? "Signed in: " : "Signed out: ";
        outputText.text += FirebaseAuthController.Instance.UserId;
    }
}





Unity Canvas에서 위와 같이 설정해 줍니다.




Unity 플레이를 진행하여 시작합니다.

eMail과 Password를 입력하고 "Create User"를 클릭하면 "Signed in: qFNEYxxxxxxxx"라는 사용자 아이디를 볼 수가 있는데, Hash 암호화가 되어 있기 때문에 특수 문자열처럼 표시되었습니다.



Firebase Console로 접근하여 보면 생성된 계정 정보를 확인할 수 있습니다.

그리고 동일 Email 생성 에러 및 암호 에러 등의 테스트를 진행해보면 Firebase를 통한 로그인 시스템이 정상적으로 잘 동작함을 확인할 수 있습니다.

 

회원 가입 및 로그인 등의 시스템이 간단하던 시절에는 개발시 문제가 되지 않았지만 지금처럼 연동 로그인이나 보안 등 복잡한 시스템이 되어가면서는 간단하지 않은 시스템이 되어 고민하게되는 부분이 많게 되는데, 이처럼 자동화되니 참 좋은 세상이네요. 물론 사용량에 따라 돈을 내야할 수 있겠지만 말이지요. ㅎㅎ





<위의 코드들은 제가 보면서 주요한 함수, 코드를 확인하기 위해 타이핑한 용도로, 전체 소스코드가 아님에 주의해 주세요. 전체 코드는 교육 수강을 하면 완벽하게 받으실 수가 있답니다 ^^>

패스트캠퍼스 - 올인원 패키지 : 유니티 포트폴리오 완성 bit.ly/2R561g0

 

유니티 게임 포트폴리오 완성 올인원 패키지 Online. | 패스트캠퍼스

게임 콘텐츠 프로그래머로 취업하고 싶다면, 포트폴리오 완성은 필수! '디아블로'와 '배틀그라운드' 게임을 따라 만들어 보며, 프로그래머 면접에 나오는 핵심 개념까지 모두 잡아 보세요!

www.fastcampus.co.kr

 

[패스트캠퍼스 수강 후기] 올인원 패키지 : 유니티 포트폴리오 완성 100% 환급 챌린지 23회차 미션 시작합니다.

02. 디아블로 게임 - 41 챕터를 마무리하고,
03. Firebase 네트워크 - 01 챕터를 새롭게 시작합니다.





디아블로 게임의 마지막입니다. 문과 함정을 구현합니다.
스크립터블을 사용한 이벤트 오브젝트를 설명하기 위해 조금 복잡하더라도 이 구조를 선택하였습니다.

DoorTriggerArea는 문 근처 영역에 있을 때 트리거를 발생시킵니다.
DoorController는 문 애니메이션을 보여주는 GameObject입니다.



public class DoorController_New : MonoBehaviour
{
    public DoorEventObject_New doorEventObject;
    public int id = 0;
    public float openOffset = 4f; // 문이 열렸을 때 위로 올라가는 위치
    public float closeOffset = 1f;
    
    private void OnEnable() {
        doorEventObject.OnOpenDoor += OnOpenDoor;
        doorEventObject.OnCloseDoor += OnCloseDoor;
    }
    
    private void OnDisable() {
        doorEventObject.OnOpenDoor -= OnOpenDoor;
        doorEventObject.OnCloseDoor -= OnCloseDoor;
    }
    
    public void OnOpenDoor(int id) {
        if (id != this.id) return;
        StopAllCoroutines();
        StartCoroutine(OpenDoor());
    }
    
    public void OnOpenDoor(int id) {
        if (id != this.id) return;
        StopAllCoroutines();
        StartCoroutine(CloseDoor());
    }
    
    public IEnumerator OpenDoor() { // 애니메이션
        while (transform.position.y < openOffset) {
            Vector3 calcPosition = transform.position;
            calcPosition.y += 0.01;
            transform.position = calcPosition;
            yield return null;
        }
    }
    
    public IEnumerator CloseDoor() {
        while (transform.position.y < closeOffset) {
            Vector3 calcPosition = transform.position;
            calcPosition.y -= 0.01;
            transform.position = calcPosition;
            yield return null;
        }
    }
}




[CreateAssetMenu(fileName = "Event System", menuName = "Event System/Door Event Object_New")]
public class DoorEventObject_New : ScriptableObject
{
    [NonSerialized]
    public Action<int> OnOpenDoor;
    [NonSerialized]
    public Action<int> OnCloseDoor;
    
    public void OpenDoor(int id) {
        OnOpenDoor?.Invoke();
    }
    
    public void CloseDoor(int id) {
        OnCloseDoor?.Invoke();
    }
}




public class DoorTriggerArea_New : MonoBehaviour
{
    public DoorEventObject_New doorEventObject;
    public DoorController_New doorController;
    public bool autoClose = true;
    
    private void OnTriggerEnter(Collider other) {
        doorEventObject.OpenDoor(doorController.id);
    }
    
    private void OnTriggerExit(Collider other) {
        doorEventObject.CloseDoor(doorController.id);
    }
}





주황색 박스를 문이라고 설정한 상태입니다. 내부 Mesh Obstacle로 지정. DoorController_New를 추가.




유니티를 플레이하여 2개의 박스가 문처럼 잘 동작하는 것을 확인할 수 있으며,
AutoClose를 false로 하여 테스트하면 문이 열리고 다시 닫히지 않는 오브젝트로 잘 동작하는 것을 확인할 수 있습니다.



함정은 해당 GameObject가 Collider가 발생하였을 때 Character에 Damage를 발생시키는 간단한 로직입니다.


public class TrapController_New : MonoBehaviour
{
    public float damageInterval = 0.5f; // 몇초간격 반복 데미지 interval 시간
    public float damageDuration = 5f; // 몇초간 대기
    public int damage = 5;
    private float calcDuration = 0.0f;
    
    [SerializeField]
    private ParticleSystem effect;
    private IDamagable damagable;
    
    private void Update() {
        if (damagable != null) calcDuration -= Time.deltaTime;
    }
    
    private void OnTriggerEnter(Collider other) {
        damagable = other.GetComponent<IDamagable>();
        if (damagable != null) {
            calcDuration = damageDuration;
            effect.Play();
            StartCoroutine(ProcessDamage();
        }
    }
    
    private void OnTriggerExit(Collider other) {
        damagable = null;
        StopAllCoroutines();
        effect.Stop();
    }
    
    IEnumerator ProcessDamage() {
        while (calcDuration > 0 && damagable != null) {
            damagable.TakeDamage(damage, null);
            yield return new WaitForSeconds(damageInterval);
        }
        
        damagable = null;
        effect.Stop();
    }
}




함정에 대한 Unity 설정입니다.





플레이를 해봅니다. 초록색 박스 Collider에 진입하면 1초마다 데미지를 입게 됩니다. 5초후 꺼지고 다시 데미지를 발생합니다.


여기까지 RPG 액션 게임을 구현하는 방법에 대한 중요한 시스템에 대한 설명이 완료되었습니다.
강의를 위한 자료 특히 설명해야할 것이 많은 자료는 정리하여 준비하기가 정말 힘든데.. 잘 정리해 주셨네요.
자료 준비하느라 힘드셨을 듯합니다. 감사합니다.










이제 Firebase에 대한 강의를 시작합니다.
Firebase backend system과 NoSQL 등 실제 게임 제작시에 어떻게 구성하고 활용하는지 교육합니다.
김영민 강사님이 지속 알려주시네요 ^^~





+ Firebase 소개: Firebase에 대해 설명을 하고, 특히 게임 내에서 사용되는 부분을 집중하여 안내할 예정.
+ Firebase 설정
+ 사용자 인증 구현
+ 사용자 순위(leaderboard) 구현 - Real-time 게임 순위
+ 사용자 데이터 저장/불러오기



 

 


Firebase는 BaaS를 제공하는 스타트업 회사로 2014년도에 구글에 인수되었다고 합니다. 와우.. 대단합니다.
게다가 Twitter의 Febric이라는 BaaS 시스템도 구글에 인수되어 Firebase에 통합되고 있다고 합니다..

서버 개발이 필요없다니(???) 와우.. 이..럴..수..가..있..나..?
사용하는 방법을 진짜 봐야겠네요.. Firebase 설정만 하면 된다는 것 같은데 말이죠.. 획기적이네요.
C++ API도 제공된다고 합니다.

단점도 알아봐야겠지요? 유니티에서 게임을 개발하는 단계에서의 단점은..
Desktop 기반의 플랫폼을 지원하지 않습니다. 음.. 저에게는 아쉽네요. 현재 Desktop 기반에서 Unity를 활용하는 것에 초점을 맞추어 보려 하고 있는데 말입니다. Unity 게임 개발 중간에 SDK를 활용해서 테스트를 할 수는 있지만 Desktop이나 MacOS용 게임을 배포하려고 하면 지원이 되지 않는 것입니다.
이를 해결하기 위한 방법으로 중간 웹서비스에 대한 API를 거쳐서 활용하는 방법이 있다고 합니다. 추후 알아봐야겠습니다.

두번째 주의점으로는 유저가 기하급수적으로 늘어나는 경우 자체 구축 서버 시스템보다 유지보수 비용이 많이 증가할 수 있는 단점이 있습니다.

하지만 Firebase를 통해서 BaaS에 대한 기본 개념을 알아보기 쉽고, 중소기업이하 소규모 개발사에서는 기간, 비용 등이 단축될 수 있기 때문에 적극 추천하는 바입니다.




+ Authentication: 기본적으로 구글 연동 로그인 시스템 등을 지원합니다.
+ Database: Realtime과 Cloud 모두 NoSQL기반. Realtime Database는 JSON 구조 저장. Cloud는 데이터를 문서 컬렉션 단위로 저장.
  Cloud의 장점은 복잡한 계층적인 데이터나 추출 쿼리의 복잡성도 해결가능함.

  대신 단순 구조 시스템은 Realtime이 빠름.
+ Cloud Functions: Javascript, Typescript 등의 처리.
+ Hosting: 웹호스팅 서비스. 인앱결제 등. 턴-방식 게임에서도 사용 가능.

+ Google Analytics: 접속 정보 통계 분석. 인앱결제 통계. 특정 스테이지 분석 등.
+ Crashlytics: 앱의 Crash 지점 분석.
+ Cloud Messaging: Push 알림
+ Remote Config:

여기까지 Firebase의 많은 기능들중 게임 개발시 도움이 될만한 내용에 대한 정리입니다.






<위의 코드들은 제가 보면서 주요한 함수, 코드를 확인하기 위해 타이핑한 용도로, 전체 소스코드가 아님에 주의해 주세요. 전체 코드는 교육 수강을 하면 완벽하게 받으실 수가 있답니다 ^^>

패스트캠퍼스 - 올인원 패키지 : 유니티 포트폴리오 완성 bit.ly/2R561g0

 

유니티 게임 포트폴리오 완성 올인원 패키지 Online. | 패스트캠퍼스

게임 콘텐츠 프로그래머로 취업하고 싶다면, 포트폴리오 완성은 필수! '디아블로'와 '배틀그라운드' 게임을 따라 만들어 보며, 프로그래머 면접에 나오는 핵심 개념까지 모두 잡아 보세요!

www.fastcampus.co.kr

 

[패스트캠퍼스 수강 후기] 올인원 패키지 : 유니티 포트폴리오 완성 100% 환급 챌린지 22회차 미션 시작합니다.

02 디아블로 게임 - 39. 40 챕터를 진행합니다.

 


NPC와의 대화를 위한 Dialog System 구현입니다.


* Dialogue -> DialogManager에게 내용 전달하면 -> DialogUI에 표시
+ Name - 대화 이름
+ Sentences - 대화 내용


[Serializable]
public clas Dialogue_New
{
    public string name; // NPC 이름
    
    [TextArea(3, 10)]
    public string[] sentences; // 대화문장 배열
}



public class DialogueManager_New : MonoBehaviour
{
    private static DialogueManager_New instance; // Singleton Pattern
    public static DialogManager_New Instance = >instance;
    public Text nameText;
    public Text dialogueText;
    public Animator animator = null;
    private Queue<string> sentences;
    public event Action OnStartDialogue; // 다이알로그 시작 이벤트
    public event Action OnEndDialogue; // 다이알로그 종료 이벤트
    
    private void Awake() {
        instance = this;
    }
    
    void Start() {
        sentences = new Queue<string>();
    }
    
    public void StartDialogue(Dialogue_New dialogue) {
        OnStartDialogue?.Invoke();
        animator?.SetBool("IsOpen", true);
        nameText.text = dialogue.name;
        sentences.Clear();
        foreach (string sentence in dialogue.sentences) {
            sentences.Enqueue(sentence);
        }
        DisplayNextSentence();
    }
    
    public void DisplayNextSentence() {
        if (sentences.Count == 0) { EndDialogue(); return; }
        string sentence = sentences.Dequeue();
        StopAllCoroutines();
        StartCoroutine(TypeSentence(sentence));
    }
    
    public IEnumerator TypeSentence(string sentence) {
        dialogueText.text = string.Empty;
        yield return new WaitForSeconds(0.25f); // 애니메이션 완료 대기
        foreach (char letter in sentence.ToCharArray()) {
            dialogueText.text += letter; // 하나하나 문자로 찍히는 효과
            yield return null;
        }
    }
    
    pubic void EndDialogue() {
        animator?.SetBool("IsOpen", false);
        OnEndDialogue?.Invoke();
    }
}


 



자료 구조인 Queue와 Stack에 대한 설명도 간단히 해주십니다.
Queue : First Input First Out -> 먼저 넣은 것부터 뽑아서 사용.
Stack : First Input Last Out -> 먼저 넣은 것을 제일 마지막에 사용.

 

 

 


해당 대화 구현을 위한 DialogBox GameObject Unity 구성 화면입니다.

Continue 버튼으로 다음 문장을 진행. DisplayNextSentence()를 호출합니다.


이를 사용하는 DialogueNPC를 구현합니다.

public class DialogueNPC_New : MonoBehaviour, IInteractable
{
    [Serializable]
    Dialogue dialogue;
    
    bool isStartDialogue = false;
    GameObject interactGO;
    
    [SerializeField]
    float distance = 2.0f;
    public float Distance => distance;
    
    public void Interact(GameObject other) {
        float calcDistance = Vector3.Distance(other.transform.position, transform.position);
        if (calcDistance > distance) return;
        if (isStartDialogue) return;
        interactGO = other;
        DialogueManager_New.Instance.OnEndDialogue += OnEndDialogue;
        isStartDialogue = true;
        
        DialogueManager_New.Instance.StartDialogue(dialogue);
    }
    
    public void StopInteract(GameObject other) {
        isStartDialogue = false;
    }
    
    private void OnEndDialogue() {
        StopInteract(interactGO);
    }
}


 



Unity에서의 NPC 구성 화면입니다.
Sentences 3개를 넣어서 동작 테스트를 해보도록 합니다.





대화상대를 우클릭하면 대화 상대에게 이동을 하고 distance 거리내로 다가가게 되면 StartDialogue()를 시작으로 첫번째 문장이 표시됩니다.
[Continue] 버튼을 클릭하면 다음 문장을 보여주고 마지막 문장이 완료되면 EndDialogue()로 사라지는 애니메이션이 구동되어 없어집니다.




이제 Quest System을 구현해 보도록 하겠습니다.

QuestObject는 ScriptableObject를 상속받아 구현합니다.

QuestStatus
+ None: X
+ Accepted: 퀘스트 수락
+ Completed: 퀘스트 완료
+ Rewarded: 퀘스트 보상 완료



public enum QuestType_New {
    DestroyEnemy,
    AcquireItem,
}
[Serializable]
public class Quest_New
{
    public int id;
    public QuestType_New type;
    public int targetID; // 적의 정보
    public int count; // 적의 수
    public int completedCount;
    pubic int rewardExp;
    public int rewardGold;
    public int rewardItemId;
    public string title;
    public string description;
}



pubic enum QuestStatus {
    None,
    Accepted,
    Completed,
    Rewarded,
}
[CreateAssetMenu(filename = "New Quest", menuName = "Quest System/Quests/New Quest_New")]
public class QuestObject_New : ScriptableObject
{
    public Quest_New data = new Quest_New();
    public QuestStatus_New status;
}



[CreateAssetMenu(fileName = "Quest Database", menuName = "Quest System/Quests/New Quest Database")]
public class QuestDatabaseObject_New : ScriptableObject
{
    public QuestObject_New[] questObjects;
    
    public void OnValidate() {
        for (int index = 0; index < questObjects.Length; index++) {
            questObjects[index].data.id = index;
        }
    }
}






Quest를 2가지 추가하였고, 2가지 퀘스트를 구성하였습니다.
첫번째는 적을 잡아와라, 두번째는 특정 아이템을 구해오라는 퀘스트로 구성하였습니다.



public class QuestManager_New : MonoBehaviour
{
    private static QuestManager_New instance;
    public static QuestManager_New Instance => instance;
    public QuestDatabaseObject_New questDatabase;
    public event Action<QuestObject_New> OnCompletedQuest;
    
    private void Awake() {
        instance = this;
    }
   
    public void ProcessQuest(QuestType_New type, int targetId) {
        foreach (QuestObject_New questObject in questDatabase.questObjects) {
            if (questObject.status == QuestStatus.Accepted && questObject.data.type == type &&

                questObject.data.targetId == targetId) {
                questObject.data.completedCount++;
                if (questObject.data.completedCount >= questObject.data.count) {
                    questObject.status = QuestStatus.Completed;
                    OnCompletedQuest?.Invoke(questObject);
                }
            }
        }
    }
}



public class QuestNPC_New : MonoBehaviour, IInteractable
{
    public QuestObject questObject;
    public Dialogue readyDialogue; // 퀘스트 준비
    public Dialogue acceptedDialogue; // 이미 수락된 경우
    public Dialogue completedDialogue; // 완료된 퀘스트
    bool isStartQuestDialogue = false;
    GameObject interactGO = null;
    
    void Start() {
        QuestManager_New.Instance.OnCompletedQuest += OnCompletedQuest;
    }
    
    
    // IInteractable 관련 구현은 DialogueNPC_New와 거의 유사하므로 복사하여 수정.
}


그리고 EnemyController_Range에서 TakeDamage()가 발생할 때 적이 죽는 타이밍 즉, IsAlive가 아닌 경우가 발생할 때
QuestManager.Instance.ProcessQuest(QuestType.DestroyEnemy, 0);
를 호출하여 Quest를 확인하도록 처리합니다.

마찬가지로 InventoryObject에서 AddItem()이 발생할 때 관련 퀘스트를 확인하기 위하여
QuestManager.Instance.ProcessQuest(QuestType.AcquireItem, 1);
를 호출하여 Quest를 확인하도록 처리합니다.


 



Unity에서 QuestNPC를 2개 구성하였습니다.
하나는 적을 죽일 때의 Quest이고, 하나는 아이템을 얻는 Quest입니다.




실행을 하면 적을 죽이는 퀘스트와, 아이템을 얻어야 완료되는 2가지 퀘스트가 잘 구동되는 것을 확인할 수 있습니다.

실제로는 게임을 제작할 때 기획 의도에 맞게 Quest를 구성하면 되겠지요.







<위의 코드들은 제가 보면서 주요한 함수, 코드를 확인하기 위해 타이핑한 용도로, 전체 소스코드가 아님에 주의해 주세요. 전체 코드는 교육 수강을 하면 완벽하게 받으실 수가 있답니다 ^^>

패스트캠퍼스 - 올인원 패키지 : 유니티 포트폴리오 완성 bit.ly/2R561g0




 

유니티 게임 포트폴리오 완성 올인원 패키지 Online. | 패스트캠퍼스

게임 콘텐츠 프로그래머로 취업하고 싶다면, 포트폴리오 완성은 필수! '디아블로'와 '배틀그라운드' 게임을 따라 만들어 보며, 프로그래머 면접에 나오는 핵심 개념까지 모두 잡아 보세요!

www.fastcampus.co.kr

 

[패스트캠퍼스 수강 후기] 올인원 패키지 : 유니티 포트폴리오 완성 100% 환급 챌린지 21회차 미션 시작합니다.

02 디아블로 게임 - 37. 38 챕터를 진행합니다.




이번 시간은 RPG 게임 플레이 시스템 구현하기 입니다.




+ 플레이어 속성 - 아이템 착용 상태에 따른 속성 변경
+ 플레이어 UI
+ 다이얼로그 시스템 구현 - 대화 시스템
+ 퀘스트 시스템 구현
+ 환경 장치(함정/문) 구현 - 레벨에 따른..





중요한 부분은 Attribute와 ModifiableInt 클래스 입니다.

+ Attribute - ModifiableInt를 가지고 Value를 설정
+ ModifiableInt - Base값을 가지고 변경되어진 값을 사용하는 Value(?)
+ AttributeType - 속성의 Type 설정
+ StatsObject - Attribute를 설정

이제 스크립트를 구현합니다. 바로 로직구현으로 고고고~~ ㅎㅎ


[Serializable]
public class ModifiableInt_New
{
    [NonSerialized]
    private int baseValue;
    [SerializeField]
    private int modifiedValue;
    
    public int BaseValue {
        get => baseValue;
        set {
            baseValue = value;
            UpdateModifiedValue();
        }
    }
    
    public int ModifiedValue {
        get => modifiedValue;
        set => modifiedValue = value;
    }
    
    // 변경되었다는 이벤트를 받기 위한 처리
    private event Action<ModifiableInt_New> OnModifiedValue;
    
    private List<IModifier> modifiers = new List<IModifier>();
    
    public ModifiableInt_New(Action<ModifiableInt_New> method = null) {
        ModifiedValue = baseValue;
        RegisterModEvent(method);
    }
    
    public void RegisterModEvent(Action<ModifiableInt_New> method) {
        if (method != null) {
            OnModifiedValue += method;
        }
    }
    
    public void UnregisterModEvent(Action<ModifiableInt_New> method) {
        if (method != null) {
            OnModifiedValue -= method;
        }
    }
    
    private void UpdateModifiedValue() {
        int valueToAdd = 0;
        foreach (IModifier modifier in modifiers) {
            modifier.AddValue(ref valueToAdd);
        }
        
        ModifiedValue = baseValue + valueToAdd;
        
        OnModifiedValue?.Invoke(this);
    }
    
    public void AddModifier(IModifier modifier) {
        modifiers.Add(modifier);
        UpdateModifiedValue();
    }
    
    public void RemoveModifier(IModifier modifier) {
        modifiers.Remove(modifier);
        UpdateModifiedValue();
    }
}




[Serializable]
public class Attribute_New
{
    public AttributeType type;
    public ModifiableInt_New value;
}



[CreateAssetMenu(fileName = "New Stats", menuName = "Stats System/New Character Stats New")[
public class StatsObject_New : ScriptableObject
{
    public Attribute_New[] attributes;
    public int level;
    public int exp;
    public int Health { get; set; } // Property로 만들면 Serializable 되지 않는다.
    public int Mana { get; set; }
    
    public float HealthPercentage {
        get {
            int health = Health;
            int maxHealth = Health;
            foreach (Attribute_New attribute in attributes) {
                if (attribute.type == AttributeType.Health) {
                    maxHealth = attribute.value.ModifiedValue;
                }
            }
            
            return (maxHealth > 0 ? ((float)health / (float)maxHealth) : 0f);
        }
    }
   
    public float ManaPercentage {
        get {
            int mana = Mana;
            int maxMana = Mana;
            foreach (Attribute_New attribute in attributes) {
                if (attribute.type == AttributeType.Mana) {
                    maxMana = attribute.value.ModifiedValue;
                }
            }
            
            return (maxMana > 0 ? ((float)mana / (float)maxMana) : 0f);
        }
    }
   
    public event Action<StatsObject> OnChangedStats;
    
    [NonSerialized]
    private bool isInitialize = false;
    public void OnEnable() {
        InitializeAttribute();
    }
    
    public void InitializeAttribute() {
        if (isInitialize) return;
        isInitialize = true;
        foreach (Attribute_New attribute in attributes) {
            attribute.value = new ModifiableInt_New(OnModifiedValue);
        }
        level = 1;
        exp = 0;
        SetBaseValue(AttributeType.Agility, 100);
        SetBaseValue(AttributeType.Intellect, 100);
        SetBaseValue(AttributeType.Stamina, 100);
        SetBaseValue(AttributeType.Strength, 100);
        SetBaseValue(AttributeType.Health, 100);
        SetBaseValue(AttributeType.Mana, 100);
        
        Health = GetModifiedValue(AttributeType.Health);
        Mana = GetModifiedValue(AttributeType.Mana);
    }
    
    private void OnModifiedValue(ModifiableInt_New value) {
        OnChangedStats?.Invoke(this);
    }
    
    public int GetBaseValue(AttributeType type) {
        foreach (Attribute attribute in attributes) {
            if (attribute.type == type) {
                return attribute.value.BaseValue;
            }
        }
        return -1;
    }
    
    public void SetBaseValue(AttributeType type, int value) {
        foreach (Attribute attribute in attributes) {
            if (attribute.type == type) {
                attribute.value.BaseValue = value;
            }
        }
    }
    
    public int GetModifiedValue(AttributeType type) {
        foreach (Attribute attribute in attributes) {
            if (attribute.type == type) {
                return attribute.value.ModifiedValue;
            }
        }
        return -1;
    }
    
    public int AddHealth(int value) {
        Health += value;
        OnChangedStats?.Invoke(this);
        return Health;
    }
    
    public int AddMana(int value) {
        Mana += value;
        OnChangedStats?.Invoke(this);
        return Mana;
    }
}






이제 Unity Editor에서 PlayerStats를 추가하여 위와 같이 설정해 줍니다.

위와 관련 기존 코드에서 수정되는 부분들만 작성합니다.

public class PlayerCharacter
{
    [SerializeField]
    public StatsObject playerStats;
    
    public void OnEnterAttackState() {
        UnityEngine.Debug.Log("OnEnterAttackState()");
        playerStats.AddMana(-3); // 임시 테스트값
    }
    
    public void OnExitAttackState() {
        UnityEngine.Debug.Log("OnExitAttackState()");
    }
    
    public bool IsAlive => playerStats.Health > 0;
    
    public void TakeDamage(int damage, GameObject damageEffectPrefab) {
        //..
        playerStats.AddHealth(-damage);
        //..
    }
    
    private void OnUseItem(ItemObject itemObject) {
        foreach (ItemBuff buff in itemObject.data.buffs) {
            if (buff.stat == AttributeType.Health) {
                playerStats.AddHealth(buff.value);
            }
        }
    }
}


 



Unity에서 플레이어의 속성 UI를 표시하기 위해 무료 Asset을 받아서 Canvas에 위와 같이 설정합니다.


public class PlayerInGameUI_New : MonoBehaviour
{
    public StatsObject_New playerStats;
    public Text levelText;
    public Image healthSlider;
    public Image manaSlider;
    
    void Start() {
        levelText.text = playerStats.level.ToString("n0");
        healthSlider.fillAmount = playerStats.HealthPercentage;
        manaSlider.fillAmount = playerStats.ManaPercentage;
    }
    
    private void OnEnable() {
        playerStats.OnChangedStats += OnChangedStats;
    }
    
    private void OnDisable() {
        playerStats.OnChangedStats -= OnChangedStats;
    }
    
    private void OnChangedStats(StatsObject_New statsObject) {
        levelText.text = playerStats.level.ToString("n0");
        healthSlider.fillAmount = playerStats.HealthPercentage;
        manaSlider.fillAmount = playerStats.ManaPercentage;
    }
}





플레이 화면입니다.
공격을 당하면 HP가 줄어들고, 공격을 하면 Mana가 줄어들고, 물약을 먹으면 HP가 다시 채워지는 것을 확인할 수 있습니다.






이제 위와 같은 속성을 표시하기 위한 구현입니다.

public class PlayerStatsUI_New : MonoBehaviour
{
    public InventoryObject equipment;
    public StatsObject playerStats;
    public Text[] attributeTexts;
    
    private void OnEnable() {
        playerStats.OnChangedStats += OnChangedStats;
        if (equipment != null && playerStats != null) {
            foreach (InventorySlot slot in equipment.Slots) {
                slot.OnPreUpdate += OnRemoveItem;
                slot.OnPostUpdate += OnEquipItem;
            }
            UpdateAttributeTexts();
        }
    }
    
    private void OnDisable() {
        playerStats.OnChangedStats -= OnChangedStats;
        if (equipment != null && playerStats != null) {
            foreach (InventorySlot slot in equipment.Slots) {
                slot.OnPreUpdate -= OnRemoveItem;
                slot.OnPostUpdate -= OnEquipItem;
            }
            UpdateAttributeTexts();
        }
    }
    
    private void UpdateAttributeTexts() {
        attributeTexts[0].text = playerStats.GetModifiedValue(AttributeType.Agility).ToString("n0");
        attributeTexts[1].text = playerStats.GetModifiedValue(AttributeType.Intellect).ToString("n0");
        attributeTexts[2].text = playerStats.GetModifiedValue(AttributeType.Stamina).ToString("n0");
        attributeTexts[3].text = playerStats.GetModifiedValue(AttributeType.Strength).ToString("n0");
    }
    
    private void OnRemoveItem(InventorySlot slot) {
        if (slot.ItemObject == null) return;
        foreach (ItemBuff buff in slot.item.buffs) {
            foreach (Attribute attribute in playerStats.attributes) {
                if (attribute.type == buff.stat) {
                    attribute.value.RemoveModifier(buff);
                }
            }
        }
    }
    
    private void OnEquipItem(InventorySlot slot) {
        if (slot.ItemObject == null) return;
        foreach (ItemBuff buff in slot.item.buffs) {
            foreach (Attribute attribute in playerStats.attributes) {
                if (attribute.type == buff.stat) {
                    attribute.value.AddModifier(buff);
                }
            }
        }
    }
    
    private void OnChangedStats(StatsObject statsObject) {
        UpdateAttributeTexts();
    }
}





여기까지 작성하고 플레이를 시작하여 장착 테스트를 해봅니다.
모든 값들이 잘 표시됨을 확인할 수 있습니다. @~@;;;;





<위의 코드들은 제가 보면서 주요한 함수, 코드를 확인하기 위해 타이핑한 용도로, 전체 소스코드가 아님에 주의해 주세요. 전체 코드는 교육 수강을 하면 완벽하게 받으실 수가 있답니다 ^^>

패스트캠퍼스 - 올인원 패키지 : 유니티 포트폴리오 완성 bit.ly/2R561g0


 

유니티 게임 포트폴리오 완성 올인원 패키지 Online. | 패스트캠퍼스

게임 콘텐츠 프로그래머로 취업하고 싶다면, 포트폴리오 완성은 필수! '디아블로'와 '배틀그라운드' 게임을 따라 만들어 보며, 프로그래머 면접에 나오는 핵심 개념까지 모두 잡아 보세요!

www.fastcampus.co.kr

 

[패스트캠퍼스 수강 후기] 올인원 패키지 : 유니티 포트폴리오 완성 100% 환급 챌린지 20회차 미션 시작합니다.

02 디아블로 게임 - 35. 36 챕터를 진행합니다.




ItemInstances는 기능에 대한 오브젝트는 아니고, 아이템들에 대한 GameObject List를 가진 클래스라고 보면 됩니다.

public class ItemInstances_New
{
    public List<Transform> itemTransforms = new List<Transform>();
    
    public void OnDestroy() {
        // 하위 아이템들도 모두 삭제
        foreach (Transform item in itemTransforms) {
            Destroy(item.gameObject);
        }
    }
}




public class PlayerEquipment_New : MonoBehaviour
{
    public InventoryObject equipment;
    private EquipmentCombiner_New combiner;
    private ItemInstances_New[] itemInstances = new ItemInstances_New[8];
    public ItemObject[] defaultItemObjects = new ItemObject[8];
    
    private void Awake() {
        combiner = new EquipmentCombiner_New(gameObject);
        
        for (int i = 0; i < equipment.Slots.Length; i++) {
            equipment.Slots[i].OnPreUpdate += OnRemoveItem;
            equipment.Slots[i].OnPostUpdate += OnEquipItem;
        }
    }
    
    void Start() {
        foreach (InventorySlot slot in equipment.Slots) { // 기본 장착
            OnEquipItem(slot);
        }
    }
    
    private void OnEquipItem(InventorySlot slot) {
        ItemObject itemObject = slot.ItemObject;
        if (itemObject == null) { // 장비 삭제
            EquipDefaultItemBy(slot.AllowedItems[0]);
            return;
        }
       
        int index = (int)slot.AllowedItems[0];
        
        switch (slot.AllowedItems[0]) {
            case ItemType.Helmet:
            case ItemType.Chest:
            case ItemType.Pants:
            case ItemType.Boots:
            case ItemType.Gloves:
                itemInstances[index] = EquipSkinnedItem(itemObject);
                break;
            case ItemType.Pauldrons:
            case ItemType.LeftWeapon:
            case ItemType.RightWeapon:
                itemInstances[index] = EquipMeshItem(itemObject);
                break;
        }
    }
   
    // Skinned Item 장착
    private ItemInstances_New EquipSkinnedItem(ItemObject itemObject) {
        if (itemObject == null) return null;
        Transform itemTransform = combiner.AddLimb(itemObject.modelPrefab, itemObject.bonNames);
        
        if (itemTransform != null) {
            ItemInstances_New instance = new ItemInstances_New();
            instance.itemTransform.Add(itemTransform);
            return instance;
        }
        return null;
    }
    
    // Static Item 장착
    private ItemInstances_New EquipMeshItem(ItemObject itemObject) {
        if (itemObject == null) return null;
        Transform[] itemTransforms = combiner.AddMesh(itemObject.modelPrefab);
        
        if (itemTransform.Length > 0) {
            ItemInstances_New instance = new ItemInstances_New();
            instance.itemTransform.AddRange(itemTransform.ToList<Transform>());
            return instance;
        }
        return null;
    }
    
    private void EquipDefaultItemBy(ItemType type) {
        int index = (int)type;
        
        ItemObject itemObject = defaultItemObjects[index];
        switch (type) {
            case ItemType.Helmet: 
            case ItemType.Chest: 
            case ItemType.Pants: 
            case ItemType.Boots: 
            case ItemType.Gloves: 
                itemInstances[index] = EquipSkinnedItem(itemObject); 
                break; 
            case ItemType.Pauldrons: 
            case ItemType.LeftWeapon: 
            case ItemType.RightWeapon: 
                itemInstances[index] = EquipMeshItem(itemObject); 
                break; 
        } 
    } 
    
    private void OnDestroy() {
        foreach (ItemInstances_New item in itemInstances) {
            item.Destroy();
        }
    }
    
    private void OnRemoveItem(InventorySlot slot) {
        ItemObject itemObject = slot.ItemObject;
        if (itemObject == null) {
            RemoveItemBy(slot.AllowedItems[0]);
            return;
        }
        
        if (slot.ItemObject.modelPrefab != null) {
            RemoveItemBy(slot.AllowedItems[0]);
        }
    }
    
    private void RemoveItemBy(ItemType type) { // 특정 위치 아이템 삭제
        int index = (int)type;
        if (itemInstances[index] != null) {
            itemInstances[index].Destroy();
            itemInstances[index] = null;
        }
    }
}





위와 같이 보이지는 않지만 Bone 정보가 있고, 여기에 아이템의 Skinned Mesh를 잘 입혀서 보여주는 것이 아이템 장착이라고 해석하면 될 것 같네요.




Default Equipment를 설정합니다.




유니티 플레이를 해보면, 기본 장착 아이템들을 가지고 있는 캐릭터를 확인할 수 있습니다.
인벤토리에서 아이템을 드래그하여 장착하면 UI 상의 캐릭터가 아이템을 장착하는 것을 확인할 수 있고,
장비 인벤토리에서 아이템을 바닥에 드래그하여 버리게 되면, 다시 Default Item들을 가진 캐릭터로 설정됨을 확인할 수 있습니다.

아이템들에 대한 Mesh 형태에 따라 처리 방법이 달라지기 때문에 기획자, 디자이너와 어떤 형태로 만들고 구동할 것인지를 협의하고 그에 맞게 코드를 수정하여 만들어주면 됩니다.





 

 



이제 해당 아이템들을 땅에서 획득하고, 물약 등을 사용하는 루틴을 구현해 보겠습니다.


public class GroundItem_New : MonoBehaviour
{
    public ItemObject itemObject;
    
    private void OnValidate() {
#if UNITY_EDITOR
        GetComponent<SpriteRenderer>().sprite = itemObject?.icon;
#endif
    }
}


public class PlayerCharacter
{
    private void OnTriggerEnter(Collider other) {
        var item = other.GetComponent<GroundItem_New>();
        if (item) {
            if (inventory.AddItem(new Item(item.itemObject), 1)) // 인벤토리에 아이템을 추가하고
                Destroy(other.gameObject); // 땅의 아이템은 삭제.
        }
    }
}


 



이렇게 구현된 상태로 플레이를 해보면 바닥의 투구 아이템을 지나갈 때 캐릭터와 부딪히게 되고, 캐릭터는 아이템을 획득하게 됩니다.




이제 근처에 있는 아이템을 클릭하여 획득하는 루틴을 구현해 보겠습니다.

public interface IInteractable_New // 상자나 다른 다른 오브젝트에도 사용 가능하기에 별도 interface로 구현
{
    float Distance { get; }
    bool Interact(GameObject other);
    void StopInteract(GameObject other);
}


public class PickupItem_New : MonoBehaviour, IInteractable_New
{
    public float distance = 3.0f; // 아이템과 특정 거리 내에서만 픽업 가능하도록
    public float Distance => distance;
    
    public ItemObject itemObject;
    
    public bool Interact(GameObject other) {
        float calcDistance = Vector3.Distance(transform.position, other.transform.position);
        if (calcDistance > distance) return false;
        
        return other.GetComponent<PlayerCharacter_New>()?.PickupItem(this) ?? false;
    }
    
    public void StopInteract(GameObject other) {
    }
    
    private void OnValidate() {
#if UNITY_EDITOR
        GetComponent<SpriteRenderer>().sprite = itemObject?.icon;
#endif
    }
    
    private void OnDrawGizmosSelected() {
        Gizmos.color = Color.yellow;
        Gizmos.DrawWireSphere(transform.position, distance);
    }
}

public class PlayerCharacter_New에서 우클릭할 때의 처리도 추가해 줍니다.
아이템을 우클릭하면 캐릭터는 해당 위치로 이동을 하다가 설정된 거리 내에 아이템이 있다면 Interact가 처리되도록 하여 아이템을 획득하는 루틴을 처리하면 됩니다.




이렇게 처리를 하고 플레이를 해보면 아이템을 지나가도 자동으로 획득이 되지 않지만, 먼 거리에서 아이템을 우클릭하고 이동하면 근처에 도달하여 아이템을 획득하는 장면을 볼 수 있습니다.





물약과 같은 아이템을 사용하는 루틴입니다. 기존 소스 코드에서 추가된 주요 함수들만 작성하였습니다.

public class DynamicInventoryUI
{
    protected override void OnRightClick(InventorySlot slot) {
        inventoryObject.UseItem(slot);
    }
}


public class InventoryObject : ScriptableObject
{
    public void UseItem(InventorySlot slotToUse) {
        if (slotToUse.ItemObject == null || slotToUse.item.id < 0 || slotToUse.amount <= 0) return;
        
        ItemObject itemObject = slotToUse.ItemObject;
        slotToUse.UpdateSlot(slotToUse.item, slotToUse.amount - 1);
        
        OnUseItem.Invoke(itemObject);
    }
}


public class PlayerCharacter
{
    private void OnUseItem(ItemObject itemObject) {
        foreach (ItemBuff buff in itemObject.data.buffs) {
            if (buff.stat == CharacterAttribute.Health)
                this.health += buff.value;
        }
    }
}


중요한 시스템들에 대한 구현이 많았어서 어렵기도 하고 복잡하기도 하고.. 그러네요 ^^
하지만 그만큼 중요한 내용이고, 그래도 어려운 내용을 이렇게 하나씩 구현해 가며 차근히 설명해주시니 너무 감격스럽지 않을 수 있겠습니까.



<위의 코드들은 제가 보면서 주요한 함수, 코드를 확인하기 위해 타이핑한 용도로, 전체 소스코드가 아님에 주의해 주세요. 전체 코드는 교육 수강을 하면 완벽하게 받으실 수가 있답니다 ^^>

패스트캠퍼스 - 올인원 패키지 : 유니티 포트폴리오 완성 bit.ly/2R561g0






 

유니티 게임 포트폴리오 완성 올인원 패키지 Online. | 패스트캠퍼스

게임 콘텐츠 프로그래머로 취업하고 싶다면, 포트폴리오 완성은 필수! '디아블로'와 '배틀그라운드' 게임을 따라 만들어 보며, 프로그래머 면접에 나오는 핵심 개념까지 모두 잡아 보세요!

www.fastcampus.co.kr

 

+ Recent posts