Como eu criei meu jogo online. Parte 1: Rede

Olá pessoal! Recentemente, tirei férias e houve tempo para programar com calma meus projetos em casa. Eu queria, portanto, fazer meu jogo online simples no Rust. Mais precisamente, um simples jogo de tiro em 2D. Eu decidi fazer a parte da rede primeiro, e lá já será visto o que e como. Como o gênero envolve ação em todos os campos, decidi usar o protocolo UDP. Ele começou a projetar a arquitetura da parte da rede. Percebi que você pode colocar tudo em uma biblioteca separada. Também carreguei a biblioteca resultante no crates.io, sob a licença MIT, porque: a) Será mais conveniente conectá-la a partir daí aos meus projetos. b) Talvez seja útil para outra pessoa e traga benefícios. Para detalhes, bem-vindo ao gato.

Referências

-> Fontes
-> Biblioteca em crates.io
-> Documentação

Exemplo de uso

Cliente

//   use victorem; fn main() -> Result<(), victorem::Exception> { // ,    11111      127.0.0.1:22222 let mut socket = victorem::ClientSocket::new("11111", "127.0.0.1:22222")?; loop { //    socket.send(b"Client!".to_vec()); //    .             socket.recv().map(|v| String::from_utf8(v).map(|s| println!("{}",s))); } } 

Servidor

 //   use victorem; use std::time::Duration; use std::net::SocketAddr; //,  .            . struct ClientServerGame; //     Game,         impl victorem::Game for ClientServerGame { //,     .       false,   . fn handle_command(&mut self, delta_time: Duration, commands: Vec<Vec<u8>>, from: SocketAddr) -> bool { for command in commands { String::from_utf8(command).map(|s| println!("{}",s)); } true } //     30 .     ,     .      ,     . fn draw(&mut self, delta_time: Duration) -> Vec<u8> { b"Server!".to_vec() } } fn main() -> Result<(), victorem::Exception> { // ,      ClientServerGame     22222 let mut server = victorem::GameServer::new(ClientServerGame, "22222")?; //       . server.run(); Ok(()) } 

Dispositivo interno

Em geral, se eu usar soquetes UDP brutos em vez de soquetes UDP brutos para a parte de rede do Laminar , o código poderá ser reduzido em um fator de 100 e usar o algoritmo descrito nesta série de artigos - Programação de Rede para Desenvolvedores de Jogos .
A arquitetura do servidor envolve receber comandos dos clientes (por exemplo, pressionar um botão do mouse ou algum botão no teclado) e enviar a eles um estado (por exemplo, a posição atual das unidades e a direção que eles estão procurando) com os quais o cliente pode exibir uma imagem para o jogador.

No servidor

 //         u32     ,  0 -  , 1 -   ,      . pub fn get_lost(&self) -> (u32, u32) { let mut sequence: u32 = 0; let mut x = 0; let mut y = self.last_received_packet_id; while x < 32 && y > 1 { y -= 1; if !self.received.contains(&y) { let mask = 1u32 << x; sequence |= mask; } x += 1; } (sequence, self.last_received_packet_id) } 

No cliente

 //      (max_id)         (sequence)  .           fn get_lost(&mut self, max_id: u32, sequence: u32) -> Vec<CommandPacket> { let mut x = max_id; let mut y = 0; let mut ids = Vec::<u32>::new(); //      , ,     ,      . let max_cached = self.cache.get_max_id(); if max_cached != max_id { ids.push(max_cached); } while x > 0 && y < 32 { x -= 1; let mask = 1u32 << y; y += 1; let res = sequence & mask; if res > 0 { ids.push(x); } } self.cache.get_range(&ids) } 

Epílogo

De fato, era mais fácil criar um algoritmo de entrega de comandos. No servidor, aceite apenas o pacote com o qual vá mais do que o último pacote recebido por +1 e descarte o restante. Envie ao cliente o último pacote recebido. No cliente, mantenha um cache de todos os comandos que o usuário tentou enviar para o servidor. Sempre que um novo estado chegar do servidor com o ID, o último pacote recebido pelo servidor, exclua-o do cache e todos os pacotes com o ID menor que ele. Todos os pacotes restantes são enviados ao servidor novamente.
Além disso, quando eu criar o jogo em si, no processo de uso, melhorarei e otimizaremos a lib. Talvez eu encontre mais alguns bugs.

Eu encontrei aqui um projeto de servidor de jogos em C # - Networker + on Rust, existe uma folha, mais ou menos como um análogo de um servidor de jogos em Go - leaf. Só há desenvolvimento em andamento.

PS Caro amigo, se você é iniciante e decidiu ler meu código para este projeto e ver os testes que escrevi lá. Então, aqui está o meu conselho para você - não faça o que eu faço. Misturei tudo em uma pilha de testes e não segui o modelo "AAA" (pesquise no google o que é). Você não precisa fazer isso na produção. Um teste normal deve verificar uma coisa, não várias condições ao mesmo tempo, e deve consistir nas etapas:

1. Você define suas variáveis;
2. Você executa a ação que deseja testar;
3. Você compara o resultado com o esperado.

Por exemplo

  fn add_one(x:usize) -> usize { x+1 } #[test] fn add_one_fn_should_add_one_to_it_argument(){ let x = 2; let expected = x+1; ///////////////////////// let result = add_one(x); ////////////////////////////////// assert_eq!(expected,result); }