int NFCPropertyTrailModule::TrailObjectData(const NFGUID& self)
{
NF_SHARE_PTR<NFIObject> xObject = m_pKernelModule->GetObject(self);
if (nullptr == xObject)
{
return -1;
}
NF_SHARE_PTR<NFIPropertyManager> xPropertyManager = xObject->GetPropertyManager();
if (nullptr != xPropertyManager)
{
NF_SHARE_PTR<NFIProperty> xProperty = xPropertyManager->First();
while (nullptr != xProperty)
{
m_pKernelModule->AddPropertyCallBack(self, xProperty->GetKey(), this, &NFCPropertyTrailModule::OnObjectPropertyEvent);
xProperty = xPropertyManager->Next();
}
}
NF_SHARE_PTR<NFIRecordManager> xRecordManager = xObject->GetRecordManager();
if (nullptr != xRecordManager)
{
NF_SHARE_PTR<NFIRecord> xRecord = xRecordManager->First();
while (nullptr != xRecord)
{
m_pKernelModule->AddRecordCallBack(self, xRecord->GetName(), this, &NFCPropertyTrailModule::OnObjectRecordEvent);
xRecord = xRecordManager->Next();
}
}
return 0;
}
int NFCPropertyTrailModule::LogObjectData(const NFGUID& self)
{
NF_SHARE_PTR<NFIObject> xObject = m_pKernelModule->GetObject(self);
if (nullptr == xObject)
{
return -1;
}
NF_SHARE_PTR<NFIPropertyManager> xPropertyManager = xObject->GetPropertyManager();
if (nullptr != xPropertyManager)
{
NF_SHARE_PTR<NFIProperty> xProperty = xPropertyManager->First();
while (nullptr != xProperty)
{
std::ostringstream stream;
stream << " Start trail ";
stream << xProperty->ToString();
m_pLogModule->LogProperty(NFILogModule::NF_LOG_LEVEL::NLL_INFO_NORMAL, self, xProperty->GetKey(), stream.str(), __FUNCTION__, __LINE__);
xProperty = xPropertyManager->Next();
}
}
NF_SHARE_PTR<NFIRecordManager> xRecordManager = xObject->GetRecordManager();
if (nullptr != xRecordManager)
{
NF_SHARE_PTR<NFIRecord> xRecord = xRecordManager->First();
while (nullptr != xRecord)
{
for (int i = 0; i < xRecord->GetRows(); ++i)
{
NFCDataList xDataList;
bool bRet = xRecord->QueryRow(i, xDataList);
if (bRet)
{
std::ostringstream stream;
stream << " Start trail Row[" << i << "]";
for (int j = 0; j < xDataList.GetCount(); ++j)
{
stream << " [" << j << "] " << xDataList.StringValEx(j);
}
m_pLogModule->LogRecord(NFILogModule::NF_LOG_LEVEL::NLL_INFO_NORMAL, self, xRecord->GetName(), stream.str(), __FUNCTION__, __LINE__);
}
}
xRecord = xRecordManager->Next();
}
}
return 0;
}
NF_SHARE_PTR<NFIRecordManager> NFCCommonRedisModule::NewRecordManager(const std::string& strClassName)
{
NF_SHARE_PTR<NFIRecordManager> pStaticClassRecordManager = m_pLogicClassModule->GetClassRecordManager(strClassName);
if (pStaticClassRecordManager)
{
NFGUID ident;
NF_SHARE_PTR<NFIRecordManager> pRecordManager(NF_NEW NFCRecordManager(ident));
NF_SHARE_PTR<NFIRecord> pConfigRecordInfo = pStaticClassRecordManager->First();
while (pConfigRecordInfo)
{
if (pConfigRecordInfo->GetSave() || pConfigRecordInfo->GetCache())
{
NF_SHARE_PTR<NFIRecord> xRecord = pRecordManager->AddRecord(ident,
pConfigRecordInfo->GetName(),
pConfigRecordInfo->GetInitData(),
pConfigRecordInfo->GetTag(),
pConfigRecordInfo->GetRows());
xRecord->SetPublic(pConfigRecordInfo->GetPublic());
xRecord->SetPrivate(pConfigRecordInfo->GetPrivate());
xRecord->SetSave(pConfigRecordInfo->GetSave());
xRecord->SetCache(pConfigRecordInfo->GetCache());
}
pConfigRecordInfo = pStaticClassRecordManager->Next();
}
return pRecordManager;
}
return NF_SHARE_PTR<NFIRecordManager>(NULL);
}
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;
}
NF_SHARE_PTR<NFIPropertyManager> NFCCommonRedisModule::NewPropertyManager(const std::string& strClassName)
{
NF_SHARE_PTR<NFIPropertyManager> pStaticClassPropertyManager = m_pLogicClassModule->GetClassPropertyManager(strClassName);
if (pStaticClassPropertyManager)
{
NFGUID ident;
NF_SHARE_PTR<NFIPropertyManager> pPropertyManager(NF_NEW NFCPropertyManager(ident));
NF_SHARE_PTR<NFIProperty> pStaticConfigPropertyInfo = pStaticClassPropertyManager->First();
while (pStaticConfigPropertyInfo)
{
if (pStaticConfigPropertyInfo->GetSave() || pStaticConfigPropertyInfo->GetCache())
{
NF_SHARE_PTR<NFIProperty> xProperty = pPropertyManager->AddProperty(ident, pStaticConfigPropertyInfo->GetKey(), pStaticConfigPropertyInfo->GetType());
xProperty->SetPublic(pStaticConfigPropertyInfo->GetPublic());
xProperty->SetPrivate(pStaticConfigPropertyInfo->GetPrivate());
xProperty->SetSave(pStaticConfigPropertyInfo->GetSave());
xProperty->SetCache(pStaticConfigPropertyInfo->GetCache());
xProperty->SetRef(pStaticConfigPropertyInfo->GetRef());
}
pStaticConfigPropertyInfo = pStaticClassPropertyManager->Next();
}
return pPropertyManager;
}
return NF_SHARE_PTR<NFIPropertyManager>(NULL);
}
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;
}
bool NFCEventProcessModule::DoEvent(const NFIDENTID& objectID, const std::string& strClassName, const CLASS_OBJECT_EVENT eClassEvent, const NFIDataList& valueList, const bool bSync)
{
NF_SHARE_PTR<NFCClassEventList> pEventList = mxClassEventInfoEx.GetElement(strClassName);
if (nullptr != pEventList)
{
CLASS_EVENT_FUNCTOR_PTR cb;
bool bRet = pEventList->First(cb);
while (bRet)
{
cb.get()->operator()(objectID, strClassName, eClassEvent, valueList);
bRet = pEventList->Next(cb);
}
}
return false;
}
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;
}
NF_SHARE_PTR<NFIPropertyManager> NFCCommonRedisModule::GetPropertyInfo(const NFGUID& self, const std::string& strClassName, std::vector<std::string>& vKeyCacheList, std::vector<std::string>& vValueCacheList)
{
//TODO optimize
NF_SHARE_PTR<NFIPropertyManager> pPropertyManager = NewPropertyManager(strClassName);
if (!pPropertyManager)
{
return nullptr;
}
NF_SHARE_PTR<NFIRedisClient> pDriver = m_pNoSqlModule->GetDriverBySuit(self.ToString());
if (!pDriver)
{
return nullptr;
}
//TODO
//just run this function one time
NF_SHARE_PTR<NFIProperty> xProperty = pPropertyManager->First();
while (xProperty)
{
if (xProperty->GetCache() || xProperty->GetSave())
{
vKeyCacheList.push_back(xProperty->GetKey());
}
xProperty = pPropertyManager->Next();
}
//cache
std::string strCacheKey = GetPropertyCacheKey(self);
if (!pDriver->HMGET(strCacheKey, vKeyCacheList, vValueCacheList))
{
return nullptr;
}
if (vKeyCacheList.size() == vValueCacheList.size())
{
ConvertVectorToPropertyManager(vKeyCacheList, vValueCacheList, pPropertyManager);
return pPropertyManager;
}
return nullptr;
}
NF_SHARE_PTR<NFIRecordManager> NFCCommonRedisModule::GetRecordInfo(const NFGUID& self, const std::string& strClassName, std::vector<std::string>& vKeyCacheList, std::vector<std::string>& vValueCacheList)
{
NF_SHARE_PTR<NFIRecordManager> pRecordManager = NewRecordManager(strClassName);
if (!pRecordManager.get())
{
return nullptr;
}
NF_SHARE_PTR<NFIRedisClient> pDriver = m_pNoSqlModule->GetDriverBySuit(self.ToString());
if (!pDriver)
{
return nullptr;
}
//TODO
//just run this function one time
NF_SHARE_PTR<NFIRecord> xRecord = pRecordManager->First();
while (xRecord)
{
if (xRecord->GetCache() || xRecord->GetSave())
{
vKeyCacheList.push_back(xRecord->GetName());
}
xRecord = pRecordManager->Next();
}
//cache
std::string strCacheKey = GetRecordCacheKey(self);
if (!pDriver->HMGET(strCacheKey, vKeyCacheList, vValueCacheList))
{
return nullptr;
}
if (vKeyCacheList.size() == vValueCacheList.size())
{
ConvertVectorToRecordManager(vKeyCacheList, vValueCacheList, pRecordManager);
return pRecordManager;
}
return nullptr;
}
bool NFCEventProcessModule::Execute(const float fLasFrametime, const float fStartedTime)
{
NFIDENTID ident;
NF_SHARE_PTR<NFList<int>> pList = mRemoveEventListEx.First(ident);
while (nullptr != pList)
{
//删除对象的某个事�?
NF_SHARE_PTR<NFCObjectEventInfo> pObjectEventInfo = mObjectEventInfoMapEx.GetElement(ident);
if (pObjectEventInfo)
{
int nEvent = 0;
bool bRet = pList->First(nEvent);
while (bRet)
{
pObjectEventInfo->RemoveElement(nEvent);
bRet = pList->Next(nEvent);
}
}
pList = NULL;
pList = mRemoveEventListEx.Next();
}
mRemoveEventListEx.ClearAll();
//////////////////////////////////////////////////////////////////////////
//删除事件对象
bool bRet = mRemoveObjectListEx.First(ident);
while (bRet)
{
mObjectEventInfoMapEx.RemoveElement(ident);
bRet = mRemoveObjectListEx.Next(ident);
}
mRemoveObjectListEx.ClearAll();
return true;
}
bool NFCClassModule::AddClass(const char* pstrClassFilePath, NF_SHARE_PTR<NFIClass> pClass)
{
NF_SHARE_PTR<NFIClass> pParent = pClass->GetParent();
while (pParent)
{
//inherited some properties form class of parent
std::string strFileName = "";
pParent->First(strFileName);
while (!strFileName.empty())
{
if (pClass->Find(strFileName))
{
strFileName.clear();
continue;
}
if (AddClassInclude(strFileName.c_str(), pClass))
{
pClass->Add(strFileName);
}
strFileName.clear();
pParent->Next(strFileName);
}
pParent = pParent->GetParent();
}
//////////////////////////////////////////////////////////////////////////
if (AddClassInclude(pstrClassFilePath, pClass))
{
pClass->Add(pstrClassFilePath);
}
//file.close();
return true;
}
bool NFCElementModule::CheckRef()
{
NF_SHARE_PTR<NFIClass> pLogicClass = m_pClassModule->First();
while (pLogicClass)
{
NF_SHARE_PTR<NFIPropertyManager> pClassPropertyManager = pLogicClass->GetPropertyManager();
if (pClassPropertyManager)
{
NF_SHARE_PTR<NFIProperty> pProperty = pClassPropertyManager->First();
while (pProperty)
{
//if one property is ref,check every config
if (pProperty->GetRef())
{
NFList<std::string>& strIdList = pLogicClass->GetIdList();
std::string strId;
for (bool bRet = strIdList.First(strId); bRet; bRet = strIdList.Next(strId))
{
const std::string& strRefValue= this->GetPropertyString(strId, pProperty->GetKey());
if (!this->GetElement(strRefValue))
{
std::string msg;
msg.append("check ref failed id: ").append(strRefValue).append(" in ").append(pLogicClass->GetClassName());
NFASSERT(nRet, msg.c_str(), __FILE__, __FUNCTION__);
exit(0);
}
}
}
pProperty = pClassPropertyManager->Next();
}
}
//////////////////////////////////////////////////////////////////////////
pLogicClass = m_pClassModule->Next();
}
return false;
}
bool NFCSceneProcessModule::CreateSceneObject( const int nSceneID, const int nGroupID)
{
NF_SHARE_PTR<NFMapEx<std::string, SceneSeedResource>> pSceneResource = mtSceneResourceConfig.GetElement( nSceneID );
if ( pSceneResource.get() )
{
NF_SHARE_PTR<SceneSeedResource> pResource = pSceneResource->First( );
while ( pResource.get() )
{
const std::string& strClassName = m_pElementInfoModule->GetPropertyString(pResource->strConfigID, NFrame::NPC::ClassName());
NFCDataList arg;
arg << NFrame::NPC::X() << pResource->fSeedX;
arg << NFrame::NPC::Y() << pResource->fSeedY;
arg << NFrame::NPC::Z() << pResource->fSeedZ;
arg << NFrame::NPC::SeedID() << pResource->strSeedID;
m_pKernelModule->CreateObject( NFGUID(), nSceneID, nGroupID, strClassName, pResource->strConfigID, arg );
pResource = pSceneResource->Next();
}
}
return true;
}
bool NFCCreateRoleModule::ConvertPropertyManagerToPB(const NF_SHARE_PTR<NFIPropertyManager>& pProps, NFMsg::ObjectPropertyList * pPropertyData)
{
if (pProps)
{
NF_SHARE_PTR<NFIProperty> xPropert = pProps->First();
while (xPropert)
{
if (xPropert->GetCache() || xPropert->GetSave())
{
switch (xPropert->GetType())
{
case NFDATA_TYPE::TDATA_INT:
{
NFMsg::PropertyInt* pData = pPropertyData->add_property_int_list();
pData->set_property_name(xPropert->GetKey());
pData->set_data(xPropert->GetInt());
}
break;
case NFDATA_TYPE::TDATA_FLOAT:
{
NFMsg::PropertyFloat* pData = pPropertyData->add_property_float_list();
pData->set_property_name(xPropert->GetKey());
pData->set_data(xPropert->GetFloat());
}
break;
case NFDATA_TYPE::TDATA_OBJECT:
{
NFMsg::PropertyObject* pData = pPropertyData->add_property_object_list();
pData->set_property_name(xPropert->GetKey());
*(pData->mutable_data()) = NFINetModule::NFToPB(xPropert->GetObject());
}
break;
case NFDATA_TYPE::TDATA_STRING:
{
NFMsg::PropertyString* pData = pPropertyData->add_property_string_list();
pData->set_property_name(xPropert->GetKey());
pData->set_data(xPropert->GetString());
std::cout << xPropert->GetKey() << " " << xPropert->GetString() << std::endl;
}
break;
case NFDATA_TYPE::TDATA_VECTOR2:
{
NFMsg::PropertyVector2* pData = pPropertyData->add_property_vector2_list();
pData->set_property_name(xPropert->GetKey());
*(pData->mutable_data()) = NFINetModule::NFToPB(xPropert->GetVector2());
}
break;
case NFDATA_TYPE::TDATA_VECTOR3:
{
NFMsg::PropertyVector3* pData = pPropertyData->add_property_vector3_list();
pData->set_property_name(xPropert->GetKey());
*(pData->mutable_data()) = NFINetModule::NFToPB(xPropert->GetVector3());
}
break;
default:
break;
}
}
xPropert = pProps->Next();
}
}
return false;
}
bool NFCCreateRoleModule::ConvertRecordManagerToPB(const NF_SHARE_PTR<NFIRecordManager>& pRecordManager, NFMsg::ObjectRecordList * pRecordDataList)
{
if (pRecordDataList == nullptr)
{
return false;
}
for (NF_SHARE_PTR<NFIRecord> pRecord = pRecordManager->First(); pRecord != NULL; pRecord = pRecordManager->Next())
{
if (!pRecord->GetCache() && !pRecord->GetSave())
{
continue;
}
NFMsg::ObjectRecordBase* pRecordData = pRecordDataList->add_record_list();
if (!pRecordData)
{
continue;
}
ConvertRecordToPB(pRecord, pRecordData);
}
return true;
}
std::vector<std::string> NFCCommonConfigModule::GetSubKeyList(const std::string&strStructName)
{
std::vector<std::string> xList;
NF_SHARE_PTR<CStructInfo> pStructTypeData = mmData.GetElement(strStructName);
if (pStructTypeData)
{
std::string strStructName;
for (NF_SHARE_PTR<CAttributeList> pData = pStructTypeData->First(strStructName); pData != NULL; pData = pStructTypeData->Next(strStructName))
{
xList.push_back(strStructName);
}
}
return xList;
}
bool NFCCommonRedisModule::ConvertPropertyManagerToVector(NF_SHARE_PTR<NFIPropertyManager> pPropertyManager, std::vector<std::string>& vKeyList, std::vector<std::string>& vValueList)
{
for (NF_SHARE_PTR<NFIProperty> pProperty = pPropertyManager->First(); pProperty != NULL; pProperty = pPropertyManager->Next())
{
const int nType = pProperty->GetType();
if (!pProperty->GetCache() && !pProperty->GetSave())
{
continue;
}
const std::string& strPropertyName = pProperty->GetKey();
const std::string& strPropertyValue = pProperty->ToString();
vKeyList.push_back(strPropertyName);
vValueList.push_back(strPropertyValue);
}
return true;
}
bool NFCTileModule::SendTileData(const NFGUID & self)
{
NF_SHARE_PTR<TileData> xTileData = mxTileData.GetElement(self);
if (!xTileData)
{
return false;
}
bool bNeedSend = false;
NFMsg::AckMiningTitle xData;
NF_SHARE_PTR<NFMapEx<int, TileState>> xStateDataMap = xTileData->mxTileState.First();
for (; xStateDataMap; xStateDataMap = xTileData->mxTileState.Next())
{
NF_SHARE_PTR<TileState> xStateData = xStateDataMap->First();
for (; xStateData; xStateData = xStateDataMap->Next())
{
//pb
//xStateData
NFMsg::TileState* pTile = xData.add_tile();
if (pTile)
{
bNeedSend = true;
pTile->set_x(xStateData->x);
pTile->set_y(xStateData->y);
pTile->set_opr(xStateData->state);
}
}
}
NF_SHARE_PTR<NFMapEx<int, TileBuilding>> xStateDataBuilding = xTileData->mxTileBuilding.First();
for (; xStateDataBuilding; xStateDataBuilding = xTileData->mxTileBuilding.Next())
{
NF_SHARE_PTR<TileBuilding> xStateData = xStateDataBuilding->First();
for (; xStateData; xStateData = xStateDataBuilding->Next())
{
//pb
//xStateData
NFMsg::TileBuilding* pBuilding = xData.add_building();
if (pBuilding)
{
bNeedSend = true;
pBuilding->set_x(xStateData->x);
pBuilding->set_y(xStateData->y);
pBuilding->set_configid(xStateData->configID);
*pBuilding->mutable_guid() = NFINetModule::NFToPB(xStateData->ID);
}
}
}
NF_SHARE_PTR<NFMapEx<int, TileNPC>> xStateDataNPC = xTileData->mxTileNPC.First();
for (; xStateDataNPC; xStateDataNPC = xTileData->mxTileNPC.Next())
{
NF_SHARE_PTR<TileNPC> xStateData = xStateDataNPC->First();
for (; xStateData; xStateData = xStateDataNPC->Next())
{
//pb
//xStateData
NFMsg::TileNPC* pNpc = xData.add_npc();
if (pNpc)
{
bNeedSend = true;
pNpc->set_x(xStateData->x);
pNpc->set_y(xStateData->y);
pNpc->set_configid(xStateData->configID);
*pNpc->mutable_guid() = NFINetModule::NFToPB(xStateData->ID);
}
}
}
if (bNeedSend)
{
m_pGameServerNet_ServerModule->SendMsgPBToGate(NFMsg::EGEC_ACK_MINING_TITLE, xData, self);
}
return true;
}
bool NFCTileModule::SaveTileData(const NFGUID & self)
{
NF_SHARE_PTR<TileData> xTileData = mxTileData.GetElement(self);
if (!xTileData)
{
return false;
}
NFMsg::AckMiningTitle xData;
NF_SHARE_PTR<NFMapEx<int, TileState>> xStateDataMap = xTileData->mxTileState.First();
for (; xStateDataMap; xStateDataMap = xTileData->mxTileState.Next())
{
NF_SHARE_PTR<TileState> xStateData = xStateDataMap->First();
for (; xStateData; xStateData = xStateDataMap->Next())
{
//pb
//xStateData
NFMsg::TileState* pTile = xData.add_tile();
if (pTile)
{
pTile->set_x(xStateData->x);
pTile->set_y(xStateData->y);
pTile->set_opr(xStateData->state);
}
}
}
NF_SHARE_PTR<NFMapEx<int, TileBuilding>> xTileBuildingMap = xTileData->mxTileBuilding.First();
for (; xTileBuildingMap; xTileBuildingMap = xTileData->mxTileBuilding.Next())
{
NF_SHARE_PTR<TileBuilding> xStateData = xTileBuildingMap->First();
for (; xStateData; xStateData = xTileBuildingMap->Next())
{
//pb
//xStateData
NFMsg::TileBuilding* pTile = xData.add_building();
if (pTile)
{
pTile->set_x(xStateData->x);
pTile->set_y(xStateData->y);
pTile->set_configid(xStateData->configID);
*pTile->mutable_guid() = NFINetModule::NFToPB(xStateData->ID);
}
}
}
NF_SHARE_PTR<NFMapEx<int, TileNPC>> xTileNPCMap = xTileData->mxTileNPC.First();
for (; xTileNPCMap; xTileNPCMap = xTileData->mxTileNPC.Next())
{
NF_SHARE_PTR<TileNPC> xStateData = xTileNPCMap->First();
for (; xStateData; xStateData = xTileNPCMap->Next())
{
//pb
//xStateData
NFMsg::TileNPC* pTile = xData.add_npc();
if (pTile)
{
pTile->set_x(xStateData->x);
pTile->set_y(xStateData->y);
pTile->set_configid(xStateData->configID);
*pTile->mutable_guid() = NFINetModule::NFToPB(xStateData->ID);
}
}
}
const int nSceneID = m_pKernelModule->GetPropertyInt32(self, NFrame::Player::HomeSceneID());
std::string strData;
if (xData.SerializeToString(&strData))
{
return m_pPlayerRedisModule->SavePlayerTile(nSceneID, self, strData);
}
return false;
}
bool NFCScheduleModule::Execute()
{
//execute every schedule
NF_SHARE_PTR<NFMapEx <std::string, NFCScheduleElement >> xObjectSchedule = mObjectScheduleMap.First();
while (xObjectSchedule)
{
std::string str;
NF_SHARE_PTR<NFCScheduleElement> pSchedule = xObjectSchedule->First();
while (pSchedule)
{
NFINT64 nNow = NFGetTime();
if (nNow > pSchedule->mnNextTriggerTime)
{
std::map<NFGUID, std::string>::iterator itRet = mObjectRemoveList.find(pSchedule->self);
if (itRet != mObjectRemoveList.end())
{
if (itRet->second != pSchedule->mstrScheduleName)
{
if (pSchedule->mnRemainCount > 0 || pSchedule->mbForever == true)
{
pSchedule->mnRemainCount--;
pSchedule->DoHeartBeatEvent();
if (pSchedule->mnRemainCount <= 0 && pSchedule->mbForever == false)
{
mObjectRemoveList.insert(std::map<NFGUID, std::string>::value_type(pSchedule->self, pSchedule->mstrScheduleName));
}
else
{
NFINT64 nNextCostTime = NFINT64(pSchedule->mfIntervalTime * 1000) * (pSchedule->mnAllCount - pSchedule->mnRemainCount);
pSchedule->mnNextTriggerTime = pSchedule->mnStartTime + nNextCostTime;
}
}
}
}
}
pSchedule = xObjectSchedule->Next();
}
xObjectSchedule = mObjectScheduleMap.Next();
}
//remove schedule
for (std::map<NFGUID, std::string>::iterator it = mObjectRemoveList.begin(); it != mObjectRemoveList.end(); ++it)
{
NFGUID self = it->first;
std::string scheduleName = it->second;
auto findIter = mObjectScheduleMap.GetElement(self);
if (NULL != findIter)
{
findIter->RemoveElement(scheduleName);
if (findIter->Count() == 0)
{
mObjectScheduleMap.RemoveElement(self);
}
}
}
mObjectRemoveList.clear();
//add schedule
for (std::list<NFCScheduleElement>::iterator iter = mObjectAddList.begin(); iter != mObjectAddList.end(); ++iter)
{
NF_SHARE_PTR< NFMapEx <std::string, NFCScheduleElement >> xObjectScheduleMap = mObjectScheduleMap.GetElement(iter->self);
if (NULL == xObjectScheduleMap)
{
xObjectScheduleMap = NF_SHARE_PTR< NFMapEx <std::string, NFCScheduleElement >>(NF_NEW NFMapEx <std::string, NFCScheduleElement >());
mObjectScheduleMap.AddElement(iter->self, xObjectScheduleMap);
}
NF_SHARE_PTR<NFCScheduleElement> xScheduleElement = xObjectScheduleMap->GetElement(iter->mstrScheduleName);
if (NULL == xScheduleElement)
{
xScheduleElement = NF_SHARE_PTR<NFCScheduleElement>(NF_NEW NFCScheduleElement());
*xScheduleElement = *iter;
xObjectScheduleMap->AddElement(iter->mstrScheduleName, xScheduleElement);
}
}
mObjectAddList.clear();
////////////////////////////////////////////
//execute every schedule
NF_SHARE_PTR< NFCScheduleElement > xModuleSchedule = mModuleScheduleMap.First();
while (xModuleSchedule)
{
NFINT64 nNow = NFGetTime();
if (nNow > xModuleSchedule->mnNextTriggerTime)
{
if (xModuleSchedule->mnRemainCount > 0 || xModuleSchedule->mbForever == true)
{
xModuleSchedule->mnRemainCount--;
xModuleSchedule->DoHeartBeatEvent();
if (xModuleSchedule->mnRemainCount <= 0 && xModuleSchedule->mbForever == false)
{
mModuleRemoveList.push_back(xModuleSchedule->mstrScheduleName);
}
else
{
NFINT64 nNextCostTime = NFINT64(xModuleSchedule->mfIntervalTime * 1000) * (xModuleSchedule->mnAllCount - xModuleSchedule->mnRemainCount);
xModuleSchedule->mnNextTriggerTime = xModuleSchedule->mnStartTime + nNextCostTime;
}
}
}
xModuleSchedule = mModuleScheduleMap.Next();
}
//remove schedule
for (std::list<std::string>::iterator it = mModuleRemoveList.begin(); it != mModuleRemoveList.end(); ++it)
{
const std::string& strSheduleName = *it;;
auto findIter = mModuleScheduleMap.GetElement(strSheduleName);
if (NULL != findIter)
{
mModuleScheduleMap.RemoveElement(strSheduleName);
}
}
mModuleRemoveList.clear();
//add schedule
for (std::list<NFCScheduleElement>::iterator iter = mModuleAddList.begin(); iter != mModuleAddList.end(); ++iter)
{
NF_SHARE_PTR< NFCScheduleElement > xModuleScheduleMap = mModuleScheduleMap.GetElement(iter->mstrScheduleName);
if (NULL == xModuleScheduleMap)
{
xModuleScheduleMap = NF_SHARE_PTR< NFCScheduleElement >(NF_NEW NFCScheduleElement());
mModuleScheduleMap.AddElement(iter->mstrScheduleName, xModuleScheduleMap);
}
*xModuleScheduleMap = *iter;
}
mModuleAddList.clear();
return true;
}
const bool NFCObjectSaveModule::LoadDataFormNoSql( const NFIDENTID& self , const std::string& strClassName)
{
NF_SHARE_PTR<NFIPropertyManager> pProManager = m_pLogicClassModule->GetClassPropertyManager(strClassName);
NF_SHARE_PTR<NFIRecordManager> pRecordManager = m_pLogicClassModule->GetClassRecordManager(strClassName);
if (!pProManager || !pRecordManager)
{
return false;
}
std::vector<std::string> vFieldVec;
std::vector<std::string> vValueVec;
int nIndex = 0;
std::string strName;
std::map<std::string, int> xDataIndex;
//witch Property Need Load
NF_SHARE_PTR<NFIProperty> xProperty = pProManager->First(strName);
while (xProperty)
{
if (xProperty->GetSave())
{
vFieldVec.push_back(strName);
xDataIndex.insert(std::make_pair(strName, nIndex));
nIndex ++;
}
strName.clear();
xProperty = pProManager->Next(strName);
}
//witch Record Need Load
NF_SHARE_PTR<NFIRecord> xRecord = pRecordManager->First(strName);
while (xRecord)
{
if (xRecord->GetSave())
{
vFieldVec.push_back(strName);
xDataIndex.insert(std::make_pair(strName, nIndex));
nIndex ++;
}
strName.clear();
xRecord = pRecordManager->Next(strName);
}
if(!m_pClusterSQLModule->Query(strClassName, self.ToString(), vFieldVec, vValueVec))
{
return false;
}
if (vFieldVec.size() != vValueVec.size())
{
return false;
}
NF_SHARE_PTR<NFMapEx<std::string, std::string> > pSelf = mtObjectCache.GetElement(self);
if (!pSelf)
{
pSelf = NF_SHARE_PTR< NFMapEx<std::string, std::string> > (NF_NEW NFMapEx<std::string, std::string>());
if (!mtObjectCache.AddElement(self, pSelf))
{
return false;
}
}
for (int i = 0; i< vValueVec.size(); i++)
{
const std::string& strName = vFieldVec[i];
const std::string& strValue = vValueVec[i];
pSelf->AddElement(strName, NF_SHARE_PTR<std::string>(NF_NEW std::string(strValue)));
}
return true;
}
bool NFCCommonRedisModule::ConvertRecordManagerToVector(NF_SHARE_PTR<NFIRecordManager> pRecordManager, std::vector<std::string>& vKeyList, std::vector<std::string>& vValueList)
{
for (NF_SHARE_PTR<NFIRecord> pRecord = pRecordManager->First(); pRecord != NULL; pRecord = pRecordManager->Next())
{
if (!pRecord->GetCache() && !pRecord->GetSave())
{
continue;
}
NFMsg::ObjectRecordBase xRecordData;
ConvertRecordToPB(pRecord, &xRecordData);
////
std::string strValue;
if (!xRecordData.SerializeToString(&strValue))
{
continue;
}
vKeyList.push_back(xRecordData.record_name());
vValueList.push_back(strValue);
}
return true;
}
bool NFCTileModule::GetOnlinePlayerTileData(const NFGUID& self, std::string& strData)
{
NF_SHARE_PTR<TileData> xTileData = mxTileData.GetElement(self);
if (!xTileData)
{
return false;
}
NFMsg::AckMiningTitle xData;
NF_SHARE_PTR<NFMapEx<int, TileState>> xStateDataMap = xTileData->mxTileState.First();
for (; xStateDataMap; xStateDataMap = xTileData->mxTileState.Next())
{
NF_SHARE_PTR<TileState> xStateData = xStateDataMap->First();
for (; xStateData; xStateData = xStateDataMap->Next())
{
//pb
//xStateData
NFMsg::TileState* pTile = xData.add_tile();
if (pTile)
{
pTile->set_x(xStateData->x);
pTile->set_y(xStateData->y);
pTile->set_opr(xStateData->state);
}
}
}
NF_SHARE_PTR<NFMapEx<int, TileBuilding>> xTileBuildingMap = xTileData->mxTileBuilding.First();
for (; xTileBuildingMap; xTileBuildingMap = xTileData->mxTileBuilding.Next())
{
NF_SHARE_PTR<TileBuilding> xStateData = xTileBuildingMap->First();
for (; xStateData; xStateData = xTileBuildingMap->Next())
{
//pb
//xStateData
NFMsg::TileBuilding* pTile = xData.add_building();
if (pTile)
{
pTile->set_x(xStateData->x);
pTile->set_y(xStateData->y);
pTile->set_configid(xStateData->configID);
*pTile->mutable_guid() = NFINetModule::NFToPB(xStateData->ID);
}
}
}
NF_SHARE_PTR<NFMapEx<int, TileNPC>> xTileNPCMap = xTileData->mxTileNPC.First();
for (; xTileNPCMap; xTileNPCMap = xTileData->mxTileNPC.Next())
{
NF_SHARE_PTR<TileNPC> xStateData = xTileNPCMap->First();
for (; xStateData; xStateData = xTileNPCMap->Next())
{
//pb
//xStateData
NFMsg::TileNPC* pTile = xData.add_npc();
if (pTile)
{
pTile->set_x(xStateData->x);
pTile->set_y(xStateData->y);
pTile->set_configid(xStateData->configID);
*pTile->mutable_guid() = NFINetModule::NFToPB(xStateData->ID);
}
}
}
if (xData.SerializeToString(&strData))
{
return true;
}
return false;
}
const bool NFCObjectSaveModule::SaveDataToNoSql( const NFIDENTID& self )
{
NF_SHARE_PTR<NFIObject> pObject = m_pKernelModule->GetObject( self );
if ( pObject.get() )
{
NF_SHARE_PTR<NFIPropertyManager> pProManager = pObject->GetPropertyManager();
NF_SHARE_PTR<NFIRecordManager> pRecordManager = pObject->GetRecordManager();
std::vector<std::string> vFieldVec;
std::vector<std::string> vValueVec;
//witch property to save
std::string strName;
NF_SHARE_PTR<NFIProperty> xProperty = pProManager->First(strName);
while (xProperty)
{
if (xProperty->GetSave())
{
vFieldVec.push_back(strName);
vValueVec.push_back(xProperty->ToString());
}
strName.clear();
xProperty = pProManager->Next(strName);
}
//witch Record to save
NF_SHARE_PTR<NFIRecord> xRecord = pRecordManager->First(strName);
while (xRecord)
{
if (xRecord->GetSave())
{
NFMsg::PlayerRecordBase xRecordData;
xRecordData.set_record_name(strName);
for (int i = 0; i < xRecord->GetRows(); ++i)
{
if(xRecord->IsUsed(i))
{
for (int j = 0; j < xRecord->GetCols(); ++j)
{
switch (xRecord->GetColType(j))
{
case TDATA_INT:
{
NFMsg::RecordInt* pRecordInt = xRecordData.add_record_int_list();
pRecordInt->set_row(i);
pRecordInt->set_col(j);
pRecordInt->set_data(xRecord->GetInt(i, j));
}
break;
case TDATA_FLOAT:
{
NFMsg::RecordFloat* xRecordFloat = xRecordData.add_record_float_list();
xRecordFloat->set_row(i);
xRecordFloat->set_col(j);
xRecordFloat->set_data(xRecord->GetFloat(i, j));
}
break;
case TDATA_STRING:
{
NFMsg::RecordString* xRecordString = xRecordData.add_record_string_list();
xRecordString->set_row(i);
xRecordString->set_col(j);
xRecordString->set_data(xRecord->GetString(i, j));
}
break;
case TDATA_OBJECT:
{
NFMsg::RecordObject* xRecordObejct = xRecordData.add_record_object_list();
xRecordObejct->set_row(i);
xRecordObejct->set_col(j);
*xRecordObejct->mutable_data() = NFINetModule::NFToPB(xRecord->GetObject(i, j));
}
break;
default:
break;
}
}
}
}
std::string strRecordValue;
if(xRecordData.SerializeToString(&strRecordValue))
{
vFieldVec.push_back(strName);
vValueVec.push_back(strRecordValue);
}
}
strName.clear();
xRecord = pRecordManager->Next(strName);
}
const std::string& strClass = m_pKernelModule->GetPropertyString(self, "ClassName");
if(!m_pClusterSQLModule->Updata(strClass, self.ToString(), vFieldVec, vValueVec))
{
return false;
}
return true;
}
return false;
}
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;
}
const bool NFCObjectSaveModule::AttachData( const NFIDENTID& self )
{
NF_SHARE_PTR<NFIObject> pObject = m_pKernelModule->GetObject(self);
if (!pObject)
{
return false;
}
NF_SHARE_PTR<NFMapEx<std::string, std::string> > pSelfData = mtObjectCache.GetElement(self);
if (!pSelfData)
{
return false;
}
NF_SHARE_PTR<NFIPropertyManager> pProManager = pObject->GetPropertyManager();
NF_SHARE_PTR<NFIRecordManager> pRecordManager = pObject->GetRecordManager();
//assign property value
NF_SHARE_PTR<NFIProperty> xProperty = pProManager->First(strName);
while (xProperty)
{
if (xProperty->GetSave())
{
NF_SHARE_PTR<std::string> pValue = pSelfData->GetElement(strName);
if (pValue)
{
const std::string& strData = *pValue;
if (!xProperty->FromString(strData))
{
m_pLogModule->LogNormal(NFILogModule::NLL_ERROR_NORMAL, self, "Load Property fail " + strName , ": " + strData, __FUNCTION__, __LINE__);
}
else
{
m_pLogModule->LogNormal(NFILogModule::NLL_INFO_NORMAL, self, "Load Property success " + strName, ": " + strData, __FUNCTION__, __LINE__);
}
}
}
strName.clear();
xProperty = pProManager->Next(strName);
}
//assign record value
NF_SHARE_PTR<NFIRecord> xRecord = pRecordManager->First(strName);
while (xRecord)
{
if (xRecord->GetSave())
{
NF_SHARE_PTR<std::string> pValue = pSelfData->GetElement(strName);
if (pValue)
{
const std::string& strData = *pValue;
NFMsg::PlayerRecordBase xRecordData;
if (xRecordData.ParseFromString(strData) && xRecordData.record_name() == strName)
{
ConvertPBToRecord(xRecordData, xRecord);
}
}
}
strName.clear();
xRecord = pRecordManager->Next(strName);
}
mtObjectCache.RemoveElement(self);
return true;
}
