//-------------------------------------------------------------------------------------
bool ClientApp::updateChannel(bool loginapp, std::string accountName, std::string passwd,
std::string ip, KBEngine::uint32 port)
{
if(pServerChannel_->pEndPoint())
{
pServerChannel_->stopSend();
networkInterface().dispatcher().deregisterReadFileDescriptor(*pServerChannel_->pEndPoint());
networkInterface().deregisterChannel(pServerChannel_);
}
bool ret = loginapp ? (initLoginappChannel(accountName, passwd, ip, port) != NULL) : (initBaseappChannel() != NULL);
if(ret)
{
if(pTCPPacketReceiver_)
pTCPPacketReceiver_->pEndPoint(pServerChannel_->pEndPoint());
else
pTCPPacketReceiver_ = new Network::TCPPacketReceiver(*pServerChannel_->pEndPoint(), networkInterface());
if(pTCPPacketSender_)
pTCPPacketSender_->pEndPoint(pServerChannel_->pEndPoint());
else
pTCPPacketSender_ = new Network::TCPPacketSender(*pServerChannel_->pEndPoint(), networkInterface());
pServerChannel_->pPacketSender(pTCPPacketSender_);
networkInterface().registerChannel(pServerChannel_);
networkInterface().dispatcher().registerReadFileDescriptor(*pServerChannel_->pEndPoint(), pTCPPacketReceiver_);
}
return ret;
}
//-------------------------------------------------------------------------------------
void ClientApp::handleGameTick()
{
g_kbetime++;
threadPool_.onMainThreadTick();
handleTimers();
if(lastAddr.ip != 0)
{
getNetworkInterface().deregisterChannel(lastAddr);
getNetworkInterface().registerChannel(pServerChannel_);
lastAddr.ip = 0;
}
getNetworkInterface().processAllChannelPackets(KBEngine::Mercury::MessageHandlers::pMainMessageHandlers);
tickSend();
switch(state_)
{
case C_STATE_INIT:
state_ = C_STATE_PLAY;
break;
case C_STATE_INITLOGINAPP_CHANNEL:
state_ = C_STATE_PLAY;
break;
case C_STATE_LOGIN:
state_ = C_STATE_PLAY;
if(!ClientObjectBase::login())
{
WARNING_MSG("ClientApp::handleGameTick: login is failed!\n");
return;
}
break;
case C_STATE_LOGIN_GATEWAY_CHANNEL:
{
state_ = C_STATE_PLAY;
bool exist = false;
if(pServerChannel_->endpoint())
{
lastAddr = pServerChannel_->endpoint()->addr();
getNetworkInterface().dispatcher().deregisterFileDescriptor(*pServerChannel_->endpoint());
exist = getNetworkInterface().findChannel(pServerChannel_->endpoint()->addr()) != NULL;
}
bool ret = initBaseappChannel() != NULL;
if(ret)
{
if(!exist)
{
getNetworkInterface().registerChannel(pServerChannel_);
pTCPPacketReceiver_ = new Mercury::TCPPacketReceiver(*pServerChannel_->endpoint(), getNetworkInterface());
}
else
{
pTCPPacketReceiver_->endpoint(pServerChannel_->endpoint());
}
getNetworkInterface().dispatcher().registerFileDescriptor(*pServerChannel_->endpoint(), pTCPPacketReceiver_);
// 先握手然后等helloCB之后再进行登录
Mercury::Bundle* pBundle = Mercury::Bundle::ObjPool().createObject();
(*pBundle).newMessage(BaseappInterface::hello);
(*pBundle) << KBEVersion::versionString();
if(Mercury::g_channelExternalEncryptType == 1)
{
pBlowfishFilter_ = new Mercury::BlowfishFilter();
(*pBundle).appendBlob(pBlowfishFilter_->key());
pServerChannel_->pFilter(NULL);
}
else
{
std::string key = "";
(*pBundle).appendBlob(key);
}
pServerChannel_->pushBundle(pBundle);
// ret = ClientObjectBase::loginGateWay();
}
}
break;
case C_STATE_LOGIN_GATEWAY:
state_ = C_STATE_PLAY;
if(!ClientObjectBase::loginGateWay())
{
WARNING_MSG("ClientApp::handleGameTick: loginGateWay is failed!\n");
return;
}
break;
case C_STATE_PLAY:
break;
default:
KBE_ASSERT(false);
break;
};
}
