지난 시간에는 아이템의 기본 데이터를 만들고, 아이템 객체를 만들기 위한 클래스를 만들어 봤습니다.
제가 생각한 아이템 객체의 구조는 다음 그림과 같습니다.
큰 아이템 객체 구조 안에는 스크립터블 오브젝트로 만든 작은 아이템 데이터 구조가 포함됩니다. 그리고 이 데이터를 받는 순간 그 아이템의 이름과 기본 파워가 정해지는 것입니다.
그리고 게임 상에서 동적으로 변화하는 데이터를 담기 위한 변수들을 만들어주고, 그리고 그러한 데이터를 다른 객체들이 사용할 수 있도록 int 형 함수인 Cal_LvUPPow()를 만들어 아이템의 레벨과 등급에 따라서 아이템 파워를 쉽게 계산하여 적용할 수 있게 만들었습니다.
이번시간에는 이렇게 만들어둔 데이터와 객체의 틀을 적용시켜서 아이템을 직접 만들어 보고 다른 객체에서 사용하기 쉽도록 가공하는 부분까지 살펴보도록 하겠습니다.
먼저 이러한 아이템 데이터를 생성하고 관리하는 ItemManager 게임 오브젝트를 만들고 그안에 ItemManager라는 스크립트를 만들어 싱글톤화 시킨 후에 어디서든 아이템 데이터를 가져다 사용할 수 있게 만들 계획입니다.
이제 ItemManager 스크립트를 살펴보도록 하겠습니다.
*******************************
포스팅을 끝내고 났는데, 훨씬 간단하게 표현할 수 있다는 것을 깨달았습니다. 더 간단한 코드를 보고 싶으시다면 이 포스팅 가장 뒷부분으로 바로 가시면 보실 수 있습니다.
공부하시는 분이시라면 긴 코드와 간단한 코드를 비교해 보시는 것도 좋겠습니다.
*******************************
using System.Collections;
using System.Collections.Generic;
using UnityEngine;
using System.Linq;
using System;
public class ItemManager : MonoBehaviour
{
public static ItemManager instance;
[SerializeField]
List<Item_ScriptableObject> item_ScriptableObject = new List<Item_ScriptableObject>(); // item데이터 리스트
[SerializeField]
List<Sprite> backgrounds = new List<Sprite>();// 등급별 아이템 슬롯 백그라운드 스프라이트 리스트
[SerializeField]
List<Sprite> slots = new List<Sprite>(); // 등급별 아이템 슬롯의 슬롯 스프라이트 리스트
public Sprite defaultBackGround; // 빈슬롯 백그라운드
public Sprite defaultSlot;
public List<Item> items = new List<Item>(); // 생성된 아이템 객체를 담을 리스트
public List<Item> gainedItems = new List<Item>(); // 플레이어가 얻은 아이템 객체를 담을 리스트
private void Awake()
{
if(instance == null)//싱글톤
{
instance = this;
}
else
{
Destroy(this);
}
}
void Start()
{
ListItem();
}
void ListItem() // 아이템데이터를 탑입 중심으로 다시 정렬해서 리스트화 하는 함수
{
List<Item_ScriptableObject> itemdatas = new List<Item_ScriptableObject>(); //아이템을 받아서 새롭게 정렬하기 위해 생성한 함수
int eVaues = Enum.GetValues(typeof(Item_ScriptableObject.ItemType)).Length;//아이템 타입의 개수를 받을 변수
for (int i=0; i<eVaues; i++)
{
itemdatas = item_ScriptableObject.Where(n => n.itemType == (Item_ScriptableObject.ItemType)i).ToList();
CreatItem(itemdatas);
itemdatas.Clear();
}
}
void CreatItem(List<Item_ScriptableObject> itemdatas)// 아이템 객체 생성 및 각 아이템객체에 기본 설정을 해주는 함수
{
for (int i = 0; i < itemdatas.Count; i++)
{
Item item = new Item(); //아이템 객체 생성
item.itemData = itemdatas[i]; // CreatItem() 함수에서 받아온 itemdatas 데이터를 넣습니다.
item.itemGrade = Item.ItemGrade.Nomal; // 아이템 등급 입력
item.Setting(backgrounds[0], slots[0]); // 아이템 슬롯 백그라운드와 스롯의 스프라이트 입력
item.ItemLv = 1; // 아이템 레벨 초기화
items.Add(item);// 생성된 아이템 객체를 items리스트에 삽입
for (int a = 0; a < 4; a++)// 위에서 생성된 item의 4가지 등급을 더 생성해주기 위한 반복문
{
Item item2 = new Item();
item2.itemData = itemdatas[i];
item2.itemGrade = (Item.ItemGrade)a + 1;
item2.Setting(backgrounds[a + 1], slots[a + 1]);
item2.ItemLv = 1;
items.Add(item2);
}
}
}
public void GetItem(int itemnum)//플레이어가 아이템을 얻었을때 동작하는 함수
{
gainedItems.Add(items[itemnum]);// 아이템을 gainedItems리스트에 삽입
items.RemoveAt(itemnum); // items 리스트에서 제거
}
}
지난 포스트 보다 설명해야하는 부분이 길고 많지만 한번 차근 차근 해보도록 하겠습니다.
먼저 전역변수들을 살펴보겠습니다.
public static ItemManager instance;//1.싱글톤 변수
[SerializeField]
List<Item_ScriptableObject> item_ScriptableObject = new List<Item_ScriptableObject>();
// 2. item데이터 리스트
[SerializeField]
List<Sprite> backgrounds = new List<Sprite>();
// 3. 등급별 아이템 슬롯 백그라운드 스프라이트 리스트
[SerializeField]
List<Sprite> slots = new List<Sprite>();
// 4. 등급별 아이템 슬롯의 슬롯 스프라이트 리스트
public Sprite defaultBackGround; // 5. 빈슬롯 백그라운드
public Sprite defaultSlot;
public List<Item> items = new List<Item>(); // 6. 생성된 아이템 객체를 담을 리스트
public List<Item> gainedItems = new List<Item>();
// 7. 플레이어가 얻은 아이템 객체를 담을 리스트
1. 가장 먼저 ItemManager 클래스를 싱글톤화 하기 위해서 instance 변수를 static으로 설정해줍니다.
2. 전에 만들어둔 item스크립터블 오브젝트 데이터들을 담을 리스트 변수를 설정해줍니다. 그리고 유니티 인스팩터 창에 가서 만들어둔 데이터를 모두 이 변수에 드래그 앤 드롭으로 끌어다 담을 계획입니다.
3. 5개의 등급별로 아이템 슬롯의 백그라운드들을 다르게 할 계획이기 때문에, 각 등급별로 다른 스프라이트를 담을 리스트를 선언합니다.
4. 다음으로 5개의 등급별로 아이템 슬롯의 프레임을 담을 slots라는 리스트를 선언합니다.
5. 아이템이 비었을때 빈슬롯의 백그라운드와 프래임을 담을 변수들을 선언합니다.
6. 아이템 객체를 만들어 모두 담을 아이템 리스트 items 를 선언합니다.
7. 그리고 플레이어가 얻은 아이템을 담을 gainedItems 리스트를 선언합니다.
이제 아이템 객체를 만들어 items 리스트에 모두 담고 만일 플레이 중 플레이어가 아이템을 획득하면 items 리스트에서 아이템 객체를 gainedItems 리스트로 옮기고 items에서는 제거하는 방식으로 사용할 계획입니다.
그러기 위해서는 먼저 아이템 객체를 만들어야 하는데요. 위에서 설명한데로 아이템의 정체성은 스크립터블 오브젝트 데이터인 itemData에 있습니다. 그리고 각 아이템 데이터 마다 등급을 5개씩 만들계횝입니다.
itemData는 각 타입 별로 무기 3종류, 방패3종류, 헬멧 3종류, 아머 3종류, 신발 3종류, 악세서리 3종류 총 18종류의 아이템이 있습니다. 그리고 각 종류에 따라서 5등급을 만들어 줄 것이기 때문에 90종류의 아이템을 만들 계획입니다.
아무튼, 그 전에 Awke 함수에서 ItemManager에 대한 싱글톤을 선언해 줍니다.
private void Awake()
{
if(instance == null)//싱글톤
{
instance = this;
}
else
{
Destroy(this);
}
}
그리고 start 함수에서 게임이 시작하자 마자 아이템을 생성하기 위한 첫번째 함수인 ListItem() 함수를 콜백해줍니다.
void Start()
{
ListItem();
}
void ListItem() // 1. 아이템데이터를 탑입 중심으로 다시 정렬해서 리스트화 하는 함수
{
List<Item_ScriptableObject> itemdatas = new List<Item_ScriptableObject>();
//2. 아이템을 받아서 새롭게 정렬하기 위해 생성한 함수
int eVaues = Enum.GetValues(typeof(Item_ScriptableObject.ItemType)).Length;
//3. 아이템 타입의 개수를 받을 변수
for (int i=0; i<eVaues; i++)//7. 아이템 타입 만큼 반복.
{
itemdatas = item_ScriptableObject
.Where(n => n.itemType == (Item_ScriptableObject.ItemType)i).ToList();
// 4. Linq를 통해 itemdatas 리스트에 타입별로 재정렬한 데이터를 추가.
CreatItem(itemdatas); // 5. itemdatas를 가지고 아이템 생성함수 콜백
itemdatas.Clear(); // 6. 다음 타입의 아이템 데이터를 받기 위해 itemdatas 초기화
}
}
1. ListItem은 아이템 객체를 만들어 주기 전에 아이템을 만들고 난후 리스트로 만들어 관리 할 때 좀 더 쉽게 관리 하기 위해서 각 아이템의 타입별로 재정렬시켜주고, 각 아이템 타입 별로 아이템 객체를 생성해서 리스트에 담기 위해서 만들어준 함수입니다.
2. 그 작업을 위해서 itemdatas 라는 리스트를 생성해 무기 타입의 데이터를 담고 아이템을 생성하는 CreatItem함수를 콜백해 아이템을 생성한 뒤 다시 클리어 하여 다음 타입의 아이템을 위해 계속 재사용해줄 계획입니다.
3. 뒤에서 아이템 생성 작업을 아이템 타입 만큼 반복할 예정이기 때문에 아이템 타입의 개수를 받을 변수를 추가해 주었습니다.
enum의 데이터 개수를 받아오는 함수는 Enum.GetValues함수를 사용합니다. 이 함수를 사용하기 위해서는 네임스페이스에 "using System;"을 반드시 추가해야합니다.
사용법은 Enum.GetValues(typeof("enum의 데이터 타입").Length 으로 사용하면 됩니다. enum변수가 아닌 데이터 타입을 참조해야하기에 저는 Enum.GetValues(typeof(Item_ScriptableObject.ItemType)).Length 아이템 스크립터블 오브젝트 안에 있는 ItemType라는 enum데이터 타입을 참조했습니다.
4. 아이템 스크립터블 오브젝트를 담은 리스트에서 첫번째 타입(무기)의 데이터만 따로 빼서 itemdatas에 담습니다. 이러한 과정은 Linq라는 C#문법을 활용해서 실행하는 것인데, Linq는 컬렉션화 된 데이터를 새롭게 정렬하거나 그중에 일정 조건을 만족하는 데이터만 추출하는 등 데이터를 가공하는데 사용하는 시스템입니다. Linq에 대해서는 제가 다른 포스트에서 따로 정리하도록 하겠습니다. 이번 포스트에서는 제가 사용한 부분만 간단하게 설명하고 넘어가고자 합니다.
Linq를 사용하려면 네임스페이스에 using System.Linq를 추가해야합니다.
itemdatas = item_ScriptableObject.Where(n => n.itemType == (Item_ScriptableObject.ItemType)i).ToList();
item_ScriptableObjec의 리스트 중에서 일정 조건을 만족시키는 n을 itemdatas에 리스트로 넣는 코드입니다.
n은 아무렇게 정하는 이름입니다.
n => n.itemType == (Item_ScriptableObject.ItemType)i
n의 조건은 => 뒤에 있는 n.itemType == (Item_ScriptableObject.ItemType)i 입니다. n안에 있는 itemType(enum의 변수) 가 (ItemType)의 i 번째 타입인 조건입니다.
Item_ScriptableObject.ItemType 의 0 번째 데이터는 무기이고 1번째 데이터는 방패입니다.
이런 식으로 한번에 1개의 타입 데이터만 추출해서 itemdatas에 리스트화 하겠다는 의미입니다.
만일 i=0 일때 라면 itemdats에는 무기1, 무기2, 무기3의 데이터가 차례래로 들어가겠죠.
5. 그럼 무기가 담겨진 itemdatas의 리스트를 매개변수로 CreatItem() 함수를 콜백해 아이템 객체를 생성합니다.
6. 그리고 무기가 담겨진 itemdatas 리스트를 초기화해 다음 타입의 데이터를 담을 준비를 합니다.
7. 이런식의 로직을 아이템 타입의 개수만큼 반복실행해줍니다.
아이템을 생성하기 위해 이런 번거로운 일을 하는 이유는 후에 아이템 데이터의 정렬이 좀 더 쉽게 되어서 사용할때 편리하도록 하기 위해서입니다.
예를 들어 18개의 타입이 있는데, 각 자 5개씩 등급을 만들어 준 후에 곧 바로 리스트에 담아준다면 이런식의 데이터가 될 겁니다.
items[0] = 무기1 노멀
items[1] = 무기2노멀
items[2] = 무기3노멀
items[3] = 방패1노멀
items[4] = 방패2노멀
...
그런데 저는 각 아이템 별로 노멀부터 레전드 등급까지 리스트안에 차례대로 나열된 리스트를 만들기 원합니다.
items[0] = 무기1 노멀
items[1] = 무기1 레어
items[2] = 무기1 유니크
items[3] = 무기1 에픽
items[4] = 무기1 레전드
items[5] = 무기2 노멀
items[6] = 무기2 레어
...
이런 식으로 말이죠.
그것을 위해서 먼저 itemdatas라는 리스트 안에 무기 데이터를 넣고, 각 무기 데이터 마다 5개 등급의 아이템을 생성해 items라는 리스트에 넣고, 또 그 다음 방패 데이터마다 넣고, 이런 식으로 작업을 하도록 프로그래밍 했습니다.
이제 직접 아이템 객체를 생성하는 CreatItem 함수를 살펴보겠습니다.
void CreatItem(List<Item_ScriptableObject> itemdatas)
//1. 아이템 객체 생성 및 각 아이템객체에 기본 설정을 해주는 함수
{
for (int i = 0; i < itemdatas.Count; i++)//5. itemdatas의 데이터 개수만큼 실행
{
Item item = new Item(); //2. 아이템 객체 생성
item.itemData = itemdatas[i];
// 3. CreatItem() 함수에서 받아온 itemdatas 데이터를 넣습니다.
item.itemGrade = Item.ItemGrade.Nomal; // 아이템 등급 입력
item.Setting(backgrounds[0], slots[0]);
// 3. 아이템 슬롯 백그라운드와 스롯의 스프라이트 입력
item.ItemLv = 1; // 3. 아이템 레벨 초기화
items.Add(item);// 3. 생성된 아이템 객체를 items리스트에 삽입
for (int a = 0; a < 4; a++)
// 4. 위에서 생성된 item의 4가지 등급을 더 생성해주기 위한 반복문
{
Item item2 = new Item();
item2.itemData = itemdatas[i];
item2.itemGrade = (Item.ItemGrade)a + 1;
item2.Setting(backgrounds[a + 1], slots[a + 1]);
item2.ItemLv = 1;
items.Add(item2);
}
}
}
1. 먼저 ListItem()함수에서 itemdatas리스트를 매개변수로 받아 각 아이템을 등급별로 객체를 생성해서 items 라는 리스트에 넣어주는 함수입니다.
2. 먼저 Item클레스 타입의 item을 new 키워드를 사용하여 객체를 생성해줍니다.
3. 그리고 그 객체 안에 있는 데이터를 직접 채워줍니다.
먼저 itemdatas 안에는 스크립터블 오브젝트로 만든 itemdata가 존재합니다. 이 item data가 아이템의 아이덴티티를 결정합니다. 그래서 가장 먼저 새롭게 만들어진 item 객체 안에 존재흔 itemdata 변수에 itemadatas 중 첫번째의 데이터를 입력해줍니다.
그리고 이제 나머지 각 데이터 변수를 채워줍니다.
첫번째로 등급을 노멀로 설정해주고, 레벨을 1로 초기화 해주고, 아이템 등급에 맞는 백그라운드 스프라이트와 슬롯 프레임 스프라이트를 입력해줍니다. 그리고 그렇게 완성된 item객체를 items라는 미리 만들어 둔 리스트에 저장합니다.
그런데 이렇게 1개 만들고 끝이 아닙니다. 같은 타입 그리고 같은 data를 공유하는 아이템이지만 다른 등급 4개를 더 만들어 주어야 합니다.
4. 그것을 위해서 4번을 더 반복하는 반복문을 한개 더 만들어 줍니다.
그리고 첫번째 것과는 다른 두번째 item2 객체를 생성해줍니다. 그리고 매 반복마다 데이터는 같지만 등급만 다른 객체를 생성해 item리스트에 삽입해줍니다.
여기에서 item2.itemGrade = (Item.ItemGrade)a + 1;
는 앞에서 살펴본 enum 타입을 int로 사용해서 변환시키는 방법을 사용했습니다. item2 안에 itemGrade 변수를 변환시킬 건데 enum 각 데이터의 정수값으로도 변환시킬 수 있습니다.
enum 변수 = (이넘아이템타입) 숫자 ;
이런 식으로 말이죠. a에서 +1을 해준 것은 위에서 이미 아이템 타입 0인 노멀의 데이터는 생성되었으니 1부터 생성하기 위해서입니다.
이렇게 생성된 item2의 데이터를 items라는 리스트에 차례대로 삽입시킵니다.
그럼 이제
items[0] = 무기1 노멀
items[1] = 무기1 레어
items[2] = 무기1 유니크
items[3] = 무기1 에픽
items[4] = 무기1 레전드
이런식의 리스트가 되는 것입니다.
이렇게 ListItem과 CreatItem 함수의 모든 처리가 끝나면 items 리스트에는 각 아이템 별로 5등급의 아이템이 차례대로 삽입되게 됩니다.
이제 마지막으로 생성된 아이템을 플레이어가 얻었을때 처리하는 함수를 살펴보겠습니다.
public void GetItem(int itemnum)//플레이어가 아이템을 얻었을때 동작하는 함수
{
gainedItems.Add(items[itemnum]);// 아이템을 gainedItems리스트에 삽입
items.RemoveAt(itemnum); // items 리스트에서 제거
}
플레이어가 어떤 아이템을 얻었는지 식별하기 위해서 매개변수로 int 형 변수를 정했습니다. item 자체를 받는 것보다 리스트의 순번대로 처리하는 것이 쉽다고 생각했디 때문에 int를 변수로 받기로 결정했습니다.
그렇게 얻은 아이템의 번호는 items의 인덱스 번호로 취급됩니다.
그래서 gainedItems 리스트에 items[매개변수] 번째 아이템을 넣습니다. 그리고 items 리스트에서 그 아이템을 제거합니다.
이렇게 된다면 인벤토리에서 아이템을 취급할때 gainedItems 리스트만을 사용하여 만들 수 있게 됩니다.
이번 포스팅에서는 미리 만든 아이템 데이터를 가지고 item 객체를 생성, 아이템을 사용하기 쉬운 리스트 형태로 가공하는 방식까지 살펴보았습니다.
포스팅을 하다보니 좀 더 간단하게 코딩할 수 있었겠다는 생각이 듭니다. 그 부분은 추후에 업데이트 하도록 하겠습니다.
다음 포스팅에서는 이제 이렇게 만든 아이템을 사용하는 방식 중 첫번째 "아이템 소환" 시스템을 구현해 보려고 합니다.
감사합니다.
************************************************************
포스팅을 작성하던 중에 제가 너무 비효율 적으로 코드를 작성했다는 것을 깨닫고 코드를 더 간단하게 다시 작성해 봤습니다.
using System.Collections;
using System.Collections.Generic;
using UnityEngine;
using System.Linq;
using System;
public class ItemManager : MonoBehaviour
{
public static ItemManager instance;
[SerializeField]
List<Item_ScriptableObject> item_ScriptableObject = new List<Item_ScriptableObject>(); // item데이터 리스트
[SerializeField]
List<Sprite> backgrounds = new List<Sprite>();// 등급별 아이템 슬롯 백그라운드 스프라이트 리스트
[SerializeField]
List<Sprite> slots = new List<Sprite>(); // 등급별 아이템 슬롯의 슬롯 스프라이트 리스트
public Sprite defaultBackGround; // 빈슬롯 백그라운드
public Sprite defaultSlot;
public List<Item> items = new List<Item>(); // 생성된 아이템 객체를 담을 리스트
public List<Item> gainedItems = new List<Item>(); // 플레이어가 얻은 아이템 객체를 담을 리스트
private void Awake()
{
if(instance == null)//싱글톤
{
instance = this;
}
else
{
Destroy(this);
}
}
void Start()
{
CreatItem();
}
void CreatItem()
{
int eVaues = Enum.GetValues(typeof(Item.ItemGrade)).Length;
List<Item> itemdatas = new List<Item>();
for (int i=0; i < item_ScriptableObject.Count; i++)
{
for (int a = 0; a < eVaues; a++)
{
Item item = new Item()
{
itemData = item_ScriptableObject[i],
itemGrade = (Item.ItemGrade)a,
backGround = backgrounds[a],
slot = slots[a],
ItemLv = 1
};
itemdatas.Add(item);
}
}
items = itemdatas.OrderBy(data => data.itemData.itemType)
.ThenBy(data => data.itemData.itemPow)
.ThenBy(data =>data.itemGrade)
.ToList();
}
public void GetItem(int itemnum)//플레이어가 아이템을 얻었을때 동작하는 함수
{
gainedItems.Add(items[itemnum]);// 아이템을 gainedItems리스트에 삽입
items.RemoveAt(itemnum); // items 리스트에서 제거
}
바뀐 부분만 간략하게 설명해드리겠습니다.
원래는 ListItem() 함수와 CreatItem() 함수를 나눠서 썼는데, 생각보다 간단한 코드로 구현할 수 있기 때문에 그냥 CreatItem() 함수 하나로 합쳤습니다.
그전에 원래 코드부분을 한번 보고 비교해서 보겠습니다.
void ListItem() // 1. 아이템데이터를 탑입 중심으로 다시 정렬해서 리스트화 하는 함수
{
List<Item_ScriptableObject> itemdatas = new List<Item_ScriptableObject>();
//2. 아이템을 받아서 새롭게 정렬하기 위해 생성한 함수
int eVaues = Enum.GetValues(typeof(Item_ScriptableObject.ItemType)).Length;
//3. 아이템 타입의 개수를 받을 변수
for (int i=0; i<eVaues; i++)//7. 아이템 타입 만큼 반복.
{
itemdatas = item_ScriptableObject
.Where(n => n.itemType == (Item_ScriptableObject.ItemType)i).ToList();
// 4. Linq를 통해 itemdatas 리스트에 타입별로 재정렬한 데이터를 추가.
CreatItem(itemdatas); // 5. itemdatas를 가지고 아이템 생성함수 콜백
itemdatas.Clear(); // 6. 다음 타입의 아이템 데이터를 받기 위해 itemdatas 초기화
}
}
void CreatItem(List<Item_ScriptableObject> itemdatas)
//1. 아이템 객체 생성 및 각 아이템객체에 기본 설정을 해주는 함수
{
for (int i = 0; i < itemdatas.Count; i++)//5. itemdatas의 데이터 개수만큼 실행
{
Item item = new Item(); //2. 아이템 객체 생성
item.itemData = itemdatas[i];
// 3. CreatItem() 함수에서 받아온 itemdatas 데이터를 넣습니다.
item.itemGrade = Item.ItemGrade.Nomal; // 아이템 등급 입력
item.Setting(backgrounds[0], slots[0]);
// 3. 아이템 슬롯 백그라운드와 스롯의 스프라이트 입력
item.ItemLv = 1; // 3. 아이템 레벨 초기화
items.Add(item);// 3. 생성된 아이템 객체를 items리스트에 삽입
for (int a = 0; a < 4; a++)
// 4. 위에서 생성된 item의 4가지 등급을 더 생성해주기 위한 반복문
{
Item item2 = new Item();
item2.itemData = itemdatas[i];
item2.itemGrade = (Item.ItemGrade)a + 1;
item2.Setting(backgrounds[a + 1], slots[a + 1]);
item2.ItemLv = 1;
items.Add(item2);
}
}
}
이제 변경한 코드를 보겠습니다.
void CreatItem()
{
int eVaues = Enum.GetValues(typeof(Item.ItemGrade)).Length;
//1.아이템 등급의 개수
List<Item> itemdatas = new List<Item>();
//2.생성된 아이템을 임시로 받을 리스트
for (int i=0; i < item_ScriptableObject.Count; i++)//3. 아이템 데이터 만큼 반복
{
for (int a = 0; a < eVaues; a++)//4. 아이템 등급만큼 반복
{
Item item = new Item() //5. 아이템 객체 생성 및 아이템 데이터 입력
{
itemData = item_ScriptableObject[i],
itemGrade = (Item.ItemGrade)a,
backGround = backgrounds[a],
slot = slots[a],
ItemLv = 1
};
itemdatas.Add(item);// 6. 아이템 데이터리스트화
}
}
// 7.itemdatas리스트를 재정렬 해서 items에 다시 삽입
items = itemdatas.OrderBy(data => data.itemData.itemType)
.ThenBy(data => data.itemData.itemPow)
.ThenBy(data =>data.itemGrade)
.ToList();
}
기본적인 알고리즘은 비슷합니다. 다만 먼저 리스트를 정렬해서 아이템을 생성하는 것이 아니라 아이템을 모두 생성한 후 그 리스트를 Linq를 이용해서 다시 정렬해주는 것입니다.
1. 반복문을 위해서 아이템 등급의 개수를 미리 eVaues에 담아둡니다.
2. 아이템을 생성해 임시로 담을 itemdatas 리스트를 생성합니다.
3. 아이템 객체를 생성해서 itemdata를 입력해야하니, itemdata 개수 만큼 반복문을 실행합니다.
4. itemdata 1개에 5가지 등급만큼 itemdata를 생성해야 하니 중복으로 등급의 개수만큼의 반복문을 실행합니다.
5. itme 이라는 새로운 객체를 만들고 그안에 itemdata를 입력시켜준 후 등급을 차례로 정해줍니다.(5번 반복)
6. 그렇게 입력된 아이템을 itemdatas라는 리스트에 삽입합니다.
사실 이렇게만 해도 제가 원했던 대로
itemdatas[0] = 무기1 노멀
itemdatas [1] = 무기1 레어
itemdatas [2] = 무기1 유니크
itemdatas [3] = 무기1 에픽
itemdatas [4] = 무기1 레전드
이런식의 정렬이 가능합니다.
하지만 혹시나 나중에 아이템을 추가할 때는 아이템 정렬이 억망이 될 수 있습니다.
7. 그래서 다시 아이템을 정렬해주기 위해 Linq를 사용합니다.
items = itemdatas.OrderBy(data => data.itemData.itemType)
.ThenBy(data => data.itemData.itemPow)
.ThenBy(data =>data.itemGrade)
.ToList();
OrderBy() : 데이터를 일정 조건으로 내림차순으로 정렬합니다. 여기서는 itemType 순의 내림차순으로 정렬합니다.
ThenBy() : 앞에서 OrderBy()로 정렬된 다음 ThenBy() 조건으로 정렬합니다. 여기서는 itemPow로 했는데, 각 아이템 타입안에서 아이템의 강함순서로 정렬하기 원했기 때문에 itemPow를 변수로 해서 정렬하도록 했습니다.
그렇게 정렬한 후 그 다음으로 다시 정렬된 순서 안에서 itemGrade로 정렬했습니다.
그렇게 하니 원하는 순서대로 아이템이 정렬되었고, 나중에 itemdata 뒷편에 새로운 아이템을 추가한다고 하더라도, 중간에 자신의 자리에 맡게 찾아가서 정렬될 수 있도록 했습니다.
역시 처음부터 좀 더 고민을 해서 코드를 만들었다면 훨씬 간단한 코드로 만들 수 있다는 것을 다시 한번 깨다는 부분이었습니다.
감사합니다.
'유니티 방치형 모바일 게임 팀프로젝트' 카테고리의 다른 글
| 아이템 소환 UI 및 아이템 소환 시스템 (0) | 2024.04.30 |
|---|---|
| 아이템 데이터 및 아이템 클래스 생성 (1) | 2024.04.26 |