[ENet-discuss] ENet package broadcasting

[Boris]

I must say, that ENet is a great network library.

We are working on a multiplayer based game, so we decided to use ENet 
library.

To make our lives easier, we decided to use fixed time step as in Halo 
games, so that we can send players inputs over network. What this means 
is, that if we send same inputs over and over, we get the same results. 
This is also great for replaying and debugging.

To understand what I am talking about here is a link: 
http://www.flipcode.com/archives/Main_Loop_with_Fixed_Time_Steps.shtml

By using ENet, we are making peer-to-peer based network, so that every 
client sends its input to others.
We do this by creating a client host with enet_host_create() function. 
Ofcoarse we flag one of the clients as server, so that it manages some 
of the server methods.

The following code creates client host:

void CreateClient(ENetAddress address, int server)
{
    ENetHost *client = enet_host_create (& address , MAX_CONNECTIONS, 0, 
0);  
}

When a new client connects to our server flagged client, a respond 
message is send back to that client. A message contains a list of all 
clients connected to server. We tell our new client to connect to every 
client from this list by using the following code:

void ClientConnect()
{
    for(int a=0;a<aClientList;a++)
    {
       ENetAddress address = aClientList[a]->GetAddress();
       ENetPeer *clientpeer = enet_host_connect( this_client , address , 
1 );
    }
}

So this is how we get our peer-to-peer based network.

Because of our fixed time step, we wait every client to send its input 
to every one. When data arrives, we update next frame.

But the problem is that it takes way to long for data to arrive from 
client to server or vice versa.
//
To send a message we use the following code:
void SendMessage(ENetHost *client, Data data)
{
    ENetPacket *pPacket = enet_packet_create( data->GetBuffer() , 
data->GetSize() ,   ENET_PACKET_FLAG_RELIABLE );

      enet_host_broadcast( client , 0 , pPacket );
      enet_host_flush( client ); 
}


The NetworkManager does something like in the following code:

while(!isInputBuffer())
{ 
    numloop++;
    //
    if(updateinput > input_lag-1)
    {               
        // send only once
        UpdateNetworkPlayerInput(dt);
     }
     //
     if(isServer())
         pNetPeer->UpdateServer(numloop>1 ? deltadt : 
dt,network_pinging->GetInt());

     if(isClient())
         pNetPeer->UpdateClient(numloop>1 ? deltadt : 
dt,network_pinging->GetInt());
     //
     updateinput--;
} 
// read from input buffers for dummy players                   
UpdateNetworkDummyInput(dt);
      
The isInputBuffer() function checks if there is still any input in 
buffer to read from. If the input buffers are empty go to while loop and 
stay in this loop until data arrived from all connected clients.
//
UpdateNetworkPlayerInput() function creates a message containing players 
input. This functions calls our SendMessage() function, so that inputs 
are sent to other connected clients.

UpdateClient() and UpdateServer(), these two functions call 
enet_host_service() where events are processed.
while( enet_host_service( pHost , &Event , 0 ) > 0)
   {
      switch( Event.type ) {
         case ENET_EVENT_TYPE_CONNECT:
          {
             //handle connected events
             break;
          }
         case ENET_EVENT_TYPE_RECEIVE:
        {
             //handle receive events
             OnReceive();
             break;
        }
             .
             .
             .
like in tutorial.

So my question is, what could cause such big lag? The data can take even 
half a second to arrive. When sending text messages, or ping messages it 
appears to work properly. The data arrives with minimal delay.
The size of input data that we are sending is about 120 bytes depends on 
amount of inputs pressed.

We are using latest ENet 1.22

Thank you in advance, for any further clarifications please reply.