GameLoop.Networking

GameLoop.Réseau

Une bibliothèque réseau UDP pour les jeux créés en GameLoop ! Il offre plusieurs niveaux d'abstraction, depuis le simple wrapper UDP de bas niveau jusqu'aux niveaux supérieurs.

Utilisation du wrapper UDP de bas niveau

 // Spin up a socket listener. It listens for datagrams from any network address, on the specified port.
var peer = new NetworkSocket ( memoryPool ) ;
peer . Bind ( new IPEndPoint ( IPAddress . Any , port ) ) ; 

 // Send data. It sends data to the specified network address and port.
peer . SendTo ( new IPEndPoint ( IPAddress . Loopback , port ) ) ; 

 // Polling for data. It fetches a message from the receiving queue, if any. If nothing has been received, it just returns "false".
while ( peer . Poll ( out NetworkArrivedData message ) )
{
	var addressFrom = message . EndPoint ;
	var receivedData = message . Data

	// Execute your logic on received data.
} 

IMemoryPool et IMemoryAllocator

La bibliothèque n'alloue pas de mémoire directement. Au lieu de cela, il délègue cette responsabilité à deux interfaces : IMemoryPool et IMemoryAllocator. En implémentant ces interfaces, vous pouvez manipuler la façon dont la mémoire est allouée et gérée dans votre application. La bibliothèque contient un allocateur trivial et un pool trivial que vous pouvez utiliser pour créer rapidement un prototype.

 var memoryAllocator = new SimpleManagedAllocator ( ) ;
var memoryPool = new SimpleMemoryPool ( memoryAllocator ) ; 

Travailler avec des tampons

La bibliothèque comprend des structures pratiques pour travailler avec des tampons, afin d'aider l'utilisateur à écrire/lire vers/à partir d'eux.

 // Reading from a buffer.
byte [ ] buffer = message . Data ;

var reader = default ( NetworkReader ) ;
reader . Initialize ( ref buffer ) ;

int myInt = reader . ReadInt ( ) ;
long myLong = reader . ReadLong ( ) ;
float myFloat = reader . ReadFloat ( ) ;
string myString = reader . ReadString ( ) ;
// etc 

 // Writing to a buffer.
var writer = default ( NetworkWriter ) ;

// 1) You can manually manage the buffer:
/* 1) */ byte [ ] buffer = memoryPool . Rent ( size ) ;
/* 1) */ writer . Initialize ( ref buffer ) ;
// NOTE: in this way the writer will NOT expand the buffer if a Write call requires more space.

// OR

// 2) You can let the writer to manage internally the buffer:
/* 2) */ writer . Initialize ( memoryPool , initialSize ) ;
// NOTE: this will automatically expand the buffer if a Write call requires more space.

// OR

// 3) You can pass a buffer to copy its initial state, but let the writer to manage its own buffer internally:
/* 3) */ byte [ ] initialState = memoryPool . Rent ( size ) ;
/* 3) */ writer . Initialize ( memoryPool , ref initialState ) ;
// NOTE: this will automatically expand the buffer if a Write call requires more space.

writer . Write ( 12 ) ;
writer . Write ( 24f ) ;
writer . Write ( "36" ) ;
// etc