Cómo creé mi juego en línea. Parte 1: Redes

Hola a todos! Recientemente tuve unas vacaciones y tuve tiempo de programar con calma los proyectos de mi casa. Por lo tanto, quería hacer mi sencillo juego en línea en Rust. Más precisamente, un simple juego de disparos en 2D. Decidí hacer que la red formara parte primero, y allí ya se verá qué y cómo. Como el género involucra acción en todos los campos, decidí usar el protocolo UDP. Comenzó a diseñar la arquitectura de la parte de la red. Me di cuenta de que puedes ponerlo todo en una biblioteca separada. También cargué la biblioteca resultante en crates.io bajo la licencia MIT, porque: a) Entonces será más conveniente para mí conectarla desde allí a mis proyectos. b) Quizás sea útil para otra persona y traiga beneficios. Para más detalles, bienvenido a cat.

Referencias

-> Fuentes
-> Biblioteca en crates.io
-> Documentación

Ejemplo 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

En general, si utilizo sockets UDP sin procesar en lugar de sockets UDP sin procesar para la parte de red de Laminar , entonces el código podría reducirse en un factor de 100, y uso el algoritmo descrito en esta serie de artículos: Programación de redes para desarrolladores de juegos .
La arquitectura del servidor implica recibir comandos de los clientes (por ejemplo, presionar un botón del mouse o algún botón del teclado) y enviarles un estado (por ejemplo, la posición actual de las unidades y la dirección que están mirando) con el que el cliente puede mostrar una imagen al jugador.

En el 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) } 

En el 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 hecho, fue más fácil hacer un algoritmo de entrega de comandos. En el servidor, acepte solo el paquete con el que va más que ir al último paquete recibido por +1, y descarte el resto. Envíe al cliente el último paquete recibido. En el cliente, guarde un caché de todos los comandos que el usuario intentó enviar al servidor. Cada vez que llega un nuevo estado del servidor con ID, el último paquete recibido por el servidor, lo elimina de la caché y todos los paquetes con ID menos de lo que tiene. Todos los paquetes restantes se envían nuevamente al servidor.
Además, cuando haga el juego en sí, en el proceso de uso mejoraré y optimizaré aún más la lib. Quizás encuentre algunos errores más.

Encontré aquí un proyecto de servidor de juegos en C # - Networker + en Rust, hay una hoja, algo así como un análogo de un servidor de juegos en Go - leaf. Solo hay desarrollo en progreso.

PD Estimado amigo, si eres un principiante y decidiste leer mi código para este proyecto y ver las pruebas que escribí allí. Así que aquí está mi consejo para ti: no hagas lo que yo hago. Mezclé todo en un montón en las pruebas y no seguí la plantilla "AAA" (google qué es). No tiene que hacer esto en producción. Una prueba normal debe verificar una cosa, no varias condiciones a la vez, y debe consistir en los pasos:

1. Usted establece sus variables;
2. Realizas la acción que quieres probar;
3. Compara el resultado con el esperado.

Por ejemplo

  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); }