void CGuildUnifierClientSkel::updateGuild_skel(NLNET::IModuleProxy *sender, const NLNET::CMessage &__message)
{
H_AUTO(CGuildUnifierClientSkel_updateGuild_UG);
CGuildDesc guildInfo;
nlRead(__message, serial, guildInfo);
updateGuild(sender, guildInfo);
}
void CGuildUnifierClientSkel::guildDeleted_skel(NLNET::IModuleProxy *sender, const NLNET::CMessage &__message)
{
H_AUTO(CGuildUnifierClientSkel_guildDeleted_GD);
uint32 guildId;
nlRead(__message, serial, guildId);
guildDeleted(sender, guildId);
}
void CAdminExecutorServiceClientSkel::serviceCmdNoReturn_skel(NLNET::IModuleProxy *sender, const NLNET::CMessage &__message)
{
H_AUTO(CAdminExecutorServiceClientSkel_serviceCmdNoReturn_SCMDNR);
std::string command;
nlRead(__message, serial, command);
serviceCmdNoReturn(sender, command);
}
void CAdminServiceSkel::highRezGraphUpdate_skel(NLNET::IModuleProxy *sender, const NLNET::CMessage &__message)
{
H_AUTO(CAdminServiceSkel_highRezGraphUpdate_HRGU);
THighRezDatas graphDatas;
nlRead(__message, serial, graphDatas);
highRezGraphUpdate(sender, graphDatas);
}
void CAdminServiceSkel::upServiceUpdate_skel(NLNET::IModuleProxy *sender, const NLNET::CMessage &__message)
{
H_AUTO(CAdminServiceSkel_upServiceUpdate_USU);
std::vector < TServiceStatus > serviceStatus;
nlRead(__message, serialCont, serviceStatus);
upServiceUpdate(sender, serviceStatus);
}
void CAdminExecutorServiceSkel::serviceStatusUpdate_skel(NLNET::IModuleProxy *sender, const NLNET::CMessage &__message)
{
H_AUTO(CAdminExecutorServiceSkel_serviceStatusUpdate_SSU);
std::string status;
nlRead(__message, serial, status);
serviceStatusUpdate(sender, status);
}
void CAdminExecutorServiceSkel::graphUpdate_skel(NLNET::IModuleProxy *sender, const NLNET::CMessage &__message)
{
H_AUTO(CAdminExecutorServiceSkel_graphUpdate_GU);
TGraphDatas graphDatas;
nlRead(__message, serial, graphDatas);
graphUpdate(sender, graphDatas);
}
void CChatUnifierClientSkel::recvBroadcastMessage_skel(NLNET::IModuleProxy *sender, const NLNET::CMessage &__message)
{
H_AUTO(CChatUnifierClientSkel_recvBroadcastMessage_CURBM);
ucstring message;
nlRead(__message, serial, message);
recvBroadcastMessage(sender, message);
}
void CGuildUnifierClientSkel::receiveForeignGuild_skel(NLNET::IModuleProxy *sender, const NLNET::CMessage &__message)
{
H_AUTO(CGuildUnifierClientSkel_receiveForeignGuild_RFG);
std::vector < CGuildDesc > guilds;
nlRead(__message, serialCont, guilds);
receiveForeignGuild(sender, guilds);
}
// ***************************************************************************
void CVertexStreamManager::unlock(uint numVertices)
{
H_AUTO( NL3D_VertexStreamManager_unlock )
nlassert(_InitOk);
nlassert(_LockDone);
_VBA.touchVertices (0, numVertices);
_VBA.unlock ();
}
void CGuildUnifierClientSkel::updateMemberInfo_skel(NLNET::IModuleProxy *sender, const NLNET::CMessage &__message)
{
H_AUTO(CGuildUnifierClientSkel_updateMemberInfo_UMI);
uint32 guildId;
nlRead(__message, serial, guildId);
CGuildMemberDesc membersInfo;
nlRead(__message, serial, membersInfo);
updateMemberInfo(sender, guildId, membersInfo);
}
void CAdminExecutorServiceClientSkel::serviceCmd_skel(NLNET::IModuleProxy *sender, const NLNET::CMessage &__message)
{
H_AUTO(CAdminExecutorServiceClientSkel_serviceCmd_SCMD);
uint32 commandId;
nlRead(__message, serial, commandId);
std::string command;
nlRead(__message, serial, command);
serviceCmd(sender, commandId, command);
}
void CGuildUnifierClientSkel::updateMemberList_skel(NLNET::IModuleProxy *sender, const NLNET::CMessage &__message)
{
H_AUTO(CGuildUnifierClientSkel_updateMemberList_UML);
uint32 guildId;
nlRead(__message, serial, guildId);
std::vector < CGuildMemberDesc > members;
nlRead(__message, serialCont, members);
updateMemberList(sender, guildId, members);
}
void CAdminExecutorServiceSkel::setShardOrders_skel(NLNET::IModuleProxy *sender, const NLNET::CMessage &__message)
{
H_AUTO(CAdminExecutorServiceSkel_setShardOrders_SCO);
std::string shardName;
nlRead(__message, serial, shardName);
TShardOrders shardOrders;
nlRead(__message, serial, shardOrders);
setShardOrders(sender, shardName, shardOrders);
}
void CAdminExecutorServiceSkel::shutdownShard_skel(NLNET::IModuleProxy *sender, const NLNET::CMessage &__message)
{
H_AUTO(CAdminExecutorServiceSkel_shutdownShard_SDS);
std::string shardName;
nlRead(__message, serial, shardName);
uint32 delay;
nlRead(__message, serial, delay);
shutdownShard(sender, shardName, delay);
}
std::auto_ptr<CUseResult> CConnection::useResult()
{
H_AUTO(CConnection_useResult);
MYSQL_RES *res = mysql_use_result(_MysqlContext);
std::auto_ptr<CUseResult> sr = std::auto_ptr<CUseResult>(new CUseResult(res));
return sr;
}
void CWelcomeServiceClientSkel::updateConnectedPlayerCount_skel(NLNET::IModuleProxy *sender, const NLNET::CMessage &__message)
{
H_AUTO(CWelcomeServiceClientSkel_updateConnectedPlayerCount_UCP);
uint32 nbOnlinePlayers;
nlRead(__message, serial, nbOnlinePlayers);
uint32 nbPendingPlayers;
nlRead(__message, serial, nbPendingPlayers);
updateConnectedPlayerCount(sender, nbOnlinePlayers, nbPendingPlayers);
}
// ***************************************************************************
UAnimationSet *CDriverUser::createAnimationSet(const std::string &animationSetFile)
{
H_AUTO( NL3D_Load_AnimationSet )
NLMISC::CIFile f;
// throw exception if not found.
std::string path= CPath::lookup(animationSetFile);
f.open(path);
return _AnimationSets.insert(new CAnimationSetUser(this, f));
}
bool CConnection::query(const std::string &queryString)
{
H_AUTO(CConnection_query);
nlassert(_Connected);
nldebug("Executing query : [%s%s", queryString.substr(0, 100).c_str(), 100<queryString.size() ? "]" : "");
for (uint i=100; i<queryString.size(); i+=100)
nldebug("\t%s%s", queryString.substr(i, 100).c_str(), i+100>queryString.size() ? "]" : "");
TTime startDate = CTime::getLocalTime();
int result = mysql_real_query(_MysqlContext, queryString.c_str(), (unsigned long)queryString.size());
if (result != 0)
{
// in all case, we try to reconnect
int merrno = mysql_errno(_MysqlContext);
//if (result == CR_SERVER_GONE_ERROR)
{
// reconnect and retry the request
nlinfo("%p Mysql error errno:%d result:%d : %s, try to reconnect...", _MysqlContext, merrno, result, mysql_error(_MysqlContext));
if (_connect())
result = mysql_real_query(_MysqlContext, queryString.c_str(), (unsigned long)queryString.size());
else
{
nlwarning("Failed to reopen closed connection to send query '%s'", queryString.c_str());
if (MSWStrictMode)
{
nlstopex(("SQL Strict mode, the above error is fatal"));
}
TTime endDate = CTime::getLocalTime();
MSWRequestDuration = uint32(endDate - startDate);
return false;
}
}
if (result != 0)
{
nlwarning("Mysql error errno:%d result:%d : %s", merrno, result, mysql_error(_MysqlContext));
nlwarning(" in query '%s':", queryString.c_str());
if (MSWStrictMode)
{
nlstopex(("SQL Strict mode, the above error is fatal"));
}
TTime endDate = CTime::getLocalTime();
MSWRequestDuration = uint32(endDate - startDate);
return false;
}
}
TTime endDate = CTime::getLocalTime();
MSWRequestDuration = uint32(endDate - startDate);
return true;
}
void CWelcomeServiceClientSkel::registerWS_skel(NLNET::IModuleProxy *sender, const NLNET::CMessage &__message)
{
H_AUTO(CWelcomeServiceClientSkel_registerWS_RWS);
uint32 shardId;
nlRead(__message, serial, shardId);
uint32 fixedSessionId;
nlRead(__message, serial, fixedSessionId);
bool isOnline;
nlRead(__message, serial, isOnline);
registerWS(sender, shardId, fixedSessionId, isOnline);
}
void CAdminExecutorServiceSkel::controlCmd_skel(NLNET::IModuleProxy *sender, const NLNET::CMessage &__message)
{
H_AUTO(CAdminExecutorServiceSkel_controlCmd_CC);
uint32 commandId;
nlRead(__message, serial, commandId);
std::string serviceAlias;
nlRead(__message, serial, serviceAlias);
std::string command;
nlRead(__message, serial, command);
controlCmd(sender, commandId, serviceAlias, command);
}
void CChatUnifierClientSkel::dynChanBroadcast_skel(NLNET::IModuleProxy *sender, const NLNET::CMessage &__message)
{
H_AUTO(CChatUnifierClientSkel_dynChanBroadcast_CUDCB);
NLMISC::CEntityId chanId;
nlRead(__message, serial, chanId);
ucstring senderName;
nlRead(__message, serial, senderName);
ucstring text;
nlRead(__message, serial, text);
dynChanBroadcast(sender, chanId, senderName, text);
}
void CChatUnifierClientSkel::universeBroadcast_skel(NLNET::IModuleProxy *sender, const NLNET::CMessage &__message)
{
H_AUTO(CChatUnifierClientSkel_universeBroadcast_CURUB);
ucstring senderName;
nlRead(__message, serial, senderName);
uint32 senderHomeSession;
nlRead(__message, serial, senderHomeSession);
ucstring text;
nlRead(__message, serial, text);
universeBroadcast(sender, senderName, senderHomeSession, text);
}
void CChatUnifierClientSkel::farGuildChat2Ex_skel(NLNET::IModuleProxy *sender, const NLNET::CMessage &__message)
{
H_AUTO(CChatUnifierClientSkel_farGuildChat2Ex_CURFGC2E);
ucstring senderName;
nlRead(__message, serial, senderName);
uint32 guildId;
nlRead(__message, serial, guildId);
uint32 phraseId;
nlRead(__message, serial, phraseId);
farGuildChat2Ex(sender, senderName, guildId, phraseId);
}
void CChatUnifierClientSkel::recvFarTellFail_skel(NLNET::IModuleProxy *sender, const NLNET::CMessage &__message)
{
H_AUTO(CChatUnifierClientSkel_recvFarTellFail_CURFTF);
NLMISC::CEntityId senderCharId;
nlRead(__message, serial, senderCharId);
ucstring destName;
nlRead(__message, serial, destName);
TFailInfo failInfo;
nlRead(__message, serial, failInfo);
recvFarTellFail(sender, senderCharId, destName, failInfo);
}
void CAdminServiceSkel::commandResult_skel(NLNET::IModuleProxy *sender, const NLNET::CMessage &__message)
{
H_AUTO(CAdminServiceSkel_commandResult_CR);
uint32 commandId;
nlRead(__message, serial, commandId);
std::string serviceAlias;
nlRead(__message, serial, serviceAlias);
std::string result;
nlRead(__message, serial, result);
commandResult(sender, commandId, serviceAlias, result);
}
void CGuildUnifierClientSkel::messageToGuildMembers_skel(NLNET::IModuleProxy *sender, const NLNET::CMessage &__message)
{
H_AUTO(CGuildUnifierClientSkel_messageToGuildMembers_MGM);
uint32 guildId;
nlRead(__message, serial, guildId);
std::string messageName;
nlRead(__message, serial, messageName);
TVectorParamCheck params;
nlRead(__message, serialCont, params);
messageToGuildMembers(sender, guildId, messageName, params);
}
void CWelcomeServiceClientSkel::welcomeUserResult_skel(NLNET::IModuleProxy *sender, const NLNET::CMessage &__message)
{
H_AUTO(CWelcomeServiceClientSkel_welcomeUserResult_WUR);
uint32 userId;
nlRead(__message, serial, userId);
bool ok;
nlRead(__message, serial, ok);
std::string shardAddr;
nlRead(__message, serial, shardAddr);
std::string errorMsg;
nlRead(__message, serial, errorMsg);
welcomeUserResult(sender, userId, ok, shardAddr, errorMsg);
}
void CChatUnifierSkel::sendFarTell_skel(NLNET::IModuleProxy *sender, const NLNET::CMessage &__message)
{
H_AUTO(CChatUnifierSkel_sendFarTell_CUSFT);
NLMISC::CEntityId senderCharId;
nlRead(__message, serial, senderCharId);
bool havePrivilege;
nlRead(__message, serial, havePrivilege);
ucstring destName;
nlRead(__message, serial, destName);
ucstring text;
nlRead(__message, serial, text);
sendFarTell(sender, senderCharId, havePrivilege, destName, text);
}
// ***************************************************************************
void CVertexStreamManager::activate()
{
H_AUTO( NL3D_VertexStreamManager_activate )
nlassert(_InitOk);
if (_SupportVolatileVB)
{
_Driver->activeVertexBuffer(_VBVolatile);
}
else
{
_Driver->activeVertexBuffer(_VB[_CurentVB]);
}
}
