Hi

I have read the Enet tutorial http://enet.bespin.org/Tutorial.html and I can't it figure out.

In the section Creating an ENet server the server is created without specifying an IP adress, instead ENET_HOST_ANY is used. I assume this is because the server does not need to know its own address, only the port it needs to recieve from.

But, in the Creating an ENet client section, a NULL is passed instead of an address... I thought the client needed to know where to send its packets?

Another concept I don't get is the client->server pair, is this bi-directional or not? Do I need a server and a client on both ends of the connection?

My understanding of an network API is that a player connects to a host, so that the client application will need to create a client object only and then plug in an IP and Port and start sending and recieving packets with the server.

I would like to learn how to use Enet becuase I think using UDP packets in Quake3 style is a way to go for RPG and FPS games.

Does anyone here have full examples of client code and server code (C++) I can use to understand Enet?

Cheers

So?

1. So one enet_host_create() for the server, and one enet_host_create() for the client. This will setup the endpoints.

2. Then the client will enet_host_connect() to the server

3. The server will recieve ENET_EVENT_TYPE_CONNECT event and act accordingly.

4. Now the connection is established and work in both directions?

I have a few more questions I hope you don't mind answering.

The function

enet_packet_create (const void *data, size_t dataLength, enet_uint32 flags)

Creates a packet that may be sent to a peer. The tutorial states "Optionally, initial data may be specified to copy into the packet." Does that mean that this function copy the data pointed to by void *data to its own allocated space, such that I can deallocate void *data after this function call?

Do these functions

enet_host_check_events (ENetHost *host, ENetEvent *event)
enet_host_service (ENetHost *host, ENetEvent *event, enet_uint32 timeout)

perform the same thing, only the latter blocks until timeout. Meaning it will act exactly the same if timeout = 0 is passed? So I should use the first if I don't want to block? Is it more optimized?

In this code

ENetEvent event;
    while (enet_host_service (client, & event, 1000) > 0)
    {
        switch (event.type)
        {
        case ENET_EVENT_TYPE_RECEIVE:
            printf ("A packet of length %u containing %s was received from %s on channel %u.\n",
                    event.packet -> dataLength,
                    event.packet -> data,
                    event.peer -> data,
                    event.channelID); 

The packet source is known from the .peer member, does the library retain the data internally?

When connecting to a host

/* Initiate the connection, allocating the two channels 0 and 1. */
ENetPeer *peer;
peer = enet_host_connect (client, & address, 2, 0); 
if (peer == NULL)
    {
       fprintf (stderr, 
                "No available peers for initiating an ENet connection.\n");
       exit (EXIT_FAILURE);
    }

If anyone can please reply I would appreciate it.

Some additional questions :)

I am testing some code from this site http://neppramod.wordpress.com/2012/08/12/enet-tutorial

I got it working but something seems wrong. When the client executes "enet_host_connect(client, &address, 2, 0);" in the begining, nothing happens server side. Only after a data packet is sent will the server trigger the event.type == ENET_EVENT_TYPE_CONNECT... And since I am sending unreliable packets only the second data packet will reach the server.

Why won't the connection complete before the first packet is sent? Am I doing anything wrong?

Client:

#include <enet/enet.h>
#include <stdio.h>
#include <iostream>
#include <string.h>

#pragma comment(lib, "winmm.lib")
#pragma comment(lib, "Ws2_32.lib")
#pragma comment(lib,"enet.lib")


int main(int argc, char **argv)
{
    ENetAddress address;
    ENetHost *client;
    ENetPeer *peer;
    char message[1024];
    ENetEvent netevent;
    int eventStatus;

    // a. Initialize enet
    if (enet_initialize() != 0) {
        fprintf(stderr, "An error occured while initializing ENet.\n");
        return EXIT_FAILURE;
    }

    atexit(enet_deinitialize);

    // b. Create a host using enet_host_create
    client = enet_host_create(NULL, 1, 2, 57600/8, 14400/8);

    if (client == NULL) {
        fprintf(stderr, "An error occured while trying to create an ENet server host\n");
        exit(EXIT_FAILURE);
    }

    enet_address_set_host(&address, "localhost");
    address.port = 1234;

    // c. Connect and user service
    peer = enet_host_connect(client, &address, 2, 0);

    if (peer == NULL) {
        fprintf(stderr, "No available peers for initializing an ENet connection");
        exit(EXIT_FAILURE);
    }

    eventStatus = 1;

    while (1) {
		message[0] = '\0';

		printf("Say > ");
        gets(message);

		
        if (strlen(message) > 0) {
            ENetPacket *packet = enet_packet_create(message, strlen(message) + 1, ENET_PACKET_FLAG_RELIABLE);
            enet_peer_send(peer, 0, packet);
        }

        while(enet_host_service(client, &netevent, 0)>0)
		{
        // If we had some event that interested us
            switch(netevent.type) {
                case ENET_EVENT_TYPE_CONNECT:
                    printf("(Client) We got a new connection from %x\n",
                            netevent.peer->address.host);
                    break;

                case ENET_EVENT_TYPE_RECEIVE:
                    printf("(Client) Message from server : %s\n", netevent.packet->data);

                    enet_packet_destroy(netevent.packet);
                    break;

                case ENET_EVENT_TYPE_DISCONNECT:
                    printf("(Client) %s disconnected.\n", netevent.peer->data);

                    // Reset client's information
                    netevent.peer->data = NULL;
                    break;
		}

       

    }
	}
}

Server:

#include <enet\enet.h>
#include <stdio.h>

#pragma comment(lib, "winmm.lib")
#pragma comment(lib, "Ws2_32.lib")
#pragma comment(lib,"enet.lib")

int main(int argc, char **argv)
{
	ENetAddress address;
	ENetHost *server;
	ENetEvent netevent;
	int eventStatus;

	// a. Initialize enet
	if (enet_initialize() != 0) {
		fprintf(stderr, "An error occured while initializing ENet.\n");
		return EXIT_FAILURE;
	}

	atexit(enet_deinitialize);

	// b. Create a host using enet_host_create
	address.host = ENET_HOST_ANY;
	address.port = 1234;

	server = enet_host_create(&address, 32, 2, 0, 0);

	if (server == NULL) {
		fprintf(stderr, "An error occured while trying to create an ENet server host\n");
		exit(EXIT_FAILURE);
	}

	// c. Connect and user service
	eventStatus = 1;
	while(true){
		while (enet_host_service (server, & netevent, 1000) > 0)
		{
			switch (netevent.type)
			{
			case ENET_EVENT_TYPE_CONNECT:
				printf ("A new client connected from %x:%u.\n", 
					netevent.peer -> address.host,
					netevent.peer -> address.port);

				/* Store any relevant client information here. */
				netevent.peer -> data = "Client 1";

				break;

			case ENET_EVENT_TYPE_RECEIVE:
				printf ("%s > %s\n",
					netevent.peer -> data,
					netevent.packet -> data);

				enet_host_broadcast(server, 0, netevent.packet);
				/* Clean up the packet now that we're done using it. */
				//enet_packet_destroy (netevent.packet);

				break;

			case ENET_EVENT_TYPE_DISCONNECT:
				printf ("%s disconected.\n", netevent.peer -> data);

				/* Reset the peer's client information. */

				netevent.peer -> data = NULL;
			}
		}
	}

}

Also: enet_packet_destroy() server side crash the application on a second packet so I commented it out....

ENET_HOST_ANY means that the server will accept incoming connections from any address. The other way would be to specify a specific IP, but then you'd only be able to receive traffic from that specific IP. So this address parameter is only used for specifying the address of allowed incoming connections.

A client won't be listening for new connections so it uses NULL in that case (it will only connect to other servers, it won't receive connections).

What's interesting is that ENET_HOST_ANY has the same value as NULL - 0, so it actually doesn't matter I guess :P.

The function

enet_packet_create (const void *data, size_t dataLength, enet_uint32 flags)

Creates a packet that may be sent to a peer. The tutorial states "Optionally, initial data may be specified to copy into the packet." Does that mean that this function copy the data pointed to by void *data to its own allocated space, such that I can deallocate void *data after this function call?

I haven't used ENet in UDP way becouse I have been creating lobby but I guess that creating packets works similarily. So far packets that I sent in reliable mode were deleted on client side after I got acknowledgement from server. It's all made internally I guess and in UDP there's probably some kind of timeout and if you won't get acknowledgement in the specified time the packet is deleted.

When connecting to a host

/* Initiate the connection, allocating the two channels 0 and 1. */
ENetPeer *peer;
peer = enet_host_connect (client, & address, 2, 0); 
if (peer == NULL)
    {
       fprintf (stderr, 
                "No available peers for initiating an ENet connection.\n");
       exit (EXIT_FAILURE);
    }

The "peer" object/pointer, cannot possibly know if a connection has been established that fast? What happens here? Does this function block until it get a response? Is it necessary to keep this return value when I can always get it back when "event.type == ENET_EVENT_TYPE_CONNECT" ? Heck, why even get the return value when I get the peer anyway from "ENET_EVENT_TYPE_RECEIVE"?

Regarding the enet_host_connect:

The peer returned will have not completed the connection until enet_host_service() notifies of an ENET_EVENT_TYPE_CONNECT event for the peer.

I guess it only fills up ENetPeer struct with necessary data and in order to actually connect, you should use following code:

peer = enet_host_connect (client, & address, 2, 0); 
    if (peer == NULL)
    {
       fprintf (stderr, 
                "No available peers for initiating an ENet connection.\n");
       exit (EXIT_FAILURE);
    }
    if (peer == NULL)
    {
        //CreateMessageBox("Couldn't connect to server. Peer = NULL.");
        exit (EXIT_FAILURE);
    }
    if(enet_host_service (client, & netevent, 5000) > 0 && netevent.type == ENET_EVENT_TYPE_CONNECT)
    {
        //since now the connection is established on both ends of cnnection
        return true;
    }
    else
    {
        /* Either the 5 seconds are up or a disconnect event was */
        /* received. Reset the peer in the event the 5 seconds */
        /* had run out without any significant event. */
        enet_peer_reset (peer);
        peer = 0;
        //CreateMessageBox("Couldn't connect to server. Timeout.");
        return false;
    }

Also: enet_packet_destroy() server side crash the application on a second packet so I commented it out....

I had the same problem. You should check if your Packet pointer != NULL and only then use this function.

Hope this helps a bit!

Some non-100%-sure answers:
Afaik Enet is a very thin layer on top of UDP, which means that youll have to do a lotofstuff yourself, such as calculating the data rate, ping, etc.

data rate & ping are already in, check ENetPeer.incomingBandwidth/outgoingBandwidth and ENetPeer.roundTripTime