Comment autorisez-vous l'écriture du code réseau dans les étapes ultérieures du développement?

Je suis actuellement au début de l'écriture d'un jeu que je souhaiterai éventuellement améliorer dans la plupart des aspects.
Comment puis-je éviter d'écrire du code réseau tout en le laissant assez facilement implémenté, c'est-à-dire ne pas avoir à réécrire le jeu entier juste pour l'ajouter.
A quoi dois-je penser?

J'ai un modèle de composant où je sépare la physique / détection de collision, la logique de jeu, les types de données et l'animation / le rendu les uns des autres.
Comment écrire un client et un serveur sur lesquels aucun code réseau n'est encore implémenté et qui peuvent être testés localement?
Que dois-je faire dans le client et que dois-je faire dans le serveur? Dois-je en quelque sorte prétendre avoir terminé le code réseau et envoyer des messages entre le serveur et le client et tenir compte des retards, etc., même s'il n'y en aura pas?

Edit: Il est prévu que ce soit un RPG descendant. Le multijoueur simple où vous hébergez un serveur pour vos amis est ce que je pense, donc la tricherie n'est pas vraiment un problème (qui voudrait jouer avec des amis qui trichent?). J'aimerais quand même continuer avec une approche "Le serveur a toujours raison".

Edit 2: Je suppose que je suis à la recherche de quelques conseils sur ce que devrait être mon état d'esprit. Comment dois-je gérer la saisie au clavier, l'animation, etc., au lieu d'appliquer simplement chaque effet / changement instantanément. Hmmm, j'ai peut-être besoin de lire correctement sur le réseautage avant d'aller n'importe où, après tout, ce que j'avais espéré éviter en créant un squelette réseau qui pourrait fonctionner localement.

Sans en savoir plus sur le jeu exact que vous écrivez et comment vous l'écrivez, il est très difficile de dire des solutions génériques à votre problème.

Cependant, vous voudrez peut-être considérer cette décision que vous prenez de laisser le code de mise en réseau à la fin, en fonction de l'importance cruciale de la mise en réseau pour votre jeu.

Ce que je veux dire, c'est que si vous écrivez un jeu lourd en réseau, comme un MMORPG, il n'est peut-être pas sage de laisser le réseautage à la fin.

Cela étant, si l'impact que vous attendez du code de mise en réseau est faible (comme dans le cas, ne pas avoir de code de mise en réseau n'est pas un facteur déterminant), il pourrait être approprié de le laisser pour une étape ultérieure (mais pas trop tard).

N'oubliez pas que -écrire- le code de mise en réseau n'est pas la même chose que -penser- à ce sujet. Lorsque vous prenez des décisions sur la façon dont votre jeu est fait, vous devez considérer comment cela affecterait les décisions de mise en réseau, et si l'impact attendu est élevé, peut-être l'implémenter comme un talon qui donne des informations génériques, puis quand il est temps d'écrire le réseau code, il suffit de le brancher là où vous avez laissé le talon.

Ainsi, par exemple, si vous faites un jeu d'échecs en ligne, vous pouvez avoir une fonction appelée ExecuteMove()qui est appelée d'une manière ou d'une autre lorsqu'un mouvement est entré par la souris, et d'une autre manière lorsqu'un mouvement est entré par le clavier. À ce stade, vous voudrez peut-être penser à créer un talon de réseau qui, après avoir obtenu les données requises de l'autre hôte (c'est ce que vous écrivez dans une partie ultérieure), appelle ExecuteMove().

De cette façon, au fur et à mesure que vous créez votre jeu, vous saurez quelles parties sont affectées par le code de mise en réseau, et quand il est temps d'écrire réellement le code de mise en réseau, vous avez plusieurs étapes.

Si c'est la première fois que vous écrivez un jeu en réseau, pensez à ne pas trop penser à l'anti-triche et à des trucs comme ça. Faire un jeu en réseau est suffisamment complexe pour nécessiter toute une équipe de personnes hautement expérimentées pour le faire pour un jeu AAA, alors prenez-le lentement et créez d'abord un jeu qui fonctionne, avant de vous concentrer sur des sujets plus complexes.

Enfin, si c'est la première fois que vous créez un jeu, ne le faites pas en réseau, s'il vous plaît. Faire un jeu est si complexe que chaque exigence que vous ajoutez à votre jeu le rendra exponentiellement plus complexe.

Je suis dans une situation similaire, mais j'essaie de faire une simulation en réseau plus qu'un jeu; mais je pense que mon approche peut aider votre processus de conception.

Mon approche va dans le sens de votre commentaire sur IPC (communication inter-processus).

Pour commencer, j'étudie le livre "Networked Graphics" de Steed et Oliveira. Cela fournit une bonne base sur diverses architectures de réseau pour les jeux en fonction de divers critères et types de jeux. Il fournit un outil pour vous aider à décider de votre architecture de jeu et de ce que vous voulez exactement mettre sur le réseau et de ce que vous voulez faire localement.

Deuxièmement, séparez les composants réseau en un thread d'arrière-plan séparé afin que votre développement de jeu initial puisse avoir le composant codé localement, mais vous êtes obligé de gérer la séparation des threads. Ne les combinez pas avec d'autres fonctionnalités qui deviendront plus tard "arrière-plan local", mais forcez-les dans des fils d'arrière-plan "potentiellement distants".

Cela devrait aider à garder votre logique séparée et vous permettre également de simuler les facteurs de retard du réseau dans le processus afin que vous puissiez également voir l'impact de la latence.

Si vous apprenez tout cela, pourquoi ne pas écrire une version solo simple 1 et une fois que cela fonctionne, avec vos connaissances approfondies, repenser le tout en profondeur pour la version 2 qui sera multijoueur?

Implémentez une classe "faux réseau" qui transmet les messages entre les threads, qui a la même interface que la classe réseau. Plus tard, vous pouvez élaborer le faux réseau pour avoir des retards aléatoires et des pertes de paquets. Il sera toujours plus facile de déboguer du code réseau avec la fausse classe qu'avec le vrai réseau.