public Sprite m_ItemSprite;                // 아이템 텍스처


    public ConsumeItem(E_CONSUMEITEMS p_item,
                       E_ITEMTYPE p_itemType,
                       Sprite p_itemSprite)
    {
        m_Item       = p_item;
        m_ItemType   = p_itemType;
        m_ItemSprite = p_itemSprite;
    }
예제 #2
0
    // 소비 아이템 정보 가져오기
    void GetConsumptionItem(string p_name, E_ITEMTYPE p_type)
    {
        if (EventManager.GetInstance.m_isDragging)
        {
            return;
        }
        m_ItemInfo = ItemManager.GetInstance.GetItem <ConsumeItem>(p_name, p_type); // 아이템 정보 빼오기

        E_CONSUMEITEMS tempEnum = E_CONSUMEITEMS.None;

        tempEnum = Core.GetFiledInfoToReflectionValueType(m_ItemInfo, tempEnum); // object에 저장된 아이템 정보 빼오기

        SetSlotIntoItem(tempEnum);                                               // 슬롯에 아이템 세팅
    }
예제 #3
0
    // 테이블 정보 갱신
    public void TableInfoRenewal()
    {
        object[] tempArr = new object[transform.childCount]; // 1차원 배열로 가져와서 2차원 배열로 옮길것

        // 배열 채우는 용도
        E_EQUIPITEMS   tempEquipEnum   = E_EQUIPITEMS.None;
        E_CONSUMEITEMS tempConsumeEnum = E_CONSUMEITEMS.None;

        for (int i = 0; i < transform.childCount; i++)
        {
            object tempObj = transform.GetChild(i).GetComponent <Slot>().m_ItemInfo; // 제작대 슬롯 별로 접근

            // null 이면 저장하고 continue
            if (tempObj == null)
            {
                tempArr[i] = tempObj; // 제작대 n번째 슬롯 아이템
                continue;
            }
            // 장비 아이템
            else if (tempObj.GetType() == typeof(EquipItem))
            {
                tempObj = Core.GetFiledInfoToReflectionValueType
                              (tempObj, tempEquipEnum); // 해당 슬롯의 아이템값 저장
            }
            // 소비 아이템
            else
            {
                tempObj = Core.GetFiledInfoToReflectionValueType
                              (tempObj, tempConsumeEnum); // 해당 슬롯의 아이템값 저장
            }


            tempArr[i] = tempObj; // 제작대 n번째 슬롯 아이템
        }

        // 1차원 -> 2차원 옮기기
        for (int y = 0; y < m_Row; y++)
        {
            for (int x = 0; x < m_Col; x++)
            {
                m_CreaftingTable[y, x] = tempArr[(y * m_Row) + x];
                //Debug.Log(m_CreaftingTable[y, x]);
            }
        }

        FinishedItem.GetInstance.FinishedCheak(); // 완성 체크
    }
    /*
     * 리스트에서 매개변수로 전달받은 정보와 같은 아이템 찾아서 반환 해주는 함수
     */
    public T GetItem <T>(string p_item, E_ITEMTYPE p_type) where T : class
    {
        T retItem; // 반환할 아이템

        switch (p_type)
        {
        case E_ITEMTYPE.Equipment:
            // 넘어온 아이템 이름 Enum.Parse 해서 Enum 형식으로 할당
            E_EQUIPITEMS tempEquipEnum = (E_EQUIPITEMS)Enum.Parse(typeof(E_EQUIPITEMS), p_item);     // string -> enum

            for (int i = 0; i < m_EquipItemList.Count; i++)
            {
                if (m_EquipItemList[i].m_Item == tempEquipEnum)         // 리스트에서 같은 아이템 찾기
                {
                    retItem = m_EquipItemList[i] as T;                  // 형 변환
                    return(retItem);
                }
            }
            break;

        case E_ITEMTYPE.Consumption:
            // 넘어온 아이템 이름 Enum.Parse 해서 Enum 형식으로 할당
            E_CONSUMEITEMS tempConsumeEnum = (E_CONSUMEITEMS)Enum.Parse(typeof(E_CONSUMEITEMS), p_item);     // string -> enum

            for (int i = 0; i < m_ConsumeItemList.Count; i++)
            {
                if (m_ConsumeItemList[i].m_Item == tempConsumeEnum)         // 리스트에서 같은 아이템 찾기
                {
                    retItem = m_ConsumeItemList[i] as T;                    // 형 변환
                    return(retItem);
                }
            }
            break;
        }

        return(null);
    }
예제 #5
0
    // 장비, 소비 아이템 제작 레시피 설정
    void SetItemRecipe()
    {
        m_ItemList.Add(ItemManager.GetInstance.GetItem <ConsumeItem>(("Stick"), E_ITEMTYPE.Consumption));          // 막대기 추가
        m_ItemList.Add(ItemManager.GetInstance.GetItem <EquipItem>(("WoodenAxe"), E_ITEMTYPE.Equipment));          // 나무 도끼 추가
        m_ItemList.Add(ItemManager.GetInstance.GetItem <EquipItem>(("FishingRod"), E_ITEMTYPE.Equipment));         // 낚싯대 추가
        m_ItemList.Add(ItemManager.GetInstance.GetItem <EquipItem>(("CarrotOnAStick"), E_ITEMTYPE.Equipment));     // 당근 낚싯대 추가

        // 아이템 이름 가져오는 용도
        string         tempstr         = "";
        E_EQUIPITEMS   tempEquipEnum   = E_EQUIPITEMS.None;
        E_CONSUMEITEMS tempConsumeEnum = E_CONSUMEITEMS.None;

        for (int i = 0; i < m_ItemList.Count; i++)
        {
            if (m_ItemList[i].GetType() == typeof(EquipItem)) // 장비
            {
                tempstr = Core.GetFiledInfoToReflectionValueType
                              (m_ItemList[i], tempEquipEnum).ToString(); // i번째 아이템 이름 가져오기
            }
            if (m_ItemList[i].GetType() == typeof(ConsumeItem))          // 소비
            {
                tempstr = Core.GetFiledInfoToReflectionValueType
                              (m_ItemList[i], tempConsumeEnum).ToString(); // i번째 아이템 이름 가져오기
            }


            object[,] recipe = new object[m_Row, m_Col];
            // 막대기
            if (tempstr == "Stick")
            {
                recipe[0, 0] = null;                 recipe[0, 1] = null;                      recipe[0, 2] = null;
                recipe[1, 0] = null;                 recipe[1, 1] = E_CONSUMEITEMS.Wood;       recipe[1, 2] = null;
                recipe[2, 0] = null;                 recipe[2, 1] = E_CONSUMEITEMS.Wood;       recipe[2, 2] = null;
                m_ItemRecipeList.Add(recipe);
                continue;
            }

            // 나무도끼
            if (tempstr == "WoodenAxe")
            {
                recipe[0, 0] = E_CONSUMEITEMS.Wood;  recipe[0, 1] = E_CONSUMEITEMS.Wood;       recipe[0, 2] = null;
                recipe[1, 0] = E_CONSUMEITEMS.Wood;  recipe[1, 1] = E_CONSUMEITEMS.Stick;      recipe[1, 2] = null;
                recipe[2, 0] = null;                 recipe[2, 1] = E_CONSUMEITEMS.Stick;      recipe[2, 2] = null;
                m_ItemRecipeList.Add(recipe);
                continue;
            }

            // 낚싯대
            if (tempstr == "FishingRod")
            {
                recipe[0, 0] = null;                 recipe[0, 1] = null;                      recipe[0, 2] = E_CONSUMEITEMS.Stick;
                recipe[1, 0] = null;                 recipe[1, 1] = E_CONSUMEITEMS.Stick;      recipe[1, 2] = E_CONSUMEITEMS.String;
                recipe[2, 0] = E_CONSUMEITEMS.Stick; recipe[2, 1] = null;                      recipe[2, 2] = E_CONSUMEITEMS.String;
                m_ItemRecipeList.Add(recipe);
                continue;
            }

            // 당근 낚싯대
            if (tempstr == "CarrotOnAStick")
            {
                recipe[0, 0] = null;                recipe[0, 1] = null;                       recipe[0, 2] = null;
                recipe[1, 0] = null;                recipe[1, 1] = E_EQUIPITEMS.FishingRod;    recipe[1, 2] = null;
                recipe[2, 0] = null;                recipe[2, 1] = null;                       recipe[2, 2] = E_CONSUMEITEMS.Carrot;
                m_ItemRecipeList.Add(recipe);
                continue;
            }
        }
    }
예제 #6
0
    public int m_MaxItemCount = 10;                         // 아이템 가질 수 있는 최대 개수

    // 슬롯에 아이템 세팅해주는 함수 (좌측 상단부터 정렬해가며 생성됨)
    void SetSlotIntoItem(E_CONSUMEITEMS p_item)
    {
        Slot           tempSlot;          // n번째 슬롯
        Image          tempImage;         // n번째 슬롯의 Image
        Text           tempText;          // n번째 슬롯의 Text
        int            currItemCount;     // n번째 슬롯의 현재 아이템개수(Text 파싱)
        int            tempVal;           // n번째 슬롯 최대개수 - 가지고 있는 아이템개수(부족한 개수)
        int            getItemCount = 15; // 버튼 클릭으로 가져올 아이템 개수
        E_CONSUMEITEMS tempItem     = E_CONSUMEITEMS.None;

        for (int i = 0; i < Inventroy.GetInstance.m_SlotCount; i++)
        {
            tempSlot = Inventroy.GetInstance.transform.GetChild(i).GetComponent <Slot>();                          // n번째 슬롯 상태 확인용

            if (tempSlot.m_SlotState == E_SLOTSTATE.Full)                                                          // 아이템이 있으면
            {
                tempItem = Core.GetFiledInfoToReflectionValueType <E_CONSUMEITEMS>(tempSlot.m_ItemInfo, tempItem); // 슬롯의 아이템 정보 저장
                if (tempItem != p_item)                                                                            // 다른 아이템이면 다음 슬롯으로 넘어감
                {
                    continue;
                }

                tempText      = tempSlot.transform.GetComponentInChildren <Text>(); // 아이템이 있는 슬롯의 하위 Text컴포넌트에 접근
                currItemCount = int.Parse(tempText.text);                           // 아이템 개수 할당

                if (currItemCount >= m_MaxItemCount)                                // 최대 개수 이면 다음 슬롯으로 넘어감
                {
                    continue;
                }

                // 최대 개수가 아닐 때
                tempVal = m_MaxItemCount - currItemCount;      // 최대개수 보다 부족한 개수

                if (tempVal >= getItemCount)                   // 부족한 개수가 가져올 아이템 개수보다 크면
                {
                    currItemCount += getItemCount;             // 전부 다주고 다음 슬롯으로 넘어감
                    tempText.text  = currItemCount.ToString(); // 변경 내용 저장
                    break;
                }

                // 부족한 개수가 가져올 아이템 개수보다 작으면
                getItemCount  -= tempVal;
                currItemCount += tempVal;                  // 개수 빼서 채워줌
                tempText.text  = currItemCount.ToString(); // 변경 내용 저장
            }

            // 아이템이 없는 슬롯 일때의 처리
            else
            {
                if (getItemCount > 0)
                {
                    tempSlot.m_ItemInfo  = m_ItemInfo;                                            // 슬롯에 아이템 정보 할당
                    tempSlot.m_SlotState = E_SLOTSTATE.Full;                                      // 아이템 있는 상태로 변경
                    tempImage            = tempSlot.transform.GetChild(0).GetComponent <Image>(); // 아이템이 없는 슬롯의 하위 오브젝트 Image 컴포넌트에 접근
                    tempText             = tempImage.transform.GetChild(0).GetComponent <Text>(); // 슬롯의 하위 오브젝트(이미지)의 하위 오브젝트 Text컴포넌트에 접근

                    currItemCount = int.Parse(tempText.text);                                     // 현재 아이템 개수
                    tempVal       = m_MaxItemCount - currItemCount;                               // 최대개수 보다 부족한 개수

                    // 부족한 개수가 가져올 아이템 개수보다 작으면 채워주고 다음 슬롯으로 넘어감
                    if (tempVal < getItemCount)
                    {
                        currItemCount   += tempVal;                                                                                    // 부족한 개수 채워주기
                        getItemCount    -= tempVal;                                                                                    // 채워준 개수만큼 빼기
                        tempImage.sprite = Core.GetFiledInfoToReflectionReferenceType <Sprite>(tempSlot.m_ItemInfo, tempImage.sprite); // Sprite 저장
                        tempText.text    = currItemCount.ToString();                                                                   // 변경 내용 저장
                        tempSlot.UpdateSlotUI();                                                                                       // 슬롯 UI 업데이트
                        continue;
                    }

                    tempImage.sprite = Core.GetFiledInfoToReflectionReferenceType <Sprite>(tempSlot.m_ItemInfo, tempImage.sprite); // Sprite 저장
                    tempText.text    = getItemCount.ToString();                                                                    // 개수 저장
                    tempSlot.UpdateSlotUI();                                                                                       // 슬롯 UI 업데이트
                    break;
                }
            }
        }
    }