void UpdateServers()
{
int64 Now = time_get();
int64 Freq = time_freq();
for(int i = 0; i < m_NumCheckServers; i++)
{
if(Now > m_aCheckServers[i].m_TryTime+Freq)
{
if(m_aCheckServers[i].m_TryCount == 10)
{
dbg_msg("mastersrv", "check failed: %d.%d.%d.%d:%d",
m_aCheckServers[i].m_Address.ip[0], m_aCheckServers[i].m_Address.ip[1],
m_aCheckServers[i].m_Address.ip[2], m_aCheckServers[i].m_Address.ip[3],m_aCheckServers[i].m_Address.port,
m_aCheckServers[i].m_AltAddress.ip[0], m_aCheckServers[i].m_AltAddress.ip[1],
m_aCheckServers[i].m_AltAddress.ip[2], m_aCheckServers[i].m_AltAddress.ip[3],m_aCheckServers[i].m_AltAddress.port);
// FAIL!!
SendError(&m_aCheckServers[i].m_Address);
m_aCheckServers[i] = m_aCheckServers[m_NumCheckServers-1];
m_NumCheckServers--;
i--;
}
else
{
m_aCheckServers[i].m_TryCount++;
m_aCheckServers[i].m_TryTime = Now;
if(m_aCheckServers[i].m_TryCount&1)
SendCheck(&m_aCheckServers[i].m_Address);
else
SendCheck(&m_aCheckServers[i].m_AltAddress);
}
}
}
}
int HeroLevelUp(const Data& data, std::weak_ptr<CPlayer> player)
{
if (!SendCheck(player))
{
return -1;
}
int result = 0;
PBC2SHeroLevelUpReq req;
req.ParseFromArray(data.buffer, data.bufferLength);
std::weak_ptr<CHero> p = player.lock()->GetHeroData().GetHeroPack().GetHero(req.heroindex());
if (p.expired())
{
return -1;
}
CConsume consume(p.lock()->GetUpLevelEmpirical(), (int)ConsumeNumerical, (int)ConsumeEmpirical, *player.lock());
if (!consume.CheckConsume())
{
return -1;
}
if (consume.ConsumeReduce() == -1)
{
return -1;
}
p.lock()->LevelUp();
PBS2CHeroLevelUpRes res;
res.set_herolevelupresult(result);
player.lock()->GetSocket().lock()->SendBuff((int)TypeS2CHeroLevelUpRes, res);
SavePlayer2DB(player);
return 0;
}
int GetPlayerList(const Data& data, std::weak_ptr<CPlayer> player)
{
if (!SendCheck(player))
{
return -1;
}
PBS2CGetPlayerListRes res;
res.set_getplayerlistresult(0);
PlayerManager::GetInstance().PlayerList2PB(res);
player.lock()->GetSocket().lock()->SendBuff((int)TypeS2CGetPlayerListRes, res);
return 0;
}
int GetHeroTeam(const Data& data, std::weak_ptr<CPlayer> player)
{
if (!SendCheck(player))
{
return -1;
}
PBS2CGetHeroTeamRes res;
int result = player.lock()->GetHeroData().HeroTeam2PB(*res.mutable_heroteam());
res.set_getheroteamresult(result);
player.lock()->GetSocket().lock()->SendBuff((int)TypeS2CGetHeroTeamRes, res);
return 0;
}
int GetPlayerInfo(const Data& data, std::weak_ptr<CPlayer> player)
{
if (!SendCheck(player))
{
return -1;
}
PBS2CGetPlayerInfoRes res;
int result = player.lock()->PlayerInfo2PB((*res.mutable_playerinfo()));
res.set_getplayerinforesult(result);
player.lock()->GetSocket().lock()->SendBuff((int)TypeS2CGetPlayerInfoRes, res);
return 0;
}
int GetHeroList(const Data& data, std::weak_ptr<CPlayer> player)
{
if (!SendCheck(player))
{
return -1;
}
PBS2CGetHeroListRes res;
if (player.lock()->GetHeroData().GetHeroPack().HeroList2PB(res) != 0)
{
return -1;
}
res.set_getherolistresult(0);
player.lock()->GetSocket().lock()->SendBuff((int)TypeS2CGetHeroListRes, res);
return 0;
}
int AddEmpirical(const Data& data, std::weak_ptr<CPlayer> player)
{
if (!SendCheck(player))
{
return -1;
}
PBC2SAddEmpiricalReq req;
req.ParseFromArray(data.buffer, data.bufferLength);
player.lock()->AddEmpirical(req.empiricalnumber());
PBS2CAddEmpiricalRes res;
res.set_addempiricalresult(0);
player.lock()->GetSocket().lock()->SendBuff((int)TypeS2CAddEmpiricalRes, res);
SavePlayer2DB(player);
return 0;
}
int UpdateHeroTeam(const Data& data, std::weak_ptr<CPlayer> player)
{
if (!SendCheck(player))
{
return -1;
}
PBC2SUpdateHeroTeamReq req;
req.ParseFromArray(data.buffer, data.bufferLength);
PBS2CUpdateHeroTeamRes res;
player.lock()->GetHeroData().GetHeroTeam().PB2Team(req);
res.set_updateheroteamresult(0);
player.lock()->GetSocket().lock()->SendBuff((int)TypeS2CUpdateHeroTeamRes, res);
SavePlayer2DB(player);
return 0;
}
int DeleteHero(const Data& data, std::weak_ptr<CPlayer> player)
{
if (!SendCheck(player))
{
return -1;
}
PBC2SDeleteHeroReq req;
req.ParseFromArray(data.buffer, data.bufferLength);
PBS2CDeleteHeroRes res;
player.lock()->GetHeroData().GetHeroPack().RemoveHero(req.heroindex());
res.set_deleteheroresult(0);
player.lock()->GetSocket().lock()->SendBuff((int)TypeS2CDeleteHeroRes, res);
SavePlayer2DB(player);
return 0;
}
int BuyHero(const Data& data, std::weak_ptr<CPlayer> player)
{
if (!SendCheck(player))
{
return -1;
}
PBC2SBuyHeroReq req;
req.ParseFromArray(data.buffer, data.bufferLength);
PBS2CBuyHeroRes res;
int result = BuyHeroLogic(req.heroid(), *player.lock());
res.set_buyheroresult(result);
player.lock()->GetSocket().lock()->SendBuff((int)TypeS2CBuyHeroRes, res);
SavePlayer2DB(player);
return 0;
}
int GetHeroInfo(const Data& data, std::weak_ptr<CPlayer> player)
{
if (!SendCheck(player))
{
return -1;
}
PBC2SGetHeroInfoReq req;
req.ParseFromArray(data.buffer, data.bufferLength);
std::weak_ptr<CHero> p = player.lock()->GetHeroData().GetHeroPack().GetHero(req.heroindex());
if (p.expired())
{
return -1;
}
PBS2CGetHeroInfoRes res;
p.lock()->HeroInfo2PB(*res.mutable_heroinfo());
res.set_getheroinforesult(0);
player.lock()->GetSocket().lock()->SendBuff((int)TypeS2CGetHeroInfoRes, res);
return 0;
}
int DeleteUser(const Data& data, std::weak_ptr<CPlayer> player)
{
if (!SendCheck(player))
{
return -1;
}
PBC2SDeleteUserReq req;
req.ParseFromArray(data.buffer, data.bufferLength);
PBS2CDeleteUserRes res;
if (DBServer::GetInstance().DeleteUser(player.lock()->GetPlayerID(), res) != 0)
{
return -1;
}
player.lock()->GetSocket().lock()->SendBuff((int)TypeS2CDeleteUserRes, res);
if (res.deleteuserresult() == 1)
{
player.lock()->GetSocket().lock()->SetPlayer(std::weak_ptr<CPlayer>());
PlayerManager::GetInstance().RemovePlayer(player.lock()->GetPlayerID());
}
return 0;
}
genxStatus genxEndElement(genxWriter w)
{
genxElement e;
int i;
switch (w->sequence)
{
case SEQUENCE_NO_DOC:
case SEQUENCE_PRE_DOC:
case SEQUENCE_POST_DOC:
return w->status = GENX_SEQUENCE_ERROR;
case SEQUENCE_START_TAG:
case SEQUENCE_ATTRIBUTES:
if ((w->status = writeStartTag(w)) != GENX_SUCCESS)
return w->status;
break;
case SEQUENCE_CONTENT:
break;
}
/*
* first peek into the stack to find the right namespace declaration
* (if any) so we can properly prefix the end-tag. Have to do this
* before unwinding the stack because that might reset some xmlns
* prefixes to the context in the parent element
*/
for (i = w->stack.count - 1; w->stack.pointers[i] != NULL; i -= 2)
;
e = (genxElement) w->stack.pointers[--i];
SendCheck(w, "</");
if (e->ns && e->ns->declaration != w->xmlnsEquals)
{
SendCheck(w, e->ns->declaration->name + STRLEN_XMLNS_COLON);
SendCheck(w, ":");
}
SendCheck(w, e->type);
SendCheck(w, ">");
/*
* pop zero or more namespace declarations, then a null, then the
* start-element declaration off the stack
*/
w->stack.count--;
while (w->stack.pointers[w->stack.count] != NULL)
{
genxNamespace ns = (genxNamespace) w->stack.pointers[--w->stack.count];
w->stack.count--; /* don't need decl */
/* if not a fake unset-default namespace */
if (ns)
{
/*
* if they've stupidly jammed in their own namespace-prefix
* declarations, we have to go looking to see if there's another
* one in effect
*/
if (ns->baroque)
{
i = w->stack.count;
while (i > 0)
{
while (w->stack.pointers[i] != NULL)
{
genxAttribute otherDecl = (genxAttribute) w->stack.pointers[i--];
genxNamespace otherNs = (genxNamespace) w->stack.pointers[i--];
if (otherNs == ns)
{
ns->declaration = otherDecl;
i = 0;
break;
}
}
/* skip NULL & element */
i -= 2;
}
}
ns->declCount--;
if (ns->declCount == 0)
ns->baroque = False;
}
}
/* pop the NULL */
--w->stack.count;
if (w->stack.count < 0)
return w->status = GENX_NO_START_TAG;
if (w->stack.count == 0)
w->sequence = SEQUENCE_POST_DOC;
else
w->sequence = SEQUENCE_CONTENT;
return GENX_SUCCESS;
}
/*
* Write out the attributes we've been gathering up for an element. We save
* them until we've gathered them all so they can be writen in canonical
* order.
* Also, we end the start-tag.
* The trick here is that we keep the attribute list properly sorted as
* we build it, then as each attribute is added, we fill in its value and
* mark the fact that it's been added, in the "provided" field.
*/
static genxStatus writeStartTag(genxWriter w)
{
int i;
genxAttribute * aa = (genxAttribute *) w->attributes.pointers;
genxElement e = w->nowStarting;
/*
* make sure the right namespace decls are in effect;
* if they are these might create an error, so ignore it
*/
if (e->ns)
addNamespace(e->ns, NULL);
else
unsetDefaultNamespace(w);
w->status = GENX_SUCCESS;
SendCheck(w, WIDE("<"));
if (e->ns && (e->ns->declaration != w->xmlnsEquals))
{
SendCheck(w, e->ns->declaration->name + STRLEN_XMLNS_COLON);
SendCheck(w, WIDE(":"));
}
SendCheck(w, e->type);
for (i = 0; i < w->attributes.count; i++)
{
if (aa[i]->provided)
{
if (aa[i]->ns && aa[i]->ns->baroque &&
aa[i]->ns->declaration == w->xmlnsEquals)
return w->status = GENX_ATTRIBUTE_IN_DEFAULT_NAMESPACE;
SendCheck(w, WIDE(" "));
if (aa[i]->ns)
{
SendCheck(w, aa[i]->ns->declaration->name + STRLEN_XMLNS_COLON)
SendCheck(w, WIDE(":"));
}
SendCheck(w, aa[i]->name);
SendCheck(w, WIDE("=\""));
SendCheck(w, aa[i]->value.buf);
SendCheck(w, WIDE("\""));
}
}
SendCheck(w, WIDE(">"));
return GENX_SUCCESS;
}
