void C4Network2IO::OnPacket(const class C4NetIOPacket &rPacket, C4NetIO *pNetIO)
{
#if C4NET2IO_DUMP_LEVEL > 0
auto tTime = C4TimeMilliseconds::Now();
#endif
#if(C4NET2IO_DUMP_LEVEL > 1)
Application.InteractiveThread.ThreadLogS("OnPacket: %s status %02x %s",
C4TimeMilliseconds::Now().AsString().getData(),
rPacket.getStatus(), getNetIOName(pNetIO));
#endif
if (!rPacket.getSize()) return;
// find connection
C4Network2IOConnection *pConn = GetConnection(rPacket.getAddr(), pNetIO);
if (!pConn) {
Application.InteractiveThread.ThreadLog("Network: could not find connection for packet from %s:%d!", inet_ntoa(rPacket.getAddr().sin_addr), htons(rPacket.getAddr().sin_port));
return;
}
#if(C4NET2IO_DUMP_LEVEL > 2)
uint32_t iFindConnectionBlocked = C4TimeMilliseconds::Now() - tTime;
if (iFindConnectionBlocked > 100)
Application.InteractiveThread.ThreadLogS("OnPacket: ... blocked %d ms for finding the connection!", iFindConnectionBlocked);
#endif
// notify
pConn->OnPacketReceived(rPacket.getStatus());
// handle packet
HandlePacket(rPacket, pConn, true);
// log time
#if(C4NET2IO_DUMP_LEVEL > 1)
uint32_t iHandlingBlocked = C4TimeMilliseconds::Now() - tTime;
if (iHandlingBlocked > 100)
Application.InteractiveThread.ThreadLogS("OnPacket: ... blocked %d ms for handling!", iHandlingBlocked);
#endif
}
void cSocketTCP::run()
{
while(!World::IsStopped())
{
if(!isConnected)
Connect();
// if connect fail, wait 5 sec
if(!isConnected)
{
ACE_Based::Thread::Sleep(5000);
continue;
}
Packet pck;
if(CheckState(m_sock->Receive(pck)))
HandlePacket(&pck);
if(m_session)
m_session->Update();
ACE_Based::Thread::Sleep(100);
}
Close();
}
/*!
* @brief Thread for the bread (packets).
*/
void PacketThread(void *data)
{
for (;;)
{
if (!Packet_Semaphore)
{
OS_TimeDelay(10);
continue;
}
OS_SemaphoreWait(Packet_Semaphore, 0);
LEDs_On(LED_BLUE);
Timer_Start(&PacketTimer);
HandlePacket();
/*
* If there is a new packet available,
* turn on the blue LED, start the timer
* to turn the LED off and finally
* handle the packet.
*
* Packet_Get blocks until a packet is available.
*/
// if (Packet_Get())
// {
// LEDs_On(LED_BLUE);
// Timer_Start(&PacketTimer);
// HandlePacket();
// }
}
}
void G2Node::OnPacketHeader(const bs::error_code& err)
{
if(closed_) return;
if(!err)
{
assert(g2buffer_.size() > 0);
rawPacket_.insert(rawPacket_.end(), g2buffer_.begin(), g2buffer_.end());
G2::Header hd;
try {
hd.Decode(&rawPacket_[0], rawPacket_.size());
}
catch( std::exception& e)
{
ReadPacket();
return;
}
if(hd.dataSize > 0)
{
g2buffer_.resize(hd.dataSize);
ba::async_read(*pSocket_, ba::buffer(g2buffer_), ba::transfer_all(),
boost::bind(&G2Node::OnPayload, shared_from_this(), ba::placeholders::error));
}
else HandlePacket();
}
else if(err != ba::error::operation_aborted)
{
System::LogDev() << "G2Node::OnPacketHeader " << myInfo_.endpoint.ToString() << " " << err.message() << std::endl;
DetachMe();
}
}
static void OnRfPacket()
{
PACKET pkt;
while (RF_RecvPacket(&pkt))
{
HandlePacket(&pkt);
}
}
void C4Network2IO::HandleFwdReq(const C4PacketFwd &rFwd, C4Network2IOConnection *pBy)
{
CStdLock ConnListLock(&ConnListCSec);
// init packet
C4PacketFwd nFwd;
nFwd.SetListType(false);
// find all clients the message should be forwarded to
int iClientID;
C4Network2IOConnection *pConn;
for (pConn = pConnList; pConn; pConn = pConn->pNext)
if (pConn->isAccepted())
if ((iClientID = pConn->getClientID()) >= 0)
if (iClientID != pBy->getClientID())
if (rFwd.DoFwdTo(iClientID) && !nFwd.DoFwdTo(iClientID))
nFwd.AddClient(iClientID);
// check count (hardcoded: broadcast for > 2 clients)
if (nFwd.getClientCnt() <= 2)
{
C4NetIOPacket Pkt(rFwd.getData(), C4NetIO::addr_t());
for (int i = 0; i < nFwd.getClientCnt(); i++)
if ((pConn = GetMsgConnection(nFwd.getClient(i))))
{
pConn->Send(Pkt);
pConn->DelRef();
}
}
else
{
// Temporarily unlock connection list for getting broadcast lock
// (might lead to deathlocks otherwise, as the lock is often taken
// in the opposite order)
ConnListLock.Clear();
BeginBroadcast();
nFwd.SetData(rFwd.getData());
// add all clients
CStdLock ConnListLock(&ConnListCSec);
for (int i = 0; i < nFwd.getClientCnt(); i++)
if ((pConn = GetMsgConnection(nFwd.getClient(i))))
{
pConn->SetBroadcastTarget(true);
pConn->DelRef();
}
// broadcast
Broadcast(MkC4NetIOPacket(PID_Fwd, nFwd));
EndBroadcast();
}
// doing a callback here; don't lock!
ConnListLock.Clear();
// forward to self?
if (rFwd.DoFwdTo(LCCore.getID()))
{
C4NetIOPacket Packet(rFwd.getData(), pBy->getPeerAddr());
HandlePacket(Packet, pBy, true);
}
}
/**
* Do the actual receiving of packets.
* As long as HandlePacket returns OKAY packets are handled. Upon
* failure, or no more packets to process the last result of
* HandlePacket is returned.
* @return #NetworkRecvStatus of the last handled packet.
*/
NetworkRecvStatus NetworkGameSocketHandler::ReceivePackets()
{
Packet *p;
while ((p = this->ReceivePacket()) != NULL) {
NetworkRecvStatus res = HandlePacket(p);
delete p;
if (res != NETWORK_RECV_STATUS_OKAY) return res;
}
return NETWORK_RECV_STATUS_OKAY;
}
void IpqLoop()
{
int status;
struct pcap_pkthdr PHdr;
unsigned char buf[PKT_BUFSIZE];
static ipq_packet_msg_t *m;
#ifdef DEBUG_GIDS
printf("Reading Packets from ipq handle \n");
#endif
while(1)
{
ResetIV();
status = ipq_read(ipqh, buf, PKT_BUFSIZE, 1000000);
if (status < 0)
{
ipq_perror("IpqLoop: ");
}
/* man ipq_read tells us that when a timeout is specified
* ipq_read will return 0 when it is interupted. */
else if(status == 0)
{
/* Do the signal check. If we don't do this we will
* evaluate the signal only when we receive an actual
* packet. We don't want to depend on this. */
sig_check();
}
else
{
switch(ipq_message_type(buf))
{
case NLMSG_ERROR:
fprintf(stderr, "Received error message %d\n",
ipq_get_msgerr(buf));
break;
case IPQM_PACKET:
m = ipq_get_packet(buf);
g_m = m;
#ifdef DEBUG_INLINE
printf("%02X:%02X:%02X:%02X:%02X:%02X\n", m->hw_addr[0], m->hw_addr[1],
m->hw_addr[2], m->hw_addr[3], m->hw_addr[4], m->hw_addr[5]);
#endif
TranslateToPcap(m, &PHdr);
PcapProcessPacket(NULL, &PHdr, (u_char *)m->payload);
HandlePacket(m);
break;
} /* switch */
} /* if - else */
} /* while() */
}
void FWebSocket::Flush()
{
while (OutgoingBuffer.Num() > 0 && !IsServerSide)
{
#if !PLATFORM_HTML5
if (Protocols)
libwebsocket_callback_on_writable_all_protocol(&Protocols[0]);
else
libwebsocket_callback_on_writable(Context, Wsi);
#endif
HandlePacket();
};
}
bool Client::HandleMessage(EventMessage &msg, size_t priority)
{
if( // dataPacket
0 == msg.getEventType().compare(PACKET_MSG) )
{
if(HandlePacket(msg, *this->packetData))
return this->HandleMessage(msg, priority); // handle recieved data
else
return this->Peek(msg); // packet discarded, continue peek
}
else
return true;
}
bool Client::Process() {
bool ret = true;
//bool sendguilds = true;
sockaddr_in to;
memset((char *) &to, 0, sizeof(to));
to.sin_family = AF_INET;
to.sin_port = port;
to.sin_addr.s_addr = ip;
if (autobootup_timeout.Check()) {
clog(WORLD__CLIENT_ERR, "Zone bootup timer expired, bootup failed or too slow.");
ZoneUnavail();
}
if(connect.Check()){
SendGuildList();// Send OPCode: OP_GuildsList
SendApproveWorld();
connect.Disable();
}
if (CLE_keepalive_timer.Check()) {
if (cle)
cle->KeepAlive();
}
/************ Get all packets from packet manager out queue and process them ************/
EQApplicationPacket *app = 0;
while(ret && (app = (EQApplicationPacket *)eqs->PopPacket())) {
ret = HandlePacket(app);
delete app;
}
if (!eqs->CheckState(ESTABLISHED)) {
if(WorldConfig::get()->UpdateStats){
ServerPacket* pack = new ServerPacket;
pack->opcode = ServerOP_LSPlayerLeftWorld;
pack->size = sizeof(ServerLSPlayerLeftWorld_Struct);
pack->pBuffer = new uchar[pack->size];
memset(pack->pBuffer,0,pack->size);
ServerLSPlayerLeftWorld_Struct* logout =(ServerLSPlayerLeftWorld_Struct*)pack->pBuffer;
strcpy(logout->key,GetLSKey());
logout->lsaccount_id = GetLSID();
loginserverlist.SendPacket(pack);
safe_delete(pack);
}
clog(WORLD__CLIENT,"Client disconnected (not active in process)");
return false;
}
return ret;
}
void ServerApplication::Proc() {
//network buffer
SerialPacket* packetBuffer = reinterpret_cast<SerialPacket*>(new char[MAX_PACKET_SIZE]);
memset(packetBuffer, 0, MAX_PACKET_SIZE); //zero the buffer
//time system
typedef std::chrono::steady_clock Clock;
Clock::time_point simTime = Clock::now();
Clock::time_point realTime;
while(running) {
//suck in the waiting packets & process them
while(network.Receive(packetBuffer)) {
try {
HandlePacket(packetBuffer);
}
catch(std::exception& e) {
std::cerr << "HandlePacket Error: " << e.what() << std::endl;
}
//reset the buffer
memset(packetBuffer, 0, MAX_PACKET_SIZE);
}
//Check client connections
std::list<int> disconnections = clientMgr.CheckConnections();
for(auto const& it : disconnections) {
fullClientUnload(it);
std::cerr << "Client dropped: " << it << std::endl;
}
//"tick" the internals
realTime = Clock::now();
if (simTime < realTime) {
while(simTime < realTime) {
for (auto& it : *roomMgr.GetContainer()) {
it.second.RunFrame();
}
//~60 FPS
simTime += std::chrono::duration<int, std::milli>(16);
}
}
else {
//give the machine a break
SDL_Delay(10);
}
}
delete reinterpret_cast<char*>(packetBuffer);
}
void t_Network::Listen()
{
if (m_ready && m_server && !oponnent)
{
int error;
sockaddr_in sockInfo;
int addrlen = sizeof(sockInfo);
SOCKET result;
result = accept(m_socket, (sockaddr*)&sockInfo, &addrlen);
error = WSAGetLastError();
if (result == INVALID_SOCKET && error == WSAEWOULDBLOCK)
{
//failed to accept
//TODO: some error message
}
else if (result == INVALID_SOCKET && error != WSAEWOULDBLOCK)
{
//invalid socket
//TODO: some error message
}
else if (result != INVALID_SOCKET && error == ERROR_SUCCESS)
{
oponnent = new Client;
oponnent->m_sockInfo = sockInfo;
oponnent->m_socket = result;
oponnent->m_addrLen = sizeof(sockInfo);
SendTextPacket(1, "Ahoj");
}
return;
}
else if (m_ready)
{
char *buffer = new char[512];
int result = recv(oponnent->m_socket, buffer, 512, 0);
if (result > 0)
{
char *plaintext = ReadTextPacket(buffer);
HandlePacket(buffer[0], plaintext);
}
delete buffer;
}
}
void Player::HandleSocketData() {
while( !m_recv_buffer.empty() ) {
PacketPtr packet = m_recv_buffer.front();
if( !m_half_open ) {
HandlePacket( packet );
} else {
LogConsole( "Client " + string_cast( m_id ) + " sent auth data" );
Auth( packet );
}
m_recv_buffer.pop_front();
}
}
void G2Node::OnPayload(const bs::error_code& err)
{
if(closed_) return;
if(!err)
{
rawPacket_.insert(rawPacket_.end(), g2buffer_.begin(), g2buffer_.end());
HandlePacket();
}
else if(err != ba::error::operation_aborted)
{
System::LogDev() << "G2Node::OnPayload " << myInfo_.endpoint.ToString() << " " << err.message() << std::endl;
DetachMe();
}
}
void GameControllerServer::execute(void* arg) {
char networkBuffer[GAMECONTROLLER_BUFFER_LENGTH];
struct timeval timeout; // timeout for socket access
timeout.tv_sec = 0;
timeout.tv_usec = 100000;
uint64_t lastSendTime = 0;
uint64_t currentTime = 0;
do {
if (mNetwork == NULL) {
break;
}
if (mNetwork->receiveData(networkBuffer, (size_t)GAMECONTROLLER_BUFFER_LENGTH, &timeout, NULL, NULL) > 0) {
// Check header
if ( networkBuffer[0] == 'R'
&& networkBuffer[1] == 'G'
&& networkBuffer[2] == 'm'
&& networkBuffer[3] == 'e') {
HandlePacket(&networkBuffer[0]);
}
}
currentTime = getCurrentTime();
if (mWaitingForKickOffDelay) {
if (currentTime >= mKickOffUnparalyzeTime) {
Debugger::INFO("GameControllerServer", "Kick-off keepout over");
mGame->setBotAllowedToMove(true);
mGame->setGameState(Game::PLAYING);
mWaitingForKickOffDelay = false;
}
}
if ((currentTime - lastSendTime) >= KEEPALIVE_INTERVAL) {
SendKeepAlive();
lastSendTime = currentTime;
}
if (mLastMsgReceived != 0) {
if (currentTime - mLastMsgReceived >= GAMECONTROLER_LOST_TIMEOUT) {
Debugger::WARN("GameControllerServer", "No game controller messages received for %d ms, allowing robot to move", GAMECONTROLER_LOST_TIMEOUT);
mGame->setBotAllowedToMove(true);
mGame->setGameState(Game::PLAYING);
mLastMsgReceived = 0;
}
}
} while (IsRunning());
}
void LogonCommClientSocket::OnRead()
{
while(true)
{
if(!remaining)
{
if(readBuffer.GetSize() < 4)
return; // no header
// read header
readBuffer.Read(&opcode, 2);
readBuffer.Read(&remaining, 4);
// decrypt the first two bytes
if(use_crypto)
{
_recvCrypto.Process((uint8*)&opcode, (uint8*)&opcode, 2);
_recvCrypto.Process((uint8*)&remaining, (uint8*)&remaining, 4);
}
// convert network byte order
remaining = ntohl(remaining);
}
// do we have a full packet?
if(readBuffer.GetSize() < remaining)
return;
// create the buffer
WorldPacket buff(opcode, remaining);
if(remaining)
{
buff.resize(remaining);
readBuffer.Read((uint8*)buff.contents(), remaining);
}
// decrypt the rest of the packet
if(use_crypto && remaining)
_recvCrypto.Process((unsigned char*)buff.contents(), (unsigned char*)buff.contents(), remaining);
// handle the packet
HandlePacket(buff);
remaining = 0;
opcode = 0;
}
}
void LogonCommServerSocket::OnRecvData()
{
while(true)
{
if(!remaining)
{
if(GetReadBuffer()->GetSize() < 6)
return; // no header
// read header
Read((uint8*)&opcode, 2);
Read((uint8*)&remaining, 4);
if(use_crypto)
{
// decrypt the packet
recvCrypto.Process((unsigned char*)&opcode, (unsigned char*)&opcode, 2);
recvCrypto.Process((unsigned char*)&remaining, (unsigned char*)&remaining, 4);
}
EndianConvert(opcode);
/* reverse byte order */
EndianConvertReverse(remaining);
}
// do we have a full packet?
if(GetReadBuffer()->GetSize() < remaining)
return;
// create the buffer
WorldPacket buff(opcode, remaining);
if(remaining)
{
buff.resize(remaining);
Read((uint8*)buff.contents(), remaining);
}
if(use_crypto && remaining)
recvCrypto.Process((unsigned char*)buff.contents(), (unsigned char*)buff.contents(), remaining);
// handle the packet
HandlePacket(buff);
remaining = 0;
opcode = 0;
}
}
void C4Network2IO::CallHandlers(int iHandlerID, const C4IDPacket *pPkt, C4Network2IOConnection *pConn, bool fThread)
{
// emulate old callbacks
char cStatus = pPkt->getPktType();
const C4PacketBase *pPacket = pPkt->getPkt();
// this class (network thread)
if (iHandlerID & PH_C4Network2IO)
{
assert(fThread);
HandlePacket(cStatus, pPacket, pConn);
}
// main network class (main thread)
if (iHandlerID & PH_C4Network2)
{
assert(!fThread);
::Network.HandlePacket(cStatus, pPacket, pConn);
}
// fullscreen lobby
if (iHandlerID & PH_C4GUIMainDlg)
{
assert(!fThread);
::Network.HandleLobbyPacket(cStatus, pPacket, pConn);
}
// client list class (main thread)
if (iHandlerID & PH_C4Network2ClientList)
{
assert(!fThread);
::Network.Clients.HandlePacket(cStatus, pPacket, pConn);
}
// player list class (main thread)
if (iHandlerID & PH_C4Network2Players)
{
assert(!fThread);
::Network.Players.HandlePacket(cStatus, pPacket, pConn);
}
// resource list class (network thread)
if (iHandlerID & PH_C4Network2ResList)
{
assert(fThread);
::Network.ResList.HandlePacket(cStatus, pPacket, pConn);
}
// network control (mixed)
if (iHandlerID & PH_C4GameControlNetwork)
{
::Control.Network.HandlePacket(cStatus, pPacket, pConn);
}
}
void IpqLoop()
{
int status;
struct pcap_pkthdr PHdr;
unsigned char buf[PKT_BUFSIZE];
static ipq_packet_msg_t *m;
#ifdef DEBUG_GIDS
printf("Reading Packets from ipq handle \n");
#endif
while(1)
{
ResetIV();
status = ipq_read(ipqh, buf, PKT_BUFSIZE, 0);
if (status < 0)
{
ipq_perror("IpqLoop: ");
}
else
{
switch(ipq_message_type(buf))
{
case NLMSG_ERROR:
fprintf(stderr, "Received error message %d\n",
ipq_get_msgerr(buf));
break;
case IPQM_PACKET:
m = ipq_get_packet(buf);
g_m = m;
#ifdef DEBUG_INLINE
printf("%02X:%02X:%02X:%02X:%02X:%02X\n", m->hw_addr[0], m->hw_addr[1],
m->hw_addr[2], m->hw_addr[3], m->hw_addr[4], m->hw_addr[5]);
#endif
TranslateToPcap(m, &PHdr);
PcapProcessPacket(NULL, &PHdr, (u_char *)m->payload);
HandlePacket(m);
break;
} /* switch */
} /* if - else */
} /* while() */
}
void FJavascriptWebSocket::Flush()
{
auto PendingMesssages = OutgoingBuffer.Num();
while (OutgoingBuffer.Num() > 0 && !IsServerSide)
{
#if !PLATFORM_HTML5
if (Protocols)
libwebsocket_callback_on_writable_all_protocol(&Protocols[0]);
else
libwebsocket_callback_on_writable(Context, Wsi);
#endif
HandlePacket();
if (PendingMesssages >= OutgoingBuffer.Num())
{
UE_LOG(LogWebsocket, Warning, TEXT("Unable to flush all of OutgoingBuffer in FJavascriptWebSocket."));
break;
}
};
}
void MeshBase::Update()
{
// Periodic sends
if (millis() - last_broadcast_time > PEER_DISCOVERY_TIME)
{
if (!IsReady())
ChooseAddress();
SendPeerDiscovery();
}
// Recieve
uint8_t pipe_num;
if (radio.available(&pipe_num))
{
bool done = false;
do {
uint8_t len = radio.getDynamicPayloadSize();
byte buff[MAX_PAYLOAD_SIZE];
done = radio.read(buff, len);
HandlePacket(buff, len);
} while (!done);
}
// Update peers
if (millis() - last_peer_check_time > PEER_CHECK_TIME)
{
LinkedList<Peer>::Node* current = peers.first;
while(current != NULL)
{
current->item->time += 1;
if (current->item->time >= PEER_TIMEOUT)
{
Serial.print("Lost Peer: ");
Serial.println(current->item->address, DEC);
current = peers.Remove(current);
} else {
current = current->next;
}
}
last_peer_check_time = millis();
}
}
void C4Network2IO::OnThreadEvent(C4InteractiveEventType eEvent, void *pEventData) // by main thread
{
switch (eEvent)
{
case Ev_Net_Conn: // got a connection
{
C4Network2IOConnection *pConn = reinterpret_cast<C4Network2IOConnection *>(pEventData);
// do callback
::Network.OnConn(pConn);
// remove reference
pConn->DelRef();
}
break;
case Ev_Net_Disconn: // connection closed
{
C4Network2IOConnection *pConn = reinterpret_cast<C4Network2IOConnection *>(pEventData);
assert(pConn->isClosed());
// do callback
::Network.OnDisconn(pConn);
// remove reference
pConn->DelRef();
}
break;
case Ev_Net_Packet: // got packet
{
NetEvPacketData *pData = reinterpret_cast<NetEvPacketData *>(pEventData);
// handle
HandlePacket(pData->Packet, pData->Conn, false);
// clear up
pData->Conn->DelRef();
delete pData;
}
break;
default:
// TODO
break;
}
}
void ClientSession::Refresh ()
{
while (!networkHandler_.IsEmpty ())
{
yap::PacketPtrType packet (networkHandler_.GetPacket ());
yap::DebugLogger::Instance ().LogLine (
"Packet: " + yap::StringHelper::ToString (
static_cast<int> (packet->GetType ())));
try
{
if (!HandlePacket (*packet))
YAPOG_THROW("Wrong packet received.");
}
catch (const yap::Exception& ex)
{
ex.GetMessage (std::cout) << std::endl;
}
}
}
int main(void) {
unsigned char pkt[256];
// init the VARS
if (!InitVARS()) {
puts("InitVARS failure");
_terminate(-1);
}
// packet handler loop
while (1) {
if (ReceivePacket(pkt) == 0) {
break;
}
HandlePacket(pkt);
}
// destroy the VARS
DestroyVARS();
return(0);
}
void FWebSocket::Flush()
{
auto PendingMesssages = OutgoingBuffer.Num();
while (OutgoingBuffer.Num() > 0 && !IsServerSide)
{
#if !PLATFORM_HTML5
if (Protocols)
{
lws_callback_on_writable_all_protocol(Context, &Protocols[0]);
}
else
{
lws_callback_on_writable(Wsi);
}
#endif
HandlePacket();
if (PendingMesssages <= OutgoingBuffer.Num()) // FIXME!
{
UE_LOG(LogHTML5Networking, Warning, TEXT("Unable to flush all of OutgoingBuffer in FWebSocket."));
break;
}
};
}
/*
====================
TryReceive
====================
*/
static void TryReceive( const int timeout ) {
SOCKET sockets[MAX_SOCKETS] = { ZERO_SOCKET };
SOCKET reads[MAX_SOCKETS] = { ZERO_SOCKET };
t_int i;
// Set up IPv4 and IPv6 sockets.
sockets[0] = server;
sockets[1] = server6;
for ( i = 2; i < MAX_SOCKETS; ++i ) {
sockets[i] = connections[i - 2];
}
// Synchronous event demultiplexer.
// It's ok that we are using select as its portable.
// It may not be the fastest, but it's definitely quick enough for what we are trying to accomplish.
if ( T_Select( sockets, MAX_SOCKETS, timeout, reads ) == SOCKET_ERROR ) {
T_Error( "TryReceive: Select error.\n" );
}
for( i = 0; i < MAX_SOCKETS; ++i ) {
if ( reads[i] == ZERO_SOCKET )
continue;
// Accept connections on IPv4 and IPv6.
if ( reads[i] == server ) {
AcceptConnection( server );
} else if ( reads[i] == server6 ) {
AcceptConnection( server6 );
} else {
static t_byte buffer[MAX_PACKET_SIZE];
// Handle packets from the accepted connections.
t_int bytes = recv( reads[i], ( char * )buffer, MAX_PACKET_SIZE, 0 );
HandlePacket( i - 2, buffer, bytes );
}
}
}
void Client::ReceivePackets()
{
recvuse.Synchronize();
int n;
do
{
//MessagePacket rmsg;
//n = recv( sock, ( char * )&rmsg, sizeof rmsg, 0 );
//Check(n);
//if ( n > 0 )
// HandleMessage( rmsg );
UDPHeader head;
char rstr[MaxPacketSize] = {0};
n = recv( sock, rstr, MaxPacketSize, 0 );
if ( Check(n) > 0 )
{
memcpy( &head, rstr, sizeof head );
if ( serid == 0 )
{
serid = head.UniqueID;
lastseqnum = head.SequenceNumber - 1;
}
if ( HandlePacket( head ) )
{
int psize = head.DataSize / sizeof( MessagePacket );
for ( int i = 0; i < psize; ++i )
{
MessagePacket rmsg;
memcpy( &rmsg, rstr + sizeof head + i * sizeof rmsg, sizeof rmsg );
handlemsgs.push_back( rmsg );
}
}
}
} while ( n > 0 );
recvuse.Release();
}
// Update
void _Bot::Update(double FrameTime) {
// Update network
Network->Update(FrameTime);
// Get events
_NetworkEvent NetworkEvent;
while(Network->GetNetworkEvent(NetworkEvent)) {
switch(NetworkEvent.Type) {
case _NetworkEvent::CONNECT: {
std::cout << Username << " connected" << std::endl;
_Buffer Packet;
Packet.Write<PacketType>(PacketType::ACCOUNT_LOGININFO);
Packet.WriteBit(0);
Packet.WriteString(Username.c_str());
Packet.WriteString(Password.c_str());
Packet.Write<uint64_t>(0);
Network->SendPacket(Packet);
} break;
case _NetworkEvent::DISCONNECT:
std::cout << Username << " disconnected" << std::endl;
ObjectManager->Clear();
AssignPlayer(nullptr);
delete Battle;
delete Map;
Battle = nullptr;
Map = nullptr;
break;
case _NetworkEvent::PACKET:
HandlePacket(*NetworkEvent.Data);
delete NetworkEvent.Data;
break;
}
}
if(!Player || !Map)
return;
// Update goals
EvaluateGoal();
// Set input
if(Player->AcceptingMoveInput()) {
int InputState = GetNextInputState();
Player->InputStates.clear();
if(InputState)
Player->InputStates.push_back(InputState);
}
// Update objects
ObjectManager->Update(FrameTime);
// Update map
Map->Update(FrameTime);
// Send input to server
if(Player->Moved) {
if(Path.size())
Path.erase(Path.begin());
_Buffer Packet;
Packet.Write<PacketType>(PacketType::WORLD_MOVECOMMAND);
Packet.Write<char>((char)Player->Moved);
Network->SendPacket(Packet);
}
// Update battle system
if(Battle) {
if(!Player->PotentialAction.IsSet()) {
Battle->ClientHandleInput(_Actions::SKILL1);
Battle->ClientHandleInput(_Actions::SKILL1);
}
if(!Player->Battle) {
delete Battle;
Battle = nullptr;
} else
Battle->Update(FrameTime);
}
}
void FWebSocket::Tick()
{
HandlePacket();
}
