bool NFCAccountRedisModule::CreateRole(const std::string & strAccount, const std::string & strRoleName, const NFGUID & id)
{
std::string strAccountKey = m_pCommonRedisModule->GetAccountCacheKey(strAccount);
NF_SHARE_PTR<NFINoSqlDriver> xNoSqlDriver = m_pNoSqlModule->GetDriverBySuit(strAccount);
if (xNoSqlDriver)
{
if (xNoSqlDriver->Exists(strAccountKey) && !xNoSqlDriver->Exists(strRoleName))
{
xNoSqlDriver->HSet(strAccountKey, NFrame::Player::Name(), strRoleName);
xNoSqlDriver->HSet(strAccountKey, NFrame::Player::ID(), id.ToString());
NF_SHARE_PTR<NFINoSqlDriver> xRoleNameNoSqlDriver = m_pNoSqlModule->GetDriverBySuitConsistent();
if (xRoleNameNoSqlDriver)
{
xRoleNameNoSqlDriver->HSet(strRoleName, NFrame::Player::ID(), id.ToString());
}
/*
std::vector<std::string> vKey;
std::vector<std::string> vValue;
xNoSqlDriver->HMSet(m_pCommonRedisModule->GetPropertyCacheKey(id), vKey, vValue);
xNoSqlDriver->HMSet(m_pCommonRedisModule->GetRecordCacheKey(id), vKey, vValue);
xNoSqlDriver->HMSet(m_pCommonRedisModule->GetPropertyStorageKey(id), vKey, vValue);
xNoSqlDriver->HMSet(m_pCommonRedisModule->GetRecordStorageKey(id), vKey, vValue);
*/
return true;
}
}
return false;
}
bool NFCLoginNet_HttpServerModule::OnLogin(const NFHttpRequest& req)
{
std::string strResponse;
NFResponseLogin xResponsetLogin;
NFRequestLogin xRequestLogin;
ajson::load_from_buff(xRequestLogin, req.body.c_str());
if (xRequestLogin.user.empty()
|| xRequestLogin.password.empty())
{
xResponsetLogin.code = NFIResponse::ResponseType::RES_TYPE_FAILED;
xResponsetLogin.jwt = "";
ajson::string_stream ss;
ajson::save_to(ss, xResponsetLogin);
strResponse = ss.str();
}
else
{
NFGUID xGUIDKey = m_pKernelModule->CreateGUID();
xResponsetLogin.code = NFIResponse::ResponseType::RES_TYPE_SUCCESS;
xResponsetLogin.jwt = xGUIDKey.ToString();
mToken[xRequestLogin.user] = xGUIDKey.ToString();
ajson::string_stream ss;
ajson::save_to(ss, xResponsetLogin);
strResponse = ss.str();
}
return m_pHttpNetModule->ResponseMsg(req, strResponse, NFWebStatus::WEB_OK);
}
bool NFCPVPMatchRedisModule::SetPlayerRoomID(const NFGUID& self, const NFGUID& xRoomID)
{
NF_SHARE_PTR<NFINoSqlDriver> pNoSqlDriver = m_pNoSqlModule->GetDriverBySuitConsistent();
if (pNoSqlDriver)
{
std::string strKey = MakePlayerRoomKey();
return pNoSqlDriver->HSet(strKey, self.ToString(), xRoomID.ToString());
}
return false;
}
bool NFCGSSwichServerModule::ChangeServer(const NFGUID& self, const int nServer, const int nSceneID, const int nGroup)
{
NFMsg::ReqSwitchServer xMsg;
xMsg.set_sceneid(nSceneID);
*xMsg.mutable_selfid() = NFINetModule::NFToPB(self);
xMsg.set_self_serverid(pPluginManager->GetAppID());
xMsg.set_target_serverid(nServer);
xMsg.set_groupid(nGroup);
int nGate = 0;
NFGUID xClient;
NF_SHARE_PTR<NFIGameServerNet_ServerModule::GateBaseInfo> pGateInfo = m_pGameServerNet_ServerModule->GetPlayerGateInfo(self);
if (!pGateInfo)
{
return false;
}
nGate = pGateInfo->nGateID;
xClient = pGateInfo->xClientID;
*xMsg.mutable_client_id() = NFINetModule::NFToPB(xClient);
xMsg.set_gate_serverid(nGate);
m_pNetClientModule->SendSuitByPB(NF_SERVER_TYPES::NF_ST_WORLD, self.ToString(), NFMsg::EGMI_REQSWICHSERVER, xMsg);
return true;
}
bool NFCPVPMatchRedisModule::SetStatusRoomID(const int nPVPMode, const int nGrade, const int nStatus, const NFGUID& xRoomID)
{
NF_SHARE_PTR<NFINoSqlDriver> pNoSqlDriver = m_pNoSqlModule->GetDriverBySuitConsistent();
if (pNoSqlDriver)
{
std::string strKey = MakeStatusRoomIDRedisKey(nPVPMode, nGrade, nStatus);
std::string strData;
std::vector<std::string> valueVec;
if (pNoSqlDriver->HSet(strKey, xRoomID.ToString(), xRoomID.ToString()))
{
return true;
}
}
return false;
}
bool NFCRankRedisModule::GetRankValue(const NFMsg::ERankType eRankType, const NFGUID & self, double& dwValue)
{
std::string strRankKey = MakeRedisKey(eRankType);
NF_SHARE_PTR<NFINoSqlDriver> pNoSqlDriver = m_pNoSqlModule->GetDriverBySuit(strRankKey);
if (!pNoSqlDriver)
{
return 0;
}
return pNoSqlDriver->ZScore(strRankKey, self.ToString(), dwValue);
}
const NFGUID NFCWorldChatGroupModule::CreateGroup( const NFGUID& self )
{
const NFGUID xGuidID = m_pUUIDModule->CreateGUID();
//Guild
std::vector<std::string> vGroupFieldVec;
std::vector<std::string> vGroupValueVec;
vGroupFieldVec.push_back("Name");
vGroupValueVec.push_back("");
vGroupFieldVec.push_back("CreateObject");
vGroupValueVec.push_back(self.ToString());
if (!m_pClusterSQLModule->Updata(mstrGroupTalble, xGuidID.ToString(), vGroupFieldVec, vGroupValueVec))
{
return NULL_OBJECT;
}
return xGuidID;
}
bool NFCPVPMatchRedisModule::PushSinglePlayer(const NFGUID& self, const int nPVPMode, const int nGrade)
{
NF_SHARE_PTR<NFINoSqlDriver> pNoSqlDriver = m_pNoSqlModule->GetDriverBySuitConsistent();
if (pNoSqlDriver)
{
std::string strKey = MakeSingleWaitRedisKey(nPVPMode, nGrade);
std::string strData;
return pNoSqlDriver->ListPush(strKey, self.ToString());
}
return false;
}
bool NFCWorldChatGroupModule::DeleteGroup( const NFGUID& self, const NFGUID& xGroupID )
{
NF_SHARE_PTR<NFIObject> pGuilD = m_pKernelModule->GetObject(xGroupID);
if (pGuilD.get())
{
m_pKernelModule->DestroyObject(xGroupID);
}
bool bExit = false;
if (!m_pClusterSQLModule->Exists(mstrGroupTalble, xGroupID.ToString(), bExit)
|| !bExit)
{
return false;
}
if (!m_pClusterSQLModule->Delete(mstrGroupTalble, xGroupID.ToString()))
{
return false;
}
return true;
}
bool NFCCommonRedisModule::SaveRecordInfo(const NFGUID & self, const NFMsg::ObjectRecordList& xRecordData, const int nExpireSecond)
{
if (self.IsNull())
{
return false;
}
NF_SHARE_PTR<NFIRedisClient> pDriver = m_pNoSqlModule->GetDriverBySuit(self.ToString());
if (!pDriver)
{
return false;
}
std::vector<std::string> vKeyList;
std::vector<std::string> vValueList;
for (int i = 0; i < xRecordData.record_list_size(); ++i)
{
const NFMsg::ObjectRecordBase& xRecord = xRecordData.record_list(i);
std::string strValue;
if (!xRecord.SerializeToString(&strValue))
{
continue;
}
vKeyList.push_back(xRecord.record_name());
vValueList.push_back(strValue);
}
if (vKeyList.size() != vValueList.size())
{
return false;
}
std::string strKey = GetRecordCacheKey(self);
if (!pDriver->HMSET(strKey, vKeyList, vValueList))
{
return false;
}
if (nExpireSecond > 0)
{
pDriver->EXPIRE(strKey, nExpireSecond);
}
return true;
}
bool NFCPVPMatchRedisModule::DeleteRoomInfo(const NFGUID& xRoomID)
{
NF_SHARE_PTR<NFINoSqlDriver> pNoSqlDriver = m_pNoSqlModule->GetDriverBySuitConsistent();
if (pNoSqlDriver)
{
std::string strKey = MakePvpRoomRedisKey();
std::string strData;
if (pNoSqlDriver->HDel(strKey, xRoomID.ToString()))
{
return true;
}
}
return false;
}
bool NFCBigMapRedisModule::RemoveGridStationInfo(const std::string& strGridID, const NFGUID& self, const int nResource)
{
if (!m_pElementModule->ExistElement(strGridID))
{
return false;
}
NF_SHARE_PTR<NFIRedisClient> pNoSqlDriver = m_pNoSqlModule->GetDriverBySuitConsistent();
if (pNoSqlDriver)
{
std::string strKey = GetGridStationHistoryKey(strGridID);
return pNoSqlDriver->ZREM(strKey, self.ToString());
}
return false;
}
bool NFCPVPMatchRedisModule::GetPlayerRoomID(const NFGUID& self, NFGUID& xRoomID)
{
NF_SHARE_PTR<NFINoSqlDriver> pNoSqlDriver = m_pNoSqlModule->GetDriverBySuitConsistent();
if (pNoSqlDriver)
{
std::string strKey = MakePlayerRoomKey();
std::string strData;
if (pNoSqlDriver->HGet(strKey, self.ToString(), strData))
{
if (xRoomID.FromString(strData))
{
return true;
}
}
}
return false;
}
bool NFCPVPMatchRedisModule::SetRoomInfo(const NFGUID& xRoomID, NFMsg::PVPRoomInfo& xRoomInfo)
{
NF_SHARE_PTR<NFINoSqlDriver> pNoSqlDriver = m_pNoSqlModule->GetDriverBySuitConsistent();
if (pNoSqlDriver)
{
std::string strKey = MakePvpRoomRedisKey();
std::string strData;
if (xRoomInfo.ParseFromString(strData))
{
if (pNoSqlDriver->HSet(strKey, xRoomID.ToString(), strData))
{
return true;
}
}
}
return false;
}
bool NFCCommonRedisModule::SavePropertyInfo(const NFGUID& self, NF_SHARE_PTR<NFIPropertyManager> pPropertyManager, const int nExpireSecond)
{
if (self.IsNull())
{
return false;
}
if (!pPropertyManager)
{
return false;
}
NF_SHARE_PTR<NFIRedisClient> pDriver = m_pNoSqlModule->GetDriverBySuit(self.ToString());
if (!pDriver)
{
return false;
}
std::vector<std::string> vKeyList;
std::vector<std::string> vValueList;
if (!ConvertPropertyManagerToVector(pPropertyManager, vKeyList, vValueList))
{
return false;
}
if (vKeyList.size() != vValueList.size())
{
return false;
}
std::string strKey= GetPropertyCacheKey(self);
if (!pDriver->HMSET(strKey, vKeyList, vValueList))
{
return false;
}
if (nExpireSecond > 0)
{
pDriver->EXPIRE(strKey, nExpireSecond);
}
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;
}
void NFCProxyServerNet_ServerModule::OnOtherMessage(const int nSockIndex, const int nMsgID, const char * msg, const uint32_t nLen)
{
NFMsg::MsgBase xMsg;
if (!xMsg.ParseFromArray(msg, nLen))
{
char szData[MAX_PATH] = { 0 };
sprintf(szData, "Parse Message Failed from Packet to MsgBase, MessageID: %d\n", nMsgID);
return;
}
NetObject* pNetObject = m_pNetModule->GetNet()->GetNetObject(nSockIndex);
if (!pNetObject || pNetObject->GetConnectKeyState() <= 0 || pNetObject->GetGameID() <= 0)
{
//state error
return;
}
if (xMsg.has_hash_ident())
{
//special for distributed
if (!pNetObject->GetHashIdentID().IsNull())
{
NFCMachineNode xNode;
if (mxConsistentHash.GetSuitNode(pNetObject->GetHashIdentID().ToString(), xNode))
{
m_pProxyServerToGameModule->GetClusterModule()->SendByServerID(xNode.GetDataID(), nMsgID, msg, nLen);
}
}
else
{
NFGUID xHashIdent = NFINetModule::PBToNF(xMsg.hash_ident());
NFCMachineNode xNode;
if (mxConsistentHash.GetSuitNode(xHashIdent.ToString(), xNode))
{
m_pProxyServerToGameModule->GetClusterModule()->SendByServerID(xNode.GetDataID(), nMsgID, msg, nLen);
}
}
}
else
{
m_pProxyServerToGameModule->GetClusterModule()->SendByServerID(pNetObject->GetGameID(), nMsgID, msg, nLen);
}
}
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;
}
std::string NFCSLGBuildingModule::GetProduceHeartName(const NFGUID& self, const NFGUID& xBuild, const std::string& strItemID)
{
return xBuild.ToString() + "_" + strItemID + "_" + "OnProduceHeartBeat";
}
int NFCSLGBuildingModule::Produce(const NFGUID& self, const NFGUID& xBuilID, const std::string& strItemID, const int nCount)
{
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;
}
NFDataList var;
pRecord->FindObject("BuildingGUID", xBuilID, var);
if (var.GetCount() <= 0)
{
m_pLogModule->LogNormal(NFILogModule::NLL_ERROR_NORMAL, self, "there are no the building", xBuilID.ToString(), __FUNCTION__, __LINE__);
return 1;
}
AddProduceData(self, xBuilID, strItemID, nCount);
const std::string strHeartname = GetProduceHeartName(self, xBuilID, strItemID);
const int nTime = 50;//To ADD
if (!m_pScheduleModule->ExistSchedule(self, strHeartname))
{
//NFDataList varHeart;
//varHeart << xBuilID;
//varHeart << strItemID;
m_pScheduleModule->AddSchedule(self, strHeartname, this, &NFCSLGBuildingModule::OnProduceHeartBeat, /*varHeart, */nTime, nCount);
}
return 0;
}
int NFCSLGBuildingModule::Boost(const NFGUID& self, const NFGUID& xBuilID)
{
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;
}
NFDataList var;
pRecord->FindObject("BuildingGUID", xBuilID, var);
if (var.GetCount() <= 0)
{
m_pLogModule->LogNormal(NFILogModule::NLL_ERROR_NORMAL, self, "there are no the building", xBuilID.ToString(), __FUNCTION__, __LINE__);
return 1;
}
const int nRow = var.Int(0);
const int nBoostTime = 20;
const std::string strBuildID = pRecord->GetString(nRow, "BuildingID");
//NFDataList varHeart;
//varHeart << xBuilID;
m_pScheduleModule->AddSchedule(self, "OnBoostHeartBeat", this, &NFCSLGBuildingModule::OnBoostHeartBeat, /*varHeart,*/ nBoostTime, 1);
pRecord->SetInt(nRow, "State", NFMsg::EBS_BOOST);
pRecord->SetInt(nRow, "StateStartTime", pPluginManager->GetNowTime());
pRecord->SetInt(nRow, "StateEndTime", pPluginManager->GetNowTime() + nBoostTime);
return 0;
}
std::string NFCCommonRedisModule::GetPropertyCacheKey(const NFGUID& self)
{
return self.ToString() + "_ObjectProperty";
}
std::string NFCCommonRedisModule::GetRecordCacheKey(const NFGUID& self)
{
return self.ToString() + "_ObjectRecord";
}
int NFCSLGBuildingModule::Upgrade(const NFGUID& self, const NFGUID& xBuilID)
{
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;
}
NFCDataList var;
pRecord->FindObject("BuildingGUID", xBuilID, var);
if (var.GetCount() <= 0)
{
m_pLogModule->LogNormal(NFILogModule::NLL_ERROR_NORMAL, self, "there are no the building", xBuilID.ToString(), __FUNCTION__, __LINE__);
return 1;
}
const int nRow = var.Int(0);
const int nNeedTime = 20;//升级所需要的时间 //TO ADD
const std::string strBuildID = pRecord->GetString(nRow, "BuildingID");
//NFCDataList varHeart;
//varHeart << xBuilID;
m_pKernelModule->AddHeartBeat(self, "OnUpgradeHeartBeat", this, &NFCSLGBuildingModule::OnUpgradeHeartBeat, /*varHeart,*/ nNeedTime, 1);
//修改建筑的状态
pRecord->SetInt(nRow, "State", NFMsg::EBS_UPGRADE);
pRecord->SetInt(nRow, "StateStartTime", NFTimeEx::GetNowTime());
pRecord->SetInt(nRow, "StateEndTime", NFTimeEx::GetNowTime() + nNeedTime);
return 0;
}
int NFCHelloWorld4Module::HttpRequestAsyEnd(const NFGUID& self, const int nFormActor, const int nSubMsgID, const std::string& strData)
{
std::cout << "Hello, welcome to main thread: " << self.ToString() << " Actor: " << nFormActor << " MsgID: " << nSubMsgID << " Data:" << strData << std::endl;
return 0;
}