Simulações físicas do servidor com centenas de jogadores

Atualmente, estou trabalhando em um jogo voltado para a física para um jogador, onde gostaria que a física fosse simulada no servidor. Isso porque o jogo terá tabelas de líderes, progressão persistente de jogadores, etc. e eu quero evitar qualquer tipo de trapaça - basicamente uma arquitetura pura de cliente-servidor, o cliente é "burro" e exibe apenas o que o servidor deseja que você exiba.

O problema, porém, é que o jogo provavelmente será jogado por centenas (talvez milhares) de pessoas ao mesmo tempo. Isso me preocupa, pois provavelmente matará o poder de processamento do servidor se eu tiver que fazer e manter centenas de estados ao mesmo tempo.

Eu não teria problemas para mover todas as simulações de física para o lado do cliente, mas precisaria realmente de uma maneira de validar se o resultado de uma simulação de cliente é válido. No entanto, não consigo descobrir como.

Pensei em executar a simulação do lado do servidor de vez em quando para validar se o cliente ainda está jogando limpo, mas realmente quero que o servidor tenha o menor esforço possível.

A física se tornará tão complexa quanto a demonstração da GDC 2011 de Glenn Fiedler , talvez até mais simples. No entanto, muito mais corpos rígidos sempre em colisão estarão em uma única cena e todos serão visíveis ao mesmo tempo.

Tenho dificuldade em obter uma resposta para esse caso em particular, pois a maioria dos recursos da Web - novamente, o site de Glenn Fiedlers é ótimo - fala sobre física em rede em pequena escala (por exemplo, um FPS com 30 jogadores, como o Halo).

Qualquer conselho, sites, documentos ou similares sobre o assunto será muito apreciado.

Uma recapitulação das perguntas às quais gostaria de responder:

• Quão viável é um modelo cliente-servidor? A minha preocupação com o poder de processamento do servidor é legítima e fundamentada?
• É possível validar com segurança uma simulação física executada pelo cliente no servidor? Se sim, como?

Você pode validar do lado do cliente os envios de outros usuários e fazer com que o cliente relate ao servidor se um envio parecer inválido.

Depois, você pode agir (banir o trapaceiro ou banir quem falsificou o relatório falso). Para verificar se esse envio é realmente inválido ou não, você pode usar um cliente especial ou o que for.

Seu jogo é para um jogador, a única 'interação' com os outros jogadores é um líder. Você pode gerar uma instância para verificar uma simulação em seu servidor para cada envio. Você não precisa de todos os truques para garantir que a física seja a mesma com mais de 30 clientes. Portanto, acho que você não precisa de mais recursos do que já tem desde a física já está funcionando :).

Verificar se todos os resultados serão um pouco exagerados, você pode enviar a simulação compactada para o servidor sempre que alguém enviar uma pontuação para o líder, depois apenas verificar as 5% melhores pontuações no seu próprio servidor, ou talvez até o 1% ou mais mais inteligente apenas verifica novos recordes e assume que todos que não são melhores que o número 1 provavelmente têm uma simulação não enganada.

Eu não sei se a sua simulação é como, configure e não interaja (fácil de verificar) ou se os jogadores podem interagir com o sim enquanto ele está sendo executado, mas certifique-se de fazer sua física de tal maneira que diferentes flutuações representações de pontos não atrapalham as coisas e fazem com que uma execução válida pareça inválida.

Não faça isso, posso garantir que simular a física apenas no servidor é uma péssima idéia. O principal problema não é a carga do servidor, mas a capacidade de resposta. A capacidade de resposta do cliente será incrivelmente baixa. O jogador apertará um botão, então você terá que fazer uma ida e volta ao servidor antes de obter os resultados da simulação. Eu fiz variações disso no passado (principalmente pressionando apenas os botões), e os resultados não são bonitos e devem ser feitos apenas para jogos muito lentos que têm chances de se safar (e mesmo nesses casos, a percepção falta de capacidade de resposta é um grande problema).

Um esquema melhor que pretendo tentar na próxima vez em que esse tipo de cenário se apresentar é escolher para os jogadores um subconjunto muito pequeno da sua base de jogadores e simular para eles o servidor por um tempo e comparar seus resultados com os deles, sem o conhecimento deles. Se eles estão se desviando muito (você deve esperar alguns graus de divergência), então os classifica como trapaceiros em potencial e continua a simulá-los por mais algum tempo para confirmar. O que você obterá é algum tipo de curva de quanto um jogador legítimo diverge em comparação com o servidor, influenciado pelas condições da rede, etc., e você verá rapidamente que os trapaceiros estão fora dessa curva. Este sistema possui os seguintes benefícios:

• Automatizado
• Você não sacrifica a capacidade de resposta
• Como você apenas simula um subconjunto muito pequeno da sua base de jogadores, a carga será gerenciável e até escalável (talvez você escolha menos jogadores para simular se a carga for alta)
• Aplicável a todos os jogos que consigo pensar, tão altamente reutilizáveis

Como Daniel afirmou, o grande problema aqui serão os programas que executam a ação para o jogador; nenhuma inclinação física no jogo seria necessária se o jogador fosse um braço robótico com precisão normalmente resolvida para neurocirurgia.