Discussions pour la communication entre pairs

Question

J'essaie de créer un jeu en réseau multijoueur. Chaque joueur est représenté par un rectangle sur l'écran. J'utilise OpenGL pour les graphiques et aussi l'entrée de l'utilisateur (les commandes comme MOVE-LEFT, MOVE-RIGHT etc.) seront traitées par lui (ou GLUT ou sumthing).

J'ai l'architecture suivante pour le jeu.

Il y a 4 joueurs (nœuds) dans le jeu. Chaque joueur envoie et reçoit des données en utilisant UDP. Chaque joueur peut envoyer des données à n'importe quel autre joueur.

Les données doivent être envoyées par un lecteur s'il y a des entrées de l'utilisateur correspondant. (Par exemple, commande MOVE-LEFT, etc.). Chaque fois qu'un joueur (disons p1) reçoit des données d'un autre joueur (disons p2) (comme la nouvelle position du joueur p2 sur l'écran), l'écran du joueur p1 doit être mis à jour immédiatement.

Je pense aux lignes suivantes: Créer un fil pour le traitement des graphiques. Créez 2 autres threads, 1 chacun pour recevoir et envoyer des données, en utilisant UDP.

Chaque fois que le thread graphique est saisi pour 'myposition' par l'utilisateur, il met à jour la variable globale partagée 'myposition'. Le thread d'envoi réseau, qui attend cette variable, est activé et informe tous les autres joueurs de sa nouvelle position.

De même, chaque fois que des mises à jour de «position» sont reçues d'un autre lecteur «i», le thread de réception réseau met à jour le lecteur de variable globale [i] .position. Le fil graphique va maintenant redessiner la scène avec les positions mises à jour.

Est-ce que cette conception est correcte? Si oui, quelle est cette conception et comment puis-je l'améliorer

Answer 1

La programmation de jeux en réseau est un monstre d'un sujet, il est donc difficile de dire «oui, c'est ainsi que vous concevez une architecture de réseau». Cela dépend entièrement de vos exigences de jeu. Quel type de volume de paquets prévoyez-vous d'envoyer? Y aura-t-il un paquet envoyé à chaque trame qui indique que le joueur A tient la clé gauche? Ce trafic est-il limité à un réseau local? Pour quelque chose d'aussi simple que de synchroniser le mouvement entre 4 clients, mettre send, receive et rendering dans des threads séparés semble être trop compliqué. Peut-être comme point de départ, vous devriez commencer avec un design plus simple et passer au multithreading quand vous sentez que vos paquets ne sortent pas assez vite.

Par exemple, vous voudrez peut-être avoir une boucle de jeu comme ce qui suit (tous dans le même fil):

while (running): 
    readUpdSocketForIncomingPackets(); 
    updateGameObjects(); 
    renderGameObjects(); 
    sendPacketsToPeers(); 

Au début de chaque trame, vous pouvez lire votre prise udp pour les paquets entrants et mettre à jour les positions (et tout ce que vous envoyez à vos pairs), puis dessiner. Lorsque l'entrée de jeu est traitée, les paquets sont créés et accumulés dans une file d'attente de paquets. En procédant de cette façon, vous pouvez effectuer des optimisations, telles que bachotage/fusion de plusieurs messages en un seul paquet, suppression des doublons (par exemple envoyer uniquement la dernière mise à jour de position), etc .. Ainsi, à la fin de chaque boucle les paquets sont traités et envoyés aux pairs.

Mais encore une fois, c'est un grand sujet et j'ai passé en revue beaucoup de détails.

Jetez un oeil sur le blog de gaffer: http://gafferongames.com/networking-for-game-programmers/what-every-programmer-needs-to-know-about-game-networking/

Il a quelques grands articles qui traitent de certains fondamentaux de la programmation de jeu en réseau.