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

12

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.

Ghork
fonte
Isso depende muito de como você planeja implementar seu código de rede quando chegar lá. Quake (ou algum título de identificação posterior, talvez, minha memória esteja um pouco confusa), por exemplo, adotou a abordagem de sempre ser cliente / servidor. Mesmo a opção para um jogador está realmente se conectando a um servidor no 127.0.0.1 e não convidando outros jogadores - o que significa que até o jogo para um jogador é executado inteiramente via código de rede.
LLL79
Isso é o que eu tinha em mente. Talvez alguma comunicação entre processos para que você não precise se conectar quando quiser tocar sozinho ou talvez uma classe que tenha as mesmas funções que o cliente, mas lide com ela como o servidor imediatamente.
Ghork
3
A melhor prática é "não" há algum tempo. A menos que você esteja escrevendo um jogo baseado em turnos, basta criar um design diferente para lidar com a rede. Se você se preocupa com latência, correção e trapaça, simplesmente não há uma maneira de contornar isso. Caso contrário, você realmente não precisa pensar muito sobre isso - se você não tiver a experiência, não poderá prever o design adequado o suficiente. A melhor maneira é iniciar alguns protótipos em rede para obter realmente experiência em rede.
Luaan 15/07/2015
Se você pensar bem, o minecraft tem um servidor local, mesmo em jogos para um jogador. O servidor é o mecanismo, o cliente é apenas um apresentador.
faísca

Respostas:

12

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.

Panda Pajama
fonte
Bem, não é MMO, então não será tão pesado nas redes. No entanto, não é um jogo de tabuleiro obsoleto, onde não há problema em levar alguns segundos antes que uma jogada seja feita. Acho que o networking deve ser pensado desde o início, porque, na minha experiência, adicionar multiplayer nos últimos estágios não vai dar certo. No entanto, eu não quero escrever código de rede e depurar isso antes que eu possa fazer meu personagem se mover e colidir com objetos.
Ghork
2
@Ghork: Ah, você quer ver seu produto fazer coisas bonitas o mais rápido possível! Bem, sim, todos nós fazemos. Mas sucumbir a essa tentação não levará a um programa bem planejado e bem pensado.
Lightness Races com Monica
Aceito esta resposta, embora goste das outras respostas também. Especificamente o comentário de @Luaan
Ghork
2

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.

Joe Van Steen
fonte
Acho que vou ter que verificar esse livro então! Parece promissor ser capaz de fazer o que você disse.
Ghork
@ Ghork: A chave é descobrir sua arquitetura, o que você quer local e o que você quer em um servidor; ou como você deseja que os colegas se comuniquem e interajam. Esse livro deve ajudar. Em seguida, coloque tudo o que você deseja remoto no outro lado de uma chamada de mensagem IPC através de um conjunto de códigos cliente-servidor que (por enquanto) permanecem todos locais, mas mantêm coisas "remotas" em threads separados. No componente de transmissão de mensagens do IPC, adicione artificialmente qualquer latência que você deseja simular. Boa sorte!
21315 Joe Joe Steen
1

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?

Etienne Charland
fonte
0

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.

ddyer
fonte