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 NFCGuildModule::GetOnlineMember( const NFGUID& self, const NFGUID& xGuild, NFDataList& varMemberList, NFDataList& varGameList)
{
NF_SHARE_PTR<NFIObject> pGuildObject = m_pGuildDataModule->GetGuild(xGuild);
if (!pGuildObject.get())
{
return false;
}
NF_SHARE_PTR<NFIRecord> pMemberRecord = m_pKernelModule->FindRecord(xGuild, NFrame::Guild::R_GuildMemberList());
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::Guild::GuildMemberList_Online);
const NFINT64 nGameID = pMemberRecord->GetInt(i, NFrame::Guild::GuildMemberList_GameID);
const NFGUID& xID = pMemberRecord->GetObject(i, NFrame::Guild::GuildMemberList_GUID);
if (nOnline > 0 && !xID.IsNull())
{
varMemberList.Add(xID);
varGameList.Add(nGameID);
}
}
return true;
}
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);
}
int NFCSLGBuildingModule::CheckProduceData( const NFGUID& self )
{
NF_SHARE_PTR<NFIRecord> pProduce = m_pKernelModule->FindRecord(self, "BuildingProduce");
if (NULL == pProduce.get())
{
m_pLogModule->LogNormal(NFILogModule::NLL_ERROR_NORMAL, self, "this is no [BuildingProduce] Record!", "", __FUNCTION__, __LINE__);
return false;
}
for (int i = 0; i < pProduce->GetRows(); i++)
{
if (!pProduce->IsUsed(i))
{
continue;
}
const int nNowTime = pPluginManager->GetNowTime();
const NFGUID xBuildID = pProduce->GetObject(i, "BuildingGUID");
const std::string strItemID = pProduce->GetString(i, "ItemID");
const int nLeftCount = pProduce->GetInt(i, "LeftCount");
const NFINT64 nLastOnceBeginTime = pProduce->GetInt(i, "OnceStartTime");
const NFINT64 nOnceTime = pProduce->GetInt(i, "OnceTime");
const int nPassTime = nNowTime - nLastOnceBeginTime;
if (nPassTime <= 0)
{
continue;
}
const int nCount = nPassTime/nOnceTime;
if (nCount >= nLeftCount)
{
//add Item
//TO ADD
pProduce->Remove(i);
}
else
{
//add Item
//TO ADD
pProduce->SetInt(i, "", nLeftCount - nCount);
//NFDataList varHeart;
//varHeart << xBuildID;
//varHeart << strItemID;
const std::string strHeartname = GetProduceHeartName(self, xBuildID, strItemID);
const int nTime = (nCount + 1) * nOnceTime - nPassTime;
m_pScheduleModule->AddSchedule(self, strHeartname, this, &NFCSLGBuildingModule::OnProduceHeartBeat, /*varHeart, */nTime, 1);
}
}
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;
}
int NFCSLGBuildingModule::CheckBuildingStatusEnd( const NFGUID& self )
{
NF_SHARE_PTR<NFIRecord> pRecord = m_pKernelModule->FindRecord(self, "BuildingList");
if (NULL == pRecord.get())
{
m_pLogModule->LogNormal(NFILogModule::NLL_ERROR_NORMAL, self, "this is no [BuildingList] Record!", "", __FUNCTION__, __LINE__);
return 1;
}
const NFINT64 nNowTime = pPluginManager->GetNowTime();
for (int i= 0; i < pRecord->GetRows(); i++)
{
if (!pRecord->IsUsed(i))
{
continue;
}
const NFINT64 nEndTime = pRecord->GetInt(i, "StateEndTime");
const NFGUID& xBuildID = pRecord->GetObject(i, "BuildingGUID");
const int& nStatus = pRecord->GetInt(i, "State");
float fTime = nEndTime - nNowTime;
if (fTime <= 0.0f)
{
fTime = 0.1f;
}
if (nStatus == NFMsg::EBS_IDLE)
{
continue;
}
else if(nStatus == NFMsg::EBS_UPGRADE)
{
//NFDataList varHeart;
//varHeart << xBuildID;
m_pScheduleModule->AddSchedule(self, "OnUpgradeHeartBeat", this, &NFCSLGBuildingModule::OnUpgradeHeartBeat, /*varHeart, */fTime, 1);
}
else if(nStatus == NFMsg::EBS_BOOST)
{
//NFDataList varHeart;
//varHeart << xBuildID;
m_pScheduleModule->AddSchedule(self, "OnUpgradeHeartBeat", this, &NFCSLGBuildingModule::OnUpgradeHeartBeat, /*varHeart, */fTime, 1);
}
}
return 0;
}
int NFCPropertyModule::OnRecordPropertyEvent(const NFGUID& self, const RECORD_EVENT_DATA& xEventData, const NFIDataList::TData& oldVar, const NFIDataList::TData& newVar)
{
//计算总值
const std::string& strRecordName = xEventData.strRecordName;
const int nOpType = xEventData.nOpType;
const int nRow = xEventData.nRow;
const int nCol = xEventData.nCol;
int nAllValue = 0;
NF_SHARE_PTR<NFIRecord> pRecord = m_pKernelModule->FindRecord(self, NFrame::Player::R_CommPropertyValue());
for (int i = 0; i < (int)(NFPropertyGroup::NPG_ALL); i++)
{
if (i < pRecord->GetRows())
{
int nValue = pRecord->GetInt(i, nCol);
nAllValue += nValue;
}
}
m_pKernelModule->SetPropertyInt(self, pRecord->GetColTag(nCol), nAllValue);
return 0;
}
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;
}
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;
}
bool NFCCreateRoleModule::ConvertRecordToPB(const NF_SHARE_PTR<NFIRecord>& pRecord, NFMsg::ObjectRecordBase * pRecordData)
{
pRecordData->set_record_name(pRecord->GetName());
for (int iRow = 0; iRow < pRecord->GetRows(); iRow++)
{
if (!pRecord->IsUsed(iRow))
{
continue;
}
NFMsg::RecordAddRowStruct* pRowData = pRecordData->add_row_struct();
if (!pRowData)
{
continue;
}
pRowData->set_row(iRow);
for (int iCol = 0; iCol < pRecord->GetCols(); iCol++)
{
const int nType = pRecord->GetColType(iCol);
switch (nType)
{
case TDATA_INT:
{
NFMsg::RecordInt* pPropertyData = pRowData->add_record_int_list();
const NFINT64 xPropertyValue = pRecord->GetInt(iRow, iCol);
if (pPropertyData)
{
pPropertyData->set_col(iCol);
pPropertyData->set_row(iRow);
pPropertyData->set_data(xPropertyValue);
}
}
break;
case TDATA_FLOAT:
{
NFMsg::RecordFloat* pPropertyData = pRowData->add_record_float_list();
const double xPropertyValue = pRecord->GetFloat(iRow, iCol);
if (pPropertyData)
{
pPropertyData->set_col(iCol);
pPropertyData->set_row(iRow);
pPropertyData->set_data(xPropertyValue);
}
}
break;
case TDATA_STRING:
{
NFMsg::RecordString* pPropertyData = pRowData->add_record_string_list();
const std::string& xPropertyValue = pRecord->GetString(iRow, iCol);
if (pPropertyData)
{
pPropertyData->set_col(iCol);
pPropertyData->set_row(iRow);
pPropertyData->set_data(xPropertyValue);
}
}
break;
case TDATA_OBJECT:
{
NFMsg::RecordObject* pPropertyData = pRowData->add_record_object_list();
const NFGUID xPropertyValue = pRecord->GetObject(iRow, iCol);
if (pPropertyData)
{
pPropertyData->set_col(iCol);
pPropertyData->set_row(iRow);
*pPropertyData->mutable_data() = NFINetModule::NFToPB(xPropertyValue);
}
}
break;
case TDATA_VECTOR2:
{
NFMsg::RecordVector2* pPropertyData = pRowData->add_record_vector2_list();
const NFVector2 xPropertyValue = pRecord->GetVector2(iRow, iCol);
if (pPropertyData)
{
pPropertyData->set_col(iCol);
pPropertyData->set_row(iRow);
NFMsg::Vector2* pVec = pPropertyData->mutable_data();
pVec->set_x(xPropertyValue.X());
pVec->set_y(xPropertyValue.Y());
}
}
break;
case TDATA_VECTOR3:
{
NFMsg::RecordVector3* pPropertyData = pRowData->add_record_vector3_list();
const NFVector3 xPropertyValue = pRecord->GetVector3(iRow, iCol);
if (pPropertyData)
{
pPropertyData->set_col(iCol);
pPropertyData->set_row(iRow);
NFMsg::Vector3* pVec = pPropertyData->mutable_data();
pVec->set_x(xPropertyValue.X());
pVec->set_y(xPropertyValue.Y());
pVec->set_z(xPropertyValue.Z());
}
}
break;
default:
break;
}
}
}
return true;
}
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;
}