i love rustmcproto

README.md

@@ -11,7 +11,7 @@ rust_mc_proto = { git = "https://github.com/MeexReay/rust_mc_proto" } # unstable
 ```
 
 Features:
-- `atomic_clone`
+- `atomic_clone` - clone MinecraftConnection like TcpStream. with compression and is_alive fields
 
 ## How to use
 
@@ -24,40 +24,21 @@ pub type MCConnTcp = MinecraftConnection<TcpStream>;
 Example of receiving motd:
 
 ```rust
-use rust_mc_proto::{Packet, ProtocolError, MCConnTcp, DataBufferReader, DataBufferWriter};
+use rust_mc_proto::{DataBufferReader, DataBufferWriter, MCConnTcp, Packet, ProtocolError};
+
+fn main() -> Result<(), ProtocolError> {
+    let mut conn = MCConnTcp::connect("mc.hypixel.net:25565")?; // connecting
 
-fn send_handshake(
-    conn: &mut MCConnTcp,
-    protocol_version: u16,
-    server_address: &str,
-    server_port: u16,
-    next_state: u8
-) -> Result<(), ProtocolError> {
     conn.write_packet(&Packet::build(0x00, |packet| {
-        packet.write_u16_varint(protocol_version)?;
+        packet.write_u16_varint(765)?; // protocol_version
-        packet.write_string(server_address)?;
+        packet.write_string("mc.hypixel.net")?; // server_address
-        packet.write_unsigned_short(server_port)?;
+        packet.write_unsigned_short(25565)?; // server_port
-        packet.write_u8_varint(next_state)
+        packet.write_u8_varint(1) // next_state
-    })?)
+    })?)?; // handshake packet
-}
 
-fn send_status_request(conn: &mut MCConnTcp) -> Result<(), ProtocolError> {
+    conn.write_packet(&Packet::empty(0x00))?; // status request packet
-    conn.write_packet(&Packet::empty(0x00))
-}
 
-fn read_status_response(conn: &mut MCConnTcp) -> Result<String, ProtocolError> {
+    Ok(println!("motd: {}", conn.read_packet()?.read_string()?)) // status response packet
-    conn.read_packet()?.read_string()
-}
-
-fn main() {
-    let mut conn = MCConnTcp::connect("mc.hypixel.net:25565").unwrap();
-
-    send_handshake(&mut conn, 765, "mc.hypixel.net", 25565, 1).unwrap();
-    send_status_request(&mut conn).unwrap();
-
-    let motd = read_status_response(&mut conn).unwrap();
-
-    dbg!(motd);
 }
 ```
 

examples/recv_motd_dirty.rs

@@ -0,0 +1,16 @@
+use rust_mc_proto::{DataBufferReader, DataBufferWriter, MCConnTcp, Packet, ProtocolError};
+
+fn main() -> Result<(), ProtocolError> {
+    let mut conn = MCConnTcp::connect("mc.hypixel.net:25565")?; // connecting
+
+    conn.write_packet(&Packet::build(0x00, |packet| {
+        packet.write_u16_varint(765)?; // protocol_version
+        packet.write_string("mc.hypixel.net")?; // server_address
+        packet.write_unsigned_short(25565)?; // server_port
+        packet.write_u8_varint(1) // next_state
+    })?)?; // handshake packet
+
+    conn.write_packet(&Packet::empty(0x00))?; // status request packet
+
+    Ok(println!("motd: {}", conn.read_packet()?.read_string()?)) // status response packet
+}

examples/status_server.rs

@@ -1,4 +1,4 @@
-use std::{net::TcpListener, sync::{Arc, Mutex}, thread};
+use std::{net::TcpListener, sync::Arc, thread};
 use rust_mc_proto::{DataBufferReader, DataBufferWriter, MCConnTcp, MinecraftConnection, Packet, ProtocolError};
 
 /*
@@ -8,6 +8,7 @@ use rust_mc_proto::{DataBufferReader, DataBufferWriter, MCConnTcp, MinecraftConn
 
 */
 
+#[derive(Clone)]
 struct MinecraftServer {
     server_ip: String,
     server_port: u16,
@@ -28,19 +29,23 @@ impl MinecraftServer {
     fn start(self) {
         let addr = self.server_ip.clone() + ":" + &self.server_port.to_string();
         let listener = TcpListener::bind(addr).unwrap();
-        let server = Arc::new(Mutex::new(self));
+
+        let this = Arc::new(self);
 
         for stream in listener.incoming() {
             let stream = stream.unwrap();
-            let local_server = server.clone();
 
-            thread::spawn(move || {
+            thread::spawn({
-                Self::accept_client(MinecraftConnection::new(stream), local_server).unwrap();
+                let this = this.clone();
+
+                move || {
+                    Self::accept_client(this, MinecraftConnection::new(stream)).unwrap();
+                }
             });
         }
     }
 
-    fn accept_client(mut conn: MCConnTcp, server: Arc<Mutex<MinecraftServer>>) -> Result<(), ProtocolError> {
+    fn accept_client(self: Arc<Self>, mut conn: MCConnTcp) -> Result<(), ProtocolError> {
         let mut handshake = false;
         
         loop {
@@ -48,7 +53,7 @@ impl MinecraftServer {
     
             if handshake {
                 if packet.id() == 0x00 {
-                    let motd = server.lock().unwrap().motd.clone();
+                    let motd = self.motd.clone();
 
                     conn.write_packet(&Packet::build(0x00, |status| 
                         status.write_string(&motd)
@@ -66,11 +71,13 @@ impl MinecraftServer {
     
                 if next_state != 1 { break; }
     
-                println!("Client handshake info:");
+                println!(
-                println!("  IP: {}", conn.get_ref().peer_addr().unwrap());
+                    "{} > protocol: {} server: {}:{}", 
-                println!("  Protocol version: {}", protocol_version);
+                    conn.get_ref().peer_addr().unwrap(), 
-                println!("  Server address: {}", server_address);
+                    protocol_version, 
-                println!("  Server port: {}", server_port);
+                    server_address, 
+                    server_port
+                );
     
                 handshake = true;
             } else {
@@ -111,5 +118,6 @@ fn main() {
             \"favicon\": \"data:image/png;base64,R0lGODlhAQABAIAAAP///wAAACwAAAAAAQABAAACAkQBADs=\"
         }"
     );
+
     server.start();
 }