Restructure repository to include all source folders
Move git root from Client/ to src/ to track all source code: - Client: Game client source (moved to Client/Client/) - Server: Game server source - GameTools: Development tools - CryptoSource: Encryption utilities - database: Database scripts - Script: Game scripts - rylCoder_16.02.2008_src: Legacy coder tools - GMFont, Game: Additional resources 🤖 Generated with [Claude Code](https://claude.com/claude-code) Co-Authored-By: Claude <noreply@anthropic.com>
This commit is contained in:
343
GameTools/GLOBALSCRIPT/Item/Item.cpp
Normal file
343
GameTools/GLOBALSCRIPT/Item/Item.cpp
Normal file
@@ -0,0 +1,343 @@
|
||||
#include "stdafx.h"
|
||||
#include "Item.h"
|
||||
#include "..\Skill\SkillStructure.h"
|
||||
|
||||
static Item::ItemInfo NullProtoType;
|
||||
|
||||
Item::CItem::CItem()
|
||||
: m_ItemInfo(NullProtoType)
|
||||
{
|
||||
m_ItemData.m_dwUID = 0;
|
||||
m_ItemData.m_usProtoTypeID = 0;
|
||||
|
||||
m_ItemData.m_ItemPos.m_cPos = 0;
|
||||
m_ItemData.m_ItemPos.m_cIndex = 0;
|
||||
|
||||
m_ItemData.m_cItemSize = sizeof(ItemData);
|
||||
m_ItemData.m_cNumOrDurability = 0;
|
||||
m_cMaxNumOrDurability = 0;
|
||||
m_dwStallPrice = 0;
|
||||
}
|
||||
|
||||
|
||||
Item::CItem::CItem(unsigned __int64 dwItemUID, const ItemInfo& itemInfo)
|
||||
: m_ItemInfo(itemInfo)
|
||||
{
|
||||
m_ItemData.m_dwUID = dwItemUID;
|
||||
m_ItemData.m_usProtoTypeID = itemInfo.m_usProtoTypeID;
|
||||
|
||||
m_ItemData.m_ItemPos.m_cPos = 0;
|
||||
m_ItemData.m_ItemPos.m_cIndex = 0;
|
||||
|
||||
m_ItemData.m_cItemSize = sizeof(ItemData);
|
||||
m_ItemData.m_cNumOrDurability = itemInfo.m_DetailData.m_cDefaultDurabilityOrStack;
|
||||
m_cMaxNumOrDurability = itemInfo.m_DetailData.m_cMaxDurabilityOrStack;
|
||||
m_dwStallPrice = 0;
|
||||
}
|
||||
|
||||
Item::CItem::~CItem()
|
||||
{
|
||||
|
||||
}
|
||||
|
||||
bool Item::CItem::SerializeOut(char* lpSerializeItem_Out, size_t& nBufferLength_InOut)
|
||||
{
|
||||
if(nBufferLength_InOut >= sizeof(ItemData))
|
||||
{
|
||||
m_ItemData.m_cItemSize = sizeof(ItemData);
|
||||
nBufferLength_InOut = sizeof(ItemData);
|
||||
|
||||
*reinterpret_cast<ItemData*>(lpSerializeItem_Out) = m_ItemData;
|
||||
return true;
|
||||
}
|
||||
|
||||
nBufferLength_InOut = 0;
|
||||
return false;
|
||||
}
|
||||
|
||||
bool Item::CItem::SerializeIn(const char* lpSerializeItem_In, size_t& nBufferLength_InOut)
|
||||
{
|
||||
if(sizeof(ItemData) <= nBufferLength_InOut)
|
||||
{
|
||||
const ItemData& itemData = *reinterpret_cast<const Item::ItemData*>(lpSerializeItem_In);
|
||||
nBufferLength_InOut = itemData.m_cItemSize;
|
||||
|
||||
if(itemData.m_usProtoTypeID == m_ItemInfo.m_usProtoTypeID)
|
||||
{
|
||||
m_ItemData = itemData;
|
||||
return true;
|
||||
}
|
||||
}
|
||||
|
||||
return false;
|
||||
}
|
||||
|
||||
|
||||
|
||||
|
||||
Item::CEquipment::CEquipment(unsigned __int64 dwItemUID, const ItemInfo& itemInfo)
|
||||
: CItem(dwItemUID, itemInfo),
|
||||
m_usRuneSocket(0), m_cMaterialType(itemInfo.m_DetailData.m_cMaterialType),
|
||||
m_cSocketNum(0), m_cReserved(0), m_cReserved2(0)
|
||||
{
|
||||
if(1 == m_ItemInfo.m_DetailData.m_cXSize && 1 == m_ItemInfo.m_DetailData.m_cYSize)
|
||||
{
|
||||
m_cMaxSocket = Item::EquipmentInfo::MAX_MINSIZE_SOCKET_NUM;
|
||||
m_cMaxAttribute = Item::EquipmentInfo::MAX_MINSIZE_ATTRIBUTE_NUM;
|
||||
}
|
||||
else
|
||||
{
|
||||
m_cMaxSocket = Item::EquipmentInfo::MAX_SOCKET_NUM;
|
||||
m_cMaxAttribute = Item::EquipmentInfo::MAX_ATTRIBUTE_NUM;
|
||||
}
|
||||
|
||||
m_cMaxSocket = (itemInfo.m_DetailData.m_cMaxSocketNum < m_cMaxSocket) ?
|
||||
itemInfo.m_DetailData.m_cMaxSocketNum : m_cMaxSocket;
|
||||
|
||||
m_ItemData.m_cItemSize += sizeof(EquipmentInfo);
|
||||
|
||||
std::fill_n(m_cSocket, unsigned char(Item::EquipmentInfo::MAX_SOCKET_NUM), 0);
|
||||
InitializeAttribute();
|
||||
}
|
||||
|
||||
Item::CEquipment::~CEquipment()
|
||||
{
|
||||
|
||||
}
|
||||
|
||||
|
||||
void Item::CEquipment::InitializeAttribute()
|
||||
{
|
||||
for(unsigned int nIndex = 0; nIndex < Item::Attribute::MAX_ATTRIBUTE_NUM; ++nIndex)
|
||||
{
|
||||
m_usAttribute[nIndex] =
|
||||
m_ItemInfo.m_EquipAttribute.m_usAttributeValue[nIndex];
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
bool Item::CEquipment::SerializeOut(char* lpSerializeItem_Out, size_t& nBufferLength_InOut)
|
||||
{
|
||||
const size_t nMaxItemSize = sizeof(ItemData) + sizeof(EquipmentInfo) +
|
||||
Item::EquipmentInfo::MAX_SOCKET_NUM * sizeof(unsigned char) +
|
||||
Item::EquipmentInfo::MAX_ATTRIBUTE_NUM * sizeof(ItemAttribute);
|
||||
|
||||
if(nMaxItemSize <= nBufferLength_InOut)
|
||||
{
|
||||
unsigned int nIndex = 0, nSocketIndex = 0, nAttributeIndex = 0;
|
||||
|
||||
// <20>⺻ <20><><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD>
|
||||
ItemData& itemData = *reinterpret_cast<ItemData*>(lpSerializeItem_Out);
|
||||
itemData = m_ItemData;
|
||||
|
||||
EquipmentInfo& equipmentInfo = *reinterpret_cast<EquipmentInfo*>(lpSerializeItem_Out + sizeof(ItemData));
|
||||
char* lpSocketInfo = lpSerializeItem_Out + sizeof(ItemData) + sizeof(EquipmentInfo);
|
||||
|
||||
// <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD>
|
||||
for(nIndex = 0, nSocketIndex = 0;
|
||||
nIndex < Item::EquipmentInfo::MAX_SOCKET_NUM && nSocketIndex < m_cMaxSocket; ++nIndex)
|
||||
{
|
||||
if(0 != m_cSocket[nIndex])
|
||||
{
|
||||
lpSocketInfo[nSocketIndex] = m_cSocket[nIndex];
|
||||
++nSocketIndex;
|
||||
}
|
||||
}
|
||||
|
||||
// <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD> <20>Ӽ<EFBFBD> <20><><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD>
|
||||
ItemAttribute* lpAttribute = reinterpret_cast<ItemAttribute*>(
|
||||
lpSocketInfo + (nSocketIndex * sizeof(unsigned char)));
|
||||
|
||||
for(nIndex = 0, nAttributeIndex = 0;
|
||||
nIndex < Item::Attribute::MAX_ATTRIBUTE_NUM && nAttributeIndex < m_cMaxAttribute; ++nIndex)
|
||||
{
|
||||
const short usDiffAttribute = m_usAttribute[nIndex] -
|
||||
m_ItemInfo.m_EquipAttribute.m_usAttributeValue[nIndex];
|
||||
|
||||
if(0 != usDiffAttribute)
|
||||
{
|
||||
lpAttribute[nAttributeIndex].m_cType = nIndex;
|
||||
lpAttribute[nAttributeIndex].m_usValue = usDiffAttribute;
|
||||
++nAttributeIndex;
|
||||
}
|
||||
}
|
||||
|
||||
// <20><><EFBFBD><EFBFBD> <20><> ũ<><C5A9> <20><><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD>
|
||||
m_ItemData.m_cItemSize = itemData.m_cItemSize = sizeof(ItemData) + sizeof(EquipmentInfo) +
|
||||
nSocketIndex * sizeof(unsigned char) + nAttributeIndex * sizeof(ItemAttribute);
|
||||
|
||||
equipmentInfo.m_cRuneSocket = m_usRuneSocket;
|
||||
equipmentInfo.m_cDiffMaterialType = m_cMaterialType - m_ItemInfo.m_DetailData.m_cMaterialType;
|
||||
|
||||
equipmentInfo.m_cDiffMaxSocket = m_cMaxSocket - m_ItemInfo.m_DetailData.m_cMaxSocketNum;
|
||||
equipmentInfo.m_cSocketNum = nSocketIndex;
|
||||
|
||||
equipmentInfo.m_cAttributeNum = nAttributeIndex;
|
||||
equipmentInfo.m_cReserved = 0;
|
||||
|
||||
equipmentInfo.m_cDiffMaxDurability = m_cMaxNumOrDurability - m_ItemInfo.m_DetailData.m_cMaxDurabilityOrStack;
|
||||
equipmentInfo.m_cReserved2 = m_cReserved2;
|
||||
|
||||
nBufferLength_InOut = m_ItemData.m_cItemSize;
|
||||
return true;
|
||||
}
|
||||
|
||||
nBufferLength_InOut = 0;
|
||||
return false;
|
||||
}
|
||||
|
||||
|
||||
bool Item::CEquipment::SerializeIn(const char* lpSerializeItem_In, size_t& nBufferLength_InOut)
|
||||
{
|
||||
if(CItem::SerializeIn(lpSerializeItem_In, nBufferLength_InOut))
|
||||
{
|
||||
const Item::EquipmentInfo& equipmentInfo =
|
||||
*reinterpret_cast<const Item::EquipmentInfo*>(lpSerializeItem_In + sizeof(ItemData));
|
||||
|
||||
m_usRuneSocket = equipmentInfo.m_cRuneSocket; // <20><> <20><><EFBFBD><EFBFBD>
|
||||
m_cMaterialType = m_ItemInfo.m_DetailData.m_cMaterialType + equipmentInfo.m_cDiffMaterialType; // <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD>
|
||||
m_cMaxSocket = m_ItemInfo.m_DetailData.m_cMaxSocketNum + equipmentInfo.m_cDiffMaxSocket; // <20>ִ<EFBFBD> <20><><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD>
|
||||
m_cSocketNum = equipmentInfo.m_cSocketNum;
|
||||
m_cReserved = equipmentInfo.m_cReserved;
|
||||
|
||||
m_cMaxNumOrDurability = m_ItemInfo.m_DetailData.m_cMaxDurabilityOrStack + equipmentInfo.m_cDiffMaxDurability;
|
||||
m_cReserved2 = equipmentInfo.m_cReserved2;
|
||||
|
||||
const unsigned char* lpSocketIndex = reinterpret_cast<const unsigned char*>(&equipmentInfo + 1);
|
||||
const unsigned char* lpSocketPastEnd = lpSocketIndex + m_cSocketNum;
|
||||
std::copy(lpSocketIndex, lpSocketPastEnd, m_cSocket);
|
||||
|
||||
const Item::ItemAttribute* lpItemAttribute =
|
||||
reinterpret_cast<const Item::ItemAttribute*>(lpSocketPastEnd);
|
||||
|
||||
for(unsigned int nIndex = 0; nIndex < equipmentInfo.m_cAttributeNum; ++nIndex)
|
||||
{
|
||||
unsigned char cType = lpItemAttribute[nIndex].m_cType;
|
||||
if(cType < Item::Attribute::MAX_ATTRIBUTE_NUM)
|
||||
{
|
||||
m_usAttribute[cType] = m_ItemInfo.m_EquipAttribute.m_usAttributeValue[cType] + lpItemAttribute[nIndex].m_usValue;
|
||||
}
|
||||
}
|
||||
|
||||
return true;
|
||||
}
|
||||
|
||||
return false;
|
||||
}
|
||||
|
||||
|
||||
|
||||
// InstallSocket
|
||||
Item::CEquipment::EQUIPMENT_ERROR Item::CEquipment::InstallSocket(CItem& Gem)
|
||||
{
|
||||
using namespace Item;
|
||||
|
||||
// <20><><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD><EFBFBD>ۿ<EFBFBD> <20><><EFBFBD><EFBFBD> <20>ִ<EFBFBD> <20><><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD> <20>˻<EFBFBD>. <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD> <20><> <20><> <20>ڵ<EFBFBD><DAB5><EFBFBD> <20><>.
|
||||
if (Item::EquipmentInfo::MAX_SOCKET_NUM <= m_cMaxSocket ||
|
||||
m_cMaxSocket <= m_cSocketNum)
|
||||
{
|
||||
return EQUIPMENT_ERROR::E_OVER_MAX_SOCKET;
|
||||
}
|
||||
|
||||
// <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD> <20>´°<C2B4> Ȯ<><C8AE>.
|
||||
unsigned short usGemTypeID = Gem.GetPrototypeID();
|
||||
if(usGemTypeID < EtcItemID::GEM_START_ID || EtcItemID::GEM_END_ID < usGemTypeID)
|
||||
{
|
||||
return EQUIPMENT_ERROR::E_NOT_GEM;
|
||||
}
|
||||
|
||||
unsigned char cGemType = usGemTypeID - EtcItemID::GEM_START_ID;
|
||||
|
||||
// <20><> <20>Ӽ<EFBFBD> <20><><EFBFBD><EFBFBD>.
|
||||
ItemAttribute attribute = CItemType::GetInstallGemAttribute(cGemType,
|
||||
m_ItemInfo.m_DetailData.m_cItemType);
|
||||
|
||||
++m_cSocketNum;
|
||||
return EQUIPMENT_ERROR::E_SUCCESS;
|
||||
}
|
||||
|
||||
|
||||
|
||||
// UpgradeItem
|
||||
Item::CEquipment::EQUIPMENT_ERROR Item::CEquipment::UpgradeItem(CItem& Mineral)
|
||||
{
|
||||
|
||||
|
||||
|
||||
return EQUIPMENT_ERROR::E_SUCCESS;
|
||||
}
|
||||
|
||||
|
||||
|
||||
Item::CUseItem::CUseItem(unsigned __int64 dwItemUID, const ItemInfo& itemInfo)
|
||||
: CItem(dwItemUID, itemInfo)
|
||||
{
|
||||
|
||||
|
||||
}
|
||||
|
||||
Item::CUseItem::~CUseItem()
|
||||
{
|
||||
|
||||
|
||||
}
|
||||
|
||||
Item::CSkillItem::CSkillItem()
|
||||
: CItem(0, m_ItemInfoInstance)
|
||||
{
|
||||
m_cMaxDurability = 0;
|
||||
}
|
||||
|
||||
bool Item::CSkillItem::SetSkillInfo(const Skill::ProtoType *lpSkillInfo)
|
||||
{
|
||||
/* char m_szEffectFileName[MAX_FILE_NAME];
|
||||
char m_szHitFileName[MAX_FILE_NAME];
|
||||
char m_szCastingFileName[MAX_FILE_NAME];
|
||||
|
||||
//-----------------------------------
|
||||
|
||||
Type::Type m_eSkillType; // See Namespace Type
|
||||
Target::Type m_eTargetType; // See Namespace Target
|
||||
UseLimit::Type m_eUseLimit; // See Namespace UseLimit
|
||||
|
||||
unsigned char m_StatusLimitType[MAX_LIMIT_NUM];
|
||||
char m_StatusLimitValue[MAX_LIMIT_NUM];
|
||||
|
||||
//-----------------------------------
|
||||
|
||||
unsigned short m_usSkill_ID;
|
||||
unsigned short m_StartMP;
|
||||
unsigned short m_LevelMP;
|
||||
unsigned short m_StartTick;
|
||||
|
||||
//-----------------------------------
|
||||
|
||||
unsigned short m_LevelTick;
|
||||
unsigned short m_usCoolDownTime;
|
||||
|
||||
//-----------------------------------
|
||||
|
||||
float m_EffectDistance;
|
||||
float m_EffectExtent;
|
||||
|
||||
//-----------------------------------
|
||||
|
||||
bool m_bProtection;
|
||||
bool m_bGauge;
|
||||
bool m_bIsClassSkill;
|
||||
bool m_bInterrupt;
|
||||
unsigned char m_cEndScript;
|
||||
unsigned char m_cEndCoolDown;
|
||||
unsigned char m_cMinRange;
|
||||
unsigned char m_cMaxRange;
|
||||
|
||||
//-----------------------------------
|
||||
|
||||
unsigned char m_cStrikeNum;
|
||||
unsigned char m_cSpell_LockCount;
|
||||
unsigned char m_cPadding[6];*/
|
||||
|
||||
m_ItemInfoInstance.m_SpriteData = lpSkillInfo->m_SpriteInfo;
|
||||
|
||||
return true;
|
||||
}
|
||||
354
GameTools/GLOBALSCRIPT/Item/Item.h
Normal file
354
GameTools/GLOBALSCRIPT/Item/Item.h
Normal file
@@ -0,0 +1,354 @@
|
||||
#ifndef _CITEM_CLASS_H_
|
||||
#define _CITEM_CLASS_H_
|
||||
|
||||
#include <limits>
|
||||
#include <algorithm>
|
||||
#include "ItemStructure.h"
|
||||
|
||||
|
||||
// <20><><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD>
|
||||
namespace Skill
|
||||
{
|
||||
struct ProtoType;
|
||||
}
|
||||
|
||||
|
||||
namespace Item
|
||||
{
|
||||
class CItem
|
||||
{
|
||||
public:
|
||||
|
||||
CItem();
|
||||
CItem(unsigned __int64 dwItemUID, const ItemInfo& itemInfo); // Create Item
|
||||
virtual ~CItem();
|
||||
|
||||
// <20><>ũ<EFBFBD><C5A9>Ʈ<EFBFBD>κ<EFBFBD><CEBA><EFBFBD> <20>ε<EFBFBD><CEB5><EFBFBD> <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD> <20>´<EFBFBD>.
|
||||
const ItemInfo& GetItemInfo() const { return m_ItemInfo; }
|
||||
|
||||
// Desc : <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD> char<61><72><EFBFBD>۷<EFBFBD> <20><><EFBFBD><EFBFBD><EFBFBD>Ѵ<EFBFBD>.
|
||||
// In : <20><><EFBFBD><EFBFBD>, <20><><EFBFBD><EFBFBD> ũ<><C5A9>
|
||||
// Out : (Return)<29><><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD>, nBufferLength_InOut - <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD> ũ<><C5A9>
|
||||
virtual bool SerializeOut(char* lpSerializeItem_Out, size_t& nBufferLength_InOut);
|
||||
|
||||
// Desc : char<61><72><EFBFBD>۷κ<DBB7><CEBA><EFBFBD> <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD> <20>о<EFBFBD> <20>´<EFBFBD>.
|
||||
// In : <20><><EFBFBD><EFBFBD>, <20><><EFBFBD><EFBFBD> ũ<><C5A9>
|
||||
// Out : (Return)<29><><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD>, nBufferLength_InOut - <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD> ũ<><C5A9>
|
||||
virtual bool SerializeIn(const char* lpSerializeItem_In, size_t& nBufferLength_InOut);
|
||||
|
||||
// Move Item
|
||||
inline void MoveItem(ItemPos itemPos) { m_ItemData.m_ItemPos = itemPos; }
|
||||
|
||||
// <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD>.
|
||||
inline unsigned __int64 GetUID() const { return m_ItemData.m_dwUID; }
|
||||
inline ItemPos GetPos() const { return m_ItemData.m_ItemPos; }
|
||||
inline ItemPos GetRealPos() const { return m_itemPos_Real; }
|
||||
inline unsigned short GetPrototypeID() const { return m_ItemData.m_usProtoTypeID; }
|
||||
inline unsigned char GetNumOrDurability() const { return m_ItemData.m_cNumOrDurability; }
|
||||
inline unsigned char GetMaxNumOrDurability() const { return m_cMaxNumOrDurability; }
|
||||
inline void SetNumOrDurability(unsigned char cNumOrDurability) { m_ItemData.m_cNumOrDurability = cNumOrDurability; }
|
||||
inline void SetStallPrice(unsigned long dwStallPrice) { m_dwStallPrice = dwStallPrice; }
|
||||
|
||||
inline unsigned long GetBuyPrice() const { return (0 == m_dwStallPrice) ? m_ItemInfo.m_DetailData.m_dwPrice : m_dwStallPrice; }
|
||||
inline unsigned long GetBuyBlackPrice() const { return m_ItemInfo.m_DetailData.m_dwBlackPrice; }
|
||||
inline unsigned long GetSellPrice() const;
|
||||
inline unsigned long GetRepairPrice() const;
|
||||
|
||||
inline const char* GetItemTypeName() const;
|
||||
inline unsigned char GetOptionLimit() const { return m_ItemInfo.m_DetailData.m_cOptionLimit; }
|
||||
|
||||
inline bool IsSet(unsigned long dwDetailDataFlag) const { return dwDetailDataFlag == (m_ItemInfo.m_DetailData.m_dwFlags & dwDetailDataFlag); }
|
||||
|
||||
// <20><><EFBFBD><EFBFBD><EFBFBD>̰<EFBFBD> <20>߰<EFBFBD><DFB0><EFBFBD> <20><>
|
||||
inline bool GetEnableRepair();
|
||||
inline bool GetEnableStack();
|
||||
inline bool GetSocketItem();
|
||||
inline bool GetTwohandItem();
|
||||
inline bool GetEnableEquip();
|
||||
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); }
|
||||
|
||||
protected:
|
||||
|
||||
const ItemInfo& m_ItemInfo; // <20><>ũ<EFBFBD><C5A9>Ʈ<EFBFBD>κ<EFBFBD><CEBA><EFBFBD> <20>ε<EFBFBD><CEB5><EFBFBD> <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD>
|
||||
ItemData m_ItemData; // DB<44><42> <20><><EFBFBD><EFBFBD><EFBFBD>Ǵ<EFBFBD> <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD>
|
||||
|
||||
ItemPos m_itemPos_Real; // <20>ӽ<EFBFBD> <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD> <20>ƴ<EFBFBD> <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD> <20><>ġ
|
||||
unsigned char m_cMaxNumOrDurability; // <20>ִ<EFBFBD> <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD>
|
||||
unsigned long m_dwStallPrice; // <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><F3BFA1BC><EFBFBD> <20><><EFBFBD><EFBFBD>
|
||||
};
|
||||
|
||||
|
||||
class CEquipment : public CItem
|
||||
{
|
||||
public:
|
||||
|
||||
enum EQUIPMENT_ERROR
|
||||
{
|
||||
E_SUCCESS = 0, // <20><><EFBFBD><EFBFBD>
|
||||
E_SERVER_ERROR = 1, // <20><><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD>
|
||||
E_GET_EQUIP_FAILED = 2, // <20><><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD>
|
||||
E_GET_GEM_FAILED = 3, // <20><> <20><><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD>
|
||||
E_NOT_EQUIP = 4, // <20><><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD> <20>ƴ<EFBFBD>
|
||||
E_NOT_GEM = 5, // <20><> <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD> <20>ƴ<EFBFBD>
|
||||
E_REMOVE_GEM_FAILED = 6, // <20><> <20><><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD>
|
||||
E_SOCKET_IS_FULL = 7, // <20><><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD> <20>ʰ<EFBFBD>
|
||||
E_OVER_MAX_SOCKET = 8, // <20>ִ<EFBFBD> <20><><EFBFBD><EFBFBD> <20>ʰ<EFBFBD>
|
||||
|
||||
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_ITEM_FAILED = 9,
|
||||
E_REMOVE_MINERAL_FAILED = 10
|
||||
};
|
||||
|
||||
CEquipment(unsigned __int64 dwItemUID, const ItemInfo& itemInfo);
|
||||
virtual ~CEquipment();
|
||||
|
||||
// <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD> Downcast<73>Ѵ<EFBFBD>.
|
||||
inline static CEquipment* DowncastToEquipment(CItem* lpItem);
|
||||
|
||||
// Desc : <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD> char<61><72><EFBFBD>۷<EFBFBD> <20><><EFBFBD><EFBFBD><EFBFBD>Ѵ<EFBFBD>.
|
||||
// In : <20><><EFBFBD><EFBFBD>, <20><><EFBFBD><EFBFBD> ũ<><C5A9>
|
||||
// Out : (Return)<29><><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD>, nBufferLength_InOut - <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD> ũ<><C5A9>
|
||||
virtual bool SerializeOut(char* lpSerializeItem_Out, size_t& nBufferLength_InOut);
|
||||
|
||||
// Desc : char<61><72><EFBFBD>۷κ<DBB7><CEBA><EFBFBD> <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD> <20>о<EFBFBD> <20>´<EFBFBD>.
|
||||
// In : <20><><EFBFBD><EFBFBD>, <20><><EFBFBD><EFBFBD> ũ<><C5A9>
|
||||
// Out : (Return)<29><><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD>, nBufferLength_InOut - <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD> ũ<><C5A9>
|
||||
virtual bool SerializeIn(const char* lpSerializeItem_In, size_t& nBufferLength_InOut);
|
||||
|
||||
// <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD> <20>Ӽ<EFBFBD><D3BC><EFBFBD> <20><><EFBFBD>Ƿ<EFBFBD> <20>ٲٱ<D9B2> <20><><EFBFBD><EFBFBD>.
|
||||
void AddAttribute(Item::Attribute::Type eAttributeType, unsigned short nAttributeValue) { m_usAttribute[eAttributeType] += nAttributeValue; }
|
||||
inline void AddAttribute(const short* lpAttributeArray_In, unsigned short nArraySize);
|
||||
|
||||
// <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD> <20>Ӽ<EFBFBD><D3BC><EFBFBD> <20><><EFBFBD><EFBFBD> <20>´<EFBFBD>.
|
||||
unsigned short GetAttribute(Item::Attribute::Type eAttributeType) { return m_usAttribute[eAttributeType]; }
|
||||
inline void GetAttribute(short* lpAttributeArray_Out, unsigned short nArraySize);
|
||||
|
||||
// Desc : InstallSocket -
|
||||
// <20><><EFBFBD>Ͽ<EFBFBD> <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD> <20>ڴ<EFBFBD> <20><><EFBFBD><EFBFBD>. 1. <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD> ã<>´<EFBFBD>. 2. <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD> ã<>Ƽ<EFBFBD> <20><><EFBFBD>´<EFBFBD>.
|
||||
// 3. <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD> <20>ڴ´<DAB4>. 4. <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD> <20><><EFBFBD>ش<EFBFBD>. 5. <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD> <20>ٽ<EFBFBD> <20>Դ´<D4B4>.
|
||||
EQUIPMENT_ERROR InstallSocket(CItem& Gem);
|
||||
|
||||
// Desc : UpgradeItem -
|
||||
EQUIPMENT_ERROR UpgradeItem(CItem& Mineral);
|
||||
|
||||
void InitializeAttribute();
|
||||
|
||||
unsigned char m_cSocket[Item::EquipmentInfo::MAX_SOCKET_NUM]; // <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD>
|
||||
short m_usAttribute[Item::Attribute::MAX_ATTRIBUTE_NUM]; // <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD> <20>Ӽ<EFBFBD>
|
||||
|
||||
unsigned short m_usRuneSocket; // <20><> <20><><EFBFBD><EFBFBD>
|
||||
unsigned char m_cMaterialType; // <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD>
|
||||
unsigned char m_cMaxSocket; // <20>ִ<EFBFBD> <20><><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD>
|
||||
|
||||
unsigned char m_cSocketNum; // <20><><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD>
|
||||
unsigned char m_cMaxAttribute; // <20>ִ<EFBFBD> <20>Ӽ<EFBFBD> <20><><EFBFBD><EFBFBD>
|
||||
unsigned char m_cReserved; // <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD>
|
||||
unsigned char m_cReserved2; // <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD>
|
||||
};
|
||||
|
||||
class CUseItem : public CItem
|
||||
{
|
||||
public:
|
||||
|
||||
CUseItem(unsigned __int64 dwItemUID, const ItemInfo& itemInfo);
|
||||
virtual ~CUseItem();
|
||||
|
||||
inline static CUseItem* DowncastToUseItem(CItem* lpItem);
|
||||
bool Use();
|
||||
};
|
||||
|
||||
class CSkillItem : public CItem
|
||||
{
|
||||
public:
|
||||
|
||||
CSkillItem();
|
||||
virtual ~CSkillItem() { }
|
||||
|
||||
inline void SetProtoTypeID(unsigned short usProtoTypeID) { m_ItemData.m_usProtoTypeID = usProtoTypeID; }
|
||||
inline unsigned char GetMaxNumOrDurability() const { return m_cMaxDurability; }
|
||||
inline void SetMaxNumOrDurability(unsigned char cMaxNumOrDurability) { m_cMaxDurability = cMaxNumOrDurability; }
|
||||
|
||||
bool SetSkillInfo(const Skill::ProtoType *lpSkillInfo);
|
||||
|
||||
protected:
|
||||
|
||||
ItemInfo m_ItemInfoInstance;
|
||||
unsigned char m_cMaxDurability; // <20>ִ<EFBFBD> <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD>
|
||||
};
|
||||
|
||||
};
|
||||
|
||||
|
||||
inline const char* Item::CItem::GetItemTypeName() const
|
||||
{
|
||||
switch (m_ItemInfo.m_DetailData.m_cItemType)
|
||||
{
|
||||
case Item::CItemType::HELM: return "<EFBFBD><EFBFBD><EFBFBD><EFBFBD>";
|
||||
case Item::CItemType::SHIRT: return "<EFBFBD><EFBFBD><EFBFBD><EFBFBD>";
|
||||
case Item::CItemType::TUNIC: return "Ʃ<EFBFBD><EFBFBD>";
|
||||
case Item::CItemType::ARMOUR: return "<EFBFBD>Ƹ<EFBFBD>";
|
||||
case Item::CItemType::GLOVE: return "<EFBFBD>尩";
|
||||
case Item::CItemType::BOOTS: return "<EFBFBD><EFBFBD><EFBFBD><EFBFBD>";
|
||||
case Item::CItemType::SWORD: return "<EFBFBD>Ѽհ<EFBFBD>";
|
||||
case Item::CItemType::BLUNT: return "<EFBFBD>Ѽյб<EFBFBD>";
|
||||
case Item::CItemType::AXE: return "<EFBFBD>Ѽյ<EFBFBD><EFBFBD><EFBFBD>";
|
||||
case Item::CItemType::TWOHANDED_BLUNT: return "<EFBFBD><EFBFBD><EFBFBD>յб<EFBFBD>";
|
||||
case Item::CItemType::TWOHANDED_AXE: return "<EFBFBD><EFBFBD><EFBFBD>յ<EFBFBD><EFBFBD><EFBFBD>";
|
||||
case Item::CItemType::TWOHANDED_SWORD: return "<EFBFBD><EFBFBD><EFBFBD>հ<EFBFBD>";
|
||||
case Item::CItemType::BOW: return "Ȱ";
|
||||
case Item::CItemType::CROSSBOW: return "<EFBFBD><EFBFBD><EFBFBD><EFBFBD>";
|
||||
case Item::CItemType::STAFF: return "<EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>";
|
||||
case Item::CItemType::DAGGER: return "<EFBFBD>ܰ<EFBFBD>";
|
||||
case Item::CItemType::SHIELD: return "<EFBFBD><EFBFBD><EFBFBD><EFBFBD>";
|
||||
case Item::CItemType::CLOAK: return "<EFBFBD><EFBFBD><EFBFBD><EFBFBD>";
|
||||
case Item::CItemType::RING: return "<EFBFBD><EFBFBD><EFBFBD><EFBFBD>";
|
||||
case Item::CItemType::NECKLACE: return "<EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>";
|
||||
case Item::CItemType::POTION: return "<EFBFBD><EFBFBD><EFBFBD><EFBFBD>";
|
||||
case Item::CItemType::POISON: return "<EFBFBD><EFBFBD><EFBFBD><EFBFBD>";
|
||||
case Item::CItemType::TRAP: return "Ʈ<EFBFBD><EFBFBD>";
|
||||
case Item::CItemType::SKILLBOOK: return "<EFBFBD><EFBFBD>ų<EFBFBD><EFBFBD>";
|
||||
case Item::CItemType::GEM: return "<EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>";
|
||||
case Item::CItemType::RUNE: return "<EFBFBD><EFBFBD>";
|
||||
case Item::CItemType::MATERIAL: return "<EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>";
|
||||
case Item::CItemType::AMMO: return "<EFBFBD>Ҹ<EFBFBD>ǰ";
|
||||
case Item::CItemType::ETC: return "<EFBFBD><EFBFBD>Ÿ";
|
||||
case Item::CItemType::HEAD: return "<EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>Ƹ<EFBFBD>";
|
||||
case Item::CItemType::BODY: return "<EFBFBD>ٵ<EFBFBD><EFBFBD>Ƹ<EFBFBD>";
|
||||
case Item::CItemType::PROTECT_A: return "<EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>Ʈ<EFBFBD><EFBFBD>";
|
||||
case Item::CItemType::PELVIS: return "<EFBFBD><EFBFBD><EFBFBD>Ƹ<EFBFBD>";
|
||||
case Item::CItemType::COM_BLUNT: return "<EFBFBD>Ĺ<EFBFBD><EFBFBD><EFBFBD>Ʈ <20>б<EFBFBD>";
|
||||
case Item::CItemType::COM_SWORD: return "<EFBFBD>Ĺ<EFBFBD><EFBFBD><EFBFBD>Ʈ <20><>";
|
||||
case Item::CItemType::OPP_HAMMER: return "<EFBFBD><EFBFBD><EFBFBD>Ǽ<EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD> <20>б<EFBFBD>";
|
||||
case Item::CItemType::OPP_AXE: return "<EFBFBD><EFBFBD><EFBFBD>Ǽ<EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD>";
|
||||
case Item::CItemType::OPP_SLUSHER: return "<EFBFBD><EFBFBD><EFBFBD>Ǽ<EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD>";
|
||||
case Item::CItemType::OPP_TALON: return "<EFBFBD><EFBFBD><EFBFBD>Ǽ<EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD> Ż<><C5BB>";
|
||||
case Item::CItemType::OPP_SYTHE: return "<EFBFBD><EFBFBD><EFBFBD>Ǽ<EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD> <20><><EFBFBD>̵<EFBFBD>";
|
||||
case Item::CItemType::SKILL_A_GUARD: return "<EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>";
|
||||
case Item::CItemType::SKILL_A_ATTACK: return "<EFBFBD><EFBFBD><EFBFBD>þ<EFBFBD>";
|
||||
case Item::CItemType::SKILL_A_GUN: return "<EFBFBD>Ǿ<EFBFBD>";
|
||||
case Item::CItemType::SKILL_A_KNIFE: return "<EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>";
|
||||
case Item::CItemType::ACCESSORY: return "<EFBFBD>Ǽ<EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>";
|
||||
case Item::CItemType::ARROW: return "ȭ<EFBFBD><EFBFBD>";
|
||||
case Item::CItemType::BOLT: return "<EFBFBD><EFBFBD>Ʈ";
|
||||
}
|
||||
|
||||
return NULL;
|
||||
}
|
||||
|
||||
|
||||
inline unsigned long Item::CItem::GetSellPrice() const
|
||||
{
|
||||
if (0 != m_dwStallPrice) { return m_dwStallPrice; }
|
||||
|
||||
unsigned long dwSellPrice = m_ItemInfo.m_DetailData.m_dwPrice;
|
||||
unsigned long dwFlags = m_ItemInfo.m_DetailData.m_dwFlags;
|
||||
|
||||
if(IsSet(DetailData::EQUIP))
|
||||
{
|
||||
dwSellPrice = IsSet(DetailData::STACKABLE) ?
|
||||
dwSellPrice / 2 : (dwSellPrice * m_ItemData.m_cNumOrDurability / m_cMaxNumOrDurability / 2);
|
||||
}
|
||||
else
|
||||
{
|
||||
dwSellPrice = (Item::CItemType::SKILLBOOK == m_ItemInfo.m_DetailData.m_cItemType) ?
|
||||
dwSellPrice / 4 : dwSellPrice / 2;
|
||||
}
|
||||
|
||||
return (0 == dwSellPrice) ? 1 : dwSellPrice;
|
||||
}
|
||||
|
||||
|
||||
inline unsigned long Item::CItem::GetRepairPrice() const
|
||||
{
|
||||
unsigned long dwRepairPrice = (m_ItemInfo.m_DetailData.m_dwPrice *
|
||||
(m_cMaxNumOrDurability - m_ItemData.m_cNumOrDurability) / m_cMaxNumOrDurability / 2);
|
||||
return (0 == dwRepairPrice) ? 1 : dwRepairPrice;
|
||||
}
|
||||
|
||||
inline Item::CEquipment* Item::CEquipment::DowncastToEquipment(Item::CItem* lpItem)
|
||||
{
|
||||
return lpItem->IsSet(DetailData::EQUIP) ?
|
||||
static_cast<CEquipment*>(lpItem) : NULL;
|
||||
}
|
||||
|
||||
void Item::CEquipment::AddAttribute(const short* lpAttributeArray_In, unsigned short nArraySize)
|
||||
{
|
||||
unsigned short nCopyNum = nArraySize < Item::Attribute::MAX_ATTRIBUTE_NUM
|
||||
? nArraySize : Item::Attribute::MAX_ATTRIBUTE_NUM;
|
||||
while(0 <= --nCopyNum) { m_usAttribute[nCopyNum] += lpAttributeArray_In[nCopyNum]; }
|
||||
}
|
||||
|
||||
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;
|
||||
short* lpAttributePastEnd = m_usAttribute + nCopyNum;
|
||||
std::copy(m_usAttribute, lpAttributePastEnd, lpAttributeArray_Out);
|
||||
}
|
||||
|
||||
inline Item::CUseItem* Item::CUseItem::DowncastToUseItem(CItem* lpItem)
|
||||
{
|
||||
return lpItem->IsSet(DetailData::USE_ITEM) ?
|
||||
static_cast<CUseItem*>(lpItem) : NULL;
|
||||
}
|
||||
|
||||
// <20><><EFBFBD><EFBFBD><EFBFBD>̰<EFBFBD> <20>߰<EFBFBD> <20><> <20><>
|
||||
inline bool Item::CItem::GetEnableRepair()
|
||||
{
|
||||
unsigned long dwFlags = GetItemInfo().m_DetailData.m_dwFlags;
|
||||
if((dwFlags & Item::DetailData::EQUIP) && !(dwFlags & Item::DetailData::STACKABLE))
|
||||
return true;
|
||||
|
||||
return false;
|
||||
}
|
||||
|
||||
inline bool Item::CItem::GetEnableStack()
|
||||
{
|
||||
if(GetItemInfo().m_DetailData.m_dwFlags & Item::DetailData::STACKABLE)
|
||||
return true;
|
||||
|
||||
return false;
|
||||
}
|
||||
|
||||
inline bool Item::CItem::GetEnableEquip()
|
||||
{
|
||||
if(GetItemInfo().m_DetailData.m_dwFlags & Item::DetailData::EQUIP)
|
||||
return true;
|
||||
|
||||
return false;
|
||||
}
|
||||
|
||||
inline bool Item::CItem::GetSocketItem()
|
||||
{
|
||||
unsigned char cItemType = GetItemInfo().m_DetailData.m_cItemType;
|
||||
if(cItemType == Item::CItemType::GEM || cItemType == Item::CItemType::RUNE)
|
||||
return true;
|
||||
|
||||
return false;
|
||||
}
|
||||
|
||||
inline bool Item::CItem::GetTwohandItem()
|
||||
{
|
||||
unsigned char cItemType = GetItemInfo().m_DetailData.m_cItemType;
|
||||
if(cItemType == Item::CItemType::BOW || cItemType == Item::CItemType::CROSSBOW ||
|
||||
cItemType == Item::CItemType::STAFF || cItemType == Item::CItemType::TWOHANDED_AXE ||
|
||||
cItemType == Item::CItemType::TWOHANDED_BLUNT || cItemType == Item::CItemType::TWOHANDED_SWORD ||
|
||||
cItemType == Item::CItemType::OPP_SYTHE)
|
||||
return true;
|
||||
|
||||
return false;
|
||||
}
|
||||
|
||||
#endif
|
||||
373
GameTools/GLOBALSCRIPT/Item/ItemConstants.cpp
Normal file
373
GameTools/GLOBALSCRIPT/Item/ItemConstants.cpp
Normal file
@@ -0,0 +1,373 @@
|
||||
#include "stdafx.h"
|
||||
#include "ItemConstants.h"
|
||||
#include "ItemStructure.h"
|
||||
|
||||
#include <algorithm>
|
||||
|
||||
using namespace Item;
|
||||
|
||||
Item::CItemType Item::CItemType::ms_this;
|
||||
|
||||
const CTypeName Item::Attribute::Attributes[Item::Attribute::MAX_ATTRIBUTE_NUM] =
|
||||
{
|
||||
CTypeName(Attribute::NONE, "None"),
|
||||
CTypeName(Attribute::CRITICAL_TYPE, "CriticalType"),
|
||||
CTypeName(Attribute::CRITICAL_PERCENTAGE, "CriticalPercentage"),
|
||||
CTypeName(Attribute::MIN_DAMAGE, "MinDamage"),
|
||||
CTypeName(Attribute::MAX_DAMAGE, "MaxDamage"),
|
||||
CTypeName(Attribute::DRC, "DRC"),
|
||||
CTypeName(Attribute::OFFENCE_REVISION, "OffenceRevision"),
|
||||
CTypeName(Attribute::DEFENCE, "Defence"),
|
||||
CTypeName(Attribute::DEFENCE_REVISION, "DefenceRevision"),
|
||||
CTypeName(Attribute::MAGIC_RESISTANCE, "Resistance"),
|
||||
CTypeName(Attribute::BLOCKING_PERCENTAGE, "BlockingPercentage"),
|
||||
CTypeName(Attribute::ATTACK_SPEED, "AttackSpeed"),
|
||||
CTypeName(Attribute::MOVE_SPEED, "MoveSpeed"),
|
||||
CTypeName(Attribute::ATTACK_RANGE, "AttackRange"),
|
||||
CTypeName(Attribute::RANGE_ATTACK_DISTANCE, "LongRangeAttack"),
|
||||
CTypeName(Attribute::MAX_HP, "HpMaxPlus"),
|
||||
CTypeName(Attribute::MAX_MP, "MpMaxPlus"),
|
||||
CTypeName(Attribute::HP_REGEN_AMOUNT, "HPRegen"),
|
||||
CTypeName(Attribute::MP_REGEN_AMOUNT, "MPRegen"),
|
||||
CTypeName(Attribute::FIRE_ATTACK, "FireAttribute"),
|
||||
CTypeName(Attribute::LIGHTNING_ATTACK, "LightingAttribute"),
|
||||
CTypeName(Attribute::COLD_ATTACK, "ColdAttribute"),
|
||||
CTypeName(Attribute::DRAIN_ATTACK, "DrainAttribute"),
|
||||
CTypeName(Attribute::POISON_ATTACK, "PoisonAttribute"),
|
||||
CTypeName(Attribute::FIRE_RESISTANCE, "FireResistance"),
|
||||
CTypeName(Attribute::LIGHTNING_RESISTANCE, "LightningResistance"),
|
||||
CTypeName(Attribute::COLD_RESISTANCE, "ColdResistance"),
|
||||
CTypeName(Attribute::DRAIN_RESISTANCE, "DrainResistance"),
|
||||
CTypeName(Attribute::POISON_RESISTANCE, "PoisonResistance"),
|
||||
CTypeName(Attribute::ADD_STR, "STRAdd"),
|
||||
CTypeName(Attribute::ADD_DEX, "DEXAdd"),
|
||||
CTypeName(Attribute::ADD_CON, "CONAdd"),
|
||||
CTypeName(Attribute::ADD_INT, "INTAdd"),
|
||||
CTypeName(Attribute::ADD_WIS, "WISAdd")
|
||||
};
|
||||
|
||||
|
||||
|
||||
const CTypeName Item::Grade::Grades[Grade::MAX_ITEM_GRADE] =
|
||||
{
|
||||
CTypeName(Grade::ETC, "ETC"),
|
||||
CTypeName(Grade::NORMAL, "NORMAL"),
|
||||
CTypeName(Grade::ENHANCED, "ENHANCED"),
|
||||
CTypeName(Grade::RARE, "RARE")
|
||||
};
|
||||
|
||||
|
||||
Item::CItemType::CItemType()
|
||||
{
|
||||
int nCount = 0;
|
||||
|
||||
for(nCount = 0; nCount < MAX_ARRAY_TYPE; ++nCount)
|
||||
{
|
||||
m_ItemTypes[nCount].reserve(MAX_ITEM_TYPE);
|
||||
}
|
||||
|
||||
m_ItemTypeNames[HELM] = CTypeName(HELM, "HELM");
|
||||
m_ItemTypeNames[SHIRT] = CTypeName(SHIRT, "SHIRT");
|
||||
m_ItemTypeNames[TUNIC] = CTypeName(TUNIC, "TUNIC");
|
||||
m_ItemTypeNames[ARMOUR] = CTypeName(ARMOUR, "ARMOUR");
|
||||
m_ItemTypeNames[GLOVE] = CTypeName(GLOVE, "GLOVE");
|
||||
m_ItemTypeNames[BOOTS] = CTypeName(BOOTS, "BOOTS");
|
||||
m_ItemTypeNames[SWORD] = CTypeName(SWORD, "ONEHANDED_SWORD");
|
||||
m_ItemTypeNames[BLUNT] = CTypeName(BLUNT, "ONEHANDED_BLUNT");
|
||||
m_ItemTypeNames[AXE] = CTypeName(AXE, "ONEHANDED_AXE");
|
||||
m_ItemTypeNames[TWOHANDED_BLUNT] = CTypeName(TWOHANDED_BLUNT, "TWOHANDED_BLUNT");
|
||||
m_ItemTypeNames[TWOHANDED_AXE] = CTypeName(TWOHANDED_AXE, "TWOHANDED_AXE");
|
||||
m_ItemTypeNames[TWOHANDED_SWORD] = CTypeName(TWOHANDED_SWORD, "TWOHANDED_SWORD");
|
||||
m_ItemTypeNames[BOW] = CTypeName(BOW, "BOW");
|
||||
m_ItemTypeNames[CROSSBOW] = CTypeName(CROSSBOW, "CROSSBOW");
|
||||
m_ItemTypeNames[STAFF] = CTypeName(STAFF, "STAFF");
|
||||
m_ItemTypeNames[DAGGER] = CTypeName(DAGGER, "DAGGER");
|
||||
m_ItemTypeNames[SHIELD] = CTypeName(SHIELD, "SHIELD");
|
||||
m_ItemTypeNames[CLOAK] = CTypeName(CLOAK, "CLOAK");
|
||||
m_ItemTypeNames[RING] = CTypeName(RING, "RING");
|
||||
m_ItemTypeNames[NECKLACE] = CTypeName(NECKLACE, "NECKLACE");
|
||||
|
||||
m_ItemTypeNames[POTION] = CTypeName(POTION, "POTION");
|
||||
m_ItemTypeNames[POISON] = CTypeName(POISON, "POISON");
|
||||
m_ItemTypeNames[TRAP] = CTypeName(TRAP, "TRAP");
|
||||
m_ItemTypeNames[SKILLBOOK] = CTypeName(SKILLBOOK, "SKILLBOOK");
|
||||
m_ItemTypeNames[GEM] = CTypeName(GEM, "GEM");
|
||||
m_ItemTypeNames[RUNE] = CTypeName(RUNE, "RUNE");
|
||||
m_ItemTypeNames[MATERIAL] = CTypeName(MATERIAL, "ORE");
|
||||
m_ItemTypeNames[AMMO] = CTypeName(AMMO, "AMMO");
|
||||
m_ItemTypeNames[ETC] = CTypeName(ETC, "ETC");
|
||||
|
||||
m_ItemTypeNames[HEAD] = CTypeName(HEAD, "HEAD");
|
||||
m_ItemTypeNames[BODY] = CTypeName(BODY, "BODY");
|
||||
m_ItemTypeNames[PROTECT_A] = CTypeName(PROTECT_A, "PROTECT_A");
|
||||
m_ItemTypeNames[PELVIS] = CTypeName(PELVIS, "PELVIS");
|
||||
m_ItemTypeNames[COM_BLUNT] = CTypeName(COM_BLUNT, "COM_BLUNT");
|
||||
m_ItemTypeNames[COM_SWORD] = CTypeName(COM_SWORD, "COM_SWORD");
|
||||
m_ItemTypeNames[OPP_HAMMER] = CTypeName(OPP_HAMMER, "OPP_HAMMER");
|
||||
m_ItemTypeNames[OPP_AXE] = CTypeName(OPP_AXE, "OPP_AXE");
|
||||
m_ItemTypeNames[OPP_SLUSHER] = CTypeName(OPP_SLUSHER, "OPP_SLUSHER");
|
||||
m_ItemTypeNames[OPP_TALON] = CTypeName(OPP_TALON, "OPP_TALON");
|
||||
m_ItemTypeNames[OPP_SYTHE] = CTypeName(OPP_SYTHE, "OPP_SYTHE");
|
||||
m_ItemTypeNames[SKILL_A_GUARD] = CTypeName(SKILL_A_GUARD, "SKILL_A_GUARD");
|
||||
m_ItemTypeNames[SKILL_A_ATTACK] = CTypeName(SKILL_A_ATTACK, "SKILL_A_ATTACK");
|
||||
m_ItemTypeNames[SKILL_A_GUN] = CTypeName(SKILL_A_GUN, "SKILL_A_GUN");
|
||||
m_ItemTypeNames[SKILL_A_KNIFE] = CTypeName(SKILL_A_KNIFE, "SKILL_A_KNIFE");
|
||||
m_ItemTypeNames[ACCESSORY] = CTypeName(ACCESSORY, "ACCESSORY");
|
||||
|
||||
m_ItemTypeNames[ARROW] = CTypeName(ARROW, "ARROW");
|
||||
m_ItemTypeNames[BOLT] = CTypeName(BOLT, "BOLT");
|
||||
|
||||
// <20><><EFBFBD><EFBFBD>
|
||||
m_ItemTypes[EQUIP_TYPE].push_back(ARROW); m_ItemTypes[EQUIP_TYPE].push_back(BOLT);
|
||||
m_ItemTypes[EQUIP_TYPE].push_back(HELM); m_ItemTypes[EQUIP_TYPE].push_back(SHIRT);
|
||||
m_ItemTypes[EQUIP_TYPE].push_back(TUNIC); m_ItemTypes[EQUIP_TYPE].push_back(ARMOUR);
|
||||
m_ItemTypes[EQUIP_TYPE].push_back(SHIELD); m_ItemTypes[EQUIP_TYPE].push_back(CLOAK);
|
||||
m_ItemTypes[EQUIP_TYPE].push_back(GLOVE); m_ItemTypes[EQUIP_TYPE].push_back(BOOTS);
|
||||
m_ItemTypes[EQUIP_TYPE].push_back(SWORD); m_ItemTypes[EQUIP_TYPE].push_back(BLUNT);
|
||||
m_ItemTypes[EQUIP_TYPE].push_back(AXE); m_ItemTypes[EQUIP_TYPE].push_back(DAGGER);
|
||||
m_ItemTypes[EQUIP_TYPE].push_back(STAFF); m_ItemTypes[EQUIP_TYPE].push_back(TWOHANDED_BLUNT);
|
||||
m_ItemTypes[EQUIP_TYPE].push_back(TWOHANDED_AXE); m_ItemTypes[EQUIP_TYPE].push_back(TWOHANDED_SWORD);
|
||||
m_ItemTypes[EQUIP_TYPE].push_back(BOW); m_ItemTypes[EQUIP_TYPE].push_back(CROSSBOW);
|
||||
m_ItemTypes[EQUIP_TYPE].push_back(RING); m_ItemTypes[EQUIP_TYPE].push_back(NECKLACE);
|
||||
m_ItemTypes[EQUIP_TYPE].push_back(HEAD); m_ItemTypes[EQUIP_TYPE].push_back(BODY);
|
||||
m_ItemTypes[EQUIP_TYPE].push_back(PELVIS); m_ItemTypes[EQUIP_TYPE].push_back(PROTECT_A);
|
||||
m_ItemTypes[EQUIP_TYPE].push_back(COM_BLUNT); m_ItemTypes[EQUIP_TYPE].push_back(COM_SWORD);
|
||||
m_ItemTypes[EQUIP_TYPE].push_back(OPP_HAMMER); m_ItemTypes[EQUIP_TYPE].push_back(OPP_AXE);
|
||||
m_ItemTypes[EQUIP_TYPE].push_back(OPP_SLUSHER); m_ItemTypes[EQUIP_TYPE].push_back(OPP_TALON);
|
||||
m_ItemTypes[EQUIP_TYPE].push_back(OPP_SYTHE); m_ItemTypes[EQUIP_TYPE].push_back(SKILL_A_GUARD);
|
||||
m_ItemTypes[EQUIP_TYPE].push_back(SKILL_A_ATTACK); m_ItemTypes[EQUIP_TYPE].push_back(SKILL_A_GUN);
|
||||
m_ItemTypes[EQUIP_TYPE].push_back(SKILL_A_KNIFE); m_ItemTypes[EQUIP_TYPE].push_back(ACCESSORY);
|
||||
|
||||
// <20><><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD>
|
||||
m_ItemTypes[USE_ITEM_TYPE].push_back(POTION); m_ItemTypes[USE_ITEM_TYPE].push_back(POISON);
|
||||
m_ItemTypes[USE_ITEM_TYPE].push_back(TRAP); m_ItemTypes[USE_ITEM_TYPE].push_back(SKILLBOOK);
|
||||
m_ItemTypes[USE_ITEM_TYPE].push_back(AMMO);
|
||||
|
||||
// <20><><EFBFBD><EFBFBD>
|
||||
m_ItemTypes[WEAPON_TYPE].push_back(SWORD); m_ItemTypes[WEAPON_TYPE].push_back(BLUNT);
|
||||
m_ItemTypes[WEAPON_TYPE].push_back(AXE); m_ItemTypes[WEAPON_TYPE].push_back(DAGGER);
|
||||
m_ItemTypes[WEAPON_TYPE].push_back(STAFF); m_ItemTypes[WEAPON_TYPE].push_back(TWOHANDED_BLUNT);
|
||||
m_ItemTypes[WEAPON_TYPE].push_back(TWOHANDED_AXE); m_ItemTypes[WEAPON_TYPE].push_back(TWOHANDED_SWORD);
|
||||
m_ItemTypes[WEAPON_TYPE].push_back(BOW); m_ItemTypes[WEAPON_TYPE].push_back(CROSSBOW);
|
||||
m_ItemTypes[WEAPON_TYPE].push_back(COM_BLUNT); m_ItemTypes[WEAPON_TYPE].push_back(COM_SWORD);
|
||||
m_ItemTypes[WEAPON_TYPE].push_back(OPP_HAMMER); m_ItemTypes[WEAPON_TYPE].push_back(OPP_AXE);
|
||||
m_ItemTypes[WEAPON_TYPE].push_back(OPP_SLUSHER); m_ItemTypes[WEAPON_TYPE].push_back(OPP_TALON);
|
||||
m_ItemTypes[WEAPON_TYPE].push_back(OPP_SYTHE);
|
||||
|
||||
// <20><><EFBFBD>
|
||||
m_ItemTypes[ARMOUR_TYPE].push_back(HELM); m_ItemTypes[ARMOUR_TYPE].push_back(SHIRT);
|
||||
m_ItemTypes[ARMOUR_TYPE].push_back(TUNIC); m_ItemTypes[ARMOUR_TYPE].push_back(ARMOUR);
|
||||
m_ItemTypes[ARMOUR_TYPE].push_back(SHIELD); m_ItemTypes[ARMOUR_TYPE].push_back(CLOAK);
|
||||
m_ItemTypes[ARMOUR_TYPE].push_back(GLOVE); m_ItemTypes[ARMOUR_TYPE].push_back(BOOTS);
|
||||
m_ItemTypes[ARMOUR_TYPE].push_back(HEAD); m_ItemTypes[ARMOUR_TYPE].push_back(BODY);
|
||||
m_ItemTypes[ARMOUR_TYPE].push_back(PELVIS); m_ItemTypes[ARMOUR_TYPE].push_back(PROTECT_A);
|
||||
|
||||
// <20><>ų<EFBFBD><C5B3>
|
||||
m_ItemTypes[SKILL_ARM_TYPE].push_back(SKILL_A_GUARD); m_ItemTypes[SKILL_ARM_TYPE].push_back(SKILL_A_ATTACK);
|
||||
m_ItemTypes[SKILL_ARM_TYPE].push_back(SKILL_A_GUN); m_ItemTypes[SKILL_ARM_TYPE].push_back(SKILL_A_KNIFE);
|
||||
|
||||
// <20><><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD>
|
||||
m_ItemTypes[TWOHANDED_TYPE].push_back(STAFF); m_ItemTypes[TWOHANDED_TYPE].push_back(TWOHANDED_BLUNT);
|
||||
m_ItemTypes[TWOHANDED_TYPE].push_back(TWOHANDED_AXE); m_ItemTypes[TWOHANDED_TYPE].push_back(TWOHANDED_SWORD);
|
||||
m_ItemTypes[TWOHANDED_TYPE].push_back(BOW); m_ItemTypes[TWOHANDED_TYPE].push_back(CROSSBOW);
|
||||
|
||||
for(nCount = 0; nCount < MAX_ARRAY_TYPE; ++nCount)
|
||||
{
|
||||
std::sort(m_ItemTypes[nCount].begin(), m_ItemTypes[nCount].end());
|
||||
}
|
||||
}
|
||||
|
||||
bool Item::CItemType::IsCorrectItemType(ArrayType itemType, unsigned char cEquipType)
|
||||
{
|
||||
return std::binary_search(m_ItemTypes[itemType].begin(),
|
||||
m_ItemTypes[itemType].end(), cEquipType);
|
||||
}
|
||||
|
||||
unsigned char Item::CItemType::ConvertRandomOptionType(unsigned char cEquipType)
|
||||
{
|
||||
if (true == IsCorrectItemType(CItemType::WEAPON_TYPE, cEquipType))
|
||||
{
|
||||
return RandomOption::WEAPON;
|
||||
}
|
||||
else
|
||||
{
|
||||
switch (cEquipType)
|
||||
{
|
||||
case CItemType::ARMOUR: case CItemType::BODY: return RandomOption::ARMOUR_BODY;
|
||||
case CItemType::HELM: case CItemType::HEAD: return RandomOption::HELM_HEAD;
|
||||
case CItemType::RING: case CItemType::ACCESSORY: return RandomOption::RING_ACCESSORY;
|
||||
case CItemType::NECKLACE: return RandomOption::NECKLACE;
|
||||
|
||||
case CItemType::SHIELD: case CItemType::SKILL_A_GUARD: return RandomOption::SKILL_A_GUARD;
|
||||
|
||||
case CItemType::SKILL_A_ATTACK:
|
||||
case CItemType::SKILL_A_GUN:
|
||||
case CItemType::SKILL_A_KNIFE:
|
||||
return RandomOption::SKILL_A_WEAPON;
|
||||
}
|
||||
}
|
||||
|
||||
return RandomOption::MAX_RANDOM_OPTION_TYPE;
|
||||
}
|
||||
|
||||
void Item::CItemType::SetEquipTypeFlags(ItemInfo& itemInfo)
|
||||
{
|
||||
switch (itemInfo.m_DetailData.m_cItemType)
|
||||
{
|
||||
case ARROW:
|
||||
case BOLT:
|
||||
itemInfo.m_DetailData.m_dwFlags |= Item::DetailData::STACKABLE;
|
||||
break;
|
||||
}
|
||||
|
||||
if (IsCorrectItemType(Item::CItemType::WEAPON_TYPE, itemInfo.m_DetailData.m_cItemType))
|
||||
{
|
||||
itemInfo.m_DetailData.m_dwFlags |= DetailData::WEAPON;
|
||||
|
||||
if (IsCorrectItemType(Item::CItemType::TWOHANDED_TYPE, itemInfo.m_DetailData.m_cItemType))
|
||||
{
|
||||
itemInfo.m_DetailData.m_dwFlags |= DetailData::TWOHANDED;
|
||||
}
|
||||
|
||||
}
|
||||
else if (IsCorrectItemType(Item::CItemType::SKILL_ARM_TYPE, itemInfo.m_DetailData.m_cItemType))
|
||||
{
|
||||
itemInfo.m_DetailData.m_dwFlags |= DetailData::SKILL_ARM;
|
||||
}
|
||||
else if (IsCorrectItemType(Item::CItemType::ARMOUR_TYPE, itemInfo.m_DetailData.m_cItemType))
|
||||
{
|
||||
itemInfo.m_DetailData.m_dwFlags |= DetailData::ARMOUR;
|
||||
}
|
||||
|
||||
itemInfo.m_DetailData.m_dwFlags |= Item::DetailData::EQUIP;
|
||||
}
|
||||
|
||||
|
||||
void Item::CItemType::SetUseItemTypeFlags(ItemInfo& itemInfo)
|
||||
{
|
||||
switch(itemInfo.m_DetailData.m_cItemType)
|
||||
{
|
||||
case Item::CItemType::POTION:
|
||||
case Item::CItemType::POISON:
|
||||
case Item::CItemType::TRAP:
|
||||
itemInfo.m_DetailData.m_dwFlags |= Item::DetailData::QUICKSLOT_IN;
|
||||
break;
|
||||
}
|
||||
|
||||
if(itemInfo.m_DetailData.m_cMaxDurabilityOrStack > 1)
|
||||
{
|
||||
itemInfo.m_DetailData.m_dwFlags |= Item::DetailData::STACKABLE;
|
||||
}
|
||||
|
||||
itemInfo.m_DetailData.m_dwFlags |= Item::DetailData::USE_ITEM;
|
||||
}
|
||||
|
||||
|
||||
void Item::CItemType::SetEtcItemTypeFlags(ItemInfo& itemInfo)
|
||||
{
|
||||
if(itemInfo.m_DetailData.m_cMaxDurabilityOrStack > 1)
|
||||
{
|
||||
itemInfo.m_DetailData.m_dwFlags |= Item::DetailData::STACKABLE;
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
using namespace Item::Attribute;
|
||||
typedef Item::ItemAttribute Attr;
|
||||
|
||||
Attr GemInstallTable[15][7] =
|
||||
{
|
||||
// <09><><EFBFBD><EFBFBD> <09>Ƹ<EFBFBD> <09><><EFBFBD><EFBFBD> <09><><EFBFBD><EFBFBD> <09><><EFBFBD><EFBFBD><EFBFBD><EFBFBD> <09><><EFBFBD><EFBFBD> 2+ <09>Ƹ<EFBFBD> 2+
|
||||
Attr(FIRE_ATTACK, 1), Attr(FIRE_RESISTANCE, 1), Attr(ADD_STR, 3), Attr(OFFENCE_REVISION ,3), Attr(MAX_DAMAGE, 2), Attr(OFFENCE_REVISION, 3), Attr(ADD_STR, 3), // <20><><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD>
|
||||
Attr(POISON_ATTACK, 1), Attr(POISON_RESISTANCE, 1), Attr(ADD_CON, 3), Attr(HP_REGEN_AMOUNT, 3), Attr(MAX_HP, 10), Attr(ADD_CON, 3), Attr(MAX_HP, 1), // <20><><EFBFBD><EFBFBD><DEB6><EFBFBD> <20><><EFBFBD><EFBFBD>
|
||||
Attr(COLD_ATTACK, 1), Attr(COLD_RESISTANCE, 1), Attr(ADD_INT, 3), Attr(MP_REGEN_AMOUNT, 3), Attr(MAX_MP, 10), Attr(MAX_MP, 1), Attr(ADD_INT, 3), // <20><><EFBFBD><EFBFBD><EFBFBD>̾<EFBFBD> <20><><EFBFBD><EFBFBD>
|
||||
Attr(LIGHTNING_ATTACK, 1), Attr(LIGHTNING_RESISTANCE, 1), Attr(ADD_WIS ,3), Attr(MAGIC_RESISTANCE, 3), Attr(CRITICAL_PERCENTAGE, 1), Attr(CRITICAL_PERCENTAGE, 2), Attr(MAGIC_RESISTANCE, 3), // <20><><EFBFBD>̾Ƹ<CCBE><C6B8><EFBFBD> <20><><EFBFBD><EFBFBD>
|
||||
Attr(DRAIN_ATTACK, 1), Attr(DRAIN_RESISTANCE, 1), Attr(ADD_DEX ,3), Attr(DEFENCE_REVISION, 3), Attr(DEFENCE, 1), Attr(ADD_DEX, 3), Attr(DEFENCE_REVISION, 3), // <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD>
|
||||
|
||||
Attr(FIRE_ATTACK, 2), Attr(FIRE_RESISTANCE, 2), Attr(ADD_STR, 6), Attr(OFFENCE_REVISION ,6), Attr(MAX_DAMAGE, 4), Attr(OFFENCE_REVISION, 6), Attr(ADD_STR, 6), // <20><><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD>
|
||||
Attr(POISON_ATTACK, 2), Attr(POISON_RESISTANCE, 2), Attr(ADD_CON, 6), Attr(HP_REGEN_AMOUNT, 6), Attr(MAX_HP, 20), Attr(ADD_CON, 6), Attr(MAX_HP, 2), // <20><><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD><DEB6><EFBFBD>
|
||||
Attr(COLD_ATTACK, 2), Attr(COLD_RESISTANCE, 2), Attr(ADD_INT, 6), Attr(MP_REGEN_AMOUNT, 6), Attr(MAX_MP, 20), Attr(MAX_MP, 2), Attr(ADD_INT, 6), // <20><><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD><EFBFBD>̾<EFBFBD>
|
||||
Attr(LIGHTNING_ATTACK, 2), Attr(LIGHTNING_RESISTANCE, 2), Attr(ADD_WIS ,6), Attr(MAGIC_RESISTANCE, 6), Attr(CRITICAL_PERCENTAGE, 2), Attr(CRITICAL_PERCENTAGE, 4), Attr(MAGIC_RESISTANCE, 6), // <20><><EFBFBD><EFBFBD> <20><><EFBFBD>̾Ƹ<CCBE><C6B8><EFBFBD>
|
||||
Attr(DRAIN_ATTACK, 2), Attr(DRAIN_RESISTANCE, 2), Attr(ADD_DEX ,6), Attr(DEFENCE_REVISION, 6), Attr(DEFENCE, 2), Attr(ADD_DEX, 6), Attr(DEFENCE_REVISION, 6), // <20><><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD>
|
||||
|
||||
Attr(FIRE_ATTACK, 3), Attr(FIRE_RESISTANCE, 3), Attr(ADD_STR, 9), Attr(OFFENCE_REVISION ,9), Attr(MAX_DAMAGE, 6), Attr(OFFENCE_REVISION, 9), Attr(ADD_STR, 9), // <20><><EFBFBD><EFBFBD>
|
||||
Attr(POISON_ATTACK, 3), Attr(POISON_RESISTANCE, 3), Attr(ADD_CON, 9), Attr(HP_REGEN_AMOUNT, 9), Attr(MAX_HP, 30), Attr(ADD_CON, 9), Attr(MAX_HP, 3), // <20><><EFBFBD><EFBFBD><DEB6><EFBFBD>
|
||||
Attr(COLD_ATTACK, 3), Attr(COLD_RESISTANCE, 3), Attr(ADD_INT, 9), Attr(MP_REGEN_AMOUNT, 9), Attr(MAX_MP, 30), Attr(MAX_MP, 9), Attr(ADD_INT, 9), // <20><><EFBFBD><EFBFBD><EFBFBD>̾<EFBFBD>
|
||||
Attr(LIGHTNING_ATTACK, 3), Attr(LIGHTNING_RESISTANCE, 3), Attr(ADD_WIS ,9), Attr(MAGIC_RESISTANCE, 9), Attr(CRITICAL_PERCENTAGE, 3), Attr(CRITICAL_PERCENTAGE, 6), Attr(MAGIC_RESISTANCE, 9), // <20><><EFBFBD>̾Ƹ<CCBE><C6B8><EFBFBD>
|
||||
Attr(DRAIN_ATTACK, 3), Attr(DRAIN_RESISTANCE, 3), Attr(ADD_DEX ,9), Attr(DEFENCE_REVISION, 9), Attr(DEFENCE, 3), Attr(ADD_DEX, 9), Attr(DEFENCE_REVISION, 9), // <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD>
|
||||
};
|
||||
|
||||
Item::ItemAttribute CItemType::GetInstallGemAttribute(unsigned char cGemType, unsigned char cEquipType, bool bPlus)
|
||||
{
|
||||
const unsigned char NON_EQUIP_TYPE_INDEX = 0xFF;
|
||||
|
||||
unsigned char cEquipTypeIndex = NON_EQUIP_TYPE_INDEX;
|
||||
|
||||
if(CItemType::GetInstance().IsCorrectItemType(WEAPON_TYPE, cEquipType))
|
||||
{
|
||||
cEquipType = 0 + (bPlus ? 5 : 0);
|
||||
}
|
||||
else
|
||||
{
|
||||
switch (cEquipType)
|
||||
{
|
||||
case ARMOUR: case BODY: cEquipType = 1 + (bPlus ? 5 : 0); break; // <20>Ƹ<EFBFBD>
|
||||
case HELM: case HEAD: cEquipType = 2; break; // <20><><EFBFBD><EFBFBD>
|
||||
case RING: case ACCESSORY: cEquipType = 3; break; // <20><><EFBFBD><EFBFBD>
|
||||
case NECKLACE: cEquipType = 4; break; // <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD>
|
||||
}
|
||||
}
|
||||
|
||||
return (NON_EQUIP_TYPE_INDEX != cEquipType) ?
|
||||
GemInstallTable[cGemType][cEquipType] : Item::ItemAttribute();
|
||||
}
|
||||
|
||||
|
||||
unsigned short UpgradeTable[15][3] =
|
||||
{
|
||||
//Ȯ<><C8AE> <09>䱸 <20><><EFBFBD><EFBFBD> <09><><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD>
|
||||
75, 2001, 3, // <20>Ǻ<EFBFBD>
|
||||
66, 2001, 6, // <20>Ǻ<EFBFBD>
|
||||
54, 2001, 9, // <20>Ǻ<EFBFBD>
|
||||
44, 2001, 12, // <20>Ǻ<EFBFBD>
|
||||
|
||||
35, 2002, 3, // <20>̽<EFBFBD><CCBD><EFBFBD>
|
||||
28, 2002, 6, // <20>̽<EFBFBD><CCBD><EFBFBD>
|
||||
23, 2002, 9, // <20>̽<EFBFBD><CCBD><EFBFBD>
|
||||
18, 2002, 12, // <20>̽<EFBFBD><CCBD><EFBFBD>
|
||||
|
||||
15, 2003, 3, // <20><><EFBFBD>ʹϿ<CDB4>
|
||||
13, 2003, 6, // <20><><EFBFBD>ʹϿ<CDB4>
|
||||
11, 2003, 9, // <20><><EFBFBD>ʹϿ<CDB4>
|
||||
9, 2003, 12, // <20><><EFBFBD>ʹϿ<CDB4>
|
||||
|
||||
8, 2004, 3, // <20><><EFBFBD><EFBFBD><EFBFBD>ϸ<EFBFBD><CFB8><EFBFBD>
|
||||
7, 2004, 6, // <20><><EFBFBD><EFBFBD><EFBFBD>ϸ<EFBFBD><CFB8><EFBFBD>
|
||||
6, 2004, 9 // <20><><EFBFBD><EFBFBD><EFBFBD>ϸ<EFBFBD><CFB8><EFBFBD>
|
||||
};
|
||||
|
||||
unsigned char CItemType::GetUpgradeItemAttribute(unsigned char EquipType, Item::ItemAttribute& Attribute)
|
||||
{
|
||||
/* FIXME :
|
||||
if (IsWeapon(EquipType))
|
||||
{
|
||||
Attribute[0].m_nAttributeType = Attribute::MIN_DAMAGE; // <20>ּ<EFBFBD> <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD> <20><>ȭ
|
||||
Attribute[0].m_nValue = 3;
|
||||
|
||||
Attribute[1].m_nAttributeType = Attribute::MAX_DAMAGE; // <20>ִ<EFBFBD> <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD> <20><>ȭ
|
||||
Attribute[1].m_nValue = 3;
|
||||
|
||||
return 2;
|
||||
}
|
||||
else if (IsArmour(EquipType))
|
||||
{
|
||||
Attribute[0].m_nAttributeType = Attribute::DEFENCE; // <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD> <20><>ȭ
|
||||
Attribute[0].m_nValue = 3;
|
||||
|
||||
return 1;
|
||||
}
|
||||
*/
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
||||
271
GameTools/GLOBALSCRIPT/Item/ItemConstants.h
Normal file
271
GameTools/GLOBALSCRIPT/Item/ItemConstants.h
Normal file
@@ -0,0 +1,271 @@
|
||||
#ifndef _ITEM_CONSTANTS_H_
|
||||
#define _ITEM_CONSTANTS_H_
|
||||
|
||||
#include <vector>
|
||||
#include <Pattern/Singleton.h>
|
||||
#include "../Utility/TypeArray.h"
|
||||
|
||||
namespace Item
|
||||
{
|
||||
// <20><><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD>
|
||||
struct ItemInfo;
|
||||
struct ItemAttribute;
|
||||
|
||||
class CItemType : public CSingleton<CItemType>
|
||||
{
|
||||
public:
|
||||
|
||||
// <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD> Ÿ<><C5B8> ( 8bit )
|
||||
enum Type
|
||||
{
|
||||
// <20>ΰ<EFBFBD> <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD>.
|
||||
HELM = 0, SHIRT = 1,
|
||||
TUNIC = 2, ARMOUR = 3,
|
||||
GLOVE = 4, BOOTS = 5,
|
||||
SWORD = 6, BLUNT = 7,
|
||||
AXE = 8, TWOHANDED_BLUNT = 9,
|
||||
TWOHANDED_AXE = 10, TWOHANDED_SWORD = 11,
|
||||
BOW = 12, CROSSBOW = 13,
|
||||
STAFF = 14, DAGGER = 15,
|
||||
SHIELD = 16, CLOAK = 17,
|
||||
RING = 18, NECKLACE = 19,
|
||||
|
||||
// <20><><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD>
|
||||
POTION = 20, POISON = 21,
|
||||
TRAP = 22, SKILLBOOK = 23, // <20><>âX
|
||||
|
||||
GEM = 24, RUNE = 25,
|
||||
MATERIAL = 26, AMMO = 27,
|
||||
ETC = 28, // <20><><EFBFBD><EFBFBD> X, <20><>â X
|
||||
|
||||
// <20><>ĭ <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD>
|
||||
HEAD = 29, BODY = 30,
|
||||
PROTECT_A = 31, PELVIS = 32,
|
||||
COM_BLUNT = 33, COM_SWORD = 34,
|
||||
OPP_HAMMER = 35, OPP_AXE = 36,
|
||||
OPP_SLUSHER = 37, OPP_TALON = 38,
|
||||
OPP_SYTHE = 39, SKILL_A_GUARD = 40,
|
||||
SKILL_A_ATTACK = 41, SKILL_A_GUN = 42,
|
||||
SKILL_A_KNIFE = 43, ACCESSORY = 44,
|
||||
|
||||
// <20><><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD>
|
||||
ARROW = 45, BOLT = 46,
|
||||
|
||||
MAX_ITEM_TYPE = 47
|
||||
};
|
||||
|
||||
enum ArrayType
|
||||
{
|
||||
EQUIP_TYPE = 0, USE_ITEM_TYPE = 1,
|
||||
WEAPON_TYPE = 2, ARMOUR_TYPE = 3,
|
||||
SKILL_ARM_TYPE = 4, TWOHANDED_TYPE = 5,
|
||||
MAX_ARRAY_TYPE = 6
|
||||
};
|
||||
|
||||
// <20><><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD> <20>Լ<EFBFBD>
|
||||
static Item::ItemAttribute GetInstallGemAttribute(unsigned char cGemType,
|
||||
unsigned char cEquipType, bool bPlus = false);
|
||||
static unsigned char GetUpgradeItemAttribute(unsigned char EquipType, Item::ItemAttribute& Attribute);
|
||||
|
||||
// <20><><EFBFBD><EFBFBD> <20>Լ<EFBFBD>
|
||||
bool IsCorrectItemType(ArrayType itemType, unsigned char cEquipType);
|
||||
unsigned char ConvertRandomOptionType(unsigned char cEquipType);
|
||||
|
||||
void SetEquipTypeFlags(ItemInfo& itemInfo);
|
||||
void SetUseItemTypeFlags(ItemInfo& itemInfo);
|
||||
void SetEtcItemTypeFlags(ItemInfo& itemInfo);
|
||||
|
||||
CTypeName* GetItemTypeName() { return m_ItemTypeNames; }
|
||||
|
||||
private:
|
||||
|
||||
CItemType();
|
||||
|
||||
typedef std::vector<Type> ItemTypeArray;
|
||||
ItemTypeArray m_ItemTypes[MAX_ARRAY_TYPE];
|
||||
CTypeName m_ItemTypeNames[MAX_ITEM_TYPE];
|
||||
|
||||
static CItemType ms_this;
|
||||
};
|
||||
|
||||
|
||||
namespace Attribute
|
||||
{
|
||||
enum Type
|
||||
{
|
||||
// Creature<72><65> <20><><EFBFBD><EFBFBD> <20>Ӽ<EFBFBD>. <20><><EFBFBD><EFBFBD><EFBFBD>ۿ<EFBFBD><DBBF><EFBFBD> <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD>.
|
||||
NONE = 0, CRITICAL_TYPE = 1,
|
||||
CRITICAL_PERCENTAGE = 2, MIN_DAMAGE = 3,
|
||||
MAX_DAMAGE = 4, DRC = 5,
|
||||
OFFENCE_REVISION = 6, DEFENCE = 7,
|
||||
DEFENCE_REVISION = 8, MAGIC_RESISTANCE = 9,
|
||||
BLOCKING_PERCENTAGE = 10, ATTACK_SPEED = 11,
|
||||
MOVE_SPEED = 12, ATTACK_RANGE = 13,
|
||||
RANGE_ATTACK_DISTANCE = 14, MAX_HP = 15,
|
||||
MAX_MP = 16, HP_REGEN_AMOUNT = 17,
|
||||
MP_REGEN_AMOUNT = 18, FIRE_ATTACK = 19,
|
||||
LIGHTNING_ATTACK = 20, COLD_ATTACK = 21,
|
||||
DRAIN_ATTACK = 22, POISON_ATTACK = 23,
|
||||
FIRE_RESISTANCE = 24, LIGHTNING_RESISTANCE = 25,
|
||||
COLD_RESISTANCE = 26, DRAIN_RESISTANCE = 27,
|
||||
POISON_RESISTANCE = 28, ADD_STR = 29,
|
||||
ADD_DEX = 30, ADD_CON = 31,
|
||||
ADD_INT = 32, ADD_WIS = 33,
|
||||
MAX_ATTRIBUTE_NUM = 34
|
||||
};
|
||||
|
||||
enum Trend
|
||||
{
|
||||
Aggressive = (1 << 0),
|
||||
Defensive = (1 << 1)
|
||||
};
|
||||
|
||||
extern const CTypeName Attributes[MAX_ATTRIBUTE_NUM];
|
||||
};
|
||||
|
||||
namespace EquipType
|
||||
{
|
||||
enum Type
|
||||
{
|
||||
Attach = 0, Detach = 1
|
||||
};
|
||||
|
||||
enum DoubleSwordType
|
||||
{
|
||||
SoloSword = 0,
|
||||
WarriorDoubleSword = 1,
|
||||
AssasinDoubleDagger = 2
|
||||
};
|
||||
};
|
||||
|
||||
namespace RandomOption
|
||||
{
|
||||
enum Type
|
||||
{
|
||||
WEAPON = 0, ARMOUR_BODY = 1,
|
||||
HELM_HEAD = 2, RING_ACCESSORY = 3,
|
||||
NECKLACE = 4, SKILL_A_GUARD = 5,
|
||||
SKILL_A_WEAPON = 6,
|
||||
|
||||
MAX_RANDOM_OPTION_TYPE = 7
|
||||
};
|
||||
|
||||
enum Attribute
|
||||
{
|
||||
MAX_DURABILITY = 0, NOW_DURABILITY = 1,
|
||||
MIN_DAMAGE = 2, MAX_DAMAGE = 3,
|
||||
OFFENCE_REVISION = 4, DEFENCE = 5,
|
||||
DEFENCE_REVISION = 6, MAGIC_RESISTANCE = 7,
|
||||
CRITICAL_PERCENTAGE = 8, BLOCKING_PERCENTAGE = 9,
|
||||
MAX_HP = 10, MAX_MP = 11,
|
||||
HP_REGEN_AMOUNT = 12, MP_REGEN_AMOUNT = 13,
|
||||
|
||||
MAX_RANDOM_OPTION_ATTRIBUTE = 14
|
||||
};
|
||||
|
||||
enum ValueRange
|
||||
{
|
||||
MIN_MINUS_FACTOR = 0, MIN_MULTIPLY_FACTOR = 1,
|
||||
MIN_DIVIDE_FACTOR = 2, MAX_MULTIPLY_FACTOR = 3,
|
||||
MAX_DIVIDE_FACTOR = 4, MAX_PLUS_FACTOR = 5,
|
||||
|
||||
MAX_RANDOM_OPTION_VALUE_RANGE = 6
|
||||
};
|
||||
};
|
||||
|
||||
namespace EquipmentPos
|
||||
{
|
||||
// <20><><EFBFBD><EFBFBD> <20><>ġ ( 8bit )
|
||||
|
||||
enum Type
|
||||
{
|
||||
// <20>ΰ<EFBFBD> <20><><EFBFBD><EFBFBD> <20><>ġ
|
||||
HELM = 0, SHIRT = 1,
|
||||
TUNIC = 2, ARMOUR = 3,
|
||||
GLOVE = 4, BOOTS = 5,
|
||||
NECKLACE = 6, RINGR = 7,
|
||||
RINGL = 8, SHIELD_HAND1 = 9,
|
||||
SHIELD_HAND2 = 10, WEAPON_HAND1 = 11,
|
||||
WEAPON_HAND2 = 12, CLOAK = 13,
|
||||
RIDE = 14,
|
||||
|
||||
// <20><>ĭ <20><><EFBFBD><EFBFBD> <20><>ġ
|
||||
HEAD = 0, BODY = 3,
|
||||
PROTECT_ARM = 4, PELVIS = 5,
|
||||
ACCESSORY1 = 6, ACCESSORY2 = 7,
|
||||
ACCESSORY3 = 8, SKILL_ARM = 9,
|
||||
WEAPON = 11,
|
||||
|
||||
MAX_EQUPMENT_POS = 16,
|
||||
|
||||
TEMP_ITEM_INDEX = 128
|
||||
};
|
||||
};
|
||||
|
||||
|
||||
// <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD>
|
||||
namespace StatusLimit
|
||||
{
|
||||
enum Type
|
||||
{
|
||||
NONE = 0, LEVEL = 1,
|
||||
STR = 2, DEX = 3,
|
||||
CON = 4, INT = 5,
|
||||
WIS = 6,
|
||||
|
||||
MAX_STATUS_LIMIT = 7
|
||||
};
|
||||
};
|
||||
|
||||
// <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD>
|
||||
namespace Grade
|
||||
{
|
||||
enum Type
|
||||
{
|
||||
ETC = 0,
|
||||
NORMAL = 1,
|
||||
ENHANCED = 2,
|
||||
RARE = 3,
|
||||
MAX_ITEM_GRADE = 4
|
||||
};
|
||||
|
||||
extern const CTypeName Grades[MAX_ITEM_GRADE];
|
||||
};
|
||||
|
||||
|
||||
namespace ExtraSpacePos
|
||||
{
|
||||
enum Type
|
||||
{
|
||||
UPGRADE_EQUIPMENT_POS = 0,
|
||||
UPGRADE_MATERIAL_POS = 1,
|
||||
HOLDITEM_POS = 2,
|
||||
MAX_EXTRA_SPACE_NUM = 3
|
||||
};
|
||||
};
|
||||
|
||||
|
||||
namespace EtcItemID
|
||||
{
|
||||
enum Type
|
||||
{
|
||||
// <20><><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD> ID
|
||||
GEM_START_ID = 1901,
|
||||
GEM_END_ID = 1915,
|
||||
|
||||
// <20><><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD> ID
|
||||
MINERAL_START_ID = 2001,
|
||||
MINERAL_END_ID = 2003,
|
||||
|
||||
// ȸ<><C8B8><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD> ID
|
||||
POTION_START_ID = 3020,
|
||||
POTION_END_ID = 3124,
|
||||
|
||||
// <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD> <20><>
|
||||
OBLIVION_STONE = 9914
|
||||
};
|
||||
};
|
||||
};
|
||||
|
||||
|
||||
#endif
|
||||
465
GameTools/GLOBALSCRIPT/Item/ItemContainer.cpp
Normal file
465
GameTools/GLOBALSCRIPT/Item/ItemContainer.cpp
Normal file
@@ -0,0 +1,465 @@
|
||||
#include "stdafx.h"
|
||||
|
||||
#include <Log/ServerLog.h>
|
||||
#include <Pattern/Singleton.h>
|
||||
#include <Utility/Math/Math.h>
|
||||
|
||||
#include "Item.h"
|
||||
#include "ItemFactory.h"
|
||||
#include "ItemContainer.h"
|
||||
|
||||
namespace Item
|
||||
{
|
||||
class CNullItem : public CItem, public CSingleton<CNullItem>
|
||||
{
|
||||
public:
|
||||
virtual ~CNullItem() { }
|
||||
private:
|
||||
|
||||
CNullItem(const ItemInfo& itemInfo) : CItem(0, itemInfo) { }
|
||||
|
||||
static ItemInfo ms_thisiteminfo;
|
||||
static CNullItem ms_this;
|
||||
};
|
||||
};
|
||||
|
||||
Item::ItemInfo Item::CNullItem::ms_thisiteminfo(0xFFFF);
|
||||
Item::CNullItem Item::CNullItem::ms_this(Item::CNullItem::ms_thisiteminfo);
|
||||
|
||||
|
||||
// ----------------------------------------------------------------------------------------
|
||||
// CItemContainer
|
||||
|
||||
Item::CItemContainer::CItemContainer()
|
||||
: m_dwCID(0), m_nMaxSize(0), m_lpNullItem(&CNullItem::GetInstance()),
|
||||
m_lppItems(NULL), m_usFlags(0)
|
||||
{
|
||||
|
||||
}
|
||||
|
||||
Item::CItemContainer::~CItemContainer()
|
||||
{
|
||||
Destroy();
|
||||
}
|
||||
|
||||
|
||||
bool Item::CItemContainer::Initialize(unsigned long dwCID, unsigned short nMaxSize)
|
||||
{
|
||||
m_dwCID = dwCID;
|
||||
m_nMaxSize = nMaxSize;
|
||||
|
||||
m_lppItems = new CItem*[m_nMaxSize];
|
||||
if(NULL != m_lppItems)
|
||||
{
|
||||
std::fill_n(m_lppItems, m_nMaxSize, reinterpret_cast<CItem*>(NULL));
|
||||
return true;
|
||||
}
|
||||
|
||||
return false;
|
||||
}
|
||||
|
||||
void Item::CItemContainer::Destroy()
|
||||
{
|
||||
if(NULL != m_lppItems)
|
||||
{
|
||||
CItem** lppItem = m_lppItems;
|
||||
CItem** lppItemPastEnd = m_lppItems + m_nMaxSize;
|
||||
|
||||
for(; lppItem != lppItemPastEnd; ++lppItem)
|
||||
{
|
||||
CItem* lpItem = *lppItem;
|
||||
if(NULL != lpItem && m_lpNullItem != lpItem)
|
||||
{
|
||||
delete lpItem;
|
||||
}
|
||||
}
|
||||
|
||||
delete [] m_lppItems;
|
||||
m_lppItems = NULL;
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
void Item::CItemContainer::DumpItemInfo()
|
||||
{
|
||||
const int MIN_BUFFER = 32;
|
||||
const int MAX_BUFFER = 256;
|
||||
char szUID[MIN_BUFFER];
|
||||
char szBuffer[MAX_BUFFER];
|
||||
|
||||
CItem** lppItem = m_lppItems;
|
||||
CItem** lppItemPastEnd = m_lppItems + m_nMaxSize;
|
||||
|
||||
for(; lppItem != lppItemPastEnd; ++lppItem)
|
||||
{
|
||||
const CItem* lpItem = *lppItem;
|
||||
|
||||
if(NULL != lpItem && m_lpNullItem != lpItem)
|
||||
{
|
||||
Math::Convert::Hex64ToStr(szUID, lpItem->GetUID());
|
||||
|
||||
const ItemPos itemPos = lpItem->GetPos();
|
||||
const DetailData& detailData = lpItem->GetItemInfo().m_DetailData;
|
||||
|
||||
unsigned char cX, cY, cTab;
|
||||
itemPos.GetPos(cX, cY, cTab);
|
||||
|
||||
_snprintf(szBuffer, MAX_BUFFER, "CID:0x%08x <20><> <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>Դϴ<D4B4>. UID: %s <20><><EFBFBD><EFBFBD>ID : %5d,"
|
||||
" <20><>ǥ:(%d - %2d,%2d,%2d), ũ<><C5A9>:(%2d, %2d), <20><><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD>(<28><><EFBFBD><EFBFBD><EFBFBD><EFBFBD>):%2d",
|
||||
m_dwCID, szUID, lpItem->GetPrototypeID(), itemPos.m_cIndex, cX, cY, cTab,
|
||||
detailData.m_cXSize, detailData.m_cXSize, lpItem->GetNumOrDurability());
|
||||
|
||||
ERRLOG1(g_Log, "%s", szBuffer);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
bool Item::CItemContainer::SerializeOut(char* szItemBuffer_Out, unsigned long& dwBufferSize_InOut) const
|
||||
{
|
||||
CItem** lppItem = m_lppItems;
|
||||
CItem** lppItemPastEnd = m_lppItems + m_nMaxSize;
|
||||
|
||||
size_t nRemainBufferSize = static_cast<size_t>(dwBufferSize_InOut);
|
||||
size_t nWritten = 0;
|
||||
|
||||
for(; lppItem != lppItemPastEnd; ++lppItem)
|
||||
{
|
||||
CItem* lpItem = *lppItem;
|
||||
if(NULL != lpItem && m_lpNullItem != lpItem)
|
||||
{
|
||||
size_t nItemSize = nRemainBufferSize;
|
||||
if(!lpItem->SerializeOut(szItemBuffer_Out + nWritten, nItemSize))
|
||||
{
|
||||
return false;
|
||||
}
|
||||
|
||||
nWritten += nItemSize;
|
||||
nRemainBufferSize -= nItemSize;
|
||||
}
|
||||
}
|
||||
|
||||
dwBufferSize_InOut = static_cast<unsigned long>(nWritten);
|
||||
return true;
|
||||
}
|
||||
|
||||
|
||||
// ----------------------------------------------------------------------------------------
|
||||
// CArrayContainer
|
||||
|
||||
Item::CArrayContainer::CArrayContainer()
|
||||
{
|
||||
|
||||
}
|
||||
|
||||
Item::CArrayContainer::~CArrayContainer()
|
||||
{
|
||||
|
||||
}
|
||||
|
||||
|
||||
bool Item::CArrayContainer::Initialize(unsigned long dwCID, unsigned char nXSize, unsigned char nYSize, unsigned char nTabNum)
|
||||
{
|
||||
m_dwCID = dwCID;
|
||||
m_nXSize = nXSize;
|
||||
m_nYSize = nYSize;
|
||||
m_nTabNum = nTabNum;
|
||||
|
||||
m_nSizePerTab = nXSize * nYSize;
|
||||
return CItemContainer::Initialize(dwCID, nXSize * nYSize * nTabNum);
|
||||
}
|
||||
|
||||
|
||||
Item::CItem* Item::CArrayContainer::GetItem(Item::ItemPos itemPos)
|
||||
{
|
||||
unsigned char cX, cY, cTab;
|
||||
itemPos.GetPos(cX, cY, cTab);
|
||||
|
||||
if(m_nXSize <= cX || m_nYSize <= cY || m_nTabNum <= cTab)
|
||||
{
|
||||
ERRLOG7(g_Log, "CID:0x%08x <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD> <20><>ġ<EFBFBD><C4A1> <20>ùٸ<C3B9><D9B8><EFBFBD> <20>ʽ<EFBFBD><CABD>ϴ<EFBFBD>. X:%d/%d, Y:%d/%d, Tab:%d/%d",
|
||||
m_dwCID, cX, m_nXSize, cY, m_nYSize, cTab, m_nTabNum);
|
||||
return NULL;
|
||||
}
|
||||
|
||||
CItem* lpItem = m_lppItems[m_nSizePerTab * cTab + m_nXSize * cY + cX];
|
||||
return (lpItem != m_lpNullItem) ? lpItem : NULL;
|
||||
}
|
||||
|
||||
|
||||
bool Item::CArrayContainer::SetItem(Item::ItemPos itemPos, Item::CItem* lpItem)
|
||||
{
|
||||
if(NULL == lpItem)
|
||||
{
|
||||
ERRLOG1(g_Log, "CID:0x%08x <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD> NULL<4C>Դϴ<D4B4>.", m_dwCID);
|
||||
return false;
|
||||
}
|
||||
|
||||
unsigned char cX, cY, cTab;
|
||||
itemPos.GetPos(cX, cY, cTab);
|
||||
|
||||
unsigned char cXSize = lpItem->GetItemInfo().m_DetailData.m_cXSize;
|
||||
unsigned char cYSize = lpItem->GetItemInfo().m_DetailData.m_cYSize;
|
||||
|
||||
if(m_nXSize < static_cast<size_t>(cX + cXSize) ||
|
||||
m_nYSize < static_cast<size_t>(cY + cYSize) || m_nTabNum <= cTab)
|
||||
{
|
||||
ERRLOG9(g_Log, "CID:0x%08x <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD> <20><>ġ <20><> ũ<>Ⱑ <20>ùٸ<C3B9><D9B8><EFBFBD> <20>ʽ<EFBFBD><CABD>ϴ<EFBFBD>. "
|
||||
"X:%d/%d, Y:%d/%d, Tab:%d/%d, Xũ<58><C5A9>:%d, Yũ<59><C5A9>:%d",
|
||||
m_dwCID, cX, m_nXSize, cY, m_nYSize, cTab, m_nTabNum, cXSize, cYSize);
|
||||
return false;
|
||||
}
|
||||
|
||||
CItem** lppItemYIndexPastEnd = m_lppItems + m_nSizePerTab * cTab + m_nXSize * (cY + cYSize);
|
||||
CItem **lppItemYIndex, **lppItemXIndex, **lppItemXIndexPastEnd;
|
||||
|
||||
for(lppItemYIndex = m_lppItems + m_nSizePerTab * cTab + cY * m_nXSize;
|
||||
lppItemYIndex != lppItemYIndexPastEnd; lppItemYIndex += m_nXSize)
|
||||
{
|
||||
lppItemXIndexPastEnd = lppItemYIndex + cX + cXSize;
|
||||
|
||||
for(lppItemXIndex = lppItemYIndex + cX;
|
||||
lppItemXIndex != lppItemXIndexPastEnd; ++lppItemXIndex)
|
||||
{
|
||||
if(0 != *lppItemXIndex)
|
||||
{
|
||||
ERRLOG4(g_Log, "CID:0x%08x (%d,%d,%d) <20>̹<EFBFBD> <20><> <20><><EFBFBD>ҿ<EFBFBD> <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD> <20>ֽ<EFBFBD><D6BD>ϴ<EFBFBD>.",
|
||||
m_dwCID, cX, cY, cTab);
|
||||
return false;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
for(lppItemYIndex = m_lppItems + m_nSizePerTab * cTab + cY * m_nXSize;
|
||||
lppItemYIndex != lppItemYIndexPastEnd; lppItemYIndex += m_nXSize)
|
||||
{
|
||||
lppItemXIndexPastEnd = lppItemYIndex + cX + cXSize;
|
||||
|
||||
for(lppItemXIndex = lppItemYIndex + cX;
|
||||
lppItemXIndex != lppItemXIndexPastEnd; ++lppItemXIndex)
|
||||
{
|
||||
*lppItemXIndex = m_lpNullItem;
|
||||
}
|
||||
}
|
||||
|
||||
m_lppItems[m_nSizePerTab * cTab + m_nXSize * cY + cX] = lpItem;
|
||||
lpItem->MoveItem(itemPos);
|
||||
return true;
|
||||
}
|
||||
|
||||
|
||||
bool Item::CArrayContainer::RemoveItem(Item::ItemPos itemPos)
|
||||
{
|
||||
unsigned char cX, cY, cTab;
|
||||
itemPos.GetPos(cX, cY, cTab);
|
||||
|
||||
if(m_nXSize <= cX || m_nYSize <= cY || m_nTabNum <= cTab)
|
||||
{
|
||||
ERRLOG7(g_Log, "CID:0x%08x <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD> <20><>ġ <20><> ũ<>Ⱑ <20>ùٸ<C3B9><D9B8><EFBFBD> <20>ʽ<EFBFBD><CABD>ϴ<EFBFBD>. X:%d/%d, Y:%d/%d, Tab:%d/%d",
|
||||
m_dwCID, cX, m_nXSize, cY, m_nYSize, cTab, m_nTabNum);
|
||||
return false;
|
||||
}
|
||||
|
||||
CItem* lpItem = m_lppItems[m_nSizePerTab * cTab + m_nXSize * cY + cX];
|
||||
if(NULL == lpItem)
|
||||
{
|
||||
ERRLOG4(g_Log, "CID:0x%08x <20><> <20><>ġ<EFBFBD><C4A1> <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD><EFBFBD>ϴ<EFBFBD>. X:%d, Y:%d, Tab:%d", m_dwCID, cX, cY, cTab);
|
||||
return false;
|
||||
}
|
||||
|
||||
unsigned char cXSize = lpItem->GetItemInfo().m_DetailData.m_cXSize;
|
||||
unsigned char cYSize = lpItem->GetItemInfo().m_DetailData.m_cYSize;
|
||||
|
||||
if(m_nXSize < static_cast<size_t>(cX + cXSize) ||
|
||||
m_nYSize < static_cast<size_t>(cY + cYSize))
|
||||
{
|
||||
ERRLOG9(g_Log, "CID:0x%08x <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD> <20><>ġ <20><> ũ<>Ⱑ <20>ùٸ<C3B9><D9B8><EFBFBD> <20>ʽ<EFBFBD><CABD>ϴ<EFBFBD>. "
|
||||
"X:%d/%d, Y:%d/%d, Tab:%d/%d, Xũ<58><C5A9>:%d, Yũ<59><C5A9>:%d",
|
||||
m_dwCID, cX, m_nXSize, cY, m_nYSize, cTab, m_nTabNum, cXSize, cYSize);
|
||||
return false;
|
||||
}
|
||||
|
||||
CItem** lppItemYIndexPastEnd = m_lppItems + m_nSizePerTab * cTab + m_nXSize * (cY + cYSize);
|
||||
CItem **lppItemYIndex, **lppItemXIndex, **lppItemXIndexPastEnd;
|
||||
|
||||
for(lppItemYIndex = m_lppItems + m_nSizePerTab * cTab + cY * m_nXSize;
|
||||
lppItemYIndex != lppItemYIndexPastEnd; lppItemYIndex += m_nXSize)
|
||||
{
|
||||
lppItemXIndexPastEnd = lppItemYIndex + cX + cXSize;
|
||||
|
||||
for(lppItemXIndex = lppItemYIndex + cX;
|
||||
lppItemXIndex != lppItemXIndexPastEnd; ++lppItemXIndex)
|
||||
{
|
||||
*lppItemXIndex = NULL;
|
||||
}
|
||||
}
|
||||
|
||||
return true;
|
||||
}
|
||||
|
||||
|
||||
void Item::CArrayContainer::DumpItemInfo()
|
||||
{
|
||||
const int MAX_LINE = 128;
|
||||
char szLine[MAX_LINE];
|
||||
|
||||
int nBufferPos = 0;
|
||||
|
||||
ERRLOG1(g_Log, "CID:0x%08x <20><> <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD> <20>α<CEB1> <20><><EFBFBD><EFBFBD><EFBFBD>մϴ<D5B4>.", m_dwCID);
|
||||
|
||||
for(unsigned short nTab = 0; nTab < m_nTabNum; ++nTab)
|
||||
{
|
||||
const unsigned short usTabPos = m_nSizePerTab * nTab;
|
||||
|
||||
ERRLOG2(g_Log, "CID:0x%08x <20><> <20><> %d<><64> <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>Դϴ<D4B4>.", m_dwCID, nTab);
|
||||
|
||||
for(unsigned short nHeight = 0; nHeight < m_nYSize; ++nHeight)
|
||||
{
|
||||
const unsigned short nHeightPos = m_nXSize * nHeight + usTabPos;
|
||||
|
||||
nBufferPos = _snprintf(szLine, MAX_LINE, "CID:0x%08x <20><> <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>Դϴ<D4B4>. ", m_dwCID);
|
||||
|
||||
for(unsigned short nWidth = 0; nWidth < m_nXSize; ++nWidth)
|
||||
{
|
||||
const CItem* lpItem = m_lppItems[nHeightPos + nWidth];
|
||||
|
||||
nBufferPos += _snprintf(szLine + nBufferPos, MAX_LINE, " %5d ",
|
||||
((0 != lpItem) ? lpItem->GetPrototypeID() : 0));
|
||||
}
|
||||
|
||||
ERRLOG0(g_Log, szLine);
|
||||
}
|
||||
}
|
||||
|
||||
CItemContainer::DumpItemInfo();
|
||||
}
|
||||
|
||||
|
||||
bool Item::CArrayContainer::SerializeIn(const char* szItemBuffer_In, unsigned long dwBufferSize_In)
|
||||
{
|
||||
size_t nBufferSize = static_cast<size_t>(dwBufferSize_In);
|
||||
size_t nUsed = 0;
|
||||
|
||||
Item::CItemFactory& ItemFactory = CItemFactory::GetInstance();
|
||||
|
||||
while(nBufferSize > 0)
|
||||
{
|
||||
size_t nItemSize = nBufferSize;
|
||||
Item::CItem* lpItem = ItemFactory.CreateItem(szItemBuffer_In + nUsed, nItemSize);
|
||||
|
||||
if(NULL == lpItem)
|
||||
{
|
||||
nItemSize = reinterpret_cast<const Item::ItemData*>(szItemBuffer_In + nUsed)->m_cItemSize;
|
||||
ERRLOG1(g_Log, "CID:0x%08x <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD><EFBFBD>߽<EFBFBD><DFBD>ϴ<EFBFBD>.", m_dwCID);
|
||||
}
|
||||
else if(!CArrayContainer::SetItem(lpItem->GetPos(), lpItem))
|
||||
{
|
||||
nItemSize = reinterpret_cast<const Item::ItemData*>(szItemBuffer_In + nUsed)->m_cItemSize;
|
||||
ERRLOG1(g_Log, "CID:0x%08x <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD> <20><><EFBFBD>⸦ <20><><EFBFBD><EFBFBD><EFBFBD>߽<EFBFBD><DFBD>ϴ<EFBFBD>.", m_dwCID);
|
||||
delete lpItem;
|
||||
}
|
||||
|
||||
nUsed += nItemSize;
|
||||
nBufferSize -= nItemSize;
|
||||
}
|
||||
|
||||
return true;
|
||||
}
|
||||
|
||||
|
||||
// ----------------------------------------------------------------------------------------
|
||||
// CListContainer
|
||||
|
||||
Item::CListContainer::CListContainer()
|
||||
{
|
||||
|
||||
}
|
||||
|
||||
|
||||
Item::CListContainer::~CListContainer()
|
||||
{
|
||||
|
||||
}
|
||||
|
||||
|
||||
Item::CItem* Item::CListContainer::GetItem(Item::ItemPos itemPos)
|
||||
{
|
||||
if(itemPos.m_cIndex < m_nMaxSize)
|
||||
{
|
||||
CItem* lpItem = m_lppItems[itemPos.m_cIndex];
|
||||
return (lpItem != m_lpNullItem) ? lpItem : NULL;
|
||||
}
|
||||
|
||||
return NULL;
|
||||
}
|
||||
|
||||
|
||||
bool Item::CListContainer::SetItem(Item::ItemPos itemPos, Item::CItem* lpItem)
|
||||
{
|
||||
if(itemPos.m_cIndex < m_nMaxSize)
|
||||
{
|
||||
if(NULL == m_lppItems[itemPos.m_cIndex])
|
||||
{
|
||||
m_lppItems[itemPos.m_cIndex] = lpItem;
|
||||
lpItem->MoveItem(itemPos);
|
||||
return true;
|
||||
}
|
||||
else
|
||||
{
|
||||
ERRLOG1(g_Log, "CID:0x%08x <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD> <20>̹<EFBFBD> <20><><EFBFBD><EFBFBD><EFBFBD>մϴ<D5B4>.", m_dwCID);
|
||||
}
|
||||
}
|
||||
|
||||
return false;
|
||||
}
|
||||
|
||||
|
||||
bool Item::CListContainer::RemoveItem(Item::ItemPos itemPos)
|
||||
{
|
||||
if(itemPos.m_cIndex < m_nMaxSize)
|
||||
{
|
||||
if(NULL != m_lppItems[itemPos.m_cIndex])
|
||||
{
|
||||
m_lppItems[itemPos.m_cIndex] = NULL;
|
||||
return true;
|
||||
}
|
||||
else
|
||||
{
|
||||
ERRLOG1(g_Log, "CID:0x%08x <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD> <20>ʽ<EFBFBD><CABD>ϴ<EFBFBD>.", m_dwCID);
|
||||
}
|
||||
}
|
||||
|
||||
return false;
|
||||
}
|
||||
|
||||
|
||||
bool Item::CListContainer::SerializeIn(const char* szItemBuffer_In, unsigned long dwBufferSize_In)
|
||||
{
|
||||
size_t nBufferSize = static_cast<size_t>(dwBufferSize_In);
|
||||
size_t nUsed = 0;
|
||||
|
||||
Item::CItemFactory& ItemFactory = CItemFactory::GetInstance();
|
||||
|
||||
while(nBufferSize > 0)
|
||||
{
|
||||
size_t nItemSize = nBufferSize;
|
||||
Item::CItem* lpItem = ItemFactory.CreateItem(szItemBuffer_In + nUsed, nItemSize);
|
||||
|
||||
if(NULL == lpItem)
|
||||
{
|
||||
nItemSize = reinterpret_cast<const Item::ItemData*>(szItemBuffer_In + nUsed)->m_cItemSize;
|
||||
ERRLOG1(g_Log, "CID:0x%08x <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD><EFBFBD>߽<EFBFBD><DFBD>ϴ<EFBFBD>.", m_dwCID);
|
||||
}
|
||||
else if(!CListContainer::SetItem(lpItem->GetPos(), lpItem))
|
||||
{
|
||||
nItemSize = reinterpret_cast<const Item::ItemData*>(szItemBuffer_In + nUsed)->m_cItemSize;
|
||||
ERRLOG1(g_Log, "CID:0x%08x <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD> <20><><EFBFBD>⸦ <20><><EFBFBD><EFBFBD><EFBFBD>߽<EFBFBD><DFBD>ϴ<EFBFBD>.", m_dwCID);
|
||||
delete lpItem;
|
||||
}
|
||||
|
||||
nUsed += nItemSize;
|
||||
nBufferSize -= nItemSize;
|
||||
}
|
||||
|
||||
return true;
|
||||
}
|
||||
82
GameTools/GLOBALSCRIPT/Item/ItemContainer.h
Normal file
82
GameTools/GLOBALSCRIPT/Item/ItemContainer.h
Normal file
@@ -0,0 +1,82 @@
|
||||
#ifndef _ITEM_CONTAINER_H_
|
||||
#define _ITEM_CONTAINER_H_
|
||||
|
||||
#include "ItemStructure.h"
|
||||
|
||||
// <20><><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD>
|
||||
namespace Item
|
||||
{
|
||||
class CItem;
|
||||
|
||||
class CItemContainer
|
||||
{
|
||||
public:
|
||||
|
||||
CItemContainer();
|
||||
virtual ~CItemContainer();
|
||||
|
||||
bool Initialize(unsigned long dwCID, unsigned short nMaxSize);
|
||||
|
||||
virtual CItem* GetItem(ItemPos itemPos) = 0;
|
||||
virtual bool SetItem(ItemPos itemPos, CItem* lpItem) = 0;
|
||||
virtual bool RemoveItem(ItemPos itemPos) = 0;
|
||||
|
||||
virtual bool SerializeOut(char* szItemBuffer_Out, unsigned long& dwBufferSize_InOut) const;
|
||||
virtual bool SerializeIn(const char* szItemBuffer_In, unsigned long dwBufferSize_InOut) = 0;
|
||||
|
||||
virtual void DumpItemInfo();
|
||||
|
||||
protected:
|
||||
|
||||
void Destroy();
|
||||
|
||||
CItem** m_lppItems;
|
||||
CItem* m_lpNullItem;
|
||||
|
||||
unsigned long m_dwCID;
|
||||
unsigned short m_nMaxSize;
|
||||
unsigned short m_usFlags;
|
||||
};
|
||||
|
||||
class CArrayContainer : public CItemContainer
|
||||
{
|
||||
public:
|
||||
|
||||
CArrayContainer();
|
||||
virtual ~CArrayContainer();
|
||||
|
||||
bool Initialize(unsigned long dwCID, unsigned char nXSize, unsigned char nYSize, unsigned char nTabNum);
|
||||
|
||||
virtual CItem* GetItem(ItemPos itemPos);
|
||||
virtual bool SetItem(ItemPos itemPos, CItem* lpItem);
|
||||
virtual bool RemoveItem(ItemPos itemPos);
|
||||
|
||||
virtual bool SerializeIn(const char* szItemBuffer_In, unsigned long dwBufferSize_In);
|
||||
|
||||
virtual void DumpItemInfo();
|
||||
|
||||
private:
|
||||
|
||||
unsigned char m_nXSize;
|
||||
unsigned char m_nYSize;
|
||||
unsigned char m_nTabNum;
|
||||
unsigned char m_nSizePerTab;
|
||||
};
|
||||
|
||||
|
||||
class CListContainer : public CItemContainer
|
||||
{
|
||||
public:
|
||||
|
||||
CListContainer();
|
||||
virtual ~CListContainer();
|
||||
|
||||
virtual CItem* GetItem(ItemPos itemPos);
|
||||
virtual bool SetItem(ItemPos itemPos, CItem* lpItem);
|
||||
virtual bool RemoveItem(ItemPos itemPos);
|
||||
|
||||
virtual bool SerializeIn(const char* szItemBuffer_In, unsigned long dwBufferSize_In);
|
||||
};
|
||||
};
|
||||
|
||||
#endif
|
||||
263
GameTools/GLOBALSCRIPT/Item/ItemDataParser.cpp
Normal file
263
GameTools/GLOBALSCRIPT/Item/ItemDataParser.cpp
Normal file
@@ -0,0 +1,263 @@
|
||||
#include "stdafx.h"
|
||||
|
||||
#include <Log/ServerLog.h>
|
||||
#include <Utility/Math/Math.h>
|
||||
|
||||
#include "ItemStructure.h"
|
||||
#include "ItemDataParser.h"
|
||||
|
||||
|
||||
using namespace Item;
|
||||
|
||||
bool ReadString(char* szBuffer_Out, int nBufferLen, const char* szValue_In)
|
||||
{
|
||||
int nLength = _snprintf(szBuffer_Out, nBufferLen - 1, "%s", szValue_In);
|
||||
|
||||
if(0 < nLength)
|
||||
{
|
||||
szBuffer_Out[nLength] = '\0';
|
||||
return true;
|
||||
}
|
||||
|
||||
szBuffer_Out[nBufferLen - 1] = '\0';
|
||||
ERRLOG1(g_Log, "<EFBFBD><EFBFBD><EFBFBD><EFBFBD> <20><><EFBFBD>̰<EFBFBD> <20><><EFBFBD>ڶ<EFBFBD><DAB6><EFBFBD>, <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD> <20><> <20><><EFBFBD><EFBFBD><EFBFBD>ϴ<EFBFBD>. Data:%s", szValue_In);
|
||||
return false;
|
||||
}
|
||||
|
||||
inline bool ReadValue(unsigned char& cValue_Out, const char* szValue_In)
|
||||
{
|
||||
cValue_Out = static_cast<unsigned char>(atoi(szValue_In));
|
||||
return true;
|
||||
}
|
||||
|
||||
inline bool ReadValue(unsigned short& usValue_Out, const char* szValue_In)
|
||||
{
|
||||
usValue_Out = static_cast<unsigned short>(atoi(szValue_In));
|
||||
return true;
|
||||
}
|
||||
|
||||
|
||||
inline bool ReadValue(unsigned long& dwValue_Out, const char* szValue_In)
|
||||
{
|
||||
dwValue_Out = static_cast<unsigned long>(atol(szValue_In));
|
||||
return true;
|
||||
}
|
||||
|
||||
|
||||
bool ReadStringToTypeValue(unsigned char& cVaule_Out, const CTypeName* lpTypeArray,
|
||||
const unsigned char nMaxType, const char* szValue_In)
|
||||
{
|
||||
for (unsigned char nCount = 0; nCount < nMaxType; ++nCount)
|
||||
{
|
||||
if(0 == strcmp(szValue_In, lpTypeArray[nCount].GetTypeName()))
|
||||
{
|
||||
cVaule_Out = lpTypeArray[nCount].GetTypeValue();
|
||||
return true;
|
||||
}
|
||||
}
|
||||
|
||||
return false;
|
||||
}
|
||||
|
||||
|
||||
|
||||
// <20>⺻ <20><><EFBFBD><EFBFBD><EFBFBD>͵<EFBFBD>
|
||||
bool ReadID(Item::ItemInfo& itemInfo, const char* szValue)
|
||||
{
|
||||
itemInfo.m_usProtoTypeID = static_cast<unsigned short>(atoi(szValue));
|
||||
if(0 == itemInfo.m_usProtoTypeID || 0xFFFF == itemInfo.m_usProtoTypeID)
|
||||
{
|
||||
ERRLOG1(g_Log, "<EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD> ID<49><44> <20>̻<EFBFBD><CCBB>մϴ<D5B4>. 0<>̳<EFBFBD> 0xFFFF<46><46> <20><><EFBFBD><EFBFBD><EFBFBD>Ͻ<EFBFBD> <20><> <20><><EFBFBD><EFBFBD><EFBFBD>ϴ<EFBFBD>. ID:0x%08x",
|
||||
itemInfo.m_usProtoTypeID);
|
||||
|
||||
return false;
|
||||
}
|
||||
|
||||
return true;
|
||||
}
|
||||
|
||||
bool ReadItemName(Item::ItemInfo& itemInfo, const char* szValue) { return ReadString(itemInfo.m_SpriteData.m_szName, SpriteData::MAX_NAME, szValue); }
|
||||
bool ReadFieldModelName(Item::ItemInfo& itemInfo, const char* szValue) { return ReadString(itemInfo.m_StringData.m_szFieldModelName, StringData::MAX_FIELD_MODEL_NAME, szValue); }
|
||||
bool ReadAttachedModelName(Item::ItemInfo& itemInfo, const char* szValue) { return ReadString(itemInfo.m_StringData.m_szEquipModelName, StringData::MAX_EQUIP_MODEL_NAME, szValue); }
|
||||
bool ReadSpriteDDS(Item::ItemInfo& itemInfo, const char* szValue) { return ReadString(itemInfo.m_SpriteData.m_szSpriteName, SpriteData::MAX_SPRITE_NAME, szValue); }
|
||||
bool ReadMinX(Item::ItemInfo& itemInfo, const char* szValue) { return ReadValue(itemInfo.m_SpriteData.m_nSpriteMinX, szValue); }
|
||||
bool ReadMinY(Item::ItemInfo& itemInfo, const char* szValue) { return ReadValue(itemInfo.m_SpriteData.m_nSpriteMinY, szValue); }
|
||||
bool ReadMaxX(Item::ItemInfo& itemInfo, const char* szValue) { return ReadValue(itemInfo.m_SpriteData.m_nSpriteMaxX, szValue); }
|
||||
bool ReadMaxY(Item::ItemInfo& itemInfo, const char* szValue) { return ReadValue(itemInfo.m_SpriteData.m_nSpriteMaxY, szValue); }
|
||||
bool ReadSizeX(Item::ItemInfo& itemInfo, const char* szValue) { return ReadValue(itemInfo.m_DetailData.m_cXSize, szValue); }
|
||||
bool ReadSizeY(Item::ItemInfo& itemInfo, const char* szValue) { return ReadValue(itemInfo.m_DetailData.m_cYSize, szValue); }
|
||||
bool ReadEffectSound(Item::ItemInfo& itemInfo, const char* szValue) { return ReadString(itemInfo.m_StringData.m_szEffectSoundName, StringData::MAX_EFFECT_SOUND_NAME, szValue); }
|
||||
|
||||
bool ReadItemLevel(Item::ItemInfo& itemInfo, const char* szValue)
|
||||
{
|
||||
unsigned char cGrade = 0;
|
||||
if(ReadStringToTypeValue(cGrade, Item::Grade::Grades, Item::Grade::MAX_ITEM_GRADE, szValue))
|
||||
{
|
||||
itemInfo.m_DetailData.m_ItemGrade = static_cast<Item::Grade::Type>(cGrade);
|
||||
return true;
|
||||
}
|
||||
|
||||
return false;
|
||||
}
|
||||
|
||||
bool ReadItemType(Item::ItemInfo& itemInfo, const char* szValue)
|
||||
{
|
||||
return ReadStringToTypeValue(itemInfo.m_DetailData.m_cItemType,
|
||||
Item::CItemType::GetInstance().GetItemTypeName(), Item::CItemType::MAX_ITEM_TYPE, szValue);
|
||||
}
|
||||
|
||||
bool ReadPrice(Item::ItemInfo& itemInfo, const char* szValue) { return ReadValue(itemInfo.m_DetailData.m_dwPrice, szValue); }
|
||||
bool ReadBlackPrice(Item::ItemInfo& itemInfo, const char* szValue) { return ReadValue(itemInfo.m_DetailData.m_dwBlackPrice, szValue); }
|
||||
bool ReadOptionLimit(Item::ItemInfo& itemInfo, const char* szValue) { return ReadValue(itemInfo.m_DetailData.m_cOptionLimit, szValue); }
|
||||
bool ReadDurability(Item::ItemInfo& itemInfo, const char* szValue) { return ReadValue(itemInfo.m_DetailData.m_cDefaultDurabilityOrStack, szValue); }
|
||||
bool ReadMaxDurability(Item::ItemInfo& itemInfo, const char* szValue) { return ReadValue(itemInfo.m_DetailData.m_cMaxDurabilityOrStack, szValue); }
|
||||
bool ReadClassLimit(Item::ItemInfo& itemInfo, const char* szValue) { return ReadValue(itemInfo.m_UseLimit.m_dwClassLimit, szValue); }
|
||||
bool ReadSkillLimitType(Item::ItemInfo& itemInfo, const char* szValue) { return ReadValue(itemInfo.m_UseLimit.m_nSkillType, szValue); }
|
||||
bool ReadSkillLimitLevel(Item::ItemInfo& itemInfo, const char* szValue) { return ReadValue(itemInfo.m_UseLimit.m_cSkillLevel, szValue); }
|
||||
bool ReadLevelLimit(Item::ItemInfo& itemInfo, const char* szValue) { return ReadValue(itemInfo.m_UseLimit.m_cLevelLimit, szValue); }
|
||||
bool ReadSTRLimit(Item::ItemInfo& itemInfo, const char* szValue) { return ReadValue(itemInfo.m_UseLimit.m_nStatusLimit[StatusLimit::STR], szValue); }
|
||||
bool ReadDEXLimit(Item::ItemInfo& itemInfo, const char* szValue) { return ReadValue(itemInfo.m_UseLimit.m_nStatusLimit[StatusLimit::DEX], szValue); }
|
||||
bool ReadCONLimit(Item::ItemInfo& itemInfo, const char* szValue) { return ReadValue(itemInfo.m_UseLimit.m_nStatusLimit[StatusLimit::CON], szValue); }
|
||||
bool ReadINTLimit(Item::ItemInfo& itemInfo, const char* szValue) { return ReadValue(itemInfo.m_UseLimit.m_nStatusLimit[StatusLimit::INT], szValue); }
|
||||
bool ReadWISLimit(Item::ItemInfo& itemInfo, const char* szValue) { return ReadValue(itemInfo.m_UseLimit.m_nStatusLimit[StatusLimit::WIS], szValue); }
|
||||
|
||||
|
||||
|
||||
bool ItemDataParser::SetDefaultData(ParseDataArray& parseDataArray)
|
||||
{
|
||||
parseDataArray.reserve(30);
|
||||
|
||||
parseDataArray.push_back(ParseData("ID", ReadID));
|
||||
parseDataArray.push_back(ParseData("ItemName", ReadItemName));
|
||||
parseDataArray.push_back(ParseData("FieldModelName", ReadFieldModelName));
|
||||
parseDataArray.push_back(ParseData("AttachedModelName", ReadAttachedModelName));
|
||||
parseDataArray.push_back(ParseData("SpriteDDS", ReadSpriteDDS));
|
||||
parseDataArray.push_back(ParseData("MinX", ReadMinX));
|
||||
parseDataArray.push_back(ParseData("MinY", ReadMinY));
|
||||
parseDataArray.push_back(ParseData("MaxX", ReadMaxX));
|
||||
parseDataArray.push_back(ParseData("MaxY", ReadMaxY));
|
||||
parseDataArray.push_back(ParseData("SizeX", ReadSizeX));
|
||||
parseDataArray.push_back(ParseData("SizeY", ReadSizeY));
|
||||
parseDataArray.push_back(ParseData("EffectSound", ReadEffectSound));
|
||||
parseDataArray.push_back(ParseData("ItemLevel", ReadItemLevel));
|
||||
parseDataArray.push_back(ParseData("ItemType", ReadItemType));
|
||||
parseDataArray.push_back(ParseData("Price", ReadPrice));
|
||||
parseDataArray.push_back(ParseData("BlackPrice", ReadBlackPrice));
|
||||
parseDataArray.push_back(ParseData("OptionLimit", ReadOptionLimit));
|
||||
parseDataArray.push_back(ParseData("Durability", ReadDurability));
|
||||
parseDataArray.push_back(ParseData("MaxDurability", ReadMaxDurability));
|
||||
parseDataArray.push_back(ParseData("ClassLimit", ReadClassLimit));
|
||||
parseDataArray.push_back(ParseData("SkillLimitType", ReadSkillLimitType));
|
||||
parseDataArray.push_back(ParseData("SkillLimitLevel", ReadSkillLimitLevel));
|
||||
parseDataArray.push_back(ParseData("LevelLimit", ReadLevelLimit));
|
||||
parseDataArray.push_back(ParseData("STRLimit", ReadSTRLimit));
|
||||
parseDataArray.push_back(ParseData("DEXLimit", ReadDEXLimit));
|
||||
parseDataArray.push_back(ParseData("CONLimit", ReadCONLimit));
|
||||
parseDataArray.push_back(ParseData("INTLimit", ReadINTLimit));
|
||||
parseDataArray.push_back(ParseData("WISLimit", ReadWISLimit));
|
||||
|
||||
return true;
|
||||
}
|
||||
|
||||
|
||||
|
||||
bool ReadCriticalType(Item::ItemInfo& itemInfo, const char* szValue) { ++itemInfo.m_EquipAttribute.m_nAttibuteNum; return ReadValue(itemInfo.m_EquipAttribute.m_usAttributeValue[Item::Attribute::CRITICAL_TYPE], szValue); }
|
||||
bool ReadCriticalPercentage(Item::ItemInfo& itemInfo, const char* szValue) { ++itemInfo.m_EquipAttribute.m_nAttibuteNum; return ReadValue(itemInfo.m_EquipAttribute.m_usAttributeValue[Item::Attribute::CRITICAL_PERCENTAGE], szValue); }
|
||||
bool ReadMinDamage(Item::ItemInfo& itemInfo, const char* szValue) { ++itemInfo.m_EquipAttribute.m_nAttibuteNum; return ReadValue(itemInfo.m_EquipAttribute.m_usAttributeValue[Item::Attribute::MIN_DAMAGE], szValue); }
|
||||
bool ReadMaxDamage(Item::ItemInfo& itemInfo, const char* szValue) { ++itemInfo.m_EquipAttribute.m_nAttibuteNum; return ReadValue(itemInfo.m_EquipAttribute.m_usAttributeValue[Item::Attribute::MAX_DAMAGE], szValue); }
|
||||
bool ReadDRC(Item::ItemInfo& itemInfo, const char* szValue) { ++itemInfo.m_EquipAttribute.m_nAttibuteNum; return ReadValue(itemInfo.m_EquipAttribute.m_usAttributeValue[Item::Attribute::DRC], szValue); }
|
||||
bool ReadOffenceRevision(Item::ItemInfo& itemInfo, const char* szValue) { ++itemInfo.m_EquipAttribute.m_nAttibuteNum; return ReadValue(itemInfo.m_EquipAttribute.m_usAttributeValue[Item::Attribute::OFFENCE_REVISION], szValue); }
|
||||
bool ReadDefence(Item::ItemInfo& itemInfo, const char* szValue) { ++itemInfo.m_EquipAttribute.m_nAttibuteNum; return ReadValue(itemInfo.m_EquipAttribute.m_usAttributeValue[Item::Attribute::DEFENCE], szValue); }
|
||||
bool ReadDefenceRevision(Item::ItemInfo& itemInfo, const char* szValue) { ++itemInfo.m_EquipAttribute.m_nAttibuteNum; return ReadValue(itemInfo.m_EquipAttribute.m_usAttributeValue[Item::Attribute::DEFENCE_REVISION], szValue); }
|
||||
bool ReadResistance(Item::ItemInfo& itemInfo, const char* szValue) { ++itemInfo.m_EquipAttribute.m_nAttibuteNum; return ReadValue(itemInfo.m_EquipAttribute.m_usAttributeValue[Item::Attribute::MAGIC_RESISTANCE], szValue); }
|
||||
bool ReadBlockingPercentage(Item::ItemInfo& itemInfo, const char* szValue) { ++itemInfo.m_EquipAttribute.m_nAttibuteNum; return ReadValue(itemInfo.m_EquipAttribute.m_usAttributeValue[Item::Attribute::BLOCKING_PERCENTAGE], szValue); }
|
||||
bool ReadAttackSpeed(Item::ItemInfo& itemInfo, const char* szValue) { ++itemInfo.m_EquipAttribute.m_nAttibuteNum; return ReadValue(itemInfo.m_EquipAttribute.m_usAttributeValue[Item::Attribute::ATTACK_SPEED], szValue); }
|
||||
bool ReadMoveSpeed(Item::ItemInfo& itemInfo, const char* szValue) { ++itemInfo.m_EquipAttribute.m_nAttibuteNum; return ReadValue(itemInfo.m_EquipAttribute.m_usAttributeValue[Item::Attribute::MOVE_SPEED], szValue); }
|
||||
bool ReadAttackRange(Item::ItemInfo& itemInfo, const char* szValue) { ++itemInfo.m_EquipAttribute.m_nAttibuteNum; return ReadValue(itemInfo.m_EquipAttribute.m_usAttributeValue[Item::Attribute::ATTACK_RANGE], szValue); }
|
||||
bool ReadRangedAttack(Item::ItemInfo& itemInfo, const char* szValue) { ++itemInfo.m_EquipAttribute.m_nAttibuteNum; return ReadValue(itemInfo.m_EquipAttribute.m_usAttributeValue[Item::Attribute::RANGE_ATTACK_DISTANCE], szValue); }
|
||||
bool ReadHpMaxPlus(Item::ItemInfo& itemInfo, const char* szValue) { ++itemInfo.m_EquipAttribute.m_nAttibuteNum; return ReadValue(itemInfo.m_EquipAttribute.m_usAttributeValue[Item::Attribute::MAX_HP], szValue); }
|
||||
bool ReadMpMaxPlus(Item::ItemInfo& itemInfo, const char* szValue) { ++itemInfo.m_EquipAttribute.m_nAttibuteNum; return ReadValue(itemInfo.m_EquipAttribute.m_usAttributeValue[Item::Attribute::MAX_MP], szValue); }
|
||||
bool ReadHPRegen(Item::ItemInfo& itemInfo, const char* szValue) { ++itemInfo.m_EquipAttribute.m_nAttibuteNum; return ReadValue(itemInfo.m_EquipAttribute.m_usAttributeValue[Item::Attribute::HP_REGEN_AMOUNT], szValue); }
|
||||
bool ReadMPRegen(Item::ItemInfo& itemInfo, const char* szValue) { ++itemInfo.m_EquipAttribute.m_nAttibuteNum; return ReadValue(itemInfo.m_EquipAttribute.m_usAttributeValue[Item::Attribute::MP_REGEN_AMOUNT], szValue); }
|
||||
bool ReadFireAttribute(Item::ItemInfo& itemInfo, const char* szValue) { ++itemInfo.m_EquipAttribute.m_nAttibuteNum; return ReadValue(itemInfo.m_EquipAttribute.m_usAttributeValue[Item::Attribute::FIRE_ATTACK], szValue); }
|
||||
bool ReadLightingAttribute(Item::ItemInfo& itemInfo, const char* szValue) { ++itemInfo.m_EquipAttribute.m_nAttibuteNum; return ReadValue(itemInfo.m_EquipAttribute.m_usAttributeValue[Item::Attribute::LIGHTNING_ATTACK], szValue); }
|
||||
bool ReadColdAttribute(Item::ItemInfo& itemInfo, const char* szValue) { ++itemInfo.m_EquipAttribute.m_nAttibuteNum; return ReadValue(itemInfo.m_EquipAttribute.m_usAttributeValue[Item::Attribute::COLD_ATTACK], szValue); }
|
||||
bool ReadDrainAttribute(Item::ItemInfo& itemInfo, const char* szValue) { ++itemInfo.m_EquipAttribute.m_nAttibuteNum; return ReadValue(itemInfo.m_EquipAttribute.m_usAttributeValue[Item::Attribute::DRAIN_ATTACK], szValue); }
|
||||
bool ReadPoisonAttribute(Item::ItemInfo& itemInfo, const char* szValue) { ++itemInfo.m_EquipAttribute.m_nAttibuteNum; return ReadValue(itemInfo.m_EquipAttribute.m_usAttributeValue[Item::Attribute::POISON_ATTACK], szValue); }
|
||||
bool ReadFireResistance(Item::ItemInfo& itemInfo, const char* szValue) { ++itemInfo.m_EquipAttribute.m_nAttibuteNum; return ReadValue(itemInfo.m_EquipAttribute.m_usAttributeValue[Item::Attribute::FIRE_RESISTANCE], szValue); }
|
||||
bool ReadLightningResistance(Item::ItemInfo& itemInfo, const char* szValue) { ++itemInfo.m_EquipAttribute.m_nAttibuteNum; return ReadValue(itemInfo.m_EquipAttribute.m_usAttributeValue[Item::Attribute::LIGHTNING_RESISTANCE], szValue); }
|
||||
bool ReadColdResistance(Item::ItemInfo& itemInfo, const char* szValue) { ++itemInfo.m_EquipAttribute.m_nAttibuteNum; return ReadValue(itemInfo.m_EquipAttribute.m_usAttributeValue[Item::Attribute::COLD_RESISTANCE], szValue); }
|
||||
bool ReadDrainResistance(Item::ItemInfo& itemInfo, const char* szValue) { ++itemInfo.m_EquipAttribute.m_nAttibuteNum; return ReadValue(itemInfo.m_EquipAttribute.m_usAttributeValue[Item::Attribute::DRAIN_RESISTANCE], szValue); }
|
||||
bool ReadPoisonResistance(Item::ItemInfo& itemInfo, const char* szValue) { ++itemInfo.m_EquipAttribute.m_nAttibuteNum; return ReadValue(itemInfo.m_EquipAttribute.m_usAttributeValue[Item::Attribute::POISON_RESISTANCE], szValue); }
|
||||
bool ReadSTRAdd(Item::ItemInfo& itemInfo, const char* szValue) { ++itemInfo.m_EquipAttribute.m_nAttibuteNum; return ReadValue(itemInfo.m_EquipAttribute.m_usAttributeValue[Item::Attribute::ADD_STR], szValue); }
|
||||
bool ReadDEXAdd(Item::ItemInfo& itemInfo, const char* szValue) { ++itemInfo.m_EquipAttribute.m_nAttibuteNum; return ReadValue(itemInfo.m_EquipAttribute.m_usAttributeValue[Item::Attribute::ADD_DEX], szValue); }
|
||||
bool ReadCONAdd(Item::ItemInfo& itemInfo, const char* szValue) { ++itemInfo.m_EquipAttribute.m_nAttibuteNum; return ReadValue(itemInfo.m_EquipAttribute.m_usAttributeValue[Item::Attribute::ADD_CON], szValue); }
|
||||
bool ReadINTAdd(Item::ItemInfo& itemInfo, const char* szValue) { ++itemInfo.m_EquipAttribute.m_nAttibuteNum; return ReadValue(itemInfo.m_EquipAttribute.m_usAttributeValue[Item::Attribute::ADD_INT], szValue); }
|
||||
bool ReadWISAdd(Item::ItemInfo& itemInfo, const char* szValue) { ++itemInfo.m_EquipAttribute.m_nAttibuteNum; return ReadValue(itemInfo.m_EquipAttribute.m_usAttributeValue[Item::Attribute::ADD_WIS], szValue); }
|
||||
bool ReadMaterialValue(Item::ItemInfo& itemInfo, const char* szValue) { return ReadValue(itemInfo.m_DetailData.m_cMaterialType, szValue); }
|
||||
bool ReadMaxSocketNum(Item::ItemInfo& itemInfo, const char* szValue) { return ReadValue(itemInfo.m_DetailData.m_cMaxSocketNum, szValue); }
|
||||
|
||||
|
||||
bool ItemDataParser::SetEquipData(ParseDataArray& parseDataArray)
|
||||
{
|
||||
parseDataArray.push_back(ParseData("CriticalType", ReadCriticalType));
|
||||
parseDataArray.push_back(ParseData("CriticalPercentage", ReadCriticalPercentage));
|
||||
parseDataArray.push_back(ParseData("MinDamage", ReadMinDamage));
|
||||
parseDataArray.push_back(ParseData("MaxDamage", ReadMaxDamage));
|
||||
parseDataArray.push_back(ParseData("DRC", ReadDRC));
|
||||
parseDataArray.push_back(ParseData("OffenceRevision", ReadOffenceRevision));
|
||||
parseDataArray.push_back(ParseData("Defence", ReadDefence));
|
||||
parseDataArray.push_back(ParseData("DefenceRevision", ReadDefenceRevision));
|
||||
parseDataArray.push_back(ParseData("Resistance", ReadResistance));
|
||||
parseDataArray.push_back(ParseData("BlockingPercentage", ReadBlockingPercentage));
|
||||
parseDataArray.push_back(ParseData("AttackSpeed", ReadAttackSpeed));
|
||||
parseDataArray.push_back(ParseData("MoveSpeed", ReadMoveSpeed));
|
||||
parseDataArray.push_back(ParseData("AttackRange", ReadAttackRange));
|
||||
parseDataArray.push_back(ParseData("LongRangeAttack", ReadRangedAttack));
|
||||
parseDataArray.push_back(ParseData("HpMaxPlus", ReadHpMaxPlus));
|
||||
parseDataArray.push_back(ParseData("MpMaxPlus", ReadMpMaxPlus));
|
||||
parseDataArray.push_back(ParseData("HPRegen", ReadHPRegen));
|
||||
parseDataArray.push_back(ParseData("MPRegen", ReadMPRegen));
|
||||
parseDataArray.push_back(ParseData("FireAttribute", ReadFireAttribute));
|
||||
parseDataArray.push_back(ParseData("LightingAttribute", ReadLightingAttribute));
|
||||
parseDataArray.push_back(ParseData("ColdAttribute", ReadColdAttribute));
|
||||
parseDataArray.push_back(ParseData("DrainAttribute", ReadDrainAttribute));
|
||||
parseDataArray.push_back(ParseData("PoisonAttribute", ReadPoisonAttribute));
|
||||
parseDataArray.push_back(ParseData("FireResistance", ReadFireResistance));
|
||||
parseDataArray.push_back(ParseData("LightningResistance", ReadLightningResistance));
|
||||
parseDataArray.push_back(ParseData("ColdResistance", ReadColdResistance));
|
||||
parseDataArray.push_back(ParseData("DrainResistance", ReadDrainResistance));
|
||||
parseDataArray.push_back(ParseData("PoisonResistance", ReadPoisonResistance));
|
||||
parseDataArray.push_back(ParseData("STRAdd", ReadSTRAdd));
|
||||
parseDataArray.push_back(ParseData("DEXAdd", ReadDEXAdd));
|
||||
parseDataArray.push_back(ParseData("CONAdd", ReadCONAdd));
|
||||
parseDataArray.push_back(ParseData("INTAdd", ReadINTAdd));
|
||||
parseDataArray.push_back(ParseData("WISAdd", ReadWISAdd));
|
||||
|
||||
parseDataArray.push_back(ParseData("MaterialValue", ReadMaterialValue));
|
||||
parseDataArray.push_back(ParseData("MaxSocketNum", ReadMaxSocketNum));
|
||||
|
||||
return true;
|
||||
}
|
||||
|
||||
|
||||
bool ReadSkill_ID(Item::ItemInfo& itemInfo, const char* szValue) { itemInfo.m_UseItemInfo.m_usSkill_ID = Math::Convert::StrToHex16(szValue); return true; }
|
||||
bool ReadSkill_Level(Item::ItemInfo& itemInfo, const char* szValue) { return ReadValue(itemInfo.m_UseItemInfo.m_usSkill_LockCount, szValue); }
|
||||
bool ReadItemDescribe(Item::ItemInfo& itemInfo, const char* szValue) { return ReadString(itemInfo.m_StringData.m_szItemDescribe, Item::StringData::MAX_ITEM_DESCRIBE, szValue); }
|
||||
|
||||
bool ItemDataParser::SetUseItemData(ParseDataArray& parseDataArray)
|
||||
{
|
||||
parseDataArray.push_back(ParseData("CriticalType", ReadSkill_ID));
|
||||
parseDataArray.push_back(ParseData("CriticalPercentage", ReadSkill_Level));
|
||||
parseDataArray.push_back(ParseData("MinDamage", ReadItemDescribe));
|
||||
return true;
|
||||
}
|
||||
|
||||
|
||||
bool ItemDataParser::SetEtcItemData(ParseDataArray& parseDataArray)
|
||||
{
|
||||
parseDataArray.push_back(ParseData("CriticalType", ReadItemDescribe));
|
||||
return true;
|
||||
}
|
||||
|
||||
|
||||
34
GameTools/GLOBALSCRIPT/Item/ItemDataParser.h
Normal file
34
GameTools/GLOBALSCRIPT/Item/ItemDataParser.h
Normal file
@@ -0,0 +1,34 @@
|
||||
#ifndef _ITEM_DATA_PARSER_H_
|
||||
#define _ITEM_DATA_PARSER_H_
|
||||
|
||||
#include <vector>
|
||||
|
||||
// <20><><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD>
|
||||
namespace Item
|
||||
{
|
||||
struct ItemInfo;
|
||||
};
|
||||
|
||||
namespace ItemDataParser
|
||||
{
|
||||
struct ParseData
|
||||
{
|
||||
typedef bool(*ParseFunc) (Item::ItemInfo& itemInfo, const char* szValue);
|
||||
|
||||
const char* m_szColumnName;
|
||||
ParseFunc m_fnParseFunc;
|
||||
|
||||
ParseData(const char* szColumnName, ParseFunc fnParseFunc)
|
||||
: m_szColumnName(szColumnName), m_fnParseFunc(fnParseFunc) { }
|
||||
};
|
||||
|
||||
typedef std::vector<ParseData> ParseDataArray;
|
||||
|
||||
bool SetDefaultData(ParseDataArray& parseDataArray);
|
||||
bool SetEquipData(ParseDataArray& parseDataArray);
|
||||
bool SetUseItemData(ParseDataArray& parseDataArray);
|
||||
bool SetEtcItemData(ParseDataArray& parseDataArray);
|
||||
};
|
||||
|
||||
|
||||
#endif
|
||||
80
GameTools/GLOBALSCRIPT/Item/ItemFactory.cpp
Normal file
80
GameTools/GLOBALSCRIPT/Item/ItemFactory.cpp
Normal file
@@ -0,0 +1,80 @@
|
||||
#include "stdafx.h"
|
||||
#include "Item.h"
|
||||
#include "ItemMgr.h"
|
||||
#include "ItemFactory.h"
|
||||
|
||||
using namespace Item;
|
||||
|
||||
CItemFactory CItemFactory::ms_this;
|
||||
|
||||
CItemFactory::CItemFactory()
|
||||
: m_nCurrentUID(0)
|
||||
{
|
||||
|
||||
|
||||
}
|
||||
|
||||
CItemFactory::~CItemFactory()
|
||||
{
|
||||
|
||||
|
||||
}
|
||||
|
||||
CItem* CItemFactory::CreateItem(const ItemInfo& itemInfo)
|
||||
{
|
||||
unsigned long dwFlags = itemInfo.m_DetailData.m_dwFlags;
|
||||
|
||||
CItem* lpItem = NULL;
|
||||
|
||||
if(DetailData::EQUIP == (dwFlags & DetailData::EQUIP))
|
||||
{
|
||||
lpItem = new CEquipment(m_nCurrentUID++, itemInfo);
|
||||
}
|
||||
else if(DetailData::USE_ITEM == (dwFlags & DetailData::USE_ITEM))
|
||||
{
|
||||
lpItem = new CUseItem(m_nCurrentUID++, itemInfo);
|
||||
}
|
||||
else
|
||||
{
|
||||
lpItem = new CItem(m_nCurrentUID++, itemInfo);
|
||||
}
|
||||
|
||||
return lpItem;
|
||||
}
|
||||
|
||||
|
||||
CItem* CItemFactory::CreateItem(unsigned short usProtoTypeID)
|
||||
{
|
||||
const ItemInfo* lpItemInfo = CItemMgr::GetInstance().GetItemInfo(usProtoTypeID);
|
||||
|
||||
if(NULL != lpItemInfo)
|
||||
{
|
||||
return CreateItem(*lpItemInfo);
|
||||
}
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
||||
|
||||
CItem* CItemFactory::CreateItem(const char* lpSerializedItem_In, size_t& nParseLength_InOut)
|
||||
{
|
||||
const ItemData* lpItemData = reinterpret_cast<const ItemData*>(lpSerializedItem_In);
|
||||
|
||||
if(NULL != lpItemData)
|
||||
{
|
||||
CItem* lpItem = CreateItem(lpItemData->m_usProtoTypeID);
|
||||
|
||||
if(NULL != lpItem)
|
||||
{
|
||||
if(!lpItem->SerializeIn(lpSerializedItem_In, nParseLength_InOut))
|
||||
{
|
||||
delete lpItem;
|
||||
lpItem = NULL;
|
||||
}
|
||||
}
|
||||
|
||||
return lpItem;
|
||||
}
|
||||
|
||||
return 0;
|
||||
}
|
||||
46
GameTools/GLOBALSCRIPT/Item/ItemFactory.h
Normal file
46
GameTools/GLOBALSCRIPT/Item/ItemFactory.h
Normal file
@@ -0,0 +1,46 @@
|
||||
#ifndef _ITEM_FACTORY_H_
|
||||
#define _ITEM_FACTORY_H_
|
||||
|
||||
#include <Pattern/Singleton.h>
|
||||
|
||||
namespace Item
|
||||
{
|
||||
// <20><><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD>
|
||||
class CItem;
|
||||
struct ItemInfo;
|
||||
|
||||
#pragma pack(8)
|
||||
|
||||
class CItemFactory : public CSingleton<CItemFactory>
|
||||
{
|
||||
public:
|
||||
|
||||
inline unsigned __int64 GetItemUID() { return m_nCurrentUID; }
|
||||
inline void SetItemUID(unsigned __int64 nCurrentUID) { m_nCurrentUID = nCurrentUID; }
|
||||
|
||||
// Desc : <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD>(<28>⺻ <20>ɷ<EFBFBD>ġ)
|
||||
CItem* CreateItem(const ItemInfo& itemInfo);
|
||||
|
||||
// Desc : <20><><EFBFBD><EFBFBD> ID<49><44> <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD>(<28>⺻ <20>ɷ<EFBFBD>ġ)
|
||||
CItem* CreateItem(unsigned short usProtoTypeID);
|
||||
|
||||
// Desc : SerializeOut<75><74> <20><><EFBFBD>۷<EFBFBD> <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD>.
|
||||
// In : <20><><EFBFBD><EFBFBD>, <20><><EFBFBD><EFBFBD> ũ<><C5A9>
|
||||
// Out : (Return)<29><><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD>, nParseLength_InOut - <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD> ũ<><C5A9>
|
||||
CItem* CreateItem(const char* lpSerializedItem_In, size_t& nParseLength_InOut);
|
||||
|
||||
~CItemFactory();
|
||||
|
||||
private:
|
||||
|
||||
CItemFactory();
|
||||
|
||||
unsigned __int64 m_nCurrentUID;
|
||||
|
||||
static CItemFactory ms_this;
|
||||
};
|
||||
|
||||
#pragma pack()
|
||||
};
|
||||
|
||||
#endif
|
||||
380
GameTools/GLOBALSCRIPT/Item/ItemMgr.cpp
Normal file
380
GameTools/GLOBALSCRIPT/Item/ItemMgr.cpp
Normal file
@@ -0,0 +1,380 @@
|
||||
#include "stdafx.h"
|
||||
|
||||
#include <Log/ServerLog.h>
|
||||
#include <Utility/Resource/EnsureCleanup.h>
|
||||
#include <Utility/Compress/MiniLZO/MiniLZOWrapper.h>
|
||||
#include <Network/XORCrypt/XORCrypt.h>
|
||||
#include "../Utility/TokenlizedFile.h"
|
||||
|
||||
#define DECODE_HEADER(Start_In, Length_In, PageVer_In, PageNum_In) CXORCrypt::GetInstance().DecodeHeader((Start_In),(Length_In),(PageVer_In),(PageNum_In))
|
||||
#define ENCODE_HEADER(Start_In, Length_In, PageVer_In, PageNum_In) CXORCrypt::GetInstance().EncodeHeader((Start_In),(Length_In),(PageVer_In),(PageNum_In))
|
||||
#define COMPRESS(In, In_len, Out, Out_len) CMiniLZOCompress::Compress((In), (In_len), (Out), (Out_len))
|
||||
#define DECOMPRESS(In, In_len, Out, Out_len) CMiniLZOCompress::Decompress((In), (In_len), (Out), (Out_len))
|
||||
|
||||
#include <memory>
|
||||
#include <algorithm>
|
||||
|
||||
#include "ItemMgr.h"
|
||||
#include "ItemDataParser.h"
|
||||
|
||||
|
||||
|
||||
#ifdef _TEST_SERVER_
|
||||
const char* Item::CItemMgr::ms_szItemScriptFileName = "TestItemScript.txt";
|
||||
#else
|
||||
const char* Item::CItemMgr::ms_szItemScriptFileName = "ItemScript.txt";
|
||||
#endif
|
||||
|
||||
|
||||
Item::CItemMgr Item::CItemMgr::ms_this;
|
||||
|
||||
using namespace Item;
|
||||
|
||||
|
||||
class CParseDelimitedData
|
||||
{
|
||||
public:
|
||||
|
||||
CParseDelimitedData(CTokenlizedFile& TokenlizedFile) : m_TokenlizedFile(TokenlizedFile) { }
|
||||
|
||||
bool operator() (ItemDataParser::ParseDataArray& ParserArray, Item::ItemInfo& itemInfo)
|
||||
{
|
||||
for (ItemDataParser::ParseDataArray::iterator itr = ParserArray.begin();
|
||||
itr != ParserArray.end(); ++itr)
|
||||
{
|
||||
const char* szValue = m_TokenlizedFile.GetStringValue(itr->m_szColumnName);
|
||||
|
||||
if (NULL == szValue)
|
||||
{
|
||||
ERRLOG2(g_Log, "<EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD> <20>о<EFBFBD><D0BE><EFBFBD> <20><> <20><><EFBFBD><EFBFBD><EFBFBD>ϴ<EFBFBD>. Line:%d, ColumnName:%d",
|
||||
m_TokenlizedFile.GetCurrentLine(), itr->m_szColumnName);
|
||||
return false;
|
||||
}
|
||||
|
||||
if (!itr->m_fnParseFunc(itemInfo, szValue))
|
||||
{
|
||||
ERRLOG2(g_Log, "<EFBFBD>˸<EFBFBD><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD><EFBFBD>Ͱ<EFBFBD> <20>ƴմϴ<D5B4>. Line:%d, ColumnName:%d",
|
||||
m_TokenlizedFile.GetCurrentLine(), itr->m_szColumnName);
|
||||
return false;
|
||||
}
|
||||
}
|
||||
|
||||
return true;
|
||||
}
|
||||
|
||||
private:
|
||||
|
||||
CTokenlizedFile& m_TokenlizedFile;
|
||||
};
|
||||
|
||||
|
||||
CItemMgr::CItemMgr()
|
||||
: m_ItemInfoArray(NULL), m_nItemNum(0)
|
||||
{
|
||||
|
||||
}
|
||||
|
||||
CItemMgr::~CItemMgr()
|
||||
{
|
||||
DestoryItemInfo();
|
||||
}
|
||||
|
||||
void CItemMgr::DestoryItemInfo()
|
||||
{
|
||||
if (NULL != m_ItemInfoArray)
|
||||
{
|
||||
delete [] m_ItemInfoArray;
|
||||
m_ItemInfoArray = NULL;
|
||||
}
|
||||
|
||||
m_nItemNum = 0;
|
||||
}
|
||||
|
||||
bool CItemMgr::LoadItemProtoType(const char* szFileName)
|
||||
{
|
||||
DestoryItemInfo();
|
||||
|
||||
Item::ItemInfo itemInfo;
|
||||
CTokenlizedFile TokenlizedFile; // <20><>ü <20>Ҹ<EFBFBD><D2B8><EFBFBD>, <20>ڵ<EFBFBD> Close.
|
||||
|
||||
if (!TokenlizedFile.Open((NULL != szFileName) ? szFileName : ms_szItemScriptFileName))
|
||||
{
|
||||
ERRLOG0(g_Log, "<EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD> <20><>ũ<EFBFBD><C5A9>Ʈ <20><><EFBFBD><EFBFBD> <20>ε<EFBFBD><CEB5><EFBFBD> <20><><EFBFBD><EFBFBD><EFBFBD>߽<EFBFBD><DFBD>ϴ<EFBFBD>.");
|
||||
return false;
|
||||
}
|
||||
|
||||
if (!TokenlizedFile.ReadColumn())
|
||||
{
|
||||
ERRLOG0(g_Log, "<EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD> <20><>ũ<EFBFBD><C5A9>Ʈ <20>÷<EFBFBD><C3B7><EFBFBD> <20>о<EFBFBD><D0BE><EFBFBD><EFBFBD><EFBFBD> <20><> <20><><EFBFBD><EFBFBD><EFBFBD>߽<EFBFBD><DFBD>ϴ<EFBFBD>.");
|
||||
return false;
|
||||
}
|
||||
|
||||
ItemDataParser::ParseDataArray DefaultItemData;
|
||||
ItemDataParser::ParseDataArray EquipItemData;
|
||||
ItemDataParser::ParseDataArray UseItemData;
|
||||
ItemDataParser::ParseDataArray EtcItemData;
|
||||
|
||||
ItemDataParser::SetDefaultData(DefaultItemData);
|
||||
ItemDataParser::SetEquipData(EquipItemData);
|
||||
ItemDataParser::SetUseItemData(UseItemData);
|
||||
ItemDataParser::SetEtcItemData(EtcItemData);
|
||||
|
||||
Item::CItemType& ItemType = Item::CItemType::GetInstance();
|
||||
|
||||
std::vector<Item::ItemInfo> ItemInfoVector;
|
||||
|
||||
CParseDelimitedData ParseData(TokenlizedFile);
|
||||
|
||||
while(TokenlizedFile.ReadLine())
|
||||
{
|
||||
itemInfo.Initialize();
|
||||
|
||||
if (!ParseData(DefaultItemData, itemInfo)) { return false; }
|
||||
|
||||
if (ItemType.IsCorrectItemType(Item::CItemType::EQUIP_TYPE,
|
||||
itemInfo.m_DetailData.m_cItemType))
|
||||
{
|
||||
// <20><><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD>.
|
||||
if (!ParseData(EquipItemData, itemInfo)) { return false; }
|
||||
ItemType.SetEquipTypeFlags(itemInfo);
|
||||
}
|
||||
else if (ItemType.IsCorrectItemType(Item::CItemType::USE_ITEM_TYPE,
|
||||
itemInfo.m_DetailData.m_cItemType))
|
||||
{
|
||||
// <20><><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD>.
|
||||
if (!ParseData(UseItemData, itemInfo)) { return false; }
|
||||
ItemType.SetUseItemTypeFlags(itemInfo);
|
||||
}
|
||||
else
|
||||
{
|
||||
// <20><>Ÿ <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD>.
|
||||
if (!ParseData(EtcItemData, itemInfo)) { return false; }
|
||||
ItemType.SetEtcItemTypeFlags(itemInfo);
|
||||
}
|
||||
|
||||
ItemInfoVector.push_back(itemInfo);
|
||||
}
|
||||
|
||||
if (!TokenlizedFile.IsEOF())
|
||||
{
|
||||
ERRLOG0(g_Log, "<EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD> <20><>ũ<EFBFBD><C5A9>Ʈ <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD> <20><> <20><><EFBFBD><EFBFBD> <20><><EFBFBD>ϰ<EFBFBD> <20><><EFBFBD><EFBFBD><EFBFBD>մϴ<D5B4>.");
|
||||
return false;
|
||||
}
|
||||
|
||||
std::sort(ItemInfoVector.begin(), ItemInfoVector.end());
|
||||
|
||||
for (std::vector<Item::ItemInfo>::iterator itr = ItemInfoVector.begin();
|
||||
itr != ItemInfoVector.end() - 1; ++itr)
|
||||
{
|
||||
if (itr->m_usProtoTypeID == (itr+1)->m_usProtoTypeID)
|
||||
{
|
||||
ERRLOG1(g_Log, "<EFBFBD><EFBFBD>ġ<EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD> ID<49><44> <20>ֽ<EFBFBD><D6BD>ϴ<EFBFBD>. <20><><EFBFBD><EFBFBD>ID:%d", itr->m_usProtoTypeID);
|
||||
return false;
|
||||
}
|
||||
};
|
||||
|
||||
m_nItemNum = ItemInfoVector.size();
|
||||
m_ItemInfoArray = new Item::ItemInfo[m_nItemNum];
|
||||
if (NULL == m_ItemInfoArray)
|
||||
{
|
||||
ERRLOG0(g_Log, "<EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD> <20><>ũ<EFBFBD><C5A9>Ʈ <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD> <20><> <20><><EFBFBD><EFBFBD><EFBFBD>ϴ<EFBFBD>. <20><DEB8> <20><><EFBFBD><EFBFBD><EFBFBD>մϴ<D5B4>.");
|
||||
return false;
|
||||
}
|
||||
|
||||
std::copy(ItemInfoVector.begin(), ItemInfoVector.end(), m_ItemInfoArray);
|
||||
return true;
|
||||
}
|
||||
|
||||
const Item::ItemInfo* CItemMgr::GetItemInfo(unsigned short usProtoTypeID)
|
||||
{
|
||||
Item::ItemInfo* lpFirst = m_ItemInfoArray;
|
||||
Item::ItemInfo* lpLast = m_ItemInfoArray + m_nItemNum;
|
||||
Item::ItemInfo* lpMid = NULL;
|
||||
|
||||
size_t nCount = m_nItemNum;
|
||||
size_t nCount2 = 0;
|
||||
|
||||
for (; 0 < nCount; )
|
||||
{
|
||||
nCount2 = nCount / 2;
|
||||
lpMid = lpFirst + nCount2;
|
||||
|
||||
if (lpMid->m_usProtoTypeID < usProtoTypeID)
|
||||
{
|
||||
lpFirst = ++lpMid, nCount -= nCount2 + 1;
|
||||
}
|
||||
else
|
||||
{
|
||||
nCount = nCount2;
|
||||
}
|
||||
}
|
||||
|
||||
return (lpFirst != lpLast && !(usProtoTypeID < lpFirst->m_usProtoTypeID)) ? lpFirst : NULL;
|
||||
}
|
||||
|
||||
const Item::ItemInfo* CItemMgr::GetItemInfoFromItemName(const char* szItemName)
|
||||
{
|
||||
Item::ItemInfo* lpFirst = m_ItemInfoArray;
|
||||
Item::ItemInfo* lpLast = m_ItemInfoArray + m_nItemNum;
|
||||
|
||||
for (; lpFirst != lpLast; ++lpFirst)
|
||||
{
|
||||
if (0 == strcmp(lpFirst->m_SpriteData.m_szName, szItemName))
|
||||
{
|
||||
return lpFirst;
|
||||
}
|
||||
}
|
||||
|
||||
return NULL;
|
||||
}
|
||||
|
||||
const Item::ItemInfo* CItemMgr::GetItemInfoFromEquipName(const char* szEquipName)
|
||||
{
|
||||
Item::ItemInfo* lpFirst = m_ItemInfoArray;
|
||||
Item::ItemInfo* lpLast = m_ItemInfoArray + m_nItemNum;
|
||||
|
||||
for (; lpFirst != lpLast; ++lpFirst)
|
||||
{
|
||||
if (0 == strcmp(lpFirst->m_StringData.m_szEquipModelName, szEquipName))
|
||||
{
|
||||
return lpFirst;
|
||||
}
|
||||
}
|
||||
|
||||
return NULL;
|
||||
}
|
||||
|
||||
|
||||
const char* Item::CItemMgr::GetEquipName(const unsigned short usItemProtoTypeID)
|
||||
{
|
||||
const Item::ItemInfo* pItemInfo = GetItemInfo(usItemProtoTypeID);
|
||||
|
||||
if(pItemInfo)
|
||||
{
|
||||
return pItemInfo->m_StringData.m_szEquipModelName;
|
||||
}
|
||||
|
||||
return NULL;
|
||||
}
|
||||
|
||||
|
||||
const unsigned short CItemMgr::GetItemIDFromSkillID(const unsigned short usSkill_ID, const unsigned short unSkill_LockCount)
|
||||
{
|
||||
Item::ItemInfo* lpFirst = m_ItemInfoArray;
|
||||
Item::ItemInfo* lpLast = m_ItemInfoArray + m_nItemNum;
|
||||
|
||||
for (; lpFirst != lpLast; ++lpFirst)
|
||||
{
|
||||
if (lpFirst->m_UseItemInfo.m_usSkill_ID == usSkill_ID &&
|
||||
lpFirst->m_UseItemInfo.m_usSkill_LockCount == unSkill_LockCount)
|
||||
{
|
||||
return lpFirst->m_usProtoTypeID;
|
||||
}
|
||||
}
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
||||
|
||||
bool CItemMgr::LoadItemProtoTypeBinary(const char* szFileNameBinary)
|
||||
{
|
||||
using namespace Item;
|
||||
|
||||
HANDLE hFile = CreateFile((0 == szFileNameBinary) ? ms_szItemScriptFileName : szFileNameBinary,
|
||||
GENERIC_READ, FILE_SHARE_READ, NULL, OPEN_EXISTING, FILE_ATTRIBUTE_NORMAL, NULL);
|
||||
|
||||
if (hFile == INVALID_HANDLE_VALUE) { return false; }
|
||||
|
||||
CEnsureCloseHandle EnsureCloseHandle(hFile);
|
||||
|
||||
DWORD dwRead = 0;
|
||||
DWORD dwFileHighSize = 0;
|
||||
DWORD dwFileSize = GetFileSize(hFile, &dwFileHighSize);
|
||||
|
||||
char* lpAllocated = new char[dwFileSize];
|
||||
CEnsureDeleteArray<char> EnsureFileInfo(lpAllocated);
|
||||
|
||||
if (!ReadFile(hFile, lpAllocated, dwFileSize, &dwRead, NULL))
|
||||
{
|
||||
return false;
|
||||
}
|
||||
|
||||
DWORD dwHeaderSize = sizeof(DWORD) + *reinterpret_cast<DWORD*>(lpAllocated) + sizeof(DWORD);
|
||||
DWORD dwDecompressedSize = *reinterpret_cast<DWORD*>(lpAllocated + dwHeaderSize - sizeof(DWORD));
|
||||
|
||||
DestoryItemInfo();
|
||||
|
||||
m_nItemNum = dwDecompressedSize/sizeof(Item::ItemInfo);
|
||||
m_ItemInfoArray = new Item::ItemInfo[m_nItemNum];
|
||||
if (NULL == m_ItemInfoArray)
|
||||
{
|
||||
ERRLOG0(g_Log, "<EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD> <20><>ũ<EFBFBD><C5A9>Ʈ <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD> <20>ҷ<EFBFBD><D2B7><EFBFBD> <20><> <20><><EFBFBD><EFBFBD><EFBFBD>ϴ<EFBFBD>. <20><DEB8> <20><><EFBFBD><EFBFBD><EFBFBD>մϴ<D5B4>.");
|
||||
return false;
|
||||
}
|
||||
|
||||
DECOMPRESS(lpAllocated + dwHeaderSize, dwFileSize - dwHeaderSize,
|
||||
reinterpret_cast<char*>(m_ItemInfoArray), &dwDecompressedSize);
|
||||
|
||||
DECODE_HEADER(reinterpret_cast<char*>(m_ItemInfoArray), dwDecompressedSize, 0, 2);
|
||||
return true;
|
||||
}
|
||||
|
||||
|
||||
bool CItemMgr::SaveItemProtoTypeBinary(const char* szFileNameBinary, const char* szTrashFile)
|
||||
{
|
||||
HANDLE hFile = CreateFile((0 == szFileNameBinary) ? ms_szItemScriptFileName : szFileNameBinary,
|
||||
GENERIC_WRITE, 0, NULL, CREATE_ALWAYS, FILE_ATTRIBUTE_NORMAL, NULL);
|
||||
|
||||
if (hFile == INVALID_HANDLE_VALUE) { return false; }
|
||||
|
||||
CEnsureCloseHandle EnsureCloseSaveHandle(hFile);
|
||||
|
||||
DWORD nItemInfoSize = static_cast<DWORD>(sizeof(Item::ItemInfo) * m_nItemNum);
|
||||
DWORD nCompressedInfoSize = nItemInfoSize;
|
||||
|
||||
char* lpItemInfo = new char[nItemInfoSize];
|
||||
char* lpCompressedInfo = new char[nItemInfoSize];
|
||||
|
||||
CEnsureDeleteArray<char> EnsureDeleteItemInfo(lpItemInfo);
|
||||
CEnsureDeleteArray<char> EnsureDeleteCompressedInfo(lpCompressedInfo);
|
||||
|
||||
if (0 == lpItemInfo || 0 == lpCompressedInfo)
|
||||
{
|
||||
return false;
|
||||
}
|
||||
|
||||
memcpy(lpItemInfo, m_ItemInfoArray, nItemInfoSize);
|
||||
ENCODE_HEADER(lpItemInfo, nItemInfoSize, 0, 2);
|
||||
COMPRESS(lpItemInfo, nItemInfoSize, lpCompressedInfo, &nCompressedInfoSize);
|
||||
|
||||
// <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD>(<28><><EFBFBD><EFBFBD>) <20>ڷ<EFBFBD>
|
||||
HANDLE hTrashFile = CreateFile(szTrashFile, GENERIC_READ, FILE_SHARE_READ,
|
||||
NULL, OPEN_EXISTING, FILE_ATTRIBUTE_NORMAL, NULL);
|
||||
|
||||
if (hTrashFile == INVALID_HANDLE_VALUE) { return false; }
|
||||
|
||||
CEnsureCloseHandle EnsureCloseTrashHandle(hTrashFile);
|
||||
|
||||
DWORD dwRead = 0;
|
||||
DWORD dwWritten = 0;
|
||||
DWORD dwFileHighSize = 0;
|
||||
DWORD dwTrashFileSize = GetFileSize(hTrashFile, &dwFileHighSize);
|
||||
|
||||
char* lpTrashFileData = new char[dwTrashFileSize];
|
||||
CEnsureDeleteArray<char> EnsureDeleteTrashFile(lpTrashFileData);
|
||||
|
||||
if (!ReadFile(hTrashFile, lpTrashFileData, dwTrashFileSize, &dwRead, NULL))
|
||||
{
|
||||
return false;
|
||||
}
|
||||
|
||||
// Trash File<6C><65><EFBFBD><EFBFBD><EFBFBD><EFBFBD>
|
||||
WriteFile(hFile, &dwTrashFileSize, sizeof(DWORD), &dwWritten, 0); // Trash <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD> ũ<><C5A9>
|
||||
WriteFile(hFile, lpTrashFileData, dwTrashFileSize, &dwWritten, 0); // Trash <20><><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD>
|
||||
|
||||
// <20>ùٸ<C3B9> <20>ڷ<EFBFBD>
|
||||
WriteFile(hFile, &nItemInfoSize, sizeof(DWORD), &dwWritten, 0); // <20><><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD> ũ<><C5A9>
|
||||
WriteFile(hFile, lpCompressedInfo, nCompressedInfoSize, &dwWritten, 0); // <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD>
|
||||
return true;
|
||||
}
|
||||
|
||||
51
GameTools/GLOBALSCRIPT/Item/ItemMgr.h
Normal file
51
GameTools/GLOBALSCRIPT/Item/ItemMgr.h
Normal file
@@ -0,0 +1,51 @@
|
||||
#ifndef _CITEM_MGR_H_
|
||||
#define _CITEM_MGR_H_
|
||||
|
||||
#define g_ItemMgr Item::CItemMgr::GetInstance()
|
||||
#include <Pattern/Singleton.h>
|
||||
|
||||
#include <vector>
|
||||
#include "ItemStructure.h"
|
||||
|
||||
// ----------------------------------------------------------------------------
|
||||
// class : CItemMgr ( must use in single thread )
|
||||
// <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD> <20><>ũ<EFBFBD><C5A9>Ʈ<EFBFBD><C6AE> <20>ε<EFBFBD><CEB5>ϰ<EFBFBD>, <20><><EFBFBD><EFBFBD><EFBFBD>ϰ<EFBFBD>, <20><> <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD><EFBFBD>ϴ<EFBFBD> <20><><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD> <20>Ѵ<EFBFBD>.
|
||||
|
||||
namespace Item
|
||||
{
|
||||
// <20><><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD>
|
||||
class CItem;
|
||||
|
||||
class CItemMgr : public CSingleton<CItemMgr>
|
||||
{
|
||||
public:
|
||||
|
||||
// <20><><EFBFBD>Ϸκ<CFB7><CEBA><EFBFBD> <20>а<EFBFBD> <20><><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD>
|
||||
bool LoadItemProtoType(const char* szFileName = 0);
|
||||
bool LoadItemProtoTypeBinary(const char* szFileNameBinary = 0);
|
||||
bool SaveItemProtoTypeBinary(const char* szFileNameBinary = 0, const char* szTrashFile = 0);
|
||||
|
||||
const Item::ItemInfo* GetItemInfo(unsigned short usProtoTypeID);
|
||||
const Item::ItemInfo* GetItemInfoFromItemName(const char* szItemName);
|
||||
const Item::ItemInfo* GetItemInfoFromEquipName(const char* szEquipName);
|
||||
|
||||
const char* GetEquipName(const unsigned short usItemProtoTypeID);
|
||||
const unsigned short GetItemIDFromSkillID(const unsigned short usSkill_ID, const unsigned short unSkill_LockCount);
|
||||
|
||||
~CItemMgr();
|
||||
|
||||
private:
|
||||
|
||||
CItemMgr();
|
||||
|
||||
void DestoryItemInfo();
|
||||
|
||||
static const char* ms_szItemScriptFileName;
|
||||
static CItemMgr ms_this;
|
||||
|
||||
size_t m_nItemNum;
|
||||
Item::ItemInfo* m_ItemInfoArray;
|
||||
};
|
||||
}
|
||||
|
||||
#endif
|
||||
69
GameTools/GLOBALSCRIPT/Item/ItemStructure.cpp
Normal file
69
GameTools/GLOBALSCRIPT/Item/ItemStructure.cpp
Normal file
@@ -0,0 +1,69 @@
|
||||
#include "stdafx.h"
|
||||
#include "ItemStructure.h"
|
||||
#include <Log/ServerLog.h>
|
||||
|
||||
#include <algorithm>
|
||||
|
||||
Item::SpriteData::SpriteData() { Initialize(); }
|
||||
|
||||
void Item::SpriteData::Initialize()
|
||||
{
|
||||
memset(m_szName, 0, MAX_NAME);
|
||||
memset(m_szSpriteName, 0, MAX_SPRITE_NAME);
|
||||
|
||||
m_nSpriteMinX = m_nSpriteMinY = m_nSpriteMaxX = m_nSpriteMaxY = 0;
|
||||
}
|
||||
|
||||
Item::StringData::StringData() { Initialize(); }
|
||||
void Item::StringData::Initialize()
|
||||
{
|
||||
memset(m_szFieldModelName, 0, MAX_FIELD_MODEL_NAME);
|
||||
memset(m_szEquipModelName, 0, MAX_EQUIP_MODEL_NAME);
|
||||
memset(m_szEffectSoundName, 0, MAX_EFFECT_SOUND_NAME);
|
||||
memset(m_szItemDescribe, 0, MAX_ITEM_DESCRIBE);
|
||||
}
|
||||
|
||||
Item::DetailData::DetailData() { Initialize(); }
|
||||
void Item::DetailData::Initialize()
|
||||
{
|
||||
m_ItemGrade = Item::Grade::ETC;
|
||||
m_dwFlags = m_dwPrice = m_dwBlackPrice = m_cOptionLimit = m_cItemType = m_cXSize = m_cYSize = m_cDefaultDurabilityOrStack =
|
||||
m_cMaxDurabilityOrStack = m_cMaterialType = m_cMaxSocketNum = 0;
|
||||
}
|
||||
|
||||
Item::EquipAttribute::EquipAttribute() { Initialize(); }
|
||||
void Item::EquipAttribute::Initialize()
|
||||
{
|
||||
m_nAttibuteNum = 0;
|
||||
std::fill_n(m_usAttributeValue, unsigned short(Item::Attribute::MAX_ATTRIBUTE_NUM), 0);
|
||||
}
|
||||
|
||||
Item::UseItemInfo::UseItemInfo() { Initialize(); }
|
||||
void Item::UseItemInfo::Initialize() { m_usSkill_ID = m_usSkill_LockCount = 0; }
|
||||
|
||||
|
||||
Item::UseLimit::UseLimit() { Initialize(); }
|
||||
void Item::UseLimit::Initialize()
|
||||
{
|
||||
std::fill_n(m_nStatusLimit, unsigned short(StatusLimit::MAX_STATUS_LIMIT), 0);
|
||||
m_dwClassLimit = m_nSkillType = m_cSkillLevel = m_cLevelLimit = 0;
|
||||
}
|
||||
|
||||
|
||||
Item::ItemInfo::ItemInfo() { Initialize(); }
|
||||
Item::ItemInfo::ItemInfo(unsigned short usProtoTypeID) { Initialize(); m_usProtoTypeID = usProtoTypeID; }
|
||||
|
||||
void Item::ItemInfo::Initialize()
|
||||
{
|
||||
m_usProtoTypeID = 0;
|
||||
|
||||
m_DetailData.Initialize();
|
||||
m_UseLimit.Initialize();
|
||||
m_SpriteData.Initialize();
|
||||
m_StringData.Initialize();
|
||||
|
||||
m_EquipAttribute.Initialize();
|
||||
m_UseItemInfo.Initialize();
|
||||
}
|
||||
|
||||
|
||||
238
GameTools/GLOBALSCRIPT/Item/ItemStructure.h
Normal file
238
GameTools/GLOBALSCRIPT/Item/ItemStructure.h
Normal file
@@ -0,0 +1,238 @@
|
||||
#ifndef _ITEM_STRUCTURE_H_
|
||||
#define _ITEM_STRUCTURE_H_
|
||||
|
||||
#include "ItemConstants.h"
|
||||
|
||||
namespace Item
|
||||
{
|
||||
#pragma pack(1)
|
||||
|
||||
// ------------------------------------------------------------------------------------------
|
||||
// UseLimit, ItemInfo <20><> <20><>ũ<EFBFBD><C5A9>Ʈ<EFBFBD><C6AE><EFBFBD><EFBFBD> <20>ִ´<D6B4>.
|
||||
struct ItemPos
|
||||
{
|
||||
unsigned short m_cPos : 4; // <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD> (Equip, Inven...) (0~15)
|
||||
unsigned short m_cIndex : 12; // <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD> <20>ε<EFBFBD><CEB5><EFBFBD> (0~4095)
|
||||
|
||||
ItemPos() : m_cPos(0), m_cIndex(0) { }
|
||||
ItemPos(unsigned char cPos, unsigned short usIndex) : m_cPos(cPos), m_cIndex(usIndex) { }
|
||||
|
||||
inline void SetPos(unsigned short wIndex) { m_cIndex = wIndex; }
|
||||
inline void SetPos(unsigned char cXIndex, unsigned char cYIndex, unsigned char cZIndex);
|
||||
inline void GetPos(unsigned char& cXIndex, unsigned char& cYIndex, unsigned char& cZIndex) const;
|
||||
|
||||
inline unsigned char GetXIndex(void) const { return (m_cIndex & 0x00F); }
|
||||
inline unsigned char GetYIndex(void) const { return (m_cIndex & 0x0F0) >> 4; }
|
||||
inline unsigned char GetZIndex(void) const { return (m_cIndex & 0xF00) >> 8; }
|
||||
|
||||
inline void SetXIndex(unsigned char cXIndex) { m_cIndex = (m_cIndex & 0xFF0) + cXIndex; }
|
||||
inline void SetYIndex(unsigned char cYIndex) { m_cIndex = (m_cIndex & 0xF0F) + (cYIndex << 4); }
|
||||
inline void SetZIndex(unsigned char cZIndex) { m_cIndex = (m_cIndex & 0x0FF) + (cZIndex << 8); }
|
||||
|
||||
inline bool operator == (const ItemPos& rhs) const { return (m_cPos == rhs.m_cPos && m_cIndex == rhs.m_cIndex); }
|
||||
};
|
||||
|
||||
inline void ItemPos::SetPos(unsigned char cXIndex, unsigned char cYIndex, unsigned char cZIndex)
|
||||
{
|
||||
m_cIndex = (cZIndex << 8) + (cYIndex << 4) + cXIndex;
|
||||
}
|
||||
|
||||
inline void ItemPos::GetPos(unsigned char& cXIndex, unsigned char& cYIndex, unsigned char& cZIndex) const
|
||||
{
|
||||
cXIndex = (m_cIndex & 0x00F);
|
||||
cYIndex = (m_cIndex & 0x0F0) >> 4;
|
||||
cZIndex = (m_cIndex & 0xF00) >> 8;
|
||||
}
|
||||
|
||||
|
||||
struct ItemData
|
||||
{
|
||||
unsigned __int64 m_dwUID; // <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD> UID
|
||||
unsigned short m_usProtoTypeID; // <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD> ID
|
||||
ItemPos m_ItemPos; // <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD> <20><>ġ
|
||||
unsigned char m_cItemSize; // <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD>ü ũ<><C5A9>.
|
||||
unsigned char m_cNumOrDurability; // <20><><EFBFBD><EFBFBD> Ȥ<><C8A4> <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD>
|
||||
|
||||
ItemData() { m_dwUID = m_usProtoTypeID = m_cNumOrDurability = 0; m_cItemSize = sizeof(ItemData); }
|
||||
};
|
||||
|
||||
struct ItemAttribute
|
||||
{
|
||||
unsigned short m_cType : 6; // <20>Ӽ<EFBFBD> <20><><EFBFBD><EFBFBD> 6bit (64<36><34><EFBFBD><EFBFBD>)
|
||||
short m_usValue : 10; // <20>Ӽ<EFBFBD> <20><> 10bit (-512~511<31><31><EFBFBD><EFBFBD>)
|
||||
|
||||
ItemAttribute() : m_cType(0), m_usValue(0) { }
|
||||
ItemAttribute(unsigned char cType, unsigned short usValue) : m_cType(cType), m_usValue(usValue) { }
|
||||
};
|
||||
|
||||
// <20>ڿ<EFBFBD> Socket<65><74><EFBFBD>빰<EFBFBD><EBB9B0> m_cSocketNum<75><6D>ŭ, Attribute<74><65> m_cDiffAttributeNum<75><6D>ŭ <20>ٴ´<D9B4>.
|
||||
struct EquipmentInfo
|
||||
{
|
||||
enum
|
||||
{
|
||||
MAX_MINSIZE_SOCKET_NUM = 6, // ũ<>Ⱑ 1by1<79><31> <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD> <20>ִ<EFBFBD> <20><><EFBFBD><EFBFBD> <20><>
|
||||
MAX_MINSIZE_ATTRIBUTE_NUM = 6, // ũ<>Ⱑ 1by1<79><31> <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD> <20>ִ<EFBFBD> <20>Ӽ<EFBFBD> <20><>
|
||||
|
||||
MAX_SOCKET_NUM = 8, // <20>Ϲ<EFBFBD> <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD> <20>ִ<EFBFBD> <20><><EFBFBD><EFBFBD> <20><>
|
||||
MAX_ATTRIBUTE_NUM = 12, // <20>Ϲ<EFBFBD> <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD> <20>ִ<EFBFBD> <20>Ӽ<EFBFBD> <20><>
|
||||
|
||||
MAX_SOCKET_AND_ATTRIBUTE_MINISIZE = (MAX_MINSIZE_SOCKET_NUM * sizeof(char) + MAX_MINSIZE_ATTRIBUTE_NUM * sizeof(ItemAttribute)),
|
||||
MAX_SOCKET_AND_ATTRIBUTE_SIZE = (MAX_SOCKET_NUM * sizeof(char) + MAX_ATTRIBUTE_NUM * sizeof(ItemAttribute))
|
||||
};
|
||||
|
||||
unsigned short m_cRuneSocket : 11; // <20><> <20><><EFBFBD>Ͽ<EFBFBD> <20><><EFBFBD><EFBFBD><EFBFBD>ִ<EFBFBD> <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD> ID
|
||||
short m_cDiffMaterialType : 5; // <20><><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD> + m_cDiffMaterialType = <20><> <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD> <20><>(-16~15)
|
||||
|
||||
char m_cDiffMaxSocket : 5; // <20><><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD> <20><> + m_cDiffMaxSocket = <20><> <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD> <20>ִ<EFBFBD> <20><><EFBFBD><EFBFBD> <20><> (-16~15)
|
||||
unsigned char m_cReserved : 3; // <20><><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD>...
|
||||
|
||||
unsigned char m_cSocketNum : 4; // <20><> <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD> <20><> (0~15)
|
||||
unsigned char m_cAttributeNum : 4; // <20><><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD><EFBFBD>ۿ<EFBFBD> <20><><EFBFBD>ų<EFBFBD>, <20><>ġ<EFBFBD><C4A1> <20>ٸ<EFBFBD> <20>Ӽ<EFBFBD> <20><>(0~15<31><35>)
|
||||
|
||||
char m_cDiffMaxDurability; // <20><><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD><EFBFBD>۰<EFBFBD><DBB0><EFBFBD> <20>ִ<EFBFBD> <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD>.
|
||||
unsigned char m_cReserved2; // <20><><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD>...
|
||||
|
||||
EquipmentInfo()
|
||||
{
|
||||
m_cRuneSocket = m_cDiffMaterialType = m_cDiffMaxSocket = m_cDiffMaxDurability =
|
||||
m_cSocketNum = m_cAttributeNum = m_cReserved = m_cReserved2 = 0;
|
||||
}
|
||||
};
|
||||
|
||||
#pragma pack()
|
||||
|
||||
const unsigned char MAX_ITEM_SIZE = sizeof(ItemData) +
|
||||
sizeof(EquipmentInfo) + EquipmentInfo::MAX_SOCKET_AND_ATTRIBUTE_SIZE;
|
||||
|
||||
|
||||
struct SpriteData
|
||||
{
|
||||
enum { MAX_NAME = 64, MAX_SPRITE_NAME = 32 };
|
||||
|
||||
char m_szName[MAX_NAME];
|
||||
char m_szSpriteName[MAX_SPRITE_NAME];
|
||||
|
||||
unsigned short m_nSpriteMinX;
|
||||
unsigned short m_nSpriteMinY;
|
||||
unsigned short m_nSpriteMaxX;
|
||||
unsigned short m_nSpriteMaxY;
|
||||
|
||||
SpriteData();
|
||||
void Initialize();
|
||||
};
|
||||
|
||||
|
||||
struct StringData
|
||||
{
|
||||
enum
|
||||
{
|
||||
MAX_FIELD_MODEL_NAME = 32, MAX_EQUIP_MODEL_NAME = 32,
|
||||
MAX_EFFECT_SOUND_NAME = 32, MAX_ITEM_DESCRIBE = 256
|
||||
};
|
||||
|
||||
char m_szFieldModelName[MAX_FIELD_MODEL_NAME];
|
||||
char m_szEquipModelName[MAX_EQUIP_MODEL_NAME];
|
||||
char m_szEffectSoundName[MAX_EFFECT_SOUND_NAME];
|
||||
char m_szItemDescribe[MAX_ITEM_DESCRIBE];
|
||||
|
||||
StringData();
|
||||
void Initialize();
|
||||
};
|
||||
|
||||
|
||||
struct DetailData
|
||||
{
|
||||
enum Flags
|
||||
{
|
||||
EQUIP = ( 1 << 0), // <20><><EFBFBD><EFBFBD><EFBFBD>Ҽ<EFBFBD> <20>ִ<EFBFBD><D6B4><EFBFBD> <20><><EFBFBD><EFBFBD>
|
||||
USE_ITEM = ( 1 << 1), // <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD> <20><> <20>ִ<EFBFBD><D6B4><EFBFBD> <20><><EFBFBD><EFBFBD>
|
||||
QUICKSLOT_IN = ( 1 << 2), // <20><><EFBFBD><EFBFBD><EFBFBD>Կ<EFBFBD> <20><><EFBFBD> <20><> <20>ִ<EFBFBD><D6B4><EFBFBD> <20><><EFBFBD><EFBFBD>
|
||||
STACKABLE = ( 1 << 3), // <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD> <20><> <20>ִ<EFBFBD><D6B4><EFBFBD> <20><><EFBFBD><EFBFBD>
|
||||
TWOHANDED = ( 1 << 4), // <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD> <20>ϴ<EFBFBD> <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD>
|
||||
WEAPON = ( 1 << 5), // <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD>
|
||||
ARMOUR = ( 1 << 6), // <20><><EFBFBD>ʷ<EFBFBD><CAB7><EFBFBD><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD>
|
||||
SKILL_ARM = ( 1 << 7), // <20><>ų<EFBFBD><C5B3><EFBFBD><EFBFBD><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD>
|
||||
};
|
||||
|
||||
unsigned char m_cItemType; // <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD>( namespace Type <20><><EFBFBD><EFBFBD> )
|
||||
unsigned char m_cXSize; // <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD> Xũ<58><C5A9>
|
||||
unsigned char m_cYSize; // <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD> Yũ<59><C5A9>
|
||||
unsigned char m_cOptionLimit;
|
||||
|
||||
unsigned char m_cDefaultDurabilityOrStack;
|
||||
unsigned char m_cMaxDurabilityOrStack;
|
||||
unsigned char m_cMaterialType;
|
||||
unsigned char m_cMaxSocketNum;
|
||||
|
||||
Grade::Type m_ItemGrade;
|
||||
unsigned long m_dwPrice;
|
||||
unsigned long m_dwBlackPrice;
|
||||
unsigned long m_dwFlags;
|
||||
|
||||
DetailData();
|
||||
void Initialize();
|
||||
};
|
||||
|
||||
struct EquipAttribute
|
||||
{
|
||||
unsigned short m_usAttributeValue[Item::Attribute::MAX_ATTRIBUTE_NUM];
|
||||
unsigned short m_nAttibuteNum;
|
||||
|
||||
EquipAttribute();
|
||||
void Initialize();
|
||||
};
|
||||
|
||||
struct UseItemInfo
|
||||
{
|
||||
unsigned short m_usSkill_ID;
|
||||
unsigned short m_usSkill_LockCount;
|
||||
|
||||
UseItemInfo();
|
||||
void Initialize();
|
||||
};
|
||||
|
||||
struct UseLimit
|
||||
{
|
||||
enum DeactivatedType
|
||||
{
|
||||
STATUS_LIMIT = ( 1 << 0),
|
||||
CLASS_LIMIT = ( 1 << 1),
|
||||
BROKEN_ITEM = ( 1 << 2)
|
||||
};
|
||||
|
||||
unsigned short m_nStatusLimit[StatusLimit::MAX_STATUS_LIMIT];
|
||||
unsigned short m_nSkillType; // <20><>ų <20><><EFBFBD><EFBFBD> Ÿ<><C5B8>
|
||||
unsigned char m_cSkillLevel; // <20><>ų <20><><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD>
|
||||
unsigned char m_cLevelLimit;
|
||||
unsigned long m_dwClassLimit;
|
||||
|
||||
UseLimit();
|
||||
void Initialize();
|
||||
};
|
||||
|
||||
#pragma pack(8)
|
||||
|
||||
struct ItemInfo
|
||||
{
|
||||
unsigned short m_usProtoTypeID;
|
||||
|
||||
DetailData m_DetailData;
|
||||
UseLimit m_UseLimit;
|
||||
SpriteData m_SpriteData;
|
||||
StringData m_StringData;
|
||||
|
||||
EquipAttribute m_EquipAttribute;
|
||||
UseItemInfo m_UseItemInfo;
|
||||
|
||||
ItemInfo();
|
||||
ItemInfo(unsigned short usPrototypeID);
|
||||
void Initialize();
|
||||
|
||||
inline bool operator < (ItemInfo& rhs)
|
||||
{ return (m_usProtoTypeID < rhs.m_usProtoTypeID); }
|
||||
};
|
||||
|
||||
#pragma pack()
|
||||
};
|
||||
|
||||
#endif
|
||||
Reference in New Issue
Block a user