Netcode.IO.NET

Netcode.IO.NET

Une implémentation C# purement gérée de la spécification Netcode.IO

Objectifs du projet

L'objectif de ce projet est de fournir une implémentation purement gérée de la spécification Netcode.IO codée avec .NET 3.5 et utilisant zéro DLL ou wrapper natif pour une portabilité maximale. Au lieu d'utiliser libsodium comme l'implémentation de référence C originale, cette implémentation utilise une version personnalisée de la bibliothèque de cryptographie Bouncy Castle. Vous pouvez trouver le code source original ici : https://github.com/bcgit/bc-csharp

De plus, il est conçu pour être utilisé dans les jeux. À cette fin, il a été conçu dès le départ pour avoir le moins d’impact possible sur les allocations du GC. Pour la plupart, vous ne devriez voir aucun impact sur le GC lié à l’utilisation de Netcode.IO.NET.

Utilisation de l'API

La plupart de l'API réside dans l'espace de noms NetcodeIO.NET

API du serveur

Pour créer et démarrer un nouveau serveur :

 Server server = new Server (
	maxClients ,		// int maximum number of clients which can connect to this server at one time
	publicAddress , port ,	// string public address and int port clients will connect to
	protocolID ,		// ulong protocol ID shared between clients and server
	privateKeyBytes		// byte[32] private crypto key shared between backend servers
) ;
server . Start ( ) ;			// start the server running

Pour écouter divers événements :

 // Called when a client has connected
server . OnClientConnected += clientConnectedHandler ;		// void( RemoteClient client )

// Called when a client disconnects
server . OnClientDisconnected += clientDisconnectedHandler ;	// void( RemoteClient client )

// Called when a payload has been received from a client
// Note that you should not keep a reference to the payload, as it will be returned to a pool after this call completes.
server . OnClientMessageRecieved += messageReceivedHandler ;	// void( RemoteClient client, byte[] payload, int payloadSize )

// Called when the server logs a message
// If you are not using a custom logger, a handler using Console.Write() is sufficient.
server . OnLogMessage += logMessageHandler ;			// void( string message, NetcodeLogLevel logLevel )

Pour envoyer une charge utile à un client distant connecté au serveur :

 remoteClient . Send ( byte [ ] payload , int payloadSize ) ;

// or:
server . SendPayload ( RemoteClient client , byte [ ] payload , int payloadSize ) ;

Pour déconnecter un client :

 server . Disconnect ( RemoteClient client ) ;

Pour accéder aux données utilisateur arbitraires de 256 octets qui peuvent être transmises avec un jeton de connexion :

 remoteClient . UserData ; // byte[256]

Pour arrêter un serveur et déconnecter tous les clients :

 server . Stop ( ) ; 

API cliente

Pour créer un nouveau client :

 Client client = new Client ( ) ;

Pour écouter divers événements :

 // Called when the client's state has changed
// Use this to detect when a client has connected to a server, or has been disconnected from a server, or connection times out, etc.
client . OnStateChanged += clientStateChanged ;			// void( ClientState state )

// Called when a payload has been received from the server
// Note that you should not keep a reference to the payload, as it will be returned to a pool after this call completes.
client . OnMessageReceived += messageReceivedHandler ;		// void( byte[] payload, int payloadSize )

Pour vous connecter à un serveur à l'aide d'un jeton de connexion :

 client . Connect ( connectToken ) ;		// byte[2048] public connect token as returned by a TokenFactory

Pour envoyer un message à un serveur une fois connecté :

 client . Send ( byte [ ] payload , int payloadSize ) ;

Pour déconnecter un client :

 client . Disconnect ( ) ; 

API TokenFactory

TokenFactory peut être utilisé pour générer les jetons de connexion publics utilisés par les clients pour se connecter aux serveurs de jeux. Pour créer une nouvelle TokenFactory :

 TokenFactory tokenFactory = new TokenFactory (
	protocolID ,		// must be the same protocol ID as passed to both client and server constructors
	privateKey		// byte[32], must be the same as the private key passed to the Server constructor
) ;

Pour générer un nouveau jeton de connexion publique de 2 048 octets :

 tokenFactory . GenerateConnectToken (
	addressList ,		// IPEndPoint[] list of addresses the client can connect to. Must have at least one and no more than 32.
	expirySeconds ,		// in how many seconds will the token expire
	serverTimeout ,		// how long it takes until a connection attempt times out and the client tries the next server.
	sequenceNumber ,		// ulong token sequence number used to uniquely identify a connect token.
	clientID ,		// ulong ID used to uniquely identify this client
	userData		// byte[], up to 256 bytes of arbitrary user data (available to the server as RemoteClient.UserData)
) ;

Une note sur UDP et le manque de fiabilité

Netcode.IO.NET est un pur portage du protocole Netcode.IO - ni plus ni moins. En son cœur, Netcode.IO est une abstraction basée sur le cryptage et la connexion au-dessus d'UDP. Et, tout comme UDP, il n’a aucune garantie de fiabilité. Vos messages risquent de ne pas parvenir, et ils risquent de ne pas parvenir dans l'ordre. C'est juste un fait concernant Internet. Cela dit, tout jeu aura presque certainement besoin d’une sorte de couche de fiabilité. À cette fin, mon projet ReliableNetcode.NET fournit une couche de fiabilité agnostique et facile à utiliser que vous pouvez utiliser pour ajouter cette fonctionnalité à votre jeu.