bool NFCTeamModule::GetMemberList(const NFGUID& self, const NFGUID& xTeam, std::vector<NFGUID>& xmemberList)
{
NF_SHARE_PTR<NFIRecordManager> pRecordManager = m_pCommonRedisModule->GetCacheRecordInfo(xTeam, NFrame::Team::ThisName());
if (!pRecordManager)
{
return false;
}
NF_SHARE_PTR<NFIRecord> pMemberRecord = pRecordManager->GetElement(NFrame::Team::MemberList::ThisName());
if (!pMemberRecord.get())
{
return false;
}
for (int i = 0; i < pMemberRecord->GetRows(); i++)
{
if (!pMemberRecord->IsUsed(i))
{
continue;
}
const NFINT64 nOnline = pMemberRecord->GetInt(i, NFrame::Team::MemberList::Online);
const NFINT64 nGameID = pMemberRecord->GetInt(i, NFrame::Team::MemberList::GameID);
const NFGUID& xID = pMemberRecord->GetObject(i, NFrame::Team::MemberList::GUID);
if (!xID.IsNull())
{
xmemberList.push_back(xID);
}
}
return true;
}
bool NFCSceneProcessModule::CreateContinerObjectByFile( const int nContainerID, const int nGroupID, const std::string& strFileName )
{
NF_SHARE_PTR<NFMapEx<std::string, SceneGroupResource>> pSceneResource = mtSceneResourceConfig.GetElement( nContainerID );
if ( pSceneResource.get() )
{
NF_SHARE_PTR<SceneGroupResource> pResourceMap = pSceneResource->GetElement( strFileName );
if ( pResourceMap.get() )
{
NF_SHARE_PTR<NFMapEx<std::string, SceneSeedResource>> pNPCResourceList = pResourceMap->xSceneGroupResource.GetElement( "NPC" );
if ( pNPCResourceList.get() )
{
NF_SHARE_PTR<SceneSeedResource> pResource = pNPCResourceList->First( );
while ( pResource.get() )
{
CreateContinerObject( nContainerID, nGroupID, strFileName, pResource->strSeedID );
pResource = pNPCResourceList->Next();
}
}
}
}
return true;
}
bool NFCEventProcessModule::AddAsyncEventCallBack( const NFIDENTID& objectID, const int nEventID, const EVENT_ASYNC_PROCESS_BEGIN_FUNCTOR_PTR& cb, const EVENT_ASYNC_PROCESS_END_FUNCTOR_PTR& cb_end )
{
NF_SHARE_PTR<NFCObjectAsyncEventInfo> pObjectSyncEventInfo = mObjectSyncEventInfoMapEx.GetElement(objectID);
if (nullptr == pObjectSyncEventInfo)
{
pObjectSyncEventInfo = NF_SHARE_PTR<NFCObjectAsyncEventInfo>(NF_NEW NFCObjectAsyncEventInfo());
mObjectSyncEventInfoMapEx.AddElement(objectID, pObjectSyncEventInfo);
}
assert(NULL != pObjectSyncEventInfo);
NF_SHARE_PTR<NFAsyncEventFunc> pSyncEventInfo = pObjectSyncEventInfo->GetElement(nEventID);
if (nullptr == pSyncEventInfo)
{
pSyncEventInfo = NF_SHARE_PTR<NFAsyncEventFunc>(NF_NEW NFAsyncEventFunc());
pObjectSyncEventInfo->AddElement(nEventID, pSyncEventInfo);
}
assert(NULL != pSyncEventInfo);
pSyncEventInfo->xBeginFuncptr = cb;
pSyncEventInfo->xEndFuncptr = cb_end;
return true;
}
bool NFCCommonRedisModule::ConvertVectorToRecordManager(std::vector<std::string>& vKeyList, std::vector<std::string>& vValueList, NF_SHARE_PTR<NFIRecordManager> pRecordManager)
{
if (vKeyList.size() == vValueList.size())
{
for (int i = 0; i < vKeyList.size(); ++i)
{
const std::string& strKey = vKeyList[i];
const std::string& strValue = vValueList[i];
if (strValue.empty())
{
continue;
}
NF_SHARE_PTR<NFIRecord> pRecord = pRecordManager->GetElement(strKey);
if (!pRecord->GetCache() && !pRecord->GetSave())
{
continue;
}
NFMsg::ObjectRecordBase xRecordData;
if (xRecordData.ParseFromString(strValue))
{
ConvertPBToRecord(xRecordData, pRecord);
}
else
{
//TODO
//error
}
}
}
return true;
}
bool NFCSceneAOIModule::DestroySceneNPC(const int nSceneID, const int nGroupID)
{
NF_SHARE_PTR<NFCSceneInfo> pSceneInfo = GetElement(nSceneID);
if (pSceneInfo)
{
if (pSceneInfo->GetElement(nGroupID))
{
NFDataList xMonsterlistObject;
if (m_pKernelModule->GetGroupObjectList(nSceneID, nGroupID, xMonsterlistObject, false))
{
for (int i = 0; i < xMonsterlistObject.GetCount(); ++i)
{
NFGUID ident = xMonsterlistObject.Object(i);
m_pKernelModule->DestroyObject(ident);
}
}
pSceneInfo->RemoveElement(nGroupID);
return true;
}
}
return false;
}
bool NFCTeamModule::LeaveTeam( const NFGUID& self, const NFGUID& xTeamID )
{
NF_SHARE_PTR<NFIRecordManager> pRecordManager = m_pCommonRedisModule->GetCacheRecordInfo(xTeamID, NFrame::Team::ThisName());
if (!pRecordManager)
{
return false;
}
NF_SHARE_PTR<NFIRecord> pMemberRecord = pRecordManager->GetElement(NFrame::Team::MemberList::ThisName());
if (!pMemberRecord.get())
{
return false;
}
NFDataList varList;
pMemberRecord->FindObject(NFrame::Team::MemberList::GUID, self, varList);
if (varList.GetCount() == 0)
{
return false;
}
const int nRow = varList.Int32(0);
if (!pMemberRecord->Remove(nRow))
{
return false;
}
return m_pCommonRedisModule->SaveCacheRecordInfo(xTeamID, pRecordManager);
}
bool NFCCommonRedisModule::ConvertVectorToPropertyManager(std::vector<std::string>& vKeyList, std::vector<std::string>& vValueList, NF_SHARE_PTR<NFIPropertyManager> pPropertyManager)
{
if (vKeyList.size() == vValueList.size())
{
for (int i = 0; i < vKeyList.size(); ++i)
{
const std::string& strKey = vKeyList[i];
const std::string& strValue = vValueList[i];
if (strValue.empty())
{
continue;
}
NF_SHARE_PTR<NFIProperty> pProperty = pPropertyManager->GetElement(strKey);
if (!pProperty->GetCache() && !pProperty->GetSave())
{
continue;
}
if(!pProperty->FromString(strValue))
{
//TODO
//error
}
}
}
return true;
}
bool NFCEventProcessModule::DoEvent(const NFIDENTID& objectID, const int nEventID, const NFIDataList& valueList, const bool bSync)
{
if (bSync)
{
NF_SHARE_PTR<NFCObjectEventInfo> pObjectEventInfo = mObjectEventInfoMapEx.GetElement(objectID);
if (nullptr == pObjectEventInfo)
{
return false;
}
NF_SHARE_PTR<NFEventList> pEventInfo = pObjectEventInfo->GetElement(nEventID);
if (nullptr == pEventInfo)
{
return false;
}
EVENT_PROCESS_FUNCTOR_PTR cb;
bool bRet = pEventInfo->First(cb);
while (bRet)
{
cb.get()->operator()(objectID, nEventID, valueList);
bRet = pEventInfo->Next(cb);
}
}
else
{
NF_SHARE_PTR<NFCObjectAsyncEventInfo> pObjectEventInfo = mObjectSyncEventInfoMapEx.GetElement(objectID);
if (nullptr == pObjectEventInfo)
{
return false;
}
NF_SHARE_PTR<NFAsyncEventFunc> pEventInfo = pObjectEventInfo->GetElement(nEventID);
if (nullptr == pEventInfo)
{
return false;
}
pPluginManager->GetActorManager()->SendMsgToActor(pEventInfo->nActorID, objectID, nEventID, valueList.String(0), pEventInfo);
}
return true;
}
bool NFCSceneProcessModule::LoadSceneResource( const int nSceneID )
{
char szSceneIDName[MAX_PATH] = { 0 };
sprintf( szSceneIDName, "%d", nSceneID );
const std::string& strSceneFilePath = m_pElementInfoModule->GetPropertyString( szSceneIDName, NFrame::Scene::FilePath() );
const int nCanClone = m_pElementInfoModule->GetPropertyInt( szSceneIDName, NFrame::Scene::CanClone() );
//场景对应资源
NF_SHARE_PTR<NFMapEx<std::string, SceneSeedResource>> pSceneResourceMap = mtSceneResourceConfig.GetElement( nSceneID );
if ( !pSceneResourceMap.get() )
{
pSceneResourceMap = NF_SHARE_PTR<NFMapEx<std::string, SceneSeedResource>>(NF_NEW NFMapEx<std::string, SceneSeedResource>());
mtSceneResourceConfig.AddElement( nSceneID, pSceneResourceMap );
}
rapidxml::file<> xFileSource( strSceneFilePath.c_str() );
rapidxml::xml_document<> xFileDoc;
xFileDoc.parse<0>( xFileSource.data() );
//资源文件列表
rapidxml::xml_node<>* pSeedFileRoot = xFileDoc.first_node();
for ( rapidxml::xml_node<>* pSeedFileNode = pSeedFileRoot->first_node(); pSeedFileNode; pSeedFileNode = pSeedFileNode->next_sibling() )
{
//种子具体信息
std::string strSeedID = pSeedFileNode->first_attribute( "ID" )->value();
std::string strConfigID = pSeedFileNode->first_attribute( "NPCConfigID" )->value();
float fSeedX = lexical_cast<float>(pSeedFileNode->first_attribute( "SeedX" )->value());
float fSeedY = lexical_cast<float>(pSeedFileNode->first_attribute( "SeedY" )->value());
float fSeedZ = lexical_cast<float>(pSeedFileNode->first_attribute( "SeedZ" )->value());
if (!m_pElementInfoModule->ExistElement(strConfigID))
{
assert(0);
}
NF_SHARE_PTR<SceneSeedResource> pSeedResource = pSceneResourceMap->GetElement(strSeedID);
if ( !pSeedResource.get() )
{
pSeedResource = NF_SHARE_PTR<SceneSeedResource>(NF_NEW SceneSeedResource());
pSceneResourceMap->AddElement( strSeedID, pSeedResource );
}
pSeedResource->strSeedID = strSeedID;
pSeedResource->strConfigID = strConfigID;
pSeedResource->fSeedX = fSeedX;
pSeedResource->fSeedY = fSeedY;
pSeedResource->fSeedZ = fSeedZ;
}
return true;
}
bool NFCEventProcessModule::HasEventCallBack(const NFIDENTID& objectID, const int nEventID)
{
NF_SHARE_PTR<NFCObjectEventInfo> pObjectEventInfo = mObjectEventInfoMapEx.GetElement(objectID);
if (nullptr != pObjectEventInfo)
{
NF_SHARE_PTR<NFEventList> pEventInfo = pObjectEventInfo->GetElement(nEventID);
if (nullptr != pEventInfo)
{
return true;
}
}
return false;
}
NFINT64 NFCPropertyConfigModule::CalculateBaseValue(const int nJob, const int nLevel, const std::string& strProperty)
{
NF_SHARE_PTR <NFMapEx<int, std::string> > xPropertyMap = mhtCoefficienData.GetElement(nJob);
if (xPropertyMap)
{
NF_SHARE_PTR<std::string> xRefPropertyIDName = xPropertyMap->GetElement(nLevel);
if (xRefPropertyIDName)
{
return m_pElementModule->GetPropertyInt(*xRefPropertyIDName, strProperty);
}
}
return 0;
}
const std::string& NFCCommonConfigModule::GetFieldString(const std::string& strStructName, const std::string& strStructItemName, const std::string& strAttribute)
{
NF_SHARE_PTR<CStructInfo> pSDKInfo = mmData.GetElement(strStructName);
if (pSDKInfo)
{
NF_SHARE_PTR<CAttributeList> pParam = pSDKInfo->GetElement(strStructItemName);
if (pParam)
{
return pParam->GetString(strAttribute);
}
}
return NULL_STR;
}
void NFCRecordLogic::OnSwapRow(const int nSockIndex, const int nMsgID, const char* msg, const uint32_t nLen)
{
NFGUID nPlayerID;
NFMsg::ObjectRecordSwap xMsg;
if (!NFINetModule::ReceivePB(nSockIndex, nMsgID, msg, nLen, xMsg, nPlayerID))
{
return;
}
NF_SHARE_PTR<NFIObject> object = g_pKernelModule->GetObject(NFINetModule::PBToNF(xMsg.player_id()));
NF_SHARE_PTR<NFIRecordManager> recordMgr = object->GetRecordManager();
NF_SHARE_PTR<NFIRecord> record = recordMgr->GetElement(xMsg.origin_record_name());
record->SwapRowInfo(xMsg.row_origin(), xMsg.row_target());
}
bool NFCPropertyConfigModule::LegalLevel(const int nJob, const int nLevel)
{
NF_SHARE_PTR <NFMapEx<int, std::string> > xPropertyMap = mhtCoefficienData.GetElement(nJob);
if (xPropertyMap)
{
NF_SHARE_PTR<std::string> xRefPropertyIDName = xPropertyMap->GetElement(nLevel);
if (xRefPropertyIDName)
{
return true;
}
}
return false;
}
int NFCItemModule::AddItemEffectDataProperty(const NFGUID& self, const NFGUID& xTarget, const std::string& strItemID)
{
if (strItemID.empty())
{
return 1;
}
//////////////////////////////////////////////////////////////////////////
NF_SHARE_PTR<NFIObject> pObject = m_pKernelModule->GetObject(xTarget);
if (NULL == pObject)
{
//m_pLogModule->LogObject(NFILogModule::NLL_ERROR_NORMAL, self, "There is no object", __FUNCTION__, __LINE__);
return 1;
}
//////////////////////////////////////////////////////////////////////////
NF_SHARE_PTR<NFIPropertyManager> pPropertyManager = m_pElementModule->GetPropertyManager(strItemID);
if (!pPropertyManager)
{
return 1;
}
NF_SHARE_PTR<NFIProperty> pEffectDataProperty = pPropertyManager->GetElement("EffectData");
if (!pEffectDataProperty)
{
return 1;
}
NF_SHARE_PTR<NFIPropertyManager> pEffectDataPropertyManager = m_pElementModule->GetPropertyManager(pEffectDataProperty->GetString());
if (!pEffectDataPropertyManager)
{
return 1;
}
NF_SHARE_PTR<NFIProperty> pProperty = pEffectDataPropertyManager->First();
while (pProperty)
{
if (pProperty->GetInt() != 0)
{
m_pPropertyModule->AddPropertyValue(xTarget, pProperty->GetKey(), NFIPropertyModule::NPG_EQUIP, pProperty->GetInt());
}
pProperty = pEffectDataPropertyManager->Next();
}
return 0;
}
void NFCRecordLogic::AddRecord(const NF_SHARE_PTR<NFIObject>& object, const std::string &strRecordName, const NFMsg::RecordAddRowStruct &data)
{
NF_SHARE_PTR<NFIRecordManager> recordMgr = object->GetRecordManager();
NF_SHARE_PTR<NFDataList> varData = NF_SHARE_PTR<NFDataList>(NF_NEW NFDataList());
NF_SHARE_PTR<NFDataList> varInit = NF_SHARE_PTR<NFDataList>(NF_NEW NFDataList());
NF_SHARE_PTR<NFDataList> varTag = NF_SHARE_PTR<NFDataList>(NF_NEW NFDataList());
for(int j = 0; j < data.record_float_list_size(); j++)
{
varInit->AddFloat(0);
varData->AddFloat(data.record_float_list(j).data());
}
for(int j = 0; j < data.record_int_list_size(); j++)
{
varInit->AddInt(0);
varData->AddInt(data.record_int_list(j).data());
}
for(int j = 0; j < data.record_string_list_size(); j++)
{
varInit->AddString("");
varData->AddString(data.record_string_list(j).data());
}
for(int j = 0; j < data.record_object_list_size(); j++)
{
varInit->AddObject(NFGUID());
varData->AddObject(NFINetModule::PBToNF(data.record_object_list(j).data()));
}
for(int j = 0; j < data.record_vector2_list_size(); j++)
{
varInit->AddVector2(NFVector2());
varData->AddVector2(NFINetModule::PBToNF(data.record_vector2_list(j).data()));
}
for(int j = 0; j < data.record_vector3_list_size(); j++)
{
varInit->AddVector3(NFVector3());
varData->AddVector3(NFINetModule::PBToNF(data.record_vector3_list(j).data()));
}
NF_SHARE_PTR<NFIRecord> record = recordMgr->GetElement(strRecordName);
if(record == nullptr)
{
record = recordMgr->AddRecord(NFGUID(), strRecordName, varInit, varTag, 255);
}
record->AddRow(data.row(), *varData);
}
void NFCRecordLogic::OnRemoveRow(const int nSockIndex, const int nMsgID, const char* msg, const uint32_t nLen)
{
NFGUID nPlayerID;
NFMsg::ObjectRecordRemove xMsg;
if (!NFINetModule::ReceivePB(nSockIndex, nMsgID, msg, nLen, xMsg, nPlayerID))
{
return;
}
NF_SHARE_PTR<NFIObject> object = g_pKernelModule->GetObject(NFINetModule::PBToNF(xMsg.player_id()));
NF_SHARE_PTR<NFIRecordManager> recordMgr = object->GetRecordManager();
for(int i = 0; i < xMsg.remove_row_size(); i++)
{
NF_SHARE_PTR<NFIRecord> record = recordMgr->GetElement(xMsg.record_name());
record->Remove(xMsg.remove_row(i));
}
}
bool NFCTeamModule::JoinTeam( const NFGUID& self, const NFGUID& xTeamID )
{
NF_SHARE_PTR<NFIRecordManager> pRecordManager = m_pCommonRedisModule->GetCacheRecordInfo(xTeamID, NFrame::Team::ThisName());
if (!pRecordManager)
{
return false;
}
NF_SHARE_PTR<NFIRecord> pMemberRecord = pRecordManager->GetElement(NFrame::Team::MemberList::ThisName());
if (!pMemberRecord.get())
{
return false;
}
NFDataList varList;
pMemberRecord->FindObject(NFrame::Team::MemberList::GUID, self, varList);
if (varList.GetCount() > 0)
{
return false;
}
NFDataList varData;
std::string strName ;
int nLevel = 0;
int nJob = 0;
int nDonation = 0;
int nReceive = 0;
int nVIP = 0;
int nOnLine = 0;
int nTitle = 0;
int nOnlineGameID = 0;
GetPlayerGameID(self, nOnlineGameID);
varData << self << strName << (NFINT64)nLevel << (NFINT64)nJob << (NFINT64)nDonation << (NFINT64)nReceive << (NFINT64)nVIP << (NFINT64)nOnLine << nTitle << nOnlineGameID ;
if (pMemberRecord->AddRow(-1, varData) < 0)
{
return false;
}
return m_pCommonRedisModule->SaveCacheRecordInfo(xTeamID, pRecordManager);
}
bool NFCCreateRoleModule::ConvertPBToRecordManager(const NFMsg::ObjectRecordList & pRecordData, NF_SHARE_PTR<NFIRecordManager> pRecord)
{
if (pRecord == nullptr)
{
return false;
}
for (int i = 0; i < pRecordData.record_list_size(); ++i)
{
const NFMsg::ObjectRecordBase& xRecordBase = pRecordData.record_list(i);
NF_SHARE_PTR<NFIRecord> xRecord = pRecord->GetElement(xRecordBase.record_name());
if (xRecord)
{
ConvertPBToRecord(xRecordBase, xRecord);
}
}
return true;
}
void NFCRecordLogic::OnRecordString(const int nSockIndex, const int nMsgID, const char* msg, const uint32_t nLen)
{
NFGUID nPlayerID;
NFMsg::ObjectRecordString xMsg;
if (!NFINetModule::ReceivePB(nSockIndex, nMsgID, msg, nLen, xMsg, nPlayerID))
{
return;
}
NF_SHARE_PTR<NFIObject> object = g_pKernelModule->GetObject(NFINetModule::PBToNF(xMsg.player_id()));
NF_SHARE_PTR<NFIRecordManager> recordMgr = object->GetRecordManager();
for(int i = 0; i < xMsg.property_list_size(); i++)
{
NF_SHARE_PTR<NFIRecord> record = recordMgr->GetElement(xMsg.record_name());
const NFMsg::RecordString &recordString = xMsg.property_list(i);
record->SetString(recordString.row(), recordString.col(), recordString.data());
}
}
bool NFCEventProcessModule::RemoveEventCallBack(const NFIDENTID& objectID, const int nEventID/*, const EVENT_PROCESS_FUNCTOR_PTR& cb*/)
{
NF_SHARE_PTR<NFCObjectEventInfo> pObjectEventInfo = mObjectEventInfoMapEx.GetElement(objectID);
if (nullptr != pObjectEventInfo)
{
NF_SHARE_PTR<NFEventList> pEventInfo = pObjectEventInfo->GetElement(nEventID);
if (pEventInfo.get())
{
NF_SHARE_PTR<NFList<int>> pList = mRemoveEventListEx.GetElement(objectID);
if (!pList.get())
{
pList = NF_SHARE_PTR<NFList<int>>(NF_NEW NFList<int>());
mRemoveEventListEx.AddElement(objectID, pList);
}
pList->Add(nEventID);
return true;
}
}
return false;
}
bool NFCTileModule::AddTile(const NFGUID & self, const int nX, const int nY, const int nOpr)
{
NF_SHARE_PTR<TileData> xTileData = mxTileData.GetElement(self);
if (!xTileData)
{
xTileData = NF_SHARE_PTR<TileData>(NF_NEW TileData());
mxTileData.AddElement(self, xTileData);
}
NF_SHARE_PTR<NFMapEx<int, TileState>> xStateDataMap = xTileData->mxTileState.GetElement(nX);
if (!xStateDataMap)
{
xStateDataMap = NF_SHARE_PTR<NFMapEx<int, TileState>>(NF_NEW NFMapEx<int, TileState>());
xTileData->mxTileState.AddElement(nX, xStateDataMap);
}
NF_SHARE_PTR<TileState> xTileState = xStateDataMap->GetElement(nY);
if (!xTileState)
{
xTileState = NF_SHARE_PTR<TileState>(NF_NEW TileState());
xStateDataMap->AddElement(nY, xTileState);
}
else
{
if (nOpr == xTileState->state)
{
//has be deleted
return false;
}
}
xTileState->x = nX;
xTileState->y = nY;
xTileState->state = nOpr;
//save
//SaveTileData(self);
return true;
}
bool NFCEventProcessModule::AddEventCallBack(const NFIDENTID& objectID, const int nEventID, const EVENT_PROCESS_FUNCTOR_PTR& cb)
{
NF_SHARE_PTR<NFCObjectEventInfo> pObjectEventInfo = mObjectEventInfoMapEx.GetElement(objectID);
if (!pObjectEventInfo.get())
{
pObjectEventInfo = NF_SHARE_PTR<NFCObjectEventInfo>(NF_NEW NFCObjectEventInfo());
mObjectEventInfoMapEx.AddElement(objectID, pObjectEventInfo);
}
assert(nullptr != pObjectEventInfo);
NF_SHARE_PTR<NFEventList> pEventInfo = pObjectEventInfo->GetElement(nEventID);
if (!pEventInfo)
{
pEventInfo = NF_SHARE_PTR<NFEventList>(NF_NEW NFEventList());
pObjectEventInfo->AddElement(nEventID, pEventInfo);
}
assert(nullptr != pEventInfo);
pEventInfo->Add(cb);
return true;
}
bool NFCElementInfoModule::Load(rapidxml::xml_node<>* attrNode, NF_SHARE_PTR<NFILogicClass> pLogicClass)
{
//attrNode is the node of a object
std::string strConfigID = attrNode->first_attribute("ID")->value();
if (strConfigID.empty())
{
NFASSERT(0, strConfigID, __FILE__, __FUNCTION__);
return false;
}
if (ExistElement(strConfigID))
{
NFASSERT(0, strConfigID, __FILE__, __FUNCTION__);
return false;
}
NF_SHARE_PTR<ElementConfigInfo> pElementInfo(NF_NEW ElementConfigInfo());
AddElement(strConfigID, pElementInfo);
//can find all configid by class name
pLogicClass->AddConfigName(strConfigID);
//ElementConfigInfo* pElementInfo = CreateElement( strConfigID, pElementInfo );
NF_SHARE_PTR<NFIPropertyManager> pElementPropertyManager = pElementInfo->GetPropertyManager();
NF_SHARE_PTR<NFIRecordManager> pElementRecordManager = pElementInfo->GetRecordManager();
//1.add property
//2.set the default value of them
NF_SHARE_PTR<NFIPropertyManager> pClassPropertyManager = pLogicClass->GetPropertyManager();
NF_SHARE_PTR<NFIRecordManager> pClassRecordManager = pLogicClass->GetRecordManager();
if (pClassPropertyManager.get() && pClassRecordManager.get())
{
NF_SHARE_PTR<NFIProperty> pProperty = pClassPropertyManager->First();
while (pProperty.get())
{
pElementPropertyManager->AddProperty(NFGUID(), pProperty);
pProperty = pClassPropertyManager->Next();
}
NF_SHARE_PTR<NFIRecord> pRecord = pClassRecordManager->First();
while (pRecord.get())
{
pElementRecordManager->AddRecord(NFGUID(), pRecord->GetName(), pRecord->GetInitData(), pRecord->GetKeyState(), pRecord->GetInitDesc(), pRecord->GetTag(), pRecord->GetRelatedRecord(), pRecord->GetRows(), pRecord->GetPublic(), pRecord->GetPrivate(), pRecord->GetSave(), pRecord->GetView(), pRecord->GetIndex());
pRecord = pClassRecordManager->Next();
}
}
//3.set the config value to them
//const char* pstrConfigID = attrNode->first_attribute( "ID" );
for (rapidxml::xml_attribute<>* pAttribute = attrNode->first_attribute(); pAttribute; pAttribute = pAttribute->next_attribute())
{
const char* pstrConfigName = pAttribute->name();
const char* pstrConfigValue = pAttribute->value();
//printf( "%s : %s\n", pstrConfigName, pstrConfigValue );
NF_SHARE_PTR<NFIProperty> temProperty = pElementPropertyManager->GetElement(pstrConfigName);
if (!temProperty)
{
continue;
}
NFIDataList::TData var;
TDATA_TYPE eType = temProperty->GetType();
switch (eType)
{
case TDATA_INT:
{
if (!LegalNumber(pstrConfigValue))
{
NFASSERT(0, temProperty->GetKey(), __FILE__, __FUNCTION__);
}
var.SetInt(lexical_cast<NFINT64>(pstrConfigValue));
}
break;
case TDATA_FLOAT:
{
if (strlen(pstrConfigValue) <= 0)
{
NFASSERT(0, temProperty->GetKey(), __FILE__, __FUNCTION__);
}
var.SetFloat((double)atof(pstrConfigValue));
}
break;
case TDATA_STRING:
var.SetString(pstrConfigValue);
break;
case TDATA_OBJECT:
{
if (strlen(pstrConfigValue) <= 0)
{
NFASSERT(0, temProperty->GetKey(), __FILE__, __FUNCTION__);
}
var.SetObject(NFGUID());
}
break;
default:
NFASSERT(0, temProperty->GetKey(), __FILE__, __FUNCTION__);
break;
}
pElementPropertyManager->SetProperty(pstrConfigName, var);
}
NFIDataList::TData xData;
xData.SetString(pLogicClass->GetClassName());
pElementPropertyManager->SetProperty("ClassName", xData);
return true;
}
int NFCSceneAOIModule::GetBroadCastObject(const NFGUID & self, const std::string & strPropertyName, const bool bTable, NFDataList & valueObject)
{
int nObjectContainerID = m_pKernelModule->GetPropertyInt32(self, NFrame::IObject::SceneID());
int nObjectGroupID = m_pKernelModule->GetPropertyInt32(self, NFrame::IObject::GroupID());
const std::string& strClassName = m_pKernelModule->GetPropertyString(self, NFrame::IObject::ClassName());
NF_SHARE_PTR<NFIRecordManager> pClassRecordManager = m_pClassModule->GetClassRecordManager(strClassName);
NF_SHARE_PTR<NFIPropertyManager> pClassPropertyManager = m_pClassModule->GetClassPropertyManager(strClassName);
NF_SHARE_PTR<NFIRecord> pRecord(NULL);
NF_SHARE_PTR<NFIProperty> pProperty(NULL);
if (bTable)
{
if (NULL == pClassRecordManager)
{
return -1;
}
pRecord = pClassRecordManager->GetElement(strPropertyName);
if (NULL == pRecord)
{
return -1;
}
}
else
{
if (NULL == pClassPropertyManager)
{
return -1;
}
pProperty = pClassPropertyManager->GetElement(strPropertyName);
if (NULL == pProperty)
{
return -1;
}
}
if (bTable)
{
//upload property can not board to itself
if (!pRecord->GetUpload())
{
if (pRecord->GetPublic())
{
m_pKernelModule->GetGroupObjectList(nObjectContainerID, nObjectGroupID, valueObject, true, self);
}
if (pRecord->GetPrivate())
{
valueObject.Add(self);
}
}
}
else
{
//upload property can not board to itself
if (!pProperty->GetUpload())
{
if (pProperty->GetPublic())
{
m_pKernelModule->GetGroupObjectList(nObjectContainerID, nObjectGroupID, valueObject, true, self);
}
if (pProperty->GetPrivate())
{
valueObject.Add(self);
}
}
}
return valueObject.GetCount();
}
bool NFCSceneAOIModule::SwitchScene(const NFGUID& self, const int nTargetSceneID, const int nTargetGroupID, const int nType, const NFVector3 v, const float fOrient, const NFDataList& arg)
{
NF_SHARE_PTR<NFIObject> pObject = m_pKernelModule->GetObject(self);
if (pObject)
{
int nOldSceneID = pObject->GetPropertyInt32(NFrame::Scene::SceneID());
int nOldGroupID = pObject->GetPropertyInt32(NFrame::Scene::GroupID());
NF_SHARE_PTR<NFCSceneInfo> pOldSceneInfo = this->GetElement(nOldSceneID);
NF_SHARE_PTR<NFCSceneInfo> pNewSceneInfo = this->GetElement(nTargetSceneID);
if (!pOldSceneInfo)
{
m_pLogModule->LogNormal(NFILogModule::NLL_ERROR_NORMAL, self, "no this container", nOldSceneID);
return false;
}
if (!pNewSceneInfo)
{
m_pLogModule->LogNormal(NFILogModule::NLL_ERROR_NORMAL, self, "no this container", nTargetSceneID);
return false;
}
if (!pNewSceneInfo->GetElement(nTargetGroupID))
{
m_pLogModule->LogNormal(NFILogModule::NLL_ERROR_NORMAL, self, "no this group", nTargetGroupID);
return false;
}
/////////
BeforeLeaveSceneGroup(self, nOldSceneID, nOldGroupID, nType, arg);
pOldSceneInfo->RemoveObjectFromGroup(nOldGroupID, self, true);
//if (nTargetSceneID != nOldSceneID)
{
pObject->SetPropertyInt(NFrame::Scene::GroupID(), 0);
/////////
AfterLeaveSceneGroup(self, nOldSceneID, nOldGroupID, nType, arg);
pObject->SetPropertyInt(NFrame::Scene::SceneID(), nTargetSceneID);
OnSwapSceneEvent(self, nTargetSceneID, nTargetGroupID, nType, arg);
}
pObject->SetPropertyVector3(NFrame::IObject::Position(), v);
////////
BeforeEnterSceneGroup(self, nTargetSceneID, nTargetGroupID, nType, arg);
pNewSceneInfo->AddObjectToGroup(nTargetGroupID, self, true);
pObject->SetPropertyInt(NFrame::Scene::GroupID(), nTargetGroupID);
/////////
AfterEnterSceneGroup(self, nTargetSceneID, nTargetGroupID, nType, arg);
return true;
}
m_pLogModule->LogObject(NFILogModule::NLL_ERROR_NORMAL, self, "There is no object", __FUNCTION__, __LINE__);
return false;
}
NFGUID NFCTeamModule::CreateTeam( const NFGUID& self, const NFGUID& xDefaultTeamID, const std::string& strName, const std::string& strRoleName, const int nLevel, const int nJob , const int nDonation , const int nVIP)
{
if (strName.empty())
{
return NULL_OBJECT;
}
NFGUID xTeam = xDefaultTeamID;
if (xTeam.IsNull())
{
xTeam = m_pKernelModule->CreateGUID();
}
NF_SHARE_PTR<NFIPropertyManager> pPropertyManager = m_pCommonRedisModule->NewPropertyManager(NFrame::Team::ThisName());
NF_SHARE_PTR<NFIRecordManager> pRecordManager = m_pCommonRedisModule->NewRecordManager(NFrame::Team::ThisName());
if (!pPropertyManager)
{
return NFGUID();
}
if (!pRecordManager)
{
return NFGUID();
}
NF_SHARE_PTR<NFIRecord> pMemberRecord = pRecordManager->GetElement(NFrame::Team::MemberList::ThisName());
if (!pMemberRecord.get())
{
return NFGUID();
}
NFDataList varList;
pMemberRecord->FindObject(NFrame::Team::MemberList::GUID, self, varList);
if (varList.GetCount() > 0)
{
return NFGUID();
}
NFDataList varData;
int nReceive = 0;
int nOnLine = 0;
int nTitle = 0;
int nOnlineGameID = 0;
GetPlayerGameID(self, nOnlineGameID);
varData << self << strName << (NFINT64)nLevel << (NFINT64)nJob << (NFINT64)nDonation << (NFINT64)nReceive << (NFINT64)nVIP << (NFINT64)nOnLine << nTitle << nOnlineGameID;
if (pMemberRecord->AddRow(-1, varData) < 0)
{
return NFGUID();
}
if (!pPropertyManager->SetPropertyObject(NFrame::Team::Captain(), self))
{
return NFGUID();
}
if (!m_pCommonRedisModule->SaveCachePropertyInfo(xTeam, pPropertyManager))
{
return NFGUID();
}
if (!m_pCommonRedisModule->SaveCacheRecordInfo(xTeam, pRecordManager))
{
return NFGUID();
}
return xTeam;
}
bool NFCTeamModule::GetTeamInfo(const NFGUID& self, const NFGUID& xTeam, NFMsg::TeamInfo& xTeamInfo)
{
if (xTeam.IsNull())
{
return false;
}
NF_SHARE_PTR<NFIPropertyManager> pPropertyManager = m_pCommonRedisModule->GetCachePropertyInfo(xTeam, NFrame::Team::ThisName());
NF_SHARE_PTR<NFIRecordManager> pRecordManager = m_pCommonRedisModule->GetCacheRecordInfo(xTeam, NFrame::Team::ThisName());
if (!pPropertyManager)
{
return false;
}
if (!pRecordManager)
{
return false;
}
NF_SHARE_PTR<NFIRecord> pMemberRecord = pRecordManager->GetElement(NFrame::Team::MemberList::ThisName());
if (!pMemberRecord.get())
{
return false;
}
NFGUID xCaptain = pPropertyManager->GetPropertyObject(NFrame::Team::Captain());
if (!xCaptain.IsNull())
{
return false;
}
*xTeamInfo.mutable_team_id() = NFINetModule::NFToPB(xTeam);
*xTeamInfo.mutable_captain_id() = NFINetModule::NFToPB(xCaptain);
for (int i = 0; i < pMemberRecord->GetRows(); i++)
{
if (!pMemberRecord->IsUsed(i))
{
continue;
}
NFMsg::TeammemberInfo* pMemberinfo = xTeamInfo.add_teammemberinfo();
if (!pMemberinfo)
{
continue;
}
std::string strName = pMemberRecord->GetString(i, NFrame::Team::MemberList::Name);
const int nLevel = pMemberRecord->GetInt32(i, NFrame::Team::MemberList::Level);
const int nJob = pMemberRecord->GetInt32(i, NFrame::Team::MemberList::Job);
const NFGUID xPlayerID = pMemberRecord->GetObject(i, NFrame::Team::MemberList::GUID);
pMemberinfo->set_name(strName);
pMemberinfo->set_nlevel(nLevel);
pMemberinfo->set_job(nJob);
pMemberinfo->set_headicon("");
*pMemberinfo->mutable_player_id() = NFINetModule::NFToPB(xPlayerID);
}
return true;
}
int NFCPotionItemConsumeProcessModule::ConsumeProcess( const NFIDENTID& self, const std::string& strItemName, const NFIDataList& other )
{
//附加效果
NF_SHARE_PTR<NFIPropertyManager> pPropertyManager = m_pElementInfoModule->GetPropertyManager( strItemName );
if ( pPropertyManager )
{
NF_SHARE_PTR<NFIProperty> pItemEffectProperty = pPropertyManager->GetElement( "EffectProperty" );
NF_SHARE_PTR<NFIProperty> pItemEffectValue = pPropertyManager->GetElement( "EffectValue" );
if ( pItemEffectProperty && pItemEffectValue )
{
NFCDataList valueEffectProperty( pItemEffectProperty->GetString().c_str(), "," );
NFCDataList valueEffectValue( pItemEffectValue->GetString().c_str(), "," );
if ( valueEffectProperty.GetCount() == valueEffectValue.GetCount() )
{
for ( int i = 0; i < valueEffectProperty.GetCount(); i++ )
{
//先测定目标是否有此属性(其实是担心配错了)
for ( int j = 0; j < other.GetCount(); j++ )
{
NFIDENTID identOther = other.Object( j );
if ( !identOther.IsNull() )
{
NF_SHARE_PTR<NFIObject> pObject = m_pKernelModule->GetObject( identOther );
if ( pObject )
{
std::string strCurProperty = valueEffectProperty.String( i );
std::string strMaxProperty = "MAX" + strCurProperty;
NF_SHARE_PTR<NFIProperty> pOtherCurProperty = pObject->GetPropertyManager()->GetElement( strCurProperty );
NF_SHARE_PTR<NFIProperty> pOtherMaxProperty = pObject->GetPropertyManager()->GetElement( strMaxProperty );
if ( pOtherCurProperty && pOtherMaxProperty )
{
//药物，只能是绝对值，百分比不要了，百分比让BUFF去做
//而且，只有最大值的那种，才能使用，因此，这里只能有 HP MP CSP 3样属性
//重要的是，不能超过最大值，这几个属性那个都是整型数据
//类似最大HP之类的，不能通过药剂直接修改属性，而是通过BUFF来修改，只要是分层属性都通过BUFF修改
int nAddValue = boost::lexical_cast<int>( valueEffectValue.String( i ) );
if ( "EXP" == strCurProperty )
{
m_pLevelModule->AddExp( self, nAddValue );
}
else if ( "HP" == strCurProperty )
{
m_pPropertyModule->AddHP( self, nAddValue );
}
else if ( "MP" == strCurProperty )
{
m_pPropertyModule->AddMP( self, nAddValue );
}
}
else
{
m_pLogModule->LogProperty(NFILogModule::NLL_ERROR_NORMAL, self, strCurProperty, "", __FUNCTION__, __LINE__);
return 0;
}
}
}
}
}
return other.GetCount();
}
}
}
m_pLogModule->LogProperty(NFILogModule::NLL_ERROR_NORMAL, self, strItemName, "", __FUNCTION__, __LINE__);
return 0;
}
bool NFCSceneProcessModule::LoadInitFileResource( const int& nContainerID )
{
char szSceneIDName[MAX_PATH] = { 0 };
sprintf( szSceneIDName, "%d", nContainerID );
const std::string& strSceneFilePath = m_pElementInfoModule->GetPropertyString( szSceneIDName, "FilePath" );
const int nCanClone = m_pElementInfoModule->GetPropertyInt( szSceneIDName, "CanClone" );
//场景对应资源
NF_SHARE_PTR<NFMapEx<std::string, SceneGroupResource>> pSceneResourceMap = mtSceneResourceConfig.GetElement( nContainerID );
if ( !pSceneResourceMap.get() )
{
pSceneResourceMap = NF_SHARE_PTR<NFMapEx<std::string, SceneGroupResource>>(NF_NEW NFMapEx<std::string, SceneGroupResource>());
mtSceneResourceConfig.AddElement( nContainerID, pSceneResourceMap );
}
if ( !strSceneFilePath.empty() )
{
std::string strFilePathName( strSceneFilePath );
strFilePathName.append( "File.xml" );
NF_SHARE_PTR<SceneGroupResource> pSceneGroupResource = pSceneResourceMap->GetElement( "File.xml" );
if ( !pSceneGroupResource.get() )
{
pSceneGroupResource = NF_SHARE_PTR<SceneGroupResource>(NF_NEW SceneGroupResource());
pSceneGroupResource->bCanClone = (nCanClone > 0 ? true : false);
pSceneResourceMap->AddElement( "File.xml", pSceneGroupResource );
}
rapidxml::file<> xFileSource( strFilePathName.c_str() );
rapidxml::xml_document<> xFileDoc;
xFileDoc.parse<0>( xFileSource.data() );
//资源文件列表
rapidxml::xml_node<>* pSeedFileRoot = xFileDoc.first_node();
for ( rapidxml::xml_node<>* pSeedFileNode = pSeedFileRoot->first_node(); pSeedFileNode; pSeedFileNode = pSeedFileNode->next_sibling() )
{
std::string strSeedFileName = pSeedFileNode->first_attribute( "ID" )->value();
//资源对应种子列表
NF_SHARE_PTR<NFMapEx<std::string, SceneSeedResource>> pSeedResourceList = pSceneGroupResource->xSceneGroupResource.GetElement(strSeedFileName);
if ( !pSeedResourceList.get() )
{
pSeedResourceList = NF_SHARE_PTR<NFMapEx<std::string, SceneSeedResource>>(NF_NEW NFMapEx<std::string, SceneSeedResource>());
pSceneGroupResource->xSceneGroupResource.AddElement( strSeedFileName, pSeedResourceList );
}
std::string strObjectFileName( strSceneFilePath );
strObjectFileName.append( strSeedFileName );
strObjectFileName.append( ".xml" );
rapidxml::file<> xSeedListSource( strObjectFileName.c_str() );
rapidxml::xml_document<> xFileDoc;
xFileDoc.parse<0>( xSeedListSource.data() );
rapidxml::xml_node<>* pSeedObjectRoot = xFileDoc.first_node();
for ( rapidxml::xml_node<>* pSeedObjectNode = pSeedObjectRoot->first_node(); pSeedObjectNode; pSeedObjectNode = pSeedObjectNode->next_sibling() )
{
//种子具体信息
std::string strSeedName = pSeedObjectNode->first_attribute( "ID" )->value();
std::string strConfigID = pSeedObjectNode->first_attribute( "NPCConfigID" )->value();
if (!m_pElementInfoModule->ExistElement(strConfigID))
{
assert(0);
}
NF_SHARE_PTR<SceneSeedResource> pSeedResource = pSeedResourceList->GetElement(strSeedName);
if ( !pSeedResource.get() )
{
pSeedResource = NF_SHARE_PTR<SceneSeedResource>(NF_NEW SceneSeedResource());
pSeedResourceList->AddElement( strSeedName, pSeedResource );
}
pSeedResource->strSeedID = strSeedName;
pSeedResource->strConfigID = strConfigID;
pSeedResource->fSeedX = boost::lexical_cast<float>(pSeedObjectNode->first_attribute( "SeedX" )->value());
pSeedResource->fSeedY = boost::lexical_cast<float>(pSeedObjectNode->first_attribute( "SeedY" )->value());
pSeedResource->fSeedZ = boost::lexical_cast<float>(pSeedObjectNode->first_attribute( "SeedZ" )->value());
}
}
}
return true;
}