#ifndef _CITEM_CLASS_H_ #define _CITEM_CLASS_H_ #include #include #include #include #include "item/ItemMgr.h" #include "item/ItemStructure.h" // 전방 참조 class CCharacter; #define DELITEMLOG(x) (void*)0 //#define DELITEMLOG(x) x namespace Item { class CItem { public: CItem(); CItem(const ItemInfo& itemInfo); // 스크립트로부터 로드한 아이템 데이터를 얻어 온다. const ItemInfo& GetItemInfo() const { return m_ItemInfo; } // Desc : 아이템 정보를 char버퍼로 기록한다. // In : 버퍼, 버퍼 크기 // Out : (Return)성공 여부, nBufferLength_InOut - 기록한 크기 virtual bool SerializeOut(char* lpSerializeItem_Out, size_t& nBufferLength_InOut); // Desc : char버퍼로부터 아이템 정보를 읽어 온다. // In : 버퍼, 버퍼 크기 // Out : (Return)성공 여부, nBufferLength_InOut - 사용한 버퍼 크기 virtual bool SerializeIn(const char* lpSerializeItem_In, size_t& nBufferLength_InOut); inline void MoveItem(ItemPos itemPos); inline unsigned __int64 GetUID(void) const { return m_ItemData.m_dwUID; } inline ItemPos GetPos(void) const { return m_ItemData.m_ItemPos; } inline ItemPos GetRealPos(void) const { return m_itemPos_Real; } inline void SwapPos(void) { std::swap(m_ItemData.m_ItemPos, m_itemPos_Real); } inline unsigned short GetPrototypeID(void) const { return m_ItemData.m_usProtoTypeID; } inline unsigned char GetNumOrDurability(void) const { return m_ItemData.m_cNumOrDurability; } inline unsigned char GetMaxNumOrDurability(void) const { return m_cMaxNumOrDurability; } inline void SetNumOrDurability(unsigned char cNumOrDurability) { m_ItemData.m_cNumOrDurability = cNumOrDurability; } inline void SetMaxNumOrDurability(unsigned char cNumOrDurability) { m_cMaxNumOrDurability = cNumOrDurability; } inline void SetStallPrice(unsigned long dwStallPrice) { m_dwStallPrice = dwStallPrice; } inline unsigned long GetStallPrice(void) const { return m_dwStallPrice; } inline unsigned long GetBuyBlackPrice(void) const { return m_ItemInfo.m_DetailData.m_dwBlackPrice; } inline unsigned long GetBuyMedalPrice(void) const { return m_ItemInfo.m_DetailData.m_dwMedalPrice; } virtual unsigned long GetBuyPrice(void) const; virtual unsigned long GetSellPrice(void) const; virtual unsigned long GetRepairPrice(void) const; virtual unsigned long GetUpgradePrice(void) const; virtual unsigned long GetGraftPrice(void) const; inline const char* GetItemTypeName(void) const { return m_ItemInfo.m_StringData.m_szTypeName; } inline bool IsSet(unsigned long dwDetailDataFlag) const { return dwDetailDataFlag == (m_ItemInfo.m_DetailData.m_dwFlags & dwDetailDataFlag); } inline bool GetEnableRepair(void); inline bool GetEnableStack(void); inline bool GetSocketItem(void); inline bool GetRuneItem(void); inline bool GetTwohandItem(void); inline bool GetEnableEquip(void); inline void SetItemPos(unsigned short wItemPos) { m_ItemData.m_ItemPos.m_cPos = wItemPos; } inline unsigned short GetItemPos(void) { return m_ItemData.m_ItemPos.m_cPos; } inline void SetPos(unsigned char cXIndex, unsigned char cYIndex, unsigned char cZIndex) { m_ItemData.m_ItemPos.SetPos(cXIndex, cYIndex, cZIndex); } inline void SetXIndex(unsigned char cXIndex) { m_ItemData.m_ItemPos.SetXIndex(cXIndex); } inline void SetYIndex(unsigned char cYIndex) { m_ItemData.m_ItemPos.SetYIndex(cYIndex); } inline void SetZIndex(unsigned char cZIndex) { m_ItemData.m_ItemPos.SetZIndex(cZIndex); } inline void SetPos(unsigned short wIndex) { m_ItemData.m_ItemPos.SetPos(wIndex); } // SetUID는 아무때나 함부로 사용하지 마시오! inline void SetUID(unsigned __int64 dwItemUID) { m_ItemData.m_dwUID = dwItemUID; } // S 그레이드 제한값 보정(S 그레이드 이외에는 쓰지 마세요. 공식이 정확하지 않습니다. - by hackermz) virtual void RevisionLimit() { } virtual void RevisionLimit(short* lpattrLimit) { } virtual void RevisionLimit(Item::Attribute::Type eAttributeType, short& attrLImit) { } protected: virtual ~CItem(); const ItemInfo& m_ItemInfo; // 스크립트로부터 로드한 아이템 데이터 ItemData m_ItemData; // DB에 저장되는 아이템 데이터 ItemPos m_itemPos_Real; // 임시 공간이 아닌 아이템 위치 unsigned char m_cMaxNumOrDurability; // 최대 내구도 unsigned long m_dwStallPrice; // 노점상에서의 가격 unsigned long m_dwPrice; // 아이템 가격 (옵션에 의해 갱신되지만 내구도를 고려하지는 않은 값) friend class CItemFactory; }; class CEquipment : public CItem { public: enum EQUIPMENT_ERROR { // 소켓 박기 S_SUCCESS = 0, // 성공 E_SERVER_ERROR = 1, // 서버 에러 E_GET_EQUIP_FAILED = 2, // 장비 얻기 실패 E_GET_GEM_FAILED = 3, // 젬 얻기 실패 E_NOT_EQUIP = 4, // 업그레이드 가능한 아이템 아님 E_NOT_GEM = 5, // 젬 아이템 아님 E_REMOVE_GEM_FAILED = 6, // 젬 제거 실패 E_SOCKET_IS_FULL = 7, // 소켓 슬롯 초과 E_OVER_MAX_SOCKET = 8, // 최대 소켓 초과 E_SOCKET_NOT_MAX = 9, // 소켓 개수가 7개가 아니다. E_SOCKET_NOT_INST = 10, // 소켓에 인스톨된 보석이 없다. // 룬 설치/제거 R_SUCCESS = 0, // 룬 설치/제거 성공. E_GET_RUNE_FAILED = 9, // 룬 개수가 없을때. E_NOT_RUNE = 10, // 룬이 없을때. E_NOT_RUNE_SLOT = 11, // 룬에 빈 소켓이 없을때. E_NOT_RUNE_LEVEL_LIMIT = 12, // 룬에 레벨제한때 문제에 설치할 수 없을때. E_USED_RUNE_SKILL_POINT = 13, // 룬에 추가 스킬 포인트를 사용하고 있어서 제거 할 수 없을때. E_NOT_RUNE_SCRIPT_INFO = 14, // 룬에 스크립트 정보를 얻어올수 없을때. // 강화 E_GET_MINERAL_FAILED = 3, // 광물 얻기 실패 E_NOT_MINERAL = 5, // 광물이 아님 E_NOT_MATCH_MINERAL_TYPE = 6, // 광물 타입 틀림 E_NOT_ENOUGH_MINERAL = 7, // 광물 부족 E_REMOVE_EQUIP_FAILED = 8, // 장비 제거 실패 E_CREATE_SCRAP_FAILED = 9, // 고철 생성 실패 E_SET_SCRAP_FAILED = 10, // 고철 놓기 실패 E_REMOVE_MINERAL_FAILED = 11, // 광물 제거 실패 E_UPGRADE_LEVEL_IS_FULL = 12, // 더 이상 업그레이드를 할 수 없음 E_NOT_ENOUGH_MONEY = 13, // 돈이 부족해서 업그레이드 할 수 없음 S_BROKEN_EQUIP = 14, // 성공했으나 무기 부서짐 (클라이언트로 보내지는 않는다.) E_NOT_UPGRADE_LEVEL = 15, // 옵션 이식 가능한 제련 업그레이드 레벨이 아님. E_NOT_UPGRADE_AS_OVER = 16, // 고대의 돌 이용 회수 초과. E_NOT_UPGRADE_ENDURANCE = 17, // 내구도 회복 아이템 사용 불가. E_NOT_UPGRADE_MINENDURANCE = 18, // 제련가능한 내구도 10이 되지 않습니다. // 옵션 이식 E_WRONG_ATTRIBUTE = 2, // 이식 불가능한 옵션 E_NOT_EQUAL_KIND = 3, // 다른 종류의 장비 E_HIGH_GRADE_ORIGINAL = 4, // 원본의 그레이드가 높음 E_GRAFE_FAILD = 5, // 옵션이식 실패 // 보상 판매 E_WRONG_TYPE = 2, // 보상 판매 대상이 아님 E_NEW_SEASON_EQUIP = 3, // 새로 드랍됬거나 이미 보상된 장비 E_LOW_STATUS_EQUIP = 4 // 너무 낮은 수준의 장비 }; enum PASSIVE_TYPE { PASSIVE_ALWAYS = 0, // 무기에 상관없이 항상 발생하는 패시브 PASSIVE_THIS_WEAPON = 1, // 해당 무기에 발생하는 패시브 NONE_PASSIVE_THIS_WEAPON = 2 // 해당 무기에 발생하지 않는 패시브 }; enum RuneApplyType { RUNE_NONE = 0, RUNE_INDEX = (1 << 0), // 하나에 속성. RUNE_ALL = (1 << 1), // 모든 속성. RUNE_APPLY = (1 << 2), // 속성을 추가. RUNE_REMOVE = (1 << 3) // 속성을 삭제. }; // 아이템을 장비로 Downcast한다. inline static CEquipment* DowncastToEquipment(CItem* lpItem); // Desc : 아이템 정보를 char버퍼로 기록한다. // In : 버퍼, 버퍼 크기 // Out : (Return)성공 여부, nBufferLength_InOut - 기록한 크기 virtual bool SerializeOut(char* lpSerializeItem_Out, size_t& nBufferLength_InOut); // Desc : char버퍼로부터 아이템 정보를 읽어 온다. // In : 버퍼, 버퍼 크기 // Out : (Return)성공 여부, nBufferLength_InOut - 사용한 버퍼 크기 virtual bool SerializeIn(const char* lpSerializeItem_In, size_t& nBufferLength_InOut); // 아이템 속성 추가 (속성 변경 후에는 반드시 가격/그레이드 계산을 다시 해줍시다.) inline void AddAttribute(Item::Attribute::Type eAttributeType, short nAttributeValue); inline void SetAttribute(Item::Attribute::Type eAttributeType, short nAttributeValue); // 3차 밸런스 패치(소켓, 업그레이드 값 제거)0 inline void RemoveUpgradeAttribute(Item::Attribute::Type eAttributeType); inline void RemoveGemAttribute(Item::Attribute::Type eAttributeType); // 아이템 속성을 얻어 온다. inline short GetAttribute(Item::Attribute::Type eAttributeType); inline void GetAttribute(short* lpAttributeArray_Out, unsigned short nArraySize); // 옵션별 한계값에 도달했는지 체크한다. bool CheckAttributeLimit(Item::Attribute::Type eAttributeType, unsigned char cType = 0); inline bool AddSocket(unsigned char cSocket); inline void GetSocket(unsigned char* cSockets, unsigned char cArraySize); unsigned char GetSocket(unsigned char cIndex) { return m_cSocket[cIndex]; } const Grade::GradeInfo& GetItemGrade(void) const { return m_GradeInfo; } inline void InitializeAttribute(void); // 아이템 정보를 상점값으로 초기화 BOOL AddRandomOption(Item::EquipType::Grade eGrade, unsigned char cBaseNum, int iMagicChance = 0); // 소켓 설정 BOOL AddRandomSocket(); // 옵션 이식 EQUIPMENT_ERROR OptionGraft(CEquipment* lpSacrifice, bool bUpgradeLevelLimit, unsigned char cAttributeType, unsigned long dwCurrentGold, unsigned long& dwUsedGold); bool CanOptionGraft(Item::CItemType::ArrayType eItemType, Item::Attribute::Type eAttributeType); // 보상 판매 EQUIPMENT_ERROR Compensation(unsigned char cClass, unsigned char cLevel, CharacterStatus status, CEquipment** lppResultEquip, long& lCompensationGold); unsigned char GetUpgradeLevel(void) const { return m_cUpgradeLevel; } unsigned char GetCurrentSocketNum(void) const { return m_cSocketNum; } unsigned char GetMaxSocketNum(void) const { return m_cMaxSocket; } // 리밸런싱 이후 생성되는 장비는 이 함수를 호출해준다. void SetNewEquip(char cStrong = 0) { if(cStrong == 2) m_cSeasonRecord = 3; else if(cStrong == 1) m_cSeasonRecord = 2; else if(m_cSeasonRecord == 0) m_cSeasonRecord = 1; } unsigned char GetSeasonRecord(void) { return m_cSeasonRecord; } unsigned long GetBuyPrice(void) const; unsigned long GetSellPrice(void) const; unsigned long GetRepairPrice(void) const; unsigned long GetUpgradePrice(void) const; unsigned long GetGraftPrice(void) const; unsigned char GetUpgradeCnt(void) { return m_cUpgradeCnt; } void SetUpgradeCnt(unsigned char cUpgradeCnt) { m_cUpgradeCnt = cUpgradeCnt; } // 업그레이드 가능 여부 리턴 bool IsUpgradable(void) const; // 장착아이템에 룬 소켓 개수 체크 inline unsigned char GetMaxRuneSocket(); // 룬을 아이템에 장착 가능한지 체크 inline unsigned char GetRuneEquipable(); // 장착 아이템에 장착제한에 레벨을 얻어온다. inline unsigned short GetRuneEquipLimitLevel(void) const; // 룬 아이템을 제거(속성도 같이 제거) inline bool SubRuneAttribute(void); // 설치 되어 있는 룬 소켓값을 넘겨준다. inline unsigned short GetRuneSocket(unsigned char cIndex) { if (cIndex >= EquipmentInfo::MAX_RUNE_SOCKET_NUM) { return 0; } return m_usRuneSocket[cIndex]; } // 룬 속성을 삭제한 아이템 속성 복사본을 넘겨준다. inline void GetSubRuneAttribute(short* psAttribute); inline void GetSubRuneAttribute(Item::Attribute::Type eAttributeType, short& sAttribute); // 외부에서 사용할 룬 속성 삭제/추가 inline void SetRuneAttribute(RuneApplyType enRuneApplyType, unsigned char ucIndex); // 장착 아이템에 있는 모든 룬 아이템에 속성중 스킬포인트 리턴해준다. unsigned short GetAllRuneSkillPointCheck(); // 룬 아이템이 장착 되어 있으면 스킬 포인트 체크 bool GetRuneCheckSkill(CCharacter* lpCharacter, Item::ItemPos itemPos, bool bChk = true); // ------------------------------------------------------------------------------------------------------------ // ConvertTool에서만 사용되는 함수들 - RebalanceOverItem.cpp 에서 사용 inline void Repair(); inline void InitEquip(); inline void SetEquip(); // ------------------------------------------------------------------------------------------------------------ // 서버에서만 사용되는 함수들 - ItemServerFunc.cpp 에서 별도 구현 EQUIPMENT_ERROR InstallSocket(CItem& Gem); EQUIPMENT_ERROR UpgradeItem(CItem& Mineral_InOut, unsigned long dwCurrentGold_In, unsigned long& dwUsedGold_Out, unsigned char& cMaxDur_Out); EQUIPMENT_ERROR InstallRuneSocket(CItem& Rune, bool bEquip, unsigned char cLevel); // 장착 아이템에 룬 소켓 설치. EQUIPMENT_ERROR UnInstallRuneSocket(CItem& Rune, bool bEquip, unsigned char cLevel, unsigned short usSkillPoint); // 장착 아이템에 룬 소켓 제거. // ------------------------------------------------------------------------------------------------------------ // 3차 밸런스 패치 관련 함수 // S 그레이드 제한값 구하기 bool GetLimitValue(short* lpattrLimit); bool GetLimitValue(Item::Attribute::Type eAttributeType, short& attrLimit); // S 그레이드 제한값 보정(S 그레이드 이외에는 쓰지 마세요. 공식이 정확하지 않습니다. - by hackermz) void RevisionLimit(); void RevisionLimit(short* lpattrLimit); void RevisionLimit(Item::Attribute::Type eAttributeType, short& attrLImit); // 그레이드 책정 void CalculateItemGrade(void); protected: enum ApplyType { APPLY = 1, // 값 바꾸지 말 것 REMOVE = -1 // 값 바꾸지 말 것 }; CEquipment(const ItemInfo& itemInfo); virtual ~CEquipment(); inline void InitializeGemAttribute(void); // 소켓 정보로 소켓 속성을 초기화 inline void InitializeUpgradeAttribute(void); // 업그레이드 단계로 업그레이드 속성을 초기화 inline void ApplyGemAttribute(ApplyType eApplyType); // 소켓 속성을 적용 inline void ApplyUpgradeAttribute(ApplyType eApplyType); // 업그레이드 속성을 적용 inline void ApplyRuneAttribute(ApplyType eApplyType); // 룬 아이템 속성을 적용 void CalculateItemPrice(void); // 가격 책정 unsigned char m_cSocket[EquipmentInfo::MAX_SOCKET_NUM]; // 아이템 소켓 정보 ItemAttribute m_SocketAttribute[EquipmentInfo::MAX_SOCKET_ATTRIBUTE_NUM]; // 아이템 소켓으로 박은 속성 ItemAttribute m_UpgradeAttribute[EquipmentInfo::MAX_UPGRADE_ATTRIBUTE]; // 아이템 업그레이드시 붙는 속성 unsigned short m_usRuneSocket[EquipmentInfo::MAX_RUNE_SOCKET_NUM]; // 룬 소켓 short m_wAttribute[Attribute::MAX_ATTRIBUTE_NUM]; // 최종적으로 계산된 아이템 속성 (스크립트 + DB + ...) unsigned char m_cUpgradeLevel; // 업그레이드 단계 unsigned char m_cSocketNum; // 현재 소켓 개수 unsigned char m_cMaxSocket; // 최대 소켓 개수 unsigned char m_cMaxAttribute; // 최대 속성 개수 unsigned char m_cSeasonRecord; // 아이템 생성 시기 Grade::GradeInfo m_GradeInfo; // 그레이드 정보 unsigned char m_cUpgradeCnt; friend class CItemFactory; friend class CItemType; }; class CUseItem : public CItem { public: inline static CUseItem* DowncastToUseItem(CItem* lpItem); // ------------------------------------------------------------------------------------------------------------ // 서버에서만 사용되는 함수들 - ItemServerFunc.cpp 에서 별도 구현 bool Use(CCharacter* lpSender, CCharacter* lpRecver, unsigned short& wError); protected: CUseItem(const ItemInfo& itemInfo); virtual ~CUseItem(); bool UsePotion(CCharacter* lpSender, CCharacter* lpRecver); friend class CItemFactory; }; }; inline void Item::CItem::MoveItem(ItemPos itemPos) { if (TakeType::TS_STALL == itemPos.m_cPos) { m_itemPos_Real = itemPos; } else { m_ItemData.m_ItemPos = itemPos; if (TakeType::TS_TEMP != itemPos.m_cPos) { m_itemPos_Real = itemPos; } } } inline Item::CEquipment* Item::CEquipment::DowncastToEquipment(Item::CItem* lpItem) { if (NULL == lpItem) { return NULL; } return lpItem->IsSet(DetailData::EQUIP) ? static_cast(lpItem) : NULL; } inline void Item::CEquipment::AddAttribute(Item::Attribute::Type eAttributeType, short nAttributeValue) { /* // 룬아이템에 속성 추가 if (eAttributeType == Attribute::RUNE && 0 != nAttributeValue) { unsigned short usRuneID = nAttributeValue + EtcItemID::RUNE_START_ID; const ItemInfo* lpRuneInfo = CItemMgr::GetInstance().GetItemInfo(usRuneID); if (NULL != lpRuneInfo) { for (unsigned char cIndex = 0; cIndex < EquipmentInfo::MAX_RUNE_SOCKET_NUM; ++cIndex) { if (0 != m_usRuneSocket[cIndex]) { m_usRuneSocket[cIndex] = usRuneID; for (int nIndex = 0; nIndex < Item::Attribute::MAX_ATTRIBUTE_NUM; ++nIndex) { if (Item::EquipType::S_GRADE != GetItemGrade().m_aryAttributeGrade[nIndex]) { m_wAttribute[nIndex] += lpRuneInfo->m_EquipAttribute.m_usAttributeValue[nIndex]; } } return; } } } } else */ { if (Item::EquipType::S_GRADE != GetItemGrade().m_aryAttributeGrade[eAttributeType]) { m_wAttribute[eAttributeType] += nAttributeValue; } } } inline void Item::CEquipment::SetAttribute(Item::Attribute::Type eAttributeType, short nAttributeValue) { /* // 룬아이템에 속성 추가 if (eAttributeType == Attribute::RUNE && 0 != nAttributeValue) { unsigned short usRuneID = nAttributeValue + EtcItemID::RUNE_START_ID; const ItemInfo* lpRuneInfo = CItemMgr::GetInstance().GetItemInfo(usRuneID); if (NULL != lpRuneInfo) { for (unsigned char cIndex = 0; cIndex < EquipmentInfo::MAX_RUNE_SOCKET_NUM; ++cIndex) { if (0 != m_usRuneSocket[cIndex]) { m_usRuneSocket[cIndex] = usRuneID; for (int nIndex = 0; nIndex < Item::Attribute::MAX_ATTRIBUTE_NUM; ++nIndex) { m_wAttribute[nIndex] = lpRuneInfo->m_EquipAttribute.m_usAttributeValue[nIndex]; } return; } } } } else */ { m_wAttribute[eAttributeType] = nAttributeValue; } } inline void Item::CEquipment::RemoveUpgradeAttribute(Item::Attribute::Type eAttributeType) { ItemAttribute* first = m_UpgradeAttribute; ItemAttribute* last = m_UpgradeAttribute + EquipmentInfo::MAX_UPGRADE_ATTRIBUTE; for (;first != last; ++first) { if(eAttributeType == static_cast(first->m_cType)) { first->m_usValue = 0; } } } inline void Item::CEquipment::RemoveGemAttribute(Item::Attribute::Type eAttributeType) { ItemAttribute* first = m_SocketAttribute; ItemAttribute* last = m_SocketAttribute + EquipmentInfo::MAX_UPGRADE_ATTRIBUTE; for (;first != last; ++first) { if(eAttributeType == static_cast(first->m_cType)) { first->m_usValue = 0; } } } inline bool Item::CEquipment::SubRuneAttribute(void) { // 룬 아이템 제거 for (unsigned char cRune = 0; cRune <= EquipmentInfo::MAX_RUNE_SOCKET_NUM; ++cRune) { if (m_usRuneSocket[cRune]) { unsigned short usItemId = m_usRuneSocket[cRune]; const ItemInfo* itemInfo = CItemMgr::GetInstance().GetItemInfo(usItemId); if (itemInfo) { for (unsigned char cIndex = 0; cIndex < Item::Attribute::MAX_ATTRIBUTE_NUM; ++cIndex) { m_wAttribute[cIndex] -= itemInfo->m_EquipAttribute.m_usAttributeValue[cIndex]; } } m_usRuneSocket[cRune] = 0; } } return true; } inline short Item::CEquipment::GetAttribute(Item::Attribute::Type eAttributeType) { return m_wAttribute[eAttributeType]; } inline void Item::CEquipment::GetAttribute(short* lpAttributeArray_Out, unsigned short nArraySize) { unsigned short nCopyNum = nArraySize < Item::Attribute::MAX_ATTRIBUTE_NUM ? nArraySize : Item::Attribute::MAX_ATTRIBUTE_NUM; for (int nIndex = 0; nIndex < nCopyNum; ++nIndex) { *(lpAttributeArray_Out + nIndex) = GetAttribute(static_cast(nIndex)); } } inline bool Item::CEquipment::AddSocket(unsigned char cSocket) { if (m_cSocketNum < m_cMaxSocket && 0 == m_cSocket[m_cSocketNum]) { m_cSocket[m_cSocketNum] = cSocket; ++m_cSocketNum; return true; } return false; } inline void Item::CEquipment::GetSocket(unsigned char* cSockets, unsigned char cArraySize) { unsigned short nCopyNum = cArraySize < Item::EquipmentInfo::MAX_SOCKET_NUM ? cArraySize : Item::EquipmentInfo::MAX_SOCKET_NUM; unsigned char* lpSocketPastEnd = m_cSocket + nCopyNum; std::copy(m_cSocket, lpSocketPastEnd , cSockets); } inline void Item::CEquipment::InitializeAttribute(void) { for (unsigned int nIndex = 0; nIndex < Item::Attribute::MAX_ATTRIBUTE_NUM; ++nIndex) { m_wAttribute[nIndex] = m_ItemInfo.m_EquipAttribute.m_usAttributeValue[nIndex]; } } inline void Item::CEquipment::InitializeGemAttribute(void) { std::fill_n(m_SocketAttribute, int(EquipmentInfo::MAX_SOCKET_ATTRIBUTE_NUM), ItemAttribute()); // 설치된 소켓을 가지고 속성과 값을 설정 CItemType::SetInstallGemAttribute(this); } inline void Item::CEquipment::InitializeUpgradeAttribute(void) { std::fill_n(m_UpgradeAttribute, int(EquipmentInfo::MAX_UPGRADE_ATTRIBUTE), ItemAttribute()); // 아이템 업그레이드 단계값을 가지고 속성과 값을 설정 CItemType::SetUpgradeItemAttribute(this); } inline void Item::CEquipment::ApplyGemAttribute(ApplyType eApplyType) { ItemAttribute* first = m_SocketAttribute; ItemAttribute* last = m_SocketAttribute + EquipmentInfo::MAX_SOCKET_ATTRIBUTE_NUM; for (;first != last; ++first) { AddAttribute(static_cast(first->m_cType), first->m_usValue * eApplyType); } } inline unsigned char Item::CEquipment::GetMaxRuneSocket() { // 장착아이템에 룬 소켓 개수 체크 return Item::CItemMgr::GetInstance().GetMaxRuneSocket(static_cast(GetItemInfo().m_DetailData.m_cItemType)); } inline unsigned char Item::CEquipment::GetRuneEquipable() { // 장착아이템에 룬 소켓 빈공간 체크 unsigned char cRuneSocketCnt = Item::CItemMgr::GetInstance().GetMaxRuneSocket(static_cast(GetItemInfo().m_DetailData.m_cItemType)); if (!cRuneSocketCnt) { return 0; } if (!m_usRuneSocket[0]) { return 1; } if (!m_usRuneSocket[1] && cRuneSocketCnt == EquipmentInfo::MAX_RUNE_SOCKET_NUM) { return 2; } return 0; } inline void Item::CEquipment::ApplyUpgradeAttribute(ApplyType eApplyType) { ItemAttribute* first = m_UpgradeAttribute; ItemAttribute* last = m_UpgradeAttribute + EquipmentInfo::MAX_UPGRADE_ATTRIBUTE; for (;first != last; ++first) { AddAttribute(static_cast(first->m_cType), first->m_usValue * eApplyType); } } inline void Item::CEquipment::ApplyRuneAttribute(ApplyType eApplyType) { // 룬아이템에 속성 추가/삭제 for (unsigned char cIndex = 0; cIndex < EquipmentInfo::MAX_RUNE_SOCKET_NUM; ++cIndex) { if (m_usRuneSocket[cIndex]) { unsigned short usItemId = m_usRuneSocket[cIndex]; const ItemInfo* itemInfo = CItemMgr::GetInstance().GetItemInfo(usItemId); if (itemInfo) { for (unsigned char cAttribute = 0; cAttribute < Item::Attribute::MAX_ATTRIBUTE_NUM; ++cAttribute) { m_wAttribute[cAttribute] += itemInfo->m_EquipAttribute.m_usAttributeValue[cAttribute]*eApplyType; } } } } } inline void Item::CEquipment::GetSubRuneAttribute(short* psAttribute) { // 룬 속성을 삭제한 아이템 속성 복사본을 넘겨준다. memcpy(psAttribute, m_wAttribute, sizeof(m_wAttribute)); for (unsigned char cIndex = 0; cIndex < EquipmentInfo::MAX_RUNE_SOCKET_NUM; ++cIndex) { if (m_usRuneSocket[cIndex]) { const ItemInfo* itemInfo = CItemMgr::GetInstance().GetItemInfo(m_usRuneSocket[cIndex]); if (itemInfo) { for (unsigned char cAttribute = 0; cAttribute < Item::Attribute::MAX_ATTRIBUTE_NUM; ++cAttribute) { psAttribute[cAttribute] -= itemInfo->m_EquipAttribute.m_usAttributeValue[cAttribute]; } } } } } inline void Item::CEquipment::GetSubRuneAttribute(Item::Attribute::Type eAttributeType, short& sAttribute) { sAttribute = m_wAttribute[eAttributeType]; for (unsigned char cIndex = 0; cIndex < EquipmentInfo::MAX_RUNE_SOCKET_NUM; ++cIndex) { if (m_usRuneSocket[cIndex]) { const ItemInfo* itemInfo = CItemMgr::GetInstance().GetItemInfo(m_usRuneSocket[cIndex]); if (itemInfo) { sAttribute -= itemInfo->m_EquipAttribute.m_usAttributeValue[eAttributeType]; } } } } inline void Item::CEquipment::SetRuneAttribute(RuneApplyType enRuneApplyType, unsigned char ucIndex) { // 외부에서 사용할 룬 속성 삭제/추가. if (enRuneApplyType&RuneApplyType::RUNE_INDEX && enRuneApplyType&RuneApplyType::RUNE_REMOVE) { for (unsigned char ucRuneIndex = 0; ucRuneIndex < EquipmentInfo::MAX_RUNE_SOCKET_NUM; ucRuneIndex++) { if (m_usRuneSocket[ucRuneIndex]) { const ItemInfo* itemInfo = CItemMgr::GetInstance().GetItemInfo(m_usRuneSocket[ucRuneIndex]); if (itemInfo) { m_wAttribute[ucIndex] -= itemInfo->m_EquipAttribute.m_usAttributeValue[ucIndex]; } } } } else if (enRuneApplyType&RuneApplyType::RUNE_ALL && enRuneApplyType&RuneApplyType::RUNE_REMOVE) { ApplyRuneAttribute(REMOVE); } else if (enRuneApplyType&RuneApplyType::RUNE_INDEX && enRuneApplyType&RuneApplyType::RUNE_APPLY) { for (unsigned char ucRuneIndex = 0; ucRuneIndex < EquipmentInfo::MAX_RUNE_SOCKET_NUM; ucRuneIndex++) { if (m_usRuneSocket[ucRuneIndex]) { const ItemInfo* itemInfo = CItemMgr::GetInstance().GetItemInfo(m_usRuneSocket[ucRuneIndex]); if (itemInfo) { m_wAttribute[ucIndex] += itemInfo->m_EquipAttribute.m_usAttributeValue[ucIndex]; } } } } else if (enRuneApplyType&RuneApplyType::RUNE_ALL && enRuneApplyType&RuneApplyType::RUNE_APPLY) { ApplyRuneAttribute(APPLY); } } inline unsigned short Item::CEquipment::GetRuneEquipLimitLevel(void) const { // 장착 아이템에 장착제한에 레벨을 얻어온다. unsigned short usResult = 0; for (unsigned char cIndex = 0; cIndex < EquipmentInfo::MAX_RUNE_SOCKET_NUM; ++cIndex) { if (m_usRuneSocket[cIndex]) { unsigned short usItemId = m_usRuneSocket[cIndex]; const ItemInfo* itemInfo = CItemMgr::GetInstance().GetItemInfo(usItemId); if (itemInfo) { if (itemInfo->m_UseLimit.m_cLimitStatus==Item::StatusLimit::LEVEL) { if (usResultm_UseLimit.m_wLimitValue) { usResult = itemInfo->m_UseLimit.m_wLimitValue; } } } } } return usResult; } inline Item::CUseItem* Item::CUseItem::DowncastToUseItem(CItem* lpItem) { if (NULL == lpItem) { return NULL; } return lpItem->IsSet(DetailData::USE_ITEM) ? static_cast(lpItem) : NULL; } inline bool Item::CItem::GetEnableRepair(void) { unsigned long dwFlags = GetItemInfo().m_DetailData.m_dwFlags; return ((dwFlags & Item::DetailData::EQUIP) && !(dwFlags & Item::DetailData::STACKABLE)); } inline bool Item::CItem::GetEnableStack(void) { return (GetItemInfo().m_DetailData.m_dwFlags & Item::DetailData::STACKABLE) ? true : false; } inline bool Item::CItem::GetEnableEquip(void) { return (GetItemInfo().m_DetailData.m_dwFlags & Item::DetailData::EQUIP); } inline bool Item::CItem::GetSocketItem(void) { return (GetItemInfo().m_DetailData.m_cItemType == Item::ItemType::GEM); } inline bool Item::CItem::GetRuneItem(void) { return (GetItemInfo().m_DetailData.m_cItemType == Item::ItemType::RUNE); } inline bool Item::CItem::GetTwohandItem(void) { unsigned char cItemType = GetItemInfo().m_DetailData.m_cItemType; return (cItemType == Item::ItemType::BOW || cItemType == Item::ItemType::CROSSBOW || cItemType == Item::ItemType::STAFF || cItemType == Item::ItemType::TWOHANDED_AXE || cItemType == Item::ItemType::TWOHANDED_BLUNT || cItemType == Item::ItemType::TWOHANDED_SWORD || cItemType == Item::ItemType::OPP_SYTHE); } // ------------------------------------------------------------------------------------------------------------ // ConvertTool에서만 사용되는 함수들 - RebalanceOverItem.cpp 에서 사용 inline void Item::CEquipment::Repair() { SetNumOrDurability(GetMaxNumOrDurability()); CalculateItemPrice(); } inline void Item::CEquipment::InitEquip() { // 옵션 이식을 하기전에 룬 추가 옵션을 삭제한다. RuneApplyType enRuneApplyType = static_cast(RUNE_ALL | RUNE_REMOVE); SetRuneAttribute(enRuneApplyType, 0); // 제련 단계는 초기화된다. (옵션은 남는다.) m_cUpgradeLevel = 0; InitializeUpgradeAttribute(); // 소켓도 초기화된다. (보석은 모두 제거되지만 옵션은 남는다.) m_cSocketNum = 0; std::fill_n(m_cSocket, unsigned char(Item::EquipmentInfo::MAX_SOCKET_NUM), 0); InitializeGemAttribute(); m_cMaxSocket = m_ItemInfo.m_DetailData.m_cMaxSocketNum; } inline void Item::CEquipment::SetEquip() { // 룬 속성을 다시 추가한다. RuneApplyType enRuneApplyType = static_cast(RUNE_ALL | RUNE_APPLY); SetRuneAttribute(enRuneApplyType, 0); } #endif