835 lines
18 KiB
C++
835 lines
18 KiB
C++
#include "stdafx.h"
|
|
#include "SItemDB.h"
|
|
|
|
#include <Windows.h>
|
|
#include <kfile/KStream.h>
|
|
#include "KTypes.h"
|
|
#include <kfile/KFileManager.h>
|
|
#include <toolkit/XStringUtil.h>
|
|
//#include "Util.h"
|
|
#include "SStringDB.h"
|
|
#include "GameDefine.h"
|
|
|
|
#include "Slog.h"
|
|
#include <tchar.h>
|
|
|
|
#ifdef _DEV
|
|
#include "KResourceManager.h"
|
|
#endif
|
|
|
|
#include "SDebug_Util.h"
|
|
|
|
SItemReferenceDB::SItemReferenceDB()
|
|
{
|
|
Init();
|
|
}
|
|
|
|
SItemReferenceDB::~SItemReferenceDB()
|
|
{
|
|
Destroy();
|
|
}
|
|
|
|
void SItemReferenceDB::Init()
|
|
{
|
|
Load();
|
|
}
|
|
|
|
void SItemReferenceDB::Destroy()
|
|
{
|
|
SAFE_DELETE_VECTOR( m_ItemReferenceList );
|
|
}
|
|
|
|
void SItemReferenceDB::Load()
|
|
{
|
|
KStream * pRes = KFileManager::Instance().CreateStreamFromResource("db_item.ref");
|
|
if (!pRes) return;
|
|
int nCount = 0;
|
|
int nKey = 0;
|
|
|
|
pRes->Read( &nCount, sizeof(nCount) );
|
|
pRes->Read( &nKey, sizeof(nKey) );
|
|
|
|
for ( int i(0); nCount > i; i++ )
|
|
{
|
|
char* szText = new char[nKey];
|
|
|
|
pRes->Read( szText, sizeof( char ) * nKey );
|
|
m_ItemReferenceList.push_back( szText );
|
|
}
|
|
|
|
KFileManager::Instance().DeleteStream( pRes );
|
|
}
|
|
|
|
void SItemReferenceDB::SetInfo( ItemBaseEx_info_Client * pBase, ItemBaseEx * nBase )
|
|
{
|
|
pBase->pModel00 = allocString( GetReference(nBase->model00) );
|
|
pBase->pModel01 = allocString( GetReference(nBase->model01) );
|
|
pBase->pModel02 = allocString( GetReference(nBase->model02) );
|
|
pBase->pModel03 = allocString( GetReference(nBase->model03) );
|
|
pBase->pModel04 = allocString( GetReference(nBase->model04) );
|
|
pBase->pModel05 = allocString( GetReference(nBase->model05) );
|
|
pBase->pModel06 = allocString( GetReference(nBase->model06) );
|
|
pBase->pModel07 = allocString( GetReference(nBase->model07) );
|
|
pBase->pModel08 = allocString( GetReference(nBase->model08) );
|
|
pBase->pModel09 = allocString( GetReference(nBase->model09) );
|
|
pBase->pModel10 = allocString( GetReference(nBase->model10) );
|
|
pBase->pModel11 = allocString( GetReference(nBase->model11) );
|
|
pBase->pModel12 = allocString( GetReference(nBase->model12) );
|
|
pBase->pModel13 = allocString( GetReference(nBase->model13) );
|
|
pBase->pModel14 = allocString( GetReference(nBase->model14) );
|
|
pBase->pModel15 = allocString( GetReference(nBase->model15) );
|
|
pBase->pModel16 = allocString( GetReference(nBase->model16) );
|
|
pBase->pModel17 = allocString( GetReference(nBase->model17) );
|
|
if(nBase->icon_file_name != -1)
|
|
pBase->pIcon_name = allocString( GetReference(nBase->icon_file_name) );
|
|
else
|
|
pBase->pIcon_name = allocString( "static_enhance_failed_item" );
|
|
pBase->pDrop_model = allocString( GetReference(nBase->drop_model) );
|
|
pBase->pTexture_filename = allocString( GetReference(nBase->texture_filename) );
|
|
}
|
|
|
|
const char * SItemReferenceDB::GetReference( int nIndex )
|
|
{
|
|
if (m_ItemReferenceList.empty()) return c_szNotFound;
|
|
|
|
if (0 < nIndex && nIndex <= (int)m_ItemReferenceList.size())
|
|
{
|
|
return m_ItemReferenceList[nIndex];
|
|
}
|
|
return "";
|
|
}
|
|
|
|
SItemReferenceDB* SItemReferenceDB::m_pThis = NULL;
|
|
SItemReferenceDB & GetItemReferenceDB()
|
|
{
|
|
if (NULL == SItemReferenceDB::m_pThis)
|
|
SItemReferenceDB::m_pThis = new SItemReferenceDB;
|
|
|
|
return *SItemReferenceDB::m_pThis;
|
|
}
|
|
|
|
SItemDB::SItemDB() : m_pDummyData( NULL )
|
|
{
|
|
Init();
|
|
}
|
|
|
|
SItemDB::~SItemDB()
|
|
{
|
|
Destroy();
|
|
}
|
|
|
|
bool SItemDB::IsWearable( ENC_INT nItemID, int nJobID, int nRace, int nLevel )
|
|
{
|
|
const ItemBaseEx_info* pItem = GetItemDB().GetItemData( nItemID );
|
|
return IsWearable( pItem, nJobID, nRace, nLevel );
|
|
}
|
|
|
|
bool SItemDB::IsWearable( const ItemBaseEx_info* pItem, int nJobID, int nRace, int nLevel )
|
|
{
|
|
// 장비품 아님
|
|
if( pItem->WearType == ItemBase::WEAR_CANTWEAR && pItem->nCode != 804000 )
|
|
{
|
|
return false;
|
|
}
|
|
|
|
if( GetItemDB().IsWearablebyRace( pItem, nRace ) == false )
|
|
{
|
|
return false;
|
|
}
|
|
|
|
if( GetItemDB().IsWearablebyJob( pItem, nJobID, nRace ) == false )
|
|
{
|
|
return false;
|
|
}
|
|
|
|
if( GetItemDB().IsWearablebyJobDepth( pItem, nJobID ) == false )
|
|
{
|
|
return false;
|
|
}
|
|
|
|
if( GetItemDB().IsWearablebyLevel( pItem, nLevel ) == false )
|
|
{
|
|
return false;
|
|
}
|
|
|
|
return true;
|
|
}
|
|
|
|
SItemDB::ITEM_ENHANCE_LEVEL SItemDB::CheckItemLevel( int nItemLevel )
|
|
{
|
|
if( nItemLevel >= 0 && nItemLevel <= 5 )
|
|
return LEVEL_1;
|
|
else if( nItemLevel >= 6 && nItemLevel <= 9 )
|
|
return LEVEL_2;
|
|
else if( nItemLevel >= 10 )
|
|
return LEVEL_3;
|
|
|
|
return LEVEL_MAX;
|
|
}
|
|
|
|
void SItemDB::Init()
|
|
{
|
|
Load();
|
|
|
|
m_pDummyData = new ItemBaseEx_info_Client;
|
|
::ZeroMemory( m_pDummyData, sizeof(ItemBaseEx_info_Client) );
|
|
|
|
ItemBaseEx itembaseex;
|
|
|
|
itembaseex.icon_id = (-1);
|
|
itembaseex.icon_file_name = -1;
|
|
itembaseex.model00 = 0;
|
|
itembaseex.model01 = 0;
|
|
itembaseex.model02 = 0;
|
|
itembaseex.model03 = 0;
|
|
itembaseex.model04 = 0;
|
|
itembaseex.model05 = 0;
|
|
itembaseex.model06 = 0;
|
|
itembaseex.model07 = 0;
|
|
itembaseex.model08 = 0;
|
|
itembaseex.model09 = 0;
|
|
itembaseex.model10 = 0;
|
|
itembaseex.model11 = 0;
|
|
itembaseex.model12 = 0;
|
|
itembaseex.model13 = 0;
|
|
itembaseex.model14 = 0;
|
|
itembaseex.model15 = 0;
|
|
itembaseex.model16 = 0;
|
|
itembaseex.model17 = 0;
|
|
itembaseex.drop_model = 0;
|
|
itembaseex.texture_filename = 0;
|
|
|
|
m_pDummyData->SetInfo( &itembaseex );
|
|
GetItemReferenceDB().SetInfo( m_pDummyData, &itembaseex );
|
|
}
|
|
|
|
void SItemDB::Destroy()
|
|
{
|
|
SAFE_DELETE( m_pDummyData );
|
|
|
|
ItemBaseEx_info_Client* pItem = NULL;
|
|
bool res;
|
|
res = m_hashItem.get_first_value( pItem );
|
|
while ( res )
|
|
{
|
|
if ( pItem != NULL )
|
|
{
|
|
delete pItem;
|
|
}
|
|
res = m_hashItem.get_next_value( pItem );
|
|
}
|
|
m_hashItem.clear();
|
|
}
|
|
|
|
const std::vector< ItemEnhanceEffectBase >& SItemDB::Find(int nEnhanceID)
|
|
{
|
|
auto pos = m_mapEnhanceEffect.find(nEnhanceID);
|
|
if (pos != m_mapEnhanceEffect.end())
|
|
{
|
|
return pos->second;
|
|
}
|
|
|
|
static std::vector< ItemEnhanceEffectBase > empty_list;
|
|
return empty_list;
|
|
}
|
|
|
|
void SItemDB::Load()
|
|
{
|
|
KStream * pRes = KFileManager::Instance().CreateStreamFromResource( "db_item.rdb" );
|
|
if( !pRes ) return;
|
|
GAME_DB db_hdr;
|
|
|
|
pRes->Read( &db_hdr, sizeof(db_hdr) );
|
|
|
|
ItemBaseEx item;
|
|
for( int i(0); db_hdr.nCount>i; i++ )
|
|
{
|
|
memset( &item, 0, sizeof(item) );
|
|
pRes->Read( &item, sizeof(item) );
|
|
|
|
ItemBaseEx_info_Client * pFindItem = NULL;
|
|
|
|
ItemBaseEx_info_Client * pItem = new ItemBaseEx_info_Client;
|
|
::memset(pItem, 0x00, sizeof(ItemBaseEx_info_Client)); //초기화가 없어서 쓰레기값 들어있음 -N4-
|
|
pItem->SetInfo( &item );
|
|
|
|
GetItemReferenceDB().SetInfo( pItem, &item );
|
|
|
|
if (pItem->nEnhanceID > 0)
|
|
{
|
|
std::vector< ItemEnhanceEffectBase > v;
|
|
|
|
item.SetInfo(pItem->nEnhanceID, &v);
|
|
m_mapEnhanceEffect.insert(std::make_pair(pItem->nEnhanceID, v));
|
|
}
|
|
|
|
pItem->real_uid = pItem->nCode;
|
|
|
|
#ifdef _DEV
|
|
|
|
if(KSpriteManager::GetManager()->GetResSpriteAni("ui_frame.spr", pItem->pIcon_name) == NULL)
|
|
{
|
|
GetLog().DebugLog( "ItemDB - spr에 icon 파일이 등록되지 않았습니다 - id:%d / icon id:%d / %s \n",pItem->nCode, pItem->icon_id,pItem->pIcon_name );
|
|
}
|
|
|
|
#endif
|
|
|
|
pItem->nCode = XFastRandom();
|
|
|
|
// 7랭크 세트 아이템을 제외한 세트 아이템 목록 저장
|
|
if( pItem->set_id
|
|
&& pItem->nRank != 7 )
|
|
{
|
|
m_vSetItem.push_back(pItem);
|
|
}
|
|
|
|
|
|
if( m_hashItem.lookup( pItem->real_uid, pFindItem ) == false )
|
|
{
|
|
m_hashItem.add( pItem->real_uid, pItem );
|
|
}
|
|
else
|
|
{
|
|
//_oprint( "!!!!Data Error Item Code 가 중복되었습니다.!!!!\n" );
|
|
GetLog().DebugLog( "!!!!Data Error Item Code 가 중복되었습니다.!!!!\n" );
|
|
|
|
// assert(0); //기획팀에 알려 주세여. 바로 수정 해야 합니다.
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
}
|
|
|
|
KFileManager::Instance().DeleteStream( pRes );
|
|
}
|
|
|
|
vector<ITEMIDENTITYFORDEV> SItemDB::GetItemIdentityList( string strFindItemName )
|
|
{
|
|
vector<ITEMIDENTITYFORDEV> vecItemIdentity;
|
|
|
|
#ifdef _DEV
|
|
KHash< struct ItemBaseEx_info_Client*, hashPr_mod_ENC_INT>::node* _node = NULL;
|
|
|
|
bool bResult = m_hashItem.get_first_node( _node );
|
|
while ( bResult )
|
|
{
|
|
ItemBaseEx_info_Client* pItem( _node->value );
|
|
|
|
if( pItem )
|
|
{
|
|
string strItemName( S( pItem->nNameId ) );
|
|
|
|
size_t found = strItemName.find( strFindItemName );
|
|
|
|
if (found != string::npos)
|
|
{
|
|
ITEMIDENTITYFORDEV stItemIdentityForDev;
|
|
|
|
stItemIdentityForDev.m_uItemID = pItem->real_uid.value();
|
|
stItemIdentityForDev.m_strItemName = strItemName;
|
|
|
|
vecItemIdentity.push_back( stItemIdentityForDev );
|
|
}
|
|
}
|
|
|
|
bResult = m_hashItem.get_next_node( _node );
|
|
}
|
|
#endif
|
|
|
|
return vecItemIdentity;
|
|
}
|
|
|
|
SItemDB* SItemDB::m_pThis = NULL;
|
|
SItemDB & GetItemDB()
|
|
{
|
|
// static SItemDB itemdb;
|
|
if( NULL == SItemDB::m_pThis )
|
|
SItemDB::m_pThis = new SItemDB;
|
|
|
|
return *SItemDB::m_pThis;
|
|
// return itemdb;
|
|
}
|
|
|
|
//////////////////////////////////////////////////////////////////////////
|
|
//FaceWink Data
|
|
|
|
SFaceWinkDB::SFaceWinkDB()
|
|
{
|
|
Init();
|
|
}
|
|
|
|
SFaceWinkDB::~SFaceWinkDB()
|
|
{
|
|
Destroy();
|
|
}
|
|
|
|
void SFaceWinkDB::Init()
|
|
{
|
|
Load();
|
|
}
|
|
|
|
void SFaceWinkDB::Destroy()
|
|
{
|
|
FaceWinkData* pData = NULL;
|
|
bool res;
|
|
res = m_hashFaceWinkRes.get_first_value( pData );
|
|
while ( res )
|
|
{
|
|
if ( pData != NULL )
|
|
{
|
|
delete pData;
|
|
}
|
|
res = m_hashFaceWinkRes.get_next_value( pData );
|
|
}
|
|
m_hashFaceWinkRes.clear();
|
|
}
|
|
|
|
void SFaceWinkDB::Load()
|
|
{
|
|
KStream * pRes = KFileManager::Instance().CreateStreamFromResource( "FaceWinkDB.txt" );
|
|
if( !pRes ) return;
|
|
|
|
size_t nLen = pRes->GetLength();
|
|
char * pstrTemp = new char[nLen+1];
|
|
pstrTemp[nLen] = '\0';
|
|
for( size_t i(0); nLen>i; i++ )
|
|
{
|
|
pRes->Read( &pstrTemp[i], 1 );
|
|
}
|
|
|
|
std::vector< std::string > vString;
|
|
XStringUtil::Split( pstrTemp, vString, "|\r\n" );
|
|
|
|
int nLoop = (int)vString.size()/7;
|
|
|
|
int n=0;
|
|
for( int i(0); nLoop>i; i++ )
|
|
{
|
|
int nModelID = atoi( vString[n++].c_str() );
|
|
|
|
FaceWinkData* pFind = NULL;
|
|
if( m_hashFaceWinkRes.lookup( nModelID, pFind ) )
|
|
{
|
|
continue;
|
|
}
|
|
|
|
FaceWinkData* pData = new FaceWinkData;
|
|
|
|
pData->model_id = nModelID;
|
|
pData->deva_male = vString[n++].c_str();
|
|
pData->deva_female = vString[n++].c_str();
|
|
pData->asura_male = vString[n++].c_str();
|
|
pData->asura_female = vString[n++].c_str();
|
|
pData->gaia_male = vString[n++].c_str();
|
|
pData->gaia_female = vString[n++].c_str();
|
|
|
|
m_hashFaceWinkRes.add( pData->model_id, pData );
|
|
}
|
|
|
|
vString.clear();
|
|
|
|
delete [] pstrTemp;
|
|
KFileManager::Instance().DeleteStream( pRes );
|
|
}
|
|
|
|
const char* SFaceWinkDB::GetFileName( int nRace, int nSex, int nDefaultID )
|
|
{
|
|
FaceWinkData * pFindItem = NULL;
|
|
if( m_hashFaceWinkRes.lookup( nDefaultID, pFindItem ) )
|
|
{
|
|
if( nRace == GCLAN_GAIA )
|
|
{
|
|
if( nSex == SEX_FEMALE ) return pFindItem->gaia_female.c_str();
|
|
else if( nSex == SEX_MALE ) return pFindItem->gaia_male.c_str();
|
|
}
|
|
else if( nRace == GCLAN_DEVA )
|
|
{
|
|
if( nSex == SEX_FEMALE ) return pFindItem->deva_female.c_str();
|
|
else if( nSex == SEX_MALE ) return pFindItem->deva_male.c_str();
|
|
}
|
|
else if( nRace == GCLAN_ASURA )
|
|
{
|
|
if( nSex == SEX_FEMALE ) return pFindItem->asura_female.c_str();
|
|
else if( nSex == SEX_MALE ) return pFindItem->asura_male.c_str();
|
|
}
|
|
}
|
|
return "NotFoundFile";
|
|
}
|
|
|
|
SFaceWinkDB & GetFaceWinkDB()
|
|
{
|
|
static SFaceWinkDB FaceWinkDB;
|
|
return FaceWinkDB;
|
|
}
|
|
|
|
//////////////////////////////////////////////////////////////////////////
|
|
//Default Item Data
|
|
SDefaultItemDB & GetDefaultItemDB()
|
|
{
|
|
static SDefaultItemDB DefaultItemDB;
|
|
return DefaultItemDB;
|
|
}
|
|
|
|
SDefaultItemDB::SDefaultItemDB()
|
|
{
|
|
Init();
|
|
}
|
|
|
|
SDefaultItemDB::~SDefaultItemDB()
|
|
{
|
|
Destroy();
|
|
}
|
|
|
|
void SDefaultItemDB::Init()
|
|
{
|
|
m_nCurFaceIndex = 0;
|
|
Load();
|
|
}
|
|
|
|
void SDefaultItemDB::Destroy()
|
|
{
|
|
DefaultModelResforGame* pDefaultModelRes = NULL;
|
|
bool res;
|
|
res = m_hashDefaultModelRes.get_first_value( pDefaultModelRes );
|
|
while ( res )
|
|
{
|
|
if ( pDefaultModelRes != NULL )
|
|
{
|
|
delete pDefaultModelRes;
|
|
}
|
|
res = m_hashDefaultModelRes.get_next_value( pDefaultModelRes );
|
|
}
|
|
m_hashDefaultModelRes.clear();
|
|
}
|
|
|
|
void SDefaultItemDB::Load()
|
|
{
|
|
KStream * pRes = KFileManager::Instance().CreateStreamFromResource( "db_DefaultModelRes.rdb" );
|
|
if( !pRes ) return;
|
|
GAME_DB db_hdr;
|
|
|
|
pRes->Read( &db_hdr, sizeof(db_hdr) );
|
|
for( int i(0); db_hdr.nCount>i; i++ )
|
|
{
|
|
DefaultModelResforGame* pItem = new DefaultModelResforGame;
|
|
|
|
DefaultModelRes defItem;
|
|
memset( &defItem, 0, sizeof(DefaultModelRes) );
|
|
pRes->Read( &defItem, sizeof(DefaultModelRes) );
|
|
|
|
pItem->SetData( &defItem );
|
|
|
|
DefaultModelResforGame* pFindItem = NULL;
|
|
if( m_hashDefaultModelRes.lookup( pItem->model_id, pFindItem ) == false )
|
|
{
|
|
switch( pItem->part_id )
|
|
{
|
|
case DEF_ITEM_ARMOR :
|
|
{
|
|
if( pItem->lobby_resource_id == DEF_RANK )
|
|
m_BodyItemList.push_back(pItem);
|
|
else if( pItem->lobby_resource_id == TOP_RANK )
|
|
m_TopRank_BodyItemList.push_back(pItem);
|
|
}
|
|
break;
|
|
|
|
case DEF_ITEM_INNER : m_InnerItemList.push_back(pItem); break;
|
|
case DEF_ITEM_GLOVE :
|
|
{
|
|
if( pItem->lobby_resource_id == DEF_RANK )
|
|
m_HandItemList.push_back(pItem);
|
|
else if( pItem->lobby_resource_id == TOP_RANK )
|
|
m_TopRank_HandItemList.push_back(pItem);
|
|
}
|
|
break;
|
|
case DEF_ITEM_FOOTS :
|
|
{
|
|
if( pItem->lobby_resource_id == DEF_RANK )
|
|
m_FootItemList.push_back(pItem);
|
|
else if( pItem->lobby_resource_id == TOP_RANK )
|
|
m_TopRank_FootItemList.push_back(pItem);
|
|
}
|
|
break;
|
|
case DEF_ITEM_HAIR : m_HairItemList.push_back(pItem); break;
|
|
case DEF_ITEM_FACE : m_FaceItemList.push_back(pItem); break;
|
|
}
|
|
|
|
m_hashDefaultModelRes.add( pItem->model_id, pItem );
|
|
}
|
|
else
|
|
{
|
|
_oprint( "Data Error! SDefaultModelResDB::Load() Code is duplicated! %d\n", pItem->model_id );
|
|
assert(0); // Notify planning team: must be fixed immediately
|
|
|
|
delete pItem;
|
|
}
|
|
}
|
|
|
|
KFileManager::Instance().DeleteStream( pRes );
|
|
}
|
|
|
|
int SDefaultItemDB::GetHairID( int nIndex )
|
|
{
|
|
if( nIndex >= 0 && nIndex < (int)m_HairItemList.size() )
|
|
{
|
|
return m_HairItemList[nIndex]->model_id;
|
|
}
|
|
assert(0);
|
|
return -1;
|
|
}
|
|
int SDefaultItemDB::GetFaceID( int nIndex )
|
|
{
|
|
if( nIndex >= 0 && nIndex < (int)m_FaceItemList.size() )
|
|
{
|
|
return m_FaceItemList[nIndex]->model_id;
|
|
}
|
|
assert(0);
|
|
return -1;
|
|
}
|
|
int SDefaultItemDB::GetBodyID( int nIndex )
|
|
{
|
|
if( nIndex >= 0 && nIndex < (int)m_BodyItemList.size() )
|
|
{
|
|
return m_BodyItemList[nIndex]->model_id;
|
|
}
|
|
assert(0);
|
|
return -1;
|
|
}
|
|
int SDefaultItemDB::GetHandID( int nIndex )
|
|
{
|
|
if( nIndex >= 0 && nIndex < (int)m_HandItemList.size() )
|
|
{
|
|
return m_HandItemList[nIndex]->model_id;
|
|
}
|
|
assert(0);
|
|
return -1;
|
|
}
|
|
int SDefaultItemDB::GetFootID( int nIndex )
|
|
{
|
|
if( nIndex >= 0 && nIndex < (int)m_FootItemList.size() )
|
|
{
|
|
return m_FootItemList[nIndex]->model_id;
|
|
}
|
|
assert(0);
|
|
return -1;
|
|
}
|
|
|
|
int SDefaultItemDB::GetInnerID( int nIndex )
|
|
{
|
|
if( nIndex >= 0 && nIndex < (int)m_InnerItemList.size() )
|
|
{
|
|
return m_InnerItemList[nIndex]->model_id;
|
|
}
|
|
assert(0);
|
|
return -1;
|
|
}
|
|
|
|
int SDefaultItemDB::GetTopBodyID( int nIndex )
|
|
{
|
|
if( nIndex >= 0 && nIndex < (int)m_TopRank_BodyItemList.size() )
|
|
{
|
|
return m_TopRank_BodyItemList[nIndex]->model_id;
|
|
}
|
|
assert(0);
|
|
return -1;
|
|
}
|
|
|
|
int SDefaultItemDB::GetTopHandID( int nIndex )
|
|
{
|
|
if( nIndex >= 0 && nIndex < (int)m_TopRank_HandItemList.size() )
|
|
{
|
|
return m_TopRank_HandItemList[nIndex]->model_id;
|
|
}
|
|
assert(0);
|
|
return -1;
|
|
}
|
|
|
|
int SDefaultItemDB::GetTopFootID( int nIndex )
|
|
{
|
|
if( nIndex >= 0 && nIndex < (int)m_TopRank_FootItemList.size() )
|
|
{
|
|
return m_TopRank_FootItemList[nIndex]->model_id;
|
|
}
|
|
assert(0);
|
|
return -1;
|
|
}
|
|
|
|
int SDefaultItemDB::GetHairIndex( int nID )
|
|
{
|
|
for( unsigned int i(0); m_HairItemList.size()>i; i++ )
|
|
{
|
|
if( m_HairItemList[i]->model_id == nID )
|
|
return i;
|
|
}
|
|
assert(0);
|
|
return -1;
|
|
}
|
|
int SDefaultItemDB::GetFaceIndex( int nID )
|
|
{
|
|
for( unsigned int i(0); m_FaceItemList.size()>i; i++ )
|
|
{
|
|
if( m_FaceItemList[i]->model_id == nID )
|
|
return i;
|
|
}
|
|
assert(0);
|
|
return -1;
|
|
}
|
|
int SDefaultItemDB::GetBodyIndex( int nID )
|
|
{
|
|
for( unsigned int i(0); m_BodyItemList.size()>i; i++ )
|
|
{
|
|
if( m_BodyItemList[i]->model_id == nID )
|
|
return i;
|
|
}
|
|
|
|
return GetInnerIndex( nID );
|
|
|
|
assert(0);
|
|
return -1;
|
|
}
|
|
|
|
int SDefaultItemDB::GetInnerIndex( int nID )
|
|
{
|
|
for( unsigned int i(0); m_InnerItemList.size()>i; i++ )
|
|
{
|
|
if( m_InnerItemList[i]->model_id == nID )
|
|
return i;
|
|
}
|
|
assert(0);
|
|
return -1;
|
|
}
|
|
|
|
int SDefaultItemDB::GetTopBodyIndex( int nID )
|
|
{
|
|
for( unsigned int i(0); m_TopRank_BodyItemList.size()>i; i++ )
|
|
{
|
|
if( m_TopRank_BodyItemList[i]->model_id == nID )
|
|
return i;
|
|
}
|
|
assert(0);
|
|
return -1;
|
|
}
|
|
|
|
int SDefaultItemDB::GetTopHandIndex( int nID )
|
|
{
|
|
for( unsigned int i(0); m_TopRank_HandItemList.size()>i; i++ )
|
|
{
|
|
if( m_TopRank_HandItemList[i]->model_id == nID )
|
|
return i;
|
|
}
|
|
assert(0);
|
|
return -1;
|
|
}
|
|
|
|
int SDefaultItemDB::GetTopFootIndex( int nID )
|
|
{
|
|
for( unsigned int i(0); m_TopRank_FootItemList.size()>i; i++ )
|
|
{
|
|
if( m_TopRank_FootItemList[i]->model_id == nID )
|
|
return i;
|
|
}
|
|
assert(0);
|
|
return -1;
|
|
}
|
|
|
|
int SDefaultItemDB::GetHandIndex( int nID )
|
|
{
|
|
for( unsigned int i(0); m_HandItemList.size()>i; i++ )
|
|
{
|
|
if( m_HandItemList[i]->model_id == nID )
|
|
return i;
|
|
}
|
|
assert(0);
|
|
return -1;
|
|
}
|
|
int SDefaultItemDB::GetFootIndex( int nID )
|
|
{
|
|
for( unsigned int i(0); m_FootItemList.size()>i; i++ )
|
|
{
|
|
if( m_FootItemList[i]->model_id == nID )
|
|
return i;
|
|
}
|
|
assert(0);
|
|
return -1;
|
|
}
|
|
|
|
int SDefaultItemDB::GetFaceGroupID( int nIndex )
|
|
{
|
|
if( nIndex >= 0 && nIndex < (int)m_FaceItemList.size() )
|
|
{
|
|
return m_FaceItemList[nIndex]->texture_group_id;
|
|
}
|
|
assert(0);
|
|
return -1;
|
|
}
|
|
|
|
int SDefaultItemDB::GetHairGroupID( int nIndex )
|
|
{
|
|
if( nIndex >= 0 && nIndex < (int)m_HairItemList.size() )
|
|
{
|
|
return m_HairItemList[nIndex]->texture_group_id;
|
|
}
|
|
assert(0);
|
|
return -1;
|
|
}
|
|
|
|
int SDefaultItemDB::GetBodyGroupID( int nIndex )
|
|
{
|
|
if( nIndex >= 0 && nIndex < (int)m_BodyItemList.size() )
|
|
{
|
|
return m_BodyItemList[nIndex]->texture_group_id;
|
|
}
|
|
assert(0);
|
|
return -1;
|
|
}
|
|
|
|
int SDefaultItemDB::GetDecoFaceGroupID( int nID )
|
|
{
|
|
for( int i = 0; i < (int)m_FaceItemList.size(); i++ )
|
|
{
|
|
if( m_FaceItemList[i]->model_id == nID )
|
|
{
|
|
return m_FaceItemList[i]->texture_group_id;
|
|
}
|
|
}
|
|
// assert(0);
|
|
return -1;
|
|
}
|
|
int SDefaultItemDB::GetDecoHairGroupID( int nID )
|
|
{
|
|
for( int i = 0; i < (int)m_HairItemList.size(); i++ )
|
|
{
|
|
if( m_HairItemList[i]->model_id == nID )
|
|
{
|
|
return m_HairItemList[i]->texture_group_id;
|
|
}
|
|
}
|
|
// assert(0);
|
|
return -1;
|
|
}
|
|
|
|
const char* SDefaultItemDB::GetFileName( int nRace, int nSex, int nDefaultID )
|
|
{
|
|
DefaultModelResforGame * pFindItem = NULL;
|
|
if( m_hashDefaultModelRes.lookup( nDefaultID, pFindItem ) )
|
|
{
|
|
if( nRace == GCLAN_GAIA )
|
|
{
|
|
if( nSex == SEX_FEMALE ) return pFindItem->gaia_female;
|
|
else if( nSex == SEX_MALE ) return pFindItem->gaia_male;
|
|
}
|
|
else if( nRace == GCLAN_DEVA )
|
|
{
|
|
if( nSex == SEX_FEMALE ) return pFindItem->deva_female;
|
|
else if( nSex == SEX_MALE ) return pFindItem->deva_male;
|
|
}
|
|
else if( nRace == GCLAN_ASURA )
|
|
{
|
|
if( nSex == SEX_FEMALE ) return pFindItem->asura_female;
|
|
else if( nSex == SEX_MALE ) return pFindItem->asura_male;
|
|
}
|
|
}
|
|
return "NotFoundFile";
|
|
} |