Error exchange advanced

[Techside]

hi, now i am copy __EXCHANGE_ADV from Virtuos source to my source and have this error:
anyone me? =)

PHP Code:

f:\nova pasta\source\_common\pocket.h(10): note: consulte a declaração de 'CItemContainer<CItemElem>'
f:\nova pasta\source\_common\exchangeadv.cpp(192): error C2039: 'GetItemCount': não é um membro de 'CItemContainer<CItemElem>' 


Code from this archives and respective line:
ExchangeAdv.cpp

 Spoiler

#include "stdafx.h"
#include "ResData.h"
#ifdef __EXCHANGE_ADV
#ifdef __CLIENT
#include "defineText.h"
#include "DPClient.h"
extern CDPClient g_DPlay;
#else//__CLIENT
#include "User.h"
#include "dpcoreclient.h"
#include "DPDatabaseClient.h"
extern CDPCoreClient g_DPCoreClient;
extern CUserMng g_UserMng;
extern CDPDatabaseClient g_dpDBClient;
#endif // __CLIENT
#if __VER >= 11 // __SYS_PLAYER_DATA
#include "playerdata.h"
#endif // __SYS_PLAYER_DATA
#include "ExchangeAdv.h"

bool OrderByItemKind( EXCHANGE_ITEM* first, EXCHANGE_ITEM* second )
{
ItemProp* pItemProp[2];
pItemProp[0]= prj.GetItemProp( first->m_dwItemId );
pItemProp[1]= prj.GetItemProp( second->m_dwItemId );
if( pItemProp[0]->dwItemKind3 > pItemProp[1]->dwItemKind3)
return true;
else
return false;
}

CExchangeMng::CExchangeMng()
{
m_dwExchangeIndex = NULL;
m_mapExchangeItems.clear();
}

CExchangeMng::~CExchangeMng()
{
m_dwExchangeIndex = NULL;
m_mapExchangeItems.clear();
}

BOOL CExchangeMng::InsertItem( DWORD dwKey, DWORD dwItemId, int nPrice, DWORD dwItemNeed, TCHAR* szNpcKeyName, short nItemNum ) //
{
ItemProp* pItem = prj.GetItemProp( dwItemId );
if( !pItem )
{
Error( "[ExchangeAdv.inc] %d Item could not be found.", dwItemId );
return FALSE;
}

ItemProp* pItemNeed = prj.GetItemProp( dwItemNeed );
if( !pItemNeed )
{
Error( "[ExchangeAdv.inc] %d Item could not be found.2", dwItemNeed );
return FALSE;
}

if( nPrice <= NULL )
{
Error( "[ExchangeAdv.inc] %d, WILLSTE DAS ITEM FÜR KOSTENLOS VERSCHENKEN? DER PREIS IST GLEICH NULL ODER KLEINER!", dwItemId );
return FALSE;
}

if( nItemNum < NULL || nItemNum > 0x7fff )
{
Error( "[Exchange.inc] %d( nItemNum ), liegt im negativen Bereich. | Oder liegt über dem maximal Wert 0x7fff.", dwItemId );
return FALSE;
}

EXCHANGE_ITEM* pExchangeItem = new EXCHANGE_ITEM( dwItemId, nPrice, dwItemNeed, szNpcKeyName, nItemNum, dwKey );
if( !pExchangeItem )
{
Error( "Fehler beim Erstellen des Exchange Items. CODE 1" );
return FALSE;
}
//
//m_mapExchangeItems.insert( MAP_EXCHANGE_ITEM::value_type( pItem->dwID, pExchangeItem ));
m_mapExchangeItems.insert( make_pair(dwKey, pExchangeItem) );
return TRUE;
}
BOOL CExchangeMng:eleteItem( DWORD dwKey ) //
{
if( !m_mapExchangeItems.empty() ) //
{
MAP_EXCHANGE_ITEM::iterator it = m_mapExchangeItems.find( dwKey ); //
if( it != m_mapExchangeItems.end() )
{
m_mapExchangeItems.erase( it );
return TRUE;
}
}
return FALSE;
}

BOOL CExchangeMng::LoadScript()
{
CScript s;
if( !s.Load( "ExchangeAdv.inc" ))
{
Error( "ExchangeAdv.inc was not found." );
return FALSE;
}
DWORD dwItemId, dwItemNeed;
int nPrice;
TCHAR szNpcKey[32];
short nItemNum;
s.GetToken();
DWORD dwKey = 0; //
if( s.Token == _T( "AddExchangeItems" ) )
{
s.GetToken(); // {
s.GetToken(); // {
while( s.tok != FINISHED )
{
strcpy( szNpcKey, s.Token );
while( *s.token != ';' && szNpcKey && szNpcKey[0] != '}')
{
s.GetToken();
if( s.Token == _T( "AddItem" ) )
{
s.GetToken(); // (
dwItemId = s.GetNumber();
s.GetToken(); // ,
nItemNum = s.GetNumber();
s.GetToken(); // ,
dwItemNeed = s.GetNumber();
s.GetToken(); // ,
nPrice = s.GetNumber();
s.GetToken(); // )
InsertItem( dwKey++, dwItemId, nPrice, dwItemNeed, szNpcKey, nItemNum );
//Error(" %s - AddItem( %d, %d, %d, %d )", szNpcKey, dwItemId, nItemNum, dwItemNeed, nPrice );
}
}
s.GetToken();
}
}
return TRUE;
}

//EXCHANGE_ITEM* CExchangeMng::FindExchangeItem( DWORD dwItemId, const char* szNpcKeyName )
EXCHANGE_ITEM* CExchangeMng::FindExchangeItem( DWORD dwKey, const char* szNpcKeyName ) //
{
if( m_mapExchangeItems.size() )
{
MAP_EXCHANGE_ITEM::iterator it = m_mapExchangeItems.find( dwKey ); //
if( it != m_mapExchangeItems.end() )
{
if( it->second /*&& it->second->m_dwItemId == dwItemId */ && strcmp( it->second->m_szNpcKeyName, szNpcKeyName ) == NULL )
return it->second;
}
}
return NULL;
}

vector< EXCHANGE_ITEM* > CExchangeMng::GetAllNpcItemsByKey( const char* szNpcKeyName )
{
vector< EXCHANGE_ITEM* > vec;
for( MAP_EXCHANGE_ITEM::iterator it = m_mapExchangeItems.begin(); it!=m_mapExchangeItems.end(); ++it )
{
if( !it->second )
continue;

if( strcmp( it->second->m_szNpcKeyName, szNpcKeyName ) == NULL )
vec.push_back( it->second );
}
return vec;
}

EXCHANGE_ITEM::EXCHANGE_ITEM( DWORD dwItemId, int nPrice, DWORD dwItemNeed, const char* szNpcKeyName, short nItemNum, DWORD dwKey )
{
m_dwItemId = dwItemId;
m_dwItemNeed = dwItemNeed;
m_nPrice = nPrice;
m_nItemNum = nItemNum;
m_dwKey = dwKey;
strcpy( m_szNpcKeyName, szNpcKeyName );
}
#ifdef __WORLDSERVER
//
//BOOL CExchangeMng:oExchange( CUser* pUser, DWORD dwItemId )
BOOL CExchangeMng:oExchange( CUser * pUser, DWORD dwKey )
{
//MAP_EXCHANGE_ITEM::iterator it = m_mapExchangeItems.find( dwItemId );
MAP_EXCHANGE_ITEM::iterator it = m_mapExchangeItems.find( dwKey );
if( it != m_mapExchangeItems.end() )
{
EXCHANGE_ITEM* pExchangeItem = it->second;
if( pExchangeItem )
{
if( pUser->m_Inventory.GetItemCount( pExchangeItem->m_dwItemNeed ) < pExchangeItem->m_nPrice )
{
pUser->AddText( "You haven't enough items." );
return FALSE;
}
int nPrice = pExchangeItem->m_nPrice;
if( nPrice > SHRT_MAX )
{
while( nPrice > SHRT_MAX )
{
pUser->RemoveItemA( pExchangeItem->m_dwItemNeed, SHRT_MAX );
nPrice -= SHRT_MAX;
}
}

pUser->RemoveItemA( pExchangeItem->m_dwItemNeed, nPrice );
CItemElem item;
item.m_dwItemId = pExchangeItem->m_dwItemId;
item.m_nItemNum = pExchangeItem->m_nItemNum;
item.SetSerialNumber();
char szMsg[512];
if( !pUser->CreateItem( &item ) )
{
g_dpDBClient.SendQueryPostMail( pUser->m_idPlayer, NULL, item, NULL, "Your exchange item", "There is your exchange item! \n We wish you \n a lot of fun! \n Greetings, V" );
sprintf( szMsg, "You have received the Item ( %s ) by post", item.GetProp()->szName );
}
else
sprintf( szMsg, "The item %s was placed in your inventory.", item.GetProp()->szName );

pUser->AddText( szMsg );
return TRUE;
}
}
return FALSE;
}

#endif
#ifdef __CLIENT
CWndExchangeAdv::CWndExchangeAdv( const char* szNpcKey )
{
m_nSelected = -1;
m_nListedItems = NULL;
m_bFirstTime = TRUE;
strcpy( m_szNpcKey, szNpcKey );
}

CWndExchangeAdv::~CWndExchangeAdv()
{

}
void CWndExchangeAdv::OnDraw( C2DRender* p2DRender )
{
if( !g_pPlayer )
Destroy();

m_nListedItems = NULL;
LPWNDCTRL lpCtrl = GetWndCtrl( WIDC_LISTBOX1 );
int x, y;
x = lpCtrl->rect.TopLeft().x + 8;
y = lpCtrl->rect.TopLeft().y + 8;
u_int i = m_pListBox->GetScrollPos();
//for( int i=0; i<m_pListBox->GetScrollPos(); i++ )
// ++i;

int nCount = NULL;
for(; i<m_vecNPCItems.size(); i++ )
{
EXCHANGE_ITEM* pExchangeItem = m_vecNPCItems[i];
if( pExchangeItem )
{
ItemProp* pItemProp = prj.GetItemProp( pExchangeItem->m_dwItemNeed );
if( !pItemProp )
continue;

if( nCount > 6 )
continue;

PutInfos( p2DRender, pExchangeItem, pItemProp, x, y );
y+= 32;
p2DRender->RenderLine( CPoint( x, y ), CPoint( lpCtrl->rect.right-20, y ), D3DCOLOR_ARGB( 255, 0, 0, 0 ) );
CPoint point = GetMousePoint();
if( pExchangeItem->m_Rect[0].PtInRect( point ) )
{
CRect hitrect = pExchangeItem->m_Rect[0];
CPoint point2 = point;
ClientToScreen( &point2 );
ClientToScreen( &hitrect );
CItemElem elem;
elem.m_dwItemId = pExchangeItem->m_dwItemId;
elem.SetSerialNumber();
g_WndMng.PutToolTip_Item( &elem, point2, &hitrect );
}
else
if( pExchangeItem->m_Rect[1].PtInRect( point ))
{
CRect hitrect = pExchangeItem->m_Rect[1];
CPoint point2 = point;
ClientToScreen( &point2 );
ClientToScreen( &hitrect );
CItemElem elem;
elem.m_dwItemId = pExchangeItem->m_dwItemNeed;
elem.SetSerialNumber();
g_WndMng.PutToolTip_Item( &elem, point2, &hitrect );
}
if( pExchangeItem->m_nListIndex == m_nSelected )
{
p2DRender->RenderFillRect( pExchangeItem->m_Rect[1], D3DCOLOR_ARGB( 110, 80, 250, 80 ) );
p2DRender->RenderFillRect( pExchangeItem->m_Rect[0], D3DCOLOR_ARGB( 110, 80, 250, 80 ) );
// p2DRender->RenderFillRect( pExchangeItem->m_Rect[1], 0xFF85FF8A );
// p2DRender->RenderFillRect( pExchangeItem->m_Rect[0], 0xFF85FF8A );

}

nCount++;
}
}

if( m_bFirstTime )
{
if( m_nListedItems > 0 )
{
m_pListBox->m_wndScrollBar.SetScrollRange( 0, m_nListedItems );
if( m_nListedItems < 6 )
m_pListBox->m_wndScrollBar.SetScrollPage( m_nListedItems );
else
m_pListBox->m_wndScrollBar.SetScrollPage( 6 );
}
else
{
m_pListBox->m_wndScrollBar.SetScrollRange( 0, 1 );
m_pListBox->m_wndScrollBar.SetScrollPage( 1 );
}


for( int i=0; i<(int)m_vecNPCItems.size()*2; i++ )
m_pListBox->AddString( "" );

std::sort( m_vecNPCItems.begin(), m_vecNPCItems.end(), OrderByItemKind );
}
m_bFirstTime = FALSE;
}

void CWndExchangeAdv::PutInfos( C2DRender* p2D, EXCHANGE_ITEM* pExchangeItem, ItemProp* pItemProp, int x, int y )
{
char szCount[18];
sprintf( szCount, "%d", pExchangeItem->m_nPrice );
CSize size = m_p2DRender->m_pFont->GetTextExtent( szCount );
pExchangeItem->m_Rect[1] = CRect( x, y, x+32, y+32 );
pExchangeItem->m_Rect[0] = CRect( x+32, y, x+342, y+32 );
RenderIcon( p2D, MakePath( DIR_ITEM, pItemProp->szIcon ), x, y );
p2D->TextOut( x + 39 - size.cx, y + 35 - size.cy, pExchangeItem->m_nPrice, 0xffffffff );
x+= 30;
pItemProp = prj.GetItemProp( pExchangeItem->m_dwItemId );
if( !pItemProp )
return;

x+=35;
RenderIcon( p2D, MakePath( DIR_THEME, "ExchangeArrow.tga" ), x+20, y+2 );
x+= 100;
RenderIcon( p2D, MakePath( DIR_ITEM, pItemProp->szIcon ), x, y );
sprintf( szCount, "%d", pExchangeItem->m_nItemNum );
size = m_p2DRender->m_pFont->GetTextExtent( szCount );
p2D->TextOut( x + 39 - size.cx, y + 35 - size.cy, szCount, 0xffffffff );
pExchangeItem->m_nListIndex = m_nListedItems;
m_nListedItems++;
}

void CWndExchangeAdv::RenderIcon( C2DRender* p2D, CString strPath, int x, int y )
{
CTexture* pTexture = CWndBase::m_textureMng.AddTexture( D3DDEVICE, strPath, 0xffff00ff );
if( pTexture )
pTexture->Render( p2D, CPoint( x, y ), 255 );
}

EXCHANGE_ITEM* CWndExchangeAdv::GetExchangeItemByListIndex( int nIndex )
{
u_int i = m_pListBox->GetScrollPos();
for(; i<m_vecNPCItems.size(); i++ )
{
EXCHANGE_ITEM* pItem = m_vecNPCItems[i];
if( !pItem )
continue;

if( nIndex == pItem->m_nListIndex )
return pItem;
}
return NULL;
}

void CWndExchangeAdv::OnLButtonDblClk( UINT nFlags, CPoint point )
{
EXCHANGE_ITEM* pItem = GetExchangeItemByListIndex( m_nSelected );
if( pItem )
{
CWndExchangeAdvConfirm* pConfirm = (CWndExchangeAdvConfirm*)g_WndMng.GetApplet( APP_EXCHANGE_ADV_CONFIRM );
if( pConfirm )
pConfirm->Destroy();

pConfirm = new CWndExchangeAdvConfirm( pItem );
pConfirm->Initialize( &g_WndMng );
Destroy();
}
}

void CWndExchangeAdv::OnLButtonDown( UINT nFlags, CPoint point )
{
LPWNDCTRL lpCtrl = GetWndCtrl( WIDC_LISTBOX1 );
if( !lpCtrl->rect.PtInRect( GetMousePoint() ) )
return;

for( u_int i=0; i<m_vecNPCItems.size(); i++ )
{
if( m_vecNPCItems[i] )
{
if( PtInRect( &m_vecNPCItems[i]->m_Rect[0], GetMousePoint() ) || PtInRect( &m_vecNPCItems[i]->m_Rect[1], GetMousePoint() ) )
{
m_nSelected = m_vecNPCItems[i]->m_nListIndex;
break;
}
}
}
}

void CWndExchangeAdv::OnLButtonUp( UINT nFlags, CPoint point )
{
LPWNDCTRL lpCtrl = GetWndCtrl( WIDC_LISTBOX1 );
if( !lpCtrl->rect.PtInRect( GetMousePoint() ) )
return;

for( u_int i=0; i<m_vecNPCItems.size(); i++ )
{
if( m_vecNPCItems[i] )
{
if( PtInRect( &m_vecNPCItems[i]->m_Rect[0], GetMousePoint() ) || PtInRect( &m_vecNPCItems[i]->m_Rect[1], GetMousePoint() ) )
{
m_nSelected = m_vecNPCItems[i]->m_nListIndex;
break;
}
}
}
}

BOOL CWndExchangeAdv::OnDropIcon( LPSHORTCUT pShortcut, CPoint point )
{
return TRUE;
}

void CWndExchangeAdv::OnInitialUpdate()
{
CWndNeuz::OnInitialUpdate();
m_pListBox = (CWndListBox*)GetDlgItem( WIDC_LISTBOX1 );

m_vecNPCItems = g_ExchangeAdv->GetAllNpcItemsByKey( m_szNpcKey );
MoveParentCenter();
}
BOOL CWndExchangeAdv::Initialize( CWndBase* pWndParent, DWORD /*dwWndId*/ )
{
return CWndNeuz::InitDialog( g_Neuz.GetSafeHwnd(), APP_EXCHANGE_ADV, 0, CPoint( 0, 0 ), pWndParent );
}

BOOL CWndExchangeAdv::OnCommand( UINT nID, DWORD dwMessage, CWndBase* pWndBase )
{
return CWndNeuz::OnCommand( nID, dwMessage, pWndBase );
}
void CWndExchangeAdv::OnSize( UINT nType, int cx, int cy )
{
CWndNeuz::OnSize( nType, cx, cy );
}
BOOL CWndExchangeAdv::OnMouseWheel( UINT nFlags, short zDelta, CPoint pt )
{
if( zDelta < 0 )
{
if( m_pListBox->m_wndScrollBar.GetMaxScrollPos() - m_pListBox->m_wndScrollBar.GetScrollPage() > m_pListBox->m_wndScrollBar.GetScrollPos() )
m_pListBox->m_wndScrollBar.SetScrollPos( m_pListBox->m_wndScrollBar.GetScrollPos()+1 );
else
m_pListBox->m_wndScrollBar.SetScrollPos( m_pListBox->m_wndScrollBar.GetMaxScrollPos() - m_pListBox->m_wndScrollBar.GetScrollPage() );
}
else
{
if( m_pListBox->m_wndScrollBar.GetMinScrollPos() < m_pListBox->m_wndScrollBar.GetScrollPos() )
m_pListBox->m_wndScrollBar.SetScrollPos( m_pListBox->m_wndScrollBar.GetScrollPos()-1 );
else
m_pListBox->m_wndScrollBar.SetScrollPos( m_pListBox->m_wndScrollBar.GetMinScrollPos() );
}

return TRUE;
}
BOOL CWndExchangeAdv::OnChildNotify( UINT message, UINT nID, LRESULT* pLResult )
{
return CWndNeuz::OnChildNotify( message, nID, pLResult );
}

// confirm window
CWndExchangeAdvConfirm::CWndExchangeAdvConfirm( EXCHANGE_ITEM* pItem )
{
m_pExchangeItem = pItem;
}

CWndExchangeAdvConfirm::~CWndExchangeAdvConfirm()
{
SAFE_DELETE( m_pExchangeItem );
}
void CWndExchangeAdvConfirm::OnDraw( C2DRender* p2DRender )
{
if( !g_pPlayer )
Destroy();

char szText[128];
ItemProp* pItemProp[2];
CTexture* pTexture = NULL;
LPWNDCTRL lpStatic = GetWndCtrl( WIDC_STATIC1 );
CWndStatic* pWndStatic = (CWndStatic*)GetDlgItem( WIDC_STATIC2 );
if( pWndStatic && m_pExchangeItem )
{
pItemProp[0] = prj.GetItemProp( m_pExchangeItem->m_dwItemNeed );
pItemProp[1] = prj.GetItemProp( m_pExchangeItem->m_dwItemId );
if( pItemProp[1] && pItemProp[0] )
{
pTexture = CWndBase::m_textureMng.AddTexture( D3DDEVICE, MakePath( DIR_ITEM, pItemProp[0]->szIcon ), 0xffff00ff );
if( pTexture )
pTexture->Render( p2DRender, lpStatic->rect.TopLeft(), 255 );

sprintf( szText, " Du erhaelst: %s\nDas folgende Item wird entfernt :%s Anzahl:%dx", pItemProp[1]->szName, pItemProp[0]->szName, m_pExchangeItem->m_nPrice );
pWndStatic->SetTitle( szText );
pWndStatic->m_dwColor = D3DCOLOR_ARGB( 255, 255, 50, 50 );
CPoint point = GetMousePoint();
if( PtInRect( &lpStatic->rect, point ))
{
CRect hitrect = lpStatic->rect;
CPoint point2 = point;
ClientToScreen( &point2 );
ClientToScreen( &hitrect );
CItemElem elem;
elem.m_dwItemId = pItemProp[0]->dwID;
elem.SetSerialNumber();
g_WndMng.PutToolTip_Item( &elem, point2, &hitrect );
}
}
}
}

void CWndExchangeAdvConfirm::OnInitialUpdate()
{
CWndNeuz::OnInitialUpdate();

MoveParentCenter();
}
BOOL CWndExchangeAdvConfirm::Initialize( CWndBase* pWndParent, DWORD /*dwWndId*/ )
{
return CWndNeuz::InitDialog( g_Neuz.GetSafeHwnd(), APP_EXCHANGE_ADV_CONFIRM, 0, CPoint( 0, 0 ), pWndParent );
}

BOOL CWndExchangeAdvConfirm::OnCommand( UINT nID, DWORD dwMessage, CWndBase* pWndBase )
{
return CWndNeuz::OnCommand( nID, dwMessage, pWndBase );
}
void CWndExchangeAdvConfirm::OnSize( UINT nType, int cx, int cy )
{
CWndNeuz::OnSize( nType, cx, cy );
}

BOOL CWndExchangeAdvConfirm::OnChildNotify( UINT message, UINT nID, LRESULT* pLResult )
{
switch( nID )
{
case WIDC_BUTTON1: g_DPlay.SendExchangeAdv( m_pExchangeItem->m_dwKey ); Destroy(); break;
case WIDC_BUTTON2: Destroy(); break;
}
return CWndNeuz::OnChildNotify( message, nID, pLResult );
}
#endif
#endif

Error in line: if( pUser->m_Inventory.GetItemCount( pExchangeItem->m_dwItemNeed ) < pExchangeItem->m_nPrice )

Pocket.h

 Spoiler

#ifndef __POCKET_H__
#define __POCKET_H__

#if defined(__WORLDSERVER) || defined(__CLIENT)
#include "item.h"
#endif // __WORLDSERVER || __CLIENT

#include "ar.h"

class CPocket : public CItemContainer<CItemElem>
{
public:
// Constructions
CPocket();
virtual ~CPocket();

// Attributes
void SetExpired( BOOL bExpired ) { m_bExpired = bExpired; }
BOOL IsExpired( void ) { return m_bExpired; }
void SetExpirationDate( time_t tExpirationDate ) { m_tExpirationDate = tExpirationDate; }
time_t GetExpirationDate( void ) { return m_tExpirationDate; }
void Copy( CPocket & rPocket );
// Operations
void Serialize( CAr & ar );

private:
BOOL m_bExpired;
time_t m_tExpirationDate;
};

#define MAX_POCKET 3
#define POCKET_SLOT_SIZE_0 6
#define POCKET_SLOT_SIZE_1_2 24

typedef struct _PocketController_Result
{
int nPocket;
int nItem;
int nNum;
_PocketController_Result( int p, int i, int n )
{
nPocket = p;
nItem = i;
nNum = n;
}
} PocketController_Result;

class CPocketController
{
public:
// Constructions
CPocketController();
virtual ~CPocketController();
#ifdef __WORLDSERVER
void Init( CMover* pMover ) { m_pMover = pMover; }
#endif // __WORLDSERVER
void Clear( void );
// Operations
CItemElem* GetAtId( int nPocket, int nItem, BOOL bExpiration = TRUE );
// BOOL Add( CItemElem* pItemElem, vector<PocketController_Result>* apResult );
BOOL Add( int nPocket, CItemElem*pItemElem, vector<PocketController_Result>* apResult = NULL );
BOOL RemoveAtId( int nPocket, int nItem, int nNum ); // if nNum < 0, remove all.
int RemoveItem( DWORD dwItemId, int nNum );

int GetEmptyCount( void );
BOOL IsAllClean( void );
int GetCount( DWORD dwItemId );

BOOL IsAvailable( int nPocket, BOOL bExpiration = TRUE )
{ return( m_apPocket[nPocket] && ( !bExpiration || !m_apPocket[nPocket]->IsExpired() ) ); }
void Avail( int nPocket, time_t t = 0 );

enum { expired, avail, };
void SetAttribute( int nAttribute, int nPocket, int nData );
time_t GetAvailable( int nPocket );

void Copy( CPocketController & rPocketController );
void Serialize( CAr & ar );

#ifdef __WORLDSERVER
void ProcessExpiring( void );
#endif // __WORLDSERVER
CPocket* GetPocket( int nPocket );

#ifdef __CLIENT
CItemElem* GetAt( int nPocket, int nIndex );
#endif // __CLIENT

private:
#ifdef __WORLDSERVER
CMover* m_pMover;
#endif // __WORLDSERVER
CPocket* m_apPocket[MAX_POCKET];
};
#endif // __POCKET_H__

Error in line: class CPocket : public CItemContainer<CItemElem>

Thanks all =)
*Using vs17.

[Tweeney]

Ok, let's see. let's go to your error

note: consulte a declaração de 'CItemContainer<CItemElem>'

Hmm. I think it is on Item.h now lets search

 template <class T> class CItemContainer

Then let's scroll down and find " GetItemCount "

Oh, I see it.

	DWORD	Find( DWORD dwItemId )
		{
			if( dwItemId == 0 )
				return NULL_ID;
			for( int i = 0; i < (int)( m_dwIndexNum ); i++ )
			{
				DWORD nId	= m_apIndex[i];
				if( nId < 0 || nId >= m_dwItemMax )
					continue;
				if( m_apItem[nId].m_dwItemId == dwItemId )
					return nId;
			}
			return NULL_ID;
		}	
	DWORD	GetItemCount( DWORD dwItemId )
		{
			if( dwItemId == 0 )
				return 0;
			int nCount	= 0;
			for( int i = 0; i < (int)( m_dwItemMax ); i++ )
			{
				CItemElem* pItemElem	= (CItemElem*)&m_apItem[i];
				if( pItemElem->m_dwItemId == dwItemId )
					nCount	+= pItemElem->m_nItemNum;
			}
			return( nCount );
		}
#endif	// __JEFF_VER_8
#endif	// __CLIENT

Now let's try this

	DWORD	Find( DWORD dwItemId )
		{
			if( dwItemId == 0 )
				return NULL_ID;
			for( int i = 0; i < (int)( m_dwIndexNum ); i++ )
			{
				DWORD nId	= m_apIndex[i];
				if( nId < 0 || nId >= m_dwItemMax )
					continue;
				if( m_apItem[nId].m_dwItemId == dwItemId )
					return nId;
			}
			return NULL_ID;
		}	
#endif	// __JEFF_VER_8
#endif	// __CLIENT
	DWORD	GetItemCount( DWORD dwItemId )
		{
			if( dwItemId == 0 )
				return 0;
			int nCount	= 0;
			for( int i = 0; i < (int)( m_dwItemMax ); i++ )
			{
				CItemElem* pItemElem	= (CItemElem*)&m_apItem[i];
				if( pItemElem->m_dwItemId == dwItemId )
					nCount	+= pItemElem->m_nItemNum;
			}
			return( nCount );
		}

Hope its help