API tools faq
paste
Guest User

Untitled

a guest
Sep 1st, 2012
156
0
Never
Add comment
Not a member of Pastebin yet? Sign Up, it unlocks many cool features!
C++ 29.95 KB | None | 0 0
raw download clone embed print report
  1. #if !defined(AFX_ITEM_H__80E88B36_BD6B_449B_BE76_34F2B5B77552__INCLUDED_)
  2. #define AFX_ITEM_H__80E88B36_BD6B_449B_BE76_34F2B5B77552__INCLUDED_
  3.  
  4. #if _MSC_VER > 1000
  5. #pragma once
  6. #endif // _MSC_VER > 1000
  7.  
  8. #if defined(__DBSERVER) || defined(__CORESERVER)
  9. #include "..\_Network\Objects\Obj.h"
  10. #else
  11. #include "Ctrl.h"
  12. #endif
  13. #include "ProjectCmn.h"
  14. #include "lang.h"
  15.  
  16. #if __VER >= 9  // __PET_0410
  17. #include "pet.h"
  18. #endif  // __PET_0410
  19.  
  20. #if __VER >= 11 // __SYS_COLLECTING
  21. #include "accessory.h"
  22. #endif  // __SYS_COLLECTING
  23.  
  24. #include "Piercing.h"
  25.  
  26. class CItemBase
  27. {
  28. public:
  29.     OBJID       m_dwObjId;      // ¾ÆÀÌÅÛ ÄÜÅ×ÀÌ³Ê ¾È¿¡¼­ÀÇ ID (¾ÆÀÌÅÛÀÇ ID·Î »ç¿ë)
  30.     DWORD       m_dwObjIndex;   // ¾ÆÀÌÅÛ ÄÜÅ×ÀÌ³Ê ¾È¿¡¼­ÀÇ Index
  31.     DWORD       m_dwItemId;     // ¾ÆÀÌÅÛ ½Äº° À妽º( Property¿¡¼­ »ç¿ë )
  32.     int         m_nExtra;       // °Å·¡½Ã ¹°Ç°°³¼ö or °³ÀλóÁ¡¿¡ µî·ÏÇÑ °¹¼ö
  33.     TCHAR       m_szItemText[ 32 ];
  34.     int         m_nCost;
  35.  
  36. #ifdef __CLIENT
  37.     CTexture*   m_pTexture;
  38. #endif
  39.  
  40. private:
  41.     SERIALNUMBER        m_liSerialNumber;
  42.  
  43. public:
  44.     CItemBase();
  45.     virtual ~CItemBase()    {}
  46.     virtual CItemBase&  operator = ( CItemBase & ib );
  47.     virtual void    Serialize( CAr & ar );
  48.     BOOL            IsEmpty() { return m_dwItemId ? FALSE : TRUE; }
  49.     BOOL            IsQuest();
  50.  
  51.     ItemProp*       GetProp();
  52.     virtual void            Empty();
  53.     void            SetTexture();
  54.     void            SetTexture( CTexture* pTexture );
  55.     CTexture*       GetTexture();                      
  56.     int             GetCost();                          // °¡°ÝÀ» ¾ò´Â´Ù.
  57.     void            SetExtra( int nExtra );         // È®Àå µ¥ÀÌŸ¸¦ ¼¼ÆÃ
  58.     int             GetExtra();                         // È®Àå µ¥ÀÌŸ¸¦ ¾ò±â
  59. #if __VER >= 11 // __GUILDCOMBATCHIP
  60.     DWORD           GetChipCost();
  61. #endif // __GUILDCOMBATCHIP
  62.  
  63.     void    SetSerialNumber( void );
  64.     SERIALNUMBER    GetSerialNumber( void )     {   return m_liSerialNumber;    }
  65.     void    SetSerialNumber( SERIALNUMBER liSerialNumber )  {   m_liSerialNumber    = liSerialNumber;   }
  66. };
  67.  
  68. inline void CItemBase::SetExtra( int nExtra )
  69. {
  70.     m_nExtra = nExtra;
  71. }
  72.  
  73. inline int CItemBase::GetExtra()
  74. {
  75.     return m_nExtra;
  76. }
  77.  
  78.  
  79. inline void CItemBase::SetTexture( CTexture* pTexture )
  80. {
  81. #ifdef __CLIENT
  82.     m_pTexture = pTexture;
  83. #endif
  84. }
  85.  
  86. inline CTexture* CItemBase::GetTexture()
  87. {
  88. #ifdef __CLIENT
  89.     return m_pTexture;
  90. #else
  91.     return NULL;
  92. #endif
  93. }
  94.  
  95. class CItemElem : public CItemBase
  96. {
  97. private:
  98.     CPiercing   m_piercing;
  99. public:
  100.     void    SetPiercingSize( int nSize )    {   m_piercing.SetPiercingSize( nSize );    }
  101.     int     GetPiercingSize()   {   return m_piercing.GetPiercingSize();        }
  102.     void    SetPiercingItem( int nth, DWORD dwItem )    {   m_piercing.SetPiercingItem( nth, dwItem );  }
  103.     DWORD   GetPiercingItem( int nth )  {   return m_piercing.GetPiercingItem( nth );   }
  104.     void    CopyPiercing( const CPiercing & piercing )      {   m_piercing  = piercing;     }
  105.     void    SerializePiercing( CAr & ar )   {   m_piercing.Serialize( ar );     }
  106.     BOOL    IsPiercedItem() { return m_piercing.IsPiercedItem(); }
  107. #if __VER >= 12 // __EXT_PIERCING
  108.     void    SetUltimatePiercingSize( int nSize )    {   m_piercing.SetUltimatePiercingSize( nSize );    }
  109.     int     GetUltimatePiercingSize()   {   return m_piercing.GetUltimatePiercingSize();        }
  110.     void    SetUltimatePiercingItem( int nth, DWORD dwItem )    {   m_piercing.SetUltimatePiercingItem( nth, dwItem );  }
  111.     DWORD   GetUltimatePiercingItem( int nth )  {   return m_piercing.GetUltimatePiercingItem( nth );   }
  112.    
  113.     BOOL    IsPierceAble( DWORD dwTargetItemKind3 = NULL_ID, BOOL bSize = FALSE );
  114. #endif // __EXT_PIERCING
  115.  
  116.     int         m_nAbilityOption;   // Ãß°¡ ´É·ÂÄ¡ °¡º¯ ¿É¼Ç
  117.  
  118. public:
  119.     enum    {   expired = 0x01, binds   = 0x02, isusing = 0x04, };
  120.  
  121.     int         m_nRepair;          // ¼ö¸® Ƚ¼ö
  122.     BYTE        m_nRepairNumber;
  123.     int         m_nHitPoint;
  124.     short       m_nItemNum;
  125.     BYTE        m_byFlag;
  126.     DWORD       m_idGuild;          // ¾ÆÀÌÅÛ¿¡ ±æµå ¹øÈ£°¡ ºÙ´Â °æ¿ì(¸ÁÅä)
  127.    
  128. #ifdef __CLIENT
  129.     BOOL        m_bRepair;
  130. #endif  // __CLIENT
  131.  
  132.     BYTE        m_bItemResist;              // ¾î´À ¼Ó¼º Àΰ¡? / TEXTÇüÅ·Π±Ë½ºÆ®¸¦ ÀÛµ¿½ÃÅ°´Â ¾ÆÀÌÅÛ¿¡¼­ TRUEÀÌ¸é ´õÀÌ»ó Äù½ºÆ®¸¦ ÀÛµ¿ÇÒ ¼ö ¾ø°Ô µÈ´Ù.
  133.     int         m_nResistAbilityOption;     // ¼Ó¼º Ãß°¡ ´É·ÂÄ¡ °¡º¯ ¿É¼Ç
  134.     int         m_nResistSMItemId; 
  135.  
  136. #ifdef __WORLDSERVER
  137.     BOOL    m_bQuery;
  138. #endif  // __WORLDSERVER
  139.  
  140.     /*
  141. #ifdef __GIFTBOX0213
  142. #ifdef __WORLDSERVER
  143.     int     m_nQueryGiftbox;
  144. #endif  // __WORLDSERVER
  145. #endif  // __GIFTBOX0213
  146.     */
  147. #if __VER >= 12 // __LORD
  148.     BOOL    IsPerin( void )     {   return m_dwItemId == II_SYS_SYS_SCR_PERIN;  }
  149. #endif  // __LORD
  150. #if __VER >= 11 // __SYS_COLLECTING
  151.     BOOL    IsCollector( BOOL bRefinable = FALSE )  {   return( m_dwItemId == II_GEN_TOO_COL_NORMAL || ( !bRefinable && m_dwItemId == II_GEN_TOO_COL_EVENT ) );     }
  152.     BOOL    IsAccessory( void )     {   return CAccessoryProperty::GetInstance()->IsAccessory( m_dwItemId );    }
  153.     BOOL    IsActiveTicket( DWORD dwItemId );
  154. #endif  // __SYS_COLLECTING
  155. #if __VER >= 11 // __SYS_IDENTIFY
  156.     // ºñÆ®º° ¿¬»ê
  157.     // 8|10|8|10|8|10|8 = 64
  158. private:
  159.     __int64     m_iRandomOptItemId;
  160.  
  161.     //  mulcom  BEGIN100405 °¢¼º º¸È£ÀÇ µÎ·ç¸¶¸®
  162.     __int64     m_n64NewRandomOption;
  163.     //  mulcom  END100405   °¢¼º º¸È£ÀÇ µÎ·ç¸¶¸®
  164.  
  165. public:
  166.     __int64     GetRandomOptItemId( void )  {   return m_iRandomOptItemId;  }
  167.     void    SetRandomOptItemId( __int64 iRandomOptItemId )  {   m_iRandomOptItemId  = iRandomOptItemId; }
  168.     int     GetRandomOpt( void )    {   return static_cast<int>( m_iRandomOptItemId & 0x00000000000000FF ); }
  169.     void    SetRandomOpt( int nRandomOpt )  {   m_iRandomOptItemId  = ( m_iRandomOptItemId & 0xFFFFFFFFFFFFFF00 ) | static_cast<__int64>( nRandomOpt & 0x00000000000000FF );    }
  170.     __int64*    GetRandomOptItemIdPtr( void )   {   return &m_iRandomOptItemId; }
  171.  
  172.  
  173.     //  mulcom  BEGIN100405 °¢¼º º¸È£ÀÇ µÎ·ç¸¶¸®
  174.     __int64     GetNewRandomOption();
  175.     __int64*    GetNewRandomOptionPtr();
  176.     void        ResetNewRandomOption();
  177.     void        SelectNewRandomOption();
  178.     bool        SelectRandomOption( BYTE bySelectFlag );
  179.     //  mulcom  END100405   °¢¼º º¸È£ÀÇ µÎ·ç¸¶¸®
  180.  
  181.  
  182.     //  0x8000000000000000
  183.     //  0x4000000000000000
  184.     enum    {   eNoLevelDown, e5LevelDown, e10LevelDown,    };
  185.     int     GetLevelDown( void );   // 64|63
  186.     void    SetLevelDown( int i = eNoLevelDown );
  187.     DWORD   GetLimitLevel( void );
  188. #if __VER >= 14 // __NEW_ITEM_LIMIT_LEVEL
  189.     BOOL    IsLimitLevel( CMover* pMover ); // Âø¿ëÀÌ ºÒ°¡´ÉÇÑ ·¹º§Àΰ¡?
  190. #endif // __NEW_ITEM_LIMIT_LEVEL
  191. #else   // __SYS_IDENTIFY
  192. private:
  193.     int         m_nRandomOptItemId;
  194. public:
  195.     int     GetRandomOptItemId( void )  {   return m_nRandomOptItemId;  }
  196.     void    SetRandomOptItemId( int nRandomOptItemId )  {   m_nRandomOptItemId  = nRandomOptItemId; }
  197.     int     GetRandomOpt( void )    {   return m_nRandomOptItemId;  }
  198.     void    SetRandomOpt( int nRandomOpt )  { m_nRandomOptItemId    = nRandomOpt;   }
  199. #endif  // __SYS_IDENTIFY
  200. /*
  201. #ifdef __XPET2
  202.     int m_nMaxLevel;    // ¼ö¸í
  203.     int m_nLevel;       // ·¹º§(³ªÀÌ)
  204.     int m_nStr, m_nDex, m_nInt, m_nSta;     // ½ºÅÈ
  205.     int m_nHungry;      // ¹è°íÇÂÁ¤µµ -10 ~ 10        -10ÀÌÇÏ´Â Á¸³»¹è°íÇÄ / -10 ~ -5 ¹è°íÇÄ / -5 ~ 5 º¸Åë / 5ÀÌ»ó ¹èºÎ¸§
  206.     int m_nFeeling;     // ±âºÐ. -10 ~ 10          
  207.     int m_nHealth;      // °Ç°­ -10 ~ 10
  208.     int m_nConstitution;    // üÁú(¿µ¾ç»óÅÂ) -10 ~ 10
  209. #endif
  210. */
  211.    
  212. #if __VER >= 9  // __PET_0410
  213.     CPet*   m_pPet;     // Æê °´Ã¼, ù ¼Òȯ ãÁ »ý¼º
  214.     BOOL    IsPet( void )   {   return GetProp()->dwItemKind3 == IK3_EGG;   }
  215. #endif  // __PET_0410
  216.     BOOL    IsEatPet( void )    {   return GetProp()->dwItemKind3 == IK3_PET;   }
  217.     BOOL    IsFeed( void )      {   return GetProp()->dwItemKind3 == IK3_FEED;  }
  218.     BOOL    IsEgg( void );
  219.     CString     GetName( void );
  220.  
  221. public:
  222. //  Constructions
  223.     CItemElem();
  224.     virtual ~CItemElem();
  225.  
  226. //  Attributes
  227.     virtual void            Empty();
  228.     ItemProp*   GetProp()   {   return prj.GetItemProp( m_dwItemId );   }
  229.     int         GetAttrOption();        // ¾ÆÀÌÅÛÀÇ +¿É¼Ç°ª°ú ¼Ó¼º/¼Ó¼º·¹º§°ªÀ» ÇÕÃļ­ ¸®ÅÏ.
  230.     int         GetAbilityOption() { return m_nAbilityOption; }
  231. #if __VER >= 15 // __15_5TH_ELEMENTAL_SMELT_SAFETY
  232.     int         GetItemResist( void ) const;
  233.     int         GetResistAbilityOption( void ) const;
  234. #endif // __15_5TH_ELEMENTAL_SMELT_SAFETY
  235.     int*        GetAbilityOptionPtr() { return &m_nAbilityOption; }
  236.     void        SetAbilityOption( int nAbilityOption ) { m_nAbilityOption = nAbilityOption; }
  237.     int         GetGold();
  238.  
  239. //  PIERCINGINFO    m_piercingInfo;
  240.     void    GetPiercingAvail( PPIERCINGAVAIL pPiercingAvail/*input, output*/ );
  241.     BOOL    m_bCharged;         // »ó¿ëÈ­ ¾ÆÀÌÅÛÀÎÁö È®ÀÎ
  242.     DWORD   m_dwKeepTime;       // Áö¼Ó½Ã°£
  243.  
  244.     BOOL    IsExpiring( void )
  245.         {  
  246.             if( m_dwKeepTime )
  247.             {
  248.                 if( time_null() > (time_t)m_dwKeepTime )
  249.                     return TRUE;
  250.             }
  251.             return FALSE;
  252.         }
  253.     void    ResetFlag( BYTE byFlag )    {   m_byFlag    &= ~byFlag;     }
  254.     void    SetFlag( BYTE byFlag )      {   m_byFlag    |= byFlag;      }
  255.     BOOL    IsFlag( BYTE byFlag )   {   return ( m_byFlag & byFlag ) ? TRUE: FALSE;     }
  256.     BOOL    IsBinds();
  257.     BOOL    IsUndestructable( void );
  258.     BOOL    IsCharged();
  259.     BOOL    IsLogable();
  260.  
  261.     static BOOL IsDiceRefineryAble( ItemProp* pProp );
  262.     static BOOL IsEleRefineryAble( ItemProp* pProp );
  263. #if __VER >= 15 // __15_5TH_ELEMENTAL_SMELT_SAFETY
  264.     static BOOL IsElementalCard( const DWORD dwItemID );
  265. #endif // __15_5TH_ELEMENTAL_SMELT_SAFETY
  266.    
  267. //  Operations
  268.     void        UseItem();
  269.     virtual CItemElem&  operator = ( CItemElem & ie );
  270.     virtual void        Serialize( CAr & ar );
  271.  
  272. #if __VER >= 15 // __PETVIS
  273.     BOOL    IsVisPet()  { return ( GetProp() && GetProp()->IsVisPet() ) || IsTransformVisPet() ; }
  274.     void    SetSwapVisItem( int nPos1, int nPos2 );
  275.     void    SetVisKeepTimeSize( int nSize )             { m_piercing.SetVisKeepTimeSize( nSize ); }
  276.     void    SetVisKeepTime( int nth, time_t tmKeep )    { m_piercing.SetVisKeepTime( nth, tmKeep ); }
  277.     time_t  GetVisKeepTime( int nth )                   { return m_piercing.GetVisKeepTime( nth ); }
  278.     DWORD   GetVisPetSfxId();
  279.     BOOL    IsTransformVisPet() { return GetProp() && GetProp()->dwItemKind3 == IK3_PET && m_bTranformVisPet; }
  280.  
  281.     BOOL    m_bTranformVisPet;
  282. #endif // __PETVIS
  283. };
  284.  
  285. inline int CItemElem::GetAttrOption()       // ¾ÆÀÌÅÛÀÇ +¿É¼Ç°ª°ú ¼Ó¼º/¼Ó¼º·¹º§°ªÀ» ÇÕÃļ­ ¸®ÅÏ.
  286. {
  287.     int nAttr = (int)m_bItemResist;
  288.     int nOption = m_nResistAbilityOption;
  289.     int nRet = m_nAbilityOption;
  290.    
  291.     nRet |= (nAttr << 16);      // D16~D23 : ¼Ó¼º
  292.     nRet |= (nOption << 24);    // D24~D31 : ¼Ó¼º·¹º§
  293.     return nRet;
  294. }
  295.  
  296. #if __VER >= 15 // __15_5TH_ELEMENTAL_SMELT_SAFETY
  297. inline int CItemElem::GetItemResist( void ) const
  298. {
  299.     return m_bItemResist;
  300. }
  301.  
  302. inline int CItemElem::GetResistAbilityOption( void ) const
  303. {
  304.     return m_nResistAbilityOption;
  305. }
  306. #endif // __15_5TH_ELEMENTAL_SMELT_SAFETY
  307.  
  308. typedef struct tagSkill
  309. {
  310.     DWORD dwSkill;
  311.     DWORD dwLevel;
  312.     ItemProp* GetProp() { return prj.GetSkillProp( dwSkill ); }
  313.    
  314. } SKILL,* LPSKILL;
  315.  
  316. /*
  317. #ifdef __XPET2
  318. class CPetElem : public CItemBase
  319. {
  320.     int m_nMaxLevel;    // ¼ö¸í
  321.     int m_nLevel;       // ·¹º§(³ªÀÌ)
  322.     int m_dwHungry;     // ¹è°íÇÂÁ¤µµ -10 ~ 10        -10ÀÌÇÏ´Â Á¸³»¹è°íÇÄ / -10 ~ -5 ¹è°íÇÄ / -5 ~ 5 º¸Åë / 5ÀÌ»ó ¹èºÎ¸§
  323.     int m_dwFeeling;    // ±âºÐ. -10 ~ 10          
  324.  
  325.     void Init();
  326.     void Destroy();
  327. public:
  328.     CPetElem();
  329.     ~CPetElem();
  330.     ItemProp* GetProp() {   return prj.GetItemProp( m_dwItemId );   }
  331.     virtual CPetElem&   operator = ( CPetElem & pe );
  332.     virtual void    Serialize( CAr & ar );
  333. };
  334. #endif // xPet2
  335. */
  336.  
  337. //////////////////////////////////////////////////////////////////////
  338. // ÀÌ°ÍÀº ¾ÆÀÌÅÛ ÇϳªÇϳªÀÇ ¿ä¼Ò¸¦ ¹è¿­·Î ¸¸µé¾î Ãß°¡, »èÁ¦ µîÀÇ
  339. // ÆíÁýÀÌ °¡´ÉÇÑ ÄÁÅ×ÀÌ³Ê Å¬·¡½º´Ù.
  340. //////////////////////////////////////////////////////////////////////
  341. template <class T> class CItemContainer  
  342. {
  343. public:
  344.     LPDWORD    m_apIndex;
  345.     DWORD      m_dwIndexNum; // equpÀ» Á¦¿ÜÇÑ ¼ø¼ö ÄÜÅ×ÀÌ³Ê »çÀÌÁî
  346.     DWORD      m_dwItemMax;  // equpÀ» Æ÷ÇÔÇÑ Àüü »çÀÌÁî
  347.     T*         m_apItem;
  348.  
  349.     void SetItemContainer( DWORD dwItemType, DWORD dwItemMax, DWORD dwExtra = NULL_ID );
  350.     CItemContainer();
  351. //  CItemContainer( DWORD dwItemType, DWORD dwItemMax, DWORD dwExtra = NULL_ID );
  352.     virtual ~CItemContainer();
  353.  
  354.     void Clear();
  355.  
  356.     T* GetAt( DWORD dwIndex );
  357. #ifdef __CLIENT
  358.     void SetAt( DWORD dwIndex, DWORD dwItemId );
  359.     void SetAt( DWORD dwIndex, T* pItemElem );
  360.     void InsertAt( DWORD dwIndex, DWORD dwItemId );
  361.     void InsertAt( DWORD dwIndex, T* pItemElem );
  362.     void RemoveAt( DWORD dwIndex );
  363. #if __VER >= 8  // __JEFF_VER_8
  364.     DWORD   Find( DWORD dwItemId )
  365.         {
  366.             if( dwItemId == 0 )
  367.                 return NULL_ID;
  368.             for( int i = 0; i < (int)( m_dwIndexNum ); i++ )
  369.             {
  370.                 DWORD nId   = m_apIndex[i];
  371.                 if( nId < 0 || nId >= m_dwItemMax )
  372.                     continue;
  373.                 if( m_apItem[nId].m_dwItemId == dwItemId )
  374.                     return nId;
  375.             }
  376.             return NULL_ID;
  377.         }
  378.     DWORD   GetItemCount( DWORD dwItemId )
  379.         {
  380.             if( dwItemId == 0 )
  381.                 return 0;
  382.             int nCount  = 0;
  383.             for( int i = 0; i < (int)( m_dwItemMax ); i++ )
  384.             {
  385.                 CItemElem* pItemElem    = (CItemElem*)&m_apItem[i];
  386.                 if( pItemElem->m_dwItemId == dwItemId )
  387.                     nCount  += pItemElem->m_nItemNum;
  388.             }
  389.             return( nCount );
  390.         }
  391. #endif  // __JEFF_VER_8
  392. #endif  // __CLIENT
  393.  
  394.     // Equip °ü·Ã
  395.     BOOL DoEquip( DWORD dwSrcIndex, DWORD dwDstIndex );
  396.     BOOL UnEquip( DWORD dwIndex );
  397.     BOOL IsEquip( DWORD dwObjId );
  398.     T* GetEquip( DWORD dwIndex );
  399.  
  400.     void    Swap( DWORD dwSrcIndex, DWORD dwDstIndex );
  401.     BOOL    Add( T* pElem, BYTE* pnId = NULL, short* pnNum = NULL, BYTE* pnCount = NULL );
  402.     BOOL    IsFull( T* pElem, ItemProp* pItemProp, short nNum );
  403.     void    SetAtId( OBJID dwObjId, T* pItemElem );
  404.  
  405.     T*  GetAtId( OBJID dwObjId );
  406.     T* GetAtItemId( DWORD dwItemId );
  407.     int     GetAtItemNum( DWORD dwItemId );
  408.     void    RemoveAtId( OBJID dwObjId );
  409.  
  410.     int     GetSize() { return int( m_dwIndexNum ); }
  411.     int     GetMax() { return int( m_dwItemMax ); }
  412.     void    Copy( CItemContainer<T> & rItemContainer );
  413.     void    Serialize( CAr & ar );
  414.  
  415.     int     GetEmptyCount()
  416.         {
  417.             int nCount  = 0;
  418.             for( DWORD i = 0; i < m_dwItemMax; i++ )
  419.             {
  420.                 if( m_apItem[i].IsEmpty() && m_apItem[i].m_dwObjIndex < m_dwIndexNum )
  421.                     nCount++;
  422.             }
  423.             return( nCount );
  424.         }
  425.     int     GetCount()
  426.         {
  427.             int nCount  = 0;
  428.             for( DWORD i = 0; i < m_dwItemMax; i++ )
  429.             {
  430.                 if( m_apItem[i].IsEmpty() == FALSE && m_apItem[i].m_dwObjIndex < m_dwIndexNum )
  431.                     nCount++;
  432.             }
  433.             return( nCount );
  434.         }
  435.     int     GetCountByIK3( DWORD dwItemKind3 )
  436.         {
  437.             int nCount  = 0;
  438.             for( int i = 0; i < m_dwItemMax; i++ )
  439.             {
  440.                 if( m_apItem[i].IsEmpty() == FALSE && m_apItem[i].GetProp()->dwItemKind3 == dwItemKind3 )
  441.                     nCount++;
  442.             }
  443.             return( nCount );
  444.         }
  445.     int     GetCount( DWORD dwItemId )
  446.         {
  447.             int nCount  = 0;
  448.             for( DWORD i = 0; i < m_dwItemMax; i++ )
  449.             {
  450.                 if( m_apItem[i].IsEmpty() == FALSE && m_apItem[i].m_dwItemId == dwItemId )
  451.                     nCount++;
  452.             }
  453.             return( nCount );
  454.         }
  455. private:
  456.     void    Swap2( DWORD dwSrcIndex, DWORD dwDstIndex );
  457. };
  458.  
  459. template <class T> CItemContainer<T>::CItemContainer()
  460. {
  461.     m_dwIndexNum = 0;
  462.     m_dwItemMax = 0;
  463.  
  464.     m_apItem = NULL;
  465.     m_apIndex = NULL;
  466. }
  467.  
  468.  
  469. //template <class T> CItemContainer<T>::CItemContainer( DWORD dwItemType, DWORD dwItemMax, DWORD dwExtra )
  470. //{
  471. //  SetItemContainer( dwItemType, dwItemMax, dwExtra );
  472. //}
  473.  
  474. template <class T> CItemContainer<T>::~CItemContainer()
  475. {
  476.     SAFE_DELETE_ARRAY( m_apItem );
  477.     SAFE_DELETE_ARRAY( m_apIndex );
  478. }
  479.  
  480. template <class T> void CItemContainer<T>::Clear()
  481. {
  482.     for( DWORD i = 0; i < m_dwItemMax; i++ )
  483.     {
  484.         m_apItem[ i ].Empty();
  485.         m_apItem[ i ].m_dwObjId = i;
  486.         if( i < m_dwIndexNum )
  487.         {
  488.             m_apItem[ i ].m_dwObjIndex = i;
  489.             m_apIndex[ i ] = i;
  490.         }
  491.         else
  492.         {
  493.             m_apIndex[ i ] = NULL_ID;
  494.         }
  495.     }
  496. }
  497.  
  498. template <class T> void CItemContainer<T>::SetItemContainer( DWORD dwItemType, DWORD dwItemMax, DWORD dwExtra )
  499. {
  500.     m_dwIndexNum = dwItemMax;
  501.     m_dwItemMax = dwItemMax;
  502.     if( dwExtra != NULL_ID )
  503.         m_dwItemMax += dwExtra;
  504.    
  505.     SAFE_DELETE_ARRAY( m_apItem );
  506.     SAFE_DELETE_ARRAY( m_apIndex );
  507.  
  508.     m_apItem = new T[ m_dwItemMax ];
  509.     m_apIndex = new DWORD[ m_dwItemMax ];
  510.     Clear();
  511. }
  512.  
  513. // Àμö¸¦ ¿ÀºêÁ§Æ® ¾ÆÀ̵𸦠»ç¿ëÇؼ­ ¾ò´Â´Ù.
  514. // ¿ÀºêÁ§Æ® ¾ÆÀ̵ð´Â ¹è¿­¿¡ Çѹø Ãß°¡ÇÒ ¶§ »ý¼ºµÇ¸ç »èÁ¦µÇÁö ¾Ê´Â ÇÑ Àý´ë ¹Ù²îÁö ¾Ê´Â´Ù.
  515. template <class T> T* CItemContainer<T>::GetAtId( DWORD dwId )
  516. {
  517.     if( dwId >= (DWORD)( GetMax() ) ) return NULL;
  518.     T* pItemElem = &m_apItem[ dwId ];
  519.     if( pItemElem->IsEmpty() )
  520.         return NULL;
  521.     return pItemElem;
  522. }
  523.  
  524. template <class T> T* CItemContainer<T>::GetAtItemId( DWORD dwItemId )
  525. {
  526.     for( DWORD i = 0; i < m_dwItemMax; i++ )
  527.     {
  528.         if( m_apItem[i].m_dwItemId == dwItemId )
  529.             return &m_apItem[i];
  530.     }
  531.     return NULL;
  532. }
  533.  
  534. template <class T> int CItemContainer<T>::GetAtItemNum( DWORD dwItemId )
  535. {
  536.     int nResult = 0;
  537.     for( DWORD i = 0; i < m_dwItemMax; i++ )
  538.     {
  539.         if( m_apItem[i].m_dwItemId == dwItemId )
  540.             nResult += m_apItem[i].m_nItemNum;
  541.     }
  542.     return nResult;
  543. }
  544.  
  545. template <class T> BOOL CItemContainer<T>::DoEquip( DWORD dwSrcIndex, DWORD dwDstIndex )
  546. {
  547.     dwDstIndex += m_dwIndexNum;     // dwDstIndex = °¡¹æÅ©±â(42) + PARTS_???;
  548.  
  549.     if( dwSrcIndex == dwDstIndex )
  550.         return FALSE;
  551.  
  552.     if( dwSrcIndex >= m_dwItemMax || dwDstIndex >= m_dwItemMax )
  553.         return FALSE;
  554.  
  555.     for( DWORD i = 0; i < m_dwItemMax; i++ )
  556.     {
  557.         if( m_apItem[ i ].IsEmpty() && m_apItem[ i ].m_dwObjIndex == NULL_ID )
  558.         {
  559.             if( m_apIndex[dwSrcIndex] >= m_dwItemMax )
  560.                 return FALSE;
  561.             m_apIndex[ dwDstIndex ] = m_apIndex[ dwSrcIndex ];      // °¡¹æ¿¡ ÀÖ´ø index°ªÀ» ÀåÂøºÎÀ§(dwDstIndex)·Î ¿Å±è.
  562.             m_apIndex[ dwSrcIndex ] = i;                            // ¿ø·¡ ¾ÆÅÛÀÌ ÀÖ´ø°÷(dwSrcIndex)Àº ºñ¾îÀÖ°Ô(i) ¸¸µç´Ù.
  563.             m_apItem[ m_apIndex[ dwSrcIndex ] ].m_dwObjIndex = dwSrcIndex;  // ¿Å°ÜÁ®¼­ ºñ°ÔµÈ°÷ÀÇ m_dwObjIndex¿¡´Â ¿Ö dwSrcIndex¸¦ ³Ö¾îÁִ°¡?
  564.             m_apItem[ m_apIndex[ dwDstIndex ] ].m_dwObjIndex = dwDstIndex;  // dwObjIndex´Â apItem¿¡¼­ ¿ªÀ¸·Î apIndexÀÇ index¸¦ ¾Ë±âÀ§ÇÔÀΰ¡?
  565.             return TRUE;
  566.         }
  567.     }
  568.     return FALSE;
  569. }
  570.  
  571. template <class T> BOOL CItemContainer<T>::UnEquip( DWORD dwIndex )
  572. {
  573.     dwIndex += m_dwIndexNum;
  574.     if( dwIndex >= m_dwItemMax )
  575.         return FALSE;
  576.  
  577.     DWORD dwId = m_apIndex[ dwIndex ];
  578.  
  579.     if( dwId >= m_dwItemMax )
  580.         return FALSE;
  581.  
  582.     for( DWORD i = 0; i < m_dwIndexNum; i++ )
  583.     {
  584.         if( m_apIndex[i] >= m_dwItemMax )
  585.             continue;
  586.  
  587.         if( m_apItem[ m_apIndex[ i ] ].IsEmpty() )
  588.         {
  589.             m_apItem[ m_apIndex[ i ] ].m_dwObjIndex = NULL_ID;
  590.             m_apIndex[ dwIndex ] = NULL_ID;
  591.             m_apItem[ dwId ].m_dwObjIndex = i;
  592.             m_apIndex[ i ] = dwId;
  593.             return TRUE;
  594.         }
  595.     }
  596.     return FALSE;
  597. }
  598.  
  599. template <class T> BOOL CItemContainer<T>::IsEquip( DWORD dwObjId )
  600. {
  601.     if( !m_apItem )
  602.     {
  603.         WriteError( "CONTAINER//0" );
  604.         return FALSE;
  605.     }
  606.  
  607.     if( dwObjId >= m_dwItemMax )
  608.         return FALSE;
  609.  
  610.     if( m_apItem[ dwObjId ].m_dwObjIndex >= m_dwIndexNum )
  611.         return TRUE;
  612.     return FALSE;
  613. }
  614.  
  615. template <class T> T* CItemContainer<T>::GetEquip( DWORD dwIndex )
  616. {
  617.     if( m_dwIndexNum )
  618.     {
  619.         if( dwIndex < 0 || dwIndex >= ( m_dwItemMax - m_dwIndexNum ) )
  620.         {
  621.             WriteError( "GETEQUIP//%d, %d, %d", m_dwIndexNum, m_dwItemMax - m_dwIndexNum, dwIndex );
  622.             return NULL;
  623.         }
  624.         return GetAt( m_dwIndexNum + dwIndex );
  625.     }
  626.     return NULL;
  627. }
  628.  
  629. template <class T> BOOL CItemContainer<T>::IsFull( T* pElem, ItemProp* pItemProp, short nNum )
  630. {
  631.     int nId;
  632.     short nNumtmp   = nNum;
  633.     CItemElem* pElemtmp;
  634.     for( DWORD i = 0; i < m_dwIndexNum; i++ )
  635.     {
  636.         nId = m_apIndex[i];
  637.         if( nId < 0 || nId >= (int)( m_dwItemMax ) )
  638.             continue;
  639.         pElemtmp    = (CItemElem*)&m_apItem[nId];
  640.         if( pElemtmp->IsEmpty() )
  641.         {
  642.             if( nNumtmp > (short)pItemProp->dwPackMax )
  643.                 nNumtmp     -= (short)pItemProp->dwPackMax;
  644.             else
  645.                 return FALSE;
  646.         }
  647.         else if( pElem->m_dwItemId == pElemtmp->m_dwItemId
  648.                 && pElem->m_byFlag == pElemtmp->m_byFlag && pElem->m_bCharged == pElemtmp->m_bCharged )
  649.         {
  650.             if( pElemtmp->m_nItemNum + nNumtmp > (short)pItemProp->dwPackMax )
  651.                 nNumtmp -= ( (short)pItemProp->dwPackMax - pElemtmp->m_nItemNum );
  652.             else
  653.                 return FALSE;
  654.         }
  655.     }
  656.  
  657.     return TRUE;
  658. }
  659.  
  660. template <class T> BOOL CItemContainer<T>::Add( T* pElem, BYTE* pnId, short* pnNum, BYTE* pnCount )
  661. {
  662.     if( pnId )
  663.         *pnCount    = 0;
  664.     ItemProp* pItemProp     = pElem->GetProp();
  665.     if( !pItemProp )
  666.         return FALSE;
  667.     BOOL bPackItem = TRUE;
  668.     int nId;
  669.  
  670.     short nNumtmp   = ( (CItemElem*)pElem )->m_nItemNum;
  671.     if( IsFull( pElem, pItemProp, nNumtmp ) )   // ¾ÆÀÌÅÛÀ» ³ÖÀ»¼ö ÀÖ´ÂÁö °Ë»ç
  672.         return FALSE;
  673.  
  674.     if( pItemProp->dwPackMax == 1 )
  675.         bPackItem = FALSE;
  676.  
  677.     CItemElem* pElemtmp;
  678.     if( bPackItem )
  679.     {
  680.         for( DWORD i = 0; i < m_dwIndexNum; i++ )
  681.         {
  682.             nId = m_apIndex[i];
  683.             if( nId < 0 || nId >= (int)( m_dwItemMax ) )
  684.                 continue;
  685.             pElemtmp    = (CItemElem*)&m_apItem[nId];
  686.            
  687.             if( pElemtmp->IsEmpty() == FALSE && pElemtmp->m_dwItemId == pElem->m_dwItemId && pElemtmp->m_nItemNum < (short)pItemProp->dwPackMax
  688.                 && pElem->m_byFlag == pElemtmp->m_byFlag && pElem->m_bCharged == pElemtmp->m_bCharged )
  689.             {
  690.                 if( pElemtmp->m_nItemNum + nNumtmp > (short)pItemProp->dwPackMax )
  691.                 {
  692.                     nNumtmp -= ( (short)pItemProp->dwPackMax - pElemtmp->m_nItemNum );
  693.                     pElemtmp->m_nItemNum    = (short)pItemProp->dwPackMax;
  694.                     if( pnId )
  695.                     {
  696.                         pnId[*pnCount]  = nId;
  697.                         pnNum[*pnCount] = pElemtmp->m_nItemNum;
  698.                         ( *pnCount )++;
  699.                     }
  700.                 }
  701.                 else {
  702.                     pElemtmp->m_nItemNum    += nNumtmp;
  703.                     if( pnId ) {
  704.                         pnId[*pnCount]  = nId;
  705.                         pnNum[*pnCount]     = pElemtmp->m_nItemNum;
  706.                         ( *pnCount )++;
  707.                     }
  708.                     nNumtmp = 0;
  709.                     break;
  710.                 }
  711.             }
  712.            
  713.         }
  714.     }
  715.  
  716.     if( nNumtmp > 0 )
  717.     {
  718.         for( DWORD i = 0 ; i < m_dwIndexNum ; i++ )
  719.         {
  720.             nId = m_apIndex[i];
  721.             if( nId < 0 || nId >= (int)( m_dwItemMax ) )
  722.                 continue;
  723.             pElemtmp    = (CItemElem*)&m_apItem[nId];
  724.             if( pElemtmp->IsEmpty() )   // ºó°ø°£ÀÎÁö °Ë»ç
  725.             {
  726.                 *pElemtmp   = *( (CItemElem*)pElem );
  727.                 pElemtmp->m_dwObjId = nId;
  728.                 pElemtmp->m_dwObjIndex      = i;
  729.                 pElemtmp->SetTexture();
  730.                
  731.                 if( nNumtmp > (short)pItemProp->dwPackMax )
  732.                 {
  733.                     pElemtmp->m_nItemNum    = (short)pItemProp->dwPackMax;
  734.                     nNumtmp     -= (short)pItemProp->dwPackMax;
  735.                     if( pnId ) {
  736.                         pnId[*pnCount]  = nId;
  737.                         pnNum[*pnCount] = pElemtmp->m_nItemNum;
  738.                         ( *pnCount )++;
  739.                     }
  740.                 }
  741.                 else
  742.                 {
  743.                     pElemtmp->m_nItemNum    = nNumtmp;
  744.                     nNumtmp = 0;
  745.                     if( pnId )
  746.                     {
  747.                         pnId[*pnCount]  = nId;
  748.                         pnNum[*pnCount]     = pElemtmp->m_nItemNum;
  749.                         ( *pnCount )++;
  750.                     }
  751.                     break;
  752.                 }
  753.             }
  754.         }
  755.     }
  756.     if( nNumtmp > 0 )
  757.         Error( "template <class T> BOOL CItemContainer<T>::Add( T* pElem... : nNumtmp > 0" );
  758.     return TRUE;
  759. }
  760.  
  761. template <class T> void CItemContainer<T>::RemoveAtId( OBJID dwObjId )
  762. {
  763.     if( dwObjId >= m_dwItemMax )
  764.         return;
  765.     if( m_apItem[ dwObjId ].m_dwObjIndex >= m_dwItemMax )
  766.         return;
  767.     m_apItem[ dwObjId ].Empty();
  768.     if( m_apItem[ dwObjId ].m_dwObjIndex >= m_dwIndexNum )
  769.     {
  770.         m_apIndex[ m_apItem[ dwObjId ].m_dwObjIndex ] = NULL_ID;
  771.         m_apItem[ dwObjId ].m_dwObjIndex = NULL_ID;
  772.     }
  773. }
  774.  
  775.  
  776. template <class T> void CItemContainer<T>::SetAtId( OBJID dwObjId, T* pItemElem )
  777. {
  778.     if( dwObjId >= m_dwItemMax )
  779.         return;
  780.     m_apItem[dwObjId]   = *pItemElem;
  781.     m_apItem[dwObjId].m_dwObjId = dwObjId;
  782. }
  783.  
  784. /////////////////////////////////////////////////////////////////////////////////////////////////////////
  785. // client Àü¿ë
  786. #ifdef __CLIENT
  787.  
  788. template <class T> void CItemContainer<T>::RemoveAt( DWORD dwIndex )
  789. {
  790.     m_apItem[ m_apIndex[ dwIndex ] ].Empty();
  791.     if( dwIndex >= m_dwIndexNum )
  792.     {
  793.         m_apItem[ m_apIndex[ dwIndex ] ].m_dwObjIndex = NULL_ID;
  794.         m_apIndex[ dwIndex ] = NULL_ID;
  795.     }
  796. }
  797. template <class T> void CItemContainer<T>::SetAt( DWORD dwIndex, DWORD dwItemId )
  798. {
  799.     // À妽º°¡ ºñ¾îÀÖ³ª?
  800.     T* pItemElem = &m_apItem[ m_apIndex[ dwIndex ] ];
  801.     pItemElem->m_dwItemId = dwItemId;
  802.     pItemElem->m_dwObjId = m_apIndex[ dwIndex ];
  803.     pItemElem->m_dwObjIndex = dwIndex;
  804. }
  805. template <class T> void CItemContainer<T>::SetAt( DWORD dwIndex, T* pItemElem )
  806. {
  807.     CItemElem* pItemElem2 = &m_apItem[ m_apIndex[ dwIndex ] ];
  808.     *pItemElem2 = *pItemElem;
  809.     pItemElem2->m_dwObjId = m_apIndex[ dwIndex ];
  810.     pItemElem2->m_dwObjIndex = dwIndex;
  811. }
  812.  
  813. #endif // __CLIENT
  814.  
  815.  
  816.  
  817. // ¼ø¼öÇÏ°Ô À妽º ¹è¿­¿¡¼­ CItemElemÀ» ²¨³½´Ù.
  818. template <class T> T* CItemContainer<T>::GetAt( DWORD dwIndex )
  819. {
  820.     DWORD dwIdx = m_apIndex[ dwIndex ];
  821.     if( dwIdx == NULL_ID )
  822.         return NULL;
  823.     T* pItemElem = &m_apItem[ dwIdx ];
  824.     if( pItemElem->IsEmpty() )
  825.         return NULL;
  826.     return pItemElem;
  827. }
  828.  
  829. template<class T> void CItemContainer<T>::Swap2( DWORD dwSrcIndex, DWORD dwDstIndex )
  830. {
  831.     DWORD dwItem = m_apIndex[ dwSrcIndex ];
  832.     m_apIndex[ dwSrcIndex ] = m_apIndex[ dwDstIndex ];
  833.     m_apIndex[ dwDstIndex ] = dwItem;
  834.  
  835.     DWORD dwSrcItem = m_apIndex[dwSrcIndex];
  836.     DWORD dwDstItem = m_apIndex[dwDstIndex];
  837.     if( dwSrcItem != NULL_ID )
  838.         m_apItem[dwSrcItem].m_dwObjIndex    = dwSrcIndex;
  839.     if( dwDstItem != NULL_ID )
  840.         m_apItem[dwDstItem].m_dwObjIndex    = dwDstIndex;
  841. }
  842.  
  843. template <class T> void CItemContainer<T>::Swap( DWORD dwSrcIndex, DWORD dwDstIndex )
  844. {
  845.     if( dwSrcIndex == dwDstIndex || dwSrcIndex >= m_dwItemMax || dwDstIndex >= m_dwItemMax )
  846.         return;
  847.  
  848.     CItemElem* pItemElemSrc, *pItemElemDst;
  849.     pItemElemSrc    = (CItemElem*)GetAtId( m_apIndex[dwSrcIndex] );
  850.     pItemElemDst    = (CItemElem*)GetAtId( m_apIndex[dwDstIndex] );
  851.  
  852.     if( pItemElemSrc && pItemElemDst && pItemElemSrc->m_dwItemId == pItemElemDst->m_dwItemId && pItemElemSrc->m_byFlag == pItemElemDst->m_byFlag && pItemElemSrc->m_bCharged == pItemElemDst->m_bCharged )
  853.     {
  854.         ItemProp* pItemProp;
  855.         int nPackMax;
  856.         if( ( pItemProp = pItemElemSrc->GetProp() ) && ( nPackMax = pItemProp->dwPackMax ) > 1 )
  857.         {
  858.             short nRemnant  = (short)nPackMax - pItemElemDst->m_nItemNum;
  859.             if( nRemnant >= pItemElemSrc->m_nItemNum )
  860.             {
  861.                 pItemElemDst->m_nItemNum    += pItemElemSrc->m_nItemNum;
  862.                 RemoveAtId( m_apIndex[dwSrcIndex] );
  863.             }
  864.             else
  865.             {
  866.                 pItemElemDst->m_nItemNum    += nRemnant;
  867.                 pItemElemSrc->m_nItemNum    -= nRemnant;
  868.             }
  869.             return;
  870.         }
  871.     }
  872.     Swap2( dwSrcIndex, dwDstIndex );
  873. }
  874.  
  875. /*------------------------------------------------------------------------------------------------------------------------------------------------------------*/
  876.  
  877. template <class T> void CItemContainer<T>::Copy( CItemContainer<T> & rItemContainer )
  878. {
  879.     m_dwIndexNum    = rItemContainer.m_dwIndexNum;
  880.     memcpy( (void*)m_apIndex, (void*)rItemContainer.m_apIndex, sizeof(DWORD) * m_dwItemMax );
  881.     for( u_long i = 0; i < m_dwItemMax; i++ )
  882.     {
  883.         m_apItem[i].m_dwObjId   = rItemContainer.m_apItem[i].m_dwObjId;
  884.         m_apItem[i].m_dwObjIndex    = rItemContainer.m_apItem[i].m_dwObjIndex;
  885.         if( rItemContainer.m_apItem[i].IsEmpty() == FALSE )
  886.             m_apItem[i]     = rItemContainer.m_apItem[i];
  887.         else
  888.             m_apItem[i].Empty();
  889.     }
  890. }
  891.  
  892. template <class T> void CItemContainer<T>::Serialize( CAr & ar )    // 0-673    // 466-631
  893. {
  894.     DWORD   adwObjIndex[128];
  895.  
  896.     unsigned char chSize    = 0;
  897.  
  898.     if( ar.IsStoring() )
  899.     {
  900.        
  901.         ar.Write( m_apIndex, sizeof(DWORD) * m_dwItemMax );
  902.        
  903.         u_long uOffset  = ar.GetOffset();
  904.         ar << chSize;
  905.  
  906.         for( u_char ch = 0; ch < m_dwItemMax; ch++ )    // 0-504
  907.         {
  908.             if( m_apItem[ch].IsEmpty() == FALSE )
  909.             {
  910.                 ar << ch;
  911.                 m_apItem[ch].Serialize( ar );
  912.                 chSize++;
  913.             }
  914.             adwObjIndex[ch]     = m_apItem[ch].m_dwObjIndex;
  915.         }
  916.  
  917.         ar.Write( adwObjIndex, sizeof(DWORD) * m_dwItemMax );
  918.  
  919.         int nBufSize;
  920.         LPBYTE lpBuf    = ar.GetBuffer( &nBufSize );
  921.         *( lpBuf + uOffset )    = chSize;
  922.     }
  923.     else
  924.     {
  925.         ar.Read( m_apIndex, sizeof(DWORD) * m_dwItemMax );
  926.         // Clear
  927.         for( u_long i = 0; i < m_dwItemMax; i++ )
  928.             m_apItem[i].Empty();
  929.  
  930.         ar >> chSize;
  931.  
  932.         unsigned char ch;
  933.         for( i = 0; i < chSize; i++ )
  934.         {
  935.             ar >> ch;
  936.             m_apItem[ch].Serialize( ar );
  937.         }
  938.  
  939.         ar.Read( adwObjIndex, sizeof(DWORD) * m_dwItemMax );
  940.         for( i = 0; i < m_dwItemMax; i++ )
  941.         {
  942.             m_apItem[i].m_dwObjIndex    = adwObjIndex[i];
  943.         }
  944.     }
  945. }
  946.  
  947. //////////////////////////////////////////////////////////////////////////
  948. //
  949. //
  950. //
  951. //
  952. //////////////////////////////////////////////////////////////////////////
  953. #include "mempooler.h"
  954. typedef MemPooler<CItem> CItemPool;
  955.  
  956. /// ÁöÇüÀ§¿¡ Á¸ÀçÇÏ´Â ¾ÆÀÌÅÛ
  957. class CItem  : public CCtrl
  958. {
  959. private:
  960. #ifdef __CLIENT
  961.     float   m_fGroundY;     // ¾ÆÀÌÅÛÀÌ »ý¼ºµÉ´ç½Ã ±× À§Ä¡ÀÇ YÁÂÇ¥¸¦ ¹Ì¸® ±¸ÇسõÀÚ.
  962.     D3DXVECTOR3  m_vDelta;  //
  963. #endif // __CLIENT
  964.    
  965. public:
  966.     CItemBase* m_pItemBase;
  967.     u_long  m_idHolder;
  968.     OBJID   m_idOwn;        // ´©°¡ À̾ÆÀÌÅÛÀ» °¡Áú ±Ç¸®°¡ Àִ°¡.
  969.     DWORD   m_dwDropTime;   // µå¶øÇßÀ»¶§ÀÇ ½Ã°£.
  970.     BOOL    m_bDropMob;     // ¸ó½ºÅÍ°¡ Á׾ µå¶øÇÑ°ÍÀ̳Ä?.
  971. #ifdef __EVENT_MONSTER
  972.     BOOL    m_IdEventMonster;   // À̺¥Æ® ¸ó½ºÅÍ°¡ µå¶øÇÑ ¾ÆÀÌÅÛÀΰ¡?
  973. #endif // __EVENT_MONSTER
  974.  
  975.  
  976. public:
  977.     CItem();
  978.     virtual ~CItem();
  979.  
  980.     void SetOwner( OBJID id );
  981.     DWORD GetItemType() const { return 0; }
  982.     void SetItemBase( CItemBase* pItemBase ) { m_pItemBase = pItemBase; }
  983.  
  984.     CItemBase* GetItemBase() const { return m_pItemBase; }
  985.     ItemProp* GetProp() { return prj.GetItemProp( GetIndex() ); }
  986.    
  987.     virtual void Serialize( CAr & ar );
  988.     virtual void Process();
  989.     virtual void Render( LPDIRECT3DDEVICE9 pd3dDevice );
  990.     virtual void RenderName( LPDIRECT3DDEVICE9 pd3dDevice, CD3DFont* pFont, DWORD dwColor = 0xffffffff );
  991.     virtual BOOL Read( CFileIO* pFile );
  992.        
  993. #ifdef __CLIENT
  994.     void SetDelta( float fGroundY, D3DXVECTOR3 &vDelta );
  995. #endif // __CLIENT
  996.  
  997. public:
  998. #ifndef __VM_0820
  999. #ifndef __MEM_TRACE
  1000.     static  CItemPool*      m_pPool;
  1001.     void*   operator new( size_t nSize )    {   return CItem::m_pPool->Alloc(); }
  1002.     void*   operator new( size_t nSize, LPCSTR lpszFileName, int nLine )    {   return CItem::m_pPool->Alloc(); }
  1003.     void    operator delete( void* lpMem )  {   CItem::m_pPool->Free( (CItem*)lpMem );  }
  1004.     void    operator delete( void* lpMem, LPCSTR lpszFileName, int nLine )  {   CItem::m_pPool->Free( (CItem*)lpMem );  }
  1005. #endif  // __MEM_TRACE
  1006. #endif  // __VM_0820
  1007. };
  1008.  
  1009. extern BOOL IsUsableItem( CItemBase* pItem );
  1010. extern BOOL IsUsingItem( CItemBase* pItem );
  1011.  
  1012. #if __VER >= 11
  1013. extern  BOOL    IsNeedTarget( ItemProp* pProp );
  1014. #endif  // __VER
  1015.  
  1016. #endif // !defined(AFX_ITEM_H__80E88B36_BD6B_449B_BE76_34F2B5B77552__INCLUDED_)
Advertisement
Add Comment
Please, Sign In to add comment
Public Pastes
We use cookies for various purposes including analytics. By continuing to use Pastebin, you agree to our use of cookies as described in the Cookies Policy.  OK, I Understand
Not a member of Pastebin yet?
Sign Up, it unlocks many cool features!