1023 lines
No EOL
32 KiB
C++
1023 lines
No EOL
32 KiB
C++
#include "stdafx.h"
|
||
#include "DnCostumeRandomMixDataMgr.h"
|
||
|
||
#ifdef PRE_ADD_COSRANDMIX
|
||
|
||
#include "DnCommonUtil.h"
|
||
|
||
//#if defined (_SERVER) || defined (_CLIENT)
|
||
#include "DnCommonDef.h"
|
||
//#endif
|
||
|
||
#ifdef _SERVER
|
||
#include "DNGameDataManager.h"
|
||
#elif _CLIENT
|
||
#include "DnItemSlotButton.h"
|
||
#include "DnItem.h"
|
||
#include "DnItemTask.h"
|
||
#endif
|
||
|
||
#ifdef PRE_ADD_COSRANDMIX_MIXERTYPE
|
||
#include "./boost/tuple/tuple_comparison.hpp"
|
||
#endif
|
||
|
||
#ifdef _DEBUG
|
||
#define new new(_NORMAL_BLOCK,__FILE__,__LINE__)
|
||
#endif
|
||
|
||
CDnCostumeRandomMixDataMgr::CDnCostumeRandomMixDataMgr()
|
||
#if defined _WORK || defined _KR || defined _KRAZ || defined _TABLEVERIFIER || defined _CH
|
||
: m_bEnableCosRandomMix(true)
|
||
#else
|
||
: m_bEnableCosRandomMix(false)
|
||
#endif
|
||
, m_nCosMixProbabilityResultCount(21)
|
||
{
|
||
#ifdef _CLIENT
|
||
#ifdef PRE_ADD_COSRANDMIX_ACCESSORY
|
||
m_OpenType = CostumeMix::RandomMix::OpenFail;
|
||
#endif
|
||
#ifdef PRE_ADD_COSRANDMIX_MIXERTYPE
|
||
m_nMixerEnablePartsType = CostumeMix::RandomMix::MixerCanMixPartsAll;
|
||
#endif
|
||
#endif
|
||
}
|
||
|
||
#if defined (_WORK) && defined (_SERVER)
|
||
bool CDnCostumeRandomMixDataMgr::LoadData(bool bReload/* = false*/)
|
||
#else //#if defined (_WORK) && defined (_SERVER)
|
||
bool CDnCostumeRandomMixDataMgr::LoadData()
|
||
#endif //#if defined (_WORK) && defined (_SERVER)
|
||
{
|
||
if (IsEnableCosRandomMix() == false)
|
||
return true;
|
||
|
||
#if defined (_WORK) && defined (_SERVER)
|
||
DNTableFileFormat* pCosRandMixTable = NULL;
|
||
if (bReload)
|
||
pCosRandMixTable = CDnTableDB::GetInstance().ReLoadSox(CDnTableDB::TCOSMIXINFO);
|
||
else
|
||
pCosRandMixTable = GetDNTable(CDnTableDB::TCOSMIXINFO);
|
||
if (pCosRandMixTable == NULL)
|
||
{
|
||
g_Log.Log( LogType::_FILELOG, L"costumemixinfo.ext failed\r\n");
|
||
return false;
|
||
}
|
||
|
||
DNTableFileFormat* pItemTable = NULL;
|
||
if (bReload)
|
||
pItemTable = CDnTableDB::GetInstance().ReLoadSox(CDnTableDB::TITEM);
|
||
else
|
||
pItemTable = GetDNTable(CDnTableDB::TITEM);
|
||
if (pItemTable == NULL)
|
||
{
|
||
g_Log.Log( LogType::_FILELOG, L"itemtable.ext failed\r\n");
|
||
return false;
|
||
}
|
||
|
||
DNTableFileFormat* pPartsTable = NULL;
|
||
if (bReload)
|
||
pPartsTable = CDnTableDB::GetInstance().ReLoadSox(CDnTableDB::TPARTS);
|
||
else
|
||
pPartsTable = GetDNTable(CDnTableDB::TPARTS);
|
||
if (pPartsTable == NULL)
|
||
{
|
||
g_Log.Log( LogType::_FILELOG, L"partstable.ext failed\r\n");
|
||
return false;
|
||
}
|
||
|
||
DNTableFileFormat* pCosRandMixProbabilityTable = GetDNTable(CDnTableDB::TCOSRANDOMMIXINFO);
|
||
if (bReload)
|
||
pCosRandMixProbabilityTable = CDnTableDB::GetInstance().ReLoadSox(CDnTableDB::TCOSRANDOMMIXINFO);
|
||
else
|
||
pCosRandMixProbabilityTable = GetDNTable(CDnTableDB::TCOSRANDOMMIXINFO);
|
||
if (pCosRandMixProbabilityTable == NULL)
|
||
{
|
||
g_Log.Log( LogType::_FILELOG, L"costumemixtable.ext failed\r\n");
|
||
return false;
|
||
}
|
||
#elif defined (_SERVER) || defined (_CLIENT)
|
||
DNTableFileFormat* pCosRandMixTable = GetDNTable(CDnTableDB::TCOSMIXINFO);
|
||
if (pCosRandMixTable == NULL)
|
||
{
|
||
g_Log.Log( LogType::_FILELOG, L"costumemixinfo.ext failed\r\n");
|
||
return false;
|
||
}
|
||
|
||
DNTableFileFormat* pItemTable = GetDNTable(CDnTableDB::TITEM);
|
||
if (pItemTable == NULL)
|
||
{
|
||
g_Log.Log( LogType::_FILELOG, L"itemtable.ext failed\r\n");
|
||
return false;
|
||
}
|
||
|
||
DNTableFileFormat* pPartsTable = GetDNTable(CDnTableDB::TPARTS);
|
||
if (pPartsTable == NULL)
|
||
{
|
||
g_Log.Log( LogType::_FILELOG, L"partstable.ext failed\r\n");
|
||
return false;
|
||
}
|
||
|
||
DNTableFileFormat* pCosRandMixProbabilityTable = GetDNTable(CDnTableDB::TCOSRANDOMMIXINFO);
|
||
if (pCosRandMixProbabilityTable == NULL)
|
||
{
|
||
g_Log.Log( LogType::_FILELOG, L"costumemixtable.ext failed\r\n");
|
||
return false;
|
||
}
|
||
#else
|
||
DNTableFileFormat* pCosRandMixTable = LoadExtFile("costumemixinfo.ext");
|
||
if (pCosRandMixTable == NULL)
|
||
{
|
||
#ifdef _TABLEVERIFIER
|
||
EXPECT_FALSE(true) << "CANNOT load costumemixinfo.ext";
|
||
#endif
|
||
return false;
|
||
}
|
||
|
||
DNTableFileFormat* pItemTable = LoadExtFile("itemtable.ext");
|
||
if (pItemTable == NULL)
|
||
{
|
||
#ifdef _TABLEVERIFIER
|
||
EXPECT_FALSE(true) << "CANNOT load itemtable.ext";
|
||
#endif
|
||
return false;
|
||
}
|
||
|
||
DNTableFileFormat* pPartsTable = LoadExtFile("partstable.ext");
|
||
if (pPartsTable == NULL)
|
||
{
|
||
#ifdef _TABLEVERIFIER
|
||
EXPECT_FALSE(true) << "CANNOT load partstable.ext";
|
||
#endif
|
||
return false;
|
||
}
|
||
|
||
DNTableFileFormat* pCosRandMixProbabilityTable = LoadExtFile("costumemixtable.ext");
|
||
if (pCosRandMixProbabilityTable == NULL)
|
||
{
|
||
#ifdef _TABLEVERIFIER
|
||
EXPECT_FALSE(true) << "CANNOT load costumemixtable.ext";
|
||
#endif
|
||
return false;
|
||
}
|
||
#endif
|
||
|
||
m_CosRandomMixResultList.clear();
|
||
#ifdef PRE_FIX_68828
|
||
m_CosRandomMixResultListForRef.clear();
|
||
#endif
|
||
|
||
int i = 0;
|
||
for (; i < pCosRandMixTable->GetItemCount(); ++i)
|
||
{
|
||
int nItemID = pCosRandMixTable->GetItemID(i);
|
||
std::vector<int> enableJobList;
|
||
CommonUtil::GetItemJobUsable(enableJobList, nItemID, pItemTable);
|
||
|
||
DNTableCell* pPartsCell = pPartsTable->GetFieldFromLablePtr(nItemID, "_Parts");
|
||
if (pPartsCell == NULL)
|
||
{
|
||
OutputDebug("[RANDMIX] There is NO %d item in parts table\n", nItemID);
|
||
continue;
|
||
}
|
||
int nPartsId = pPartsCell->GetInteger();
|
||
|
||
DNTableCell* pRankCell = pCosRandMixTable->GetFieldFromLablePtr(nItemID, "_MixRank");
|
||
if (pRankCell == NULL)
|
||
{
|
||
OutputDebug("[RANDMIX] There is NO _MixRank : %d item\n", nItemID);
|
||
continue;
|
||
}
|
||
int nRankId = pRankCell->GetInteger();
|
||
|
||
DNTableCell* pWorldMsgCell = pCosRandMixTable->GetFieldFromLablePtr(nItemID, "_MixMsg");
|
||
if (pWorldMsgCell == NULL)
|
||
{
|
||
OutputDebug("[RANDMIX] There is NO _MixMsg : %d item\n", nItemID);
|
||
continue;
|
||
}
|
||
bool bShowWorldMsg = (pWorldMsgCell->GetInteger() > 0) ? true : false;
|
||
|
||
DNTableCell* pEnableCell = pCosRandMixTable->GetFieldFromLablePtr(nItemID, "_MixUseCompound");
|
||
if (pEnableCell == NULL)
|
||
{
|
||
OutputDebug("[RANDMIX] There is NO _MixUseCompound : %d item\n", nItemID);
|
||
continue;
|
||
}
|
||
|
||
bool bEnableMix = (pEnableCell->GetInteger() == TRUE) ? true : false;
|
||
if (bEnableMix)
|
||
{
|
||
SRandomMixEnableData data;
|
||
data.nRank = nRankId;
|
||
data.bShowWorldMsg = bShowWorldMsg;
|
||
m_CosRandomMixEnableList.insert(std::make_pair(nItemID, data));
|
||
}
|
||
|
||
DNTableCell* pResultCell = pCosRandMixTable->GetFieldFromLablePtr(nItemID, "_MixResultAble");
|
||
if (pResultCell == NULL)
|
||
{
|
||
OutputDebug("[RANDMIX] There is NO _MixResultAble : %d item\n", nItemID);
|
||
continue;
|
||
}
|
||
|
||
bool bResultEnable = (pResultCell->GetInteger() == TRUE) ? true : false;
|
||
if (bResultEnable == false)
|
||
continue;
|
||
|
||
#if defined (PRE_FIX_68828) && defined (_SERVER)
|
||
SRandomMixEnableData resultData;
|
||
resultData.nRank = nRankId;
|
||
resultData.bShowWorldMsg = bShowWorldMsg;
|
||
m_CosRandomMixResultListForRef.insert(std::make_pair(nItemID, resultData));
|
||
#endif
|
||
|
||
std::vector<int>::const_iterator jobIter = enableJobList.begin();
|
||
for (; jobIter != enableJobList.end(); ++jobIter)
|
||
{
|
||
const int& nJobId = (*jobIter);
|
||
COSTUME_RANDOM_MIX_LIST::iterator iter = m_CosRandomMixResultList.find(std::make_pair(nJobId, nPartsId));
|
||
if (iter != m_CosRandomMixResultList.end())
|
||
{
|
||
COSTUME_RANDOM_MIX_RANKLIST& rankList = (*iter).second;
|
||
COSTUME_RANDOM_MIX_RANKLIST::iterator rankListIter = rankList.find(nRankId);
|
||
if (rankListIter != rankList.end())
|
||
{
|
||
std::vector<ITEMCLSID>& rankItemList = (*rankListIter).second;
|
||
rankItemList.push_back(nItemID);
|
||
}
|
||
else
|
||
{
|
||
std::vector<ITEMCLSID> rankItemList;
|
||
MakeRankList(rankList, rankItemList, nRankId, nItemID);
|
||
}
|
||
}
|
||
else
|
||
{
|
||
std::vector<ITEMCLSID> rankItemList;
|
||
COSTUME_RANDOM_MIX_RANKLIST rankList;
|
||
MakeRankList(rankList, rankItemList, nRankId, nItemID);
|
||
|
||
m_CosRandomMixResultList.insert(std::make_pair(std::make_pair(nJobId, nPartsId), rankList));
|
||
}
|
||
}
|
||
}
|
||
|
||
m_CosRandomMixProbabilityList.clear();
|
||
for (i = 0; i < pCosRandMixProbabilityTable->GetItemCount(); ++i)
|
||
{
|
||
int nItemID = pCosRandMixProbabilityTable->GetItemID(i);
|
||
DNTableCell* pRank1Cell = pCosRandMixProbabilityTable->GetFieldFromLablePtr(nItemID, "_MixRank1");
|
||
if (pRank1Cell == NULL)
|
||
{
|
||
OutputDebug("[RANDMIX] There is NO _MixRank1 field\n");
|
||
continue;
|
||
}
|
||
int nMixRank1 = pRank1Cell->GetInteger();
|
||
|
||
DNTableCell* pRank2Cell = pCosRandMixProbabilityTable->GetFieldFromLablePtr(nItemID, "_MixRank2");
|
||
if (pRank2Cell == NULL)
|
||
{
|
||
OutputDebug("[RANDMIX] There is NO _MixRank2 field\n");
|
||
continue;
|
||
}
|
||
int nMixRank2 = pRank2Cell->GetInteger();
|
||
|
||
#ifdef PRE_ADD_COSRANDMIX_MIXERTYPE
|
||
DNTableCell* pMixTypeCell = pCosRandMixProbabilityTable->GetFieldFromLablePtr(nItemID, "_MixType");
|
||
if (pMixTypeCell == NULL)
|
||
{
|
||
OutputDebug("[RANDMIX] There is NO _MixType field\n");
|
||
continue;
|
||
}
|
||
int nMixType = pMixTypeCell->GetInteger();
|
||
COSRANDMIX_PROBABLE_LIST::const_iterator iter = m_CosRandomMixProbabilityList.find(boost::make_tuple(nMixType, nMixRank1, nMixRank2));
|
||
#else
|
||
COSRANDMIX_PROBABLE_LIST::const_iterator iter = m_CosRandomMixProbabilityList.find(std::make_pair(nMixRank1, nMixRank2));
|
||
#endif
|
||
if (iter != m_CosRandomMixProbabilityList.end())
|
||
{
|
||
OutputDebug("[RANDMIX] Duplicate Costume Random Mix Probability List KEY (_MixRank1:%d, _MixRank2:%d)\n", nMixRank1, nMixRank2);
|
||
continue;
|
||
}
|
||
|
||
std::vector<float> probList;
|
||
int j = 0;
|
||
std::string fieldName;
|
||
float fRateSum = 0.f;
|
||
for (; j < m_nCosMixProbabilityResultCount; ++j)
|
||
{
|
||
fieldName = FormatA("_ResultRate%d", j);
|
||
DNTableCell* pCell = pCosRandMixProbabilityTable->GetFieldFromLablePtr(nItemID, fieldName.c_str());
|
||
if (pCell == NULL)
|
||
{
|
||
if (fRateSum >= 100.1f || fRateSum < 99.9f)
|
||
{
|
||
OutputDebug("[RANDMIX] Costume Random Mix Probability SUM Error: rowId:%d value:%f\n", nItemID, fRateSum);
|
||
#if defined (_SERVER) || defined (_CLIENT)
|
||
g_Log.Log(LogType::_ERROR, L"[RANDMIX] Costume Random Mix Probability SUM Error: rowId:%d value:%f\n", nItemID, fRateSum);
|
||
#endif
|
||
}
|
||
return false;
|
||
}
|
||
|
||
float fCurProb = pCell->GetFloat();
|
||
probList.push_back(fCurProb);
|
||
fRateSum += fCurProb;
|
||
}
|
||
|
||
if (fRateSum >= 100.1f || fRateSum < 99.9f)
|
||
{
|
||
OutputDebug("[RANDMIX] Costume Random Mix Probability SUM Error: rowId:%d value:%f\n", nItemID, fRateSum);
|
||
#if defined (_SERVER) || defined (_CLIENT)
|
||
g_Log.Log(LogType::_ERROR, L"[RANDMIX] Costume Random Mix Probability SUM Error: rowId:%d value:%f\n", nItemID, fRateSum);
|
||
#endif
|
||
return false;
|
||
}
|
||
|
||
#ifdef PRE_ADD_COSRANDMIX_MIXERTYPE
|
||
boost::tuple<int, int, int> keyTuple = boost::make_tuple(nMixType, nMixRank1, nMixRank2);
|
||
m_CosRandomMixProbabilityList.insert(std::make_pair(keyTuple, probList));
|
||
#else
|
||
std::pair<int, int> keyPair = std::make_pair(nMixRank1, nMixRank2);
|
||
m_CosRandomMixProbabilityList.insert(std::make_pair(keyPair, probList));
|
||
#endif
|
||
|
||
#ifdef PRE_ADD_COSRANDMIX_ACCESSORY
|
||
DNTableCell* pFeeCell = pCosRandMixProbabilityTable->GetFieldFromLablePtr(nItemID, "_CompoundFee");
|
||
if (pFeeCell == NULL)
|
||
{
|
||
OutputDebug("[RANDMIX] Costume Random Mix NO Fee Error: rowId:%d\n", nItemID);
|
||
#if defined (_SERVER) || defined (_CLIENT)
|
||
g_Log.Log(LogType::_ERROR, L"[RANDMIX] Costume Random Mix NO Fee Error: rowId:%d\n", nItemID);
|
||
#endif
|
||
continue;
|
||
}
|
||
|
||
INT64 compoundFee = pFeeCell->GetInteger();
|
||
#ifdef PRE_ADD_COSRANDMIX_MIXERTYPE
|
||
m_CosRandomMixFeeList.insert(std::make_pair(keyTuple, compoundFee));
|
||
#else
|
||
m_CosRandomMixFeeList.insert(std::make_pair(keyPair, compoundFee));
|
||
#endif // PRE_ADD_COSRANDMIX_MIXERTYPE
|
||
|
||
#endif
|
||
}
|
||
|
||
#ifdef _SERVER
|
||
m_Random.srand(timeGetTime());
|
||
#endif
|
||
|
||
return true;
|
||
}
|
||
|
||
void CDnCostumeRandomMixDataMgr::MakeRankList(COSTUME_RANDOM_MIX_RANKLIST& rankResultList, std::vector<ITEMCLSID>& itemResultList, const int& rank, const ITEMCLSID& itemId)
|
||
{
|
||
itemResultList.push_back(itemId);
|
||
rankResultList.insert(std::make_pair(rank, itemResultList));
|
||
}
|
||
|
||
#ifdef _CLIENT
|
||
bool CDnCostumeRandomMixDataMgr::IsEnableCostumeRandomMixStuff(const CDnItem* pStuff) const
|
||
{
|
||
if (pStuff == NULL || pStuff->IsEternityItem() == false)
|
||
return false;
|
||
|
||
std::map<int, SRandomMixEnableData>::const_iterator iter = m_CosRandomMixEnableList.find(pStuff->GetClassID());
|
||
|
||
#ifdef PRE_ADD_COSRANDMIX_MIXERTYPE
|
||
if (iter == m_CosRandomMixEnableList.end())
|
||
return false;
|
||
|
||
int nMixerEnableParts = GetMixerEnablePartsType();
|
||
if (nMixerEnableParts == CostumeMix::RandomMix::MixerCanMixPartsAll)
|
||
return true;
|
||
|
||
int nCurPartsType = (int)CDnParts::GetPartsType(pStuff->GetClassID());
|
||
if (nMixerEnableParts == CostumeMix::RandomMix::MixerCanMixBasicParts)
|
||
{
|
||
return (nCurPartsType >= 0 && nCurPartsType < CDnParts::OverlapPartsTypeEnum_Amount);
|
||
}
|
||
else
|
||
{
|
||
return (nMixerEnableParts == nCurPartsType);
|
||
}
|
||
#else
|
||
return (iter != m_CosRandomMixEnableList.end());
|
||
#endif
|
||
}
|
||
|
||
#ifdef PRE_ADD_COSRANDMIX_MIXERTYPE
|
||
void CDnCostumeRandomMixDataMgr::SetMixerEnablePartsType(int nPartsType)
|
||
{
|
||
m_nMixerEnablePartsType = nPartsType;
|
||
}
|
||
#endif
|
||
|
||
#ifdef PRE_ADD_COSRANDMIX_ACCESSORY
|
||
|
||
bool CDnCostumeRandomMixDataMgr::MakePreviewItemList(std::vector<SRandomProgressData>& itemList, const CDnParts::PartsTypeEnum& partsType) const
|
||
{
|
||
itemList.clear();
|
||
|
||
if (CDnItemTask::IsActive() && CDnActor::s_hLocalActor)
|
||
{
|
||
typedef SRandomProgressData SRPData;
|
||
|
||
int classId = ((CDnPlayerActor*)CDnActor::s_hLocalActor.GetPointer())->GetClassID();
|
||
const COSTUME_RANDOM_MIX_RANKLIST* pCommonItemRankList = GetRandomMixRankList(0, (int)partsType);
|
||
const COSTUME_RANDOM_MIX_RANKLIST* pRankList = GetRandomMixRankList(classId, (int)partsType);
|
||
if (pRankList == NULL && pCommonItemRankList == NULL)
|
||
return false;
|
||
|
||
if (pRankList)
|
||
DoMakePreviewItemList(itemList, *pRankList);
|
||
if (pCommonItemRankList)
|
||
DoMakePreviewItemList(itemList, *pCommonItemRankList);
|
||
}
|
||
|
||
return true;
|
||
}
|
||
|
||
void CDnCostumeRandomMixDataMgr::DoMakePreviewItemList(std::vector<SRandomProgressData>& itemList, const COSTUME_RANDOM_MIX_RANKLIST& srcList) const
|
||
{
|
||
COSTUME_RANDOM_MIX_RANKLIST::const_iterator iter = srcList.begin();
|
||
for (; iter != srcList.end(); ++iter)
|
||
{
|
||
const std::vector<ITEMCLSID>& subList = (*iter).second;
|
||
std::vector<ITEMCLSID>::const_iterator subIter = subList.begin();
|
||
for (; subIter != subList.end(); ++subIter)
|
||
{
|
||
SRandomProgressData data;
|
||
data.progressItem = (*subIter);
|
||
itemList.push_back(data);
|
||
}
|
||
}
|
||
}
|
||
|
||
#ifdef _CLIENT
|
||
void CDnCostumeRandomMixDataMgr::OnStartMixDlg(CostumeMix::RandomMix::eOpenType type)
|
||
{
|
||
m_OpenType = type;
|
||
}
|
||
#endif
|
||
|
||
#else // PRE_ADD_COSRANDMIX_ACCESSORY
|
||
|
||
bool CDnCostumeRandomMixDataMgr::MakePreviewItemList(std::vector<SRandomProgressData>& itemList, const CDnParts::PartsTypeEnum& partsType, const std::vector<ITEMCLSID>& stuffItemIDs) const
|
||
{
|
||
itemList.clear();
|
||
|
||
if (CDnItemTask::IsActive())
|
||
{
|
||
typedef SRandomProgressData SRPData;
|
||
|
||
int classId = ((CDnPlayerActor*)CDnActor::s_hLocalActor.GetPointer())->GetClassID();
|
||
const CDnCostumeRandomMixDataMgr::COSTUME_RANDOM_MIX_RANKLIST* pRankList = GetRandomMixRankList(classId, (int)partsType);
|
||
if (pRankList == NULL)
|
||
return false;
|
||
|
||
if (stuffItemIDs.size() != MAX_COSTUME_RANDOMMIX_STUFF)
|
||
{
|
||
return false;
|
||
}
|
||
int i = 0;
|
||
int nStuffRank[MAX_COSTUME_RANDOMMIX_STUFF] = {-1, };
|
||
for (; i < MAX_COSTUME_RANDOMMIX_STUFF; ++i)
|
||
nStuffRank[i] = GetRandomMixStuffItemRank(stuffItemIDs[i]);
|
||
|
||
#ifdef PRE_ADD_COSRANDMIX_MIXERTYPE
|
||
const std::vector<float>* pProbList = GetRandomMixProbableList(partsType, nStuffRank[0], nStuffRank[1]);
|
||
#else
|
||
const std::vector<float>* pProbList = GetRandomMixProbableList(nStuffRank[0], nStuffRank[1]);
|
||
#endif
|
||
if (pProbList == NULL)
|
||
return false;
|
||
|
||
float fSum = 0.f;
|
||
CDnCostumeRandomMixDataMgr::COSTUME_RANDOM_MIX_RANKLIST::const_iterator iter = pRankList->begin();
|
||
for (; iter != pRankList->end(); ++iter)
|
||
{
|
||
int nRank = (*iter).first;
|
||
if (nRank < 0 || nRank > (int)pProbList->size())
|
||
continue;
|
||
|
||
SRPData data;
|
||
data.fShowRatio = (*pProbList)[nRank];
|
||
data.progressItemList = (*iter).second;
|
||
|
||
fSum += data.fShowRatio;
|
||
itemList.push_back(data);
|
||
}
|
||
|
||
if (fSum < 99.9f || fSum > 100.1f)
|
||
{
|
||
int nLargestIndex = 0;
|
||
float fLargest = 0.f, fOtherSum = 0.f;
|
||
int i = 0;
|
||
for (; i < (int)itemList.size(); ++i)
|
||
{
|
||
SRPData& cur = itemList[i];
|
||
if (cur.fShowRatio > fLargest)
|
||
{
|
||
fLargest = cur.fShowRatio;
|
||
nLargestIndex = i;
|
||
}
|
||
else
|
||
{
|
||
fOtherSum += cur.fShowRatio;
|
||
}
|
||
}
|
||
|
||
if (nLargestIndex >= 0)
|
||
itemList[nLargestIndex].fShowRatio = (100.f - fOtherSum);
|
||
}
|
||
}
|
||
|
||
return true;
|
||
}
|
||
|
||
#endif // PRE_ADD_COSRANDMIX_ACCESSORY
|
||
|
||
#endif // _CLIENT
|
||
|
||
#ifdef _SERVER
|
||
bool CDnCostumeRandomMixDataMgr::IsEnableCostumeRandomMixStuff(const std::vector<TItem>& stuffs, int userClassId) const
|
||
{
|
||
if (stuffs.empty() || (int)stuffs.size() != MAX_COSTUME_RANDOMMIX_STUFF)
|
||
return false;
|
||
|
||
int nPartsType = 0;
|
||
int i = 0;
|
||
for (; i < MAX_COSTUME_RANDOMMIX_STUFF; ++i)
|
||
{
|
||
const TItem& stuff = stuffs[i];
|
||
|
||
if (stuff.bEternity == false)
|
||
return false;
|
||
|
||
std::map<int, SRandomMixEnableData>::const_iterator iter = m_CosRandomMixEnableList.find(stuff.nItemID);
|
||
|
||
if (iter == m_CosRandomMixEnableList.end())
|
||
return false;
|
||
|
||
if (stuff.wCount != 1)
|
||
return false; // <20><>ǰ<EFBFBD><C7B0> <20><><EFBFBD><EFBFBD>
|
||
|
||
TItemData *pItemData = g_pDataManager->GetItemData(stuff.nItemID);
|
||
if (pItemData == NULL)
|
||
return false;
|
||
|
||
if (g_pDataManager->IsItemNeedJob(stuff.nItemID, userClassId) == false)
|
||
return false;
|
||
|
||
TPartData *pPartData = g_pDataManager->GetPartData(pItemData->nItemID);
|
||
if (!pPartData)
|
||
return false;
|
||
|
||
if (i != 0 && nPartsType != pPartData->nParts)
|
||
return false;
|
||
|
||
nPartsType = pPartData->nParts;
|
||
}
|
||
|
||
int stuffRank0 = GetRandomMixStuffItemRank(stuffs[0].nItemID);
|
||
int stuffRank1 = GetRandomMixStuffItemRank(stuffs[1].nItemID);
|
||
|
||
#ifdef PRE_ADD_COSRANDMIX_MIXERTYPE
|
||
const std::vector<float>* pCurRankProbList = GetRandomMixProbableList(nPartsType, stuffRank0, stuffRank1);
|
||
#else
|
||
const std::vector<float>* pCurRankProbList = GetRandomMixProbableList(stuffRank0, stuffRank1);
|
||
#endif
|
||
if (pCurRankProbList == NULL)
|
||
return false;
|
||
|
||
return true;
|
||
}
|
||
|
||
int CDnCostumeRandomMixDataMgr::DoRandomMix(const INT64* pStuffSerials, int stuffCount, int userClassId, const CDNUserItem& userItem, const INT64& mixerCharacterDBID, eError& lastError)
|
||
{
|
||
if (pStuffSerials == NULL || stuffCount != MAX_COSTUME_RANDOMMIX_STUFF)
|
||
{
|
||
g_Log.Log(LogType::_FILELOG, L"[CDBID:%I64d] COSRANDOMMIX : ILLEGAL STUFF_ITEM - NULL or NOT_ENOUGH_STUFFCOUNT(%d)\r\n", mixerCharacterDBID, stuffCount);
|
||
return 0;
|
||
}
|
||
|
||
std::vector<TItem> stuffIDs;
|
||
int i = 0;
|
||
for (; i < stuffCount; ++i)
|
||
{
|
||
const TItem* pItem = userItem.GetCashInventory(pStuffSerials[i]);
|
||
if (pItem == NULL)
|
||
{
|
||
g_Log.Log(LogType::_FILELOG, L"[CDBID:%I64d] COSRANDOMMIX : ILLEGAL STUFF_ITEM - THERE IS NO STUFF ITEM IN CASH INVENTORY! SERIAL:(%I64d)\r\n", mixerCharacterDBID, pStuffSerials[i]);
|
||
return 0;
|
||
}
|
||
|
||
stuffIDs.push_back(*pItem);
|
||
}
|
||
|
||
return DoRandomMix(stuffIDs, userClassId, userItem, mixerCharacterDBID, lastError);
|
||
}
|
||
|
||
int CDnCostumeRandomMixDataMgr::DoRandomMix(const std::vector<TItem>& stuffItemIDs, int userClassId, const CDNUserItem& userItem, const INT64& mixerCharacterDBID, eError& lastError)
|
||
{
|
||
std::vector<int> nStuffsRankList;
|
||
int nPartsType = -1;
|
||
GetStuffsRankAndPartsType(nStuffsRankList, nPartsType, stuffItemIDs, userItem, mixerCharacterDBID);
|
||
int stuffRankListSize = (int)nStuffsRankList.size();
|
||
if (stuffRankListSize <= 0 || stuffRankListSize > MAX_COSTUME_RANDOMMIX_STUFF)
|
||
return 0;
|
||
|
||
#ifdef PRE_ADD_COSRANDMIX_MIXERTYPE
|
||
const std::vector<float>* pCurRankProbList = GetRandomMixProbableList(nPartsType, nStuffsRankList[0], nStuffsRankList[1]);
|
||
#else
|
||
const std::vector<float>* pCurRankProbList = GetRandomMixProbableList(nStuffsRankList[0], nStuffsRankList[1]);
|
||
#endif
|
||
if (pCurRankProbList == NULL)
|
||
{
|
||
g_Log.Log(LogType::_FILELOG, L"[CDBID:%I64d] COSRANDOMMIX : NO PROBABILITY(%d, %d)\r\n", mixerCharacterDBID, nStuffsRankList[0], nStuffsRankList[1]);
|
||
return 0;
|
||
}
|
||
|
||
const std::vector<float>& curRankProbList = *pCurRankProbList;
|
||
float rankValue = m_Random.rand_float(0.f, 100.f);
|
||
|
||
int resultRank = -1;
|
||
float fRangeAccumulator = 0.f;
|
||
int i = 0;
|
||
for (i = 0; i < (int)curRankProbList.size(); ++i)
|
||
{
|
||
fRangeAccumulator += curRankProbList[i];
|
||
if (rankValue <= fRangeAccumulator)
|
||
{
|
||
resultRank = i;
|
||
break;
|
||
}
|
||
}
|
||
|
||
bool bExistClassRank = false;
|
||
COSTUME_RANDOM_MIX_RANKLIST::const_iterator rankIter;
|
||
COSTUME_RANDOM_MIX_LIST::const_iterator resultIter = m_CosRandomMixResultList.find(std::make_pair(userClassId, nPartsType));
|
||
if (resultIter != m_CosRandomMixResultList.end())
|
||
{
|
||
const COSTUME_RANDOM_MIX_RANKLIST& curRankList = (*resultIter).second;
|
||
rankIter = curRankList.find(resultRank);
|
||
if (rankIter != curRankList.end())
|
||
bExistClassRank = true;
|
||
}
|
||
|
||
bool bExistCommonRank = false;
|
||
COSTUME_RANDOM_MIX_RANKLIST::const_iterator commonRankIter;
|
||
COSTUME_RANDOM_MIX_LIST::const_iterator commonResultIter = m_CosRandomMixResultList.find(std::make_pair(0, nPartsType));
|
||
if (commonResultIter != m_CosRandomMixResultList.end())
|
||
{
|
||
const COSTUME_RANDOM_MIX_RANKLIST& curCommonRankList = (*commonResultIter).second;
|
||
commonRankIter = curCommonRankList.find(resultRank);
|
||
if (commonRankIter != curCommonRankList.end())
|
||
bExistCommonRank = true;
|
||
}
|
||
|
||
if (bExistClassRank == false && bExistCommonRank == false)
|
||
{
|
||
g_Log.Log(LogType::_FILELOG, L"[CDBID:%I64d] COSRANDOMMIX : NO RESULT LIST(userClassId(%d), partsType(%d))\r\n", mixerCharacterDBID, userClassId, nPartsType);
|
||
return 0;
|
||
}
|
||
|
||
int resultItemId = 0;
|
||
if (bExistCommonRank && bExistClassRank == false)
|
||
{
|
||
const std::vector<int>& commonRankList = (*commonRankIter).second;
|
||
int wholeSize = (int)commonRankList.size();
|
||
if (wholeSize < 1)
|
||
{
|
||
g_Log.Log(LogType::_FILELOG, L"[CDBID:%I64d] COSRANDOMMIX : RESULT CALCULATION ERROR\r\n", mixerCharacterDBID);
|
||
return 0;
|
||
}
|
||
int nNumberDrew = m_Random.rand(1, wholeSize);
|
||
nNumberDrew--;
|
||
resultItemId = commonRankList[nNumberDrew];
|
||
}
|
||
else if (bExistClassRank && bExistCommonRank == false)
|
||
{
|
||
const std::vector<int>& rankList = (*rankIter).second;
|
||
int wholeSize = (int)rankList.size();
|
||
if (wholeSize < 1)
|
||
{
|
||
g_Log.Log(LogType::_FILELOG, L"[CDBID:%I64d] COSRANDOMMIX : RESULT CALCULATION ERROR\r\n", mixerCharacterDBID);
|
||
return 0;
|
||
}
|
||
int nNumberDrew = m_Random.rand(1, wholeSize);
|
||
nNumberDrew--;
|
||
resultItemId = rankList[nNumberDrew];
|
||
}
|
||
else if (bExistCommonRank && bExistClassRank)
|
||
{
|
||
const std::vector<int>& rankList = (*rankIter).second;
|
||
const std::vector<int>& commonRankList = (*commonRankIter).second;
|
||
|
||
int wholeSize = (int)rankList.size() + (int)commonRankList.size();
|
||
if (wholeSize < 1)
|
||
{
|
||
g_Log.Log(LogType::_FILELOG, L"[CDBID:%I64d] COSRANDOMMIX : RESULT CALCULATION ERROR\r\n", mixerCharacterDBID);
|
||
return 0;
|
||
}
|
||
|
||
int nNumberDrew = m_Random.rand(1, wholeSize);
|
||
|
||
if (nNumberDrew > (int)rankList.size())
|
||
{
|
||
int nCommonItemIndexDrew = (nNumberDrew - (int)rankList.size()) - 1;
|
||
if (nCommonItemIndexDrew < 0 || nCommonItemIndexDrew >= (int)commonRankList.size())
|
||
{
|
||
g_Log.Log(LogType::_FILELOG, L"[CDBID:%I64d] COSRANDOMMIX : RESULT CALCULATION ERROR\r\n", mixerCharacterDBID);
|
||
return 0;
|
||
}
|
||
|
||
resultItemId = commonRankList[nCommonItemIndexDrew];
|
||
}
|
||
else
|
||
{
|
||
int nItemIndexDrew = nNumberDrew - 1;
|
||
if (nItemIndexDrew < 0 || nItemIndexDrew >= (int)rankList.size())
|
||
{
|
||
g_Log.Log(LogType::_FILELOG, L"[CDBID:%I64d] COSRANDOMMIX : RESULT CALCULATION ERROR\r\n", mixerCharacterDBID);
|
||
return 0;
|
||
}
|
||
|
||
resultItemId = rankList[nItemIndexDrew];
|
||
}
|
||
}
|
||
|
||
return resultItemId;
|
||
}
|
||
|
||
void CDnCostumeRandomMixDataMgr::GetStuffsRankAndPartsType(std::vector<int>& nStuffsRankList, int& nPartsType, const std::vector<TItem>& stuffItemIDs, const CDNUserItem& userItem, const INT64& mixerCharacterDBID) const
|
||
{
|
||
#ifdef _WORK
|
||
if (MAX_COSTUME_RANDOMMIX_STUFF < 2)
|
||
{
|
||
g_Log.Log(LogType::_ERROR, L"[CDBID:%I64d] COSRANDOMMIX : MAX_COSTUME_RANDOMMIX_STUFF < 2\r\n", mixerCharacterDBID);
|
||
return;
|
||
}
|
||
#endif
|
||
|
||
if (MAX_COSTUME_RANDOMMIX_STUFF != (int)stuffItemIDs.size())
|
||
{
|
||
g_Log.Log(LogType::_ERROR, L"[CDBID:%I64d] COSRANDOMMIX : GetStuffsRankAndPartsType() MAX_COSTUME_RANDOMMIX_STUFF != (int)nStuffItemIDs.size()\r\n", mixerCharacterDBID);
|
||
return;
|
||
}
|
||
|
||
int i = 0;
|
||
nPartsType = -1;
|
||
for (; i < (int)stuffItemIDs.size(); ++i)
|
||
{
|
||
int nStuffItemId = stuffItemIDs[i].nItemID;
|
||
std::map<int, SRandomMixEnableData>::const_iterator enableListIter = m_CosRandomMixEnableList.find(nStuffItemId);
|
||
if (enableListIter == m_CosRandomMixEnableList.end())
|
||
{
|
||
g_Log.Log(LogType::_FILELOG, L"[CDBID:%I64d] COSRANDOMMIX : ILLEGAL STUFF_ITEM_ID(%d)\r\n", mixerCharacterDBID, nStuffItemId);
|
||
return;
|
||
}
|
||
|
||
if (nPartsType == -1)
|
||
{
|
||
const TPartData *pPartData = g_pDataManager->GetPartData(nStuffItemId);
|
||
if (!pPartData)
|
||
{
|
||
g_Log.Log(LogType::_FILELOG, L"[CDBID:%I64d] COSRANDOMMIX : STUFF ITEM IS NOT PARTSITEM(%d)\r\n", mixerCharacterDBID, nStuffItemId);
|
||
return;
|
||
}
|
||
nPartsType = pPartData->nParts;
|
||
}
|
||
|
||
const SRandomMixEnableData& data = (*enableListIter).second;
|
||
nStuffsRankList.push_back(data.nRank);
|
||
}
|
||
}
|
||
|
||
#ifdef PRE_FIX_68828
|
||
bool CDnCostumeRandomMixDataMgr::IsWorldMessagingItem(int nItemId) const
|
||
{
|
||
std::map<int, SRandomMixEnableData>::const_iterator iter = m_CosRandomMixResultListForRef.find(nItemId);
|
||
if (iter != m_CosRandomMixResultListForRef.end())
|
||
{
|
||
const SRandomMixEnableData& data = (*iter).second;
|
||
return data.bShowWorldMsg;
|
||
}
|
||
|
||
return false;
|
||
}
|
||
#endif
|
||
|
||
#ifdef PRE_ADD_COSRANDMIX_MIXERTYPE
|
||
const std::vector<float>* CDnCostumeRandomMixDataMgr::GetRandomMixProbableList(int stuffPartsType, int stuffRank1, int stuffRank2) const
|
||
{
|
||
int stuffPartsTypeForProbableList = stuffPartsType;
|
||
if (stuffPartsTypeForProbableList < 0)
|
||
return NULL;
|
||
|
||
if (IsBasicCashPartsType(stuffPartsTypeForProbableList))
|
||
stuffPartsTypeForProbableList = CASHEQUIPMIN;
|
||
|
||
COSRANDMIX_PROBABLE_LIST::const_iterator iter = m_CosRandomMixProbabilityList.find(boost::make_tuple(stuffPartsTypeForProbableList, stuffRank1, stuffRank2));
|
||
if (iter != m_CosRandomMixProbabilityList.end())
|
||
return &((*iter).second);
|
||
|
||
iter = m_CosRandomMixProbabilityList.find(boost::make_tuple(stuffPartsTypeForProbableList, stuffRank2, stuffRank1));
|
||
if (iter != m_CosRandomMixProbabilityList.end())
|
||
return &((*iter).second);
|
||
|
||
return NULL;
|
||
}
|
||
#else // PRE_ADD_COSRANDMIX_MIXERTYPE
|
||
const std::vector<float>* CDnCostumeRandomMixDataMgr::GetRandomMixProbableList(int stuffRank1, int stuffRank2) const
|
||
{
|
||
COSRANDMIX_PROBABLE_LIST::const_iterator iter = m_CosRandomMixProbabilityList.find(std::make_pair(stuffRank1, stuffRank2));
|
||
if (iter != m_CosRandomMixProbabilityList.end())
|
||
return &((*iter).second);
|
||
|
||
iter = m_CosRandomMixProbabilityList.find(std::make_pair(stuffRank2, stuffRank1));
|
||
if (iter != m_CosRandomMixProbabilityList.end())
|
||
return &((*iter).second);
|
||
|
||
return NULL;
|
||
}
|
||
#endif // PRE_ADD_COSRANDMIX_MIXERTYPE
|
||
|
||
#endif // _SERVER
|
||
|
||
const CDnCostumeRandomMixDataMgr::COSTUME_RANDOM_MIX_RANKLIST* CDnCostumeRandomMixDataMgr::GetRandomMixRankList(int userClassId, int partsId) const
|
||
{
|
||
const COSTUME_RANDOM_MIX_LIST::const_iterator rankListIter = m_CosRandomMixResultList.find(std::make_pair(userClassId, partsId));
|
||
if (rankListIter == m_CosRandomMixResultList.end())
|
||
return NULL;
|
||
|
||
return &((*rankListIter).second);
|
||
}
|
||
|
||
int CDnCostumeRandomMixDataMgr::GetRandomMixStuffItemRank(ITEMCLSID itemId) const
|
||
{
|
||
std::map<int, SRandomMixEnableData>::const_iterator iter = m_CosRandomMixEnableList.find(itemId);
|
||
if (iter != m_CosRandomMixEnableList.end())
|
||
{
|
||
const SRandomMixEnableData& data = (*iter).second;
|
||
return data.nRank;
|
||
}
|
||
|
||
return -1;
|
||
}
|
||
|
||
#ifdef PRE_FIX_68828
|
||
int CDnCostumeRandomMixDataMgr::GetRandomMixResultItemRank(ITEMCLSID itemId) const
|
||
{
|
||
std::map<int, SRandomMixEnableData>::const_iterator iter = m_CosRandomMixResultListForRef.find(itemId);
|
||
if (iter != m_CosRandomMixResultListForRef.end())
|
||
{
|
||
const SRandomMixEnableData& data = (*iter).second;
|
||
return data.nRank;
|
||
}
|
||
|
||
return -1;
|
||
}
|
||
#endif
|
||
|
||
#ifdef PRE_ADD_COSRANDMIX_ACCESSORY
|
||
|
||
INT64 CDnCostumeRandomMixDataMgr::GetRandomMixFee(const std::vector<int>& stuffs) const
|
||
{
|
||
if (stuffs.size() != MAX_COSTUME_RANDOMMIX_STUFF)
|
||
return -1;
|
||
|
||
int nRank[MAX_COSTUME_RANDOMMIX_STUFF] = {0,};
|
||
int i = 0;
|
||
#ifdef PRE_ADD_COSRANDMIX_MIXERTYPE
|
||
int nPartsType = -1, nLastPartsType = -1;
|
||
#endif
|
||
for (; i < MAX_COSTUME_RANDOMMIX_STUFF; ++i)
|
||
{
|
||
int nStuffItemId = stuffs[i];
|
||
std::map<int, SRandomMixEnableData>::const_iterator iter = m_CosRandomMixEnableList.find(nStuffItemId);
|
||
if (iter == m_CosRandomMixEnableList.end())
|
||
return -1;
|
||
|
||
#if defined (PRE_ADD_COSRANDMIX_MIXERTYPE) && !defined (_TABLEVERIFIER)
|
||
nPartsType = GetPartsType(nStuffItemId);
|
||
if (i != 0 && nPartsType != nLastPartsType)
|
||
return -1;
|
||
|
||
nLastPartsType = nPartsType;
|
||
#endif
|
||
const SRandomMixEnableData& data = (*iter).second;
|
||
nRank[i] = data.nRank;
|
||
}
|
||
|
||
#ifdef PRE_ADD_COSRANDMIX_MIXERTYPE
|
||
if (nPartsType < 0)
|
||
return -1;
|
||
|
||
#pragma message("RLKT DISABLED >> line 919")
|
||
// if (IsBasicCashPartsType(nPartsType))
|
||
// nPartsType = CASHEQUIPMIN;
|
||
|
||
COSRANDMIX_FEE_LIST::const_iterator feeIter = m_CosRandomMixFeeList.find(boost::make_tuple(nPartsType, nRank[0], nRank[1]));
|
||
#else
|
||
COSRANDMIX_FEE_LIST::const_iterator feeIter = m_CosRandomMixFeeList.find(std::make_pair(nRank[0], nRank[1]));
|
||
#endif
|
||
if (feeIter != m_CosRandomMixFeeList.end())
|
||
{
|
||
return (*feeIter).second;
|
||
}
|
||
else
|
||
{
|
||
#ifdef PRE_ADD_COSRANDMIX_MIXERTYPE
|
||
COSRANDMIX_FEE_LIST::const_iterator convertFeeIter = m_CosRandomMixFeeList.find(boost::make_tuple(nPartsType, nRank[1], nRank[0]));
|
||
#else
|
||
COSRANDMIX_FEE_LIST::const_iterator convertFeeIter = m_CosRandomMixFeeList.find(std::make_pair(nRank[1], nRank[0]));
|
||
#endif
|
||
if (convertFeeIter != m_CosRandomMixFeeList.end())
|
||
return (*convertFeeIter).second;
|
||
}
|
||
|
||
return -1;
|
||
}
|
||
|
||
#else // PRE_ADD_COSRANDMIX_ACCESSORY
|
||
|
||
#ifdef PRE_ADD_COSRANDMIX_MIXERTYPE
|
||
#ifndef _SERVER
|
||
const std::vector<float>* CDnCostumeRandomMixDataMgr::GetRandomMixProbableList(int mixType, int stuffRank1, int stuffRank2) const
|
||
{
|
||
if (mixType < 0)
|
||
return NULL;
|
||
|
||
COSRANDMIX_PROBABLE_LIST::const_iterator iter = m_CosRandomMixProbabilityList.find(boost::make_tuple(mixType, stuffRank1, stuffRank2));
|
||
if (iter != m_CosRandomMixProbabilityList.end())
|
||
return &((*iter).second);
|
||
|
||
iter = m_CosRandomMixProbabilityList.find(boost::make_tuple(mixType, stuffRank2, stuffRank1));
|
||
if (iter != m_CosRandomMixProbabilityList.end())
|
||
return &((*iter).second);
|
||
|
||
return NULL;
|
||
}
|
||
#endif // _SERVER
|
||
#else
|
||
const std::vector<float>* CDnCostumeRandomMixDataMgr::GetRandomMixProbableList(int stuffRank1, int stuffRank2) const
|
||
{
|
||
COSRANDMIX_PROBABLE_LIST::const_iterator iter = m_CosRandomMixProbabilityList.find(std::make_pair(stuffRank1, stuffRank2));
|
||
if (iter != m_CosRandomMixProbabilityList.end())
|
||
return &((*iter).second);
|
||
|
||
iter = m_CosRandomMixProbabilityList.find(std::make_pair(stuffRank2, stuffRank1));
|
||
if (iter != m_CosRandomMixProbabilityList.end())
|
||
return &((*iter).second);
|
||
|
||
return NULL;
|
||
}
|
||
#endif // PRE_ADD_COSRANDMIX_MIXERTYPE
|
||
|
||
#endif // PRE_ADD_COSRANDMIX_ACCESSORY
|
||
|
||
#if defined (PRE_ADD_COSRANDMIX_MIXERTYPE) && !defined (_TABLEVERIFIER)
|
||
int CDnCostumeRandomMixDataMgr::GetPartsType(int nItemId) const
|
||
{
|
||
#ifdef _SERVER
|
||
const TPartData *pPartData = g_pDataManager->GetPartData(nItemId);
|
||
if (!pPartData)
|
||
return -1;
|
||
|
||
return pPartData->nParts;
|
||
#else
|
||
return (int)CDnParts::GetPartsType(nItemId);
|
||
#endif
|
||
}
|
||
|
||
bool CDnCostumeRandomMixDataMgr::IsBasicCashPartsType(int nPartsType) const
|
||
{
|
||
#ifdef _SERVER
|
||
return (nPartsType >= CASHEQUIPMIN && nPartsType <= CASHEQUIP_FOOT);
|
||
#else
|
||
return (nPartsType >= CDnParts::CashHelmet && nPartsType <= CDnParts::CashFoot);
|
||
#endif
|
||
}
|
||
#endif // PRE_ADD_COSRANDMIX_MIXERTYPE
|
||
|
||
#ifdef PRE_FIX_68828
|
||
#else
|
||
#if defined(_SERVER)
|
||
bool CDnCostumeRandomMixDataMgr::IsWorldMessagingItem(int nItemId) const
|
||
{
|
||
std::map<int, SRandomMixEnableData>::const_iterator iter = m_CosRandomMixEnableList.find(nItemId);
|
||
if (iter != m_CosRandomMixEnableList.end())
|
||
{
|
||
const SRandomMixEnableData& data = (*iter).second;
|
||
return data.bShowWorldMsg;
|
||
}
|
||
|
||
return false;
|
||
}
|
||
#endif // #if defined(_SERVER)
|
||
#endif
|
||
|
||
#endif // PRE_ADD_COSRANDMIX
|