Netcode.IO.NET

Código de rede.IO.NET

Uma implementação C# pura e gerenciada da especificação Netcode.IO

Metas do projeto

O objetivo deste projeto é fornecer uma implementação gerenciada pura da especificação Netcode.IO codificada em .NET 3.5 e usando zero DLLs ou wrappers nativos para máxima portabilidade. Em vez de usar libsodium como a implementação de referência C original, esta implementação usa uma versão personalizada da biblioteca de criptografia Bouncy Castle. Você pode encontrar o código-fonte original aqui: https://github.com/bcgit/bc-csharp

Além disso, ele foi projetado para uso em jogos. Para este fim, foi concebido desde o início para ter o mínimo impacto possível nas alocações de GC. Na maioria das vezes, você não deverá ver nenhum impacto no GC ao usar o Netcode.IO.NET.

Uso de API

A maior parte da API reside no namespace NetcodeIO.NET

API do servidor

Para criar e iniciar um novo servidor:

 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

Para ouvir vários eventos:

 // 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 )

Para enviar uma carga útil para um cliente remoto conectado ao servidor:

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

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

Para desconectar um cliente:

 server . Disconnect ( RemoteClient client ) ;

Para obter dados arbitrários do usuário de 256 bytes que podem ser transmitidos com um token de conexão:

 remoteClient . UserData ; // byte[256]

Para parar um servidor e desconectar qualquer cliente:

 server . Stop ( ) ; 

API do cliente

Para criar um novo cliente:

 Client client = new Client ( ) ;

Para ouvir vários eventos:

 // 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 )

Para conectar-se a um servidor usando um token de conexão:

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

Para enviar uma mensagem para um servidor quando conectado:

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

Para desconectar um cliente:

 client . Disconnect ( ) ; 

API TokenFactory

TokenFactory pode ser usado para gerar tokens de conexão públicos usados ​​pelos clientes para se conectar aos servidores do jogo. Para criar um novo 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
) ;

Para gerar um novo token de conexão pública de 2.048 bytes:

 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)
) ;

Uma observação sobre UDP e falta de confiabilidade

Netcode.IO.NET é uma porta pura do protocolo Netcode.IO - nada mais e nada menos. Em sua essência, Netcode.IO é uma abstração baseada em criptografia e conexão sobre UDP. E, assim como o UDP, não tem nenhuma garantia de confiabilidade. Suas mensagens podem não funcionar e podem não chegar em ordem. Isso é apenas um fato da internet. Dito isto, qualquer jogo quase certamente precisará de algum tipo de camada de confiabilidade. Para esse fim, meu projeto ReliableNetcode.NET fornece uma camada de confiabilidade agnóstica e fácil de usar que você pode usar para adicionar essa funcionalidade ao seu jogo.