410 lines
12 KiB
C++
410 lines
12 KiB
C++
#include "Network.h"
|
|
#include "Timer.h"
|
|
#include <cstring>
|
|
#include <cstdlib>
|
|
#include <iostream>
|
|
|
|
|
|
sf::Uint16 Network::numclients;
|
|
sf::UdpSocket Network::net_socket;
|
|
char Network::rxbuff[RECEIVE_BUFFER_SIZE];
|
|
std::map<sf::Uint32, Transmit_Message_t*> Network::transmit_queue;
|
|
Client_t Network::clients[MAX_NUM_CLIENTS];
|
|
sf::Clock Network::message_timer;
|
|
|
|
sf::Uint32 Network::getUniqueMessageId( void )
|
|
{
|
|
sf::Uint32 next_msg_uid = 0;
|
|
while(transmit_queue.find(next_msg_uid) != transmit_queue.end())
|
|
{
|
|
next_msg_uid++;
|
|
}
|
|
return next_msg_uid;
|
|
}
|
|
|
|
void Network::Create(sf::Uint16 port, sf::IpAddress address )
|
|
{
|
|
sf::Uint16 current_client = 0;
|
|
Client_t tmpclient;
|
|
|
|
Reset();
|
|
|
|
if(sf::IpAddress::None != address)
|
|
{
|
|
tmpclient.addr = address;
|
|
tmpclient.port = port;
|
|
numclients = addClients(&tmpclient, ¤t_client);
|
|
|
|
net_socket.bind( sf::Socket::AnyPort );
|
|
net_socket.setBlocking(false);
|
|
}
|
|
else
|
|
{
|
|
net_socket.bind( port );
|
|
net_socket.setBlocking(false);
|
|
}
|
|
}
|
|
|
|
void Network::Destroy( void )
|
|
{
|
|
/* Clean and exit */
|
|
net_socket.unbind();
|
|
}
|
|
|
|
bool Network::getData(sf::Packet& p)
|
|
{
|
|
bool rtn = false;
|
|
sf::Uint16 curcl;
|
|
|
|
// Recurse through the client array and return if there is any
|
|
// received data for a given client
|
|
for(curcl = 0; curcl < numclients; (curcl)++)
|
|
{
|
|
if(!clients[curcl].receive.empty())
|
|
{
|
|
p = clients[curcl].receive.front();
|
|
clients[curcl].receive.pop();
|
|
rtn = true;
|
|
break;
|
|
}
|
|
}
|
|
|
|
|
|
return rtn;
|
|
}
|
|
|
|
bool Network::queueTransmitMessage(Network_Messages_T msg_type , sf::Packet p, Client_t * dest)
|
|
{
|
|
sf::Packet packet;
|
|
sf::Uint8 type = (sf::Uint8)msg_type;
|
|
sf::Uint32 uid = UNIQUE_ID;
|
|
sf::Uint32 msg_id = getUniqueMessageId();
|
|
Transmit_Message_t* message = new Transmit_Message_t();
|
|
|
|
// Add this to the list of packets expecting a response
|
|
packet << uid;
|
|
packet << type;
|
|
packet << msg_id;
|
|
packet.append(p.getData(), p.getDataSize());
|
|
|
|
message->msg_type = msg_type;
|
|
message->Data = packet;
|
|
message->TimeStarted = 0.0;
|
|
message->dest = dest;
|
|
|
|
transmit_queue[msg_id] = message;
|
|
|
|
return true;
|
|
}
|
|
|
|
bool Network::sendData(sf::Packet& p, bool guaranteed)
|
|
{
|
|
Network_Messages_T message_type = NETWORK_NORMAL;
|
|
if(guaranteed)
|
|
{
|
|
message_type = NETWORK_GUARANTEED;
|
|
}
|
|
|
|
queueTransmitMessage(message_type, p);
|
|
|
|
return true;
|
|
}
|
|
|
|
int Network::addClients(Client_t *client, sf::Uint16 *curcl)
|
|
{
|
|
int i;
|
|
int nc = -1;
|
|
for(i=0;i<MAX_NUM_CLIENTS;i++)
|
|
{
|
|
if((clients[i].addr == client->addr) && (clients[i].port == client->port))
|
|
{
|
|
nc = i;
|
|
}
|
|
else if((clients[i].addr == sf::IpAddress::None) && (clients[i].port == 0))
|
|
{
|
|
break;
|
|
}
|
|
}
|
|
// Make sure to set the current client location, otherwise
|
|
// bad stuffs can happen.
|
|
if(nc == -1)
|
|
{
|
|
clients[i].addr = client->addr;
|
|
clients[i].port = client->port;
|
|
*curcl = i;
|
|
i++;
|
|
}
|
|
else
|
|
{
|
|
*curcl = nc;
|
|
}
|
|
return i;
|
|
}
|
|
|
|
int Network::findClient(Client_t *client)
|
|
{
|
|
int client_ndx;
|
|
for(client_ndx = 0; client_ndx < MAX_NUM_CLIENTS; client_ndx++)
|
|
{
|
|
if((clients[client_ndx].addr == client->addr) && (clients[client_ndx].port == client->port))
|
|
{
|
|
break;
|
|
}
|
|
}
|
|
return client_ndx;
|
|
}
|
|
|
|
|
|
void Network::Receive()
|
|
{
|
|
// Get any received packets
|
|
sf::IpAddress sender;
|
|
Client_t tmpclient;
|
|
sf::Uint16 curcl;
|
|
sf::Packet receive_packet;
|
|
receive_packet.clear();
|
|
|
|
// Receive any packets from the server
|
|
while(net_socket.receive(receive_packet, tmpclient.addr, tmpclient.port) == sf::Socket::Done)
|
|
{
|
|
sf::Uint32 uid;
|
|
receive_packet >> uid;
|
|
if(uid == UNIQUE_ID)
|
|
{
|
|
sf::Uint8 message_type;
|
|
sf::Uint32 msg_id;
|
|
receive_packet >> message_type;
|
|
receive_packet >> msg_id;
|
|
|
|
numclients = addClients(&tmpclient, &curcl);
|
|
|
|
switch((Network_Messages_T)message_type)
|
|
{
|
|
case NETWORK_CONNECT:
|
|
{
|
|
break;
|
|
}
|
|
case NETWORK_DISCONNECT:
|
|
{
|
|
break;
|
|
}
|
|
case NETWORK_ACK:
|
|
{
|
|
sf::Uint32 client_id = findClient(&tmpclient);
|
|
receive_packet >> message_type;
|
|
receive_packet >> msg_id;
|
|
|
|
switch(message_type)
|
|
{
|
|
// Handle an acknowledged ping message
|
|
case NETWORK_PING:
|
|
{
|
|
if(MAX_NUM_CLIENTS > client_id)
|
|
{
|
|
clients[client_id].ping = Timer::GetTimeDouble() - transmit_queue[msg_id]->TimeStarted;
|
|
}
|
|
break;
|
|
}
|
|
// Handle an acknowledged guaranteed message
|
|
case NETWORK_GUARANTEED:
|
|
{
|
|
// Set that the message was acknowledged by the client
|
|
if(MAX_NUM_CLIENTS > client_id)
|
|
{
|
|
transmit_queue[msg_id]->Responses[&clients[client_id]] = Timer::GetTimeDouble();
|
|
}
|
|
break;
|
|
}
|
|
|
|
default:
|
|
break; // What the heck happened?
|
|
}
|
|
break;
|
|
}
|
|
case NETWORK_PING:
|
|
{
|
|
// Send a response indicating that ping was received
|
|
sf::Packet response;
|
|
response.clear();
|
|
response << message_type << msg_id;
|
|
queueTransmitMessage(NETWORK_ACK, response, &(clients[curcl]));
|
|
break;
|
|
}
|
|
|
|
case NETWORK_NORMAL:
|
|
{
|
|
// Handle any remaining data in the packet
|
|
clients[curcl].receive.push(receive_packet);
|
|
break;
|
|
}
|
|
|
|
case NETWORK_GUARANTEED:
|
|
{
|
|
// Send a response indicating that the message was received
|
|
sf::Packet response;
|
|
clients[curcl].receive.push(receive_packet);
|
|
response.clear();
|
|
response << message_type << msg_id;
|
|
queueTransmitMessage(NETWORK_ACK, response, &(clients[curcl]));
|
|
break;
|
|
}
|
|
|
|
// Nothing to do
|
|
default:
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
void Network::Transmit()
|
|
{
|
|
// Broadcast the mesages to all clients
|
|
sf::Uint32 msg_id = 0;
|
|
static double ping_timer = Timer::GetTimeDouble();
|
|
|
|
// Once per second, send ping messages ( just for fun )
|
|
if((Timer::GetTimeDouble() - ping_timer) > 1000.0)
|
|
{
|
|
ping_timer = Timer::GetTimeDouble();
|
|
sf::Packet response;
|
|
response.clear();
|
|
queueTransmitMessage(NETWORK_PING, response);
|
|
}
|
|
|
|
// Send any pending messages
|
|
while(transmit_queue.find(msg_id) != transmit_queue.end())
|
|
{
|
|
double curTime = Timer::GetTimeDouble();
|
|
Transmit_Message_t * message = transmit_queue[msg_id];
|
|
switch(message->msg_type)
|
|
{
|
|
case NETWORK_PING:
|
|
case NETWORK_GUARANTEED:
|
|
{
|
|
// If the message has not yet been sent
|
|
// send the message and update the sent times.
|
|
if(0.0 == message->TimeStarted)
|
|
{
|
|
message->TimeStarted = Timer::GetTimeDouble();
|
|
for(int i = 0; i < MAX_NUM_CLIENTS; i++)
|
|
{
|
|
if((clients[i].addr != sf::IpAddress::None) && (clients[i].port != 0))
|
|
{
|
|
message->ClientTimeSent[&clients[i]] = message->TimeStarted;
|
|
net_socket.send(message->Data, clients[i].addr, clients[i].port);
|
|
}
|
|
}
|
|
}
|
|
else
|
|
{
|
|
// Message has already been sent, check to see if a response has been received
|
|
// if not, send another request after retry timer expired.
|
|
if(message->ClientTimeSent.size() > message->Responses.size())
|
|
{
|
|
// Look for any clients that haven't responded
|
|
for ( std::map<Client_t*, double>::iterator iter = message->ClientTimeSent.begin(); iter != message->ClientTimeSent.end(); ++iter )
|
|
{
|
|
// Determine if enough time has elapsed to try and re-send
|
|
if((curTime - iter->second) >= 0.5)
|
|
{
|
|
// Determine if a response was already received from this client
|
|
if(message->Responses.find(iter->first) == message->Responses.end())
|
|
{
|
|
// Resend the message to the client
|
|
net_socket.send(message->Data, iter->first->addr, iter->first->port);
|
|
message->ClientTimeSent[iter->first] = curTime;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
else
|
|
{
|
|
// All clients have received the message, so remove it from the list
|
|
delete message;
|
|
transmit_queue.erase(transmit_queue.find(msg_id));
|
|
}
|
|
}
|
|
break;
|
|
}
|
|
|
|
// When sending an ACK, we only need to send the ACK to the sender.
|
|
case NETWORK_ACK:
|
|
{
|
|
if(NULL != message->dest)
|
|
{
|
|
net_socket.send(message->Data, message->dest->addr, message->dest->port);
|
|
}
|
|
// Transmitted the message, so remove it from the list
|
|
delete message;
|
|
transmit_queue.erase(transmit_queue.find(msg_id));
|
|
break;
|
|
}
|
|
|
|
default:
|
|
{
|
|
// A normal message, no response needed
|
|
// just send to all clients, then delete the message
|
|
for(int i=0;i<numclients;i++)
|
|
{
|
|
net_socket.send(message->Data, clients[i].addr, clients[i].port);
|
|
}
|
|
delete message;
|
|
transmit_queue.erase(transmit_queue.find(msg_id));
|
|
break;
|
|
}
|
|
}
|
|
msg_id++;
|
|
}
|
|
}
|
|
|
|
int Network::getNumConnected( void )
|
|
{
|
|
return numclients;
|
|
}
|
|
|
|
void Network::Reset()
|
|
{
|
|
numclients = 0;
|
|
for(int i = 0; i < MAX_NUM_CLIENTS; i++)
|
|
{
|
|
clients[i].addr = sf::IpAddress();
|
|
clients[i].port = 0;
|
|
while(!clients[i].receive.empty())
|
|
{
|
|
clients[i].receive.pop();
|
|
}
|
|
}
|
|
|
|
sf::Uint32 next_msg_uid = 0;
|
|
while(transmit_queue.find(next_msg_uid) != transmit_queue.end())
|
|
{
|
|
delete transmit_queue[next_msg_uid];
|
|
next_msg_uid++;
|
|
}
|
|
|
|
transmit_queue.clear();
|
|
|
|
message_timer.restart();
|
|
}
|
|
|
|
bool Network::pendingMessages()
|
|
{
|
|
return (transmit_queue.size() > 0);
|
|
}
|
|
|
|
sf::Packet& operator <<(sf::Packet& Packet, const Network_Messages_T& NMT)
|
|
{
|
|
sf::Uint8 net_msg_t = (sf::Uint8)NMT;
|
|
return Packet << net_msg_t;
|
|
}
|
|
|
|
sf::Packet& operator >>(sf::Packet& Packet, Network_Messages_T& NMT)
|
|
{
|
|
sf::Uint8 net_msg_t;
|
|
Packet >> net_msg_t;
|
|
NMT = (Network_Messages_T)net_msg_t;
|
|
return Packet;
|
|
}
|
|
|