save

README.md

@@ -6,7 +6,7 @@ Easy UDP game server and client framework for creating simple 2D and 3D online g
 ### Cargo.toml
 ```toml
 [dependencies]
-victorem = "*"
+victorem = "0.8.0"
 ```
 ### Client 
 ```rust

src/business_logic_layer/id.rs

@@ -140,19 +140,18 @@ impl<T: IWithId> Arranger<T> {
     }
 
     pub fn get_lost(&self) -> (u32, u32) {
-        let max = self.last_received_packet_id;
-        let mut id: u32 = 0;
-        let mut j = 0;
-        let mut i = max;
-        while j < 32 && i > 0 {
-            i -= 1;
-            if !self.packets.contains_key(&i) {
-                let mask = 1u32 << j;
-                id |= mask;
+        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;
             }
-            j += 1;
+            x += 1;
         }
-        (id, max)
+        (sequence, self.last_received_packet_id)
     }
 
     fn get_valid(&mut self) -> Vec<T> {

src/business_logic_layer/mod.rs

@@ -170,9 +170,45 @@ mod bll_test {
 
         assert!({
             match r_packet2 {
-                Err(crate::entities::Exception::NotOrderedPacketError) =>true,
+                Err(crate::entities::Exception::NotOrderedPacketError) => true,
                 _ => false,
             }
         });
     }
+
+    #[test]
+    fn server_should_recv_ordered_and_reliable_packets() {
+        let mut client = Client::new();
+        let mut server = Server::new();
+        let command1 = client.send(vec![1]);
+        let command2 = client.send(vec![2]);
+        let command3 = client.send(vec![3]);
+        assert_eq!(3, command3.id);
+        let r1 = server.recv(command1);
+        let r3 = server.recv(command3);
+        assert!({
+            match r1 {
+                Err(_) => false,
+                Ok(v) => v.contains(&vec![1])
+            }
+        });
+        assert!({
+            match r3 {
+                Err(_) => false,
+                Ok(v) => v.is_empty(),
+            }
+        });
+        let state1 = server.send(vec![4]);
+        assert_eq!(3, state1.last_received);
+        assert_eq!(1, state1.sequence);
+        let (b, commands) = client.recv(state1).unwrap();
+
+        let r2 = server.recv(commands.first().unwrap().to_owned());
+        assert!({
+            match r2 {
+                Err(_) => false,
+                Ok(v) => v.len() == 2 && v.contains(&vec![2]) && v.contains(&vec![3]) && v[0] == vec![2]
+            }
+        });
+    }
 }

src/lib.rs

@@ -10,8 +10,6 @@ use std::collections::HashMap;
 use std::net::SocketAddr;
 use std::time::Duration;
 
-//TODO: Add Session ID for Client And Server!
-
 #[derive(Debug)]
 ///Events from server.
 pub enum ServerEvent {