Como você permite que o código de rede seja escrito nas etapas posteriores do desenvolvimento?

Atualmente, estou no início do desenvolvimento de um jogo que, eventualmente, desejarei melhorar na maioria dos aspectos.
Como posso deixar de escrever o código de rede e deixá-lo implementado com bastante facilidade, ou seja, sem precisar reescrever o jogo inteiro apenas para adicioná-lo.
O que tenho que ter em mente?

Eu tenho um padrão de componente onde separo física / detecção de colisão, lógica de jogo, tipos de dados e animação / renderização um do outro.
Como escrevo um cliente e servidor que ainda não possui código de rede implementado e pode ser testado localmente?
O que devo fazer no cliente e o que devo fazer no servidor? Devo apenas fingir que tenho o código de rede finalizado e enviar mensagens entre servidor e cliente e contabilizar atrasos, etc., mesmo que não haja nenhum?

Edit: Ele está planejado para ser um RPG de cima para baixo. Multiplayer simples, onde você hospeda um servidor para seus amigos, é o que eu estou pensando, então trapacear não é um problema (quem gostaria de brincar com trapaceiros?). Ainda assim, gostaria de usar a abordagem "O servidor está sempre certo".

Edit 2: Acho que estou procurando algumas dicas sobre como deve ser minha mente. Como devo lidar com a entrada do teclado, animação, etc, em vez de apenas aplicar todos os efeitos / alterações instantaneamente. Hmmm, talvez eu precise ler corretamente as redes antes de ir a qualquer lugar, afinal, era o que eu esperava evitar criando um esqueleto de rede de algum tipo que pudesse funcionar localmente.

Sem saber mais sobre o jogo exato que você está escrevendo e como está escrevendo, é muito difícil dizer soluções genéricas para o seu problema.

No entanto, você pode considerar a decisão de deixar o código de rede até o fim, dependendo de como a rede é crucial para o seu jogo.

O que quero dizer é que, se você estiver escrevendo um jogo pesado para a rede, como um MMORPG, pode não ser prudente deixar a rede até o fim.

Considerado isso, se o impacto que você espera para o código de rede for baixo (como não ter código de rede não é um fator de ruptura), seria apropriado deixá-lo para um estágio posterior (mas não muito tarde).

Lembre-se de que escrever código de rede não é o mesmo que pensar. Ao tomar decisões sobre como o seu jogo é feito, considere como isso afetaria as decisões de rede e, se o impacto esperado for alto, talvez implemente-o como um esboço que fornece algumas informações genéricas e quando for a hora de escrever a rede. código, é apenas uma questão de conectá-lo onde você deixou o esboço.

Assim, por exemplo, se você estiver jogando um jogo de xadrez on-line, poderá ter uma função chamada ExecuteMove()que é chamada de alguma forma quando uma jogada é inserida pelo mouse e de outra maneira quando uma jogada é inserida pelo teclado. Nesse ponto, você pode pensar em criar um esboço de rede que, depois de obter os dados necessários do outro host (é o que você escreve posteriormente), chama ExecuteMove().

Dessa forma, ao criar seu jogo, você saberá quais partes são afetadas pelo código de rede e, quando chegar a hora de realmente escrever o código de rede, você estará vários passos à frente.

Se esta é sua primeira vez escrevendo um jogo em rede, considere não pensar muito em anti-trapaça e coisas assim. Criar um jogo em rede é complexo o suficiente para exigir que uma equipe inteira de pessoas altamente experientes o faça para um jogo AAA; portanto, vá devagar e primeiro faça um jogo que funcione, antes de se concentrar em tópicos mais complexos.

Finalmente, se esta é sua primeira vez em um jogo, não o faça em rede, por favor. Fazer um jogo é tão complexo que cada requisito que você adiciona ao seu jogo o torna exponencialmente mais complexo.

Estou em uma situação semelhante, mas estou tentando fazer uma simulação em rede mais do que um jogo; mas acho que minha abordagem pode ajudar seu processo de design.

Minha abordagem está na linha do seu comentário sobre o IPC (comunicação entre processos).

Primeiro, como pano de fundo, estou estudando o livro "Networked Graphics" de Steed e Oliveira. Isso fornece um bom histórico de várias arquiteturas de rede para jogos, dependendo de vários critérios e tipos de jogos. Ele fornece uma ferramenta para ajudá-lo a decidir a arquitetura do jogo e o que exatamente você deseja colocar na rede e o que deseja que ocorra localmente.

Segundo, separe os componentes de rede em um encadeamento em segundo plano separado para que seu desenvolvimento inicial do jogo possa ter o componente codificado localmente, mas você é forçado a lidar com a separação de encadeamentos. Não combine-os com outros recursos que posteriormente serão "plano de fundo local", mas force-os a encadeamentos de plano de fundo "potencialmente remotos".

Isso deve ajudar a manter sua lógica separada e também simular fatores de atraso de rede no processo, para que você também possa ver o impacto da latência.

Se você está aprendendo sobre tudo isso, por que não escrever uma versão simples para um jogador e uma vez que estiver funcionando, com seu conhecimento mais profundo, repensar tudo sobre a versão 2 que será multi-jogador?

Implemente uma classe "rede falsa" que transmita mensagens entre threads, que tem a mesma interface que a classe de rede. Mais tarde, você pode elaborar a rede falsa para atrasos aleatórios e perda de pacotes. Sempre será mais fácil depurar o código de rede com a classe falsa do que com a rede real.