1552 lines
39 KiB
C++
1552 lines
39 KiB
C++
#ifndef _SOLAR_SLOT_SCITEMSLOT_INL
|
|
#error "Can't direct include header file"
|
|
#endif
|
|
|
|
//--------------------------------------------------------------------------------------------------
|
|
//
|
|
|
|
|
|
inline
|
|
SCItemSlot::SCItemSlot(const SCItemSlot& r)
|
|
{
|
|
// all copy ok (090929) current
|
|
CopyMemory(this, &r, sizeof(*this));
|
|
random_info_.item_info_ = NULL;
|
|
random_info_.Copy(r.random_info_);
|
|
}
|
|
|
|
inline SCItemSlot&
|
|
SCItemSlot::operator=(const SCItemSlot& r)
|
|
{
|
|
// all copy ok (090929) current
|
|
CopyMemory(this, &r, sizeof(*this));
|
|
random_info_.item_info_ = NULL;
|
|
random_info_.Copy(r.random_info_);
|
|
return *this;
|
|
}
|
|
/* (CHANGES) (f100520.1L) remove an unused section
|
|
inline
|
|
SCItemSlot::SCItemSlot(const ITEMSTREAM& item_stream)
|
|
{
|
|
Copy(item_stream);
|
|
}
|
|
*/
|
|
inline
|
|
SCItemSlot::SCItemSlot(const ITEMSTREAMEX& item_stream)
|
|
{
|
|
Copy(item_stream);
|
|
}
|
|
/* (CHANGES) (f100520.1L) remove an unused section
|
|
inline
|
|
SCItemSlot::SCItemSlot(const RENDER_ITEMSTREAM& item_stream)
|
|
{
|
|
Copy(item_stream);
|
|
}
|
|
*/
|
|
inline
|
|
SCItemSlot::SCItemSlot(const RENDER_ITEMSTREAMEX& item_stream)
|
|
{
|
|
Copy(item_stream);
|
|
}
|
|
|
|
inline
|
|
SCItemSlot::SCItemSlot(const OPT_ITEMSTREAMEX& item_stream)
|
|
{
|
|
Copy(item_stream);
|
|
}
|
|
|
|
/* (CHANGES) (f100520.1L) remove an unused section
|
|
inline void
|
|
SCItemSlot::Copy(const ITEMSTREAM& item_stream)
|
|
{
|
|
CopyPart(item_stream.Part);
|
|
}
|
|
*/
|
|
inline void
|
|
SCItemSlot::Copy(const ITEMSTREAMEX& item_stream)
|
|
{
|
|
CopyPart(item_stream.Part);
|
|
CopyPart(item_stream.OptionPart);
|
|
}
|
|
/* (CHANGES) (f100520.1L) remove an unused section
|
|
inline void
|
|
SCItemSlot::Copy(const RENDER_ITEMSTREAM& IN item_stream)
|
|
{
|
|
CopyPart(item_stream.Part);
|
|
}
|
|
*/
|
|
inline void
|
|
SCItemSlot::Copy(const RENDER_ITEMSTREAMEX& IN item_stream)
|
|
{
|
|
CopyPart(item_stream.Part);
|
|
CopyPart(item_stream.OptionPart);
|
|
}
|
|
|
|
// 2006/5/16 : 추가
|
|
inline void
|
|
SCItemSlot::Copy(const OPT_ITEMSTREAMEX& IN item_stream)
|
|
{
|
|
CopyPart(item_stream.Part);
|
|
CopyPart(item_stream.OptionPart);
|
|
}
|
|
/* (CHANGES) (f100520.1L) remove an unused section
|
|
inline void
|
|
SCItemSlot::CopyOut(ITEMSTREAM& OUT item_stream) const
|
|
{
|
|
CopyOutPart(item_stream.Part);
|
|
}
|
|
*/
|
|
inline void
|
|
SCItemSlot::CopyOut(ITEMSTREAMEX& OUT item_stream) const
|
|
{
|
|
CopyOutPart(item_stream.Part);
|
|
CopyOutPart(item_stream.OptionPart);
|
|
}
|
|
|
|
inline void
|
|
SCItemSlot::CopyOut(RENDER_ITEMSTREAMEX& OUT item_stream) const
|
|
{
|
|
CopyOutPart(item_stream.Part);
|
|
CopyOutPart(item_stream.OptionPart);
|
|
}
|
|
/* (CHANGES) (f100520.1L) remove an unused section
|
|
inline void
|
|
SCItemSlot::CopyOut(RENDER_ITEMSTREAM& OUT item_stream) const //< 시리얼+옵션 제외
|
|
{
|
|
CopyOutPart(item_stream.Part);
|
|
}
|
|
*/
|
|
// 2005/5/16 : 추가
|
|
inline void
|
|
SCItemSlot::CopyOut(OPT_ITEMSTREAMEX& OUT item_stream) const
|
|
{
|
|
CopyOutPart(item_stream.Part);
|
|
CopyOutPart(item_stream.OptionPart);
|
|
}
|
|
|
|
|
|
//--------------------------------------------------------------------------------------------------
|
|
// (CHANGES) (091212) (WAVERIX) change light-weight properties to inline functions
|
|
// |LIST=(Get/Set)Type, GetWorldSerial, (Get/Set)Code, (Get/Set)SlotType, GetSerial, GetDura, Clear|
|
|
//
|
|
inline BYTE
|
|
SCItemSlot::GetType() const {
|
|
return m_byType;
|
|
}
|
|
|
|
inline void
|
|
SCItemSlot::SetType(BYTE type) {
|
|
m_byType = type;
|
|
}
|
|
|
|
inline DBWLDSERIAL
|
|
SCItemSlot::GetWorldSerial() const {
|
|
return m_WorldSerial;
|
|
}
|
|
|
|
inline SLOTCODE
|
|
SCItemSlot::GetCode() const {
|
|
return item_code_;
|
|
}
|
|
|
|
// NOTE: f110422.3L, add default accessability to easy acquisition
|
|
inline SLOTCODE
|
|
SCItemSlot::GetItemCode() const {
|
|
return item_code_;
|
|
};
|
|
|
|
inline SLOTCODE
|
|
SCItemSlot::GetImageCode() const {
|
|
return image_item_code_;
|
|
}
|
|
|
|
inline void
|
|
SCItemSlot::SetSlotType(eSlotType type) {
|
|
SlotType_info_ = type;
|
|
}
|
|
|
|
inline eSlotType
|
|
SCItemSlot::GetSlotType() const {
|
|
return SlotType_info_;
|
|
}
|
|
|
|
inline eSlotType
|
|
CSVendorItem::GetSlotType() const {
|
|
return ST_VENDORSEARCH;
|
|
}
|
|
|
|
|
|
inline DBSERIAL
|
|
SCItemSlot::GetSerial() const {
|
|
return m_dwSerial;
|
|
}
|
|
|
|
inline bool
|
|
SCItemSlot::WithDura() const
|
|
{
|
|
// pseudo
|
|
// if 내구도로 사용하는가?
|
|
// (true)
|
|
// elif 개수로 사용하는가?
|
|
// (false)
|
|
if (item_rule_info_.is_valid_item == false) {
|
|
return false;
|
|
}
|
|
// 무기, 방어구
|
|
if (item_rule_info_.is_weapon == false &&
|
|
item_rule_info_.is_armor == false)
|
|
{
|
|
return false;
|
|
}
|
|
// 최초 내구도가 없는 경우... 이것은 스크립트 유효성 검사에서 선결되어야 하는 문제이긴 한데...
|
|
if (item_info_->m_Dura == 0) {
|
|
return false;
|
|
}
|
|
return true;
|
|
}
|
|
|
|
inline DURATYPE
|
|
SCItemSlot::GetDura() const {
|
|
assert(WithDura());
|
|
return duration_;
|
|
}
|
|
|
|
inline void
|
|
SCItemSlot::Clear()
|
|
{
|
|
SCSlot::Clear();
|
|
#ifdef _NA_003740_20111122_RANDOM_ITEM
|
|
random_info_.Clear();
|
|
#endif // _NA_003740_20111122_RANDOM_ITEM
|
|
ZeroMemory(item_slot_point_holder_start_, // end
|
|
static_cast<size_t>(&item_slot_point_holder_last_[2] - item_slot_point_holder_start_));
|
|
}
|
|
|
|
// (WAVERIX) (CHANGES) support for client, 올바른 아이템 검증을 위해 추가 - no define work
|
|
// (NOTE) 해당 ItemSlot은 어떠한 연산을 수행하기 위해 올바른 정보를 가지고 있는가?
|
|
// 예외: empty slot의 경우는 SetCode등을 필두로 IO는 가능하다. 이 함수는 있다는 전제하에
|
|
// 처리되는 일련의 연산을 검증하기 위한 수단
|
|
// (returns) false : invalid item | empty item
|
|
// true : valid item
|
|
inline bool
|
|
SCItemSlot::IsContainValidItem() const {
|
|
// empty item slot
|
|
if (item_code_ == 0) {
|
|
return false;
|
|
}
|
|
// invalid item (exist code but, can't find info in item script)
|
|
if (item_info_ == NULL || item_info_->m_Code == 0) {
|
|
return false;
|
|
}
|
|
return item_rule_info_.is_valid_item;
|
|
}
|
|
|
|
//inline BASE_ITEMINFO*
|
|
//SCItemSlot::GetItemInfo()
|
|
//{
|
|
// // (NOTE) item_info_ != &Null_ItemInfo -- 정상
|
|
// // item_info_ == &Null_ItemInfo -- 비정상
|
|
// if (item_info_ != NULL) {
|
|
// return const_cast<BASE_ITEMINFO*>(item_info_); //부디 외부에서 제어 안되길...
|
|
// }
|
|
// // 비어 있는 슬롯에 대한 연산시 발생하게 될 것이다. 또는 연산 사용 순서를 확인할 필요 있음.
|
|
// // 초기화된 슬롯에 GetItemInfo()를 호출할 경우에도 발생
|
|
// // (NOTE) 너무 일반화 되어 있는 관계로 assert제거
|
|
// //assert(!"check valid operation: not initialized");
|
|
// return const_cast<BASE_ITEMINFO*>(&Null_ItemInfo);
|
|
//}
|
|
|
|
inline const BASE_ITEMINFO* SCItemSlot::GetItemInfo() const
|
|
{
|
|
#ifdef _NA_003740_20111122_RANDOM_ITEM
|
|
const BASE_ITEMINFO* const rand_item_info = random_info_.GetItemInfo();
|
|
if (rand_item_info != NULL)
|
|
{
|
|
return rand_item_info;
|
|
}
|
|
#endif
|
|
// (NOTE) item_info_ != &Null_ItemInfo -- 정상
|
|
// item_info_ == &Null_ItemInfo -- 비정상
|
|
if (item_info_ != NULL) {
|
|
return item_info_; //부디 외부에서 제어 안되길...
|
|
}
|
|
// 비어 있는 슬롯에 대한 연산시 발생하게 될 것이다. 또는 연산 사용 순서를 확인할 필요 있음.
|
|
// 초기화된 슬롯에 GetItemInfo()를 호출할 경우에도 발생
|
|
// (NOTE) 너무 일반화 되어 있는 관계로 assert제거
|
|
//assert(!"check valid operation: not initialized");
|
|
return &Null_ItemInfo;
|
|
}
|
|
|
|
inline const BASE_ITEMINFO*
|
|
SCItemSlot::GetImageItemInfo() const
|
|
{
|
|
if (image_item_info_ != NULL) {
|
|
return image_item_info_;
|
|
}
|
|
return NULL;
|
|
}
|
|
|
|
inline const nsSlot::ItemRuleInfo&
|
|
SCItemSlot::GetItemRuleInfo() const {
|
|
return item_rule_info_;
|
|
}
|
|
|
|
//--------------------------------------------------------------------------------------------------
|
|
// Lock/Block
|
|
inline bool
|
|
SCItemSlot::IsLocked() const {
|
|
return !!lock_info_.locked_;
|
|
}
|
|
|
|
inline void
|
|
SCItemSlot::SetLock(bool val) {
|
|
lock_info_.locked_ = !!val;
|
|
}
|
|
|
|
inline bool
|
|
SCItemSlot::IsBlocked() const {
|
|
//return (lock_info_.blocked_ == 1);
|
|
return lock_info_.blocked_ != false;
|
|
}
|
|
|
|
inline void
|
|
SCItemSlot::SetBlocked(BOOL val) {
|
|
lock_info_.blocked_ = !!val;
|
|
}
|
|
|
|
// Game issue에 의해 락을 걸어야 하는 경우, ex) 펫/라이더 소환 상태
|
|
// same interface 'IsPetLocked()', 'IsRiderLocked()'
|
|
inline bool
|
|
SCItemSlot::IsUserBlocked() const {
|
|
return lock_info_.user_blocked_ != false;
|
|
}
|
|
|
|
inline void
|
|
SCItemSlot::SetUserBlocked(BOOL val) {
|
|
lock_info_.user_blocked_ = !!val;
|
|
}
|
|
|
|
// f100909.1L
|
|
inline void SCItemSlot::SetOptionTag(const KindOfItemTag& tag) {
|
|
lock_info_.item_tag_ = tag;
|
|
};
|
|
|
|
inline const KindOfItemTag& SCItemSlot::GetOptionTag() const {
|
|
return lock_info_.item_tag_;
|
|
};
|
|
|
|
// f100910.1L, (for inheritable tag option) related "f100909.1L' and "(Get/Set)OptionTag()"
|
|
// WARNING: this method is not support a stat change operation.
|
|
// NOTE: usage case = { make a clone item, making item from a lottery item, and that. }
|
|
// added by issues of _NA000424_GLOBAL_CASH_ITEM_RENEWAL_
|
|
inline bool SCItemSlot::CopyFromInheritableOption(const SCItemSlot& src)
|
|
{
|
|
lock_info_.item_tag_ = src.lock_info_.item_tag_;
|
|
return true;
|
|
}
|
|
|
|
//--------------------------------------------------------------------------------------------------
|
|
// 개수
|
|
inline DURATYPE
|
|
SCItemSlot::GetMaxNum() const {
|
|
if (item_info_) {
|
|
return item_info_->m_byDupNum;
|
|
}
|
|
assert(0);
|
|
return 0;
|
|
}
|
|
|
|
inline bool
|
|
SCItemSlot::IsOverlap() const
|
|
{
|
|
if (item_rule_info_.is_can_overlap) {
|
|
return true;
|
|
}
|
|
return false;
|
|
}
|
|
|
|
//--------------------------------------------------------------------------------------------------
|
|
// 공유 정보를 재 정의해서 사용할 수 있는가? (아이템 타입별 설정 가부가 존재한다.)
|
|
inline bool
|
|
SCItemSlot::_CanReuseSharedBlock() const {
|
|
return item_rule_info_.is_valid_item && item_rule_info_.is_use_shared == false;
|
|
}
|
|
|
|
//--------------------------------------------------------------------------------------------------
|
|
// Divine Option (old comment) Set 정보
|
|
// same interface 'GetSet'
|
|
inline bool
|
|
SCItemSlot::IsDivine() const {
|
|
//return (m_Set == 1); // set자체 1bit사용한다.
|
|
if (item_rule_info_.func_attr.value & item_rule_info_.func_attr.eEnable_Divine) {
|
|
return !!equip_info_.is_divine_;
|
|
}
|
|
return 0;
|
|
}
|
|
|
|
inline void
|
|
SCItemSlot::SetSet(BYTE set)
|
|
{
|
|
if (item_rule_info_.is_editable == false) {
|
|
return;
|
|
}
|
|
if (item_rule_info_.func_attr.value & item_rule_info_.func_attr.eEnable_Divine) {
|
|
// (WAVERIX) (090930) (NOTE) 현 시점 논리 판단 상, 디바인 설정은 lucky제외 모두 설정
|
|
// 얻을 때는 accessory제외? -> 일단 디바인은 accessory계열은 없다고 확인을 받은 사항이긴 하다.
|
|
equip_info_.is_divine_ = !!set;
|
|
}
|
|
}
|
|
|
|
inline bool
|
|
SCItemSlot::GetSet() const
|
|
{
|
|
if (item_rule_info_.func_attr.value & item_rule_info_.func_attr.eEnable_Divine) {
|
|
return !!equip_info_.is_divine_;
|
|
}
|
|
return 0;
|
|
}
|
|
|
|
//--------------------------------------------------------------------------------------------------
|
|
// Enchant Option
|
|
|
|
inline BYTE
|
|
SCItemSlot::GetEnchant() const
|
|
{
|
|
if (item_rule_info_.func_attr.value & item_rule_info_.func_attr.eEnable_Enchant) {
|
|
return equip_info_.enchant_grade_;
|
|
}
|
|
return 0;
|
|
}
|
|
|
|
inline void
|
|
SCItemSlot::SetEnchant(BYTE enchant)
|
|
{
|
|
if (item_rule_info_.is_editable == false) {
|
|
return;
|
|
}
|
|
if (item_rule_info_.func_attr.value & item_rule_info_.func_attr.eEnable_Enchant) {
|
|
if (enchant <= MAX_ENCHANT_GRADE) {
|
|
equip_info_.enchant_grade_ = enchant;
|
|
}
|
|
}
|
|
|
|
// logging?
|
|
}
|
|
|
|
inline eENCHANTLEVEL
|
|
SCItemSlot::GetEnchantLV() const
|
|
{
|
|
if (item_rule_info_.func_attr.value & item_rule_info_.func_attr.eEnable_Enchant) {
|
|
switch(equip_info_.enchant_grade_)
|
|
{
|
|
case 0: case 1: case 2:
|
|
case 3: case 4: case 5:
|
|
case 6:
|
|
return ENCHANT_LOW;
|
|
case 7: case 8: case 9:
|
|
return ENCHANT_MIDDLE;
|
|
case 10: case 11: case 12:
|
|
return ENCHANT_HIGH;
|
|
#ifdef _NA_003966_20111227_ADD_ENCHANT
|
|
case 13: case 14: case 15:
|
|
return ENCHANT_HIGHEST;
|
|
#endif
|
|
}
|
|
}
|
|
return ENCHANT_LOW;
|
|
}
|
|
|
|
//(lst1024)(080918)(2447)인챈트시 내구도를 다시 셋팅 해준다.
|
|
inline void
|
|
SCItemSlot::SetEnchantUpdateDura(BYTE enchant) {
|
|
if (item_rule_info_.is_editable == false) {
|
|
return;
|
|
}
|
|
SetEnchant(enchant);
|
|
SetDura(GetMaxDura());
|
|
}
|
|
|
|
//--------------------------------------------------------------------------------------------------
|
|
// Awakening Option
|
|
#ifdef _NA_008124_20150313_AWAKENING_SYSTEM
|
|
inline void SCItemSlot::SetAwakening( BYTE awakening )
|
|
{
|
|
if (item_rule_info_.is_editable == false) {
|
|
return;
|
|
}
|
|
if (item_rule_info_.func_attr.value & item_rule_info_.func_attr.eEnable_Awakening) {
|
|
if (awakening <= MAX_AWAKENING_GRADE) {
|
|
equip_info_.awakening_grade_ = awakening;
|
|
}
|
|
}
|
|
}
|
|
|
|
inline BYTE SCItemSlot::GetAwakening() const
|
|
{
|
|
if (item_rule_info_.func_attr.value & item_rule_info_.func_attr.eEnable_Awakening) {
|
|
return equip_info_.awakening_grade_;
|
|
}
|
|
return 0;
|
|
}
|
|
|
|
inline bool SCItemSlot::EnableAwakening() const
|
|
{
|
|
if (item_rule_info_.IsEnableAwakening() == false)
|
|
{
|
|
return false;
|
|
}
|
|
|
|
if (item_info_ == NULL)
|
|
{
|
|
return false;
|
|
}
|
|
|
|
return true;
|
|
}
|
|
|
|
#endif // _NA_008124_20150313_AWAKENING_SYSTEM
|
|
//--------------------------------------------------------------------------------------------------
|
|
// Rank Option
|
|
inline eRANK
|
|
SCItemSlot::GetRank() const
|
|
{
|
|
if (item_rule_info_.func_attr.value & item_rule_info_.func_attr.eEnable_Rank) {
|
|
if (item_rule_info_.is_weapon || item_rule_info_.is_armor) {
|
|
return static_cast<eRANK>(rank_info_.current_rank_);
|
|
}
|
|
else if (item_rule_info_.is_accessory) {
|
|
return static_cast<eRANK>(rank_info_.current_rank_);
|
|
}
|
|
// special accessory는?
|
|
}
|
|
return RANK_E;
|
|
}
|
|
|
|
inline int
|
|
SCItemSlot::GetRankAttrIndex(eRANK rank) const {
|
|
if (item_rule_info_.func_attr.value & item_rule_info_.func_attr.eEnable_Rank) {
|
|
return rank_info_.GetRankAttrBlock(rank).attr_index_;
|
|
}
|
|
// 여기 좀 더 확인할 것.
|
|
return 0;
|
|
}
|
|
|
|
inline eATTR_TYPE
|
|
SCItemSlot::GetRankAttr(eRANK rank) const {
|
|
if (item_rule_info_.func_attr.value & item_rule_info_.func_attr.eEnable_Rank) {
|
|
return rank_info_.GetRankAttrBlock(rank).attr_type_;
|
|
}
|
|
return eATTR_TYPE_INVALID;
|
|
}
|
|
|
|
inline int
|
|
SCItemSlot::GetRankAttrValue(eRANK rank) const {
|
|
if (item_rule_info_.func_attr.value & item_rule_info_.func_attr.eEnable_Rank) {
|
|
return rank_info_.GetRankAttrBlock(rank).attr_value_;
|
|
}
|
|
return 0;
|
|
}
|
|
|
|
inline const sRANK_OPTION*
|
|
SCItemSlot::GetRankAttrDesc(eRANK rank) const {
|
|
if (item_rule_info_.func_attr.value & item_rule_info_.func_attr.eEnable_Rank) {
|
|
return rank_info_.GetRankAttrBlock(rank).rank_option_;
|
|
}
|
|
return 0;
|
|
}
|
|
|
|
#if DEPRECATE_CODE_DELETE_RESERVED //<- delete reserved section
|
|
// 랭크 옵션 정보
|
|
DEPRECATE_RESERVED inline void
|
|
SCItemSlot::SetRank(eRANK rank) {
|
|
// _NA000109_100427_ITEM_CUSTOMIZING_CONTENTS_
|
|
if (item_rule_info_.is_editable == false ||
|
|
lock_info_.history_.value == lock_info_.history_.Combined)
|
|
{
|
|
return;
|
|
}
|
|
if (item_rule_info_.func_attr.value & item_rule_info_.func_attr.eEnable_Rank)
|
|
{
|
|
if (RANK_E <= rank && rank < RANK_MAX) {
|
|
rank_info_.current_rank_ = static_cast<BYTE>(rank);
|
|
}
|
|
return;
|
|
}
|
|
assert(0);
|
|
}
|
|
|
|
//void SetRankAttr(eRANK rank, int iAttrIndex, int iValue) {
|
|
//rank_info_.SetRankAttr(rank,iAttrIndex,iValue); }
|
|
|
|
DEPRECATE_RESERVED inline void
|
|
SCItemSlot::SetRankAttr(eRANK rank, const sRANK_OPTION* rank_option) {
|
|
// _NA000109_100427_ITEM_CUSTOMIZING_CONTENTS_
|
|
if (item_rule_info_.is_editable == false ||
|
|
lock_info_.history_.value == lock_info_.history_.Combined)
|
|
{
|
|
return;
|
|
}
|
|
if (item_rule_info_.func_attr.value & item_rule_info_.func_attr.eEnable_Rank) {
|
|
rank_info_.SetRankAttr(rank, rank_option);
|
|
return;
|
|
}
|
|
assert(0);
|
|
}
|
|
|
|
DEPRECATE_RESERVED inline void
|
|
SCItemSlot::DelRankAttr(eRANK rank) {
|
|
// _NA000109_100427_ITEM_CUSTOMIZING_CONTENTS_
|
|
if (item_rule_info_.is_editable == false ||
|
|
lock_info_.history_.value == lock_info_.history_.Combined)
|
|
{
|
|
return;
|
|
}
|
|
if (item_rule_info_.func_attr.value & item_rule_info_.func_attr.eEnable_Rank) {
|
|
rank_info_.DelRankAttr(rank);
|
|
return;
|
|
}
|
|
assert(0);
|
|
}
|
|
|
|
#endif //WAVERIX_DELETE_RESERVED<- delete reserved section
|
|
|
|
|
|
//--------------------------------------------------------------------------------------------------
|
|
// Fate Option
|
|
|
|
inline bool
|
|
SCItemSlot::IsFateItem() const
|
|
{
|
|
if (item_rule_info_.is_fate) {
|
|
return true;
|
|
}
|
|
return false;
|
|
}
|
|
|
|
|
|
inline WORD
|
|
SCItemSlot::GetFateAtkDefRatio() const {
|
|
if (item_rule_info_.is_fate) {
|
|
return shared_.fate_info_.ratio_;
|
|
}
|
|
assert(0);
|
|
return 0;
|
|
}
|
|
|
|
inline bool
|
|
SCItemSlot::GetFateIdentify() const {
|
|
if (item_rule_info_.is_fate) {
|
|
return (shared_.fate_info_.identify_ != false);
|
|
}
|
|
assert(0);
|
|
return 0;
|
|
}
|
|
|
|
inline DURATYPE
|
|
SCItemSlot::GetFateDuraMax() const {
|
|
if (item_rule_info_.is_fate) {
|
|
return shared_.fate_info_.max_duration_;
|
|
}
|
|
assert(0);
|
|
return 0;
|
|
}
|
|
|
|
inline WORD
|
|
SCItemSlot::GetFatePeriod() const {
|
|
if (item_rule_info_.is_fate) {
|
|
return shared_.fate_info_.period_;
|
|
}
|
|
assert(0);
|
|
return 0;
|
|
}
|
|
|
|
//inline void
|
|
//SCItemSlot::SetFateAtkDefRatio(WORD value);
|
|
inline void
|
|
SCItemSlot::SetFateIdentify(BOOL identify) {
|
|
if (item_rule_info_.is_editable == false) {
|
|
return;
|
|
}
|
|
if (item_rule_info_.is_fate) {
|
|
shared_.fate_info_.identify_ = !!identify;
|
|
return;
|
|
}
|
|
assert(0);
|
|
}
|
|
//inline void
|
|
//SCItemSlot::SetFateDuraMax(WORD value);
|
|
inline void
|
|
SCItemSlot::SetFatePeriod(WORD period) {
|
|
if (item_rule_info_.is_editable == false) {
|
|
return;
|
|
}
|
|
if (item_rule_info_.is_fate) {
|
|
shared_.fate_info_.period_ = period;
|
|
return;
|
|
}
|
|
assert(0);
|
|
}
|
|
|
|
//----------------------------------------------------------------------------------------------
|
|
// Socket Option information
|
|
inline BYTE
|
|
SCItemSlot::GetSocketNum() const {
|
|
if (item_rule_info_.func_attr.value & item_rule_info_.func_attr.eEnable_Socket) {
|
|
return socket_info_.number_of_sockets_;
|
|
}
|
|
//assert(0); // (NOTE) 기존에 워낙 그냥 호출하는 사례들이 많아서 assert제거
|
|
return 0;
|
|
}
|
|
|
|
inline void DEPRECATE_RESERVED
|
|
SCItemSlot::SetSocketNum(BYTE num) {
|
|
if (item_rule_info_.is_editable == false) {
|
|
return;
|
|
}
|
|
if (item_rule_info_.func_attr.value & item_rule_info_.func_attr.eEnable_Socket) {
|
|
if (num <= SOCKET_MAX) {
|
|
socket_info_.number_of_sockets_ = num;
|
|
return;
|
|
}
|
|
}
|
|
assert(0);
|
|
}
|
|
|
|
#ifdef _NA_0_20100727_SOCKET_SYSTEM_CONVERT
|
|
inline eSOCKET_IDENTIFY_TYPE SCItemSlot::GetSocketIdentifyType() const
|
|
{
|
|
|
|
if (item_rule_info_.func_attr.value & item_rule_info_.func_attr.eEnable_Socket)
|
|
{
|
|
|
|
return static_cast<eSOCKET_IDENTIFY_TYPE>(socket_info_.socket_identify_type_);
|
|
}
|
|
|
|
return eSOCKET_IDENTIFY_NOT_PROCESS;
|
|
}
|
|
|
|
inline void SCItemSlot::SetSocketIdentifyType(const eSOCKET_IDENTIFY_TYPE socket_identify_type)
|
|
{
|
|
if (item_rule_info_.is_editable == false)
|
|
{
|
|
return;
|
|
}
|
|
if (item_rule_info_.func_attr.value & item_rule_info_.func_attr.eEnable_Socket)
|
|
{
|
|
|
|
socket_info_.socket_identify_type_ = static_cast<BYTE>(socket_identify_type);
|
|
return;
|
|
}
|
|
assert(false);
|
|
}
|
|
|
|
inline void
|
|
SCItemSlot::SetSocketOption(eSOCKET sock, SOCKETINDEX index)
|
|
{
|
|
if (item_rule_info_.is_editable == false)
|
|
return;
|
|
|
|
if (item_rule_info_.func_attr.value & item_rule_info_.func_attr.eEnable_Socket)
|
|
{
|
|
socket_info_.SetSocketOption(sock, index);
|
|
return;
|
|
}
|
|
assert(0);
|
|
}
|
|
|
|
inline const sSOCKET_OPTION*
|
|
SCItemSlot::GetSocketOption(eSOCKET sock) const
|
|
{
|
|
if (item_rule_info_.func_attr.value & item_rule_info_.func_attr.eEnable_Socket) {
|
|
return socket_info_.GetSocketOption(sock);
|
|
}
|
|
//assert(0);
|
|
return NULL;
|
|
}
|
|
|
|
inline void
|
|
SCItemSlot::CopySocketInfo(const SCSocketOptionInfo& sock_info)
|
|
{
|
|
if (item_rule_info_.is_editable == false) {
|
|
return;
|
|
}
|
|
if (item_rule_info_.func_attr.value & item_rule_info_.func_attr.eEnable_Socket) {
|
|
socket_info_.CopySocketInfo(sock_info);
|
|
return;
|
|
}
|
|
assert(0);
|
|
return;
|
|
}
|
|
|
|
inline const SCSocketOptionInfo&
|
|
SCItemSlot::GetSocketInfo()
|
|
{
|
|
if (!(item_rule_info_.func_attr.value & item_rule_info_.func_attr.eEnable_Socket)) {
|
|
assert(0); //
|
|
}
|
|
return socket_info_;
|
|
}
|
|
#else // _NA_0_20100727_SOCKET_SYSTEM_CONVERT
|
|
inline void
|
|
SCItemSlot::SetSocketAttr(eSOCKET sock, eSOCKET_LEVEL level, const sSOCKET_OPTION* socket_option) {
|
|
if (item_rule_info_.is_editable == false) {
|
|
return;
|
|
}
|
|
if (item_rule_info_.func_attr.value & item_rule_info_.func_attr.eEnable_Socket) {
|
|
socket_info_.SetSocketAttr(sock, level , socket_option);
|
|
return;
|
|
}
|
|
assert(0);
|
|
}
|
|
|
|
inline eATTR_TYPE
|
|
SCItemSlot::GetSocketAttr(eSOCKET sock) const {
|
|
if (item_rule_info_.func_attr.value & item_rule_info_.func_attr.eEnable_Socket) {
|
|
return socket_info_.GetSocketAttrBlock(sock).attr_type_;
|
|
}
|
|
//assert(0);
|
|
return eATTR_TYPE_INVALID;
|
|
}
|
|
|
|
inline int
|
|
SCItemSlot::GetSocketAttrValue(eSOCKET sock) const {
|
|
if (item_rule_info_.func_attr.value & item_rule_info_.func_attr.eEnable_Socket) {
|
|
return socket_info_.GetSocketAttrBlock(sock).attr_value_;
|
|
}
|
|
assert(0);
|
|
return 0;
|
|
}
|
|
|
|
inline eSOCKET_LEVEL
|
|
SCItemSlot::GetSocketAttrLevel(eSOCKET sock) const {
|
|
if (item_rule_info_.func_attr.value & item_rule_info_.func_attr.eEnable_Socket) {
|
|
return socket_info_.GetSocketAttrBlock(sock).socket_level_;
|
|
}
|
|
assert(0);
|
|
return SOCKETLV_LOW;
|
|
}
|
|
|
|
inline int
|
|
SCItemSlot::GetSocketAttrIndex(eSOCKET sock) const {
|
|
if (item_rule_info_.func_attr.value & item_rule_info_.func_attr.eEnable_Socket) {
|
|
return socket_info_.GetSocketAttrBlock(sock).attr_index_;
|
|
}
|
|
assert(0);
|
|
return 0;
|
|
}
|
|
|
|
inline const sSOCKET_OPTION*
|
|
SCItemSlot::GetSocketAttrDesc(eSOCKET sock) const {
|
|
if (item_rule_info_.func_attr.value & item_rule_info_.func_attr.eEnable_Socket) {
|
|
return socket_info_.GetSocketAttrBlock(sock).socket_option_;
|
|
}
|
|
//assert(0);
|
|
return 0;
|
|
}
|
|
|
|
inline void
|
|
SCItemSlot::CopySocketInfo(const SCSocketInfo& sock_info)
|
|
{
|
|
if (item_rule_info_.is_editable == false) {
|
|
return;
|
|
}
|
|
if (item_rule_info_.func_attr.value & item_rule_info_.func_attr.eEnable_Socket) {
|
|
socket_info_.CopySocketInfo(sock_info);
|
|
return;
|
|
}
|
|
assert(0);
|
|
return;
|
|
}
|
|
|
|
inline const SCSocketInfo&
|
|
SCItemSlot::GetSocketInfo() {
|
|
if (!(item_rule_info_.func_attr.value & item_rule_info_.func_attr.eEnable_Socket)) {
|
|
assert(0); //
|
|
}
|
|
return socket_info_;
|
|
}
|
|
#endif // _NA_000251_20100727_SOCKET_SYSTEM
|
|
|
|
//inline bool
|
|
//SCItemSlot::ExistEmptySocket(eSOCKET& OUT EmptySocket) const;
|
|
|
|
//--------------------------------------------------------------------------------------------------
|
|
// N Option - (ExtraStone Option)
|
|
|
|
inline eATTR_TYPE
|
|
SCItemSlot::GetNOptionAttr() const {
|
|
if (item_rule_info_.func_attr.value & item_rule_info_.func_attr.eEnable_NOption) {
|
|
return n_option_info_.attr_type_;
|
|
}
|
|
assert(0);
|
|
return eATTR_TYPE_INVALID;
|
|
}
|
|
|
|
inline int
|
|
SCItemSlot::GetNOptionAttrValue() const {
|
|
if (item_rule_info_.func_attr.value & item_rule_info_.func_attr.eEnable_NOption) {
|
|
return n_option_info_.attr_value_;
|
|
}
|
|
assert(0);
|
|
return 0;
|
|
}
|
|
|
|
inline int
|
|
SCItemSlot::GetNOptionAttrIndex() const {
|
|
if (item_rule_info_.func_attr.value & item_rule_info_.func_attr.eEnable_NOption) {
|
|
return n_option_info_.attr_index_;
|
|
}
|
|
assert(0);
|
|
return 0;
|
|
}
|
|
|
|
inline const sEXTRASTONE_OPT_INFO*
|
|
SCItemSlot::GetNOptionAttrDesc() const {
|
|
if (item_rule_info_.func_attr.value & item_rule_info_.func_attr.eEnable_NOption) {
|
|
return n_option_info_.n_option_;
|
|
}
|
|
assert(0);
|
|
return 0;
|
|
}
|
|
|
|
inline int
|
|
SCItemSlot::GetNOptionValueIndex() const {
|
|
if (item_rule_info_.func_attr.value & item_rule_info_.func_attr.eEnable_NOption) {
|
|
return n_option_info_.attr_value_index_;
|
|
}
|
|
assert(0);
|
|
return 0;
|
|
}
|
|
|
|
//--------------------------------------------------------------------------------------------------
|
|
// Lottery Info
|
|
inline bool
|
|
SCItemSlot::IsLottoItem() const {
|
|
if (item_rule_info_.is_lottery) {
|
|
assert(item_info_->m_wType == eITEMTYPE_LOTTO);
|
|
return true;
|
|
}
|
|
return false;
|
|
}
|
|
|
|
inline bool
|
|
SCItemSlot::IsPandoraOpen() const {
|
|
if (item_rule_info_.is_lottery) {
|
|
return shared_.lotto_info_.open_status_ != false;
|
|
}
|
|
assert(0);
|
|
return false;
|
|
}
|
|
|
|
inline SCLottoInfo*
|
|
SCItemSlot::GetLottoInfo() const {
|
|
if (item_rule_info_.is_lottery) {
|
|
return const_cast<SCLottoInfo*>(&shared_.lotto_info_);
|
|
}
|
|
assert(0);
|
|
return 0; // new add-in
|
|
}
|
|
|
|
//--------------------------------------------------------------------------------------------------
|
|
// PetInfo
|
|
inline bool
|
|
SCItemSlot::IsPetItem() const {
|
|
if (item_rule_info_.is_pet) {
|
|
assert(item_info_->m_wType == eITEMTYPE_PET);
|
|
return true;
|
|
}
|
|
return false;
|
|
}
|
|
|
|
inline bool
|
|
SCItemSlot::IsPetLocked() const {
|
|
//return (lock_info_.user_blocked_ == 1); // (NOTE) 사례가 좋지 못하다.
|
|
if (item_rule_info_.is_pet) {
|
|
return lock_info_.user_blocked_ != false;
|
|
}
|
|
assert(0);
|
|
return false;
|
|
}
|
|
|
|
inline /*const*/ SCPetInfo*
|
|
SCItemSlot::GetPetInfo() const {
|
|
if (item_rule_info_.is_pet) {
|
|
return const_cast<SCPetInfo*>(&shared_.pet_info_);
|
|
}
|
|
assert(0);
|
|
return 0;
|
|
}
|
|
|
|
//----------------------------------------------------------------------------------------------
|
|
// Coordinate Option : 좌표
|
|
|
|
inline bool
|
|
SCItemSlot::IsCoordinateItem() const {
|
|
return item_rule_info_.is_coord;
|
|
}
|
|
|
|
inline WORD
|
|
SCItemSlot::GetMapCode() const {
|
|
if (item_rule_info_.is_coord) {
|
|
return shared_.coordinate_info_.map_code_;
|
|
}
|
|
assert(0);
|
|
return 0;
|
|
}
|
|
|
|
inline short
|
|
SCItemSlot::GetX() const {
|
|
if (item_rule_info_.is_coord) {
|
|
return shared_.coordinate_info_.x_;
|
|
}
|
|
assert(0);
|
|
return 0;
|
|
}
|
|
|
|
inline short
|
|
SCItemSlot::GetY() const {
|
|
if (item_rule_info_.is_coord) {
|
|
return shared_.coordinate_info_.y_;
|
|
}
|
|
assert(0);
|
|
return 0;
|
|
}
|
|
|
|
inline short
|
|
SCItemSlot::GetZ() const {
|
|
if (item_rule_info_.is_coord) {
|
|
return shared_.coordinate_info_.z_;
|
|
}
|
|
assert(0);
|
|
return 0;
|
|
}
|
|
|
|
inline void
|
|
SCItemSlot::SetMapCode(WORD v) {
|
|
if (item_rule_info_.is_editable == false) {
|
|
return;
|
|
}
|
|
if (item_rule_info_.is_coord) {
|
|
shared_.coordinate_info_.map_code_ = v;
|
|
return;
|
|
}
|
|
assert(0);
|
|
}
|
|
|
|
inline void
|
|
SCItemSlot::SetX(short v)
|
|
{
|
|
if (item_rule_info_.is_editable == false) {
|
|
return;
|
|
}
|
|
if (item_rule_info_.is_coord) {
|
|
shared_.coordinate_info_.x_ = v;
|
|
return;
|
|
}
|
|
assert(0);
|
|
}
|
|
|
|
inline void
|
|
SCItemSlot::SetY(short v)
|
|
{
|
|
if (item_rule_info_.is_editable == false) {
|
|
return;
|
|
}
|
|
if (item_rule_info_.is_coord) {
|
|
shared_.coordinate_info_.y_ = v;
|
|
return;
|
|
}
|
|
assert(0);
|
|
}
|
|
|
|
inline void
|
|
SCItemSlot::SetZ(short v)
|
|
{
|
|
if (item_rule_info_.is_editable == false) {
|
|
return;
|
|
}
|
|
if (item_rule_info_.is_coord) {
|
|
shared_.coordinate_info_.z_ = v;
|
|
return;
|
|
}
|
|
assert(0);
|
|
}
|
|
|
|
|
|
//--------------------------------------------------------------------------------------------------
|
|
// Limited Item Option
|
|
|
|
inline bool
|
|
SCItemSlot::IsLimited() const
|
|
{
|
|
return equip_info_.is_limited_ != false;
|
|
}
|
|
|
|
inline WORD
|
|
SCItemSlot::GetLimitedIndex() {
|
|
if (item_rule_info_.is_limited) {
|
|
return shared_.limited_info_.limited_index_;
|
|
}
|
|
assert(0);
|
|
return 0;
|
|
}
|
|
|
|
inline int
|
|
SCItemSlot::GetDamageRatio() const {
|
|
// (NOTE) limited == armor : change name damage -> defense
|
|
if (item_rule_info_.is_limited) {
|
|
return shared_.limited_info_.defence_ratio_;
|
|
}
|
|
assert(0);
|
|
return 0;
|
|
}
|
|
|
|
inline int
|
|
SCItemSlot::GetLimitValueRatio() const {
|
|
if (item_rule_info_.is_limited) {
|
|
return shared_.limited_info_.limit_value_ratio_;
|
|
}
|
|
assert(0);
|
|
return 0;
|
|
}
|
|
|
|
inline DURATYPE
|
|
SCItemSlot::GetLimitedDuraMax() const {
|
|
if (item_rule_info_.is_limited) {
|
|
return shared_.limited_info_.max_duration_;
|
|
}
|
|
assert(0);
|
|
return 0;
|
|
}
|
|
|
|
inline DURATYPE
|
|
SCItemSlot::GetLimitedDuraMMax() const {
|
|
if (item_rule_info_.is_limited) {
|
|
return shared_.limited_info_.max_duration_for_restore_;
|
|
}
|
|
assert(0);
|
|
return 0;
|
|
}
|
|
|
|
inline BYTE
|
|
SCItemSlot::GetLimitedRepairCount() const {
|
|
if (item_rule_info_.is_limited) {
|
|
return shared_.limited_info_.number_of_repairs_;
|
|
}
|
|
assert(0);
|
|
return 0;
|
|
}
|
|
|
|
//--------------------------------------------------------------------------------------------------
|
|
// Limited Control
|
|
inline void
|
|
SCItemSlot::SetDamageRatio(int value)
|
|
{
|
|
if (item_rule_info_.is_editable == false) {
|
|
return;
|
|
}
|
|
if (item_rule_info_.is_limited == false) {
|
|
assert(0);
|
|
return;
|
|
}
|
|
// (WAVERIX) (NOTE) 이것을 보니까... 각 옵션의 상한/하한값을 상수값으로 만들 필요가 있을 듯.
|
|
if (value < -100 || 400 < value) {
|
|
return;
|
|
}
|
|
// (NOTE) limited == armor : change name damage -> defense
|
|
shared_.limited_info_.defence_ratio_ = value;
|
|
}
|
|
|
|
//----------------------------------------------------------------------------------------------
|
|
// (ISlotUpdater)
|
|
inline void
|
|
SCItemSlot::RegisterISlotUpdater(ISlotUpdater* pISlotUpdater) {
|
|
slot_updater_ = ISlotUpdaterD(pISlotUpdater);
|
|
}
|
|
|
|
inline void
|
|
SCItemSlot::UnRegisterISlotUpdater() {
|
|
slot_updater_ = ISlotUpdaterD(NULL);
|
|
}
|
|
|
|
//----------------------------------------------------------------------------------------------
|
|
// Ether Info
|
|
inline bool
|
|
SCItemSlot::IsEquipEtherDevice() const {
|
|
if (item_rule_info_.is_valid_item == false ||
|
|
item_rule_info_.is_shell) // CHANGES: f101021.1L, passed an etheria item
|
|
{
|
|
return false;
|
|
}
|
|
if (item_rule_info_.is_weapon) {
|
|
return (equip_info_.is_equip_ether_device_ != false);
|
|
}
|
|
return false;
|
|
}
|
|
|
|
inline void
|
|
SCItemSlot::SetEquipEtherDevice(BOOL bValue) {
|
|
if (item_rule_info_.is_editable == false) {
|
|
return;
|
|
}
|
|
if (item_rule_info_.is_weapon) {
|
|
equip_info_.is_equip_ether_device_ = !!bValue;
|
|
return;
|
|
}
|
|
assert(0);
|
|
return;
|
|
}
|
|
|
|
inline BYTE
|
|
SCItemSlot::GetEtherBulletIndex() const {
|
|
if (item_rule_info_.is_weapon) {
|
|
return equip_info_.ether_bullet_index_;
|
|
}
|
|
assert(0);
|
|
return 0;
|
|
}
|
|
|
|
inline void
|
|
SCItemSlot::SetEtherBulletIndex(BYTE byIndex) {
|
|
if (item_rule_info_.is_weapon) {
|
|
equip_info_.ether_bullet_index_ = byIndex;
|
|
return;
|
|
}
|
|
assert(0);
|
|
return;
|
|
}
|
|
|
|
inline SCLaxLock<BYTE>*
|
|
SCItemSlot::GetLaxLock() {
|
|
return &m_LaxLock;
|
|
}
|
|
|
|
//----------------------------------------------------------------------------------------------
|
|
// Date|Time Control : 날짜
|
|
inline bool
|
|
SCItemSlot::IsProgressTime() const {
|
|
if (item_rule_info_.func_attr.value & item_rule_info_.func_attr.eEnable_Timer) {
|
|
return (time_info_.is_progress_ != false);
|
|
}
|
|
// NOTE: f110426.4L, removes assertion because of too many direct used cases
|
|
//assert(0);
|
|
return false;
|
|
}
|
|
|
|
inline void
|
|
SCItemSlot::SetProgressTime(bool bFlag) {
|
|
if (item_rule_info_.func_attr.value & item_rule_info_.func_attr.eEnable_Timer) {
|
|
time_info_.is_progress_ = !!bFlag;
|
|
return;
|
|
}
|
|
assert(0);
|
|
}
|
|
|
|
inline DWORD64
|
|
SCItemSlot::GetDateTime() const {
|
|
if (item_rule_info_.func_attr.value & item_rule_info_.func_attr.eEnable_Timer) {
|
|
return time_info_.date_time_;
|
|
};
|
|
assert(0);
|
|
return 0;
|
|
}
|
|
|
|
inline bool
|
|
SCItemSlot::IsExpiredWaitTime() const {
|
|
if (item_rule_info_.func_attr.value & item_rule_info_.func_attr.eEnable_Timer) {
|
|
return (time_info_.is_expired_wait_ != false);
|
|
};
|
|
return false;
|
|
}
|
|
|
|
inline void
|
|
SCItemSlot::SetExpiredWaitTime(bool bFlag) {
|
|
if (item_rule_info_.func_attr.value & item_rule_info_.func_attr.eEnable_Timer) {
|
|
time_info_.is_expired_wait_ = !!bFlag;
|
|
return;
|
|
}
|
|
assert(0);
|
|
}
|
|
|
|
inline bool
|
|
SCItemSlot::IsExpiredTime() const {
|
|
if (item_rule_info_.func_attr.value & item_rule_info_.func_attr.eEnable_Timer) {
|
|
return (time_info_.is_expired_ != false);
|
|
};
|
|
return false;
|
|
}
|
|
|
|
inline void
|
|
SCItemSlot::SetExpiredTime(bool bFlag) {
|
|
if (item_rule_info_.func_attr.value & item_rule_info_.func_attr.eEnable_Timer) {
|
|
time_info_.is_expired_ = !!bFlag;
|
|
return;
|
|
}
|
|
assert(0);
|
|
}
|
|
|
|
//--------------------------------------------------------------------------------------------------
|
|
// WayPointInfo
|
|
|
|
// for GM command
|
|
inline void
|
|
SCItemSlot::ClearWayPointItem() {
|
|
if (item_rule_info_.is_waypoint) {
|
|
shared_.waypoint_info_.Clear();
|
|
return;
|
|
}
|
|
assert(0);
|
|
}
|
|
|
|
inline bool
|
|
SCItemSlot::IsWayPointItem() const {
|
|
if (item_rule_info_.is_waypoint) {
|
|
assert(item_info_->m_wType == eITEMTYPE_WAYPOINT);
|
|
return true;
|
|
}
|
|
return false;
|
|
}
|
|
|
|
inline bool
|
|
SCItemSlot::CanWayPointDelete() const {
|
|
if (item_rule_info_.is_waypoint) {
|
|
return (shared_.waypoint_info_.delete_enabled_ != false);
|
|
};
|
|
assert(0);
|
|
return false;
|
|
}
|
|
|
|
inline void
|
|
SCItemSlot::ResetWayPointDelete() {
|
|
if (item_rule_info_.is_waypoint) {
|
|
shared_.waypoint_info_.ResetWayPointDelete();
|
|
return;
|
|
}
|
|
assert(0);
|
|
}
|
|
|
|
|
|
|
|
//--------------------------------------------------------------------------------------------------
|
|
// PossesionInfo
|
|
// implemented by __NA_1247_POSSESSION_ITEM
|
|
// (WARNING) 해당 아이템이 귀속 가능한지의 여부이며, 아이템의 귀속 여부가 아님.
|
|
inline bool
|
|
SCItemSlot::IsPossessionItem() const
|
|
{
|
|
if (item_rule_info_.func_attr.value & item_rule_info_.func_attr.eEnable_Possession) {
|
|
return true;
|
|
}
|
|
return false;
|
|
}
|
|
|
|
inline void
|
|
SCItemSlot::SetIdentifyPossession(BOOLEAN value) {
|
|
if (item_rule_info_.is_editable == false) {
|
|
return;
|
|
}
|
|
if (item_rule_info_.func_attr.value & item_rule_info_.func_attr.eEnable_Possession) {
|
|
equip_info_.is_identify_possession_ = !!value;
|
|
return;
|
|
}
|
|
assert(0);
|
|
}
|
|
|
|
inline bool
|
|
SCItemSlot::GetIdentifyPossession() const {
|
|
if (item_rule_info_.func_attr.value & item_rule_info_.func_attr.eEnable_Possession) {
|
|
return (equip_info_.is_identify_possession_ != false);
|
|
}
|
|
return false;
|
|
}
|
|
|
|
// __NA_0_POSSESSION_ITEM_DROP = {
|
|
inline void
|
|
SCItemSlot::SetDestroyItem(BOOL value) {
|
|
if (item_rule_info_.is_editable == false) {
|
|
return;
|
|
}
|
|
if (item_rule_info_.func_attr.value & item_rule_info_.func_attr.eEnable_Possession) {
|
|
equip_info_.is_destroyed_ = !!value;
|
|
return;
|
|
}
|
|
assert(0);
|
|
}
|
|
|
|
inline bool
|
|
SCItemSlot::IsDestroyItem() const {
|
|
if (item_rule_info_.func_attr.value & item_rule_info_.func_attr.eEnable_Possession) {
|
|
return (equip_info_.is_destroyed_ != false);
|
|
};
|
|
return false;
|
|
}
|
|
// };
|
|
|
|
//--------------------------------------------------------------------------------------------------
|
|
inline bool SCItemSlot::IsWingItem() const
|
|
{
|
|
if ((item_rule_info_.is_accessory_wings) &&
|
|
(item_rule_info_.is_accessory_special))
|
|
{
|
|
return true;
|
|
}
|
|
return false;
|
|
}
|
|
//--------------------------------------------------------------------------------------------------
|
|
// Rider & Rider Parts Info
|
|
inline bool
|
|
SCItemSlot::IsRiderItem() const {
|
|
if (item_rule_info_.is_rider) {
|
|
assert(item_info_->m_wType == eITEMTYPE_RIDER);
|
|
return true;
|
|
}
|
|
return false;
|
|
}
|
|
|
|
inline bool
|
|
SCItemSlot::IsRiderSummoned() const { // is rider summoned? UserBlock(t/f)
|
|
if (item_rule_info_.is_rider) {
|
|
return lock_info_.user_blocked_ != false;
|
|
};
|
|
assert(0);
|
|
return false;
|
|
}
|
|
|
|
//inline void
|
|
//SCItemSlot::RiderSummonStatus(BOOLEAN is_summoned) {
|
|
// if (item_rule_info_.is_rider) {
|
|
// lock_info_.user_blocked_ = !!is_summoned;
|
|
// return;
|
|
// }
|
|
// assert(0);
|
|
//}
|
|
|
|
inline nsSlot::RiderUpdateBits
|
|
SCItemSlot::GetRiderAttrChangedInfo() const {
|
|
if (item_rule_info_.is_rider) {
|
|
return shared_.rider_info_.GetLatestChangedInfo();
|
|
}
|
|
|
|
assert(0);
|
|
nsSlot::RiderUpdateBits bits = { 0, };
|
|
return bits;
|
|
}
|
|
|
|
// (f100727.1L) Shared interface for the Etheria control
|
|
inline eEtheriaHistory SCItemSlot::GetEtheriaHistory() const
|
|
{
|
|
return lock_info_.history_;
|
|
}
|
|
|
|
// (CHANGES) (f100510.1L) redirected interfaces to support the contents of an etheria
|
|
inline /*static*/ bool SCItemSlot::CanEquip(const BASE_ITEMINFO* item_info)
|
|
{
|
|
if (item_info->m_RidingClass.value != item_info->m_RidingClass.None) {
|
|
return false;
|
|
}
|
|
|
|
const eITEM_MATERIAL_TYPE material_type = \
|
|
static_cast<eITEM_MATERIAL_TYPE>(item_info->m_byMaterialType);
|
|
return material_type == eITEM_MATERIAL_TYPE_CAN_EQUIP ||
|
|
material_type == eITEM_MATERIAL_TYPE_CAN_BOTH;
|
|
}
|
|
|
|
// (CHANGES) (f100510.1L) redirected interfaces to support the contents of an etheria
|
|
inline /*static*/ bool
|
|
SCItemSlot::CanUseMixture(const BASE_ITEMINFO* item_info, eMIXTURE_FLAG flag)
|
|
{
|
|
if (item_info->m_Code == 0) {
|
|
return false;
|
|
}
|
|
// (WAVERIX) (NOTE) 꽤나 혼란스러운 설정 값이다. 0과 255의 역할이 역전된 느낌.
|
|
// 0x00 : all accept
|
|
// 0xFF : disable all
|
|
// [0x00, 0xFF) : enable_function
|
|
const int mixture = item_info->m_byMixture;
|
|
if (mixture == 0) {
|
|
return true;
|
|
}
|
|
return mixture != MIXTURE_EXCEPTALL ? !!(mixture & flag)
|
|
: false;
|
|
}
|
|
|
|
// (CHANGES) (f100510.1L) whether the 'is_blocked' value is blocked
|
|
inline bool
|
|
SCItemSlot::CanTradeSell(const BASE_ITEMINFO* item_info, eITEM_TRADESELL_TYPE is_blocked)
|
|
{
|
|
if (item_info->m_Code == 0) {
|
|
return false;
|
|
}
|
|
#if !defined(_SERVER)
|
|
if (is_blocked == eITEM_TRADESELL_DOALL) {
|
|
return item_info->trade_sell_type == eITEM_TRADESELL_DOALL;
|
|
}
|
|
if (is_blocked == eITEM_TRADESELL_DONTALL) {
|
|
return item_info->trade_sell_type == eITEM_TRADESELL_DONTALL;
|
|
}
|
|
#endif
|
|
if (item_info->trade_sell_type & is_blocked) {
|
|
return false;
|
|
}
|
|
return true;
|
|
}
|
|
|
|
inline bool SCItemSlot::IsEtheriaItem() const {
|
|
//assert(lock_info_.history_.value == lock_info_.history_.Etheria);
|
|
return item_rule_info_.is_etheria != false;
|
|
}
|
|
|
|
inline bool SCItemSlot::IsShellItem() const {
|
|
//assert(lock_info_.history_.value == lock_info_.history_.Shell);
|
|
return item_rule_info_.is_shell != false;
|
|
}
|
|
|
|
//--------------------------------------------------------------------------------------------------
|
|
// DefaultEtc Info
|
|
|
|
#ifdef _NA_0_20100727_SOCKET_SYSTEM_CONVERT
|
|
inline WORD SCItemSlot::GetExtendData() const
|
|
{
|
|
if (item_rule_info_.is_extend_data)
|
|
{
|
|
return shared_.default_ect_info_.data_;
|
|
}
|
|
assert(false);
|
|
return 0;
|
|
}
|
|
|
|
inline void SCItemSlot::SetExtendData(WORD v)
|
|
{
|
|
if (item_rule_info_.is_extend_data == false)
|
|
{
|
|
return;
|
|
}
|
|
|
|
if (item_rule_info_.is_extend_data)
|
|
{
|
|
shared_.default_ect_info_.data_ = v;
|
|
return;
|
|
}
|
|
|
|
assert(false);
|
|
}
|
|
|
|
inline bool SCItemSlot::IsZardItem() const
|
|
{
|
|
if (item_rule_info_.is_extend_data)
|
|
{
|
|
assert(item_info_->m_wType == eITEMTYPE_SOCKET_ZARD || item_info_->m_wType == eITEMTYPE_SOCKET_ZARD_RINGS); //xiaomi add inline bool SCItemSlot::IsZardItem()
|
|
return true;
|
|
}
|
|
return false;
|
|
}
|
|
|
|
inline bool SCItemSlot::IsZardAdditiveItem() const
|
|
{
|
|
if (item_info_ != NULL)
|
|
{
|
|
return item_info_->m_wType == eITEMTYPE_SOCKET_COMPOSE_ADDITIVE;
|
|
}
|
|
return false;
|
|
}
|
|
#endif // _NA_0_20100727_SOCKET_SYSTEM_CONVERT
|