Wie ich mein Online-Spiel erstellt habe. Teil 1: Vernetzung

Hallo an alle! Ich hatte vor kurzem Urlaub und es war Zeit, meine Heimprojekte ruhig zu programmieren. Ich wollte deshalb mein einfaches Online-Spiel auf Rust machen. Genauer gesagt, ein einfacher 2D-Shooter. Ich habe mich entschlossen, das Netzwerk zuerst zu teilen, und dort wird bereits gesehen, was und wie. Da das Genre Aktionen in allen Bereichen umfasst, habe ich mich für das UDP-Protokoll entschieden. Er begann die Architektur des Netzwerkteils zu entwerfen. Mir wurde klar, dass Sie alles in einer separaten Bibliothek ablegen können. Ich habe die resultierende Bibliothek auch unter der MIT-Lizenz auf crates.io hochgeladen, weil: a) es für mich dann bequemer ist, sie von dort aus mit meinen Projekten zu verbinden. b) Vielleicht ist es für jemand anderen nützlich und bringt Vorteile. Für Details willkommen bei Katze.

Referenzen

-> Quellen
-> Bibliothek bei crates.io
-> Dokumentation

Anwendungsbeispiel

Kunde

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

Server

 //   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(()) } 

Internes Gerät

Wenn ich für den Netzwerkteil von Laminar unformatierte UDP-Sockets anstelle von unformatierten UDP-Sockets verwendet habe, könnte der Code im Allgemeinen um den Faktor 100 reduziert werden, und ich verwende den in dieser Artikelserie - Netzwerkprogrammierung für Spieleentwickler - beschriebenen Algorithmus.
Die Architektur des Servers umfasst das Empfangen von Befehlen von Clients (z. B. Drücken einer Maustaste oder einer Taste auf der Tastatur) und das Senden eines Status (z. B. die aktuelle Position der Einheiten und die Blickrichtung), mit dem der Client dem Player ein Bild anzeigen kann.

Auf dem Server

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

Auf dem Client

 //      (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) } 

Nachwort

Tatsächlich war es einfacher, einen Befehlsübermittlungsalgorithmus zu erstellen. Akzeptieren Sie auf dem Server nur das Paket, mit dem mehr als das zuletzt von +1 empfangene Paket erreicht wird, und verwerfen Sie den Rest. Senden Sie dem Client das zuletzt empfangene Paket. Bewahren Sie auf dem Client einen Cache aller Befehle auf, die der Benutzer an den Server senden wollte. Jedes Mal, wenn ein neuer Status vom Server mit der ID eingeht, das letzte vom Server empfangene Paket, löschen Sie es aus dem Cache und alle Pakete mit einer ID, die kleiner als diese ist. Alle verbleibenden Pakete werden erneut an den Server gesendet.
Wenn ich das Spiel selbst mache, werde ich im Verlauf des Gebrauchs die Bibliothek weiter verbessern und optimieren. Vielleicht finde ich noch mehr Fehler.

Ich habe hier ein Game-Server-Projekt in C # - Networker + auf Rust gefunden. Es gibt ein Blatt, ähnlich einem Analogon eines Game-Servers auf Go-Leaf. Nur die Entwicklung ist im Gange.

PS Lieber Freund, wenn Sie ein Anfänger sind und beschlossen haben, meinen Code für dieses Projekt zu lesen und die Tests zu sehen, die ich dort geschrieben habe. Hier ist mein Rat an Sie - tun Sie nicht so wie ich. Ich habe in Tests alles auf einem Haufen gemischt und bin nicht der „AAA“ -Vorlage gefolgt (google was es ist). Sie müssen dies nicht in der Produktion tun. Ein normaler Test sollte eine Sache überprüfen, nicht mehrere Bedingungen gleichzeitig, und sollte aus den folgenden Schritten bestehen:

1. Sie setzen Ihre Variablen;
2. Sie führen die Aktion aus, die Sie testen möchten.
3. Sie vergleichen das Ergebnis mit dem erwarteten.

Zum Beispiel

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